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

pretty-print.h (pp_underscore): New. 

* pretty-print.h (pp_underscore): New.
	(pp_comma): Tidy.
	* gimple-pretty-print.c (dump_unary_rhs): Use specialized pretty
	printer functions instead of pp_character.
	(dump_binary_rhs): Likewise.
	(dump_ternary_rhs): Likewise.
	(dump_gimple_call_args): Likewise.
	(pp_points_to_solution): Likewise.
	(dump_gimple_call): Likewise.
	(dump_gimple_switch): Likewise.
	(dump_gimple_cond): Likewise.
	(dump_gimple_bind): Likewise.
	(dump_gimple_try): Likewise.
	(dump_gimple_omp_for): Likewise.
	(dump_gimple_omp_continue): Likewise.
	(dump_gimple_omp_single): Likewise.
	(dump_gimple_omp_sections): Likewise.
	(dump_gimple_omp_block): Likewise.
	(dump_gimple_omp_critical): Likewise.
	(dump_gimple_transaction): Likewise.
	(dump_gimple_asm): Likewise.
	(dump_gimple_phi): Likewise.
	(dump_gimple_omp_parallel): Likewise.
	(dump_gimple_omp_task): Likewise.
	(dump_gimple_omp_atomic_load): Likewise.
	(dump_gimple_omp_atomic_store): Likewise.
	(dump_gimple_mem_ops): Likewise.
	(pp_gimple_stmt_1): Likewise.
	(pp_cfg_jump): Likewise.
	(dump_implicit_edges): Likewise.
	(gimple_dump_bb_for_graph): Likewise.
	* graph.c (draw_cfg_node): Likewise.
	* langhooks.c (lhd_print_error_function): Likewise.
	* sched-vis.c (print_exp): Likewise.
	(print_value): Likewise.
	(print_pattern): Likewise.
	(print_insn): Likewise.
	(rtl_dump_bb_for_graph): Likewise.
	* tree-pretty-print.c (dump_function_declaration): Likewise.
	(dump_array_domain): Likewise.
	(dump_omp_clause): Likewise.
	(dump_location): Likewise.
	(dump_generic_node): Likewise.
	(print_struct_decl): Likewise.
	* diagnostic.c (diagnostic_show_locus): Use pp_space.

c-family/
	* c-ada-spec.c (print_ada_macros): Use specialized pretty printer
	functions instead of pp_character.
	(pp_ada_tree_identifier): Likewise.
	(dump_ada_double_name): Likewise.
	(dump_ada_function_declaration): Likewise.
	(dump_ada_array_domains): Likewise.
	(dump_template_types): Likewise.
	(dump_generic_ada_node): Likewise.
	(print_ada_declaration): Likewise.
	(print_ada_struct_decl): Likewise.
	* c-pretty-print.c (pp_c_integer_constant): Likewise.

cp/
	* error.c (dump_aggr_type): Use specialized pretty printer
	functions instead of pp_character.
	(dump_type_prefix): Likewise.
	(dump_simple_decl): Likewise.
	(type_to_string): Likewise.

From-SVN: r201467
This commit is contained in:
Gabriel Dos Reis 2013-08-03 18:57:25 +00:00 committed by Gabriel Dos Reis
parent bb0d2039ba
commit 07838b1363
13 changed files with 301 additions and 231 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
gcc/ChangeLog
View File

@ -1,3 +1,51 @@
2013-08-03 Gabriel Dos Reis <gdr@integrable-solutions.net>
* pretty-print.h (pp_underscore): New.
(pp_comma): Tidy.
* gimple-pretty-print.c (dump_unary_rhs): Use specialized pretty
printer functions instead of pp_character.
(dump_binary_rhs): Likewise.
(dump_ternary_rhs): Likewise.
(dump_gimple_call_args): Likewise.
(pp_points_to_solution): Likewise.
(dump_gimple_call): Likewise.
(dump_gimple_switch): Likewise.
(dump_gimple_cond): Likewise.
(dump_gimple_bind): Likewise.
(dump_gimple_try): Likewise.
(dump_gimple_omp_for): Likewise.
(dump_gimple_omp_continue): Likewise.
(dump_gimple_omp_single): Likewise.
(dump_gimple_omp_sections): Likewise.
(dump_gimple_omp_block): Likewise.
(dump_gimple_omp_critical): Likewise.
(dump_gimple_transaction): Likewise.
(dump_gimple_asm): Likewise.
(dump_gimple_phi): Likewise.
(dump_gimple_omp_parallel): Likewise.
(dump_gimple_omp_task): Likewise.
(dump_gimple_omp_atomic_load): Likewise.
(dump_gimple_omp_atomic_store): Likewise.
(dump_gimple_mem_ops): Likewise.
(pp_gimple_stmt_1): Likewise.
(pp_cfg_jump): Likewise.
(dump_implicit_edges): Likewise.
(gimple_dump_bb_for_graph): Likewise.
* graph.c (draw_cfg_node): Likewise.
* langhooks.c (lhd_print_error_function): Likewise.
* sched-vis.c (print_exp): Likewise.
(print_value): Likewise.
(print_pattern): Likewise.
(print_insn): Likewise.
(rtl_dump_bb_for_graph): Likewise.
* tree-pretty-print.c (dump_function_declaration): Likewise.
(dump_array_domain): Likewise.
(dump_omp_clause): Likewise.
(dump_location): Likewise.
(dump_generic_node): Likewise.
(print_struct_decl): Likewise.
* diagnostic.c (diagnostic_show_locus): Use pp_space.
2013-08-03 Bill Schmidt <wschmidt@vnet.linux.ibm.com>
* gimple-ssa-strength-reduction.c (replace_mult_candidate): Update

14
gcc/c-family/ChangeLog
View File

@ -1,3 +1,17 @@
2013-08-03 Gabriel Dos Reis <gdr@integrable-solutions.net>
* c-ada-spec.c (print_ada_macros): Use specialized pretty printer
functions instead of pp_character.
(pp_ada_tree_identifier): Likewise.
(dump_ada_double_name): Likewise.
(dump_ada_function_declaration): Likewise.
(dump_ada_array_domains): Likewise.
(dump_template_types): Likewise.
(dump_generic_ada_node): Likewise.
(print_ada_declaration): Likewise.
(print_ada_struct_decl): Likewise.
* c-pretty-print.c (pp_c_integer_constant): Likewise.
2013-07-23 Tom Tromey <tromey@redhat.com>
* c-common.h (enum rid) <RID_GENERIC>: New constant.

28
gcc/c-family/c-ada-spec.c
View File

