* matrix-reorg.c (analyze_matrix_allocation_site): Remove unused

	malloc_fname variable.
	(check_allocation_function): Remove unused gsi and bb_level_0
	variables.
	(transform_access_sites): Remove unused d_type_size and d_type_size_k
	variables.
	* omega.c (resurrect_subs): Remove unused n variable.
	(omega_solve_geq): Remove unused neweqns variable.
	* lto-streamer-in.c (lto_read_tree): Remove unused end_marker variable.
	* tree-inline.c (declare_return_variable): Remove USE_P argument,
	return use instead of var.
	(remap_decl, remap_block): Remove unused fn variable.
	(expand_call_inline): Remove unused retvar variable, adjust
	declare_return_variable caller.
	(optimize_inline_calls): Remove unused prev_fn variable.
	* tree-vect-slp.c (vect_analyze_slp_instance): Remove unused ncopies
	variable.
	(vect_create_mask_and_perm): Remove unused group_size and dr_chain_size
	variables.
	* tree-ssa-loop-niter.c (split_to_var_and_offset): Handle MINUS_EXPR
	properly.
	* tree-vect-loop.c (vect_analyze_loop_form): Remove unused backedge
	variable.
	(vect_create_epilog_for_reduction): Remove unused bytesize variable.
	* omp-low.c (workshare_safe_to_combine_p): Remove par_entry_bb
	parameter.  Remove unused par_stmt variable.
	(determine_parallel_type): Adjust workshare_safe_to_combine_p caller.
	(expand_omp_sections): Remove unused l1 variable.
	(lower_omp_for): Remove unused ilist variable.
	* tree-loop-distribution.c (mark_nodes_having_upstream_mem_writes):
	Remove unused has_upstream_mem_write_p variable.
	* recog.c (decode_asm_operands): Remove unused noperands variable.
	* tree-ssa-alias.c (refs_may_alias_p_1): Remove unused size1 and
	size2 variable.
	* libgcov.c (__gcov_merge_delta): Remove unused last variable.
	* tree-call-cdce.c (gen_conditions_for_pow_int_base): Remove unused
	base_nm variable.
	(gen_conditions_for_pow): Remove unused ec variable.
	* tree-ssa-sccvn.c (vn_reference_lookup_3): Remove unused size
	variable.
	* ipa-struct-reorg.c (program_redefines_malloc_p): Remove unused
	fndecl variable.
	* tree-ssa-sink.c (statement_sink_location): Remove unused code
	variable.
	* regmove.c (copy_src_to_dest): Remove unused insn_uid and move_uid
	variables.
	* tree-complex.c (create_one_component_var): Remove unused inner_type
	variable.
	* calls.c (emit_call_1): Don't GEN_INT (struct_value_size)
	unnecessarily when GEN_*CALL omits that argument.
	* regrename.c (regrename_optimize): Remove unused regs_seen variable.
	(build_def_use): Remove unused icode variable.
	* ipa-pure-const.c (check_call): Remove unused callee and avail
	variables.
	* tree-dfa.c (add_referenced_var): Remove unused v_ann variable.
	* tree-vect-patterns.c (vect_recog_pow_pattern): Remove unused type
	variable.
	(vect_pattern_recog): Remove unused stmt variable.
	* sel-sched-ir.c (make_regions_from_the_rest): Remove unused
	new_regions variable.
	* postreload.c (reload_cse_simplify_operands): Remove unused mode
	variable.
	* tree-parloops.c (create_call_for_reduction_1): Remove unused
	addr_type variable.
	(create_parallel_loop): Remove unused res variable.
	(gen_parallel_loop): Remove unused nloop variable.
	* tree-vect-loop-manip.c (vect_loop_versioning): Likewise.
	* value-prof.c (gimple_mod_subtract_transform,
	gimple_stringops_transform): Remove unused value variable.
	(gimple_stringops_values_to_profile): Remove unused fcode variable.
	* tree-vrp.c (register_new_assert_for): Remove unused found variable.
	(vrp_visit_switch_stmt): Remove unused n variable.
	* tree-vect-stmts.c (vectorizable_conversion): Remove unused expr
	variable.
	(vectorizable_operation): Remove unused shift_p variable.
	(vectorizable_store): Remove unused first_stmt_vinfo variable.
	* tree-ssa-operands.c (add_stmt_operand): Remove unused v_ann variable.
	* tree-vect-data-refs.c (vect_analyze_data_refs): Remove unused bb
	variable.
	(vect_permute_store_chain): Remove unused scalar_dest variable.
	(vect_supportable_dr_alignment): Remove unused invariant_in_outerloop
	variable.
	* tree-ssa-threadupdate.c (thread_single_edge): Remove unused
	local_info variable.
	* tree-optimize.c (tree_rest_of_compilation): Remove unused node
	variable.
	* optabs.c (expand_binop): Remove unused equiv_value variable.
	(emit_libcall_block): Remove unused prev variable.
	(init_optabs): Remove unused int_mode variable.
	* tree-ssa-structalias.c (scc_visit): Remove unused have_ref_node
	variable.
	(do_structure_copy): Remove unused lhsbase and rhsbase variables.
	(find_func_aliases): Remove unused rhstype variable.
	(ipa_pta_execute): Remove unused varid variable.
gcc/objc/
	* objc-act.c (generate_shared_structures): Remove unused sc_spec and
	decl_specs variables.
	(objc_build_message_expr): Remove unused loc variable.
	(objc_finish_message_expr): Remove unused saved_rtype variable.
	(encode_field_decl): Remove unused type variable.
gcc/lto/
	* lto-lang.c (handle_nonnull_attribute): Remove unused attr_arg_num
	variable.


git-svn-id: https://gcc.gnu.org/svn/gcc/trunk@154726 138bc75d-0d04-0410-961f-82ee72b054a4

41 files changed, 174 insertions, 233 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index da9ad1a950f..14101e61c9f 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,100 @@
+2009-11-28  Jakub Jelinek  <jakub@redhat.com>
+
+	* matrix-reorg.c (analyze_matrix_allocation_site): Remove unused
+	malloc_fname variable.
+	(check_allocation_function): Remove unused gsi and bb_level_0
+	variables.
+	(transform_access_sites): Remove unused d_type_size and d_type_size_k
+	variables.
+	* omega.c (resurrect_subs): Remove unused n variable.
+	(omega_solve_geq): Remove unused neweqns variable.
+	* lto-streamer-in.c (lto_read_tree): Remove unused end_marker variable.
+	* tree-inline.c (declare_return_variable): Remove USE_P argument,
+	return use instead of var.
+	(remap_decl, remap_block): Remove unused fn variable.
+	(expand_call_inline): Remove unused retvar variable, adjust
+	declare_return_variable caller.
+	(optimize_inline_calls): Remove unused prev_fn variable.
+	* tree-vect-slp.c (vect_analyze_slp_instance): Remove unused ncopies
+	variable.
+	(vect_create_mask_and_perm): Remove unused group_size and dr_chain_size
+	variables.
+	* tree-ssa-loop-niter.c (split_to_var_and_offset): Handle MINUS_EXPR
+	properly.
+	* tree-vect-loop.c (vect_analyze_loop_form): Remove unused backedge
+	variable.
+	(vect_create_epilog_for_reduction): Remove unused bytesize variable.
+	* omp-low.c (workshare_safe_to_combine_p): Remove par_entry_bb
+	parameter.  Remove unused par_stmt variable.
+	(determine_parallel_type): Adjust workshare_safe_to_combine_p caller.
+	(expand_omp_sections): Remove unused l1 variable.
+	(lower_omp_for): Remove unused ilist variable.
+	* tree-loop-distribution.c (mark_nodes_having_upstream_mem_writes):
+	Remove unused has_upstream_mem_write_p variable.
+	* recog.c (decode_asm_operands): Remove unused noperands variable.
+	* tree-ssa-alias.c (refs_may_alias_p_1): Remove unused size1 and
+	size2 variable.
+	* libgcov.c (__gcov_merge_delta): Remove unused last variable.
+	* tree-call-cdce.c (gen_conditions_for_pow_int_base): Remove unused
+	base_nm variable.
+	(gen_conditions_for_pow): Remove unused ec variable.
+	* tree-ssa-sccvn.c (vn_reference_lookup_3): Remove unused size
+	variable.
+	* ipa-struct-reorg.c (program_redefines_malloc_p): Remove unused
+	fndecl variable.
+	* tree-ssa-sink.c (statement_sink_location): Remove unused code
+	variable.
+	* regmove.c (copy_src_to_dest): Remove unused insn_uid and move_uid
+	variables.
+	* tree-complex.c (create_one_component_var): Remove unused inner_type
+	variable.
+	* calls.c (emit_call_1): Don't GEN_INT (struct_value_size)
+	unnecessarily when GEN_*CALL omits that argument.
+	* regrename.c (regrename_optimize): Remove unused regs_seen variable.
+	(build_def_use): Remove unused icode variable.
+	* ipa-pure-const.c (check_call): Remove unused callee and avail
+	variables.
+	* tree-dfa.c (add_referenced_var): Remove unused v_ann variable.
+	* tree-vect-patterns.c (vect_recog_pow_pattern): Remove unused type
+	variable.
+	(vect_pattern_recog): Remove unused stmt variable.
+	* sel-sched-ir.c (make_regions_from_the_rest): Remove unused
+	new_regions variable.
+	* postreload.c (reload_cse_simplify_operands): Remove unused mode
+	variable.
+	* tree-parloops.c (create_call_for_reduction_1): Remove unused
+	addr_type variable.
+	(create_parallel_loop): Remove unused res variable.
+	(gen_parallel_loop): Remove unused nloop variable.
+	* tree-vect-loop-manip.c (vect_loop_versioning): Likewise.
+	* value-prof.c (gimple_mod_subtract_transform,
+	gimple_stringops_transform): Remove unused value variable.
+	(gimple_stringops_values_to_profile): Remove unused fcode variable.
+	* tree-vrp.c (register_new_assert_for): Remove unused found variable.
+	(vrp_visit_switch_stmt): Remove unused n variable.
+	* tree-vect-stmts.c (vectorizable_conversion): Remove unused expr
+	variable.
+	(vectorizable_operation): Remove unused shift_p variable.
+	(vectorizable_store): Remove unused first_stmt_vinfo variable.
+	* tree-ssa-operands.c (add_stmt_operand): Remove unused v_ann variable.
+	* tree-vect-data-refs.c (vect_analyze_data_refs): Remove unused bb
+	variable.
+	(vect_permute_store_chain): Remove unused scalar_dest variable.
+	(vect_supportable_dr_alignment): Remove unused invariant_in_outerloop
+	variable.
+	* tree-ssa-threadupdate.c (thread_single_edge): Remove unused
+	local_info variable.
+	* tree-optimize.c (tree_rest_of_compilation): Remove unused node
+	variable.
+	* optabs.c (expand_binop): Remove unused equiv_value variable.
+	(emit_libcall_block): Remove unused prev variable.
+	(init_optabs): Remove unused int_mode variable.
+	* tree-ssa-structalias.c (scc_visit): Remove unused have_ref_node
+	variable.
+	(do_structure_copy): Remove unused lhsbase and rhsbase variables.
+	(find_func_aliases): Remove unused rhstype variable.
+	(ipa_pta_execute): Remove unused varid variable.
+
 2009-11-28  Andy Hutchinson  <hutchinsonandy@gcc.gnu.org>
 
 	* config/avr/avr.h (ASM_OUTPUT_EXTERNAL): Add. 
