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
Jakub Jelinek
parent
e86b4c032a
commit
0f900dfafa
41 changed files with 174 additions and 233 deletions
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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))
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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 ();
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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],
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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))
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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
21
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. */
|
||||
|
|
|
|||
|
|
@ -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],
|
||||
|
|
|
|||
|
|
@ -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++)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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 ();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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. */
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
||||
|
|
|
|||
|
|
@ -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 ();
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
||||
|
|
|
|||
|
|
@ -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))
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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. */
|
||||
|
|
|
|||
|
|
@ -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++)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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. */
|
||||
|
|
|
|||
|
|
@ -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))
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue