diff options
41 files changed, 174 insertions, 233 deletions
diff --git a/gcc/ChangeLog b/gcc/ChangeLog index da9ad1a..14101e6 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 34fde8b..fe4bf0d 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 9efcb8d..7ee9f5d 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 43ed0a5..0cb7ccc 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 4076409..af3d9cf 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 9559869..16ae9b8 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 6792d18..7e0a0d4 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 486338f..0caa318 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 71c7419..90e21e5 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 65d0282..d6e2b1f 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 e720dab..e39462d 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 ff7da4e..666d4bd 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 ba4d764..02fea10 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 9e659dc..87067d8 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 eaedee1..f878582 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 5a6490e..8102706 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 18afc5b..25fcc52 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 a29ffe3..e0e8970 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 3484d86..e864eb4 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 8b1ece8..9a27adc 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 8f246fa..53bf118 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 69535f1..a918f4b 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 2991c9e..a70b5b1c 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 f9c96d3..3c93f8e 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 781cbea..23b7046 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 56b88a8..cf01970 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 6ba550b..e713708 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 7dbb8c3..48e2045 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 a8e11b1..9b6d3a3 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 466ca75..2027357 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 6f7d9a4..bc6a714 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 012dc1c..753eefe 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 db29b3b..872de64 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 abc8485..8991853 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 ea1a4d6..d3068b3 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 9c42376..f160cb4 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 b2c1de2..37b0633 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 76227aa..3222f8b 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 5c12697..92f2198 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 6e60709..2d0761b1 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 5b92f74..0dde9bf 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; |