+2017-05-16 Martin Liska <mliska@suse.cz>
+
+ * cgraph.c (cgraph_edge::resolve_speculation): Add default value for flags
+ argument of print_gimple_stmt, print_gimple_expr,
+ print_generic_stmt and print_generic_expr.
+ * cgraphclones.c (symbol_table::materialize_all_clones): Likewise.
+ * coretypes.h: Likewise.
+ * except.c (dump_eh_tree): Likewise.
+ * gimple-fold.c (gimple_fold_stmt_to_constant_1): Likewise.
+ * gimple-pretty-print.h: Likewise.
+ * gimple-ssa-backprop.c (dump_usage_prefix): Likewise.
+ (backprop::push_to_worklist): Likewise.
+ (backprop::pop_from_worklist): Likewise.
+ (backprop::process_use): Likewise.
+ (backprop::intersect_uses): Likewise.
+ (note_replacement): Likewise.
+ * gimple-ssa-store-merging.c (pass_store_merging::terminate_all_aliasing_chains): Likewise.
+ (imm_store_chain_info::coalesce_immediate_stores): Likewise.
+ (pass_store_merging::execute): Likewise.
+ * gimple-ssa-strength-reduction.c (dump_candidate): Likewise.
+ (ssa_base_cand_dump_callback): Likewise.
+ (dump_incr_vec): Likewise.
+ (replace_refs): Likewise.
+ (replace_mult_candidate): Likewise.
+ (create_add_on_incoming_edge): Likewise.
+ (create_phi_basis): Likewise.
+ (insert_initializers): Likewise.
+ (all_phi_incrs_profitable): Likewise.
+ (introduce_cast_before_cand): Likewise.
+ (replace_one_candidate): Likewise.
+ * gimplify.c (gimplify_expr): Likewise.
+ * graphite-isl-ast-to-gimple.c (is_valid_rename): Likewise.
+ (set_rename): Likewise.
+ (rename_uses): Likewise.
+ (copy_loop_phi_nodes): Likewise.
+ (add_close_phis_to_merge_points): Likewise.
+ (copy_loop_close_phi_args): Likewise.
+ (copy_cond_phi_args): Likewise.
+ (graphite_copy_stmts_from_block): Likewise.
+ (translate_pending_phi_nodes): Likewise.
+ * graphite-poly.c (print_pdr): Likewise.
+ (dump_gbb_cases): Likewise.
+ (dump_gbb_conditions): Likewise.
+ (print_scop_params): Likewise.
+ * graphite-scop-detection.c (build_cross_bb_scalars_def): Likewise.
+ (build_cross_bb_scalars_use): Likewise.
+ (gather_bbs::before_dom_children): Likewise.
+ * hsa-dump.c (dump_hsa_immed): Likewise.
+ * ipa-cp.c (print_ipcp_constant_value): Likewise.
+ (get_replacement_map): Likewise.
+ * ipa-inline-analysis.c (dump_condition): Likewise.
+ (estimate_function_body_sizes): Likewise.
+ * ipa-polymorphic-call.c (check_stmt_for_type_change): Likewise.
+ (ipa_polymorphic_call_context::get_dynamic_type): Likewise.
+ * ipa-prop.c (ipa_dump_param): Likewise.
+ (ipa_print_node_jump_functions_for_edge): Likewise.
+ (ipa_modify_call_arguments): Likewise.
+ (ipa_modify_expr): Likewise.
+ (ipa_dump_param_adjustments): Likewise.
+ (ipa_dump_agg_replacement_values): Likewise.
+ (ipcp_modif_dom_walker::before_dom_children): Likewise.
+ * ipa-pure-const.c (check_stmt): Likewise.
+ (pass_nothrow::execute): Likewise.
+ * ipa-split.c (execute_split_functions): Likewise.
+ * omp-offload.c (dump_oacc_loop_part): Likewise.
+ (dump_oacc_loop): Likewise.
+ * trans-mem.c (tm_log_emit): Likewise.
+ (tm_memopt_accumulate_memops): Likewise.
+ (dump_tm_memopt_set): Likewise.
+ (dump_tm_memopt_transform): Likewise.
+ * tree-cfg.c (gimple_verify_flow_info): Likewise.
+ (print_loop): Likewise.
+ * tree-chkp-opt.c (chkp_print_addr): Likewise.
+ (chkp_gather_checks_info): Likewise.
+ (chkp_get_check_result): Likewise.
+ (chkp_remove_check_if_pass): Likewise.
+ (chkp_use_outer_bounds_if_possible): Likewise.
+ (chkp_reduce_bounds_lifetime): Likewise.
+ * tree-chkp.c (chkp_register_addr_bounds): Likewise.
+ (chkp_mark_completed_bounds): Likewise.
+ (chkp_register_incomplete_bounds): Likewise.
+ (chkp_mark_invalid_bounds): Likewise.
+ (chkp_maybe_copy_and_register_bounds): Likewise.
+ (chkp_build_returned_bound): Likewise.
+ (chkp_get_bound_for_parm): Likewise.
+ (chkp_build_bndldx): Likewise.
+ (chkp_get_bounds_by_definition): Likewise.
+ (chkp_generate_extern_var_bounds): Likewise.
+ (chkp_get_bounds_for_decl_addr): Likewise.
+ * tree-chrec.c (chrec_apply): Likewise.
+ * tree-data-ref.c (dump_data_reference): Likewise.
+ (dump_subscript): Likewise.
+ (dump_data_dependence_relation): Likewise.
+ (analyze_overlapping_iterations): Likewise.
+ * tree-inline.c (expand_call_inline): Likewise.
+ (tree_function_versioning): Likewise.
+ * tree-into-ssa.c (dump_defs_stack): Likewise.
+ (dump_currdefs): Likewise.
+ (dump_names_replaced_by): Likewise.
+ (dump_update_ssa): Likewise.
+ (update_ssa): Likewise.
+ * tree-object-size.c (pass_object_sizes::execute): Likewise.
+ * tree-parloops.c (build_new_reduction): Likewise.
+ (try_create_reduction_list): Likewise.
+ (ref_conflicts_with_region): Likewise.
+ (oacc_entry_exit_ok_1): Likewise.
+ (oacc_entry_exit_single_gang): Likewise.
+ * tree-pretty-print.h: Likewise.
+ * tree-scalar-evolution.c (set_scalar_evolution): Likewise.
+ (get_scalar_evolution): Likewise.
+ (add_to_evolution): Likewise.
+ (get_loop_exit_condition): Likewise.
+ (analyze_evolution_in_loop): Likewise.
+ (analyze_initial_condition): Likewise.
+ (analyze_scalar_evolution): Likewise.
+ (instantiate_scev): Likewise.
+ (number_of_latch_executions): Likewise.
+ (gather_chrec_stats): Likewise.
+ (final_value_replacement_loop): Likewise.
+ (scev_const_prop): Likewise.
+ * tree-sra.c (dump_access): Likewise.
+ (disqualify_candidate): Likewise.
+ (create_access): Likewise.
+ (reject): Likewise.
+ (maybe_add_sra_candidate): Likewise.
+ (create_access_replacement): Likewise.
+ (analyze_access_subtree): Likewise.
+ (analyze_all_variable_accesses): Likewise.
+ (sra_modify_assign): Likewise.
+ (initialize_constant_pool_replacements): Likewise.
+ (find_param_candidates): Likewise.
+ (decide_one_param_reduction): Likewise.
+ (replace_removed_params_ssa_names): Likewise.
+ * tree-ssa-ccp.c (ccp_fold_stmt): Likewise.
+ * tree-ssa-copy.c (dump_copy_of): Likewise.
+ (copy_prop_visit_cond_stmt): Likewise.
+ * tree-ssa-dce.c (mark_operand_necessary): Likewise.
+ * tree-ssa-dom.c (pass_dominator::execute): Likewise.
+ (record_equivalences_from_stmt): Likewise.
+ * tree-ssa-dse.c (compute_trims): Likewise.
+ (delete_dead_call): Likewise.
+ (delete_dead_assignment): Likewise.
+ * tree-ssa-forwprop.c (forward_propagate_into_gimple_cond): Likewise.
+ (forward_propagate_into_cond): Likewise.
+ (pass_forwprop::execute): Likewise.
+ * tree-ssa-ifcombine.c (ifcombine_ifandif): Likewise.
+ * tree-ssa-loop-im.c (invariantness_dom_walker::before_dom_children): Likewise.
+ (move_computations_worker): Likewise.
+ (execute_sm): Likewise.
+ * tree-ssa-loop-ivcanon.c (tree_estimate_loop_size): Likewise.
+ (remove_exits_and_undefined_stmts): Likewise.
+ (remove_redundant_iv_tests): Likewise.
+ * tree-ssa-loop-ivopts.c (dump_use): Likewise.
+ (adjust_iv_update_pos): Likewise.
+ * tree-ssa-math-opts.c (bswap_replace): Likewise.
+ * tree-ssa-phiopt.c (factor_out_conditional_conversion): Likewise.
+ (value_replacement): Likewise.
+ * tree-ssa-phiprop.c (phiprop_insert_phi): Likewise.
+ * tree-ssa-pre.c (print_pre_expr): Likewise.
+ (get_representative_for): Likewise.
+ (create_expression_by_pieces): Likewise.
+ (insert_into_preds_of_block): Likewise.
+ (eliminate_insert): Likewise.
+ (eliminate_dom_walker::before_dom_children): Likewise.
+ (eliminate): Likewise.
+ (remove_dead_inserted_code): Likewise.
+ * tree-ssa-propagate.c (substitute_and_fold): Likewise.
+ * tree-ssa-reassoc.c (get_rank): Likewise.
+ (eliminate_duplicate_pair): Likewise.
+ (eliminate_plus_minus_pair): Likewise.
+ (eliminate_not_pairs): Likewise.
+ (undistribute_ops_list): Likewise.
+ (eliminate_redundant_comparison): Likewise.
+ (update_range_test): Likewise.
+ (optimize_range_tests_var_bound): Likewise.
+ (optimize_vec_cond_expr): Likewise.
+ (rewrite_expr_tree): Likewise.
+ (rewrite_expr_tree_parallel): Likewise.
+ (linearize_expr): Likewise.
+ (break_up_subtract): Likewise.
+ (linearize_expr_tree): Likewise.
+ (attempt_builtin_powi): Likewise.
+ (attempt_builtin_copysign): Likewise.
+ (transform_stmt_to_copy): Likewise.
+ (transform_stmt_to_multiply): Likewise.
+ (dump_ops_vector): Likewise.
+ * tree-ssa-sccvn.c (vn_nary_build_or_lookup_1): Likewise.
+ (print_scc): Likewise.
+ (set_ssa_val_to): Likewise.
+ (visit_reference_op_store): Likewise.
+ (visit_use): Likewise.
+ (sccvn_dom_walker::before_dom_children): Likewise.
+ (run_scc_vn): Likewise.
+ * tree-ssa-scopedtables.c (avail_exprs_stack::lookup_avail_expr): Likewise.
+ (expr_hash_elt::print): Likewise.
+ (const_and_copies::pop_to_marker): Likewise.
+ (const_and_copies::record_const_or_copy_raw): Likewise.
+ * tree-ssa-structalias.c (compute_dependence_clique): Likewise.
+ * tree-ssa-uninit.c (collect_phi_def_edges): Likewise.
+ (dump_predicates): Likewise.
+ (find_uninit_use): Likewise.
+ (warn_uninitialized_phi): Likewise.
+ (pass_late_warn_uninitialized::execute): Likewise.
+ * tree-ssa.c (verify_vssa): Likewise.
+ (verify_ssa): Likewise.
+ (maybe_optimize_var): Likewise.
+ * tree-vrp.c (dump_value_range): Likewise.
+ (dump_all_value_ranges): Likewise.
+ (dump_asserts_for): Likewise.
+ (register_edge_assert_for_2): Likewise.
+ (vrp_visit_cond_stmt): Likewise.
+ (vrp_visit_switch_stmt): Likewise.
+ (vrp_visit_stmt): Likewise.
+ (vrp_visit_phi_node): Likewise.
+ (simplify_cond_using_ranges_1): Likewise.
+ (fold_predicate_in): Likewise.
+ (evrp_dom_walker::before_dom_children): Likewise.
+ (evrp_dom_walker::push_value_range): Likewise.
+ (evrp_dom_walker::pop_value_range): Likewise.
+ (execute_early_vrp): Likewise.
+
2017-05-16 Richard Biener <rguenther@suse.de>
* dwarf2out.c (loc_list_from_tree_1): Do not create
edge->caller->order,
xstrdup_for_dump (e2->callee->name ()),
e2->callee->order);
- print_generic_expr (dump_file, callee_decl, 0);
+ print_generic_expr (dump_file, callee_decl);
fprintf (dump_file, "\n");
}
else
{
ipa_replace_map *replace_info;
replace_info = (*node->clone.tree_map)[i];
- print_generic_expr (symtab->dump_file, replace_info->old_tree, 0);
+ print_generic_expr (symtab->dump_file,
+ replace_info->old_tree);
fprintf (symtab->dump_file, " -> ");
- print_generic_expr (symtab->dump_file, replace_info->new_tree, 0);
+ print_generic_expr (symtab->dump_file,
+ replace_info->new_tree);
fprintf (symtab->dump_file, "%s%s;",
replace_info->replace_p ? "(replace)":"",
replace_info->ref_p ? "(ref)":"");
+2017-05-16 Martin Liska <mliska@suse.cz>
+
+ * parser.c (cp_lexer_print_token): Add default value for flags
+ argument of print_gimple_stmt, print_gimple_expr,
+ print_generic_stmt and print_generic_expr.
+
2017-05-16 Nathan Sidwell <nathan@acm.org>
* cp-tree.h (class ovl_iterator, class lkp_iterator): New OVERLOAD
break;
case CPP_NUMBER:
- print_generic_expr (stream, token->u.value, 0);
+ print_generic_expr (stream, token->u.value);
break;
default:
for (lp = i->landing_pads; lp ; lp = lp->next_lp)
{
fprintf (out, "{%i,", lp->index);
- print_generic_expr (out, lp->post_landing_pad, 0);
+ print_generic_expr (out, lp->post_landing_pad);
fputc ('}', out);
if (lp->next_lp)
fputc (',', out);
if (c->label)
{
fprintf (out, "lab:");
- print_generic_expr (out, c->label, 0);
+ print_generic_expr (out, c->label);
fputc (';', out);
}
- print_generic_expr (out, c->type_list, 0);
+ print_generic_expr (out, c->type_list);
fputc ('}', out);
if (c->next_catch)
fputc (',', out);
case ERT_ALLOWED_EXCEPTIONS:
fprintf (out, " filter :%i types:", i->u.allowed.filter);
- print_generic_expr (out, i->u.allowed.type_list, 0);
+ print_generic_expr (out, i->u.allowed.type_list);
break;
}
fputc ('\n', out);
fprintf (dump_file, "Match-and-simplified ");
print_gimple_expr (dump_file, stmt, 0, TDF_SLIM);
fprintf (dump_file, " to ");
- print_generic_expr (dump_file, res, 0);
+ print_generic_expr (dump_file, res);
fprintf (dump_file, "\n");
}
return res;
extern void debug_gimple_stmt (gimple *);
extern void debug_gimple_seq (gimple_seq);
extern void print_gimple_seq (FILE *, gimple_seq, int, int);
-extern void print_gimple_stmt (FILE *, gimple *, int, int);
+extern void print_gimple_stmt (FILE *, gimple *, int, int = 0);
extern void debug (gimple &ref);
extern void debug (gimple *ptr);
-extern void print_gimple_expr (FILE *, gimple *, int, int);
+extern void print_gimple_expr (FILE *, gimple *, int, int = 0);
extern void pp_gimple_stmt_1 (pretty_printer *, gimple *, int, int);
extern void gimple_dump_bb (FILE *, basic_block, int, int);
extern void gimple_dump_bb_for_graph (pretty_printer *, basic_block);
dump_usage_prefix (FILE *file, tree var)
{
fprintf (file, " ");
- print_generic_expr (file, var, 0);
+ print_generic_expr (file, var);
fprintf (file, ": ");
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "[WORKLIST] Pushing ");
- print_generic_expr (dump_file, var, 0);
+ print_generic_expr (dump_file, var);
fprintf (dump_file, "\n");
}
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "[WORKLIST] Popping ");
- print_generic_expr (dump_file, var, 0);
+ print_generic_expr (dump_file, var);
fprintf (dump_file, "\n");
}
return var;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "[USE] ");
- print_generic_expr (dump_file, rhs, 0);
+ print_generic_expr (dump_file, rhs);
fprintf (dump_file, " in ");
print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "[BACKEDGE] ");
- print_generic_expr (dump_file, var, 0);
+ print_generic_expr (dump_file, var);
fprintf (dump_file, " in ");
print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
}
note_replacement (gimple *stmt, tree old_rhs, tree new_rhs)
{
fprintf (dump_file, "Replacing use of ");
- print_generic_expr (dump_file, old_rhs, 0);
+ print_generic_expr (dump_file, old_rhs);
fprintf (dump_file, " with ");
- print_generic_expr (dump_file, new_rhs, 0);
+ print_generic_expr (dump_file, new_rhs);
fprintf (dump_file, " in ");
print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
}
{
fprintf (dump_file,
"stmt causes chain termination:\n");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
terminate_and_release_chain (*chain_info);
ret = true;
fprintf (dump_file, "Store %u:\nbitsize:" HOST_WIDE_INT_PRINT_DEC
" bitpos:" HOST_WIDE_INT_PRINT_DEC " val:\n",
i, info->bitsize, info->bitpos);
- print_generic_expr (dump_file, gimple_assign_rhs1 (info->stmt), 0);
+ print_generic_expr (dump_file, gimple_assign_rhs1 (info->stmt));
fprintf (dump_file, "\n------------\n");
}
{
fprintf (dump_file,
"Recording immediate store from stmt:\n");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
(*chain_info)->m_store_info.safe_push (info);
/* If we reach the limit of stores to merge in a chain
{
fprintf (dump_file,
"Starting new chain with statement:\n");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
fprintf (dump_file, "The base object is:\n");
- print_generic_expr (dump_file, base_addr, 0);
+ print_generic_expr (dump_file, base_addr);
fprintf (dump_file, "\n");
}
}
{
fprintf (dump_file, "%3d [%d] ", c->cand_num,
gimple_bb (c->cand_stmt)->index);
- print_gimple_stmt (dump_file, c->cand_stmt, 0, 0);
+ print_gimple_stmt (dump_file, c->cand_stmt, 0);
switch (c->kind)
{
case CAND_MULT:
fputs (" MULT : (", dump_file);
- print_generic_expr (dump_file, c->base_expr, 0);
+ print_generic_expr (dump_file, c->base_expr);
fputs (" + ", dump_file);
print_decs (c->index, dump_file);
fputs (") * ", dump_file);
&& c->stride_type != TREE_TYPE (c->stride))
{
fputs ("(", dump_file);
- print_generic_expr (dump_file, c->stride_type, 0);
+ print_generic_expr (dump_file, c->stride_type);
fputs (")", dump_file);
}
- print_generic_expr (dump_file, c->stride, 0);
+ print_generic_expr (dump_file, c->stride);
fputs (" : ", dump_file);
break;
case CAND_ADD:
fputs (" ADD : ", dump_file);
- print_generic_expr (dump_file, c->base_expr, 0);
+ print_generic_expr (dump_file, c->base_expr);
fputs (" + (", dump_file);
print_decs (c->index, dump_file);
fputs (" * ", dump_file);
&& c->stride_type != TREE_TYPE (c->stride))
{
fputs ("(", dump_file);
- print_generic_expr (dump_file, c->stride_type, 0);
+ print_generic_expr (dump_file, c->stride_type);
fputs (")", dump_file);
}
- print_generic_expr (dump_file, c->stride, 0);
+ print_generic_expr (dump_file, c->stride);
fputs (") : ", dump_file);
break;
case CAND_REF:
fputs (" REF : ", dump_file);
- print_generic_expr (dump_file, c->base_expr, 0);
+ print_generic_expr (dump_file, c->base_expr);
fputs (" + (", dump_file);
- print_generic_expr (dump_file, c->stride, 0);
+ print_generic_expr (dump_file, c->stride);
fputs (") + ", dump_file);
print_decs (c->index, dump_file);
fputs (" : ", dump_file);
break;
case CAND_PHI:
fputs (" PHI : ", dump_file);
- print_generic_expr (dump_file, c->base_expr, 0);
+ print_generic_expr (dump_file, c->base_expr);
fputs (" + (unknown * ", dump_file);
- print_generic_expr (dump_file, c->stride, 0);
+ print_generic_expr (dump_file, c->stride);
fputs (") : ", dump_file);
break;
default:
gcc_unreachable ();
}
- print_generic_expr (dump_file, c->cand_type, 0);
+ print_generic_expr (dump_file, c->cand_type);
fprintf (dump_file, "\n basis: %d dependent: %d sibling: %d\n",
c->basis, c->dependent, c->sibling);
fprintf (dump_file, " next-interp: %d dead-savings: %d\n",
const_cand_chain_t chain = *slot;
cand_chain_t p;
- print_generic_expr (dump_file, chain->base_expr, 0);
+ print_generic_expr (dump_file, chain->base_expr);
fprintf (dump_file, " -> %d", chain->cand->cand_num);
for (p = chain->next; p; p = p->next)
fprintf (dump_file, "\n count: %d", incr_vec[i].count);
fprintf (dump_file, "\n cost: %d", incr_vec[i].cost);
fputs ("\n initializer: ", dump_file);
- print_generic_expr (dump_file, incr_vec[i].initializer, 0);
+ print_generic_expr (dump_file, incr_vec[i].initializer);
fputs ("\n\n", dump_file);
}
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fputs ("Replacing reference: ", dump_file);
- print_gimple_stmt (dump_file, c->cand_stmt, 0, 0);
+ print_gimple_stmt (dump_file, c->cand_stmt, 0);
}
if (gimple_vdef (c->cand_stmt))
if (dump_file && (dump_flags & TDF_DETAILS))
{
fputs ("With: ", dump_file);
- print_gimple_stmt (dump_file, c->cand_stmt, 0, 0);
+ print_gimple_stmt (dump_file, c->cand_stmt, 0);
fputs ("\n", dump_file);
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fputs ("Replacing: ", dump_file);
- print_gimple_stmt (dump_file, c->cand_stmt, 0, 0);
+ print_gimple_stmt (dump_file, c->cand_stmt, 0);
}
if (bump == 0)
if (dump_file && (dump_flags & TDF_DETAILS))
{
fputs ("With: ", dump_file);
- print_gimple_stmt (dump_file, stmt_to_print, 0, 0);
+ print_gimple_stmt (dump_file, stmt_to_print, 0);
fputs ("\n", dump_file);
}
}
{
fprintf (dump_file, "Inserting cast in block %d: ",
insert_bb->index);
- print_gimple_stmt (dump_file, cast_stmt, 0, 0);
+ print_gimple_stmt (dump_file, cast_stmt, 0);
}
fprintf (dump_file, "Inserting in block %d: ", insert_bb->index);
- print_gimple_stmt (dump_file, new_stmt, 0, 0);
+ print_gimple_stmt (dump_file, new_stmt, 0);
}
return lhs;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fputs ("Introducing new phi basis: ", dump_file);
- print_gimple_stmt (dump_file, phi, 0, 0);
+ print_gimple_stmt (dump_file, phi, 0);
}
return name;
if (cast_stmt)
{
fputs ("Inserting stride cast: ", dump_file);
- print_gimple_stmt (dump_file, cast_stmt, 0, 0);
+ print_gimple_stmt (dump_file, cast_stmt, 0);
}
fputs ("Inserting initializer: ", dump_file);
- print_gimple_stmt (dump_file, init_stmt, 0, 0);
+ print_gimple_stmt (dump_file, init_stmt, 0);
}
}
}
{
fprintf (dump_file, " Conditional candidate %d, phi: ",
c->cand_num);
- print_gimple_stmt (dump_file, phi, 0, 0);
+ print_gimple_stmt (dump_file, phi, 0);
fputs (" increment: ", dump_file);
print_decs (increment, dump_file);
if (j < 0)
if (dump_file && (dump_flags & TDF_DETAILS))
{
fputs (" Inserting: ", dump_file);
- print_gimple_stmt (dump_file, cast_stmt, 0, 0);
+ print_gimple_stmt (dump_file, cast_stmt, 0);
}
return cast_lhs;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fputs ("Replacing: ", dump_file);
- print_gimple_stmt (dump_file, c->cand_stmt, 0, 0);
+ print_gimple_stmt (dump_file, c->cand_stmt, 0);
stmt_to_print = c->cand_stmt;
}
if (dump_file && (dump_flags & TDF_DETAILS) && stmt_to_print)
{
fputs ("With: ", dump_file);
- print_gimple_stmt (dump_file, stmt_to_print, 0, 0);
+ print_gimple_stmt (dump_file, stmt_to_print, 0);
fputs ("\n", dump_file);
}
}
if (!(fallback & fb_mayfail))
{
fprintf (stderr, "gimplification failed:\n");
- print_generic_expr (stderr, *expr_p, 0);
+ print_generic_expr (stderr, *expr_p);
debug_tree (*expr_p);
internal_error ("gimplification failed");
}
if (dump_file)
{
fprintf (dump_file, "[codegen] rename not in loop closed ssa: ");
- print_generic_expr (dump_file, rename, 0);
+ print_generic_expr (dump_file, rename);
fprintf (dump_file, "\n");
}
return false;
if (dump_file)
{
fprintf (dump_file, "[codegen] setting rename: old_name = ");
- print_generic_expr (dump_file, old_name, 0);
+ print_generic_expr (dump_file, old_name);
fprintf (dump_file, ", new_name = ");
- print_generic_expr (dump_file, expr, 0);
+ print_generic_expr (dump_file, expr);
fprintf (dump_file, "\n");
}
if (dump_file)
{
fprintf (dump_file, "[codegen] renaming uses of stmt: ");
- print_gimple_stmt (dump_file, copy, 0, 0);
+ print_gimple_stmt (dump_file, copy, 0);
}
use_operand_p use_p;
if (dump_file)
{
fprintf (dump_file, "[codegen] renaming old_name = ");
- print_generic_expr (dump_file, old_name, 0);
+ print_generic_expr (dump_file, old_name);
fprintf (dump_file, "\n");
}
if (dump_file)
{
fprintf (dump_file, "[codegen] from rename_map: new_name = ");
- print_generic_expr (dump_file, new_expr, 0);
+ print_generic_expr (dump_file, new_expr);
fprintf (dump_file, "\n");
}
if (dump_file)
{
fprintf (dump_file, "[codegen] not in rename map, scev: ");
- print_generic_expr (dump_file, new_expr, 0);
+ print_generic_expr (dump_file, new_expr);
fprintf (dump_file, "\n");
}
if (dump_file)
{
fprintf (dump_file, "[codegen] creating loop-phi node: ");
- print_gimple_stmt (dump_file, new_phi, 0, 0);
+ print_gimple_stmt (dump_file, new_phi, 0);
}
}
if (dump_file)
{
fprintf (dump_file, "[codegen] Adding guard-phi: ");
- print_gimple_stmt (dump_file, merge_phi, 0, 0);
+ print_gimple_stmt (dump_file, merge_phi, 0);
}
update_stmt (merge_phi);
if (dump_file)
{
fprintf (dump_file, "[codegen] Adding loop close phi: ");
- print_gimple_stmt (dump_file, new_close_phi, 0, 0);
+ print_gimple_stmt (dump_file, new_close_phi, 0);
}
update_stmt (new_close_phi);
if (dump_file)
{
fprintf (dump_file, "[codegen] postpone close phi nodes: ");
- print_gimple_stmt (dump_file, new_close_phi, 0, 0);
+ print_gimple_stmt (dump_file, new_close_phi, 0);
}
continue;
}
{
fprintf (dump_file,
"[codegen] parameter argument to phi, new_expr: ");
- print_generic_expr (dump_file, new_phi_args[i], 0);
+ print_generic_expr (dump_file, new_phi_args[i]);
fprintf (dump_file, "\n");
}
continue;
{
fprintf (dump_file,
"[codegen] scev analyzeable, new_expr: ");
- print_generic_expr (dump_file, new_expr, 0);
+ print_generic_expr (dump_file, new_expr);
fprintf (dump_file, "\n");
}
gsi_insert_earliest (stmts);
if (dump_file)
{
fprintf (dump_file, "[codegen] postpone cond phi nodes: ");
- print_gimple_stmt (dump_file, new_phi, 0, 0);
+ print_gimple_stmt (dump_file, new_phi, 0);
}
new_phi_args [i] = NULL_TREE;
if (dump_file)
{
fprintf (dump_file, "[codegen] inserting statement: ");
- print_gimple_stmt (dump_file, copy, 0, 0);
+ print_gimple_stmt (dump_file, copy, 0);
}
maybe_duplicate_eh_stmt (copy, stmt);
if (dump_file)
{
fprintf (dump_file, "[codegen] translating pending old-phi: ");
- print_gimple_stmt (dump_file, old_phi, 0, 0);
+ print_gimple_stmt (dump_file, old_phi, 0);
}
auto_vec <tree, 1> iv_map;
if (dump_file)
{
fprintf (dump_file, "[codegen] to new-phi: ");
- print_gimple_stmt (dump_file, new_phi, 0, 0);
+ print_gimple_stmt (dump_file, new_phi, 0);
}
if (codegen_error_p ())
return;
}
fprintf (file, "in gimple stmt: ");
- print_gimple_stmt (file, pdr->stmt, 0, 0);
+ print_gimple_stmt (file, pdr->stmt, 0);
fprintf (file, "data accesses: ");
print_isl_map (file, pdr->accesses);
fprintf (file, "subscript sizes: ");
fprintf (file, "cases bb_%d (\n", GBB_BB (gbb)->index);
FOR_EACH_VEC_ELT (cases, i, stmt)
- print_gimple_stmt (file, stmt, 0, 0);
+ print_gimple_stmt (file, stmt, 0);
fprintf (file, ")\n");
}
fprintf (file, "conditions bb_%d (\n", GBB_BB (gbb)->index);
FOR_EACH_VEC_ELT (conditions, i, stmt)
- print_gimple_stmt (file, stmt, 0, 0);
+ print_gimple_stmt (file, stmt, 0);
fprintf (file, ")\n");
}
fprintf (file, "parameters (");
FOR_EACH_VEC_ELT (scop->scop_info->params, i, t)
{
- print_generic_expr (file, t, 0);
+ print_generic_expr (file, t);
fprintf (file, ", ");
}
fprintf (file, ")\n");
{
writes->safe_push (def);
DEBUG_PRINT (dp << "Adding scalar write: ";
- print_generic_expr (dump_file, def, 0);
+ print_generic_expr (dump_file, def);
dp << "\nFrom stmt: ";
print_gimple_stmt (dump_file,
- SSA_NAME_DEF_STMT (def), 0, 0));
+ SSA_NAME_DEF_STMT (def), 0));
/* This is required by the FOR_EACH_IMM_USE_STMT when we want to break
before all the uses have been visited. */
BREAK_FROM_IMM_USE_STMT (imm_iter);
if (gimple_bb (def_stmt) != gimple_bb (use_stmt))
{
DEBUG_PRINT (dp << "Adding scalar read: ";
- print_generic_expr (dump_file, use, 0);
+ print_generic_expr (dump_file, use);
dp << "\nFrom stmt: ";
- print_gimple_stmt (dump_file, use_stmt, 0, 0));
+ print_gimple_stmt (dump_file, use_stmt, 0));
reads->safe_push (std::make_pair (use_stmt, use));
}
}
dp << "read: ";
else
dp << "write: ";
- print_generic_expr (dump_file, dr->ref, 0);
+ print_generic_expr (dump_file, dr->ref);
dp << "\nFrom stmt: ";
- print_gimple_stmt (dump_file, dr->stmt, 0, 0));
+ print_gimple_stmt (dump_file, dr->stmt, 0));
scop->drs.safe_push (dr_info (dr, pbb));
}
& imm->m_type;
if (imm->m_tree_value)
- print_generic_expr (f, imm->m_tree_value, 0);
+ print_generic_expr (f, imm->m_tree_value);
else
{
if (unsigned_int_type)
&& TREE_CODE (TREE_OPERAND (v, 0)) == CONST_DECL)
{
fprintf (f, "& ");
- print_generic_expr (f, DECL_INITIAL (TREE_OPERAND (v, 0)), 0);
+ print_generic_expr (f, DECL_INITIAL (TREE_OPERAND (v, 0)));
}
else
- print_generic_expr (f, v, 0);
+ print_generic_expr (f, v);
}
/* Print V which is extracted from a value in a lattice to F. */
ipa_dump_param (dump_file, info, parm_num);
fprintf (dump_file, " with const ");
- print_generic_expr (dump_file, value, 0);
+ print_generic_expr (dump_file, value);
fprintf (dump_file, "\n");
}
replace_map->old_tree = NULL;
return;
}
fprintf (f, " %s ", op_symbol_code (c->code));
- print_generic_expr (f, c->val, 1);
+ print_generic_expr (f, c->val);
}
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, " ");
- print_gimple_stmt (dump_file, gsi_stmt (bsi), 0, 0);
+ print_gimple_stmt (dump_file, gsi_stmt (bsi), 0);
}
predicate_for_phi_result (info, bsi.phi (), &phi_predicate,
nonconstant_names);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, " ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
fprintf (dump_file, "\t\tfreq:%3.2f size:%3i time:%3i\n",
((double) freq) / CGRAPH_FREQ_BASE, this_size,
this_time);
if (dump_file)
{
fprintf (dump_file, " Checking constructor call: ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
/* See if THIS parameter seems like instance pointer. */
if (dump_file)
{
fprintf (dump_file, " Function call may change dynamic type:");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
tci->speculative++;
return csftc_abort_walking_p (tci->speculative);
if (dump_file)
{
fprintf (dump_file, " Checking vtbl store: ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
type = extr_type_from_vtbl_ptr_store (stmt, tci, &offset);
if (dump_file)
{
fprintf (dump_file, "Determining dynamic type for call: ");
- print_gimple_stmt (dump_file, call, 0, 0);
+ print_gimple_stmt (dump_file, call, 0);
fprintf (dump_file, " Starting walk at: ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
fprintf (dump_file, " instance pointer: ");
print_generic_expr (dump_file, otr_object, TDF_SLIM);
fprintf (dump_file, " Outer instance pointer: ");
if ((*info->descriptors)[i].decl_or_type)
{
fprintf (file, " ");
- print_generic_expr (file, (*info->descriptors)[i].decl_or_type, 0);
+ print_generic_expr (file, (*info->descriptors)[i].decl_or_type);
}
}
{
tree val = jump_func->value.constant.value;
fprintf (f, "CONST: ");
- print_generic_expr (f, val, 0);
+ print_generic_expr (f, val);
if (TREE_CODE (val) == ADDR_EXPR
&& TREE_CODE (TREE_OPERAND (val, 0)) == CONST_DECL)
{
fprintf (f, " -> ");
- print_generic_expr (f, DECL_INITIAL (TREE_OPERAND (val, 0)),
- 0);
+ print_generic_expr (f, DECL_INITIAL (TREE_OPERAND (val, 0)));
}
fprintf (f, "\n");
}
if (jump_func->value.pass_through.operation != NOP_EXPR)
{
fprintf (f, " ");
- print_generic_expr (f,
- jump_func->value.pass_through.operand, 0);
+ print_generic_expr (f, jump_func->value.pass_through.operand);
}
if (jump_func->value.pass_through.agg_preserved)
fprintf (f, ", agg_preserved");
else
{
fprintf (f, "cst: ");
- print_generic_expr (f, item->value, 0);
+ print_generic_expr (f, item->value);
}
fprintf (f, "\n");
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "replacing stmt:");
- print_gimple_stmt (dump_file, gsi_stmt (gsi), 0, 0);
+ print_gimple_stmt (dump_file, gsi_stmt (gsi), 0);
}
new_stmt = gimple_build_call_vec (callee_decl, vargs);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "with stmt:");
- print_gimple_stmt (dump_file, new_stmt, 0, 0);
+ print_gimple_stmt (dump_file, new_stmt, 0);
fprintf (dump_file, "\n");
}
gsi_replace (&gsi, new_stmt, true);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "About to replace expr ");
- print_generic_expr (dump_file, *expr, 0);
+ print_generic_expr (dump_file, *expr);
fprintf (dump_file, " with ");
- print_generic_expr (dump_file, src, 0);
+ print_generic_expr (dump_file, src);
fprintf (dump_file, "\n");
}
first = false;
fprintf (file, "%i. base_index: %i - ", i, adj->base_index);
- print_generic_expr (file, parms[adj->base_index], 0);
+ print_generic_expr (file, parms[adj->base_index]);
if (adj->base)
{
fprintf (file, ", base: ");
- print_generic_expr (file, adj->base, 0);
+ print_generic_expr (file, adj->base);
}
if (adj->new_decl)
{
fprintf (file, ", new_decl: ");
- print_generic_expr (file, adj->new_decl, 0);
+ print_generic_expr (file, adj->new_decl);
}
if (adj->new_ssa_base)
{
fprintf (file, ", new_ssa_base: ");
- print_generic_expr (file, adj->new_ssa_base, 0);
+ print_generic_expr (file, adj->new_ssa_base);
}
if (adj->op == IPA_PARM_OP_COPY)
{
fprintf (f, "%s %i[" HOST_WIDE_INT_PRINT_DEC "]=", comma ? "," : "",
av->index, av->offset);
- print_generic_expr (f, av->value, 0);
+ print_generic_expr (f, av->value);
comma = true;
}
fprintf (f, "\n");
if (dump_file)
{
fprintf (dump_file, " const ");
- print_generic_expr (dump_file, v->value, 0);
+ print_generic_expr (dump_file, v->value);
fprintf (dump_file, " can't be converted to type of ");
- print_generic_expr (dump_file, rhs, 0);
+ print_generic_expr (dump_file, rhs);
fprintf (dump_file, "\n");
}
continue;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Modifying stmt:\n ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
gimple_assign_set_rhs_from_tree (&gsi, val);
update_stmt (stmt);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "into:\n ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
fprintf (dump_file, "\n");
}
if (dump_file)
{
fprintf (dump_file, " scanning: ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
if (gimple_has_volatile_ops (stmt)
if (dump_file)
{
fprintf (dump_file, "Statement can throw: ");
- print_gimple_stmt (dump_file, gsi_stmt (gsi), 0, 0);
+ print_gimple_stmt (dump_file, gsi_stmt (gsi), 0);
}
return 0;
}
{
fprintf (dump_file, " freq:%6i size:%3i time:%3i ",
freq, this_size, this_time);
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
if ((flag_sanitize & SANITIZE_THREAD)
if (k == kind && stmt != from)
break;
}
- print_gimple_stmt (file, stmt, depth * 2 + 2, 0);
+ print_gimple_stmt (file, stmt, depth * 2 + 2);
gsi_next (&gsi);
while (gsi_end_p (gsi))
LOCATION_FILE (loop->loc), LOCATION_LINE (loop->loc));
if (loop->marker)
- print_gimple_stmt (file, loop->marker, depth * 2, 0);
+ print_gimple_stmt (file, loop->marker, depth * 2);
if (loop->routine)
fprintf (file, "%*sRoutine %s:%u:%s\n",
if (dump_file)
{
fprintf (dump_file, "TM thread private mem logging: ");
- print_generic_expr (dump_file, lp->addr, 0);
+ print_generic_expr (dump_file, lp->addr);
fprintf (dump_file, "\n");
}
fprintf (dump_file, "TM memopt (%s): value num=%d, BB=%d, addr=",
is_tm_load (stmt) ? "LOAD" : "STORE", loc,
gimple_bb (stmt)->index);
- print_generic_expr (dump_file, gimple_call_arg (stmt, 0), 0);
+ print_generic_expr (dump_file, gimple_call_arg (stmt, 0));
fprintf (dump_file, "\n");
}
}
gcc_assert (mem->value_id == i);
fprintf (dump_file, "%s", comma);
comma = ", ";
- print_generic_expr (dump_file, mem->addr, 0);
+ print_generic_expr (dump_file, mem->addr);
}
fprintf (dump_file, "]\n");
}
if (dump_file)
{
fprintf (dump_file, "TM memopt: transforming: ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
fprintf (dump_file, "\n");
}
}
if (prev_stmt && DECL_NONLOCAL (label))
{
error ("nonlocal label ");
- print_generic_expr (stderr, label, 0);
+ print_generic_expr (stderr, label);
fprintf (stderr, " is not first in a sequence of labels in bb %d",
bb->index);
err = 1;
if (prev_stmt && EH_LANDING_PAD_NR (label) != 0)
{
error ("EH landing pad label ");
- print_generic_expr (stderr, label, 0);
+ print_generic_expr (stderr, label);
fprintf (stderr, " is not first in a sequence of labels in bb %d",
bb->index);
err = 1;
if (label_to_block (label) != bb)
{
error ("label ");
- print_generic_expr (stderr, label, 0);
+ print_generic_expr (stderr, label);
fprintf (stderr, " to block does not match in bb %d",
bb->index);
err = 1;
if (decl_function_context (label) != current_function_decl)
{
error ("label ");
- print_generic_expr (stderr, label, 0);
+ print_generic_expr (stderr, label);
fprintf (stderr, " has incorrect context in bb %d",
bb->index);
err = 1;
if (glabel *label_stmt = dyn_cast <glabel *> (stmt))
{
error ("label ");
- print_generic_expr (stderr, gimple_label_label (label_stmt), 0);
+ print_generic_expr (stderr, gimple_label_label (label_stmt));
fprintf (stderr, " in the middle of basic block %d", bb->index);
err = 1;
}
&& !tree_int_cst_lt (CASE_LOW (prev), CASE_LOW (c)))
{
error ("case labels not sorted: ");
- print_generic_expr (stderr, prev, 0);
+ print_generic_expr (stderr, prev);
fprintf (stderr," is greater than ");
- print_generic_expr (stderr, c, 0);
+ print_generic_expr (stderr, c);
fprintf (stderr," but comes before it.\n");
err = 1;
}
else
fprintf (file, ", multiple latches");
fprintf (file, ", niter = ");
- print_generic_expr (file, loop->nb_iterations, 0);
+ print_generic_expr (file, loop->nb_iterations);
if (loop->any_upper_bound)
{
fprintf (dump_file, " + ");
if (addr.pol[n].var == NULL_TREE)
- print_generic_expr (dump_file, addr.pol[n].cst, 0);
+ print_generic_expr (dump_file, addr.pol[n].cst);
else
{
if (TREE_CODE (addr.pol[n].cst) != INTEGER_CST
|| !integer_onep (addr.pol[n].cst))
{
- print_generic_expr (dump_file, addr.pol[n].cst, 0);
+ print_generic_expr (dump_file, addr.pol[n].cst);
fprintf (dump_file, " * ");
}
- print_generic_expr (dump_file, addr.pol[n].var, 0);
+ print_generic_expr (dump_file, addr.pol[n].var);
}
}
}
{
fprintf (dump_file, "Adding check information:\n");
fprintf (dump_file, " bounds: ");
- print_generic_expr (dump_file, ci.bounds, 0);
+ print_generic_expr (dump_file, ci.bounds);
fprintf (dump_file, "\n address: ");
chkp_print_addr (ci.addr);
fprintf (dump_file, "\n check: ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
}
}
{
fprintf (dump_file, "Trying to compute result of the check\n");
fprintf (dump_file, " check: ");
- print_gimple_stmt (dump_file, ci->stmt, 0, 0);
+ print_gimple_stmt (dump_file, ci->stmt, 0);
fprintf (dump_file, " address: ");
chkp_print_addr (ci->addr);
fprintf (dump_file, "\n bounds: ");
- print_generic_expr (dump_file, bounds, 0);
+ print_generic_expr (dump_file, bounds);
fprintf (dump_file, "\n");
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Trying to remove check: ");
- print_gimple_stmt (dump_file, ci->stmt, 0, 0);
+ print_gimple_stmt (dump_file, ci->stmt, 0);
}
result = chkp_get_check_result (ci, ci->bounds);
{
fprintf (dump_file, "Check if bounds intersection is redundant: \n");
fprintf (dump_file, " check: ");
- print_gimple_stmt (dump_file, ci->stmt, 0, 0);
+ print_gimple_stmt (dump_file, ci->stmt, 0);
fprintf (dump_file, " intersection: ");
- print_gimple_stmt (dump_file, bnd_def, 0, 0);
+ print_gimple_stmt (dump_file, bnd_def, 0);
fprintf (dump_file, "\n");
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, " action: use ");
- print_generic_expr (dump_file, bnd2, 0);
+ print_generic_expr (dump_file, bnd2);
fprintf (dump_file, " instead of ");
- print_generic_expr (dump_file, ci->bounds, 0);
+ print_generic_expr (dump_file, ci->bounds);
fprintf (dump_file, "\n");
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Moving creation of ");
- print_generic_expr (dump_file, op, 0);
+ print_generic_expr (dump_file, op);
fprintf (dump_file, " down to its use.\n");
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Regsitered bound ");
- print_generic_expr (dump_file, bnd, 0);
+ print_generic_expr (dump_file, bnd);
fprintf (dump_file, " for address of ");
- print_generic_expr (dump_file, obj, 0);
+ print_generic_expr (dump_file, obj);
fprintf (dump_file, "\n");
}
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Marked bounds ");
- print_generic_expr (dump_file, bounds, 0);
+ print_generic_expr (dump_file, bounds);
fprintf (dump_file, " as completed\n");
}
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Regsitered incomplete bounds ");
- print_generic_expr (dump_file, bounds, 0);
+ print_generic_expr (dump_file, bounds);
fprintf (dump_file, " for ");
- print_generic_expr (dump_file, ptr, 0);
+ print_generic_expr (dump_file, ptr);
fprintf (dump_file, "\n");
}
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Marked bounds ");
- print_generic_expr (dump_file, bounds, 0);
+ print_generic_expr (dump_file, bounds);
fprintf (dump_file, " as invalid\n");
}
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Using default def bounds ");
- print_generic_expr (dump_file, bnd, 0);
+ print_generic_expr (dump_file, bnd);
fprintf (dump_file, " for abnormal default def SSA name ");
- print_generic_expr (dump_file, ptr, 0);
+ print_generic_expr (dump_file, ptr);
fprintf (dump_file, "\n");
}
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Creating a copy of bounds ");
- print_generic_expr (dump_file, bnd, 0);
+ print_generic_expr (dump_file, bnd);
fprintf (dump_file, " for abnormal SSA name ");
- print_generic_expr (dump_file, ptr, 0);
+ print_generic_expr (dump_file, ptr);
fprintf (dump_file, "\n");
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Regsitered bound ");
- print_generic_expr (dump_file, bnd, 0);
+ print_generic_expr (dump_file, bnd);
fprintf (dump_file, " for pointer ");
- print_generic_expr (dump_file, ptr, 0);
+ print_generic_expr (dump_file, ptr);
fprintf (dump_file, "\n");
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Built returned bounds (");
- print_generic_expr (dump_file, bounds, 0);
+ print_generic_expr (dump_file, bounds);
fprintf (dump_file, ") for call: ");
- print_gimple_stmt (dump_file, call, 0, TDF_VOPS|TDF_MEMSYMS);
+ print_gimple_stmt (dump_file, call, 0, TDF_VOPS | TDF_MEMSYMS);
}
bounds = chkp_maybe_copy_and_register_bounds (lhs, bounds);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Built arg bounds (");
- print_generic_expr (dump_file, bounds, 0);
+ print_generic_expr (dump_file, bounds);
fprintf (dump_file, ") for arg: ");
print_node (dump_file, "", decl, 0);
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Using bounds ");
- print_generic_expr (dump_file, bounds, 0);
+ print_generic_expr (dump_file, bounds);
fprintf (dump_file, " for parm ");
- print_generic_expr (dump_file, parm, 0);
+ print_generic_expr (dump_file, parm);
fprintf (dump_file, " of type ");
- print_generic_expr (dump_file, TREE_TYPE (parm), 0);
+ print_generic_expr (dump_file, TREE_TYPE (parm));
fprintf (dump_file, ".\n");
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Generated bndldx for pointer ");
- print_generic_expr (dump_file, ptr, 0);
+ print_generic_expr (dump_file, ptr);
fprintf (dump_file, ": ");
- print_gimple_stmt (dump_file, stmt, 0, TDF_VOPS|TDF_MEMSYMS);
+ print_gimple_stmt (dump_file, stmt, 0, TDF_VOPS | TDF_MEMSYMS);
}
return bounds;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Searching for bounds for node: ");
- print_generic_expr (dump_file, node, 0);
+ print_generic_expr (dump_file, node);
fprintf (dump_file, " using its definition: ");
- print_gimple_stmt (dump_file, def_stmt, 0, TDF_VOPS|TDF_MEMSYMS);
+ print_gimple_stmt (dump_file, def_stmt, 0, TDF_VOPS | TDF_MEMSYMS);
}
switch (code)
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Unexpected var with no definition\n");
- print_generic_expr (dump_file, var, 0);
+ print_generic_expr (dump_file, var);
}
internal_error ("chkp_get_bounds_by_definition: Unexpected var of type %s",
get_tree_code_name (TREE_CODE (var)));
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Generating bounds for extern symbol '");
- print_generic_expr (dump_file, var, 0);
+ print_generic_expr (dump_file, var);
fprintf (dump_file, "'\n");
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Building bounds for address of decl ");
- print_generic_expr (dump_file, decl, 0);
+ print_generic_expr (dump_file, decl);
fprintf (dump_file, "\n");
}
{
fprintf (dump_file, " (varying_loop = %d\n", var);
fprintf (dump_file, ")\n (chrec = ");
- print_generic_expr (dump_file, chrec, 0);
+ print_generic_expr (dump_file, chrec);
fprintf (dump_file, ")\n (x = ");
- print_generic_expr (dump_file, x, 0);
+ print_generic_expr (dump_file, x);
fprintf (dump_file, ")\n (res = ");
- print_generic_expr (dump_file, res, 0);
+ print_generic_expr (dump_file, res);
fprintf (dump_file, "))\n");
}
fprintf (outf, "#(Data Ref: \n");
fprintf (outf, "# bb: %d \n", gimple_bb (DR_STMT (dr))->index);
fprintf (outf, "# stmt: ");
- print_gimple_stmt (outf, DR_STMT (dr), 0, 0);
+ print_gimple_stmt (outf, DR_STMT (dr), 0);
fprintf (outf, "# ref: ");
- print_generic_stmt (outf, DR_REF (dr), 0);
+ print_generic_stmt (outf, DR_REF (dr));
fprintf (outf, "# base_object: ");
- print_generic_stmt (outf, DR_BASE_OBJECT (dr), 0);
+ print_generic_stmt (outf, DR_BASE_OBJECT (dr));
for (i = 0; i < DR_NUM_DIMENSIONS (dr); i++)
{
fprintf (outf, "# Access function %d: ", i);
- print_generic_stmt (outf, DR_ACCESS_FN (dr, i), 0);
+ print_generic_stmt (outf, DR_ACCESS_FN (dr, i));
}
fprintf (outf, "#)\n");
}
{
tree last_iteration = SUB_LAST_CONFLICT (subscript);
fprintf (outf, "\n last_conflict: ");
- print_generic_expr (outf, last_iteration, 0);
+ print_generic_expr (outf, last_iteration);
}
cf = SUB_CONFLICTS_IN_B (subscript);
{
tree last_iteration = SUB_LAST_CONFLICT (subscript);
fprintf (outf, "\n last_conflict: ");
- print_generic_expr (outf, last_iteration, 0);
+ print_generic_expr (outf, last_iteration);
}
fprintf (outf, "\n (Subscript distance: ");
- print_generic_expr (outf, SUB_DISTANCE (subscript), 0);
+ print_generic_expr (outf, SUB_DISTANCE (subscript));
fprintf (outf, " ))\n");
}
for (i = 0; i < DDR_NUM_SUBSCRIPTS (ddr); i++)
{
fprintf (outf, " access_fn_A: ");
- print_generic_stmt (outf, DR_ACCESS_FN (dra, i), 0);
+ print_generic_stmt (outf, DR_ACCESS_FN (dra, i));
fprintf (outf, " access_fn_B: ");
- print_generic_stmt (outf, DR_ACCESS_FN (drb, i), 0);
+ print_generic_stmt (outf, DR_ACCESS_FN (drb, i));
dump_subscript (outf, DDR_SUBSCRIPT (ddr, i));
}
{
fprintf (dump_file, "(analyze_overlapping_iterations \n");
fprintf (dump_file, " (chrec_a = ");
- print_generic_expr (dump_file, chrec_a, 0);
+ print_generic_expr (dump_file, chrec_a);
fprintf (dump_file, ")\n (chrec_b = ");
- print_generic_expr (dump_file, chrec_b, 0);
+ print_generic_expr (dump_file, chrec_b);
fprintf (dump_file, ")\n");
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Inlining ");
- print_generic_expr (dump_file, id->src_fn, 0);
+ print_generic_expr (dump_file, id->src_fn);
fprintf (dump_file, " to ");
- print_generic_expr (dump_file, id->dst_fn, 0);
+ print_generic_expr (dump_file, id->dst_fn);
fprintf (dump_file, " with frequency %i\n", cg_edge->frequency);
}
{
fprintf (dump_file, " const ");
print_generic_expr (dump_file,
- replace_info->new_tree, 0);
+ replace_info->new_tree);
fprintf (dump_file,
" can't be converted to param ");
- print_generic_expr (dump_file, parm, 0);
+ print_generic_expr (dump_file, parm);
fprintf (dump_file, "\n");
}
replace_info->old_tree = NULL;
}
fprintf (file, " Previous CURRDEF (");
- print_generic_expr (file, var, 0);
+ print_generic_expr (file, var);
fprintf (file, ") = ");
if (name)
- print_generic_expr (file, name, 0);
+ print_generic_expr (file, name);
else
fprintf (file, "<NIL>");
fprintf (file, "\n");
{
common_info *info = get_common_info (var);
fprintf (file, "CURRDEF (");
- print_generic_expr (file, var, 0);
+ print_generic_expr (file, var);
fprintf (file, ") = ");
if (info->current_def)
- print_generic_expr (file, info->current_def, 0);
+ print_generic_expr (file, info->current_def);
else
fprintf (file, "<NIL>");
fprintf (file, "\n");
bitmap old_set;
bitmap_iterator bi;
- print_generic_expr (file, name, 0);
+ print_generic_expr (file, name);
fprintf (file, " -> { ");
old_set = names_replaced_by (name);
EXECUTE_IF_SET_IN_BITMAP (old_set, 0, i, bi)
{
- print_generic_expr (file, ssa_name (i), 0);
+ print_generic_expr (file, ssa_name (i));
fprintf (file, " ");
}
fprintf (file, "\nSSA names to release after updating the SSA web\n\n");
EXECUTE_IF_SET_IN_BITMAP (names_to_release, 0, i, bi)
{
- print_generic_expr (file, ssa_name (i), 0);
+ print_generic_expr (file, ssa_name (i));
fprintf (file, " ");
}
fprintf (file, "\n");
error ("statement uses released SSA name:");
debug_gimple_stmt (stmt);
fprintf (stderr, "The use of ");
- print_generic_expr (stderr, use, 0);
+ print_generic_expr (stderr, use);
fprintf (stderr," should have been replaced\n");
err = true;
}
fprintf (dump_file, "Simplified\n ");
print_gimple_stmt (dump_file, call, 0, dump_flags);
fprintf (dump_file, " to ");
- print_generic_expr (dump_file, result, 0);
+ print_generic_expr (dump_file, result);
fprintf (dump_file, "\n");
}
{
fprintf (dump_file,
"Detected reduction. reduction stmt is:\n");
- print_gimple_stmt (dump_file, reduc_stmt, 0, 0);
+ print_gimple_stmt (dump_file, reduc_stmt, 0);
fprintf (dump_file, "\n");
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "phi is ");
- print_gimple_stmt (dump_file, phi, 0, 0);
+ print_gimple_stmt (dump_file, phi, 0);
fprintf (dump_file, "arg of phi to exit: value ");
- print_generic_expr (dump_file, val, 0);
+ print_generic_expr (dump_file, val);
fprintf (dump_file, " used outside loop\n");
fprintf (dump_file,
" checking if it is part of reduction pattern:\n");
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "reduction phi is ");
- print_gimple_stmt (dump_file, red->reduc_phi, 0, 0);
+ print_gimple_stmt (dump_file, red->reduc_phi, 0);
fprintf (dump_file, "reduction stmt is ");
- print_gimple_stmt (dump_file, red->reduc_stmt, 0, 0);
+ print_gimple_stmt (dump_file, red->reduc_stmt, 0);
}
}
}
if (dump_file)
{
fprintf (dump_file, "skipping reduction store: ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
continue;
}
if (dump_file)
{
fprintf (dump_file, "Stmt ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
return true;
}
if (dump_file)
{
fprintf (dump_file, "Stmt ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
return true;
}
if (dump_file)
{
fprintf (dump_file, "found reduction load: ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
}
}
if (dump_file)
{
fprintf (dump_file, "Unhandled stmt in entry/exit: ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
return false;
}
if (dump_file)
{
fprintf (dump_file, "conflicts with entry/exit stmt: ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
return false;
}
fprintf (dump_file,
"skipped reduction store for single-gang"
" neutering: ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
/* Update gsi to point to next stmt. */
{
fprintf (dump_file,
"found store that needs single-gang neutering: ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
{
extern void debug_generic_stmt (tree);
extern void debug_tree_chain (tree);
extern void print_generic_decl (FILE *, tree, int);
-extern void print_generic_stmt (FILE *, tree, int);
+extern void print_generic_stmt (FILE *, tree, int = 0);
extern void print_generic_stmt_indented (FILE *, tree, int, int);
-extern void print_generic_expr (FILE *, tree, int);
+extern void print_generic_expr (FILE *, tree, int = 0);
extern void dump_omp_clauses (pretty_printer *, tree, int, int);
extern int dump_generic_node (pretty_printer *, tree, int, int, bool);
extern void print_declaration (pretty_printer *, tree, int, int);
fprintf (dump_file, " instantiated_below = %d \n",
instantiated_below->index);
fprintf (dump_file, " (scalar = ");
- print_generic_expr (dump_file, scalar, 0);
+ print_generic_expr (dump_file, scalar);
fprintf (dump_file, ")\n (scalar_evolution = ");
- print_generic_expr (dump_file, chrec, 0);
+ print_generic_expr (dump_file, chrec);
fprintf (dump_file, "))\n");
}
if (dump_flags & TDF_STATS)
{
fprintf (dump_file, "(get_scalar_evolution \n");
fprintf (dump_file, " (scalar = ");
- print_generic_expr (dump_file, scalar, 0);
+ print_generic_expr (dump_file, scalar);
fprintf (dump_file, ")\n");
}
if (dump_flags & TDF_STATS)
if (dump_file && (dump_flags & TDF_SCEV))
{
fprintf (dump_file, " (scalar_evolution = ");
- print_generic_expr (dump_file, res, 0);
+ print_generic_expr (dump_file, res);
fprintf (dump_file, "))\n");
}
fprintf (dump_file, "(add_to_evolution \n");
fprintf (dump_file, " (loop_nb = %d)\n", loop_nb);
fprintf (dump_file, " (chrec_before = ");
- print_generic_expr (dump_file, chrec_before, 0);
+ print_generic_expr (dump_file, chrec_before);
fprintf (dump_file, ")\n (to_add = ");
- print_generic_expr (dump_file, to_add, 0);
+ print_generic_expr (dump_file, to_add);
fprintf (dump_file, ")\n");
}
if (dump_file && (dump_flags & TDF_SCEV))
{
fprintf (dump_file, " (res = ");
- print_generic_expr (dump_file, res, 0);
+ print_generic_expr (dump_file, res);
fprintf (dump_file, "))\n");
}
if (dump_file && (dump_flags & TDF_SCEV))
{
- print_gimple_stmt (dump_file, res, 0, 0);
+ print_gimple_stmt (dump_file, res, 0);
fprintf (dump_file, ")\n");
}
{
fprintf (dump_file, "(analyze_evolution_in_loop \n");
fprintf (dump_file, " (loop_phi_node = ");
- print_gimple_stmt (dump_file, loop_phi_node, 0, 0);
+ print_gimple_stmt (dump_file, loop_phi_node, 0);
fprintf (dump_file, ")\n");
}
if (dump_file && (dump_flags & TDF_SCEV))
{
fprintf (dump_file, " (evolution_function = ");
- print_generic_expr (dump_file, evolution_function, 0);
+ print_generic_expr (dump_file, evolution_function);
fprintf (dump_file, "))\n");
}
{
fprintf (dump_file, "(analyze_initial_condition \n");
fprintf (dump_file, " (loop_phi_node = \n");
- print_gimple_stmt (dump_file, loop_phi_node, 0, 0);
+ print_gimple_stmt (dump_file, loop_phi_node, 0);
fprintf (dump_file, ")\n");
}
if (dump_file && (dump_flags & TDF_SCEV))
{
fprintf (dump_file, " (init_cond = ");
- print_generic_expr (dump_file, init_cond, 0);
+ print_generic_expr (dump_file, init_cond);
fprintf (dump_file, "))\n");
}
fprintf (dump_file, "(analyze_scalar_evolution \n");
fprintf (dump_file, " (loop_nb = %d)\n", loop->num);
fprintf (dump_file, " (scalar = ");
- print_generic_expr (dump_file, var, 0);
+ print_generic_expr (dump_file, var);
fprintf (dump_file, ")\n");
}
fprintf (dump_file, " (instantiate_below = %d)\n", instantiate_below->index);
fprintf (dump_file, " (evolution_loop = %d)\n", evolution_loop->num);
fprintf (dump_file, " (chrec = ");
- print_generic_expr (dump_file, chrec, 0);
+ print_generic_expr (dump_file, chrec);
fprintf (dump_file, ")\n");
}
if (dump_file && (dump_flags & TDF_SCEV))
{
fprintf (dump_file, " (res = ");
- print_generic_expr (dump_file, res, 0);
+ print_generic_expr (dump_file, res);
fprintf (dump_file, "))\n");
}
if (dump_file && (dump_flags & TDF_SCEV))
{
fprintf (dump_file, " (set_nb_iterations_in_loop = ");
- print_generic_expr (dump_file, res, 0);
+ print_generic_expr (dump_file, res);
fprintf (dump_file, "))\n");
}
if (dump_file && (dump_flags & TDF_STATS))
{
fprintf (dump_file, "(classify_chrec ");
- print_generic_expr (dump_file, chrec, 0);
+ print_generic_expr (dump_file, chrec);
fprintf (dump_file, "\n");
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "not replacing:\n ");
- print_gimple_stmt (dump_file, phi, 0, 0);
+ print_gimple_stmt (dump_file, phi, 0);
fprintf (dump_file, "\n");
}
gsi_next (&psi);
if (dump_file)
{
fprintf (dump_file, "\nfinal value replacement:\n ");
- print_gimple_stmt (dump_file, phi, 0, 0);
+ print_gimple_stmt (dump_file, phi, 0);
fprintf (dump_file, " with\n ");
}
def = unshare_expr (def);
gsi_insert_before (&gsi, ass, GSI_SAME_STMT);
if (dump_file)
{
- print_gimple_stmt (dump_file, ass, 0, 0);
+ print_gimple_stmt (dump_file, ass, 0);
fprintf (dump_file, "\n");
}
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Replacing uses of: ");
- print_generic_expr (dump_file, name, 0);
+ print_generic_expr (dump_file, name);
fprintf (dump_file, " with: ");
- print_generic_expr (dump_file, ev, 0);
+ print_generic_expr (dump_file, ev);
fprintf (dump_file, "\n");
}
replace_uses_by (name, ev);
{
fprintf (f, "access { ");
fprintf (f, "base = (%d)'", DECL_UID (access->base));
- print_generic_expr (f, access->base, 0);
+ print_generic_expr (f, access->base);
fprintf (f, "', offset = " HOST_WIDE_INT_PRINT_DEC, access->offset);
fprintf (f, ", size = " HOST_WIDE_INT_PRINT_DEC, access->size);
fprintf (f, ", expr = ");
- print_generic_expr (f, access->expr, 0);
+ print_generic_expr (f, access->expr);
fprintf (f, ", type = ");
- print_generic_expr (f, access->type, 0);
+ print_generic_expr (f, access->type);
fprintf (f, ", non_addressable = %d, reverse = %d",
access->non_addressable, access->reverse);
if (grp)
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "! Disqualifying ");
- print_generic_expr (dump_file, decl, 0);
+ print_generic_expr (dump_file, decl);
fprintf (dump_file, " - %s\n", reason);
}
multi-element arrays in their own right). */
fprintf (dump_file, "Allowing non-reg-type load of part"
" of constant-pool entry: ");
- print_generic_expr (dump_file, expr, 0);
+ print_generic_expr (dump_file, expr);
}
maybe_add_sra_candidate (base);
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Rejected (%d): %s: ", DECL_UID (var), msg);
- print_generic_expr (dump_file, var, 0);
+ print_generic_expr (dump_file, var);
fprintf (dump_file, "\n");
}
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Candidate (%d): ", DECL_UID (var));
- print_generic_expr (dump_file, var, 0);
+ print_generic_expr (dump_file, var);
fprintf (dump_file, "\n");
}
if (access->grp_to_be_debug_replaced)
{
fprintf (dump_file, "Created a debug-only replacement for ");
- print_generic_expr (dump_file, access->base, 0);
+ print_generic_expr (dump_file, access->base);
fprintf (dump_file, " offset: %u, size: %u\n",
(unsigned) access->offset, (unsigned) access->size);
}
else
{
fprintf (dump_file, "Created a replacement for ");
- print_generic_expr (dump_file, access->base, 0);
+ print_generic_expr (dump_file, access->base);
fprintf (dump_file, " offset: %u, size: %u: ",
(unsigned) access->offset, (unsigned) access->size);
- print_generic_expr (dump_file, repl, 0);
+ print_generic_expr (dump_file, repl);
fprintf (dump_file, "\n");
}
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Changing the type of a replacement for ");
- print_generic_expr (dump_file, root->base, 0);
+ print_generic_expr (dump_file, root->base);
fprintf (dump_file, " offset: %u, size: %u ",
(unsigned) root->offset, (unsigned) root->size);
fprintf (dump_file, " to an integer.\n");
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Will attempt to totally scalarize ");
- print_generic_expr (dump_file, var, 0);
+ print_generic_expr (dump_file, var);
fprintf (dump_file, " (UID: %u): \n", DECL_UID (var));
}
}
else if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Too big to totally scalarize: ");
- print_generic_expr (dump_file, var, 0);
+ print_generic_expr (dump_file, var);
fprintf (dump_file, " (UID: %u)\n", DECL_UID (var));
}
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "\nAccess trees for ");
- print_generic_expr (dump_file, var, 0);
+ print_generic_expr (dump_file, var);
fprintf (dump_file, " (UID: %u): \n", DECL_UID (var));
dump_access_tree (dump_file, access);
fprintf (dump_file, "\n");
if (dump_file)
{
fprintf (dump_file, "Removing load: ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
generate_subtree_copies (racc->first_child, lhs,
racc->offset, 0, 0, gsi,
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Generating constant initializer: ");
- print_gimple_stmt (dump_file, stmt, 0, 1);
+ print_gimple_stmt (dump_file, stmt, 0);
fprintf (dump_file, "\n");
}
gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Candidate (%d): ", DECL_UID (parm));
- print_generic_expr (dump_file, parm, 0);
+ print_generic_expr (dump_file, parm);
fprintf (dump_file, "\n");
}
}
{
struct access *acc;
fprintf (dump_file, "Evaluating PARAM group sizes for ");
- print_generic_expr (dump_file, parm, 0);
+ print_generic_expr (dump_file, parm);
fprintf (dump_file, " (UID: %u): \n", DECL_UID (parm));
for (acc = repr; acc; acc = acc->next_grp)
dump_access (dump_file, acc, true);
if (dump_file)
{
fprintf (dump_file, "replacing an SSA name of a removed param ");
- print_generic_expr (dump_file, old_name, 0);
+ print_generic_expr (dump_file, old_name);
fprintf (dump_file, " with ");
- print_generic_expr (dump_file, new_name, 0);
+ print_generic_expr (dump_file, new_name);
fprintf (dump_file, "\n");
}
if (dump_file)
{
fprintf (dump_file, "Folding predicate ");
- print_gimple_expr (dump_file, stmt, 0, 0);
+ print_gimple_expr (dump_file, stmt, 0);
fprintf (dump_file, " to ");
- print_generic_expr (dump_file, val.value, 0);
+ print_generic_expr (dump_file, val.value);
fprintf (dump_file, "\n");
}
val = copy_of[SSA_NAME_VERSION (var)].value;
fprintf (file, " copy-of chain: ");
- print_generic_expr (file, var, 0);
+ print_generic_expr (file, var);
fprintf (file, " ");
if (!val)
fprintf (file, "[UNDEFINED]");
else
{
fprintf (file, "-> ");
- print_generic_expr (file, val, 0);
+ print_generic_expr (file, val);
fprintf (file, " ");
fprintf (file, "[COPY]");
}
{
fprintf (dump_file, "Trying to determine truth value of ");
fprintf (dump_file, "predicate ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
/* Fold COND and see whether we get a useful result. */
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "marking necessary through ");
- print_generic_expr (dump_file, op, 0);
+ print_generic_expr (dump_file, op);
fprintf (dump_file, " stmt ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
gimple_set_plf (stmt, STMT_NECESSARY, true);
if (dump_file && dump_flags & TDF_DETAILS)
{
fprintf (dump_file, "Fixing up noreturn call ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
fprintf (dump_file, "\n");
}
fixup_noreturn_call (stmt);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "==== ASGN ");
- print_generic_expr (dump_file, lhs, 0);
+ print_generic_expr (dump_file, lhs);
fprintf (dump_file, " = ");
- print_generic_expr (dump_file, rhs, 0);
+ print_generic_expr (dump_file, rhs);
fprintf (dump_file, "\n");
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "==== ASGN ");
- print_generic_expr (dump_file, lhs, 0);
+ print_generic_expr (dump_file, lhs);
fprintf (dump_file, " = ");
- print_generic_expr (dump_file, new_rhs, 0);
+ print_generic_expr (dump_file, new_rhs);
fprintf (dump_file, "\n");
}
{
fprintf (dump_file, " Trimming statement (head = %d, tail = %d): ",
*trim_head, *trim_tail);
- print_gimple_stmt (dump_file, stmt, dump_flags, 0);
+ print_gimple_stmt (dump_file, stmt, 0, dump_flags);
fprintf (dump_file, "\n");
}
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, " Deleted dead call: ");
- print_gimple_stmt (dump_file, stmt, dump_flags, 0);
+ print_gimple_stmt (dump_file, stmt, 0, dump_flags);
fprintf (dump_file, "\n");
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, " Deleted dead store: ");
- print_gimple_stmt (dump_file, stmt, dump_flags, 0);
+ print_gimple_stmt (dump_file, stmt, 0, dump_flags);
fprintf (dump_file, "\n");
}
if (dump_file && tmp)
{
fprintf (dump_file, " Replaced '");
- print_gimple_expr (dump_file, stmt, 0, 0);
+ print_gimple_expr (dump_file, stmt, 0);
fprintf (dump_file, "' with '");
- print_generic_expr (dump_file, tmp, 0);
+ print_generic_expr (dump_file, tmp);
fprintf (dump_file, "'\n");
}
if (dump_file && tmp)
{
fprintf (dump_file, " Replaced '");
- print_generic_expr (dump_file, cond, 0);
+ print_generic_expr (dump_file, cond);
fprintf (dump_file, "' with '");
- print_generic_expr (dump_file, tmp, 0);
+ print_generic_expr (dump_file, tmp);
fprintf (dump_file, "'\n");
}
if (dump_file && dump_flags & TDF_DETAILS)
{
fprintf (dump_file, "Fixing up noreturn call ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
fprintf (dump_file, "\n");
}
cfg_changed |= fixup_noreturn_call (stmt);
if (dump_file)
{
fprintf (dump_file, "optimizing double bit test to ");
- print_generic_expr (dump_file, name1, 0);
+ print_generic_expr (dump_file, name1);
fprintf (dump_file, " & T == T\nwith temporary T = (1 << ");
- print_generic_expr (dump_file, bit1, 0);
+ print_generic_expr (dump_file, bit1);
fprintf (dump_file, ") | (1 << ");
- print_generic_expr (dump_file, bit2, 0);
+ print_generic_expr (dump_file, bit2);
fprintf (dump_file, ")\n");
}
if (dump_file)
{
fprintf (dump_file, "optimizing bits or bits test to ");
- print_generic_expr (dump_file, name1, 0);
+ print_generic_expr (dump_file, name1);
fprintf (dump_file, " & T != 0\nwith temporary T = ");
- print_generic_expr (dump_file, bits1, 0);
+ print_generic_expr (dump_file, bits1);
fprintf (dump_file, " | ");
- print_generic_expr (dump_file, bits2, 0);
+ print_generic_expr (dump_file, bits2);
fprintf (dump_file, "\n");
}
if (dump_file)
{
fprintf (dump_file, "optimizing two comparisons to ");
- print_generic_expr (dump_file, t, 0);
+ print_generic_expr (dump_file, t);
fprintf (dump_file, "\n");
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
- print_gimple_stmt (dump_file, stmt, 2, 0);
+ print_gimple_stmt (dump_file, stmt, 2);
fprintf (dump_file, " invariant up to level %d, cost %d.\n\n",
loop_depth (lim_data->max_loop),
lim_data->cost);
if (dump_file && (dump_flags & TDF_DETAILS))
{
- print_gimple_stmt (dump_file, stmt, 2, 0);
+ print_gimple_stmt (dump_file, stmt, 2);
fprintf (dump_file, " invariant up to level %d, cost %d.\n\n",
loop_depth (lim_data->max_loop),
lim_data->cost);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Moving PHI node\n");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
fprintf (dump_file, "(cost %u) out of loop %d.\n\n",
cost, level->num);
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Moving statement\n");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
fprintf (dump_file, "(cost %u) out of loop %d.\n\n",
cost, level->num);
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Executing store motion of ");
- print_generic_expr (dump_file, ref->mem.ref, 0);
+ print_generic_expr (dump_file, ref->mem.ref);
fprintf (dump_file, " from loop %d\n", loop->num);
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, " size: %3i ", num);
- print_gimple_stmt (dump_file, gsi_stmt (gsi), 0, 0);
+ print_gimple_stmt (dump_file, gsi_stmt (gsi), 0);
}
/* Look for reasons why we might optimize this stmt away. */
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Forced statement unreachable: ");
- print_gimple_stmt (dump_file, elt->stmt, 0, 0);
+ print_gimple_stmt (dump_file, elt->stmt, 0);
}
}
/* If we know the exit will be taken after peeling, update. */
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Forced exit to be taken: ");
- print_gimple_stmt (dump_file, elt->stmt, 0, 0);
+ print_gimple_stmt (dump_file, elt->stmt, 0);
}
if (!loop_exit_edge_p (loop, exit_edge))
exit_edge = EDGE_SUCC (bb, 1);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Removed pointless exit: ");
- print_gimple_stmt (dump_file, elt->stmt, 0, 0);
+ print_gimple_stmt (dump_file, elt->stmt, 0);
}
gcond *cond_stmt = as_a <gcond *> (elt->stmt);
if (exit_edge->flags & EDGE_TRUE_VALUE)
{
fprintf (file, " Use %d.%d:\n", use->group_id, use->id);
fprintf (file, " At stmt:\t");
- print_gimple_stmt (file, use->stmt, 0, 0);
+ print_gimple_stmt (file, use->stmt, 0);
fprintf (file, " At pos:\t");
if (use->op_p)
print_generic_expr (file, *use->op_p, TDF_SLIM);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Reordering \n");
- print_gimple_stmt (dump_file, iv_update, 0, 0);
- print_gimple_stmt (dump_file, use->stmt, 0, 0);
+ print_gimple_stmt (dump_file, iv_update, 0);
+ print_gimple_stmt (dump_file, use->stmt, 0);
fprintf (dump_file, "\n");
}
fprintf (dump_file,
"%d bit load in target endianness found at: ",
(int) n->range);
- print_gimple_stmt (dump_file, cur_stmt, 0, 0);
+ print_gimple_stmt (dump_file, cur_stmt, 0);
}
return true;
}
{
fprintf (dump_file, "%d bit bswap implementation found at: ",
(int) n->range);
- print_gimple_stmt (dump_file, cur_stmt, 0, 0);
+ print_gimple_stmt (dump_file, cur_stmt, 0);
}
gsi_insert_after (&gsi, bswap_stmt, GSI_SAME_STMT);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "PHI ");
- print_generic_expr (dump_file, gimple_phi_result (phi), 0);
+ print_generic_expr (dump_file, gimple_phi_result (phi));
fprintf (dump_file,
" changed to factor conversion out from COND_EXPR.\n");
fprintf (dump_file, "New stmt with CAST that defines ");
- print_generic_expr (dump_file, result, 0);
+ print_generic_expr (dump_file, result);
fprintf (dump_file, ".\n");
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "PHI ");
- print_generic_expr (dump_file, gimple_phi_result (phi), 0);
+ print_generic_expr (dump_file, gimple_phi_result (phi));
fprintf (dump_file, " reduced for COND_EXPR in block %d to ",
cond_bb->index);
- print_generic_expr (dump_file, arg, 0);
+ print_generic_expr (dump_file, arg);
fprintf (dump_file, ".\n");
}
return 1;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Inserting PHI for result of load ");
- print_gimple_stmt (dump_file, use_stmt, 0, 0);
+ print_gimple_stmt (dump_file, use_stmt, 0);
}
/* Add PHI arguments for each edge inserting loads of the
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, " for edge defining ");
- print_generic_expr (dump_file, PHI_ARG_DEF_FROM_EDGE (phi, e), 0);
+ print_generic_expr (dump_file, PHI_ARG_DEF_FROM_EDGE (phi, e));
fprintf (dump_file, " reusing PHI result ");
print_generic_expr (dump_file,
- phivn[SSA_NAME_VERSION (old_arg)].value, 0);
+ phivn[SSA_NAME_VERSION (old_arg)].value);
fprintf (dump_file, "\n");
}
/* Reuse a formerly created dereference. */
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, " for edge defining ");
- print_generic_expr (dump_file, PHI_ARG_DEF_FROM_EDGE (phi, e), 0);
+ print_generic_expr (dump_file, PHI_ARG_DEF_FROM_EDGE (phi, e));
fprintf (dump_file, " inserting load ");
- print_gimple_stmt (dump_file, tmp, 0, 0);
+ print_gimple_stmt (dump_file, tmp, 0);
}
}
update_stmt (new_phi);
if (dump_file && (dump_flags & TDF_DETAILS))
- print_gimple_stmt (dump_file, new_phi, 0, 0);
+ print_gimple_stmt (dump_file, new_phi, 0);
}
return res;
switch (expr->kind)
{
case CONSTANT:
- print_generic_expr (outfile, PRE_EXPR_CONSTANT (expr), 0);
+ print_generic_expr (outfile, PRE_EXPR_CONSTANT (expr));
break;
case NAME:
- print_generic_expr (outfile, PRE_EXPR_NAME (expr), 0);
+ print_generic_expr (outfile, PRE_EXPR_NAME (expr));
break;
case NARY:
{
fprintf (outfile, "{%s,", get_tree_code_name (nary->opcode));
for (i = 0; i < nary->length; i++)
{
- print_generic_expr (outfile, nary->op[i], 0);
+ print_generic_expr (outfile, nary->op[i]);
if (i != (unsigned) nary->length - 1)
fprintf (outfile, ",");
}
}
if (vro->op0)
{
- print_generic_expr (outfile, vro->op0, 0);
+ print_generic_expr (outfile, vro->op0);
if (vro->op1)
{
fprintf (outfile, ",");
- print_generic_expr (outfile, vro->op1, 0);
+ print_generic_expr (outfile, vro->op1);
}
if (vro->op2)
{
fprintf (outfile, ",");
- print_generic_expr (outfile, vro->op2, 0);
+ print_generic_expr (outfile, vro->op2);
}
}
if (closebrace)
if (ref->vuse)
{
fprintf (outfile, "@");
- print_generic_expr (outfile, ref->vuse, 0);
+ print_generic_expr (outfile, ref->vuse);
}
}
break;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Created SSA_NAME representative ");
- print_generic_expr (dump_file, name, 0);
+ print_generic_expr (dump_file, name);
fprintf (dump_file, " for expression:");
print_pre_expr (dump_file, e);
fprintf (dump_file, " (%04d)\n", value_id);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Inserted ");
- print_gimple_stmt (dump_file, gsi_stmt (gsi_last (*stmts)), 0, 0);
+ print_gimple_stmt (dump_file, gsi_stmt (gsi_last (*stmts)), 0);
fprintf (dump_file, " in predecessor %d (%04d)\n",
block->index, value_id);
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Created phi ");
- print_gimple_stmt (dump_file, phi, 0, 0);
+ print_gimple_stmt (dump_file, phi, 0);
fprintf (dump_file, " in block %d (%04d)\n", block->index, val);
}
pre_stats.phis++;
if (res)
{
fprintf (dump_file, "Failed to insert expression for value ");
- print_generic_expr (dump_file, val, 0);
+ print_generic_expr (dump_file, val);
fprintf (dump_file, " which is really fully redundant to ");
- print_generic_expr (dump_file, res, 0);
+ print_generic_expr (dump_file, res);
fprintf (dump_file, "\n");
}
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Inserted ");
- print_gimple_stmt (dump_file, SSA_NAME_DEF_STMT (res), 0, 0);
+ print_gimple_stmt (dump_file, SSA_NAME_DEF_STMT (res), 0);
}
return res;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Replaced redundant PHI node defining ");
- print_generic_expr (dump_file, res, 0);
+ print_generic_expr (dump_file, res);
fprintf (dump_file, " with ");
- print_generic_expr (dump_file, sprime, 0);
+ print_generic_expr (dump_file, sprime);
fprintf (dump_file, "\n");
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Not replacing ");
- print_gimple_expr (dump_file, stmt, 0, 0);
+ print_gimple_expr (dump_file, stmt, 0);
fprintf (dump_file, " with ");
- print_generic_expr (dump_file, sprime, 0);
+ print_generic_expr (dump_file, sprime);
fprintf (dump_file, " which would add a loop"
" carried dependence to loop %d\n",
loop->num);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Replaced ");
- print_gimple_expr (dump_file, stmt, 0, 0);
+ print_gimple_expr (dump_file, stmt, 0);
fprintf (dump_file, " with ");
- print_generic_expr (dump_file, sprime, 0);
+ print_generic_expr (dump_file, sprime);
fprintf (dump_file, " in all uses of ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
pre_stats.eliminations++;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Replaced ");
- print_gimple_expr (dump_file, stmt, 0, 0);
+ print_gimple_expr (dump_file, stmt, 0);
fprintf (dump_file, " with ");
- print_generic_expr (dump_file, sprime, 0);
+ print_generic_expr (dump_file, sprime);
fprintf (dump_file, " in ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
if (TREE_CODE (sprime) == SSA_NAME)
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Deleted redundant store ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
/* Queue stmt for removal. */
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Removing unexecutable edge from ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
if (((EDGE_SUCC (b, 0)->flags & EDGE_TRUE_VALUE) != 0)
== ((EDGE_SUCC (b, 0)->flags & EDGE_EXECUTABLE) != 0))
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Fixing up noreturn call ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
if (fixup_noreturn_call (stmt))
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Removing unnecessary insertion:");
- print_gimple_stmt (dump_file, t, 0, 0);
+ print_gimple_stmt (dump_file, t, 0);
}
gsi = gsi_for_stmt (t);
if (dump_file && dump_flags & TDF_DETAILS)
{
fprintf (dump_file, "Removing dead stmt ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
fprintf (dump_file, "\n");
}
prop_stats.num_dce++;
if (dump_file && dump_flags & TDF_DETAILS)
{
fprintf (dump_file, "Fixing up noreturn call ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
fprintf (dump_file, "\n");
}
fixup_noreturn_call (stmt);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Rank for ");
- print_generic_expr (dump_file, e, 0);
+ print_generic_expr (dump_file, e);
fprintf (dump_file, " is %ld\n", (rank + 1));
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Equivalence: ");
- print_generic_expr (dump_file, curr->op, 0);
+ print_generic_expr (dump_file, curr->op);
fprintf (dump_file, " [&|minmax] ");
- print_generic_expr (dump_file, last->op, 0);
+ print_generic_expr (dump_file, last->op);
fprintf (dump_file, " -> ");
- print_generic_stmt (dump_file, last->op, 0);
+ print_generic_stmt (dump_file, last->op);
}
ops->ordered_remove (i);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Equivalence: ");
- print_generic_expr (dump_file, curr->op, 0);
+ print_generic_expr (dump_file, curr->op);
fprintf (dump_file, " ^ ");
- print_generic_expr (dump_file, last->op, 0);
+ print_generic_expr (dump_file, last->op);
fprintf (dump_file, " -> nothing\n");
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Equivalence: ");
- print_generic_expr (dump_file, negateop, 0);
+ print_generic_expr (dump_file, negateop);
fprintf (dump_file, " + -");
- print_generic_expr (dump_file, oe->op, 0);
+ print_generic_expr (dump_file, oe->op);
fprintf (dump_file, " -> 0\n");
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Equivalence: ");
- print_generic_expr (dump_file, notop, 0);
+ print_generic_expr (dump_file, notop);
fprintf (dump_file, " + ~");
- print_generic_expr (dump_file, oe->op, 0);
+ print_generic_expr (dump_file, oe->op);
fprintf (dump_file, " -> -1\n");
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Equivalence: ");
- print_generic_expr (dump_file, notop, 0);
+ print_generic_expr (dump_file, notop);
if (opcode == BIT_AND_EXPR)
fprintf (dump_file, " & ~");
else if (opcode == BIT_IOR_EXPR)
fprintf (dump_file, " | ~");
- print_generic_expr (dump_file, oe->op, 0);
+ print_generic_expr (dump_file, oe->op);
if (opcode == BIT_AND_EXPR)
fprintf (dump_file, " -> 0\n");
else if (opcode == BIT_IOR_EXPR)
fprintf (dump_file, " %u %s: ", c->cnt,
c->oecode == MULT_EXPR
? "*" : c->oecode == RDIV_EXPR ? "/" : "?");
- print_generic_expr (dump_file, c->op, 0);
+ print_generic_expr (dump_file, c->op);
fprintf (dump_file, "\n");
}
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Building (");
- print_generic_expr (dump_file, oe1->op, 0);
+ print_generic_expr (dump_file, oe1->op);
}
zero_one_operation (&oe1->op, c->oecode, c->op);
EXECUTE_IF_SET_IN_BITMAP (candidates2, first+1, i, sbi0)
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, " + ");
- print_generic_expr (dump_file, oe2->op, 0);
+ print_generic_expr (dump_file, oe2->op);
}
zero_one_operation (&oe2->op, c->oecode, c->op);
sum = build_and_add_sum (TREE_TYPE (oe1->op),
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, ") %s ", c->oecode == MULT_EXPR ? "*" : "/");
- print_generic_expr (dump_file, c->op, 0);
+ print_generic_expr (dump_file, c->op);
fprintf (dump_file, "\n");
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Equivalence: ");
- print_generic_expr (dump_file, curr->op, 0);
+ print_generic_expr (dump_file, curr->op);
fprintf (dump_file, " %s ", op_symbol_code (opcode));
- print_generic_expr (dump_file, oe->op, 0);
+ print_generic_expr (dump_file, oe->op);
fprintf (dump_file, " -> ");
- print_generic_expr (dump_file, t, 0);
+ print_generic_expr (dump_file, t);
fprintf (dump_file, "\n");
}
{
struct range_entry *r;
fprintf (dump_file, "Optimizing range tests ");
- print_generic_expr (dump_file, range->exp, 0);
+ print_generic_expr (dump_file, range->exp);
fprintf (dump_file, " %c[", range->in_p ? '+' : '-');
- print_generic_expr (dump_file, range->low, 0);
+ print_generic_expr (dump_file, range->low);
fprintf (dump_file, ", ");
- print_generic_expr (dump_file, range->high, 0);
+ print_generic_expr (dump_file, range->high);
fprintf (dump_file, "]");
for (i = 0; i < count; i++)
{
else
r = otherrangep[i];
fprintf (dump_file, " and %c[", r->in_p ? '+' : '-');
- print_generic_expr (dump_file, r->low, 0);
+ print_generic_expr (dump_file, r->low);
fprintf (dump_file, ", ");
- print_generic_expr (dump_file, r->high, 0);
+ print_generic_expr (dump_file, r->high);
fprintf (dump_file, "]");
}
fprintf (dump_file, "\n into ");
- print_generic_expr (dump_file, tem, 0);
+ print_generic_expr (dump_file, tem);
fprintf (dump_file, "\n");
}
{
struct range_entry *r = &ranges[*idx];
fprintf (dump_file, "Optimizing range test ");
- print_generic_expr (dump_file, r->exp, 0);
+ print_generic_expr (dump_file, r->exp);
fprintf (dump_file, " +[");
- print_generic_expr (dump_file, r->low, 0);
+ print_generic_expr (dump_file, r->low);
fprintf (dump_file, ", ");
- print_generic_expr (dump_file, r->high, 0);
+ print_generic_expr (dump_file, r->high);
fprintf (dump_file, "] and comparison ");
- print_generic_expr (dump_file, rhs1, 0);
+ print_generic_expr (dump_file, rhs1);
fprintf (dump_file, " %s ", op_symbol_code (ccode));
- print_generic_expr (dump_file, rhs2, 0);
+ print_generic_expr (dump_file, rhs2);
fprintf (dump_file, "\n into (");
- print_generic_expr (dump_file, utype, 0);
+ print_generic_expr (dump_file, utype);
fprintf (dump_file, ") ");
- print_generic_expr (dump_file, rhs1, 0);
+ print_generic_expr (dump_file, rhs1);
fprintf (dump_file, " %s (", op_symbol_code (ccode));
- print_generic_expr (dump_file, utype, 0);
+ print_generic_expr (dump_file, utype);
fprintf (dump_file, ") ");
- print_generic_expr (dump_file, rhs2, 0);
+ print_generic_expr (dump_file, rhs2);
fprintf (dump_file, "\n");
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Transforming ");
- print_generic_expr (dump_file, cond0, 0);
+ print_generic_expr (dump_file, cond0);
fprintf (dump_file, " %c ", opcode == BIT_AND_EXPR ? '&' : '|');
- print_generic_expr (dump_file, cond1, 0);
+ print_generic_expr (dump_file, cond1);
fprintf (dump_file, " into ");
- print_generic_expr (dump_file, comb, 0);
+ print_generic_expr (dump_file, comb);
fputc ('\n', dump_file);
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Transforming ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
/* If the stmt that defines operand has to be inserted, insert it
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, " into ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
}
return lhs;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Transforming ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
/* If changed is false, this is either opindex == 0
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, " into ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
}
return lhs;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Transforming ");
- print_gimple_stmt (dump_file, stmts[i], 0, 0);
+ print_gimple_stmt (dump_file, stmts[i], 0);
}
/* If the stmt that defines operand has to be inserted, insert it
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, " into ");
- print_gimple_stmt (dump_file, stmts[i], 0, 0);
+ print_gimple_stmt (dump_file, stmts[i], 0);
}
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Linearized: ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
reassociate_stats.linearized++;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Breaking up subtract ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
rhs2 = negate_value (rhs2, gsip);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "swapping operands of ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
swap_ssa_operands (stmt,
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, " is now ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
/* We want to make it so the lhs is always the reassociative op,
for (elt = j; elt < vec_len; elt++)
{
rf = &repeat_factor_vec[elt];
- print_generic_expr (dump_file, rf->factor, 0);
+ print_generic_expr (dump_file, rf->factor);
if (elt < vec_len - 1)
fputs (" * ", dump_file);
}
for (elt = j; elt < vec_len; elt++)
{
rf = &repeat_factor_vec[elt];
- print_generic_expr (dump_file, rf->factor, 0);
+ print_generic_expr (dump_file, rf->factor);
if (elt < vec_len - 1)
fputs (" * ", dump_file);
}
for (elt = j; elt < vec_len; elt++)
{
rf = &repeat_factor_vec[elt];
- print_generic_expr (dump_file, rf->factor, 0);
+ print_generic_expr (dump_file, rf->factor);
if (elt < vec_len - 1)
fputs (" * ", dump_file);
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Optimizing copysign: ");
- print_generic_expr (dump_file, cst, 0);
+ print_generic_expr (dump_file, cst);
fprintf (dump_file, " * COPYSIGN (");
- print_generic_expr (dump_file, arg0, 0);
+ print_generic_expr (dump_file, arg0);
fprintf (dump_file, ", ");
- print_generic_expr (dump_file, arg1, 0);
+ print_generic_expr (dump_file, arg1);
fprintf (dump_file, ") into %sCOPYSIGN (",
cst1_neg ? "-" : "");
- print_generic_expr (dump_file, mul, 0);
+ print_generic_expr (dump_file, mul);
fprintf (dump_file, ", ");
- print_generic_expr (dump_file, arg1, 0);
+ print_generic_expr (dump_file, arg1);
fprintf (dump_file, "\n");
}
return;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Transforming ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
rhs1 = gimple_assign_rhs1 (stmt);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, " into ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Transforming ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
gimple_assign_set_rhs_with_ops (gsi, MULT_EXPR, rhs1, rhs2);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, " into ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
}
FOR_EACH_VEC_ELT (ops, i, oe)
{
fprintf (file, "Op %d -> rank: %d, tree: ", i, oe->rank);
- print_generic_expr (file, oe->op, 0);
+ print_generic_expr (file, oe->op);
fprintf (file, "\n");
}
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Inserting name ");
- print_generic_expr (dump_file, result, 0);
+ print_generic_expr (dump_file, result);
fprintf (dump_file, " for expression ");
print_gimple_expr (dump_file, new_stmt, 0, TDF_SLIM);
fprintf (dump_file, "\n");
FOR_EACH_VEC_ELT (scc, i, var)
{
fprintf (out, " ");
- print_generic_expr (out, var, 0);
+ print_generic_expr (out, var);
}
fprintf (out, "\n");
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Not changing value number of ");
- print_generic_expr (dump_file, from, 0);
+ print_generic_expr (dump_file, from);
fprintf (dump_file, " from VARYING to ");
- print_generic_expr (dump_file, to, 0);
+ print_generic_expr (dump_file, to);
fprintf (dump_file, "\n");
}
return false;
{
fprintf (dump_file, "Forcing VARYING instead of changing "
"value number of ");
- print_generic_expr (dump_file, from, 0);
+ print_generic_expr (dump_file, from);
fprintf (dump_file, " from ");
- print_generic_expr (dump_file, currval, 0);
+ print_generic_expr (dump_file, currval);
fprintf (dump_file, " (non-constant) to ");
- print_generic_expr (dump_file, to, 0);
+ print_generic_expr (dump_file, to);
fprintf (dump_file, " (constant)\n");
}
to = from;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Setting value number of ");
- print_generic_expr (dump_file, from, 0);
+ print_generic_expr (dump_file, from);
fprintf (dump_file, " to ");
- print_generic_expr (dump_file, to, 0);
+ print_generic_expr (dump_file, to);
}
if (currval != to
{
fprintf (dump_file, "No store match\n");
fprintf (dump_file, "Value numbering store ");
- print_generic_expr (dump_file, lhs, 0);
+ print_generic_expr (dump_file, lhs);
fprintf (dump_file, " to ");
- print_generic_expr (dump_file, op, 0);
+ print_generic_expr (dump_file, op);
fprintf (dump_file, "\n");
}
/* Have to set value numbers before insert, since insert is
&& !SSA_NAME_IS_DEFAULT_DEF (use))
{
fprintf (dump_file, "Value numbering ");
- print_generic_expr (dump_file, use, 0);
+ print_generic_expr (dump_file, use);
fprintf (dump_file, " stmt = ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
/* Handle uninitialized uses. */
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "RHS ");
- print_gimple_expr (dump_file, ass, 0, 0);
+ print_gimple_expr (dump_file, ass, 0);
fprintf (dump_file, " simplified to ");
- print_generic_expr (dump_file, simplified, 0);
+ print_generic_expr (dump_file, simplified);
fprintf (dump_file, "\n");
}
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "call ");
- print_gimple_expr (dump_file, call_stmt, 0, 0);
+ print_gimple_expr (dump_file, call_stmt, 0);
fprintf (dump_file, " simplified to ");
- print_generic_expr (dump_file, simplified, 0);
+ print_generic_expr (dump_file, simplified);
fprintf (dump_file, "\n");
}
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Visiting control stmt ending BB %d: ", bb->index);
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
/* ??? We can even handle stmts with outgoing EH or ABNORMAL edges
if (VN_INFO (name)->visited
&& SSA_VAL (name) != name)
{
- print_generic_expr (dump_file, name, 0);
+ print_generic_expr (dump_file, name);
fprintf (dump_file, " = ");
- print_generic_expr (dump_file, SSA_VAL (name), 0);
+ print_generic_expr (dump_file, SSA_VAL (name));
fprintf (dump_file, "\n");
}
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "FIND: ");
- print_generic_expr (dump_file, lhs, 0);
+ print_generic_expr (dump_file, lhs);
fprintf (dump_file, "\n");
}
if (m_lhs)
{
- print_generic_expr (stream, m_lhs, 0);
+ print_generic_expr (stream, m_lhs);
fprintf (stream, " = ");
}
switch (m_expr.kind)
{
case EXPR_SINGLE:
- print_generic_expr (stream, m_expr.ops.single.rhs, 0);
- break;
+ print_generic_expr (stream, m_expr.ops.single.rhs);
+ break;
case EXPR_UNARY:
fprintf (stream, "%s ", get_tree_code_name (m_expr.ops.unary.op));
- print_generic_expr (stream, m_expr.ops.unary.opnd, 0);
- break;
+ print_generic_expr (stream, m_expr.ops.unary.opnd);
+ break;
case EXPR_BINARY:
- print_generic_expr (stream, m_expr.ops.binary.opnd0, 0);
+ print_generic_expr (stream, m_expr.ops.binary.opnd0);
fprintf (stream, " %s ", get_tree_code_name (m_expr.ops.binary.op));
- print_generic_expr (stream, m_expr.ops.binary.opnd1, 0);
- break;
+ print_generic_expr (stream, m_expr.ops.binary.opnd1);
+ break;
case EXPR_TERNARY:
fprintf (stream, " %s <", get_tree_code_name (m_expr.ops.ternary.op));
- print_generic_expr (stream, m_expr.ops.ternary.opnd0, 0);
+ print_generic_expr (stream, m_expr.ops.ternary.opnd0);
fputs (", ", stream);
- print_generic_expr (stream, m_expr.ops.ternary.opnd1, 0);
+ print_generic_expr (stream, m_expr.ops.ternary.opnd1);
fputs (", ", stream);
- print_generic_expr (stream, m_expr.ops.ternary.opnd2, 0);
+ print_generic_expr (stream, m_expr.ops.ternary.opnd2);
fputs (">", stream);
- break;
+ break;
case EXPR_CALL:
{
fputs (internal_fn_name (gimple_call_internal_fn (fn_from)),
stream);
else
- print_generic_expr (stream, gimple_call_fn (fn_from), 0);
+ print_generic_expr (stream, gimple_call_fn (fn_from));
fprintf (stream, " (");
for (i = 0; i < nargs; i++)
{
- print_generic_expr (stream, m_expr.ops.call.args[i], 0);
+ print_generic_expr (stream, m_expr.ops.call.args[i]);
if (i + 1 < nargs)
fprintf (stream, ", ");
}
fprintf (stream, "PHI <");
for (i = 0; i < nargs; i++)
{
- print_generic_expr (stream, m_expr.ops.phi.args[i], 0);
+ print_generic_expr (stream, m_expr.ops.phi.args[i]);
if (i + 1 < nargs)
fprintf (stream, ", ");
}
if (m_vop)
{
fprintf (stream, " with ");
- print_generic_expr (stream, m_vop, 0);
+ print_generic_expr (stream, m_vop);
}
fprintf (stream, "\n");
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "<<<< COPY ");
- print_generic_expr (dump_file, dest, 0);
+ print_generic_expr (dump_file, dest);
fprintf (dump_file, " = ");
- print_generic_expr (dump_file, SSA_NAME_VALUE (dest), 0);
+ print_generic_expr (dump_file, SSA_NAME_VALUE (dest));
fprintf (dump_file, "\n");
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "0>>> COPY ");
- print_generic_expr (dump_file, x, 0);
+ print_generic_expr (dump_file, x);
fprintf (dump_file, " = ");
- print_generic_expr (dump_file, y, 0);
+ print_generic_expr (dump_file, y);
fprintf (dump_file, "\n");
}
{
fprintf (dump_file, "found restrict pointed-to "
"for ");
- print_generic_expr (dump_file, ptr, 0);
+ print_generic_expr (dump_file, ptr);
fprintf (dump_file, " but not exclusively\n");
}
restrict_var = NULL;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "\n[CHECK] Found def edge %d in ", (int) i);
- print_gimple_stmt (dump_file, phi, 0, 0);
+ print_gimple_stmt (dump_file, phi, 0);
}
edges->safe_push (opnd_edge);
}
{
fprintf (dump_file, "\n[CHECK] Found def edge %d in ",
(int) i);
- print_gimple_stmt (dump_file, phi, 0, 0);
+ print_gimple_stmt (dump_file, phi, 0);
}
edges->safe_push (opnd_edge);
}
size_t i, j;
pred_chain one_pred_chain = vNULL;
fprintf (dump_file, "%s", msg);
- print_gimple_stmt (dump_file, usestmt, 0, 0);
+ print_gimple_stmt (dump_file, usestmt, 0);
fprintf (dump_file, "is guarded by :\n\n");
size_t num_preds = preds.length ();
/* Do some dumping here: */
pred_info one_pred = one_pred_chain[j];
if (one_pred.invert)
fprintf (dump_file, " (.NOT.) ");
- print_generic_expr (dump_file, one_pred.pred_lhs, 0);
+ print_generic_expr (dump_file, one_pred.pred_lhs);
fprintf (dump_file, " %s ", op_symbol_code (one_pred.cond_code));
- print_generic_expr (dump_file, one_pred.pred_rhs, 0);
+ print_generic_expr (dump_file, one_pred.pred_rhs);
if (j < np - 1)
fprintf (dump_file, " (.AND.) ");
else
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "[CHECK]: Found unguarded use: ");
- print_gimple_stmt (dump_file, use_stmt, 0, 0);
+ print_gimple_stmt (dump_file, use_stmt, 0);
}
/* Found one real use, return. */
if (gimple_code (use_stmt) != GIMPLE_PHI)
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "[WORKLIST]: Update worklist with phi: ");
- print_gimple_stmt (dump_file, use_stmt, 0, 0);
+ print_gimple_stmt (dump_file, use_stmt, 0);
}
worklist->safe_push (as_a<gphi *> (use_stmt));
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "[CHECK]: examining phi: ");
- print_gimple_stmt (dump_file, phi, 0, 0);
+ print_gimple_stmt (dump_file, phi, 0);
}
/* Now check if we have any use of the value without proper guard. */
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "[WORKLIST]: add to initial list: ");
- print_gimple_stmt (dump_file, phi, 0, 0);
+ print_gimple_stmt (dump_file, phi, 0);
}
break;
}
if (phi)
{
error ("multiple virtual PHI nodes in BB %d", bb->index);
- print_gimple_stmt (stderr, phi, 0, 0);
- print_gimple_stmt (stderr, si.phi (), 0, 0);
+ print_gimple_stmt (stderr, phi, 0);
+ print_gimple_stmt (stderr, si.phi (), 0);
err = true;
}
else
if (TREE_CODE (current_vdef) != SSA_NAME)
{
error ("virtual definition is not an SSA name");
- print_gimple_stmt (stderr, phi, 0, 0);
+ print_gimple_stmt (stderr, phi, 0);
err = true;
}
}
error ("stmt with wrong VUSE");
print_gimple_stmt (stderr, stmt, 0, TDF_VOPS);
fprintf (stderr, "expected ");
- print_generic_expr (stderr, current_vdef, 0);
+ print_generic_expr (stderr, current_vdef);
fprintf (stderr, "\n");
err = true;
}
if (TREE_CODE (current_vdef) != SSA_NAME)
{
error ("virtual definition is not an SSA name");
- print_gimple_stmt (stderr, phi, 0, 0);
+ print_gimple_stmt (stderr, phi, 0);
err = true;
}
}
e->src->index);
print_gimple_stmt (stderr, phi, 0, TDF_VOPS);
fprintf (stderr, "expected ");
- print_generic_expr (stderr, current_vdef, 0);
+ print_generic_expr (stderr, current_vdef);
fprintf (stderr, "\n");
err = true;
}
err:
fprintf (stderr, "while verifying SSA_NAME ");
- print_generic_expr (stderr, ssa_name, 0);
+ print_generic_expr (stderr, ssa_name);
fprintf (stderr, " in statement\n");
print_gimple_stmt (stderr, stmt, 4, TDF_VOPS);
if (existed)
{
error ("shared SSA name info");
- print_generic_expr (stderr, val, 0);
+ print_generic_expr (stderr, val);
fprintf (stderr, " and ");
- print_generic_expr (stderr, name, 0);
+ print_generic_expr (stderr, name);
fprintf (stderr, "\n");
goto err;
}
if (dump_file)
{
fprintf (dump_file, "No longer having address taken: ");
- print_generic_expr (dump_file, var, 0);
+ print_generic_expr (dump_file, var);
fprintf (dump_file, "\n");
}
}
if (dump_file)
{
fprintf (dump_file, "Now a gimple register: ");
- print_generic_expr (dump_file, var, 0);
+ print_generic_expr (dump_file, var);
fprintf (dump_file, "\n");
}
}
&& vrp_val_is_min (vr->min))
fprintf (file, "-INF");
else
- print_generic_expr (file, vr->min, 0);
+ print_generic_expr (file, vr->min);
fprintf (file, ", ");
&& vrp_val_is_max (vr->max))
fprintf (file, "+INF");
else
- print_generic_expr (file, vr->max, 0);
+ print_generic_expr (file, vr->max);
fprintf (file, "]");
EXECUTE_IF_SET_IN_BITMAP (vr->equiv, 0, i, bi)
{
- print_generic_expr (file, ssa_name (i), 0);
+ print_generic_expr (file, ssa_name (i));
fprintf (file, " ");
c++;
}
{
if (vr_value[i])
{
- print_generic_expr (file, ssa_name (i), 0);
+ print_generic_expr (file, ssa_name (i));
fprintf (file, ": ");
dump_value_range (file, vr_value[i]);
fprintf (file, "\n");
assert_locus *loc;
fprintf (file, "Assertions to be inserted for ");
- print_generic_expr (file, name, 0);
+ print_generic_expr (file, name);
fprintf (file, "\n");
loc = asserts_for[SSA_NAME_VERSION (name)];
while (loc)
{
fprintf (file, "\t");
- print_gimple_stmt (file, gsi_stmt (loc->si), 0, 0);
+ print_gimple_stmt (file, gsi_stmt (loc->si), 0);
fprintf (file, "\n\tBB #%d", loc->bb->index);
if (loc->e)
{
dump_edge_info (file, loc->e, dump_flags, 0);
}
fprintf (file, "\n\tPREDICATE: ");
- print_generic_expr (file, loc->expr, 0);
+ print_generic_expr (file, loc->expr);
fprintf (file, " %s ", get_tree_code_name (loc->comp_code));
- print_generic_expr (file, loc->val, 0);
+ print_generic_expr (file, loc->val);
fprintf (file, "\n\n");
loc = loc->next;
}
if (dump_file)
{
fprintf (dump_file, "Adding assert for ");
- print_generic_expr (dump_file, name3, 0);
+ print_generic_expr (dump_file, name3);
fprintf (dump_file, " from ");
- print_generic_expr (dump_file, tmp, 0);
+ print_generic_expr (dump_file, tmp);
fprintf (dump_file, "\n");
}
if (dump_file)
{
fprintf (dump_file, "Adding assert for ");
- print_generic_expr (dump_file, name2, 0);
+ print_generic_expr (dump_file, name2);
fprintf (dump_file, " from ");
- print_generic_expr (dump_file, tmp, 0);
+ print_generic_expr (dump_file, tmp);
fprintf (dump_file, "\n");
}
if (dump_file)
{
fprintf (dump_file, "Adding assert for ");
- print_generic_expr (dump_file, name2, 0);
+ print_generic_expr (dump_file, name2);
fprintf (dump_file, " from ");
- print_generic_expr (dump_file, tmp, 0);
+ print_generic_expr (dump_file, tmp);
fprintf (dump_file, "\n");
}
if (dump_file)
{
fprintf (dump_file, "Adding assert for ");
- print_generic_expr (dump_file, name2, 0);
+ print_generic_expr (dump_file, name2);
fprintf (dump_file, " from ");
- print_generic_expr (dump_file, tmp, 0);
+ print_generic_expr (dump_file, tmp);
fprintf (dump_file, "\n");
}
if (dump_file)
{
fprintf (dump_file, "Adding assert for ");
- print_generic_expr (dump_file, names[i], 0);
+ print_generic_expr (dump_file, names[i]);
fprintf (dump_file, " from ");
- print_generic_expr (dump_file, tmp, 0);
+ print_generic_expr (dump_file, tmp);
fprintf (dump_file, "\n");
}
ssa_op_iter i;
fprintf (dump_file, "\nVisiting conditional with predicate: ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
fprintf (dump_file, "\nWith known ranges\n");
FOR_EACH_SSA_TREE_OPERAND (use, stmt, i, SSA_OP_USE)
{
fprintf (dump_file, "\t");
- print_generic_expr (dump_file, use, 0);
+ print_generic_expr (dump_file, use);
fprintf (dump_file, ": ");
dump_value_range (dump_file, vr_value[SSA_NAME_VERSION (use)]);
}
if (val == NULL_TREE)
fprintf (dump_file, "DON'T KNOW\n");
else
- print_generic_stmt (dump_file, val, 0);
+ print_generic_stmt (dump_file, val);
}
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "\nVisiting switch expression with operand ");
- print_generic_expr (dump_file, op, 0);
+ print_generic_expr (dump_file, op);
fprintf (dump_file, " with known range ");
dump_value_range (dump_file, vr);
fprintf (dump_file, "\n");
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, " will take edge to ");
- print_generic_stmt (dump_file, CASE_LABEL (val), 0);
+ print_generic_stmt (dump_file, CASE_LABEL (val));
}
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Found new range for ");
- print_generic_expr (dump_file, *output_p, 0);
+ print_generic_expr (dump_file, *output_p);
fprintf (dump_file, ": ");
dump_value_range (dump_file, &vr);
fprintf (dump_file, "\n");
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Found new range for ");
- print_generic_expr (dump_file, lhs, 0);
+ print_generic_expr (dump_file, lhs);
fprintf (dump_file, ": ");
dump_value_range (dump_file, &vr_result);
fprintf (dump_file, "\n");
if (dump_file)
{
fprintf (dump_file, "Simplified relational ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
fprintf (dump_file, " into ");
}
if (dump_file)
{
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
fprintf (dump_file, "\n");
}
if (dump_file)
{
fprintf (dump_file, "Simplified relational ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
fprintf (dump_file, " into ");
}
if (dump_file)
{
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
fprintf (dump_file, "\n");
}
if (dump_file)
{
fprintf (dump_file, "Folding predicate ");
- print_gimple_expr (dump_file, stmt, 0, 0);
+ print_gimple_expr (dump_file, stmt, 0);
fprintf (dump_file, " to ");
- print_generic_expr (dump_file, val, 0);
+ print_generic_expr (dump_file, val);
fprintf (dump_file, "\n");
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Visiting controlling predicate ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
/* Entering a new scope. Try to see if we can find a VR
here. */
if (interesting && dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Visiting PHI node ");
- print_gimple_stmt (dump_file, phi, 0, 0);
+ print_gimple_stmt (dump_file, phi, 0);
}
if (!has_unvisited_preds
&& interesting)
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Visiting stmt ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
if (gcond *cond = dyn_cast <gcond *> (stmt))
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "pushing new range for ");
- print_generic_expr (dump_file, var, 0);
+ print_generic_expr (dump_file, var);
fprintf (dump_file, ": ");
dump_value_range (dump_file, vr);
fprintf (dump_file, "\n");
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "popping range for ");
- print_generic_expr (dump_file, var, 0);
+ print_generic_expr (dump_file, var);
fprintf (dump_file, ", restoring ");
dump_value_range (dump_file, vr);
fprintf (dump_file, "\n");
if (dump_file && dump_flags & TDF_DETAILS)
{
fprintf (dump_file, "Removing dead stmt ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
fprintf (dump_file, "\n");
}
gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
projects / gcc.git / commitdiff