malloc_fname variable.
(check_allocation_function): Remove unused gsi and bb_level_0
variables.
(transform_access_sites): Remove unused d_type_size and d_type_size_k
variables.
* omega.c (resurrect_subs): Remove unused n variable.
(omega_solve_geq): Remove unused neweqns variable.
* lto-streamer-in.c (lto_read_tree): Remove unused end_marker variable.
* tree-inline.c (declare_return_variable): Remove USE_P argument,
return use instead of var.
(remap_decl, remap_block): Remove unused fn variable.
(expand_call_inline): Remove unused retvar variable, adjust
declare_return_variable caller.
(optimize_inline_calls): Remove unused prev_fn variable.
* tree-vect-slp.c (vect_analyze_slp_instance): Remove unused ncopies
variable.
(vect_create_mask_and_perm): Remove unused group_size and dr_chain_size
variables.
* tree-ssa-loop-niter.c (split_to_var_and_offset): Handle MINUS_EXPR
properly.
* tree-vect-loop.c (vect_analyze_loop_form): Remove unused backedge
variable.
(vect_create_epilog_for_reduction): Remove unused bytesize variable.
* omp-low.c (workshare_safe_to_combine_p): Remove par_entry_bb
parameter. Remove unused par_stmt variable.
(determine_parallel_type): Adjust workshare_safe_to_combine_p caller.
(expand_omp_sections): Remove unused l1 variable.
(lower_omp_for): Remove unused ilist variable.
* tree-loop-distribution.c (mark_nodes_having_upstream_mem_writes):
Remove unused has_upstream_mem_write_p variable.
* recog.c (decode_asm_operands): Remove unused noperands variable.
* tree-ssa-alias.c (refs_may_alias_p_1): Remove unused size1 and
size2 variable.
* libgcov.c (__gcov_merge_delta): Remove unused last variable.
* tree-call-cdce.c (gen_conditions_for_pow_int_base): Remove unused
base_nm variable.
(gen_conditions_for_pow): Remove unused ec variable.
* tree-ssa-sccvn.c (vn_reference_lookup_3): Remove unused size
variable.
* ipa-struct-reorg.c (program_redefines_malloc_p): Remove unused
fndecl variable.
* tree-ssa-sink.c (statement_sink_location): Remove unused code
variable.
* regmove.c (copy_src_to_dest): Remove unused insn_uid and move_uid
variables.
* tree-complex.c (create_one_component_var): Remove unused inner_type
variable.
* calls.c (emit_call_1): Don't GEN_INT (struct_value_size)
unnecessarily when GEN_*CALL omits that argument.
* regrename.c (regrename_optimize): Remove unused regs_seen variable.
(build_def_use): Remove unused icode variable.
* ipa-pure-const.c (check_call): Remove unused callee and avail
variables.
* tree-dfa.c (add_referenced_var): Remove unused v_ann variable.
* tree-vect-patterns.c (vect_recog_pow_pattern): Remove unused type
variable.
(vect_pattern_recog): Remove unused stmt variable.
* sel-sched-ir.c (make_regions_from_the_rest): Remove unused
new_regions variable.
* postreload.c (reload_cse_simplify_operands): Remove unused mode
variable.
* tree-parloops.c (create_call_for_reduction_1): Remove unused
addr_type variable.
(create_parallel_loop): Remove unused res variable.
(gen_parallel_loop): Remove unused nloop variable.
* tree-vect-loop-manip.c (vect_loop_versioning): Likewise.
* value-prof.c (gimple_mod_subtract_transform,
gimple_stringops_transform): Remove unused value variable.
(gimple_stringops_values_to_profile): Remove unused fcode variable.
* tree-vrp.c (register_new_assert_for): Remove unused found variable.
(vrp_visit_switch_stmt): Remove unused n variable.
* tree-vect-stmts.c (vectorizable_conversion): Remove unused expr
variable.
(vectorizable_operation): Remove unused shift_p variable.
(vectorizable_store): Remove unused first_stmt_vinfo variable.
* tree-ssa-operands.c (add_stmt_operand): Remove unused v_ann variable.
* tree-vect-data-refs.c (vect_analyze_data_refs): Remove unused bb
variable.
(vect_permute_store_chain): Remove unused scalar_dest variable.
(vect_supportable_dr_alignment): Remove unused invariant_in_outerloop
variable.
* tree-ssa-threadupdate.c (thread_single_edge): Remove unused
local_info variable.
* tree-optimize.c (tree_rest_of_compilation): Remove unused node
variable.
* optabs.c (expand_binop): Remove unused equiv_value variable.
(emit_libcall_block): Remove unused prev variable.
(init_optabs): Remove unused int_mode variable.
* tree-ssa-structalias.c (scc_visit): Remove unused have_ref_node
variable.
(do_structure_copy): Remove unused lhsbase and rhsbase variables.
(find_func_aliases): Remove unused rhstype variable.
(ipa_pta_execute): Remove unused varid variable.
gcc/objc/
* objc-act.c (generate_shared_structures): Remove unused sc_spec and
decl_specs variables.
(objc_build_message_expr): Remove unused loc variable.
(objc_finish_message_expr): Remove unused saved_rtype variable.
(encode_field_decl): Remove unused type variable.
gcc/lto/
* lto-lang.c (handle_nonnull_attribute): Remove unused attr_arg_num
variable.
git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@154726
138bc75d-0d04-0410-961f-
82ee72b054a4
+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.
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);
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
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
{
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));
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))
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;
__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 ();
enum LTO_tags tag)
{
tree result;
- char end_marker;
int ix;
result = lto_materialize_tree (ib, data_in, tag, &ix);
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
+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
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
/* 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;
else
{
tree malloc_fn_decl;
- const char *malloc_fname;
malloc_fn_decl = gimple_call_fndecl (stmt);
if (malloc_fn_decl == NULL_TREE)
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)
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;
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++)
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],
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.
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;
/* 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)));
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));
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. */
}
else if (rtype)
{
- tree orig_rtype = rtype, saved_rtype;
+ tree orig_rtype = rtype;
if (TREE_CODE (rtype) == POINTER_TYPE)
rtype = TREE_TYPE (rtype);
&& 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);
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. */
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))
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))
{
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))
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;
|| 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,
upper_bound_count,
lower_bound_count, minC, maxC);
- neweqns = upper_bound_count * lower_bound_count;
score = maxC - minC;
if (best > score)
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;
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))))
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;
}
}
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);
}
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;
}
/* 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);
{
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. */
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;
}
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. */
break;
}
- prev = get_last_insn ();
-
/* Write the remaining insns followed by the final copy. */
-
for (insn = insns; insn; insn = next)
{
next = NEXT_INSN (insn);
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);
/* 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. */
cselib_val *v;
struct elt_loc_list *l;
rtx op;
- enum machine_mode mode;
CLEAR_HARD_REG_SET (equiv_regs[i]);
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);
&& 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],
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))
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++)
{
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
*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);
{
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);
#endif
}
- CLEAR_HARD_REG_SET (regs_seen);
while (all_chains)
{
int new_reg, best_new_reg, best_nregs;
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;
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);
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
unsigned *nconds)
{
gimple base_def;
- tree base_nm, base_val0;
+ tree base_val0;
tree base_var, int_type;
tree temp, tempn;
tree cst0;
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);
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:
unsigned *nconds)
{
tree base, expn;
- enum tree_code bc, ec;
+ enum tree_code bc;
#ifdef ENABLE_CHECKING
gcc_assert (check_pow (pow_call));
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 ();
}
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;
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. */
/* 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 *);
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. */
{
tree old_block;
tree new_block;
- tree fn;
/* Make the new block. */
old_block = *block;
&BLOCK_NONLOCALIZED_VARS (new_block),
id);
- fn = id->dst_fn;
-
if (id->transform_lang_insert_block)
id->transform_lang_insert_block (new_block);
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;
/* 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. */
/* 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
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;
}
/* 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;
optimize_inline_calls (tree fn)
{
copy_body_data id;
- tree prev_fn;
basic_block bb;
int last = n_basic_blocks;
struct gimplify_ctx gctx;
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;
{
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);
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);
}
}
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);
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);
{
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;
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));
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;
/* 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 ();
{
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;
/* 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
*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;
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))
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
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)
{
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)
&& 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;
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);
&& (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;
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++)
/* 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. */
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)
basic_block bb = e->dest;
edge eto = (edge) e->aux;
struct redirection_data rd;
- struct local_info local_info;
e->aux = NULL;
/* 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);
{
gimple stmt;
stmt_vec_info stmt_info;
- basic_block bb;
tree base, offset, init;
if (!dr || !DR_REF (dr))
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
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;
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;
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
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;
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
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.
}
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)
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;
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. */
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;
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))
{
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 *);
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++)
{
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;
/* 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)
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. */
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;
}
/* 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);
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;
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)
{
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);
first_stmt = stmt;
first_dr = dr;
group_size = vec_num = 1;
- first_stmt_vinfo = stmt_info;
}
if (vect_print_dump_info (REPORT_DETAILS))
gimple_stmt_iterator si)
{
assert_locus_t n, loc, last_loc;
- bool found;
basic_block dest_bb;
#if defined ENABLE_CHECKING
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
{
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;
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
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;
if (!histogram)
return false;
- value = histogram->hvalue.value;
all = 0;
wrong_values = 0;
for (i = 0; i < histogram->hdata.intvl.steps; i++)
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;
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];
tree fndecl;
tree blck_size;
tree dest;
- enum built_in_function fcode;
int size_arg;
if (gimple_code (stmt) != GIMPLE_CALL)
fndecl = gimple_call_fndecl (stmt);
if (!fndecl)
return;
- fcode = DECL_FUNCTION_CODE (fndecl);
if (!interesting_stringop_to_profile_p (fndecl, stmt, &size_arg))
return;
OSDN Git Service
