/* Pretty formatting of GIMPLE statements and expressions.
- Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
Free Software Foundation, Inc.
Contributed by Aldy Hernandez <aldyh@redhat.com> and
Diego Novillo <dnovillo@google.com>
break;
case FIXED_CONVERT_EXPR:
+ case ADDR_SPACE_CONVERT_EXPR:
case FIX_TRUNC_EXPR:
case FLOAT_EXPR:
CASE_CONVERT:
- pp_string (buffer, "(");
+ pp_character (buffer, '(');
dump_generic_node (buffer, TREE_TYPE (lhs), spc, flags, false);
pp_string (buffer, ") ");
- dump_generic_node (buffer, rhs, spc, flags, false);
+ if (op_prio (rhs) < op_code_prio (rhs_code))
+ {
+ pp_character (buffer, '(');
+ dump_generic_node (buffer, rhs, spc, flags, false);
+ pp_character (buffer, ')');
+ }
+ else
+ dump_generic_node (buffer, rhs, spc, flags, false);
break;
case PAREN_EXPR:
case ABS_EXPR:
pp_string (buffer, "ABS_EXPR <");
dump_generic_node (buffer, rhs, spc, flags, false);
- pp_string (buffer, ">");
+ pp_character (buffer, '>');
break;
default:
|| rhs_code == SSA_NAME
|| rhs_code == ADDR_EXPR
|| rhs_code == CONSTRUCTOR)
- ; /* do nothing. */
+ {
+ dump_generic_node (buffer, rhs, spc, flags, false);
+ break;
+ }
else if (rhs_code == BIT_NOT_EXPR)
- pp_string (buffer, "~");
+ pp_character (buffer, '~');
else if (rhs_code == TRUTH_NOT_EXPR)
- pp_string (buffer, "!");
+ pp_character (buffer, '!');
else if (rhs_code == NEGATE_EXPR)
- pp_string (buffer, "-");
+ pp_character (buffer, '-');
else
{
- pp_string (buffer, "[");
+ pp_character (buffer, '[');
pp_string (buffer, tree_code_name [rhs_code]);
pp_string (buffer, "] ");
}
- dump_generic_node (buffer, rhs, spc, flags, false);
+ if (op_prio (rhs) < op_code_prio (rhs_code))
+ {
+ pp_character (buffer, '(');
+ dump_generic_node (buffer, rhs, spc, flags, false);
+ pp_character (buffer, ')');
+ }
+ else
+ dump_generic_node (buffer, rhs, spc, flags, false);
break;
}
}
static void
dump_binary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
{
- switch (gimple_assign_rhs_code (gs))
+ const char *p;
+ enum tree_code code = gimple_assign_rhs_code (gs);
+ switch (code)
{
case COMPLEX_EXPR:
- pp_string (buffer, "COMPLEX_EXPR <");
- dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
- pp_string (buffer, ", ");
- dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
- pp_string (buffer, ">");
- break;
-
case MIN_EXPR:
- pp_string (buffer, "MIN_EXPR <");
- dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
- pp_string (buffer, ", ");
- dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
- pp_string (buffer, ">");
- break;
-
case MAX_EXPR:
- pp_string (buffer, "MAX_EXPR <");
+ case VEC_WIDEN_MULT_HI_EXPR:
+ case VEC_WIDEN_MULT_LO_EXPR:
+ case VEC_PACK_TRUNC_EXPR:
+ case VEC_PACK_SAT_EXPR:
+ case VEC_PACK_FIX_TRUNC_EXPR:
+ case VEC_EXTRACT_EVEN_EXPR:
+ case VEC_EXTRACT_ODD_EXPR:
+ case VEC_INTERLEAVE_HIGH_EXPR:
+ case VEC_INTERLEAVE_LOW_EXPR:
+ for (p = tree_code_name [(int) code]; *p; p++)
+ pp_character (buffer, TOUPPER (*p));
+ pp_string (buffer, " <");
dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
pp_string (buffer, ", ");
dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
- pp_string (buffer, ">");
+ pp_character (buffer, '>');
break;
default:
- dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
+ if (op_prio (gimple_assign_rhs1 (gs)) <= op_code_prio (code))
+ {
+ pp_character (buffer, '(');
+ dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags,
+ false);
+ pp_character (buffer, ')');
+ }
+ else
+ dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
pp_space (buffer);
pp_string (buffer, op_symbol_code (gimple_assign_rhs_code (gs)));
pp_space (buffer);
- dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
+ if (op_prio (gimple_assign_rhs2 (gs)) <= op_code_prio (code))
+ {
+ pp_character (buffer, '(');
+ dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags,
+ false);
+ pp_character (buffer, ')');
+ }
+ else
+ dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
}
}
pp_string (buffer, ", ");
dump_gimple_call_args (buffer, gs, flags);
}
- pp_string (buffer, ">");
+ pp_character (buffer, '>');
}
else
{
pp_space (buffer);
}
- dump_generic_node (buffer, gimple_call_fn (gs), spc, flags, false);
+ print_call_name (buffer, gimple_call_fn (gs), flags);
pp_string (buffer, " (");
dump_gimple_call_args (buffer, gs, flags);
- pp_string (buffer, ")");
+ pp_character (buffer, ')');
if (!(flags & TDF_RHS_ONLY))
pp_semicolon (buffer);
}
continue;
dump_generic_node (buffer, case_label, spc, flags, false);
- pp_string (buffer, " ");
+ pp_character (buffer, ' ');
dump_generic_node (buffer, CASE_LABEL (case_label), spc, flags, false);
if (i < gimple_switch_num_labels (gs) - 1)
pp_string (buffer, ", ");
}
- pp_string (buffer, ">");
+ pp_character (buffer, '>');
}
dump_generic_node (buffer, gimple_cond_rhs (gs), spc, flags, false);
if (!(flags & TDF_RHS_ONLY))
{
- pp_string (buffer, ")");
+ pp_character (buffer, ')');
if (gimple_cond_true_label (gs))
{
else
{
dump_generic_node (buffer, label, spc, flags, false);
- pp_string (buffer, ":");
+ pp_character (buffer, ':');
}
if (DECL_NONLOCAL (label))
pp_string (buffer, " [non-local]");
+ if ((flags & TDF_EH) && EH_LANDING_PAD_NR (label))
+ pp_printf (buffer, " [LP %d]", EH_LANDING_PAD_NR (label));
}
/* Dump a GIMPLE_GOTO tuple on the pretty_printer BUFFER, SPC
{
pp_string (buffer, "try");
newline_and_indent (buffer, spc + 2);
- pp_string (buffer, "{");
+ pp_character (buffer, '{');
pp_newline (buffer);
dump_gimple_seq (buffer, gimple_try_eval (gs), spc + 4, flags);
newline_and_indent (buffer, spc + 2);
- pp_string (buffer, "}");
+ pp_character (buffer, '}');
if (gimple_try_kind (gs) == GIMPLE_TRY_CATCH)
{
newline_and_indent (buffer, spc);
pp_string (buffer, "catch");
newline_and_indent (buffer, spc + 2);
- pp_string (buffer, "{");
+ pp_character (buffer, '{');
}
else if (gimple_try_kind (gs) == GIMPLE_TRY_FINALLY)
{
newline_and_indent (buffer, spc);
pp_string (buffer, "finally");
newline_and_indent (buffer, spc + 2);
- pp_string (buffer, "{");
+ pp_character (buffer, '{');
}
else
pp_string (buffer, " <UNKNOWN GIMPLE_TRY> {");
}
+/* Dump a GIMPLE_EH_MUST_NOT_THROW tuple. */
+
+static void
+dump_gimple_eh_must_not_throw (pretty_printer *buffer, gimple gs,
+ int spc, int flags)
+{
+ if (flags & TDF_RAW)
+ dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs,
+ gimple_eh_must_not_throw_fndecl (gs));
+ else
+ dump_gimple_fmt (buffer, spc, flags, "<<<eh_must_not_throw (%T)>>>",
+ gimple_eh_must_not_throw_fndecl (gs));
+}
+
+
/* Dump a GIMPLE_RESX tuple on the pretty_printer BUFFER, SPC spaces of
indent. FLAGS specifies details to show in the dump (see TDF_* in
tree-pass.h). */
{
if (flags & TDF_RAW)
dump_gimple_fmt (buffer, spc, flags, "%G <%d>", gs,
- gimple_resx_region (gs));
+ gimple_resx_region (gs));
else
dump_gimple_fmt (buffer, spc, flags, "resx %d", gimple_resx_region (gs));
}
+/* Dump a GIMPLE_EH_DISPATCH tuple on the pretty_printer BUFFER. */
+
+static void
+dump_gimple_eh_dispatch (pretty_printer *buffer, gimple gs, int spc, int flags)
+{
+ if (flags & TDF_RAW)
+ dump_gimple_fmt (buffer, spc, flags, "%G <%d>", gs,
+ gimple_eh_dispatch_region (gs));
+ else
+ dump_gimple_fmt (buffer, spc, flags, "eh_dispatch %d",
+ gimple_eh_dispatch_region (gs));
+}
+
+/* Dump a GIMPLE_DEBUG tuple on the pretty_printer BUFFER, SPC spaces
+ of indent. FLAGS specifies details to show in the dump (see TDF_*
+ in tree-pass.h). */
+
+static void
+dump_gimple_debug (pretty_printer *buffer, gimple gs, int spc, int flags)
+{
+ switch (gs->gsbase.subcode)
+ {
+ case GIMPLE_DEBUG_BIND:
+ if (flags & TDF_RAW)
+ dump_gimple_fmt (buffer, spc, flags, "%G BIND <%T, %T>", gs,
+ gimple_debug_bind_get_var (gs),
+ gimple_debug_bind_get_value (gs));
+ else
+ dump_gimple_fmt (buffer, spc, flags, "# DEBUG %T => %T",
+ gimple_debug_bind_get_var (gs),
+ gimple_debug_bind_get_value (gs));
+ break;
+
+ default:
+ gcc_unreachable ();
+ }
+}
+
/* Dump a GIMPLE_OMP_FOR tuple on the pretty_printer BUFFER. */
static void
dump_gimple_omp_for (pretty_printer *buffer, gimple gs, int spc, int flags)
static void
dump_gimple_asm (pretty_printer *buffer, gimple gs, int spc, int flags)
{
- unsigned int i;
+ unsigned int i, n, f, fields;
if (flags & TDF_RAW)
- dump_gimple_fmt (buffer, spc, flags, "%G <%+STRING <%n%s%n>", gs,
- gimple_asm_string (gs));
- else
- {
- pp_string (buffer, "__asm__");
- if (gimple_asm_volatile_p (gs))
- pp_string (buffer, " __volatile__");
- pp_string (buffer, "(\"");
- pp_string (buffer, gimple_asm_string (gs));
- pp_string (buffer, "\"");
- }
-
- if (gimple_asm_ninputs (gs)
- || gimple_asm_noutputs (gs)
- || gimple_asm_nclobbers (gs))
{
- if (gimple_asm_noutputs (gs))
- {
- if (flags & TDF_RAW)
- {
- newline_and_indent (buffer, spc + 2);
- pp_string (buffer, "OUTPUT: ");
- }
- else
- pp_string (buffer, " : ");
- }
+ dump_gimple_fmt (buffer, spc, flags, "%G <%+STRING <%n%s%n>", gs,
+ gimple_asm_string (gs));
- for (i = 0; i < gimple_asm_noutputs (gs); i++)
- {
- dump_generic_node (buffer, gimple_asm_output_op (gs, i), spc, flags,
- false);
- if ( i < gimple_asm_noutputs (gs) -1)
- pp_string (buffer, ", ");
- }
+ n = gimple_asm_noutputs (gs);
+ if (n)
+ {
+ newline_and_indent (buffer, spc + 2);
+ pp_string (buffer, "OUTPUT: ");
+ for (i = 0; i < n; i++)
+ {
+ dump_generic_node (buffer, gimple_asm_output_op (gs, i),
+ spc, flags, false);
+ if (i < n - 1)
+ pp_string (buffer, ", ");
+ }
+ }
- if (gimple_asm_ninputs (gs))
- {
- if (flags & TDF_RAW)
- {
- newline_and_indent (buffer, spc + 2);
- pp_string (buffer, "INPUT: ");
- }
- else
- pp_string (buffer, " : ");
- }
+ n = gimple_asm_ninputs (gs);
+ if (n)
+ {
+ newline_and_indent (buffer, spc + 2);
+ pp_string (buffer, "INPUT: ");
+ for (i = 0; i < n; i++)
+ {
+ dump_generic_node (buffer, gimple_asm_input_op (gs, i),
+ spc, flags, false);
+ if (i < n - 1)
+ pp_string (buffer, ", ");
+ }
+ }
- for (i = 0; i < gimple_asm_ninputs (gs); i++)
- {
- dump_generic_node (buffer, gimple_asm_input_op (gs, i), spc, flags,
- false);
- if (i < gimple_asm_ninputs (gs) -1)
- pp_string (buffer, " : ");
- }
+ n = gimple_asm_nclobbers (gs);
+ if (n)
+ {
+ newline_and_indent (buffer, spc + 2);
+ pp_string (buffer, "CLOBBER: ");
+ for (i = 0; i < n; i++)
+ {
+ dump_generic_node (buffer, gimple_asm_clobber_op (gs, i),
+ spc, flags, false);
+ if (i < n - 1)
+ pp_string (buffer, ", ");
+ }
+ }
- if (gimple_asm_nclobbers (gs))
- {
- if (flags & TDF_RAW)
- {
- newline_and_indent (buffer, spc + 2);
- pp_string (buffer, "CLOBBER: ");
- }
- else
- pp_string (buffer, " : ");
- }
+ n = gimple_asm_nlabels (gs);
+ if (n)
+ {
+ newline_and_indent (buffer, spc + 2);
+ pp_string (buffer, "LABEL: ");
+ for (i = 0; i < n; i++)
+ {
+ dump_generic_node (buffer, gimple_asm_label_op (gs, i),
+ spc, flags, false);
+ if (i < n - 1)
+ pp_string (buffer, ", ");
+ }
+ }
- for (i = 0; i < gimple_asm_nclobbers (gs); i++)
- {
- dump_generic_node (buffer, gimple_asm_clobber_op (gs, i), spc, flags,
- false);
- if ( i < gimple_asm_nclobbers (gs) -1)
- pp_string (buffer, ", ");
- }
- }
- if (flags & TDF_RAW)
- {
newline_and_indent (buffer, spc);
pp_character (buffer, '>');
}
else
- pp_string (buffer, ");");
-}
+ {
+ pp_string (buffer, "__asm__");
+ if (gimple_asm_volatile_p (gs))
+ pp_string (buffer, " __volatile__");
+ if (gimple_asm_nlabels (gs))
+ pp_string (buffer, " goto");
+ pp_string (buffer, "(\"");
+ pp_string (buffer, gimple_asm_string (gs));
+ pp_string (buffer, "\"");
+ if (gimple_asm_nlabels (gs))
+ fields = 4;
+ else if (gimple_asm_nclobbers (gs))
+ fields = 3;
+ else if (gimple_asm_ninputs (gs))
+ fields = 2;
+ else if (gimple_asm_noutputs (gs))
+ fields = 1;
+ else
+ fields = 0;
-/* Dump the set of decls SYMS. BUFFER, SPC and FLAGS are as in
- dump_generic_node. */
+ for (f = 0; f < fields; ++f)
+ {
+ pp_string (buffer, " : ");
-static void
-dump_symbols (pretty_printer *buffer, bitmap syms, int flags)
-{
- unsigned i;
- bitmap_iterator bi;
+ switch (f)
+ {
+ case 0:
+ n = gimple_asm_noutputs (gs);
+ for (i = 0; i < n; i++)
+ {
+ dump_generic_node (buffer, gimple_asm_output_op (gs, i),
+ spc, flags, false);
+ if (i < n - 1)
+ pp_string (buffer, ", ");
+ }
+ break;
- if (syms == NULL)
- pp_string (buffer, "NIL");
- else
- {
- pp_string (buffer, " { ");
+ case 1:
+ n = gimple_asm_ninputs (gs);
+ for (i = 0; i < n; i++)
+ {
+ dump_generic_node (buffer, gimple_asm_input_op (gs, i),
+ spc, flags, false);
+ if (i < n - 1)
+ pp_string (buffer, ", ");
+ }
+ break;
- EXECUTE_IF_SET_IN_BITMAP (syms, 0, i, bi)
- {
- tree sym = referenced_var_lookup (i);
- dump_generic_node (buffer, sym, 0, flags, false);
- pp_string (buffer, " ");
+ case 2:
+ n = gimple_asm_nclobbers (gs);
+ for (i = 0; i < n; i++)
+ {
+ dump_generic_node (buffer, gimple_asm_clobber_op (gs, i),
+ spc, flags, false);
+ if (i < n - 1)
+ pp_string (buffer, ", ");
+ }
+ break;
+
+ case 3:
+ n = gimple_asm_nlabels (gs);
+ for (i = 0; i < n; i++)
+ {
+ dump_generic_node (buffer, gimple_asm_label_op (gs, i),
+ spc, flags, false);
+ if (i < n - 1)
+ pp_string (buffer, ", ");
+ }
+ break;
+
+ default:
+ gcc_unreachable ();
+ }
}
- pp_string (buffer, "}");
+ pp_string (buffer, ");");
}
}
}
for (i = 0; i < gimple_phi_num_args (phi); i++)
{
+ if ((flags & TDF_LINENO) && gimple_phi_arg_has_location (phi, i))
+ {
+ expanded_location xloc;
+
+ xloc = expand_location (gimple_phi_arg_location (phi, i));
+ pp_character (buffer, '[');
+ if (xloc.file)
+ {
+ pp_string (buffer, xloc.file);
+ pp_string (buffer, " : ");
+ }
+ pp_decimal_int (buffer, xloc.line);
+ pp_string (buffer, ":");
+ pp_decimal_int (buffer, xloc.column);
+ pp_string (buffer, "] ");
+ }
dump_generic_node (buffer, gimple_phi_arg_def (phi, i), spc, flags,
false);
- pp_string (buffer, "(");
+ pp_character (buffer, '(');
pp_decimal_int (buffer, gimple_phi_arg_edge (phi, i)->src->index);
- pp_string (buffer, ")");
+ pp_character (buffer, ')');
if (i < gimple_phi_num_args (phi) - 1)
pp_string (buffer, ", ");
}
- pp_string (buffer, ">");
+ pp_character (buffer, '>');
}
}
}
-/* Dump a GIMPLE_CHANGE_DYNAMIC_TYPE statement GS. BUFFER, SPC and
- FLAGS are as in dump_gimple_stmt. */
-
-static void
-dump_gimple_cdt (pretty_printer *buffer, gimple gs, int spc, int flags)
-{
- if (flags & TDF_RAW)
- dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T>", gs,
- gimple_cdt_new_type (gs), gimple_cdt_location (gs));
- else
- {
- pp_string (buffer, "<<<change_dynamic_type (");
- dump_generic_node (buffer, gimple_cdt_new_type (gs), spc + 2, flags,
- false);
- pp_string (buffer, ") ");
- dump_generic_node (buffer, gimple_cdt_location (gs), spc + 2, flags,
- false);
- pp_string (buffer, ")>>>");
- }
-}
-
/* Dump all the memory operands for statement GS. BUFFER, SPC and
FLAGS are as in dump_gimple_stmt. */
static void
dump_gimple_mem_ops (pretty_printer *buffer, gimple gs, int spc, int flags)
{
- struct voptype_d *vdefs;
- struct voptype_d *vuses;
- int i, n;
+ tree vdef = gimple_vdef (gs);
+ tree vuse = gimple_vuse (gs);
if (!ssa_operands_active () || !gimple_references_memory_p (gs))
return;
- /* Even if the statement doesn't have virtual operators yet, it may
- contain symbol information (this happens before aliases have been
- computed). */
- if ((flags & TDF_MEMSYMS)
- && gimple_vuse_ops (gs) == NULL
- && gimple_vdef_ops (gs) == NULL)
- {
- if (gimple_loaded_syms (gs))
- {
- pp_string (buffer, "# LOADS: ");
- dump_symbols (buffer, gimple_loaded_syms (gs), flags);
- newline_and_indent (buffer, spc);
- }
-
- if (gimple_stored_syms (gs))
- {
- pp_string (buffer, "# STORES: ");
- dump_symbols (buffer, gimple_stored_syms (gs), flags);
- newline_and_indent (buffer, spc);
- }
-
- return;
- }
-
- vuses = gimple_vuse_ops (gs);
- while (vuses)
+ if (vdef != NULL_TREE)
{
- pp_string (buffer, "# VUSE <");
-
- n = VUSE_NUM (vuses);
- for (i = 0; i < n; i++)
- {
- dump_generic_node (buffer, VUSE_OP (vuses, i), spc + 2, flags, false);
- if (i < n - 1)
- pp_string (buffer, ", ");
- }
-
- pp_string (buffer, ">");
-
- if (flags & TDF_MEMSYMS)
- dump_symbols (buffer, gimple_loaded_syms (gs), flags);
-
+ pp_string (buffer, "# ");
+ dump_generic_node (buffer, vdef, spc + 2, flags, false);
+ pp_string (buffer, " = VDEF <");
+ dump_generic_node (buffer, vuse, spc + 2, flags, false);
+ pp_character (buffer, '>');
newline_and_indent (buffer, spc);
- vuses = vuses->next;
}
-
- vdefs = gimple_vdef_ops (gs);
- while (vdefs)
+ else if (vuse != NULL_TREE)
{
- pp_string (buffer, "# ");
- dump_generic_node (buffer, VDEF_RESULT (vdefs), spc + 2, flags, false);
- pp_string (buffer, " = VDEF <");
-
- n = VDEF_NUM (vdefs);
- for (i = 0; i < n; i++)
- {
- dump_generic_node (buffer, VDEF_OP (vdefs, i), spc + 2, flags, 0);
- if (i < n - 1)
- pp_string (buffer, ", ");
- }
-
- pp_string (buffer, ">");
-
- if ((flags & TDF_MEMSYMS) && vdefs->next == NULL)
- dump_symbols (buffer, gimple_stored_syms (gs), flags);
-
+ pp_string (buffer, "# VUSE <");
+ dump_generic_node (buffer, vuse, spc + 2, flags, false);
+ pp_character (buffer, '>');
newline_and_indent (buffer, spc);
- vdefs = vdefs->next;
}
}
pp_string (buffer, " : ");
}
pp_decimal_int (buffer, xloc.line);
+ pp_string (buffer, ":");
+ pp_decimal_int (buffer, xloc.column);
pp_string (buffer, "] ");
}
+ if (flags & TDF_EH)
+ {
+ int lp_nr = lookup_stmt_eh_lp (gs);
+ if (lp_nr > 0)
+ pp_printf (buffer, "[LP %d] ", lp_nr);
+ else if (lp_nr < 0)
+ pp_printf (buffer, "[MNT %d] ", -lp_nr);
+ }
+
if ((flags & (TDF_VOPS|TDF_MEMSYMS))
&& gimple_has_mem_ops (gs))
dump_gimple_mem_ops (buffer, gs, spc, flags);
dump_gimple_omp_critical (buffer, gs, spc, flags);
break;
- case GIMPLE_CHANGE_DYNAMIC_TYPE:
- dump_gimple_cdt (buffer, gs, spc, flags);
- break;
-
case GIMPLE_CATCH:
dump_gimple_catch (buffer, gs, spc, flags);
break;
dump_gimple_eh_filter (buffer, gs, spc, flags);
break;
+ case GIMPLE_EH_MUST_NOT_THROW:
+ dump_gimple_eh_must_not_throw (buffer, gs, spc, flags);
+ break;
+
case GIMPLE_RESX:
dump_gimple_resx (buffer, gs, spc, flags);
break;
+ case GIMPLE_EH_DISPATCH:
+ dump_gimple_eh_dispatch (buffer, gs, spc, flags);
+ break;
+
+ case GIMPLE_DEBUG:
+ dump_gimple_debug (buffer, gs, spc, flags);
+ break;
+
case GIMPLE_PREDICT:
pp_string (buffer, "// predicted ");
if (gimple_predict_outcome (gs))
gimple_stmt_iterator gsi;
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
- if (get_lineno (gsi_stmt (gsi)) != -1)
+ if (!is_gimple_debug (gsi_stmt (gsi))
+ && get_lineno (gsi_stmt (gsi)) != UNKNOWN_LOCATION)
{
pp_string (buffer, ", starting at line ");
pp_decimal_int (buffer, get_lineno (gsi_stmt (gsi)));
break;
}
+
+ if (bb->discriminator)
+ {
+ pp_string (buffer, ", discriminator ");
+ pp_decimal_int (buffer, bb->discriminator);
+ }
}
newline_and_indent (buffer, indent);
FOR_EACH_EDGE (e, ei, bb->preds)
if (flags & TDF_SLIM)
{
- pp_string (buffer, " ");
+ pp_character (buffer, ' ');
if (e->src == ENTRY_BLOCK_PTR)
pp_string (buffer, "ENTRY");
else
FOR_EACH_EDGE (e, ei, bb->succs)
if (flags & TDF_SLIM)
{
- pp_string (buffer, " ");
+ pp_character (buffer, ' ');
if (e->dest == EXIT_BLOCK_PTR)
pp_string (buffer, "EXIT");
else
pp_string (buffer, "goto <bb ");
pp_decimal_int (buffer, bb->index);
- pp_string (buffer, ">");
+ pp_character (buffer, '>');
if (stmt && gimple_code (stmt) == GIMPLE_LABEL)
{
pp_string (buffer, " (");
dump_generic_node (buffer, gimple_label_label (stmt), 0, 0, false);
- pp_string (buffer, ")");
+ pp_character (buffer, ')');
pp_semicolon (buffer);
}
else
pp_string (buffer, " : ");
}
pp_decimal_int (buffer, goto_xloc.line);
+ pp_string (buffer, " : ");
+ pp_decimal_int (buffer, goto_xloc.column);
pp_string (buffer, "] ");
}
OSDN Git Service