@ -418,7 +418,7 @@ print_ada_macros (pretty_printer *pp, cpp_hashnode **macros, int max_ada_macros)
pp_string (pp, "; -- ");
pp_string (pp, sloc.file);
pp_character (pp, ':');
pp_colon (pp);
pp_scalar (pp, "%d", sloc.line);
pp_newline (pp);
}
@ -1253,7 +1253,7 @@ pp_ada_tree_identifier (pretty_printer *buffer, tree node, tree type,
{
append_withs (s1, limited_access);
pp_string (buffer, s1);
pp_character (buffer, '.');
pp_dot (buffer);
}
free (s1);
}
@ -1375,7 +1375,7 @@ dump_ada_double_name (pretty_printer *buffer, tree t1, tree t2, const char *s)
pp_scalar (buffer, "%d", TYPE_UID (TREE_TYPE (t1)));
}
pp_character (buffer, '_');
pp_underscore (buffer);
if (DECL_NAME (t1))
pp_ada_tree_identifier (buffer, DECL_NAME (t2), t2, false);
@ -1489,7 +1489,7 @@ dump_ada_function_declaration (pretty_printer *buffer, tree func,
if (num_args > 0)
{
pp_space (buffer);
pp_character (buffer, '(');
pp_left_paren (buffer);
}
if (TREE_CODE (func) == FUNCTION_DECL)
@ -1550,7 +1550,7 @@ dump_ada_function_declaration (pretty_printer *buffer, tree func,
if (num < num_args)
{
pp_character (buffer, ';');
pp_semicolon (buffer);
if (num_args > 2)
newline_and_indent (buffer, spc + INDENT_INCR);
@ -1566,7 +1566,7 @@ dump_ada_function_declaration (pretty_printer *buffer, tree func,
}
if (num_args > 0)
pp_character (buffer, ')');
pp_right_paren (buffer);
return num_args;
}
@ -1577,7 +1577,7 @@ static void
dump_ada_array_domains (pretty_printer *buffer, tree node, int spc)
{
int first = 1;
pp_character (buffer, '(');
pp_left_paren (buffer);
for (; TREE_CODE (node) == ARRAY_TYPE; node = TREE_TYPE (node))
{
@ -1606,7 +1606,7 @@ dump_ada_array_domains (pretty_printer *buffer, tree node, int spc)
else
pp_string (buffer, "size_t");
}
pp_character (buffer, ')');
pp_right_paren (buffer);
}
/* Dump in BUFFER file:line information related to NODE. */
@ -1706,7 +1706,7 @@ dump_template_types (pretty_printer *buffer, tree types,
for (i = 0; i < len; i++)
{
tree elem = TREE_VEC_ELT (types, i);
pp_character (buffer, '_');
pp_underscore (buffer);
if (!dump_generic_ada_node (buffer, elem, 0, cpp_check, spc, false, true))
{
pp_string (buffer, "unknown");
@ -2215,7 +2215,7 @@ dump_generic_ada_node (pretty_printer *buffer, tree node, tree type,
if (tree_int_cst_sgn (val) < 0)
{
pp_character (buffer, '-');
pp_minus (buffer);
high = ~high + !low;
low = -low;
}
@ -2986,7 +2986,7 @@ print_ada_declaration (pretty_printer *buffer, tree t, tree type,
dump_generic_ada_node
(buffer, TYPE_NAME (TREE_TYPE (t)), type, cpp_check,
spc, false, true);
pp_character (buffer, ')');
pp_right_paren (buffer);
print_ada_methods (buffer, TREE_TYPE (t), cpp_check, spc);
}
@ -3226,7 +3226,7 @@ print_ada_struct_decl (pretty_printer *buffer, tree node, tree type,
dump_generic_ada_node
(buffer, TREE_TYPE (type), type, cpp_check, spc, false, true);
package_prefix = true;
pp_character (buffer, ')');
pp_right_paren (buffer);
if (is_union)
{
@ -3236,7 +3236,7 @@ print_ada_struct_decl (pretty_printer *buffer, tree node, tree type,
dump_generic_ada_node
(buffer, TREE_TYPE (type), type, cpp_check, spc, false, true);
pp_character (buffer, ')');
pp_right_paren (buffer);
}
if (bitfield_used)
@ -3246,7 +3246,7 @@ print_ada_struct_decl (pretty_printer *buffer, tree node, tree type,
pp_string (buffer, "pragma Pack (");
dump_generic_ada_node
(buffer, TREE_TYPE (type), type, cpp_check, spc, false, true);
pp_character (buffer, ')');
pp_right_paren (buffer);
bitfield_used = false;
}

2
gcc/c-family/c-pretty-print.c
View File

@ -920,7 +920,7 @@ pp_c_integer_constant (c_pretty_printer *pp, tree i)
HOST_WIDE_INT high = TREE_INT_CST_HIGH (i);
if (tree_int_cst_sgn (i) < 0)
{
pp_character (pp, '-');
pp_minus (pp);
high = ~high + !low;
low = -low;
}

8
gcc/cp/ChangeLog
View File

@ -1,3 +1,11 @@
2013-08-03 Gabriel Dos Reis <gdr@integrable-solutions.net>
* error.c (dump_aggr_type): Use specialized pretty printer
functions instead of pp_character.
(dump_type_prefix): Likewise.
(dump_simple_decl): Likewise.
(type_to_string): Likewise.
2013-08-02 Paolo Carlini <paolo.carlini@oracle.com>
* cp-tree.h (finish_stmt): Do not declare.

10
gcc/cp/error.c
View File

@ -663,7 +663,7 @@ dump_aggr_type (tree t, int flags)
if (lambda_function (t))
dump_parameters (FUNCTION_FIRST_USER_PARMTYPE (lambda_function (t)),
flags);
pp_character(cxx_pp, '>');
pp_greater (cxx_pp);
}
else
pp_cxx_tree_identifier (cxx_pp, name);
@ -710,13 +710,13 @@ dump_type_prefix (tree t, int flags)
TYPE_ATTRIBUTES (sub));
}
if (TYPE_PTR_P (t))
pp_character(cxx_pp, '*');
pp_star (cxx_pp);
else if (TREE_CODE (t) == REFERENCE_TYPE)
{
if (TYPE_REF_IS_RVALUE (t))
pp_string (cxx_pp, "&&");
else
pp_character (cxx_pp, '&');
pp_ampersand (cxx_pp);
}
pp_base (cxx_pp)->padding = pp_before;
pp_cxx_cv_qualifier_seq (cxx_pp, t);
@ -946,7 +946,7 @@ dump_simple_decl (tree t, tree type, int flags)
{
if (TREE_CODE (t) == FIELD_DECL && DECL_NORMAL_CAPTURE_P (t))
{
pp_character (cxx_pp, '<');
pp_less (cxx_pp);
pp_string (cxx_pp, IDENTIFIER_POINTER (DECL_NAME (t)) + 2);
pp_string (cxx_pp, " capture>");
}
@ -2870,7 +2870,7 @@ type_to_string (tree typ, int verbose)
/* And remember the start of the aka dump. */
aka_start = obstack_object_size (ob);
dump_type (aka, flags);
pp_character (cxx_pp, '}');
pp_right_brace (cxx_pp);
p = (char*)obstack_base (ob);
/* If they are identical, cut off the aka with a NUL. */
if (memcmp (p, p+aka_start, len) == 0)

2
gcc/diagnostic.c
View File

@ -306,7 +306,7 @@ diagnostic_show_locus (diagnostic_context * context,
pp_newline (context->printer);
saved_prefix = pp_get_prefix (context->printer);
pp_set_prefix (context->printer, NULL);
pp_character (context->printer, ' ');
pp_space (context->printer);
while (max_width > 0 && *line != '\0')
{
char c = *line == '\t' ? ' ' : *line;

150
gcc/gimple-pretty-print.c
View File

@ -280,14 +280,14 @@ dump_unary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
case FIX_TRUNC_EXPR:
case FLOAT_EXPR:
CASE_CONVERT:
pp_character (buffer, '(');
pp_left_paren (buffer);
dump_generic_node (buffer, TREE_TYPE (lhs), spc, flags, false);
pp_string (buffer, ") ");
if (op_prio (rhs) < op_code_prio (rhs_code))
{
pp_character (buffer, '(');
pp_left_paren (buffer);
dump_generic_node (buffer, rhs, spc, flags, false);
pp_character (buffer, ')');
pp_right_paren (buffer);
}
else
dump_generic_node (buffer, rhs, spc, flags, false);
@ -302,7 +302,7 @@ dump_unary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
case ABS_EXPR:
pp_string (buffer, "ABS_EXPR <");
dump_generic_node (buffer, rhs, spc, flags, false);
pp_character (buffer, '>');
pp_greater (buffer);
break;
default:
@ -317,23 +317,23 @@ dump_unary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
break;
}
else if (rhs_code == BIT_NOT_EXPR)
pp_character (buffer, '~');
pp_complement (buffer);
else if (rhs_code == TRUTH_NOT_EXPR)
pp_character (buffer, '!');
pp_exclamation (buffer);
else if (rhs_code == NEGATE_EXPR)
pp_character (buffer, '-');
pp_minus (buffer);
else
{
pp_character (buffer, '[');
pp_left_bracket (buffer);
pp_string (buffer, tree_code_name [rhs_code]);
pp_string (buffer, "] ");
}
if (op_prio (rhs) < op_code_prio (rhs_code))
{
pp_character (buffer, '(');
pp_left_paren (buffer);
dump_generic_node (buffer, rhs, spc, flags, false);
pp_character (buffer, ')');
pp_right_paren (buffer);
}
else
dump_generic_node (buffer, rhs, spc, flags, false);
@ -370,16 +370,16 @@ dump_binary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
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_character (buffer, '>');
pp_greater (buffer);
break;
default:
if (op_prio (gimple_assign_rhs1 (gs)) <= op_code_prio (code))
{
pp_character (buffer, '(');
pp_left_paren (buffer);
dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags,
false);
pp_character (buffer, ')');
pp_right_paren (buffer);
}
else
dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
@ -388,10 +388,10 @@ dump_binary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
pp_space (buffer);
if (op_prio (gimple_assign_rhs2 (gs)) <= op_code_prio (code))
{
pp_character (buffer, '(');
pp_left_paren (buffer);
dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags,
false);
pp_character (buffer, ')');
pp_right_paren (buffer);
}
else
dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
@ -418,7 +418,7 @@ dump_ternary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
pp_string (buffer, ", ");
dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
pp_character (buffer, '>');
pp_greater (buffer);
break;
case FMA_EXPR:
@ -517,7 +517,7 @@ dump_gimple_assign (pretty_printer *buffer, gimple gs, int spc, int flags)
{
dump_generic_node (buffer, gimple_assign_lhs (gs), spc, flags, false);
pp_space (buffer);
pp_character (buffer, '=');
pp_equal (buffer);
if (gimple_assign_nontemporal_move_p (gs))
pp_string (buffer, "{nt}");
@ -585,7 +585,7 @@ dump_gimple_call_args (pretty_printer *buffer, gimple gs, int flags)
{
if (gimple_call_num_args (gs) > 0)
{
pp_character (buffer, ',');
pp_comma (buffer);
pp_space (buffer);
}
@ -621,9 +621,9 @@ pp_points_to_solution (pretty_printer *buffer, struct pt_solution *pt)
{
pp_string (buffer, "D.");
pp_decimal_int (buffer, i);
pp_character (buffer, ' ');
pp_space (buffer);
}
pp_character (buffer, '}');
pp_right_brace (buffer);
if (pt->vars_contains_global)
pp_string (buffer, " (glob)");
}
@ -669,7 +669,7 @@ dump_gimple_call (pretty_printer *buffer, gimple gs, int spc, int flags)
pp_string (buffer, ", ");
dump_gimple_call_args (buffer, gs, flags);
}
pp_character (buffer, '>');
pp_greater (buffer);
}
else
{
@ -689,7 +689,7 @@ dump_gimple_call (pretty_printer *buffer, gimple gs, int spc, int flags)
print_call_name (buffer, fn, flags);
pp_string (buffer, " (");
dump_gimple_call_args (buffer, gs, flags);
pp_character (buffer, ')');
pp_right_paren (buffer);
if (!(flags & TDF_RHS_ONLY))
pp_semicolon (buffer);
}
@ -698,7 +698,7 @@ dump_gimple_call (pretty_printer *buffer, gimple gs, int spc, int flags)
{
pp_string (buffer, " [static-chain: ");
dump_generic_node (buffer, gimple_call_chain (gs), spc, flags, false);
pp_character (buffer, ']');
pp_right_bracket (buffer);
}
if (gimple_call_return_slot_opt_p (gs))
@ -786,12 +786,12 @@ dump_gimple_switch (pretty_printer *buffer, gimple gs, int spc, int flags)
tree case_label = gimple_switch_label (gs, i);
gcc_checking_assert (case_label != NULL_TREE);
dump_generic_node (buffer, case_label, spc, flags, false);
pp_character (buffer, ' ');
pp_space (buffer);
dump_generic_node (buffer, CASE_LABEL (case_label), spc, flags, false);
if (i < gimple_switch_num_labels (gs) - 1)
pp_string (buffer, ", ");
}
pp_character (buffer, '>');
pp_greater (buffer);
}
@ -817,7 +817,7 @@ dump_gimple_cond (pretty_printer *buffer, gimple gs, int spc, int flags)
dump_generic_node (buffer, gimple_cond_rhs (gs), spc, flags, false);
if (!(flags & TDF_RHS_ONLY))
{
pp_character (buffer, ')');
pp_right_paren (buffer);
if (gimple_cond_true_label (gs))
{
@ -851,7 +851,7 @@ dump_gimple_label (pretty_printer *buffer, gimple gs, int spc, int flags)
else
{
dump_generic_node (buffer, label, spc, flags, false);
pp_character (buffer, ':');
pp_colon (buffer);
}
if (DECL_NONLOCAL (label))
pp_string (buffer, " [non-local]");
@ -884,7 +884,7 @@ dump_gimple_bind (pretty_printer *buffer, gimple gs, int spc, int flags)
if (flags & TDF_RAW)
dump_gimple_fmt (buffer, spc, flags, "%G <", gs);
else
pp_character (buffer, '{');
pp_left_brace (buffer);
if (!(flags & TDF_SLIM))
{
tree var;
@ -901,9 +901,9 @@ dump_gimple_bind (pretty_printer *buffer, gimple gs, int spc, int flags)
dump_gimple_seq (buffer, gimple_bind_body (gs), spc + 2, flags);
newline_and_indent (buffer, spc);
if (flags & TDF_RAW)
pp_character (buffer, '>');
pp_greater (buffer);
else
pp_character (buffer, '}');
pp_right_brace (buffer);
}
@ -931,26 +931,26 @@ dump_gimple_try (pretty_printer *buffer, gimple gs, int spc, int flags)
{
pp_string (buffer, "try");
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '{');
pp_left_brace (buffer);
pp_newline (buffer);
dump_gimple_seq (buffer, gimple_try_eval (gs), spc + 4, flags);
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '}');
pp_right_brace (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_character (buffer, '{');
pp_left_brace (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_character (buffer, '{');
pp_left_brace (buffer);
}
else
pp_string (buffer, " <UNKNOWN GIMPLE_TRY> {");
@ -958,7 +958,7 @@ dump_gimple_try (pretty_printer *buffer, gimple gs, int spc, int flags)
pp_newline (buffer);
dump_gimple_seq (buffer, gimple_try_cleanup (gs), spc + 4, flags);
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '}');
pp_right_brace (buffer);
}
}
@ -1139,10 +1139,10 @@ dump_gimple_omp_for (pretty_printer *buffer, gimple gs, int spc, int flags)
switch (gimple_omp_for_cond (gs, i))
{
case LT_EXPR:
pp_character (buffer, '<');
pp_less (buffer);
break;
case GT_EXPR:
pp_character (buffer, '>');
pp_greater (buffer);
break;
case LE_EXPR:
pp_string (buffer, "<=");
@ -1163,17 +1163,17 @@ dump_gimple_omp_for (pretty_printer *buffer, gimple gs, int spc, int flags)
pp_string (buffer, " = ");
dump_generic_node (buffer, gimple_omp_for_incr (gs, i), spc,
flags, false);
pp_character (buffer, ')');
pp_right_paren (buffer);
}
if (!gimple_seq_empty_p (gimple_omp_body (gs)))
{
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '{');
pp_left_brace (buffer);
pp_newline (buffer);
dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '}');
pp_right_brace (buffer);
}
}
}
@ -1194,11 +1194,11 @@ dump_gimple_omp_continue (pretty_printer *buffer, gimple gs, int spc, int flags)
pp_string (buffer, "#pragma omp continue (");
dump_generic_node (buffer, gimple_omp_continue_control_def (gs),
spc, flags, false);
pp_character (buffer, ',');
pp_comma (buffer);
pp_space (buffer);
dump_generic_node (buffer, gimple_omp_continue_control_use (gs),
spc, flags, false);
pp_character (buffer, ')');
pp_right_paren (buffer);
}
}
@ -1221,11 +1221,11 @@ dump_gimple_omp_single (pretty_printer *buffer, gimple gs, int spc, int flags)
if (!gimple_seq_empty_p (gimple_omp_body (gs)))
{
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '{');
pp_left_brace (buffer);
pp_newline (buffer);
dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '}');
pp_right_brace (buffer);
}
}
}
@ -1251,17 +1251,17 @@ dump_gimple_omp_sections (pretty_printer *buffer, gimple gs, int spc,
pp_string (buffer, " <");
dump_generic_node (buffer, gimple_omp_sections_control (gs), spc,
flags, false);
pp_character (buffer, '>');
pp_greater (buffer);
}
dump_omp_clauses (buffer, gimple_omp_sections_clauses (gs), spc, flags);
if (!gimple_seq_empty_p (gimple_omp_body (gs)))
{
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '{');
pp_left_brace (buffer);
pp_newline (buffer);
dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '}');
pp_right_brace (buffer);
}
}
}
@ -1294,11 +1294,11 @@ dump_gimple_omp_block (pretty_printer *buffer, gimple gs, int spc, int flags)
if (!gimple_seq_empty_p (gimple_omp_body (gs)))
{
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '{');
pp_left_brace (buffer);
pp_newline (buffer);
dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '}');
pp_right_brace (buffer);
}
}
}
@ -1320,16 +1320,16 @@ dump_gimple_omp_critical (pretty_printer *buffer, gimple gs, int spc,
pp_string (buffer, " (");
dump_generic_node (buffer, gimple_omp_critical_name (gs), spc,
flags, false);
pp_character (buffer, ')');
pp_right_paren (buffer);
}
if (!gimple_seq_empty_p (gimple_omp_body (gs)))
{
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '{');
pp_left_brace (buffer);
pp_newline (buffer);
dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '}');
pp_right_brace (buffer);
}
}
}
@ -1427,12 +1427,12 @@ dump_gimple_transaction (pretty_printer *buffer, gimple gs, int spc, int flags)
if (!gimple_seq_empty_p (gimple_transaction_body (gs)))
{
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '{');
pp_left_brace (buffer);
pp_newline (buffer);
dump_gimple_seq (buffer, gimple_transaction_body (gs),
spc + 4, flags);
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '}');
pp_right_brace (buffer);
}
}
}
@ -1508,7 +1508,7 @@ dump_gimple_asm (pretty_printer *buffer, gimple gs, int spc, int flags)
}
newline_and_indent (buffer, spc);
pp_character (buffer, '>');
pp_greater (buffer);
}
else
{
@ -1634,7 +1634,7 @@ dump_gimple_phi (pretty_printer *buffer, gimple phi, int spc, int flags)
expanded_location xloc;
xloc = expand_location (gimple_phi_arg_location (phi, i));
pp_character (buffer, '[');
pp_left_bracket (buffer);
if (xloc.file)
{
pp_string (buffer, xloc.file);
@ -1647,13 +1647,13 @@ dump_gimple_phi (pretty_printer *buffer, gimple phi, int spc, int flags)
}
dump_generic_node (buffer, gimple_phi_arg_def (phi, i), spc, flags,
false);
pp_character (buffer, '(');
pp_left_paren (buffer);
pp_decimal_int (buffer, gimple_phi_arg_edge (phi, i)->src->index);
pp_character (buffer, ')');
pp_right_paren (buffer);
if (i < gimple_phi_num_args (phi) - 1)
pp_string (buffer, ", ");
}
pp_character (buffer, '>');
pp_greater (buffer);
}
@ -1696,11 +1696,11 @@ dump_gimple_omp_parallel (pretty_printer *buffer, gimple gs, int spc,
if (body && gimple_code (gimple_seq_first_stmt (body)) != GIMPLE_BIND)
{
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '{');
pp_left_brace (buffer);
pp_newline (buffer);
dump_gimple_seq (buffer, body, spc + 4, flags);
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '}');
pp_right_brace (buffer);
}
else if (body)
{
@ -1753,11 +1753,11 @@ dump_gimple_omp_task (pretty_printer *buffer, gimple gs, int spc,
if (body && gimple_code (gimple_seq_first_stmt (body)) != GIMPLE_BIND)
{
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '{');
pp_left_brace (buffer);
pp_newline (buffer);
dump_gimple_seq (buffer, body, spc + 4, flags);
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '}');
pp_right_brace (buffer);
}
else if (body)
{
@ -1791,9 +1791,9 @@ dump_gimple_omp_atomic_load (pretty_printer *buffer, gimple gs, int spc,
dump_generic_node (buffer, gimple_omp_atomic_load_lhs (gs),
spc, flags, false);
pp_space (buffer);
pp_character (buffer, '=');
pp_equal (buffer);
pp_space (buffer);
pp_character (buffer, '*');
pp_star (buffer);
dump_generic_node (buffer, gimple_omp_atomic_load_rhs (gs),
spc, flags, false);
}
@ -1817,10 +1817,10 @@ dump_gimple_omp_atomic_store (pretty_printer *buffer, gimple gs, int spc,
pp_string (buffer, "#pragma omp atomic_store ");
if (gimple_omp_atomic_need_value_p (gs))
pp_string (buffer, "[needed] ");
pp_character (buffer, '(');
pp_left_paren (buffer);
dump_generic_node (buffer, gimple_omp_atomic_store_val (gs),
spc, flags, false);
pp_character (buffer, ')');
pp_right_paren (buffer);
}
}
@ -1844,14 +1844,14 @@ dump_gimple_mem_ops (pretty_printer *buffer, gimple gs, int spc, int flags)
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, '>');
pp_greater (buffer);
newline_and_indent (buffer, spc);
}
else if (vuse != NULL_TREE)
{
pp_string (buffer, "# VUSE <");
dump_generic_node (buffer, vuse, spc + 2, flags, false);
pp_character (buffer, '>');
pp_greater (buffer);
newline_and_indent (buffer, spc);
}
}
@ -1874,7 +1874,7 @@ pp_gimple_stmt_1 (pretty_printer *buffer, gimple gs, int spc, int flags)
if ((flags & TDF_LINENO) && gimple_has_location (gs))
{
expanded_location xloc = expand_location (gimple_location (gs));
pp_character (buffer, '[');
pp_left_bracket (buffer);
if (xloc.file)
{
pp_string (buffer, xloc.file);
@ -2155,12 +2155,12 @@ pp_cfg_jump (pretty_printer *buffer, basic_block bb)
pp_string (buffer, "goto <bb ");
pp_decimal_int (buffer, bb->index);
pp_character (buffer, '>');
pp_greater (buffer);
if (stmt && gimple_code (stmt) == GIMPLE_LABEL)
{
pp_string (buffer, " (");
dump_generic_node (buffer, gimple_label_label (stmt), 0, 0, false);
pp_character (buffer, ')');
pp_right_paren (buffer);
pp_semicolon (buffer);
}
else
@ -2215,7 +2215,7 @@ dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,
{
expanded_location goto_xloc;
goto_xloc = expand_location (e->goto_locus);
pp_character (buffer, '[');
pp_left_bracket (buffer);
if (goto_xloc.file)
{
pp_string (buffer, goto_xloc.file);
@ -2304,7 +2304,7 @@ gimple_dump_bb_for_graph (pretty_printer *pp, basic_block bb)
if (!virtual_operand_p (gimple_phi_result (phi))
|| (dump_flags & TDF_VOPS))
{
pp_character (pp, '|');
pp_bar (pp);
pp_write_text_to_stream (pp);
pp_string (pp, "# ");
pp_gimple_stmt_1 (pp, phi, 0, dump_flags);
@ -2316,7 +2316,7 @@ gimple_dump_bb_for_graph (pretty_printer *pp, basic_block bb)
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
gimple stmt = gsi_stmt (gsi);
pp_character (pp, '|');
pp_bar (pp);
pp_write_text_to_stream (pp);
pp_gimple_stmt_1 (pp, stmt, 0, dump_flags);
pp_newline (pp);

4
gcc/graph.c
View File

@ -109,10 +109,10 @@ draw_cfg_node (pretty_printer *pp, int funcdef_no, basic_block bb)
pp_string (pp, "EXIT");
else
{
pp_character (pp, '{');
pp_left_brace (pp);
pp_write_text_to_stream (pp);
dump_bb_for_graph (pp, bb);
pp_character (pp, '}');
pp_right_brace (pp);
}
pp_string (pp, "\"];\n\n");

4
gcc/langhooks.c
View File

@ -446,7 +446,7 @@ lhd_print_error_function (diagnostic_context *context, const char *file,
if (fndecl)
{
expanded_location s = expand_location (*locus);
pp_character (context->printer, ',');
pp_comma (context->printer);
pp_newline (context->printer);
if (s.file != NULL)
{
@ -467,7 +467,7 @@ lhd_print_error_function (diagnostic_context *context, const char *file,
identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2)));
}
}
pp_character (context->printer, ':');
pp_colon (context->printer);
}
diagnostic_set_last_function (context, diagnostic);

3
gcc/pretty-print.h
View File

@ -238,7 +238,7 @@ pp_base_get_prefix (const pretty_printer *pp) { return pp->prefix; }
#define pp_left_brace(PP) pp_character (PP, '{')
#define pp_right_brace(PP) pp_character (PP, '}')
#define pp_semicolon(PP) pp_character (PP, ';')
#define pp_comma(PP) pp_string (PP, ", ")
#define pp_comma(PP) pp_character (PP, ',')
#define pp_dot(PP) pp_character (PP, '.')
#define pp_colon(PP) pp_character (PP, ':')
#define pp_colon_colon(PP) pp_string (PP, "::")
@ -260,6 +260,7 @@ pp_base_get_prefix (const pretty_printer *pp) { return pp->prefix; }
#define pp_quote(PP) pp_character (PP, '\'')
#define pp_backquote(PP) pp_character (PP, '`')
#define pp_doublequote(PP) pp_character (PP, '"')
#define pp_underscore(PP) pp_character (PP, '_')
#define pp_newline_and_flush(PP) \
do { \
pp_newline (PP); \

40
gcc/sched-vis.c
View File

@ -347,11 +347,11 @@ print_exp (pretty_printer *pp, const_rtx x, int verbose)
pp_string (pp, "unspec");
if (GET_CODE (x) == UNSPEC_VOLATILE)
pp_string (pp, "/v");
pp_character (pp, '[');
pp_left_bracket (pp);
for (i = 0; i < XVECLEN (x, 0); i++)
{
if (i != 0)
pp_character (pp, ',');
pp_comma (pp);
print_pattern (pp, XVECEXP (x, 0, i), verbose);
}
pp_string (pp, "] ");
@ -393,7 +393,7 @@ print_exp (pretty_printer *pp, const_rtx x, int verbose)
if (fun)
{
pp_string (pp, fun);
pp_character (pp, '(');
pp_left_paren (pp);
}
for (i = 0; i < 4; i++)
@ -404,13 +404,13 @@ print_exp (pretty_printer *pp, const_rtx x, int verbose)
if (op[i])
{
if (fun && i != 0)
pp_character (pp, ',');
pp_comma (pp);
print_value (pp, op[i], verbose);
}
}
if (fun)
pp_character (pp, ')');
pp_right_paren (pp);
} /* print_exp */
/* Prints rtxes, I customarily classified as values. They're constants,
@ -462,13 +462,13 @@ print_value (pretty_printer *pp, const_rtx x, int verbose)
case STRICT_LOW_PART:
pp_printf (pp, "%s(", GET_RTX_NAME (GET_CODE (x)));
print_value (pp, XEXP (x, 0), verbose);
pp_character (pp, ')');
pp_right_paren (pp);
break;
case REG:
if (REGNO (x) < FIRST_PSEUDO_REGISTER)
{
if (ISDIGIT (reg_names[REGNO (x)][0]))
pp_character (pp, '%');
pp_modulo (pp);
pp_string (pp, reg_names[REGNO (x)]);
}
else
@ -486,9 +486,9 @@ print_value (pretty_printer *pp, const_rtx x, int verbose)
pp_string (pp, GET_RTX_NAME (GET_CODE (x)));
break;
case MEM:
pp_character (pp, '[');
pp_left_bracket (pp);
print_value (pp, XEXP (x, 0), verbose);
pp_character (pp, ']');
pp_right_bracket (pp);
break;
case DEBUG_EXPR:
pp_printf (pp, "D#%i", DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x)));
@ -514,7 +514,7 @@ print_pattern (pretty_printer *pp, const_rtx x, int verbose)
{
case SET:
print_value (pp, SET_DEST (x), verbose);
pp_character (pp, '=');
pp_equal (pp);
print_value (pp, SET_SRC (x), verbose);
break;
case RETURN:
@ -535,14 +535,14 @@ print_pattern (pretty_printer *pp, const_rtx x, int verbose)
print_value (pp, PAT_VAR_LOCATION_LOC (x), verbose);
break;
case COND_EXEC:
pp_character (pp, '(');
pp_left_paren (pp);
if (GET_CODE (COND_EXEC_TEST (x)) == NE
&& XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
print_value (pp, XEXP (COND_EXEC_TEST (x), 0), verbose);
else if (GET_CODE (COND_EXEC_TEST (x)) == EQ
&& XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
{
pp_character (pp, '!');
pp_exclamation (pp);
print_value (pp, XEXP (COND_EXEC_TEST (x), 0), verbose);
}
else
@ -554,13 +554,13 @@ print_pattern (pretty_printer *pp, const_rtx x, int verbose)
{
int i;
pp_character (pp, '{');
pp_left_brace (pp);
for (i = 0; i < XVECLEN (x, 0); i++)
{
print_pattern (pp, XVECEXP (x, 0, i), verbose);
pp_character (pp, ';');
pp_semicolon (pp);
}
pp_character (pp, '}');
pp_right_brace (pp);
}
break;
case SEQUENCE:
@ -588,10 +588,10 @@ print_pattern (pretty_printer *pp, const_rtx x, int verbose)
for (int i = 0; i < XVECLEN (x, 0); i++)
{
print_pattern (pp, XVECEXP (x, 0, i), verbose);
pp_character (pp, ';');
pp_semicolon (pp);
}
}
pp_character (pp, '}');
pp_right_brace (pp);
}
break;
case ASM_INPUT:
@ -726,9 +726,9 @@ print_insn (pretty_printer *pp, const_rtx x, int verbose)
case NOTE_INSN_VAR_LOCATION:
case NOTE_INSN_CALL_ARG_LOCATION:
pp_character (pp, '{');
pp_left_brace (pp);
print_pattern (pp, NOTE_VAR_LOCATION (x), verbose);
pp_character (pp, '}');
pp_right_brace (pp);
break;
default:
@ -839,7 +839,7 @@ rtl_dump_bb_for_graph (pretty_printer *pp, basic_block bb)
{
if (! first)
{
pp_character (pp, '|');
pp_bar (pp);
pp_write_text_to_stream (pp);
}
first = false;

219
gcc/tree-pretty-print.c
View File

@ -229,7 +229,7 @@ dump_function_declaration (pretty_printer *buffer, tree node,
tree arg;
pp_space (buffer);
pp_character (buffer, '(');
pp_left_paren (buffer);
/* Print the argument types. */
arg = TYPE_ARG_TYPES (node);
@ -237,7 +237,7 @@ dump_function_declaration (pretty_printer *buffer, tree node,
{
if (wrote_arg)
{
pp_character (buffer, ',');
pp_comma (buffer);
pp_space (buffer);
}
wrote_arg = true;
@ -253,7 +253,7 @@ dump_function_declaration (pretty_printer *buffer, tree node,
pp_string (buffer, ", ...");
/* Avoid printing any arg for unprototyped functions. */
pp_character (buffer, ')');
pp_right_paren (buffer);
}
/* Dump the domain associated with an array. */
@ -261,7 +261,7 @@ dump_function_declaration (pretty_printer *buffer, tree node,
static void
dump_array_domain (pretty_printer *buffer, tree domain, int spc, int flags)
{
pp_character (buffer, '[');
pp_left_bracket (buffer);
if (domain)
{
tree min = TYPE_MIN_VALUE (domain);
@ -275,14 +275,14 @@ dump_array_domain (pretty_printer *buffer, tree domain, int spc, int flags)
{
if (min)
dump_generic_node (buffer, min, spc, flags, false);
pp_character (buffer, ':');
pp_colon (buffer);
if (max)
dump_generic_node (buffer, max, spc, flags, false);
}
}
else
pp_string (buffer, "<unknown>");
pp_character (buffer, ']');
pp_right_bracket (buffer);
}
@ -316,33 +316,33 @@ dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)
goto print_remap;
print_remap:
pp_string (buffer, name);
pp_character (buffer, '(');
pp_left_paren (buffer);
dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
spc, flags, false);
pp_character (buffer, ')');
pp_right_paren (buffer);
break;
case OMP_CLAUSE_REDUCTION:
pp_string (buffer, "reduction(");
pp_string (buffer, op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause)));
pp_character (buffer, ':');
pp_colon (buffer);
dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
spc, flags, false);
pp_character (buffer, ')');
pp_right_paren (buffer);
break;
case OMP_CLAUSE_IF:
pp_string (buffer, "if(");
dump_generic_node (buffer, OMP_CLAUSE_IF_EXPR (clause),
spc, flags, false);
pp_character (buffer, ')');
pp_right_paren (buffer);
break;
case OMP_CLAUSE_NUM_THREADS:
pp_string (buffer, "num_threads(");
dump_generic_node (buffer, OMP_CLAUSE_NUM_THREADS_EXPR (clause),
spc, flags, false);
pp_character (buffer, ')');
pp_right_paren (buffer);
break;
case OMP_CLAUSE_NOWAIT:
@ -373,7 +373,7 @@ dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)
default:
gcc_unreachable ();
}
pp_character (buffer, ')');
pp_right_paren (buffer);
break;
case OMP_CLAUSE_SCHEDULE:
@ -400,12 +400,12 @@ dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)
}
if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))
{
pp_character (buffer, ',');
pp_comma (buffer);
dump_generic_node (buffer,
OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause),
spc, flags, false);
}
pp_character (buffer, ')');
pp_right_paren (buffer);
break;
case OMP_CLAUSE_UNTIED:
@ -417,14 +417,14 @@ dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)
dump_generic_node (buffer,
OMP_CLAUSE_COLLAPSE_EXPR (clause),
spc, flags, false);
pp_character (buffer, ')');
pp_right_paren (buffer);
break;
case OMP_CLAUSE_FINAL:
pp_string (buffer, "final(");
dump_generic_node (buffer, OMP_CLAUSE_FINAL_EXPR (clause),
spc, flags, false);
pp_character (buffer, ')');
pp_right_paren (buffer);
break;
case OMP_CLAUSE_MERGEABLE:
@ -467,7 +467,7 @@ dump_location (pretty_printer *buffer, location_t loc)
{
expanded_location xloc = expand_location (loc);
pp_character (buffer, '[');
pp_left_bracket (buffer);
if (xloc.file)
{
pp_string (buffer, xloc.file);
@ -638,7 +638,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
node = TREE_CHAIN (node);
if (node && TREE_CODE (node) == TREE_LIST)
{
pp_character (buffer, ',');
pp_comma (buffer);
pp_space (buffer);
}
}
@ -658,7 +658,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
{
dump_generic_node (buffer, TREE_VEC_ELT (node, i), spc, flags,
false);
pp_character (buffer, ',');
pp_comma (buffer);
pp_space (buffer);
}
dump_generic_node (buffer, TREE_VEC_ELT (node, len - 1), spc,
@ -717,7 +717,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
else if (TREE_CODE (node) == VECTOR_TYPE)
{
pp_string (buffer, "vector");
pp_character (buffer, '(');
pp_left_paren (buffer);
pp_wide_integer (buffer, TYPE_VECTOR_SUBPARTS (node));
pp_string (buffer, ") ");
dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
@ -801,7 +801,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
dump_generic_node (buffer, TREE_TYPE (fnode), spc, flags, false);
pp_space (buffer);
pp_character (buffer, '(');
pp_left_paren (buffer);
pp_string (buffer, str);
if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
dump_decl_name (buffer, TYPE_NAME (node), flags);
@ -810,7 +810,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
else
pp_printf (buffer, "<T%x>", TYPE_UID (node));
pp_character (buffer, ')');
pp_right_paren (buffer);
dump_function_declaration (buffer, fnode, spc, flags);
}
else
@ -1045,7 +1045,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
if (tree_int_cst_sgn (val) < 0)
{
pp_character (buffer, '-');
pp_minus (buffer);
high = ~high + !low;
low = -low;
}
@ -1241,10 +1241,10 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
str = "->";
}
if (op_prio (op0) < op_prio (node))
pp_character (buffer, '(');
pp_left_paren (buffer);
dump_generic_node (buffer, op0, spc, flags, false);
if (op_prio (op0) < op_prio (node))
pp_character (buffer, ')');
pp_right_paren (buffer);
pp_string (buffer, str);
dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
op0 = component_ref_field_offset (node);
@ -1252,7 +1252,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
{
pp_string (buffer, "{off: ");
dump_generic_node (buffer, op0, spc, flags, false);
pp_character (buffer, '}');
pp_right_brace (buffer);
}
break;
@ -1270,15 +1270,15 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
case ARRAY_RANGE_REF:
op0 = TREE_OPERAND (node, 0);
if (op_prio (op0) < op_prio (node))
pp_character (buffer, '(');
pp_left_paren (buffer);
dump_generic_node (buffer, op0, spc, flags, false);
if (op_prio (op0) < op_prio (node))
pp_character (buffer, ')');
pp_character (buffer, '[');
pp_right_paren (buffer);
pp_left_bracket (buffer);
dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
if (TREE_CODE (node) == ARRAY_RANGE_REF)
pp_string (buffer, " ...");
pp_character (buffer, ']');
pp_right_bracket (buffer);
op0 = array_ref_low_bound (node);
op1 = array_ref_element_size (node);
@ -1291,7 +1291,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
dump_generic_node (buffer, op0, spc, flags, false);
pp_string (buffer, " sz: ");
dump_generic_node (buffer, op1, spc, flags, false);
pp_character (buffer, '}');
pp_right_brace (buffer);
}
break;
@ -1302,7 +1302,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
bool is_struct_init = false;
bool is_array_init = false;
double_int curidx = double_int_zero;
pp_character (buffer, '{');
pp_left_brace (buffer);
if (TREE_CLOBBER_P (node))
pp_string (buffer, "CLOBBER");
else if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
@ -1324,15 +1324,15 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
{
if (is_struct_init)
{
pp_character (buffer, '.');
pp_dot (buffer);
dump_generic_node (buffer, field, spc, flags, false);
pp_character (buffer, '=');
pp_equal (buffer);
}
else if (is_array_init
&& (TREE_CODE (field) != INTEGER_CST
|| tree_to_double_int (field) != curidx))
{
pp_character (buffer, '[');
pp_left_bracket (buffer);
if (TREE_CODE (field) == RANGE_EXPR)
{
dump_generic_node (buffer, TREE_OPERAND (field, 0), spc,
@ -1361,11 +1361,11 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
dump_generic_node (buffer, val, spc, flags, false);
if (ix != vec_safe_length (CONSTRUCTOR_ELTS (node)) - 1)
{
pp_character (buffer, ',');
pp_comma (buffer);
pp_space (buffer);
}
}
pp_character (buffer, '}');
pp_right_brace (buffer);
}
break;
@ -1384,7 +1384,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
newline_and_indent (buffer, spc);
else
{
pp_character (buffer, ',');
pp_comma (buffer);
pp_space (buffer);
}
@ -1398,7 +1398,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
newline_and_indent (buffer, spc);
else
{
pp_character (buffer, ',');
pp_comma (buffer);
pp_space (buffer);
}
}
@ -1434,7 +1434,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags,
false);
pp_space (buffer);
pp_character (buffer, '=');
pp_equal (buffer);
pp_space (buffer);
dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags,
false);
@ -1443,10 +1443,10 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
case TARGET_EXPR:
pp_string (buffer, "TARGET_EXPR <");
dump_generic_node (buffer, TARGET_EXPR_SLOT (node), spc, flags, false);
pp_character (buffer, ',');
pp_comma (buffer);
pp_space (buffer);
dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false);
pp_character (buffer, '>');
pp_greater (buffer);
break;
case DECL_EXPR:
@ -1459,7 +1459,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
{
pp_string (buffer, "if (");
dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false);
pp_character (buffer, ')');
pp_right_paren (buffer);
/* The lowered cond_exprs should always be printed in full. */
if (COND_EXPR_THEN (node)
&& (IS_EMPTY_STMT (COND_EXPR_THEN (node))
@ -1484,12 +1484,12 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
if (COND_EXPR_THEN (node))
{
newline_and_indent (buffer, spc+2);
pp_character (buffer, '{');
pp_left_brace (buffer);
newline_and_indent (buffer, spc+4);
dump_generic_node (buffer, COND_EXPR_THEN (node), spc+4,
flags, true);
newline_and_indent (buffer, spc+2);
pp_character (buffer, '}');
pp_right_brace (buffer);
}
/* Output COND_EXPR_ELSE. */
@ -1499,12 +1499,12 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
newline_and_indent (buffer, spc);
pp_string (buffer, "else");
newline_and_indent (buffer, spc+2);
pp_character (buffer, '{');
pp_left_brace (buffer);
newline_and_indent (buffer, spc+4);
dump_generic_node (buffer, COND_EXPR_ELSE (node), spc+4,
flags, true);
newline_and_indent (buffer, spc+2);
pp_character (buffer, '}');
pp_right_brace (buffer);
}
}
is_expr = false;
@ -1513,18 +1513,18 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
{
dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
pp_space (buffer);
pp_character (buffer, '?');
pp_question (buffer);
pp_space (buffer);
dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
pp_space (buffer);
pp_character (buffer, ':');
pp_colon (buffer);
pp_space (buffer);
dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
}
break;
case BIND_EXPR:
pp_character (buffer, '{');
pp_left_brace (buffer);
if (!(flags & TDF_SLIM))
{
if (BIND_EXPR_VARS (node))
@ -1541,7 +1541,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
newline_and_indent (buffer, spc+2);
dump_generic_node (buffer, BIND_EXPR_BODY (node), spc+2, flags, true);
newline_and_indent (buffer, spc);
pp_character (buffer, '}');
pp_right_brace (buffer);
}
is_expr = false;
break;
@ -1551,7 +1551,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
/* Print parameters. */
pp_space (buffer);
pp_character (buffer, '(');
pp_left_paren (buffer);
{
tree arg;
call_expr_arg_iterator iter;
@ -1560,7 +1560,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
dump_generic_node (buffer, arg, spc, flags, false);
if (more_call_expr_args_p (&iter))
{
pp_character (buffer, ',');
pp_comma (buffer);
pp_space (buffer);
}
}
@ -1569,19 +1569,19 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
{
if (call_expr_nargs (node) > 0)
{
pp_character (buffer, ',');
pp_comma (buffer);
pp_space (buffer);
}
pp_string (buffer, "__builtin_va_arg_pack ()");
}
pp_character (buffer, ')');
pp_right_paren (buffer);
op1 = CALL_EXPR_STATIC_CHAIN (node);
if (op1)
{
pp_string (buffer, " [static-chain: ");
dump_generic_node (buffer, op1, spc, flags, false);
pp_character (buffer, ']');
pp_right_bracket (buffer);
}
if (CALL_EXPR_RETURN_SLOT_OPT (node))
@ -1603,7 +1603,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
case PLACEHOLDER_EXPR:
pp_string (buffer, "<PLACEHOLDER_EXPR ");
dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
pp_character (buffer, '>');
pp_greater (buffer);
break;
/* Binary arithmetic and logic expressions. */
@ -1662,9 +1662,9 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
keep semantics of the tree representation. */
if (op_prio (op0) <= op_prio (node))
{
pp_character (buffer, '(');
pp_left_paren (buffer);
dump_generic_node (buffer, op0, spc, flags, false);
pp_character (buffer, ')');
pp_right_paren (buffer);
}
else
dump_generic_node (buffer, op0, spc, flags, false);
@ -1677,9 +1677,9 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
keep semantics of the tree representation. */
if (op_prio (op1) <= op_prio (node))
{
pp_character (buffer, '(');
pp_left_paren (buffer);
dump_generic_node (buffer, op1, spc, flags, false);
pp_character (buffer, ')');
pp_right_paren (buffer);
}
else
dump_generic_node (buffer, op1, spc, flags, false);
@ -1703,9 +1703,9 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
{
pp_character (buffer, '(');
pp_left_paren (buffer);
dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
pp_character (buffer, ')');
pp_right_paren (buffer);
}
else
dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
@ -1715,9 +1715,9 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
case POSTINCREMENT_EXPR:
if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
{
pp_character (buffer, '(');
pp_left_paren (buffer);
dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
pp_character (buffer, ')');
pp_right_paren (buffer);
}
else
dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
@ -1729,7 +1729,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
pp_string (buffer, ", ");
dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
pp_character (buffer, '>');
pp_greater (buffer);
break;
case MAX_EXPR:
@ -1737,13 +1737,13 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
pp_string (buffer, ", ");
dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
pp_character (buffer, '>');
pp_greater (buffer);
break;
case ABS_EXPR:
pp_string (buffer, "ABS_EXPR <");
dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
pp_character (buffer, '>');
pp_greater (buffer);
break;
case RANGE_EXPR:
@ -1759,15 +1759,15 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
op0 = TREE_OPERAND (node, 0);
if (type != TREE_TYPE (op0))
{
pp_character (buffer, '(');
pp_left_paren (buffer);
dump_generic_node (buffer, type, spc, flags, false);
pp_string (buffer, ") ");
}
if (op_prio (op0) < op_prio (node))
pp_character (buffer, '(');
pp_left_paren (buffer);
dump_generic_node (buffer, op0, spc, flags, false);
if (op_prio (op0) < op_prio (node))
pp_character (buffer, ')');
pp_right_paren (buffer);
break;
case VIEW_CONVERT_EXPR:
@ -1775,7 +1775,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
pp_string (buffer, ">(");
dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
pp_character (buffer, ')');
pp_right_paren (buffer);
break;
case PAREN_EXPR:
@ -1787,13 +1787,13 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
case NON_LVALUE_EXPR:
pp_string (buffer, "NON_LVALUE_EXPR <");
dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
pp_character (buffer, '>');
pp_greater (buffer);
break;
case SAVE_EXPR:
pp_string (buffer, "SAVE_EXPR <");
dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
pp_character (buffer, '>');
pp_greater (buffer);
break;
case COMPLEX_EXPR:
@ -1886,7 +1886,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
break;
}
dump_generic_node (buffer, op0, spc, flags, false);
pp_character (buffer, ':');
pp_colon (buffer);
if (DECL_NONLOCAL (op0))
pp_string (buffer, " [non-local]");
break;
@ -1896,11 +1896,11 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
if (!(flags & TDF_SLIM))
{
newline_and_indent (buffer, spc+2);
pp_character (buffer, '{');
pp_left_brace (buffer);
newline_and_indent (buffer, spc+4);
dump_generic_node (buffer, LOOP_EXPR_BODY (node), spc+4, flags, true);
newline_and_indent (buffer, spc+2);
pp_character (buffer, '}');
pp_right_brace (buffer);
}
is_expr = false;
break;
@ -1938,11 +1938,11 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
case SWITCH_EXPR:
pp_string (buffer, "switch (");
dump_generic_node (buffer, SWITCH_COND (node), spc, flags, false);
pp_character (buffer, ')');
pp_right_paren (buffer);
if (!(flags & TDF_SLIM))
{
newline_and_indent (buffer, spc+2);
pp_character (buffer, '{');
pp_left_brace (buffer);
if (SWITCH_BODY (node))
{
newline_and_indent (buffer, spc+4);
@ -1970,7 +1970,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
}
}
newline_and_indent (buffer, spc+2);
pp_character (buffer, '}');
pp_right_brace (buffer);
}
is_expr = false;
break;
@ -1995,15 +1995,15 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
pp_string (buffer, "__asm__");
if (ASM_VOLATILE_P (node))
pp_string (buffer, " __volatile__");
pp_character (buffer, '(');
pp_left_paren (buffer);
dump_generic_node (buffer, ASM_STRING (node), spc, flags, false);
pp_character (buffer, ':');
pp_colon (buffer);
dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false);
pp_character (buffer, ':');
pp_colon (buffer);
dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false);
if (ASM_CLOBBERS (node))
{
pp_character (buffer, ':');
pp_colon (buffer);
dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false);
}
pp_string (buffer, ")");
@ -2024,18 +2024,17 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
}
else
pp_string (buffer, "default");
pp_character (buffer, ':');
pp_colon (buffer);
break;
case OBJ_TYPE_REF:
pp_string (buffer, "OBJ_TYPE_REF(");
dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
pp_character (buffer, ';');
pp_semicolon (buffer);
dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
pp_character (buffer, '-');
pp_character (buffer, '>');
pp_arrow (buffer);
dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
pp_character (buffer, ')');
pp_right_paren (buffer);
break;
case SSA_NAME:
@ -2162,11 +2161,11 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
if (!(flags & TDF_SLIM) && OMP_BODY (node))
{
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '{');
pp_left_brace (buffer);
newline_and_indent (buffer, spc + 4);
dump_generic_node (buffer, OMP_BODY (node), spc + 4, flags, false);
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '}');
pp_right_brace (buffer);
}
is_expr = false;
break;
@ -2187,7 +2186,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
if (OMP_FOR_PRE_BODY (node))
{
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '{');
pp_left_brace (buffer);
spc += 4;
newline_and_indent (buffer, spc);
dump_generic_node (buffer, OMP_FOR_PRE_BODY (node),
@ -2212,19 +2211,19 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
if (OMP_FOR_BODY (node))
{
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '{');
pp_left_brace (buffer);
newline_and_indent (buffer, spc + 4);
dump_generic_node (buffer, OMP_FOR_BODY (node), spc + 4, flags,
false);
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '}');
pp_right_brace (buffer);
}
spc -= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node)) - 2;
if (OMP_FOR_PRE_BODY (node))
{
spc -= 4;
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '}');
pp_right_brace (buffer);
}
}
is_expr = false;
@ -2252,10 +2251,10 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
if (OMP_CRITICAL_NAME (node))
{
pp_space (buffer);
pp_character (buffer, '(');
pp_left_paren (buffer);
dump_generic_node (buffer, OMP_CRITICAL_NAME (node), spc,
flags, false);
pp_character (buffer, ')');
pp_right_paren (buffer);
}
goto dump_omp_body;
@ -2264,7 +2263,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
newline_and_indent (buffer, spc + 2);
dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
pp_space (buffer);
pp_character (buffer, '=');
pp_equal (buffer);
pp_space (buffer);
dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
break;
@ -2282,7 +2281,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
newline_and_indent (buffer, spc + 2);
dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
pp_space (buffer);
pp_character (buffer, '=');
pp_equal (buffer);
pp_space (buffer);
dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
break;
@ -2307,12 +2306,12 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
if (!(flags & TDF_SLIM) && TRANSACTION_EXPR_BODY (node))
{
newline_and_indent (buffer, spc);
pp_character (buffer, '{');
pp_left_brace (buffer);
newline_and_indent (buffer, spc + 2);
dump_generic_node (buffer, TRANSACTION_EXPR_BODY (node),
spc + 2, flags, false);
newline_and_indent (buffer, spc);
pp_character (buffer, '}');
pp_right_brace (buffer);
}
is_expr = false;
break;
@ -2341,7 +2340,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
case VEC_WIDEN_MULT_ODD_EXPR:
case VEC_WIDEN_LSHIFT_HI_EXPR:
case VEC_WIDEN_LSHIFT_LO_EXPR:
pp_character (buffer, ' ');
pp_space (buffer);
for (str = tree_code_name [code]; *str; str++)
pp_character (buffer, TOUPPER (*str));
pp_string (buffer, " < ");
@ -2474,9 +2473,9 @@ print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
{
pp_string (buffer, " __asm__ ");
pp_character (buffer, '(');
pp_left_paren (buffer);
dump_generic_node (buffer, DECL_ASSEMBLER_NAME (t), spc, flags, false);
pp_character (buffer, ')');
pp_right_paren (buffer);
}
/* The initial value of a function serves to determine whether the function
@ -2488,7 +2487,7 @@ print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
if (DECL_INITIAL (t))
{
pp_space (buffer);
pp_character (buffer, '=');
pp_equal (buffer);
pp_space (buffer);
dump_generic_node (buffer, DECL_INITIAL (t), spc, flags, false);
}
@ -2498,10 +2497,10 @@ print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
{
pp_string (buffer, " [value-expr: ");
dump_generic_node (buffer, DECL_VALUE_EXPR (t), spc, flags, false);
pp_character (buffer, ']');
pp_right_bracket (buffer);
}
pp_character (buffer, ';');
pp_semicolon (buffer);
}
@ -2527,7 +2526,7 @@ print_struct_decl (pretty_printer *buffer, const_tree node, int spc, int flags)
/* Print the contents of the structure. */
pp_newline (buffer);
INDENT (spc);
pp_character (buffer, '{');
pp_left_brace (buffer);
pp_newline (buffer);
/* Print the fields of the structure. */
@ -2552,7 +2551,7 @@ print_struct_decl (pretty_printer *buffer, const_tree node, int spc, int flags)
}
}
INDENT (spc);
pp_character (buffer, '}');
pp_right_brace (buffer);
}
/* Return the priority of the operator CODE.