OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

matrix-reorg.c (analyze_matrix_allocation_site): Remove unused malloc_fname variable. 

* 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.

From-SVN: r154726
This commit is contained in:
Jakub Jelinek 2009-11-28 17:21:00 +01:00 committed by Jakub Jelinek
parent e86b4c032a
commit 0f900dfafa
41 changed files with 174 additions and 233 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

97
gcc/ChangeLog
View File

@ -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.

8
gcc/calls.c
View File

@ -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

5
gcc/ipa-pure-const.c
View File

@ -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))

3
gcc/ipa-struct-reorg.c
View File

@ -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;

4
gcc/libgcov.c
View File

@ -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 ();

3
gcc/lto-streamer-in.c
View File

@ -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

5
gcc/lto/ChangeLog
View File

@ -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

3
gcc/lto/lto-lang.c
View File

@ -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;

11
gcc/matrix-reorg.c
View File

@ -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],

6
gcc/objc/ChangeLog
View File

@ -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.

18
gcc/objc/objc-act.c
View File

@ -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))

7
gcc/omega.c
View File

@ -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)

16
gcc/omp-low.c
View File

@ -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);

21
gcc/optabs.c
View File

@ -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. */

8
gcc/postreload.c
View File

@ -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],

5
gcc/recog.c
View File

@ -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++)
{

5
gcc/regmove.c
View File

@ -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);

7
gcc/regrename.c
View File

@ -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);

2
gcc/sel-sched-ir.c
View File

@ -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

18
gcc/tree-call-cdce.c
View File

@ -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 ();
}

2
gcc/tree-complex.c
View File

@ -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;

4
gcc/tree-dfa.c
View File

@ -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. */

34
gcc/tree-inline.c
View File

@ -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;

2
gcc/tree-loop-distribution.c
View File

@ -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);
}
}

3
gcc/tree-optimize.c
View File

@ -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);

11
gcc/tree-parloops.c
View File

@ -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 ();

3
gcc/tree-ssa-alias.c
View File

@ -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

6
gcc/tree-ssa-loop-niter.c
View File

@ -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;

2
gcc/tree-ssa-operands.c
View File

@ -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))

3
gcc/tree-ssa-sccvn.c
View File

@ -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

2
gcc/tree-ssa-sink.c
View File

@ -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)

18
gcc/tree-ssa-structalias.c
View File

@ -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)

2
gcc/tree-ssa-threadupdate.c
View File

@ -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);

13
gcc/tree-vect-data-refs.c
View File

@ -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

5
gcc/tree-vect-loop-manip.c
View File

@ -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

11
gcc/tree-vect-loop.c
View File

@ -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. */

6
gcc/tree-vect-patterns.c
View File

@ -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++)
{

8
gcc/tree-vect-slp.c
View File

@ -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. */

7
gcc/tree-vect-stmts.c
View File

@ -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))

6
gcc/tree-vrp.c
View File

@ -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

7
gcc/value-prof.c
View File

@ -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;