diff --git a/gcc/calls.c b/gcc/calls.c
index 34fde8b5280..fe4bf0dbce5 100644
--- a/gcc/calls.c
+++ b/gcc/calls.c
@@ -256,10 +256,6 @@ emit_call_1 (rtx funexp, tree fntree ATTRIBUTE_UNUSED, tree fndecl ATTRIBUTE_UNU
   rtx call_insn;
   int already_popped = 0;
   HOST_WIDE_INT n_popped = RETURN_POPS_ARGS (fndecl, funtype, stack_size);
-#if defined (HAVE_call) && defined (HAVE_call_value)
-  rtx struct_value_size_rtx;
-  struct_value_size_rtx = GEN_INT (struct_value_size);
-#endif
 
 #ifdef CALL_POPS_ARGS
   n_popped += CALL_POPS_ARGS (* args_so_far);
@@ -341,7 +337,7 @@ emit_call_1 (rtx funexp, tree fntree ATTRIBUTE_UNUSED, tree fndecl ATTRIBUTE_UNU
       else
 	emit_call_insn (GEN_SIBCALL (gen_rtx_MEM (FUNCTION_MODE, funexp),
 				     rounded_stack_size_rtx, next_arg_reg,
-				     struct_value_size_rtx));
+				     GEN_INT (struct_value_size)));
     }
   else
 #endif
@@ -357,7 +353,7 @@ emit_call_1 (rtx funexp, tree fntree ATTRIBUTE_UNUSED, tree fndecl ATTRIBUTE_UNU
       else
 	emit_call_insn (GEN_CALL (gen_rtx_MEM (FUNCTION_MODE, funexp),
 				  rounded_stack_size_rtx, next_arg_reg,
-				  struct_value_size_rtx));
+				  GEN_INT (struct_value_size)));
     }
   else
 #endif
diff --git a/gcc/ipa-pure-const.c b/gcc/ipa-pure-const.c
index 9efcb8d0524..7ee9f5dcf37 100644
--- a/gcc/ipa-pure-const.c
+++ b/gcc/ipa-pure-const.c
@@ -259,8 +259,6 @@ check_call (funct_state local, gimple call, bool ipa)
 {
   int flags = gimple_call_flags (call);
   tree callee_t = gimple_call_fndecl (call);
-  struct cgraph_node* callee;
-  enum availability avail = AVAIL_NOT_AVAILABLE;
   bool possibly_throws = stmt_could_throw_p (call);
   bool possibly_throws_externally = (possibly_throws
   				     && stmt_can_throw_external (call));
@@ -299,9 +297,6 @@ check_call (funct_state local, gimple call, bool ipa)
      graph.  */
   if (callee_t)
     {
-      callee = cgraph_node(callee_t);
-      avail = cgraph_function_body_availability (callee);
-
       /* When bad things happen to bad functions, they cannot be const
 	 or pure.  */
       if (setjmp_call_p (callee_t))
diff --git a/gcc/ipa-struct-reorg.c b/gcc/ipa-struct-reorg.c
index 43ed0a53c94..0cb7ccca31b 100644
--- a/gcc/ipa-struct-reorg.c
+++ b/gcc/ipa-struct-reorg.c
@@ -3435,13 +3435,10 @@ program_redefines_malloc_p (void)
   struct cgraph_node *c_node;
   struct cgraph_node *c_node2;
   struct cgraph_edge *c_edge;
-  tree fndecl;
   tree fndecl2;
 
   for (c_node = cgraph_nodes; c_node; c_node = c_node->next)
     {
-      fndecl = c_node->decl;
-
       for (c_edge = c_node->callees; c_edge; c_edge = c_edge->next_callee)
 	{
 	  c_node2 = c_edge->callee;
diff --git a/gcc/libgcov.c b/gcc/libgcov.c
index 4076409e11c..af3d9cfba63 100644
--- a/gcc/libgcov.c
+++ b/gcc/libgcov.c
@@ -675,13 +675,13 @@ void
 __gcov_merge_delta (gcov_type *counters, unsigned n_counters)
 {
   unsigned i, n_measures;
-  gcov_type last, value, counter, all;
+  gcov_type value, counter, all;
 
   gcc_assert (!(n_counters % 4));
   n_measures = n_counters / 4;
   for (i = 0; i < n_measures; i++, counters += 4)
     {
-      last = gcov_read_counter ();
+      /* last = */ gcov_read_counter ();
       value = gcov_read_counter ();
       counter = gcov_read_counter ();
       all = gcov_read_counter ();
diff --git a/gcc/lto-streamer-in.c b/gcc/lto-streamer-in.c
index 9559869b5ba..16ae9b83ee0 100644
--- a/gcc/lto-streamer-in.c
+++ b/gcc/lto-streamer-in.c
@@ -2597,7 +2597,6 @@ lto_read_tree (struct lto_input_block *ib, struct data_in *data_in,
 	       enum LTO_tags tag)
 {
   tree result;
-  char end_marker;
   int ix;
 
   result = lto_materialize_tree (ib, data_in, tag, &ix);
@@ -2614,7 +2613,7 @@ lto_read_tree (struct lto_input_block *ib, struct data_in *data_in,
   else if (TREE_CODE (result) == FUNCTION_DECL && !DECL_BUILT_IN (result))
     lto_register_function_decl_in_symtab (data_in, result);
 
-  end_marker = lto_input_1_unsigned (ib);
+  /* end_marker = */ lto_input_1_unsigned (ib);
 
 #ifdef LTO_STREAMER_DEBUG
   /* Remove the mapping to RESULT's original address set by
diff --git a/gcc/lto/ChangeLog b/gcc/lto/ChangeLog
index 6792d183a51..7e0a0d46353 100644
--- a/gcc/lto/ChangeLog
+++ b/gcc/lto/ChangeLog
@@ -1,3 +1,8 @@
+2009-11-28  Jakub Jelinek  <jakub@redhat.com>
+
+	* lto-lang.c (handle_nonnull_attribute): Remove unused attr_arg_num
+	variable.
+
 2009-11-19  Rafael Avila de Espindola  <espindola@google.com>
 
 	PR bootstrap/42096
diff --git a/gcc/lto/lto-lang.c b/gcc/lto/lto-lang.c
index 486338f6b66..0caa3182dda 100644
--- a/gcc/lto/lto-lang.c
+++ b/gcc/lto/lto-lang.c
@@ -285,7 +285,6 @@ handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
 			  bool * ARG_UNUSED (no_add_attrs))
 {
   tree type = *node;
-  unsigned HOST_WIDE_INT attr_arg_num;
 
   /* If no arguments are specified, all pointer arguments should be
      non-null.  Verify a full prototype is given so that the arguments
@@ -298,7 +297,7 @@ handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
 
   /* Argument list specified.  Verify that each argument number references
      a pointer argument.  */
-  for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
+  for (; args; args = TREE_CHAIN (args))
     {
       tree argument;
       unsigned HOST_WIDE_INT arg_num = 0, ck_num;
diff --git a/gcc/matrix-reorg.c b/gcc/matrix-reorg.c
index 71c7419a8f5..90e21e57e72 100644
--- a/gcc/matrix-reorg.c
+++ b/gcc/matrix-reorg.c
@@ -821,7 +821,6 @@ analyze_matrix_allocation_site (struct matrix_info *mi, gimple stmt,
       else
 	{
 	  tree malloc_fn_decl;
-	  const char *malloc_fname;
 
 	  malloc_fn_decl = gimple_call_fndecl (stmt);
 	  if (malloc_fn_decl == NULL_TREE)
@@ -829,7 +828,6 @@ analyze_matrix_allocation_site (struct matrix_info *mi, gimple stmt,
 	      mark_min_matrix_escape_level (mi, level, stmt);
 	      return;
 	    }
-	  malloc_fname = IDENTIFIER_POINTER (DECL_NAME (malloc_fn_decl));
 	  if (DECL_FUNCTION_CODE (malloc_fn_decl) != BUILT_IN_MALLOC)
 	    {
 	      if (dump_file)
@@ -1572,8 +1570,6 @@ static int
 check_allocation_function (void **slot, void *data ATTRIBUTE_UNUSED)
 {
   int level;
-  gimple_stmt_iterator gsi;
-  basic_block bb_level_0;
   struct matrix_info *mi = (struct matrix_info *) *slot;
   sbitmap visited;
 
@@ -1595,9 +1591,6 @@ check_allocation_function (void **slot, void *data ATTRIBUTE_UNUSED)
 
   mark_min_matrix_escape_level (mi, level, NULL);
 
-  gsi = gsi_for_stmt (mi->malloc_for_level[0]);
-  bb_level_0 = gsi.bb;
-
   /* Check if the expression of the size passed to malloc could be
      pre-calculated before the malloc of level 0.  */
   for (level = 1; level < mi->min_indirect_level_escape; level++)
@@ -1918,10 +1911,6 @@ transform_access_sites (void **slot, void *data ATTRIBUTE_UNUSED)
 	      else
 		{
 		  tree new_offset;
-		  tree d_type_size, d_type_size_k;
-
-		  d_type_size = size_int (mi->dimension_type_size[min_escape_l]);
-		  d_type_size_k = size_int (mi->dimension_type_size[k + 1]);
 
 		  new_offset =
 		    compute_offset (mi->dimension_type_size[min_escape_l],
diff --git a/gcc/objc/ChangeLog b/gcc/objc/ChangeLog
index 65d0282ac00..d6e2b1f5432 100644
--- a/gcc/objc/ChangeLog
+++ b/gcc/objc/ChangeLog
@@ -1,5 +1,11 @@
 2009-11-28  Jakub Jelinek  <jakub@redhat.com>
 
+	* objc-act.c (generate_shared_structures): Remove unused sc_spec and
+	decl_specs variables.
+	(objc_build_message_expr): Remove unused loc variable.
+	(objc_finish_message_expr): Remove unused saved_rtype variable.
+	(encode_field_decl): Remove unused type variable.
+
 	PR obj-c++/42156
 	* objc-act.c (objc_build_struct): INIT_TYPE_OBJC_INFO for
 	type variants that don't have it initialized yet.
diff --git a/gcc/objc/objc-act.c b/gcc/objc/objc-act.c
index e720dab39ff..e39462dcc23 100644
--- a/gcc/objc/objc-act.c
+++ b/gcc/objc/objc-act.c
@@ -5787,7 +5787,7 @@ generate_category (tree cat)
 static void
 generate_shared_structures (int cls_flags)
 {
-  tree sc_spec, decl_specs, decl;
+  tree decl;
   tree name_expr, super_expr, root_expr;
   tree my_root_id = NULL_TREE, my_super_id = NULL_TREE;
   tree cast_type, initlist, protocol_decl;
@@ -5844,9 +5844,6 @@ generate_shared_structures (int cls_flags)
 
   /* static struct objc_class _OBJC_METACLASS_Foo = { ... }; */
 
-  sc_spec = build_tree_list (NULL_TREE, ridpointers[(int) RID_STATIC]);
-  decl_specs = tree_cons (NULL_TREE, objc_class_template, sc_spec);
-
   decl = start_var_decl (objc_class_template,
 			 IDENTIFIER_POINTER
 			 (DECL_NAME (UOBJC_METACLASS_decl)));
@@ -6269,7 +6266,6 @@ tree
 objc_build_message_expr (tree mess)
 {
   tree receiver = TREE_PURPOSE (mess);
-  location_t loc;
   tree sel_name;
 #ifdef OBJCPLUS
   tree args = TREE_PURPOSE (TREE_VALUE (mess));
@@ -6281,11 +6277,6 @@ objc_build_message_expr (tree mess)
   if (TREE_CODE (receiver) == ERROR_MARK || TREE_CODE (args) == ERROR_MARK)
     return error_mark_node;
 
-  if (CAN_HAVE_LOCATION_P (receiver))
-    loc = EXPR_LOCATION (receiver);
-  else
-    loc = input_location;
-
   /* Obtain the full selector name.  */
   if (TREE_CODE (args) == IDENTIFIER_NODE)
     /* A unary selector.  */
@@ -6448,7 +6439,7 @@ objc_finish_message_expr (tree receiver, tree sel_name, tree method_params)
     }
   else if (rtype)
     {
-      tree orig_rtype = rtype, saved_rtype;
+      tree orig_rtype = rtype;
 
       if (TREE_CODE (rtype) == POINTER_TYPE)
 	rtype = TREE_TYPE (rtype);
@@ -6457,7 +6448,6 @@ objc_finish_message_expr (tree receiver, tree sel_name, tree method_params)
 	     && TREE_CODE (OBJC_TYPE_NAME (rtype)) == TYPE_DECL
 	     && DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (rtype)))
 	rtype = DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (rtype));
-      saved_rtype = rtype;
       if (TYPED_OBJECT (rtype))
 	{
 	  rprotos = TYPE_OBJC_PROTOCOL_LIST (rtype);
@@ -8311,8 +8301,6 @@ encode_gnu_bitfield (int position, tree type, int size)
 static void
 encode_field_decl (tree field_decl, int curtype, int format)
 {
-  tree type;
-
 #ifdef OBJCPLUS
   /* C++ static members, and things that are not fields at all,
      should not appear in the encoding.  */
@@ -8320,8 +8308,6 @@ encode_field_decl (tree field_decl, int curtype, int format)
     return;
 #endif
 
-  type = TREE_TYPE (field_decl);
-
   /* Generate the bitfield typing information, if needed.  Note the difference
      between GNU and NeXT runtimes.  */
   if (DECL_BIT_FIELD_TYPE (field_decl))
diff --git a/gcc/omega.c b/gcc/omega.c
index ff7da4e1609..666d4bd616d 100644
--- a/gcc/omega.c
+++ b/gcc/omega.c
@@ -1978,7 +1978,7 @@ resurrect_subs (omega_pb pb)
   if (pb->num_subs > 0
       && please_no_equalities_in_simplified_problems == 0)
     {
-      int i, e, n, m;
+      int i, e, m;
 
       if (dump_file && (dump_flags & TDF_DETAILS))
 	{
@@ -1992,7 +1992,6 @@ resurrect_subs (omega_pb pb)
 	  omega_unprotect_1 (pb, &i, NULL);
 
       m = pb->num_subs;
-      n = MAX (pb->num_vars, pb->safe_vars + m);
 
       for (e = pb->num_geqs - 1; e >= 0; e--)
 	if (single_var_geq (&pb->geqs[e], pb->num_vars))
@@ -3723,7 +3722,6 @@ omega_solve_geq (omega_pb pb, enum omega_result desired_res)
       int max_splinters = 1;
       bool exact = false;
       bool lucky_exact = false;
-      int neweqns = 0;
       int best = (INT_MAX);
       int j = 0, jLe = 0, jLowerBoundCount = 0;
 
@@ -3862,7 +3860,7 @@ omega_solve_geq (omega_pb pb, enum omega_result desired_res)
 	      || lucky
 	      || in_approximate_mode)
 	    {
-	      neweqns = score = upper_bound_count * lower_bound_count;
+	      score = upper_bound_count * lower_bound_count;
 
 	      if (dump_file && (dump_flags & TDF_DETAILS))
 		fprintf (dump_file,
@@ -3898,7 +3896,6 @@ omega_solve_geq (omega_pb pb, enum omega_result desired_res)
 			 upper_bound_count,
 			 lower_bound_count, minC, maxC);
 
-	      neweqns = upper_bound_count * lower_bound_count;
 	      score = maxC - minC;
 
 	      if (best > score)
diff --git a/gcc/omp-low.c b/gcc/omp-low.c
index ba4d76495c3..02fea106b07 100644
--- a/gcc/omp-low.c
+++ b/gcc/omp-low.c
@@ -518,13 +518,10 @@ extract_omp_for_data (gimple for_stmt, struct omp_for_data *fd,
    hack something up here, it is really not worth the aggravation.  */
 
 static bool
-workshare_safe_to_combine_p (basic_block par_entry_bb, basic_block ws_entry_bb)
+workshare_safe_to_combine_p (basic_block ws_entry_bb)
 {
   struct omp_for_data fd;
-  gimple par_stmt, ws_stmt;
-
-  par_stmt = last_stmt (par_entry_bb);
-  ws_stmt = last_stmt (ws_entry_bb);
+  gimple ws_stmt = last_stmt (ws_entry_bb);
 
   if (gimple_code (ws_stmt) == GIMPLE_OMP_SECTIONS)
     return true;
@@ -631,7 +628,7 @@ determine_parallel_type (struct omp_region *region)
 
   if (single_succ (par_entry_bb) == ws_entry_bb
       && single_succ (ws_exit_bb) == par_exit_bb
-      && workshare_safe_to_combine_p (par_entry_bb, ws_entry_bb)
+      && workshare_safe_to_combine_p (ws_entry_bb)
       && (gimple_omp_parallel_combined_p (last_stmt (par_entry_bb))
 	  || (last_and_only_stmt (ws_entry_bb)
 	      && last_and_only_stmt (par_exit_bb))))
@@ -4647,7 +4644,7 @@ expand_omp_for (struct omp_region *region)
 static void
 expand_omp_sections (struct omp_region *region)
 {
-  tree t, u, vin = NULL, vmain, vnext, l1, l2;
+  tree t, u, vin = NULL, vmain, vnext, l2;
   VEC (tree,heap) *label_vec;
   unsigned len;
   basic_block entry_bb, l0_bb, l1_bb, l2_bb, default_bb;
@@ -4692,12 +4689,10 @@ expand_omp_sections (struct omp_region *region)
 	      }
 	}
       default_bb = create_empty_bb (l1_bb->prev_bb);
-      l1 = gimple_block_label (l1_bb);
     }
   else
     {
       default_bb = create_empty_bb (l0_bb);
-      l1 = NULL_TREE;
       l2 = gimple_block_label (default_bb);
     }
 
@@ -6023,7 +6018,7 @@ lower_omp_for (gimple_stmt_iterator *gsi_p, omp_context *ctx)
   tree *rhs_p, block;
   struct omp_for_data fd;
   gimple stmt = gsi_stmt (*gsi_p), new_stmt;
-  gimple_seq omp_for_body, body, dlist, ilist;
+  gimple_seq omp_for_body, body, dlist;
   size_t i;
   struct gimplify_ctx gctx;
 
@@ -6046,7 +6041,6 @@ lower_omp_for (gimple_stmt_iterator *gsi_p, omp_context *ctx)
     }
 
   /* The pre-body and input clauses go before the lowered GIMPLE_OMP_FOR.  */
-  ilist = NULL;
   dlist = NULL;
   body = NULL;
   lower_rec_input_clauses (gimple_omp_for_clauses (stmt), &body, &dlist, ctx);
diff --git a/gcc/optabs.c b/gcc/optabs.c
index 9e659dc3869..87067d82e73 100644
--- a/gcc/optabs.c
+++ b/gcc/optabs.c
@@ -1719,7 +1719,6 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1,
     {
       int i;
       rtx insns;
-      rtx equiv_value;
 
       /* If TARGET is the same as one of the operands, the REG_EQUAL note
 	 won't be accurate, so use a new target.  */
@@ -1749,13 +1748,6 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1,
 
       if (i == GET_MODE_BITSIZE (mode) / BITS_PER_WORD)
 	{
-	  if (binoptab->code != UNKNOWN)
-	    equiv_value
-	      = gen_rtx_fmt_ee (binoptab->code, mode,
-				copy_rtx (op0), copy_rtx (op1));
-	  else
-	    equiv_value = 0;
-
 	  emit_insn (insns);
 	  return target;
 	}
@@ -3903,7 +3895,7 @@ void
 emit_libcall_block (rtx insns, rtx target, rtx result, rtx equiv)
 {
   rtx final_dest = target;
-  rtx prev, next, last, insn;
+  rtx next, last, insn;
 
   /* If this is a reg with REG_USERVAR_P set, then it could possibly turn
      into a MEM later.  Protect the libcall block from this change.  */
@@ -3980,10 +3972,7 @@ emit_libcall_block (rtx insns, rtx target, rtx result, rtx equiv)
 	break;
     }
 
-  prev = get_last_insn ();
-
   /* Write the remaining insns followed by the final copy.  */
-
   for (insn = insns; insn; insn = next)
     {
       next = NEXT_INSN (insn);
@@ -6201,7 +6190,6 @@ void
 init_optabs (void)
 {
   unsigned int i;
-  enum machine_mode int_mode;
   static bool reinit;
 
   libfunc_hash = htab_create_ggc (10, hash_libfunc, eq_libfunc, NULL);
@@ -6657,11 +6645,8 @@ init_optabs (void)
   /* The ffs function operates on `int'.  Fall back on it if we do not
      have a libgcc2 function for that width.  */
   if (INT_TYPE_SIZE < BITS_PER_WORD)
-    {
-      int_mode = mode_for_size (INT_TYPE_SIZE, MODE_INT, 0);
-      set_optab_libfunc (ffs_optab, mode_for_size (INT_TYPE_SIZE, MODE_INT, 0),
-			 "ffs");
-    }
+    set_optab_libfunc (ffs_optab, mode_for_size (INT_TYPE_SIZE, MODE_INT, 0),
+		       "ffs");
 
   /* Explicitly initialize the bswap libfuncs since we need them to be
      valid for things other than word_mode.  */
diff --git a/gcc/postreload.c b/gcc/postreload.c
index eaedee13a74..f8785821f63 100644
--- a/gcc/postreload.c
+++ b/gcc/postreload.c
@@ -407,7 +407,6 @@ reload_cse_simplify_operands (rtx insn, rtx testreg)
       cselib_val *v;
       struct elt_loc_list *l;
       rtx op;
-      enum machine_mode mode;
 
       CLEAR_HARD_REG_SET (equiv_regs[i]);
 
@@ -420,11 +419,10 @@ reload_cse_simplify_operands (rtx insn, rtx testreg)
 	continue;
 
       op = recog_data.operand[i];
-      mode = GET_MODE (op);
 #ifdef LOAD_EXTEND_OP
       if (MEM_P (op)
-	  && GET_MODE_BITSIZE (mode) < BITS_PER_WORD
-	  && LOAD_EXTEND_OP (mode) != UNKNOWN)
+	  && GET_MODE_BITSIZE (GET_MODE (op)) < BITS_PER_WORD
+	  && LOAD_EXTEND_OP (GET_MODE (op)) != UNKNOWN)
 	{
 	  rtx set = single_set (insn);
 
@@ -457,7 +455,7 @@ reload_cse_simplify_operands (rtx insn, rtx testreg)
 		   && SET_DEST (set) == recog_data.operand[1-i])
 	    {
 	      validate_change (insn, recog_data.operand_loc[i],
-			       gen_rtx_fmt_e (LOAD_EXTEND_OP (mode),
+			       gen_rtx_fmt_e (LOAD_EXTEND_OP (GET_MODE (op)),
 					      word_mode, op),
 			       1);
 	      validate_change (insn, recog_data.operand_loc[1-i],
diff --git a/gcc/recog.c b/gcc/recog.c
index 5a6490edf97..810270625a2 100644
--- a/gcc/recog.c
+++ b/gcc/recog.c
@@ -1496,7 +1496,7 @@ decode_asm_operands (rtx body, rtx *operands, rtx **operand_locs,
 		     const char **constraints, enum machine_mode *modes,
 		     location_t *loc)
 {
-  int noperands, nbase = 0, n, i;
+  int nbase = 0, n, i;
   rtx asmop;
 
   switch (GET_CODE (body))
@@ -1556,9 +1556,6 @@ decode_asm_operands (rtx body, rtx *operands, rtx **operand_locs,
       gcc_unreachable ();
     }
 
-  noperands = (ASM_OPERANDS_INPUT_LENGTH (asmop)
-	       + ASM_OPERANDS_LABEL_LENGTH (asmop) + nbase);
-
   n = ASM_OPERANDS_INPUT_LENGTH (asmop);
   for (i = 0; i < n; i++)
     {
diff --git a/gcc/regmove.c b/gcc/regmove.c
index 18afc5b6dcd..25fcc52b213 100644
--- a/gcc/regmove.c
+++ b/gcc/regmove.c
@@ -605,8 +605,6 @@ copy_src_to_dest (rtx insn, rtx src, rtx dest)
   rtx *p_move_notes;
   int src_regno;
   int dest_regno;
-  int insn_uid;
-  int move_uid;
 
   /* A REG_LIVE_LENGTH of -1 indicates the register is equivalent to a constant
      or memory location and is used infrequently; a REG_LIVE_LENGTH of -2 is
@@ -662,9 +660,6 @@ copy_src_to_dest (rtx insn, rtx src, rtx dest)
       *p_move_notes = NULL_RTX;
       *p_insn_notes = NULL_RTX;
 
-      insn_uid = INSN_UID (insn);
-      move_uid = INSN_UID (move_insn);
-
       /* Update the various register tables.  */
       dest_regno = REGNO (dest);
       INC_REG_N_SETS (dest_regno, 1);
diff --git a/gcc/regrename.c b/gcc/regrename.c
index a29ffe349ee..e0e89709513 100644
--- a/gcc/regrename.c
+++ b/gcc/regrename.c
@@ -175,7 +175,10 @@ regrename_optimize (void)
     {
       struct du_head *all_chains = 0;
       HARD_REG_SET unavailable;
+#if 0
       HARD_REG_SET regs_seen;
+      CLEAR_HARD_REG_SET (regs_seen);
+#endif
 
       id_to_chain = VEC_alloc (du_head_p, heap, 0);
 
@@ -199,7 +202,6 @@ regrename_optimize (void)
 #endif
 	}
 
-      CLEAR_HARD_REG_SET (regs_seen);
       while (all_chains)
 	{
 	  int new_reg, best_new_reg, best_nregs;
@@ -978,7 +980,7 @@ build_def_use (basic_block bb)
 	  rtx note;
 	  rtx old_operands[MAX_RECOG_OPERANDS];
 	  rtx old_dups[MAX_DUP_OPERANDS];
-	  int i, icode;
+	  int i;
 	  int alt;
 	  int predicated;
 	  enum rtx_code set_code = SET;
@@ -1007,7 +1009,6 @@ build_def_use (basic_block bb)
 	     to be marked unrenamable or even cause us to abort the entire
 	     basic block.  */
 
-	  icode = recog_memoized (insn);
 	  extract_insn (insn);
 	  if (! constrain_operands (1))
 	    fatal_insn_not_found (insn);
diff --git a/gcc/sel-sched-ir.c b/gcc/sel-sched-ir.c
index 3484d861c4b..e864eb40c7a 100644
--- a/gcc/sel-sched-ir.c
+++ b/gcc/sel-sched-ir.c
@@ -5843,11 +5843,9 @@ make_regions_from_the_rest (void)
   edge e;
   edge_iterator ei;
   int *degree;
-  int new_regions;
 
   /* Index in rgn_bb_table where to start allocating new regions.  */
   cur_rgn_blocks = nr_regions ? RGN_BLOCKS (nr_regions) : 0;
-  new_regions = nr_regions;
 
   /* Make regions from all the rest basic blocks - those that don't belong to
      any loop or belong to irreducible loops.  Prepare the data structures
diff --git a/gcc/tree-call-cdce.c b/gcc/tree-call-cdce.c
index 8b1ece89f56..9a27adc94e3 100644
--- a/gcc/tree-call-cdce.c
+++ b/gcc/tree-call-cdce.c
@@ -457,7 +457,7 @@ gen_conditions_for_pow_int_base (tree base, tree expn,
                                  unsigned *nconds)
 {
   gimple base_def;
-  tree base_nm, base_val0;
+  tree base_val0;
   tree base_var, int_type;
   tree temp, tempn;
   tree cst0;
@@ -466,7 +466,6 @@ gen_conditions_for_pow_int_base (tree base, tree expn,
   inp_domain exp_domain;
 
   base_def = SSA_NAME_DEF_STMT (base);
-  base_nm = gimple_assign_lhs (base_def);
   base_val0 = gimple_assign_rhs1 (base_def);
   base_var = SSA_NAME_VAR (base_val0);
   int_type = TREE_TYPE (base_var);
@@ -483,10 +482,10 @@ gen_conditions_for_pow_int_base (tree base, tree expn,
   else if (bit_sz == 16)
     max_exp = 64;
   else
-  {
-    gcc_assert (bit_sz == MAX_BASE_INT_BIT_SIZE);
-    max_exp = 32;
-  }
+    {
+      gcc_assert (bit_sz == MAX_BASE_INT_BIT_SIZE);
+      max_exp = 32;
+    }
 
   /* For pow ((double)x, y), generate the following conditions:
      cond 1:
@@ -548,7 +547,7 @@ gen_conditions_for_pow (gimple pow_call, VEC (gimple, heap) *conds,
                         unsigned *nconds)
 {
   tree base, expn;
-  enum tree_code bc, ec;
+  enum tree_code bc;
 
 #ifdef ENABLE_CHECKING
   gcc_assert (check_pow (pow_call));
@@ -560,12 +559,11 @@ gen_conditions_for_pow (gimple pow_call, VEC (gimple, heap) *conds,
   expn = gimple_call_arg (pow_call, 1);
 
   bc = TREE_CODE (base);
-  ec = TREE_CODE (expn);
 
   if (bc == REAL_CST)
-      gen_conditions_for_pow_cst_base (base, expn, conds, nconds);
+    gen_conditions_for_pow_cst_base (base, expn, conds, nconds);
   else if (bc == SSA_NAME)
-      gen_conditions_for_pow_int_base (base, expn, conds, nconds);
+    gen_conditions_for_pow_int_base (base, expn, conds, nconds);
   else
     gcc_unreachable ();
 }
diff --git a/gcc/tree-complex.c b/gcc/tree-complex.c
index 8f246fa080c..53bf1185495 100644
--- a/gcc/tree-complex.c
+++ b/gcc/tree-complex.c
@@ -434,11 +434,9 @@ create_one_component_var (tree type, tree orig, const char *prefix,
   if (DECL_NAME (orig) && !DECL_IGNORED_P (orig))
     {
       const char *name = IDENTIFIER_POINTER (DECL_NAME (orig));
-      tree inner_type;
 
       DECL_NAME (r) = get_identifier (ACONCAT ((name, suffix, NULL)));
 
-      inner_type = TREE_TYPE (TREE_TYPE (orig));
       SET_DECL_DEBUG_EXPR (r, build1 (code, type, orig));
       DECL_DEBUG_EXPR_IS_FROM (r) = 1;
       DECL_IGNORED_P (r) = 0;
diff --git a/gcc/tree-dfa.c b/gcc/tree-dfa.c
index 69535f1dc60..a918f4ba2bd 100644
--- a/gcc/tree-dfa.c
+++ b/gcc/tree-dfa.c
@@ -598,9 +598,7 @@ set_default_def (tree var, tree def)
 bool
 add_referenced_var (tree var)
 {
-  var_ann_t v_ann;
-
-  v_ann = get_var_ann (var);
+  get_var_ann (var);
   gcc_assert (DECL_P (var));
 
   /* Insert VAR into the referenced_vars has table if it isn't present.  */
diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c
index 2991c9e0b50..a70b5b1cbea 100644
--- a/gcc/tree-inline.c
+++ b/gcc/tree-inline.c
@@ -118,7 +118,7 @@ eni_weights eni_time_weights;
 
 /* Prototypes.  */
 
-static tree declare_return_variable (copy_body_data *, tree, tree, tree *);
+static tree declare_return_variable (copy_body_data *, tree, tree);
 static void remap_block (tree *, copy_body_data *);
 static void copy_bind_expr (tree *, int *, copy_body_data *);
 static tree mark_local_for_remap_r (tree *, int *, void *);
@@ -256,10 +256,8 @@ tree
 remap_decl (tree decl, copy_body_data *id)
 {
   tree *n;
-  tree fn;
 
   /* We only remap local variables in the current function.  */
-  fn = id->src_fn;
 
   /* See if we have remapped this declaration.  */
 
@@ -590,7 +588,6 @@ remap_block (tree *block, copy_body_data *id)
 {
   tree old_block;
   tree new_block;
-  tree fn;
 
   /* Make the new block.  */
   old_block = *block;
@@ -607,8 +604,6 @@ remap_block (tree *block, copy_body_data *id)
   					&BLOCK_NONLOCALIZED_VARS (new_block),
 					id);
 
-  fn = id->dst_fn;
-
   if (id->transform_lang_insert_block)
     id->transform_lang_insert_block (new_block);
 
@@ -2533,13 +2528,11 @@ initialize_inlined_parameters (copy_body_data *id, gimple stmt,
    is set only for CALL_EXPR_RETURN_SLOT_OPT.  MODIFY_DEST, if non-null,
    was the LHS of the MODIFY_EXPR to which this call is the RHS.
 
-   The return value is a (possibly null) value that is the result of the
-   function as seen by the callee.  *USE_P is a (possibly null) value that
-   holds the result as seen by the caller.  */
+   The return value is a (possibly null) value that holds the result
+   as seen by the caller.  */
 
 static tree
-declare_return_variable (copy_body_data *id, tree return_slot, tree modify_dest,
-			 tree *use_p)
+declare_return_variable (copy_body_data *id, tree return_slot, tree modify_dest)
 {
   tree callee = id->src_fn;
   tree caller = id->dst_fn;
@@ -2551,10 +2544,7 @@ declare_return_variable (copy_body_data *id, tree return_slot, tree modify_dest,
   /* We don't need to do anything for functions that don't return
      anything.  */
   if (!result || VOID_TYPE_P (callee_type))
-    {
-      *use_p = NULL_TREE;
-      return NULL_TREE;
-    }
+    return NULL_TREE;
 
   /* If there was a return slot, then the return value is the
      dereferenced address of that object.  */
@@ -2705,8 +2695,7 @@ declare_return_variable (copy_body_data *id, tree return_slot, tree modify_dest,
   /* Remember this so we can ignore it in remap_decls.  */
   id->retvar = var;
 
-  *use_p = use;
-  return var;
+  return use;
 }
 
 /* Callback through walk_tree.  Determine if a DECL_INITIAL makes reference
@@ -3506,7 +3495,7 @@ get_indirect_callee_fndecl (struct cgraph_node *node, gimple stmt)
 static bool
 expand_call_inline (basic_block bb, gimple stmt, copy_body_data *id)
 {
-  tree retvar, use_retvar;
+  tree use_retvar;
   tree fn;
   struct pointer_map_t *st, *dst;
   tree return_slot;
@@ -3725,7 +3714,7 @@ expand_call_inline (basic_block bb, gimple stmt, copy_body_data *id)
     }
 
   /* Declare the return variable for the function.  */
-  retvar = declare_return_variable (id, return_slot, modify_dest, &use_retvar);
+  use_retvar = declare_return_variable (id, return_slot, modify_dest);
 
   /* Add local vars in this inlined callee to caller.  */
   t_step = id->src_cfun->local_decls;
@@ -3981,7 +3970,6 @@ unsigned int
 optimize_inline_calls (tree fn)
 {
   copy_body_data id;
-  tree prev_fn;
   basic_block bb;
   int last = n_basic_blocks;
   struct gimplify_ctx gctx;
@@ -3998,12 +3986,8 @@ optimize_inline_calls (tree fn)
   id.src_node = id.dst_node = cgraph_node (fn);
   id.dst_fn = fn;
   /* Or any functions that aren't finished yet.  */
-  prev_fn = NULL_TREE;
   if (current_function_decl)
-    {
-      id.dst_fn = current_function_decl;
-      prev_fn = current_function_decl;
-    }
+    id.dst_fn = current_function_decl;
 
   id.copy_decl = copy_decl_maybe_to_var;
   id.transform_call_graph_edges = CB_CGE_DUPLICATE;
diff --git a/gcc/tree-loop-distribution.c b/gcc/tree-loop-distribution.c
index f9c96d3120e..3c93f8eddd7 100644
--- a/gcc/tree-loop-distribution.c
+++ b/gcc/tree-loop-distribution.c
@@ -521,7 +521,6 @@ mark_nodes_having_upstream_mem_writes (struct graph *rdg)
       {
 	unsigned i;
 	VEC (int, heap) *nodes = VEC_alloc (int, heap, 3);
-	bool has_upstream_mem_write_p = false;
 
 	graphds_dfs (rdg, &v, 1, &nodes, false, NULL);
 
@@ -539,7 +538,6 @@ mark_nodes_having_upstream_mem_writes (struct graph *rdg)
 		   should be placed in the same partition.  */
 		|| has_anti_dependence (&(rdg->vertices[x])))
 	      {
-		has_upstream_mem_write_p = true;
 		bitmap_set_bit (upstream_mem_writes, x);
 	      }
 	  }
diff --git a/gcc/tree-optimize.c b/gcc/tree-optimize.c
index 781cbeaf39a..23b7046c60d 100644
--- a/gcc/tree-optimize.c
+++ b/gcc/tree-optimize.c
@@ -378,14 +378,11 @@ void
 tree_rest_of_compilation (tree fndecl)
 {
   location_t saved_loc;
-  struct cgraph_node *node;
 
   timevar_push (TV_EXPAND);
 
   gcc_assert (cgraph_global_info_ready);
 
-  node = cgraph_node (fndecl);
-
   /* Initialize the default bitmap obstack.  */
   bitmap_obstack_initialize (NULL);
 
diff --git a/gcc/tree-parloops.c b/gcc/tree-parloops.c
index 56b88a89ad0..cf019701225 100644
--- a/gcc/tree-parloops.c
+++ b/gcc/tree-parloops.c
@@ -862,13 +862,12 @@ create_call_for_reduction_1 (void **slot, void *data)
   basic_block bb;
   basic_block new_bb;
   edge e;
-  tree t, addr, addr_type, ref, x;
+  tree t, addr, ref, x;
   tree tmp_load, name;
   gimple load;
 
   load_struct = fold_build1 (INDIRECT_REF, struct_type, clsn_data->load);
   t = build3 (COMPONENT_REF, type, load_struct, reduc->field, NULL_TREE);
-  addr_type = build_pointer_type (type);
 
   addr = build_addr (t, current_function_decl);
 
@@ -1405,7 +1404,7 @@ create_parallel_loop (struct loop *loop, tree loop_fn, tree data,
 {
   gimple_stmt_iterator gsi;
   basic_block bb, paral_bb, for_bb, ex_bb;
-  tree t, param, res;
+  tree t, param;
   gimple stmt, for_stmt, phi, cond_stmt;
   tree cvar, cvar_init, initvar, cvar_next, cvar_base, type;
   edge exit, nexit, guard, end, e;
@@ -1474,7 +1473,6 @@ create_parallel_loop (struct loop *loop, tree loop_fn, tree data,
       source_location locus;
       tree def;
       phi = gsi_stmt (gsi);
-      res = PHI_RESULT (phi);
       stmt = SSA_NAME_DEF_STMT (PHI_ARG_DEF_FROM_EDGE (phi, exit));
 
       def = PHI_ARG_DEF_FROM_EDGE (stmt, loop_preheader_edge (loop));
@@ -1531,7 +1529,6 @@ static void
 gen_parallel_loop (struct loop *loop, htab_t reduction_list,
 		   unsigned n_threads, struct tree_niter_desc *niter)
 {
-  struct loop *nloop;
   loop_iterator li;
   tree many_iterations_cond, type, nit;
   tree arg_struct, new_arg_struct;
@@ -1624,8 +1621,8 @@ gen_parallel_loop (struct loop *loop, htab_t reduction_list,
 
   /* We assume that the loop usually iterates a lot.  */
   prob = 4 * REG_BR_PROB_BASE / 5;
-  nloop = loop_version (loop, many_iterations_cond, NULL,
-			prob, prob, REG_BR_PROB_BASE - prob, true);
+  loop_version (loop, many_iterations_cond, NULL,
+		prob, prob, REG_BR_PROB_BASE - prob, true);
   update_ssa (TODO_update_ssa);
   free_original_copy_tables ();
 
diff --git a/gcc/tree-ssa-alias.c b/gcc/tree-ssa-alias.c
index 6ba550bbff0..e7137087625 100644
--- a/gcc/tree-ssa-alias.c
+++ b/gcc/tree-ssa-alias.c
@@ -767,7 +767,6 @@ refs_may_alias_p_1 (ao_ref *ref1, ao_ref *ref2, bool tbaa_p)
 {
   tree base1, base2;
   HOST_WIDE_INT offset1 = 0, offset2 = 0;
-  HOST_WIDE_INT size1 = -1, size2 = -1;
   HOST_WIDE_INT max_size1 = -1, max_size2 = -1;
   bool var1_p, var2_p, ind1_p, ind2_p;
   alias_set_type set;
@@ -788,11 +787,9 @@ refs_may_alias_p_1 (ao_ref *ref1, ao_ref *ref2, bool tbaa_p)
   /* Decompose the references into their base objects and the access.  */
   base1 = ao_ref_base (ref1);
   offset1 = ref1->offset;
-  size1 = ref1->size;
   max_size1 = ref1->max_size;
   base2 = ao_ref_base (ref2);
   offset2 = ref2->offset;
-  size2 = ref2->size;
   max_size2 = ref2->max_size;
 
   /* We can end up with registers or constants as bases for example from
diff --git a/gcc/tree-ssa-loop-niter.c b/gcc/tree-ssa-loop-niter.c
index 7dbb8c3fe25..48e20454857 100644
--- a/gcc/tree-ssa-loop-niter.c
+++ b/gcc/tree-ssa-loop-niter.c
@@ -94,8 +94,10 @@ split_to_var_and_offset (tree expr, tree *var, mpz_t offset)
 
       *var = op0;
       /* Always sign extend the offset.  */
-      off = double_int_sext (tree_to_double_int (op1),
-			     TYPE_PRECISION (type));
+      off = tree_to_double_int (op1);
+      if (negate)
+	off = double_int_neg (off);
+      off = double_int_sext (off, TYPE_PRECISION (type));
       mpz_set_double_int (offset, off, false);
       break;
 
diff --git a/gcc/tree-ssa-operands.c b/gcc/tree-ssa-operands.c
index a8e11b1c9ec..9b6d3a325e6 100644
--- a/gcc/tree-ssa-operands.c
+++ b/gcc/tree-ssa-operands.c
@@ -653,13 +653,11 @@ static void
 add_stmt_operand (tree *var_p, gimple stmt, int flags)
 {
   tree var, sym;
-  var_ann_t v_ann;
 
   gcc_assert (SSA_VAR_P (*var_p));
 
   var = *var_p;
   sym = (TREE_CODE (var) == SSA_NAME ? SSA_NAME_VAR (var) : var);
-  v_ann = var_ann (sym);
 
   /* Mark statements with volatile operands.  */
   if (TREE_THIS_VOLATILE (sym))
diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c
index 466ca7565b1..2027357fd63 100644
--- a/gcc/tree-ssa-sccvn.c
+++ b/gcc/tree-ssa-sccvn.c
@@ -1023,11 +1023,10 @@ vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *vr_)
   gimple def_stmt = SSA_NAME_DEF_STMT (vuse);
   tree fndecl;
   tree base;
-  HOST_WIDE_INT offset, size, maxsize;
+  HOST_WIDE_INT offset, maxsize;
 
   base = ao_ref_base (ref);
   offset = ref->offset;
-  size = ref->size;
   maxsize = ref->max_size;
 
   /* If we cannot constrain the size of the reference we cannot
diff --git a/gcc/tree-ssa-sink.c b/gcc/tree-ssa-sink.c
index 6f7d9a4685b..bc6a7146b52 100644
--- a/gcc/tree-ssa-sink.c
+++ b/gcc/tree-ssa-sink.c
@@ -273,7 +273,6 @@ statement_sink_location (gimple stmt, basic_block frombb,
   def_operand_p def_p;
   ssa_op_iter iter;
   imm_use_iterator imm_iter;
-  enum tree_code code;
 
   FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_ALL_DEFS)
     {
@@ -320,7 +319,6 @@ statement_sink_location (gimple stmt, basic_block frombb,
      to use specific hard registers.
 
   */
-  code = gimple_assign_rhs_code (stmt);
   if (stmt_ends_bb_p (stmt)
       || gimple_has_side_effects (stmt)
       || is_hidden_global_store (stmt)
diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c
index 012dc1c9795..753eefee909 100644
--- a/gcc/tree-ssa-structalias.c
+++ b/gcc/tree-ssa-structalias.c
@@ -1354,7 +1354,6 @@ scc_visit (constraint_graph_t graph, struct scc_info *si, unsigned int n)
 	  && si->dfs[VEC_last (unsigned, si->scc_stack)] >= my_dfs)
 	{
 	  bitmap scc = BITMAP_ALLOC (NULL);
-	  bool have_ref_node = n >= FIRST_REF_NODE;
 	  unsigned int lowest_node;
 	  bitmap_iterator bi;
 
@@ -1366,8 +1365,6 @@ scc_visit (constraint_graph_t graph, struct scc_info *si, unsigned int n)
 	      unsigned int w = VEC_pop (unsigned, si->scc_stack);
 
 	      bitmap_set_bit (scc, w);
-	      if (w >= FIRST_REF_NODE)
-		have_ref_node = true;
 	    }
 
 	  lowest_node = bitmap_first_set_bit (scc);
@@ -3283,14 +3280,11 @@ do_structure_copy (tree lhsop, tree rhsop)
 	   && (rhsp->type == SCALAR
 	       || rhsp->type == ADDRESSOF))
     {
-      tree lhsbase, rhsbase;
       HOST_WIDE_INT lhssize, lhsmaxsize, lhsoffset;
       HOST_WIDE_INT rhssize, rhsmaxsize, rhsoffset;
       unsigned k = 0;
-      lhsbase = get_ref_base_and_extent (lhsop, &lhsoffset,
-					 &lhssize, &lhsmaxsize);
-      rhsbase = get_ref_base_and_extent (rhsop, &rhsoffset,
-					 &rhssize, &rhsmaxsize);
+      get_ref_base_and_extent (lhsop, &lhsoffset, &lhssize, &lhsmaxsize);
+      get_ref_base_and_extent (rhsop, &rhsoffset, &rhssize, &rhsmaxsize);
       for (j = 0; VEC_iterate (ce_s, lhsc, j, lhsp);)
 	{
 	  varinfo_t lhsv, rhsv;
@@ -3640,11 +3634,9 @@ find_func_aliases (gimple origt)
 	  get_constraint_for (gimple_phi_result (t), &lhsc);
 	  for (i = 0; i < gimple_phi_num_args (t); i++)
 	    {
-	      tree rhstype;
 	      tree strippedrhs = PHI_ARG_DEF (t, i);
 
 	      STRIP_NOPS (strippedrhs);
-	      rhstype = TREE_TYPE (strippedrhs);
 	      get_constraint_for (gimple_phi_arg_def (t, i), &rhsc);
 
 	      for (j = 0; VEC_iterate (ce_s, lhsc, j, c); j++)
@@ -5681,8 +5673,6 @@ ipa_pta_execute (void)
   /* Build the constraints.  */
   for (node = cgraph_nodes; node; node = node->next)
     {
-      unsigned int varid;
-
       /* Nodes without a body are not interesting.  Especially do not
          visit clones at this point for now - we get duplicate decls
 	 there for inline clones at least.  */
@@ -5696,8 +5686,8 @@ ipa_pta_execute (void)
       if (node->local.externally_visible)
 	continue;
 
-      varid = create_function_info_for (node->decl,
-					cgraph_node_name (node));
+      create_function_info_for (node->decl,
+				cgraph_node_name (node));
     }
 
   for (node = cgraph_nodes; node; node = node->next)
diff --git a/gcc/tree-ssa-threadupdate.c b/gcc/tree-ssa-threadupdate.c
index db29b3b0151..872de64620e 100644
--- a/gcc/tree-ssa-threadupdate.c
+++ b/gcc/tree-ssa-threadupdate.c
@@ -635,7 +635,6 @@ thread_single_edge (edge e)
   basic_block bb = e->dest;
   edge eto = (edge) e->aux;
   struct redirection_data rd;
-  struct local_info local_info;
 
   e->aux = NULL;
 
@@ -657,7 +656,6 @@ thread_single_edge (edge e)
   /* Otherwise, we need to create a copy.  */
   update_bb_profile_for_threading (bb, EDGE_FREQUENCY (e), e->count, eto);
 
-  local_info.bb = bb;
   rd.outgoing_edge = eto;
 
   create_block_for_threading (bb, &rd);
diff --git a/gcc/tree-vect-data-refs.c b/gcc/tree-vect-data-refs.c
index abc848537b0..89918535372 100644
--- a/gcc/tree-vect-data-refs.c
+++ b/gcc/tree-vect-data-refs.c
@@ -1885,7 +1885,6 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo)
     {
       gimple stmt;
       stmt_vec_info stmt_info;
-      basic_block bb;
       tree base, offset, init;
 
       if (!dr || !DR_REF (dr))
@@ -1923,7 +1922,6 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo)
       init = unshare_expr (DR_INIT (dr));
 
       /* Update DR field in stmt_vec_info struct.  */
-      bb = gimple_bb (stmt);
 
       /* If the dataref is in an inner-loop of the loop that is considered for
 	 for vectorization, we also want to analyze the access relative to
@@ -2764,13 +2762,10 @@ vect_permute_store_chain (VEC(tree,heap) *dr_chain,
   tree perm_dest, vect1, vect2, high, low;
   gimple perm_stmt;
   tree vectype = STMT_VINFO_VECTYPE (vinfo_for_stmt (stmt));
-  tree scalar_dest;
   int i;
   unsigned int j;
   enum tree_code high_code, low_code;
 
-  scalar_dest = gimple_assign_lhs (stmt);
-
   /* Check that the operation is supported.  */
   if (!vect_strided_store_supported (vectype))
     return false;
@@ -3382,7 +3377,6 @@ vect_supportable_dr_alignment (struct data_reference *dr)
   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
   tree vectype = STMT_VINFO_VECTYPE (stmt_info);
   enum machine_mode mode = TYPE_MODE (vectype);
-  bool invariant_in_outerloop = false;
   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
   struct loop *vect_loop = NULL;
   bool nested_in_vect_loop = false;
@@ -3397,13 +3391,6 @@ vect_supportable_dr_alignment (struct data_reference *dr)
   vect_loop = LOOP_VINFO_LOOP (loop_vinfo);
   nested_in_vect_loop = nested_in_vect_loop_p (vect_loop, stmt);
 
-  if (nested_in_vect_loop)
-    {
-      tree outerloop_step = STMT_VINFO_DR_STEP (stmt_info);
-      invariant_in_outerloop =
-	(tree_int_cst_compare (outerloop_step, size_zero_node) == 0);
-    }
-
   /* Possibly unaligned access.  */
 
   /* We can choose between using the implicit realignment scheme (generating
diff --git a/gcc/tree-vect-loop-manip.c b/gcc/tree-vect-loop-manip.c
index ea1a4d6bcff..d3068b30852 100644
--- a/gcc/tree-vect-loop-manip.c
+++ b/gcc/tree-vect-loop-manip.c
@@ -2327,7 +2327,6 @@ vect_loop_versioning (loop_vec_info loop_vinfo, bool do_versioning,
 		      tree *cond_expr, gimple_seq *cond_expr_stmt_list)
 {
   struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
-  struct loop *nloop;
   basic_block condition_bb;
   gimple_stmt_iterator gsi, cond_exp_gsi;
   basic_block merge_bb;
@@ -2374,8 +2373,8 @@ vect_loop_versioning (loop_vec_info loop_vinfo, bool do_versioning,
     return;
 
   initialize_original_copy_tables ();
-  nloop = loop_version (loop, *cond_expr, &condition_bb,
-			prob, prob, REG_BR_PROB_BASE - prob, true);
+  loop_version (loop, *cond_expr, &condition_bb,
+		prob, prob, REG_BR_PROB_BASE - prob, true);
   free_original_copy_tables();
 
   /* Loop versioning violates an assumption we try to maintain during
diff --git a/gcc/tree-vect-loop.c b/gcc/tree-vect-loop.c
index 9c42376b19f..f160cb458b4 100644
--- a/gcc/tree-vect-loop.c
+++ b/gcc/tree-vect-loop.c
@@ -889,7 +889,7 @@ vect_analyze_loop_form (struct loop *loop)
   else
     {
       struct loop *innerloop = loop->inner;
-      edge backedge, entryedge;
+      edge entryedge;
 
       /* Nested loop. We currently require that the loop is doubly-nested,
 	 contains a single inner loop, and the number of BBs is exactly 5.
@@ -943,13 +943,9 @@ vect_analyze_loop_form (struct loop *loop)
         }
 
       gcc_assert (EDGE_COUNT (innerloop->header->preds) == 2);
-      backedge = EDGE_PRED (innerloop->header, 1);
       entryedge = EDGE_PRED (innerloop->header, 0);
       if (EDGE_PRED (innerloop->header, 0)->src == innerloop->latch)
-	{
-	  backedge = EDGE_PRED (innerloop->header, 0);
-	  entryedge = EDGE_PRED (innerloop->header, 1);
-	}
+	entryedge = EDGE_PRED (innerloop->header, 1);
 
       if (entryedge->src != loop->header
 	  || !single_exit (innerloop)
@@ -2890,7 +2886,7 @@ vect_create_epilog_for_reduction (tree vect_def, gimple stmt,
   gimple epilog_stmt = NULL;
   tree new_scalar_dest, new_dest;
   gimple exit_phi;
-  tree bitsize, bitpos, bytesize;
+  tree bitsize, bitpos;
   enum tree_code code = gimple_assign_rhs_code (stmt);
   tree adjustment_def;
   tree vec_initial_def, def;
@@ -3045,7 +3041,6 @@ vect_create_epilog_for_reduction (tree vect_def, gimple stmt,
   scalar_type = TREE_TYPE (scalar_dest);
   new_scalar_dest = vect_create_destination_var (scalar_dest, NULL);
   bitsize = TYPE_SIZE (scalar_type);
-  bytesize = TYPE_SIZE_UNIT (scalar_type);
 
   /* For MINUS_EXPR the initial vector is [init_val,0,...,0], therefore,
      partial results are added and not subtracted.  */
diff --git a/gcc/tree-vect-patterns.c b/gcc/tree-vect-patterns.c
index b2c1de2c049..37b06330f3a 100644
--- a/gcc/tree-vect-patterns.c
+++ b/gcc/tree-vect-patterns.c
@@ -456,7 +456,6 @@ vect_recog_widen_mult_pattern (gimple last_stmt,
 static gimple
 vect_recog_pow_pattern (gimple last_stmt, tree *type_in, tree *type_out)
 {
-  tree type;
   tree fn, base, exp = NULL;
   gimple stmt;
   tree var;
@@ -464,8 +463,6 @@ vect_recog_pow_pattern (gimple last_stmt, tree *type_in, tree *type_out)
   if (!is_gimple_call (last_stmt) || gimple_call_lhs (last_stmt) == NULL)
     return NULL;
 
-  type = gimple_expr_type (last_stmt);
-
   fn = gimple_call_fndecl (last_stmt);
   switch (DECL_FUNCTION_CODE (fn))
     {
@@ -812,7 +809,6 @@ vect_pattern_recog (loop_vec_info loop_vinfo)
   basic_block *bbs = LOOP_VINFO_BBS (loop_vinfo);
   unsigned int nbbs = loop->num_nodes;
   gimple_stmt_iterator si;
-  gimple stmt;
   unsigned int i, j;
   gimple (* vect_recog_func_ptr) (gimple, tree *, tree *);
 
@@ -826,8 +822,6 @@ vect_pattern_recog (loop_vec_info loop_vinfo)
       basic_block bb = bbs[i];
       for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
         {
-          stmt = gsi_stmt (si);
-
           /* Scan over all generic vect_recog_xxx_pattern functions.  */
           for (j = 0; j < NUM_PATTERNS; j++)
             {
diff --git a/gcc/tree-vect-slp.c b/gcc/tree-vect-slp.c
index 76227aa14a9..3222f8b450e 100644
--- a/gcc/tree-vect-slp.c
+++ b/gcc/tree-vect-slp.c
@@ -879,7 +879,7 @@ vect_analyze_slp_instance (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
   unsigned int unrolling_factor = 1, nunits;
   tree vectype, scalar_type;
   gimple next;
-  unsigned int vectorization_factor = 0, ncopies;
+  unsigned int vectorization_factor = 0;
   int inside_cost = 0, outside_cost = 0, ncopies_for_cost;
   unsigned int max_nunits = 0;
   VEC (int, heap) *load_permutation;
@@ -905,8 +905,6 @@ vect_analyze_slp_instance (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
     /* No multitypes in BB SLP.  */
     vectorization_factor = nunits;
 
-  ncopies = vectorization_factor / nunits;
-
   /* Calculate the unrolling factor.  */
   unrolling_factor = least_common_multiple (nunits, group_size) / group_size;
   if (unrolling_factor != 1 && !loop_vinfo)
@@ -1639,13 +1637,11 @@ vect_create_mask_and_perm (gimple stmt, gimple next_scalar_stmt,
   tree perm_dest;
   gimple perm_stmt = NULL;
   stmt_vec_info next_stmt_info;
-  int i, group_size, stride, dr_chain_size;
+  int i, stride;
   tree first_vec, second_vec, data_ref;
   VEC (tree, heap) *params = NULL;
 
-  group_size = VEC_length (gimple, SLP_TREE_SCALAR_STMTS (node));
   stride = SLP_TREE_NUMBER_OF_VEC_STMTS (node) / ncopies;
-  dr_chain_size = VEC_length (tree, dr_chain);
 
   /* Initialize the vect stmts of NODE to properly insert the generated
      stmts later.  */
diff --git a/gcc/tree-vect-stmts.c b/gcc/tree-vect-stmts.c
index 5c12697f252..92f21982e3e 100644
--- a/gcc/tree-vect-stmts.c
+++ b/gcc/tree-vect-stmts.c
@@ -1548,7 +1548,6 @@ vectorizable_conversion (gimple stmt, gimple_stmt_iterator *gsi,
   int nunits_out;
   tree vectype_out, vectype_in;
   int ncopies, j;
-  tree expr;
   tree rhs_type, lhs_type;
   tree builtin_decl;
   enum { NARROW, NONE, WIDEN } modifier;
@@ -1765,7 +1764,6 @@ vectorizable_conversion (gimple stmt, gimple_stmt_iterator *gsi,
 	    }
 
 	  /* Arguments are ready. Create the new vector stmt.  */
-	  expr = build2 (code1, vectype_out, vec_oprnd0, vec_oprnd1);
 	  new_stmt = gimple_build_assign_with_ops (code1, vec_dest, vec_oprnd0,
 						   vec_oprnd1);
 	  new_temp = make_ssa_name (vec_dest, new_stmt);
@@ -1929,7 +1927,6 @@ vectorizable_operation (gimple stmt, gimple_stmt_iterator *gsi,
   VEC(tree,heap) *vec_oprnds0 = NULL, *vec_oprnds1 = NULL;
   tree vop0, vop1;
   unsigned int k;
-  bool shift_p = false;
   bool scalar_shift_arg = false;
   bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info);
   int vf;
@@ -2013,8 +2010,6 @@ vectorizable_operation (gimple stmt, gimple_stmt_iterator *gsi,
   if (code == LSHIFT_EXPR || code == RSHIFT_EXPR || code == LROTATE_EXPR
       || code == RROTATE_EXPR)
     {
-      shift_p = true;
-
       /* vector shifted by vector */
       if (dt[1] == vect_internal_def)
 	{
@@ -2893,7 +2888,6 @@ vectorizable_store (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
   bool inv_p;
   VEC(tree,heap) *vec_oprnds = NULL;
   bool slp = (slp_node != NULL);
-  stmt_vec_info first_stmt_vinfo;
   unsigned int vec_num;
   bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info);
 
@@ -3036,7 +3030,6 @@ vectorizable_store (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
       first_stmt = stmt;
       first_dr = dr;
       group_size = vec_num = 1;
-      first_stmt_vinfo = stmt_info;
     }
 
   if (vect_print_dump_info (REPORT_DETAILS))
diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c
index 6e6070937c1..2d0761b15fa 100644
--- a/gcc/tree-vrp.c
+++ b/gcc/tree-vrp.c
@@ -3911,7 +3911,6 @@ register_new_assert_for (tree name, tree expr,
 			 gimple_stmt_iterator si)
 {
   assert_locus_t n, loc, last_loc;
-  bool found;
   basic_block dest_bb;
 
 #if defined ENABLE_CHECKING
@@ -3960,7 +3959,6 @@ register_new_assert_for (tree name, tree expr,
      COMP_CODE and VAL could be implemented.  */
   loc = asserts_for[SSA_NAME_VERSION (name)];
   last_loc = loc;
-  found = false;
   while (loc)
     {
       if (loc->comp_code == comp_code
@@ -5997,7 +5995,7 @@ vrp_visit_switch_stmt (gimple stmt, edge *taken_edge_p)
 {
   tree op, val;
   value_range_t *vr;
-  size_t i = 0, j = 0, n;
+  size_t i = 0, j = 0;
   bool take_default;
 
   *taken_edge_p = NULL;
@@ -6020,8 +6018,6 @@ vrp_visit_switch_stmt (gimple stmt, edge *taken_edge_p)
     return SSA_PROP_VARYING;
 
   /* Find the single edge that is taken from the switch expression.  */
-  n = gimple_switch_num_labels (stmt);
-
   take_default = !find_case_label_range (stmt, vr->min, vr->max, &i, &j);
 
   /* Check if the range spans no CASE_LABEL. If so, we only reach the default
diff --git a/gcc/value-prof.c b/gcc/value-prof.c
index 5b92f744860..0dde9bf8041 100644
--- a/gcc/value-prof.c
+++ b/gcc/value-prof.c
@@ -959,7 +959,7 @@ gimple_mod_subtract_transform (gimple_stmt_iterator *si)
   histogram_value histogram;
   enum tree_code code;
   gcov_type count, wrong_values, all;
-  tree lhs_type, result, value;
+  tree lhs_type, result;
   gcov_type prob1, prob2;
   unsigned int i, steps;
   gcov_type count1, count2;
@@ -982,7 +982,6 @@ gimple_mod_subtract_transform (gimple_stmt_iterator *si)
   if (!histogram)
     return false;
 
-  value = histogram->hvalue.value;
   all = 0;
   wrong_values = 0;
   for (i = 0; i < histogram->hdata.intvl.steps; i++)
@@ -1367,7 +1366,6 @@ gimple_stringops_transform (gimple_stmt_iterator *gsi)
   enum built_in_function fcode;
   histogram_value histogram;
   gcov_type count, all, val;
-  tree value;
   tree dest, src;
   unsigned int dest_align, src_align;
   gcov_type prob;
@@ -1390,7 +1388,6 @@ gimple_stringops_transform (gimple_stmt_iterator *gsi)
   histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_SINGLE_VALUE);
   if (!histogram)
     return false;
-  value = histogram->hvalue.value;
   val = histogram->hvalue.counters[0];
   count = histogram->hvalue.counters[1];
   all = histogram->hvalue.counters[2];
@@ -1593,7 +1590,6 @@ gimple_stringops_values_to_profile (gimple stmt, histogram_values *values)
   tree fndecl;
   tree blck_size;
   tree dest;
-  enum built_in_function fcode;
   int size_arg;
 
   if (gimple_code (stmt) != GIMPLE_CALL)
@@ -1601,7 +1597,6 @@ gimple_stringops_values_to_profile (gimple stmt, histogram_values *values)
   fndecl = gimple_call_fndecl (stmt);
   if (!fndecl)
     return;
-  fcode = DECL_FUNCTION_CODE (fndecl);
 
   if (!interesting_stringop_to_profile_p (fndecl, stmt, &size_arg))
     return;