static char *to_ada_name (const char *, bool *);
#define INDENT(SPACE) \
- do { int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)
+ do { int i; for (i = 0; i<SPACE; i++) pp_space (pp); } while (0)
#define INDENT_INCR 3
/* Dump a newline and indent BUFFER by SPC chars. */
static void
-newline_and_indent (pretty_printer *buffer, int spc)
+newline_and_indent (pretty_printer *pp, int spc)
{
- pp_newline (buffer);
+ pp_newline (pp);
INDENT (spc);
}
static bool package_prefix = true;
-/* Dump in BUFFER the name of an identifier NODE of type TYPE, following Ada
+/* Dump in PP the name of an identifier NODE of type TYPE, following Ada
syntax. LIMITED_ACCESS indicates whether NODE can be accessed through a
limited 'with' clause rather than a regular 'with' clause. */
static void
-pp_ada_tree_identifier (pretty_printer *buffer, tree node, tree type,
+pp_ada_tree_identifier (pretty_printer *pp, tree node, tree type,
bool limited_access)
{
const char *name = IDENTIFIER_POINTER (node);
{
char *s1 = get_ada_package (xloc.file);
append_withs (s1, limited_access);
- pp_string (buffer, s1);
- pp_dot (buffer);
+ pp_string (pp, s1);
+ pp_dot (pp);
free (s1);
}
break;
/* Generate the additional package prefix for C++ classes. */
if (separate_class_package (decl))
{
- pp_string (buffer, "Class_");
- pp_string (buffer, s);
- pp_dot (buffer);
+ pp_string (pp, "Class_");
+ pp_string (pp, s);
+ pp_dot (pp);
}
}
}
if (space_found)
if (!strcmp (s, "short_int"))
- pp_string (buffer, "short");
+ pp_string (pp, "short");
else if (!strcmp (s, "short_unsigned_int"))
- pp_string (buffer, "unsigned_short");
+ pp_string (pp, "unsigned_short");
else if (!strcmp (s, "unsigned_int"))
- pp_string (buffer, "unsigned");
+ pp_string (pp, "unsigned");
else if (!strcmp (s, "long_int"))
- pp_string (buffer, "long");
+ pp_string (pp, "long");
else if (!strcmp (s, "long_unsigned_int"))
- pp_string (buffer, "unsigned_long");
+ pp_string (pp, "unsigned_long");
else if (!strcmp (s, "long_long_int"))
- pp_string (buffer, "Long_Long_Integer");
+ pp_string (pp, "Long_Long_Integer");
else if (!strcmp (s, "long_long_unsigned_int"))
{
if (package_prefix)
{
append_withs ("Interfaces.C.Extensions", false);
- pp_string (buffer, "Extensions.unsigned_long_long");
+ pp_string (pp, "Extensions.unsigned_long_long");
}
else
- pp_string (buffer, "unsigned_long_long");
+ pp_string (pp, "unsigned_long_long");
}
else
- pp_string(buffer, s);
+ pp_string (pp, s);
else
if (!strcmp (s, "u_Bool") || !strcmp (s, "bool"))
{
if (package_prefix)
{
append_withs ("Interfaces.C.Extensions", false);
- pp_string (buffer, "Extensions.bool");
+ pp_string (pp, "Extensions.bool");
}
else
- pp_string (buffer, "bool");
+ pp_string (pp, "bool");
}
else
- pp_string(buffer, s);
+ pp_string (pp, s);
free (s);
}
-/* Dump in BUFFER the assembly name of T. */
+/* Dump in PP the assembly name of T. */
static void
-pp_asm_name (pretty_printer *buffer, tree t)
+pp_asm_name (pretty_printer *pp, tree t)
{
tree name = DECL_ASSEMBLER_NAME (t);
char *ada_name = XALLOCAVEC (char, IDENTIFIER_LENGTH (name) + 1), *s;
}
*s = '\0';
- pp_string (buffer, ada_name);
+ pp_string (pp, ada_name);
}
-/* Dump in BUFFER the name of a DECL node if set, in Ada syntax.
+/* Dump in PP the name of a DECL node if set, in Ada syntax.
LIMITED_ACCESS indicates whether NODE can be accessed via a
limited 'with' clause rather than a regular 'with' clause. */
static void
-dump_ada_decl_name (pretty_printer *buffer, tree decl, bool limited_access)
+dump_ada_decl_name (pretty_printer *pp, tree decl, bool limited_access)
{
if (DECL_NAME (decl))
- pp_ada_tree_identifier (buffer, DECL_NAME (decl), decl, limited_access);
+ pp_ada_tree_identifier (pp, DECL_NAME (decl), decl, limited_access);
else
{
tree type_name = TYPE_NAME (TREE_TYPE (decl));
if (!type_name)
{
- pp_string (buffer, "anon");
+ pp_string (pp, "anon");
if (TREE_CODE (decl) == FIELD_DECL)
- pp_decimal_int (buffer, DECL_UID (decl));
+ pp_decimal_int (pp, DECL_UID (decl));
else
- pp_decimal_int (buffer, TYPE_UID (TREE_TYPE (decl)));
+ pp_decimal_int (pp, TYPE_UID (TREE_TYPE (decl)));
}
else if (TREE_CODE (type_name) == IDENTIFIER_NODE)
- pp_ada_tree_identifier (buffer, type_name, decl, limited_access);
+ pp_ada_tree_identifier (pp, type_name, decl, limited_access);
}
}
-/* Dump in BUFFER a name for the type T, which is a TYPE without TYPE_NAME. */
+/* Dump in PP a name for the type T, which is a TYPE without TYPE_NAME. */
static void
-dump_anonymous_type_name (pretty_printer *buffer, tree t)
+dump_anonymous_type_name (pretty_printer *pp, tree t)
{
- pp_string (buffer, "anon");
+ pp_string (pp, "anon");
switch (TREE_CODE (t))
{
case ARRAY_TYPE:
- pp_string (buffer, "_array");
+ pp_string (pp, "_array");
break;
case ENUMERAL_TYPE:
- pp_string (buffer, "_enum");
+ pp_string (pp, "_enum");
break;
case RECORD_TYPE:
- pp_string (buffer, "_struct");
+ pp_string (pp, "_struct");
break;
case UNION_TYPE:
- pp_string (buffer, "_union");
+ pp_string (pp, "_union");
break;
default:
- pp_string (buffer, "_unknown");
+ pp_string (pp, "_unknown");
break;
}
- pp_decimal_int (buffer, TYPE_UID (t));
+ pp_decimal_int (pp, TYPE_UID (t));
}
-/* Dump in BUFFER aspect Import on a given node T. SPC is the current
+/* Dump in PP aspect Import on a given node T. SPC is the current
indentation level. */
static void
-dump_ada_import (pretty_printer *buffer, tree t, int spc)
+dump_ada_import (pretty_printer *pp, tree t, int spc)
{
const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t));
const bool is_stdcall
= TREE_CODE (t) == FUNCTION_DECL
&& lookup_attribute ("stdcall", TYPE_ATTRIBUTES (TREE_TYPE (t)));
- pp_string (buffer, "with Import => True, ");
+ pp_string (pp, "with Import => True, ");
- newline_and_indent (buffer, spc + 5);
+ newline_and_indent (pp, spc + 5);
if (is_stdcall)
- pp_string (buffer, "Convention => Stdcall, ");
+ pp_string (pp, "Convention => Stdcall, ");
else if (name[0] == '_' && name[1] == 'Z')
- pp_string (buffer, "Convention => CPP, ");
+ pp_string (pp, "Convention => CPP, ");
else
- pp_string (buffer, "Convention => C, ");
+ pp_string (pp, "Convention => C, ");
- newline_and_indent (buffer, spc + 5);
+ newline_and_indent (pp, spc + 5);
tree sec = lookup_attribute ("section", DECL_ATTRIBUTES (t));
if (sec)
{
- pp_string (buffer, "Linker_Section => \"");
- pp_string (buffer, TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (sec))));
- pp_string (buffer, "\", ");
- newline_and_indent (buffer, spc + 5);
+ pp_string (pp, "Linker_Section => \"");
+ pp_string (pp, TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (sec))));
+ pp_string (pp, "\", ");
+ newline_and_indent (pp, spc + 5);
}
- pp_string (buffer, "External_Name => \"");
+ pp_string (pp, "External_Name => \"");
if (is_stdcall)
- pp_string (buffer, IDENTIFIER_POINTER (DECL_NAME (t)));
+ pp_string (pp, IDENTIFIER_POINTER (DECL_NAME (t)));
else
- pp_asm_name (buffer, t);
+ pp_asm_name (pp, t);
- pp_string (buffer, "\";");
+ pp_string (pp, "\";");
}
/* Check whether T and its type have different names, and append "the_"
- otherwise in BUFFER. */
+ otherwise in PP. */
static void
-check_type_name_conflict (pretty_printer *buffer, tree t)
+check_type_name_conflict (pretty_printer *pp, tree t)
{
tree tmp = TREE_TYPE (t);
s = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (tmp)));
if (!strcasecmp (IDENTIFIER_POINTER (DECL_NAME (t)), s))
- pp_string (buffer, "the_");
+ pp_string (pp, "the_");
}
}
-/* Dump in BUFFER a function declaration FUNC in Ada syntax.
+/* Dump in PP a function declaration FUNC in Ada syntax.
IS_METHOD indicates whether FUNC is a C++ method.
IS_CONSTRUCTOR whether FUNC is a C++ constructor.
IS_DESTRUCTOR whether FUNC is a C++ destructor.
SPC is the current indentation level. */
static void
-dump_ada_function_declaration (pretty_printer *buffer, tree func,
+dump_ada_function_declaration (pretty_printer *pp, tree func,
bool is_method, bool is_constructor,
bool is_destructor, int spc)
{
num_args = 1;
if (num_args > 2)
- newline_and_indent (buffer, spc + 1);
+ newline_and_indent (pp, spc + 1);
if (num_args > 0)
{
- pp_space (buffer);
- pp_left_paren (buffer);
+ pp_space (pp);
+ pp_left_paren (pp);
}
/* For a function, see if we have the corresponding arguments. */
{
if (DECL_NAME (arg))
{
- check_type_name_conflict (buffer, arg);
- pp_ada_tree_identifier (buffer, DECL_NAME (arg), NULL_TREE,
+ check_type_name_conflict (pp, arg);
+ pp_ada_tree_identifier (pp, DECL_NAME (arg), NULL_TREE,
false);
- pp_string (buffer, " : ");
+ pp_string (pp, " : ");
}
else
{
sprintf (buf, "arg%d : ", num);
- pp_string (buffer, buf);
+ pp_string (pp, buf);
}
- dump_ada_node (buffer, TREE_TYPE (arg), type, spc, false, true);
+ dump_ada_node (pp, TREE_TYPE (arg), type, spc, false, true);
}
else
{
sprintf (buf, "arg%d : ", num);
- pp_string (buffer, buf);
- dump_ada_node (buffer, TREE_VALUE (arg), type, spc, false, true);
+ pp_string (pp, buf);
+ dump_ada_node (pp, TREE_VALUE (arg), type, spc, false, true);
}
/* If the type is a pointer to a tagged type, we need to differentiate
&& POINTER_TYPE_P (TREE_TYPE (arg))
&& is_tagged_type (TREE_TYPE (TREE_TYPE (arg)))
&& !(num == 1 && is_method && (DECL_VINDEX (func) || is_constructor)))
- pp_string (buffer, "'Class");
+ pp_string (pp, "'Class");
arg = TREE_CHAIN (arg);
if (num < num_args)
{
- pp_semicolon (buffer);
+ pp_semicolon (pp);
if (num_args > 2)
- newline_and_indent (buffer, spc + INDENT_INCR);
+ newline_and_indent (pp, spc + INDENT_INCR);
else
- pp_space (buffer);
+ pp_space (pp);
}
}
if (have_ellipsis)
{
- pp_string (buffer, " -- , ...");
- newline_and_indent (buffer, spc + INDENT_INCR);
+ pp_string (pp, " -- , ...");
+ newline_and_indent (pp, spc + INDENT_INCR);
}
if (num_args > 0)
- pp_right_paren (buffer);
+ pp_right_paren (pp);
if (is_constructor || !VOID_TYPE_P (TREE_TYPE (type)))
{
- pp_string (buffer, " return ");
+ pp_string (pp, " return ");
tree rtype = is_constructor ? DECL_CONTEXT (func) : TREE_TYPE (type);
- dump_ada_node (buffer, rtype, rtype, spc, false, true);
+ dump_ada_node (pp, rtype, rtype, spc, false, true);
}
}
-/* Dump in BUFFER all the domains associated with an array NODE,
+/* Dump in PP all the domains associated with an array NODE,
in Ada syntax. SPC is the current indentation level. */
static void
-dump_ada_array_domains (pretty_printer *buffer, tree node, int spc)
+dump_ada_array_domains (pretty_printer *pp, tree node, int spc)
{
bool first = true;
- pp_left_paren (buffer);
+ pp_left_paren (pp);
for (; TREE_CODE (node) == ARRAY_TYPE; node = TREE_TYPE (node))
{
tree max = TYPE_MAX_VALUE (domain);
if (!first)
- pp_string (buffer, ", ");
+ pp_string (pp, ", ");
first = false;
if (min)
- dump_ada_node (buffer, min, NULL_TREE, spc, false, true);
- pp_string (buffer, " .. ");
+ dump_ada_node (pp, min, NULL_TREE, spc, false, true);
+ pp_string (pp, " .. ");
/* If the upper bound is zero, gcc may generate a NULL_TREE
for TYPE_MAX_VALUE rather than an integer_cst. */
if (max)
- dump_ada_node (buffer, max, NULL_TREE, spc, false, true);
+ dump_ada_node (pp, max, NULL_TREE, spc, false, true);
else
- pp_string (buffer, "0");
+ pp_string (pp, "0");
}
else
{
- pp_string (buffer, "size_t");
+ pp_string (pp, "size_t");
first = false;
}
}
- pp_right_paren (buffer);
+ pp_right_paren (pp);
}
-/* Dump in BUFFER file:line information related to NODE. */
+/* Dump in PP file:line information related to NODE. */
static void
-dump_sloc (pretty_printer *buffer, tree node)
+dump_sloc (pretty_printer *pp, tree node)
{
expanded_location xloc;
if (xloc.file)
{
- pp_string (buffer, xloc.file);
- pp_colon (buffer);
- pp_decimal_int (buffer, xloc.line);
+ pp_string (pp, xloc.file);
+ pp_colon (pp);
+ pp_decimal_int (pp, xloc.line);
}
}
&& id_equal (DECL_NAME (TYPE_NAME (TREE_TYPE (t))), "char");
}
-/* Dump in BUFFER an array type NODE in Ada syntax. SPC is the indentation
+/* Dump in PP an array type NODE in Ada syntax. SPC is the indentation
level. */
static void
-dump_ada_array_type (pretty_printer *buffer, tree node, int spc)
+dump_ada_array_type (pretty_printer *pp, tree node, int spc)
{
const bool char_array = is_char_array (node);
/* Special case char arrays. */
if (char_array)
- pp_string (buffer, "Interfaces.C.char_array ");
+ pp_string (pp, "Interfaces.C.char_array ");
else
- pp_string (buffer, "array ");
+ pp_string (pp, "array ");
/* Print the dimensions. */
- dump_ada_array_domains (buffer, node, spc);
+ dump_ada_array_domains (pp, node, spc);
/* Print the component type. */
if (!char_array)
{
tree tmp = strip_array_types (node);
- pp_string (buffer, " of ");
+ pp_string (pp, " of ");
if (TREE_CODE (tmp) != POINTER_TYPE && !packed_layout)
- pp_string (buffer, "aliased ");
+ pp_string (pp, "aliased ");
if (TYPE_NAME (tmp)
|| (!RECORD_OR_UNION_TYPE_P (tmp)
&& TREE_CODE (tmp) != ENUMERAL_TYPE))
- dump_ada_node (buffer, tmp, node, spc, false, true);
+ dump_ada_node (pp, tmp, node, spc, false, true);
else
- dump_anonymous_type_name (buffer, tmp);
+ dump_anonymous_type_name (pp, tmp);
}
}
-/* Dump in BUFFER type names associated with a template, each prepended with
+/* Dump in PP type names associated with a template, each prepended with
'_'. TYPES is the TREE_PURPOSE of a DECL_TEMPLATE_INSTANTIATIONS. SPC is
the indentation level. */
static void
-dump_template_types (pretty_printer *buffer, tree types, int spc)
+dump_template_types (pretty_printer *pp, tree types, int spc)
{
for (int i = 0; i < TREE_VEC_LENGTH (types); i++)
{
tree elem = TREE_VEC_ELT (types, i);
- pp_underscore (buffer);
+ pp_underscore (pp);
- if (!dump_ada_node (buffer, elem, NULL_TREE, spc, false, true))
+ if (!dump_ada_node (pp, elem, NULL_TREE, spc, false, true))
{
- pp_string (buffer, "unknown");
- pp_scalar (buffer, HOST_SIZE_T_PRINT_UNSIGNED,
+ pp_string (pp, "unknown");
+ pp_scalar (pp, HOST_SIZE_T_PRINT_UNSIGNED,
(fmt_size_t) TREE_HASH (elem));
}
}
}
-/* Dump in BUFFER the contents of all class instantiations associated with
+/* Dump in PP the contents of all class instantiations associated with
a given template T. SPC is the indentation level. */
static int
-dump_ada_template (pretty_printer *buffer, tree t, int spc)
+dump_ada_template (pretty_printer *pp, tree t, int spc)
{
/* DECL_SIZE_UNIT is DECL_TEMPLATE_INSTANTIATIONS in this context. */
tree inst = DECL_SIZE_UNIT (t);
num_inst++;
INDENT (spc);
- pp_string (buffer, "package ");
+ pp_string (pp, "package ");
package_prefix = false;
- dump_ada_node (buffer, instance, t, spc, false, true);
- dump_template_types (buffer, types, spc);
- pp_string (buffer, " is");
+ dump_ada_node (pp, instance, t, spc, false, true);
+ dump_template_types (pp, types, spc);
+ pp_string (pp, " is");
spc += INDENT_INCR;
- newline_and_indent (buffer, spc);
+ newline_and_indent (pp, spc);
TREE_VISITED (get_underlying_decl (instance)) = 1;
- pp_string (buffer, "type ");
- dump_ada_node (buffer, instance, t, spc, false, true);
+ pp_string (pp, "type ");
+ dump_ada_node (pp, instance, t, spc, false, true);
package_prefix = true;
if (is_tagged_type (instance))
- pp_string (buffer, " is tagged limited ");
+ pp_string (pp, " is tagged limited ");
else
- pp_string (buffer, " is limited ");
+ pp_string (pp, " is limited ");
- dump_ada_node (buffer, instance, t, spc, false, false);
- pp_newline (buffer);
+ dump_ada_node (pp, instance, t, spc, false, false);
+ pp_newline (pp);
spc -= INDENT_INCR;
- newline_and_indent (buffer, spc);
+ newline_and_indent (pp, spc);
- pp_string (buffer, "end;");
- newline_and_indent (buffer, spc);
- pp_string (buffer, "use ");
+ pp_string (pp, "end;");
+ newline_and_indent (pp, spc);
+ pp_string (pp, "use ");
package_prefix = false;
- dump_ada_node (buffer, instance, t, spc, false, true);
- dump_template_types (buffer, types, spc);
+ dump_ada_node (pp, instance, t, spc, false, true);
+ dump_template_types (pp, types, spc);
package_prefix = true;
- pp_semicolon (buffer);
- pp_newline (buffer);
- pp_newline (buffer);
+ pp_semicolon (pp);
+ pp_newline (pp);
+ pp_newline (pp);
}
return num_inst > 0;
return true;
}
-/* Dump in BUFFER the declaration of enumeral NODE of type TYPE in Ada syntax.
+/* Dump in PP the declaration of enumeral NODE of type TYPE in Ada syntax.
SPC is the indentation level. */
static void
-dump_ada_enum_type (pretty_printer *buffer, tree node, tree type, int spc)
+dump_ada_enum_type (pretty_printer *pp, tree node, tree type, int spc)
{
if (is_simple_enum (node))
{
bool first = true;
spc += INDENT_INCR;
- newline_and_indent (buffer, spc - 1);
- pp_left_paren (buffer);
+ newline_and_indent (pp, spc - 1);
+ pp_left_paren (pp);
for (tree value = TYPE_VALUES (node); value; value = TREE_CHAIN (value))
{
if (first)
first = false;
else
{
- pp_comma (buffer);
- newline_and_indent (buffer, spc);
+ pp_comma (pp);
+ newline_and_indent (pp, spc);
}
- pp_ada_tree_identifier (buffer, TREE_PURPOSE (value), node, false);
+ pp_ada_tree_identifier (pp, TREE_PURPOSE (value), node, false);
}
- pp_string (buffer, ")");
+ pp_string (pp, ")");
spc -= INDENT_INCR;
- newline_and_indent (buffer, spc);
- pp_string (buffer, "with Convention => C");
+ newline_and_indent (pp, spc);
+ pp_string (pp, "with Convention => C");
}
else
{
if (TYPE_UNSIGNED (node))
- pp_string (buffer, "unsigned");
+ pp_string (pp, "unsigned");
else
- pp_string (buffer, "int");
+ pp_string (pp, "int");
for (tree value = TYPE_VALUES (node); value; value = TREE_CHAIN (value))
{
if (TREE_CODE (int_val) != INTEGER_CST)
int_val = DECL_INITIAL (int_val);
- pp_semicolon (buffer);
- newline_and_indent (buffer, spc);
+ pp_semicolon (pp);
+ newline_and_indent (pp, spc);
if (TYPE_NAME (node))
- dump_ada_node (buffer, node, NULL_TREE, spc, false, true);
+ dump_ada_node (pp, node, NULL_TREE, spc, false, true);
else if (type)
- dump_ada_node (buffer, type, NULL_TREE, spc, false, true);
+ dump_ada_node (pp, type, NULL_TREE, spc, false, true);
else
- dump_anonymous_type_name (buffer, node);
- pp_underscore (buffer);
- pp_ada_tree_identifier (buffer, TREE_PURPOSE (value), node, false);
+ dump_anonymous_type_name (pp, node);
+ pp_underscore (pp);
+ pp_ada_tree_identifier (pp, TREE_PURPOSE (value), node, false);
- pp_string (buffer, " : constant ");
+ pp_string (pp, " : constant ");
if (TYPE_NAME (node))
- dump_ada_node (buffer, node, NULL_TREE, spc, false, true);
+ dump_ada_node (pp, node, NULL_TREE, spc, false, true);
else if (type)
- dump_ada_node (buffer, type, NULL_TREE, spc, false, true);
+ dump_ada_node (pp, type, NULL_TREE, spc, false, true);
else
- dump_anonymous_type_name (buffer, node);
+ dump_anonymous_type_name (pp, node);
- pp_string (buffer, " := ");
- dump_ada_node (buffer, int_val, node, spc, false, true);
+ pp_string (pp, " := ");
+ dump_ada_node (pp, int_val, node, spc, false, true);
}
}
}
|| id_equal (name, "_Float128x");
}
-/* Recursively dump in BUFFER Ada declarations corresponding to NODE of type
+/* Recursively dump in PP Ada declarations corresponding to NODE of type
TYPE. SPC is the indentation level. LIMITED_ACCESS indicates whether NODE
can be referenced via a "limited with" clause. NAME_ONLY indicates whether
we should only dump the name of NODE, instead of its full declaration. */
static int
-dump_ada_node (pretty_printer *buffer, tree node, tree type, int spc,
+dump_ada_node (pretty_printer *pp, tree node, tree type, int spc,
bool limited_access, bool name_only)
{
if (node == NULL_TREE)
switch (TREE_CODE (node))
{
case ERROR_MARK:
- pp_string (buffer, "<<< error >>>");
+ pp_string (pp, "<<< error >>>");
return 0;
case IDENTIFIER_NODE:
- pp_ada_tree_identifier (buffer, node, type, limited_access);
+ pp_ada_tree_identifier (pp, node, type, limited_access);
break;
case TREE_LIST:
- pp_string (buffer, "--- unexpected node: TREE_LIST");
+ pp_string (pp, "--- unexpected node: TREE_LIST");
return 0;
case TREE_BINFO:
- dump_ada_node (buffer, BINFO_TYPE (node), type, spc, limited_access,
+ dump_ada_node (pp, BINFO_TYPE (node), type, spc, limited_access,
name_only);
return 0;
case TREE_VEC:
- pp_string (buffer, "--- unexpected node: TREE_VEC");
+ pp_string (pp, "--- unexpected node: TREE_VEC");
return 0;
case NULLPTR_TYPE:
if (package_prefix)
{
append_withs ("System", false);
- pp_string (buffer, "System.Address");
+ pp_string (pp, "System.Address");
}
else
- pp_string (buffer, "address");
+ pp_string (pp, "address");
break;
case VECTOR_TYPE:
- pp_string (buffer, "<vector>");
+ pp_string (pp, "<vector>");
break;
case COMPLEX_TYPE:
if (is_float128 (TREE_TYPE (node)))
{
append_withs ("Interfaces.C.Extensions", false);
- pp_string (buffer, "Extensions.CFloat_128");
+ pp_string (pp, "Extensions.CFloat_128");
}
else if (TREE_TYPE (node) == float_type_node)
{
append_withs ("Ada.Numerics.Complex_Types", false);
- pp_string (buffer, "Ada.Numerics.Complex_Types.Complex");
+ pp_string (pp, "Ada.Numerics.Complex_Types.Complex");
}
else if (TREE_TYPE (node) == double_type_node)
{
append_withs ("Ada.Numerics.Long_Complex_Types", false);
- pp_string (buffer, "Ada.Numerics.Long_Complex_Types.Complex");
+ pp_string (pp, "Ada.Numerics.Long_Complex_Types.Complex");
}
else if (TREE_TYPE (node) == long_double_type_node)
{
append_withs ("Ada.Numerics.Long_Long_Complex_Types", false);
- pp_string (buffer, "Ada.Numerics.Long_Long_Complex_Types.Complex");
+ pp_string (pp, "Ada.Numerics.Long_Long_Complex_Types.Complex");
}
else
- pp_string (buffer, "<complex>");
+ pp_string (pp, "<complex>");
break;
case ENUMERAL_TYPE:
if (name_only)
- dump_ada_node (buffer, TYPE_NAME (node), node, spc, false, true);
+ dump_ada_node (pp, TYPE_NAME (node), node, spc, false, true);
else
- dump_ada_enum_type (buffer, node, type, spc);
+ dump_ada_enum_type (pp, node, type, spc);
break;
case REAL_TYPE:
if (is_float32 (node))
{
- pp_string (buffer, "Float");
+ pp_string (pp, "Float");
break;
}
else if (is_float64 (node))
{
- pp_string (buffer, "Long_Float");
+ pp_string (pp, "Long_Float");
break;
}
else if (is_float128 (node))
{
append_withs ("Interfaces.C.Extensions", false);
- pp_string (buffer, "Extensions.Float_128");
+ pp_string (pp, "Extensions.Float_128");
break;
}
"__int128")))
{
if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
- pp_ada_tree_identifier (buffer, TYPE_NAME (node), node,
+ pp_ada_tree_identifier (pp, TYPE_NAME (node), node,
limited_access);
else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
&& DECL_NAME (TYPE_NAME (node)))
- dump_ada_decl_name (buffer, TYPE_NAME (node), limited_access);
+ dump_ada_decl_name (pp, TYPE_NAME (node), limited_access);
else
- pp_string (buffer, "<unnamed type>");
+ pp_string (pp, "<unnamed type>");
}
else if (TREE_CODE (node) == INTEGER_TYPE)
{
bitfield_used = true;
if (TYPE_PRECISION (node) == 1)
- pp_string (buffer, "Extensions.Unsigned_1");
+ pp_string (pp, "Extensions.Unsigned_1");
else
{
- pp_string (buffer, TYPE_UNSIGNED (node)
+ pp_string (pp, TYPE_UNSIGNED (node)
? "Extensions.Unsigned_"
: "Extensions.Signed_");
- pp_decimal_int (buffer, TYPE_PRECISION (node));
+ pp_decimal_int (pp, TYPE_PRECISION (node));
}
}
else
- pp_string (buffer, "<unnamed type>");
+ pp_string (pp, "<unnamed type>");
break;
case POINTER_TYPE:
case REFERENCE_TYPE:
if (name_only && TYPE_NAME (node))
- dump_ada_node (buffer, TYPE_NAME (node), node, spc, limited_access,
+ dump_ada_node (pp, TYPE_NAME (node), node, spc, limited_access,
true);
else if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)
{
if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (node))))
- pp_string (buffer, "access procedure");
+ pp_string (pp, "access procedure");
else
- pp_string (buffer, "access function");
+ pp_string (pp, "access function");
- dump_ada_function_declaration (buffer, node, false, false, false,
+ dump_ada_function_declaration (pp, node, false, false, false,
spc + INDENT_INCR);
/* If we are dumping the full type, it means we are part of a
type definition and need also a Convention C aspect. */
if (!name_only)
{
- newline_and_indent (buffer, spc);
- pp_string (buffer, "with Convention => C");
+ newline_and_indent (pp, spc);
+ pp_string (pp, "with Convention => C");
}
}
else
if (VOID_TYPE_P (ref_type))
{
if (!name_only)
- pp_string (buffer, "new ");
+ pp_string (pp, "new ");
if (package_prefix)
{
append_withs ("System", false);
- pp_string (buffer, "System.Address");
+ pp_string (pp, "System.Address");
}
else
- pp_string (buffer, "address");
+ pp_string (pp, "address");
}
else
{
&& id_equal (DECL_NAME (TYPE_NAME (ref_type)), "char"))
{
if (!name_only)
- pp_string (buffer, "new ");
+ pp_string (pp, "new ");
if (package_prefix)
{
- pp_string (buffer, "Interfaces.C.Strings.chars_ptr");
+ pp_string (pp, "Interfaces.C.Strings.chars_ptr");
append_withs ("Interfaces.C.Strings", false);
}
else
- pp_string (buffer, "chars_ptr");
+ pp_string (pp, "chars_ptr");
}
else
{
{
append_withs ("System", false);
if (!name_only)
- pp_string (buffer, "new ");
- pp_string (buffer, "System.Address");
+ pp_string (pp, "new ");
+ pp_string (pp, "System.Address");
}
else
- pp_string (buffer, "address");
+ pp_string (pp, "address");
return spc;
}
if (!package_prefix)
{
is_access = false;
- pp_string (buffer, "access");
+ pp_string (pp, "access");
}
else if (AGGREGATE_TYPE_P (ref_type))
{
if (!type || TREE_CODE (type) != FUNCTION_DECL)
{
is_access = true;
- pp_string (buffer, "access ");
+ pp_string (pp, "access ");
if (quals & TYPE_QUAL_CONST)
- pp_string (buffer, "constant ");
+ pp_string (pp, "constant ");
else if (!name_only)
- pp_string (buffer, "all ");
+ pp_string (pp, "all ");
}
else if (quals & TYPE_QUAL_CONST)
{
is_access = false;
- pp_string (buffer, "in ");
+ pp_string (pp, "in ");
}
else
{
is_access = true;
- pp_string (buffer, "access ");
+ pp_string (pp, "access ");
}
}
else
/* We want to use regular with clauses for scalar types,
as they are not involved in circular declarations. */
is_access = false;
- pp_string (buffer, "access ");
+ pp_string (pp, "access ");
if (!name_only)
- pp_string (buffer, "all ");
+ pp_string (pp, "all ");
}
/* If this is the anonymous original type of a typedef'ed
break;
}
- dump_ada_node (buffer, ref_type, ref_type, spc, is_access,
+ dump_ada_node (pp, ref_type, ref_type, spc, is_access,
true);
}
}
case ARRAY_TYPE:
if (name_only)
- dump_ada_node (buffer, TYPE_NAME (node), node, spc, limited_access,
+ dump_ada_node (pp, TYPE_NAME (node), node, spc, limited_access,
true);
else
- dump_ada_array_type (buffer, node, spc);
+ dump_ada_array_type (pp, node, spc);
break;
case RECORD_TYPE:
case UNION_TYPE:
if (name_only)
- dump_ada_node (buffer, TYPE_NAME (node), node, spc, limited_access,
+ dump_ada_node (pp, TYPE_NAME (node), node, spc, limited_access,
true);
else
- dump_ada_structure (buffer, node, type, false, spc);
+ dump_ada_structure (pp, node, type, false, spc);
break;
case INTEGER_CST:
if (TREE_TYPE (node) == sizetype)
node = fold_convert (ssizetype, node);
if (tree_fits_shwi_p (node))
- pp_wide_integer (buffer, tree_to_shwi (node));
+ pp_wide_integer (pp, tree_to_shwi (node));
else if (tree_fits_uhwi_p (node))
- pp_unsigned_wide_integer (buffer, tree_to_uhwi (node));
+ pp_unsigned_wide_integer (pp, tree_to_uhwi (node));
else
{
wide_int val = wi::to_wide (node);
int i;
if (wi::neg_p (val))
{
- pp_minus (buffer);
+ pp_minus (pp);
val = -val;
}
- sprintf (pp_buffer (buffer)->digit_buffer,
+ sprintf (pp_buffer (pp)->digit_buffer,
"16#%" HOST_WIDE_INT_PRINT "x",
val.elt (val.get_len () - 1));
for (i = val.get_len () - 2; i >= 0; i--)
- sprintf (pp_buffer (buffer)->digit_buffer,
+ sprintf (pp_buffer (pp)->digit_buffer,
HOST_WIDE_INT_PRINT_PADDED_HEX, val.elt (i));
- pp_string (buffer, pp_buffer (buffer)->digit_buffer);
+ pp_string (pp, pp_buffer (pp)->digit_buffer);
}
break;
if (package_prefix)
{
append_withs ("System", false);
- pp_string (buffer, "System.Address");
+ pp_string (pp, "System.Address");
}
else
- pp_string (buffer, "address");
+ pp_string (pp, "address");
}
}
else if (name_only)
- dump_ada_decl_name (buffer, node, limited_access);
+ dump_ada_decl_name (pp, node, limited_access);
else
{
if (is_tagged_type (TREE_TYPE (node)))
{
if (first)
{
- pp_string (buffer, "limited new ");
+ pp_string (pp, "limited new ");
first = false;
}
else
- pp_string (buffer, " and ");
+ pp_string (pp, " and ");
- dump_ada_decl_name (buffer, TYPE_NAME (TREE_TYPE (fld)),
+ dump_ada_decl_name (pp, TYPE_NAME (TREE_TYPE (fld)),
false);
}
}
- pp_string (buffer, first ? "tagged limited " : " with ");
+ pp_string (pp, first ? "tagged limited " : " with ");
}
else if (has_nontrivial_methods (TREE_TYPE (node)))
- pp_string (buffer, "limited ");
+ pp_string (pp, "limited ");
- dump_ada_node (buffer, TREE_TYPE (node), type, spc, false, false);
+ dump_ada_node (pp, TREE_TYPE (node), type, spc, false, false);
}
break;
case PARM_DECL:
case FIELD_DECL:
case NAMESPACE_DECL:
- dump_ada_decl_name (buffer, node, false);
+ dump_ada_decl_name (pp, node, false);
break;
default:
return 1;
}
-/* Dump in BUFFER NODE's methods. SPC is the indentation level. Return 1 if
+/* Dump in PP NODE's methods. SPC is the indentation level. Return 1 if
methods were printed, 0 otherwise. */
static int
-dump_ada_methods (pretty_printer *buffer, tree node, int spc)
+dump_ada_methods (pretty_printer *pp, tree node, int spc)
{
if (!has_nontrivial_methods (node))
return 0;
- pp_semicolon (buffer);
+ pp_semicolon (pp);
int res = 1;
for (tree fld = TYPE_FIELDS (node); fld; fld = DECL_CHAIN (fld))
{
if (res)
{
- pp_newline (buffer);
- pp_newline (buffer);
+ pp_newline (pp);
+ pp_newline (pp);
}
- res = dump_ada_declaration (buffer, fld, node, spc);
+ res = dump_ada_declaration (pp, fld, node, spc);
}
return 1;
}
-/* Dump in BUFFER a forward declaration for TYPE present inside T.
+/* Dump in PP a forward declaration for TYPE present inside T.
SPC is the indentation level. */
static void
-dump_forward_type (pretty_printer *buffer, tree type, tree t, int spc)
+dump_forward_type (pretty_printer *pp, tree type, tree t, int spc)
{
tree decl = get_underlying_decl (type);
if (!decl)
{
if (TREE_CODE (type) == POINTER_TYPE)
- dump_forward_type (buffer, TREE_TYPE (type), t, spc);
+ dump_forward_type (pp, TREE_TYPE (type), t, spc);
else if (TREE_CODE (type) == FUNCTION_TYPE)
{
function_args_iterator args_iter;
tree arg;
- dump_forward_type (buffer, TREE_TYPE (type), t, spc);
+ dump_forward_type (pp, TREE_TYPE (type), t, spc);
FOREACH_FUNCTION_ARGS (type, arg, args_iter)
- dump_forward_type (buffer, arg, t, spc);
+ dump_forward_type (pp, arg, t, spc);
}
return;
}
return;
/* Generate an incomplete type declaration. */
- pp_string (buffer, "type ");
- dump_ada_node (buffer, decl, NULL_TREE, spc, false, true);
- pp_semicolon (buffer);
- newline_and_indent (buffer, spc);
+ pp_string (pp, "type ");
+ dump_ada_node (pp, decl, NULL_TREE, spc, false, true);
+ pp_semicolon (pp);
+ newline_and_indent (pp, spc);
/* Only one incomplete declaration is legal for a given type. */
TREE_VISITED (decl) = 1;
static void dump_nested_type (pretty_printer *, tree, tree, int);
-/* Dump in BUFFER anonymous types nested inside T's definition. PARENT is the
+/* Dump in PP anonymous types nested inside T's definition. PARENT is the
parent node of T. DUMPED_TYPES is the bitmap of already dumped types. SPC
is the indentation level.
pass on the nested TYPE_DECLs and a second pass on the unnamed types. */
static void
-dump_nested_types (pretty_printer *buffer, tree t, int spc)
+dump_nested_types (pretty_printer *pp, tree t, int spc)
{
tree type, field;
&& DECL_NAME (field) != DECL_NAME (t)
&& !DECL_ORIGINAL_TYPE (field)
&& TYPE_NAME (TREE_TYPE (field)) != TYPE_NAME (type))
- dump_nested_type (buffer, field, t, spc);
+ dump_nested_type (pp, field, t, spc);
for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
if (TREE_CODE (field) == FIELD_DECL && !TYPE_NAME (TREE_TYPE (field)))
- dump_nested_type (buffer, field, t, spc);
+ dump_nested_type (pp, field, t, spc);
}
-/* Dump in BUFFER the anonymous type of FIELD inside T. SPC is the indentation
+/* Dump in PP the anonymous type of FIELD inside T. SPC is the indentation
level. */
static void
-dump_nested_type (pretty_printer *buffer, tree field, tree t, int spc)
+dump_nested_type (pretty_printer *pp, tree field, tree t, int spc)
{
tree field_type = TREE_TYPE (field);
tree decl, tmp;
{
case POINTER_TYPE:
tmp = TREE_TYPE (field_type);
- dump_forward_type (buffer, tmp, t, spc);
+ dump_forward_type (pp, tmp, t, spc);
break;
case ARRAY_TYPE:
&& !TREE_VISITED (decl))
{
/* Generate full declaration. */
- dump_nested_type (buffer, decl, t, spc);
+ dump_nested_type (pp, decl, t, spc);
TREE_VISITED (decl) = 1;
}
else if (!decl && TREE_CODE (tmp) == POINTER_TYPE)
- dump_forward_type (buffer, TREE_TYPE (tmp), t, spc);
+ dump_forward_type (pp, TREE_TYPE (tmp), t, spc);
/* Special case char arrays. */
if (is_char_array (field_type))
- pp_string (buffer, "subtype ");
+ pp_string (pp, "subtype ");
else
- pp_string (buffer, "type ");
+ pp_string (pp, "type ");
- dump_anonymous_type_name (buffer, field_type);
- pp_string (buffer, " is ");
- dump_ada_array_type (buffer, field_type, spc);
- pp_semicolon (buffer);
- newline_and_indent (buffer, spc);
+ dump_anonymous_type_name (pp, field_type);
+ pp_string (pp, " is ");
+ dump_ada_array_type (pp, field_type, spc);
+ pp_semicolon (pp);
+ newline_and_indent (pp, spc);
break;
case ENUMERAL_TYPE:
if (is_simple_enum (field_type))
- pp_string (buffer, "type ");
+ pp_string (pp, "type ");
else
- pp_string (buffer, "subtype ");
+ pp_string (pp, "subtype ");
if (TYPE_NAME (field_type))
- dump_ada_node (buffer, field_type, NULL_TREE, spc, false, true);
+ dump_ada_node (pp, field_type, NULL_TREE, spc, false, true);
else
- dump_anonymous_type_name (buffer, field_type);
- pp_string (buffer, " is ");
- dump_ada_enum_type (buffer, field_type, NULL_TREE, spc);
- pp_semicolon (buffer);
- newline_and_indent (buffer, spc);
+ dump_anonymous_type_name (pp, field_type);
+ pp_string (pp, " is ");
+ dump_ada_enum_type (pp, field_type, NULL_TREE, spc);
+ pp_semicolon (pp);
+ newline_and_indent (pp, spc);
break;
case RECORD_TYPE:
case UNION_TYPE:
- dump_nested_types (buffer, field, spc);
+ dump_nested_types (pp, field, spc);
- pp_string (buffer, "type ");
+ pp_string (pp, "type ");
if (TYPE_NAME (field_type))
- dump_ada_node (buffer, field_type, NULL_TREE, spc, false, true);
+ dump_ada_node (pp, field_type, NULL_TREE, spc, false, true);
else
- dump_anonymous_type_name (buffer, field_type);
+ dump_anonymous_type_name (pp, field_type);
if (TREE_CODE (field_type) == UNION_TYPE)
- pp_string (buffer, " (discr : unsigned := 0)");
+ pp_string (pp, " (discr : unsigned := 0)");
- pp_string (buffer, " is ");
- dump_ada_structure (buffer, field_type, t, true, spc);
- pp_semicolon (buffer);
- newline_and_indent (buffer, spc);
+ pp_string (pp, " is ");
+ dump_ada_structure (pp, field_type, t, true, spc);
+ pp_semicolon (pp);
+ newline_and_indent (pp, spc);
break;
default:
return h ? ++h->n : 0;
}
-/* Dump in BUFFER constructor spec corresponding to T for TYPE. */
+/* Dump in PP constructor spec corresponding to T for TYPE. */
static void
-print_constructor (pretty_printer *buffer, tree t, tree type)
+print_constructor (pretty_printer *pp, tree t, tree type)
{
tree decl_name = DECL_NAME (TYPE_NAME (type));
- pp_string (buffer, "New_");
- pp_ada_tree_identifier (buffer, decl_name, t, false);
+ pp_string (pp, "New_");
+ pp_ada_tree_identifier (pp, decl_name, t, false);
}
-/* Dump in BUFFER destructor spec corresponding to T. */
+/* Dump in PP destructor spec corresponding to T. */
static void
-print_destructor (pretty_printer *buffer, tree t, tree type)
+print_destructor (pretty_printer *pp, tree t, tree type)
{
tree decl_name = DECL_NAME (TYPE_NAME (type));
- pp_string (buffer, "Delete_");
+ pp_string (pp, "Delete_");
if (startswith (IDENTIFIER_POINTER (DECL_NAME (t)), "__dt_del"))
- pp_string (buffer, "And_Free_");
- pp_ada_tree_identifier (buffer, decl_name, t, false);
+ pp_string (pp, "And_Free_");
+ pp_ada_tree_identifier (pp, decl_name, t, false);
}
-/* Dump in BUFFER assignment operator spec corresponding to T. */
+/* Dump in PP assignment operator spec corresponding to T. */
static void
-print_assignment_operator (pretty_printer *buffer, tree t, tree type)
+print_assignment_operator (pretty_printer *pp, tree t, tree type)
{
tree decl_name = DECL_NAME (TYPE_NAME (type));
- pp_string (buffer, "Assign_");
- pp_ada_tree_identifier (buffer, decl_name, t, false);
+ pp_string (pp, "Assign_");
+ pp_ada_tree_identifier (pp, decl_name, t, false);
}
/* Return the name of type T. */
return IDENTIFIER_POINTER (DECL_NAME (n));
}
-/* Dump in BUFFER the declaration of object T of type TYPE in Ada syntax.
+/* Dump in PP the declaration of object T of type TYPE in Ada syntax.
SPC is the indentation level. Return 1 if a declaration was printed,
0 otherwise. */
static int
-dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc)
+dump_ada_declaration (pretty_printer *pp, tree t, tree type, int spc)
{
bool is_var = false;
bool need_indent = false;
tree orig = NULL_TREE;
if (cpp_check && cpp_check (t, IS_TEMPLATE))
- return dump_ada_template (buffer, t, spc);
+ return dump_ada_template (pp, t, spc);
/* Skip enumeral values: will be handled as part of the type itself. */
if (TREE_CODE (t) == CONST_DECL && TREE_CODE (TREE_TYPE (t)) == ENUMERAL_TYPE)
if (RECORD_OR_UNION_TYPE_P (orig) && !TREE_VISITED (stub))
{
INDENT (spc);
- dump_forward_type (buffer, orig, t, 0);
+ dump_forward_type (pp, orig, t, 0);
}
TREE_VISITED (t) = 1;
INDENT (spc);
if (RECORD_OR_UNION_TYPE_P (orig) && !TREE_VISITED (stub))
- dump_forward_type (buffer, orig, t, spc);
+ dump_forward_type (pp, orig, t, spc);
- pp_string (buffer, "subtype ");
- dump_ada_node (buffer, t, type, spc, false, true);
- pp_string (buffer, " is ");
- dump_ada_node (buffer, orig, type, spc, false, true);
- pp_string (buffer, "; -- ");
- dump_sloc (buffer, t);
+ pp_string (pp, "subtype ");
+ dump_ada_node (pp, t, type, spc, false, true);
+ pp_string (pp, " is ");
+ dump_ada_node (pp, orig, type, spc, false, true);
+ pp_string (pp, "; -- ");
+ dump_sloc (pp, t);
TREE_VISITED (t) = 1;
return 1;
case UNION_TYPE:
if (!COMPLETE_TYPE_P (TREE_TYPE (t)))
{
- pp_string (buffer, "type ");
- dump_ada_node (buffer, t, type, spc, false, true);
- pp_string (buffer, " is null record; -- incomplete struct");
+ pp_string (pp, "type ");
+ dump_ada_node (pp, t, type, spc, false, true);
+ pp_string (pp, " is null record; -- incomplete struct");
TREE_VISITED (t) = 1;
return 1;
}
if (TYPE_PACKED (TREE_TYPE (t)))
{
warning_at (DECL_SOURCE_LOCATION (t), 0, "packed layout");
- pp_string (buffer, "pragma Compile_Time_Warning (True, ");
- pp_string (buffer, "\"packed layout may be incorrect\");");
- newline_and_indent (buffer, spc);
+ pp_string (pp, "pragma Compile_Time_Warning (True, ");
+ pp_string (pp, "\"packed layout may be incorrect\");");
+ newline_and_indent (pp, spc);
packed_layout = true;
}
if (orig && TYPE_NAME (orig))
- pp_string (buffer, "subtype ");
+ pp_string (pp, "subtype ");
else
{
if (separate_class_package (t))
{
is_class = true;
- pp_string (buffer, "package Class_");
- dump_ada_node (buffer, t, type, spc, false, true);
- pp_string (buffer, " is");
+ pp_string (pp, "package Class_");
+ dump_ada_node (pp, t, type, spc, false, true);
+ pp_string (pp, " is");
spc += INDENT_INCR;
- newline_and_indent (buffer, spc);
+ newline_and_indent (pp, spc);
}
- dump_nested_types (buffer, t, spc);
+ dump_nested_types (pp, t, spc);
- pp_string (buffer, "type ");
+ pp_string (pp, "type ");
}
break;
case POINTER_TYPE:
case REFERENCE_TYPE:
- dump_forward_type (buffer, TREE_TYPE (TREE_TYPE (t)), t, spc);
+ dump_forward_type (pp, TREE_TYPE (TREE_TYPE (t)), t, spc);
if (orig && TYPE_NAME (orig))
- pp_string (buffer, "subtype ");
+ pp_string (pp, "subtype ");
else
- pp_string (buffer, "type ");
+ pp_string (pp, "type ");
break;
case ARRAY_TYPE:
if ((orig && TYPE_NAME (orig)) || is_char_array (TREE_TYPE (t)))
- pp_string (buffer, "subtype ");
+ pp_string (pp, "subtype ");
else
- pp_string (buffer, "type ");
+ pp_string (pp, "type ");
break;
case FUNCTION_TYPE:
- pp_string (buffer, "-- skipped function type ");
- dump_ada_node (buffer, t, type, spc, false, true);
+ pp_string (pp, "-- skipped function type ");
+ dump_ada_node (pp, t, type, spc, false, true);
return 1;
case ENUMERAL_TYPE:
if ((orig && TYPE_NAME (orig) && orig != TREE_TYPE (t))
|| !is_simple_enum (TREE_TYPE (t)))
- pp_string (buffer, "subtype ");
+ pp_string (pp, "subtype ");
else
- pp_string (buffer, "type ");
+ pp_string (pp, "type ");
break;
default:
- pp_string (buffer, "subtype ");
+ pp_string (pp, "subtype ");
}
TREE_VISITED (t) = 1;
INDENT (spc);
/* Print variable's name. */
- dump_ada_node (buffer, t, type, spc, false, true);
+ dump_ada_node (pp, t, type, spc, false, true);
if (TREE_CODE (t) == TYPE_DECL)
{
- pp_string (buffer, " is ");
+ pp_string (pp, " is ");
if (orig && TYPE_NAME (orig))
- dump_ada_node (buffer, TYPE_NAME (orig), type, spc, false, true);
+ dump_ada_node (pp, TYPE_NAME (orig), type, spc, false, true);
else
- dump_ada_array_type (buffer, TREE_TYPE (t), spc);
+ dump_ada_array_type (pp, TREE_TYPE (t), spc);
}
else
{
if (spc == INDENT_INCR || TREE_STATIC (t))
is_var = true;
- pp_string (buffer, " : ");
+ pp_string (pp, " : ");
if (TREE_CODE (TREE_TYPE (TREE_TYPE (t))) != POINTER_TYPE
&& !packed_layout)
- pp_string (buffer, "aliased ");
+ pp_string (pp, "aliased ");
if (TYPE_NAME (TREE_TYPE (t)))
- dump_ada_node (buffer, TREE_TYPE (t), type, spc, false, true);
+ dump_ada_node (pp, TREE_TYPE (t), type, spc, false, true);
else if (type)
- dump_anonymous_type_name (buffer, TREE_TYPE (t));
+ dump_anonymous_type_name (pp, TREE_TYPE (t));
else
- dump_ada_array_type (buffer, TREE_TYPE (t), spc);
+ dump_ada_array_type (pp, TREE_TYPE (t), spc);
}
}
else if (TREE_CODE (t) == FUNCTION_DECL)
else if (!DECL_VINDEX (t) && *IDENTIFIER_POINTER (decl_name) == '_')
{
INDENT (spc);
- pp_string (buffer, "-- skipped func ");
- pp_string (buffer, IDENTIFIER_POINTER (decl_name));
+ pp_string (pp, "-- skipped func ");
+ pp_string (pp, IDENTIFIER_POINTER (decl_name));
return 1;
}
INDENT (spc);
- dump_forward_type (buffer, TREE_TYPE (t), t, spc);
+ dump_forward_type (pp, TREE_TYPE (t), t, spc);
if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (t))) && !is_constructor)
- pp_string (buffer, "procedure ");
+ pp_string (pp, "procedure ");
else
- pp_string (buffer, "function ");
+ pp_string (pp, "function ");
if (is_constructor)
- print_constructor (buffer, t, type);
+ print_constructor (pp, t, type);
else if (is_destructor)
- print_destructor (buffer, t, type);
+ print_destructor (pp, t, type);
else if (is_assignment_operator)
- print_assignment_operator (buffer, t, type);
+ print_assignment_operator (pp, t, type);
else
{
const unsigned int suffix = overloading_index (decl_name);
- pp_ada_tree_identifier (buffer, decl_name, t, false);
+ pp_ada_tree_identifier (pp, decl_name, t, false);
if (suffix > 1)
- pp_decimal_int (buffer, suffix);
+ pp_decimal_int (pp, suffix);
}
dump_ada_function_declaration
- (buffer, t, is_method, is_constructor, is_destructor, spc);
+ (pp, t, is_method, is_constructor, is_destructor, spc);
if (is_constructor && RECORD_OR_UNION_TYPE_P (type))
for (tree fld = TYPE_FIELDS (type); fld; fld = DECL_CHAIN (fld))
}
if (is_abstract || is_abstract_class)
- pp_string (buffer, " is abstract");
+ pp_string (pp, " is abstract");
if (is_abstract || !DECL_ASSEMBLER_NAME (t))
{
- pp_semicolon (buffer);
- pp_string (buffer, " -- ");
- dump_sloc (buffer, t);
+ pp_semicolon (pp);
+ pp_string (pp, " -- ");
+ dump_sloc (pp, t);
}
else if (is_constructor)
{
- pp_semicolon (buffer);
- pp_string (buffer, " -- ");
- dump_sloc (buffer, t);
-
- newline_and_indent (buffer, spc);
- pp_string (buffer, "pragma CPP_Constructor (");
- print_constructor (buffer, t, type);
- pp_string (buffer, ", \"");
- pp_asm_name (buffer, t);
- pp_string (buffer, "\");");
+ pp_semicolon (pp);
+ pp_string (pp, " -- ");
+ dump_sloc (pp, t);
+
+ newline_and_indent (pp, spc);
+ pp_string (pp, "pragma CPP_Constructor (");
+ print_constructor (pp, t, type);
+ pp_string (pp, ", \"");
+ pp_asm_name (pp, t);
+ pp_string (pp, "\");");
}
else
{
- pp_string (buffer, " -- ");
- dump_sloc (buffer, t);
+ pp_string (pp, " -- ");
+ dump_sloc (pp, t);
- newline_and_indent (buffer, spc);
- dump_ada_import (buffer, t, spc);
+ newline_and_indent (pp, spc);
+ dump_ada_import (pp, t, spc);
}
return 1;
bool is_abstract_record = false;
/* Anonymous structs/unions. */
- dump_ada_node (buffer, TREE_TYPE (t), t, spc, false, true);
+ dump_ada_node (pp, TREE_TYPE (t), t, spc, false, true);
if (TREE_CODE (TREE_TYPE (t)) == UNION_TYPE)
- pp_string (buffer, " (discr : unsigned := 0)");
+ pp_string (pp, " (discr : unsigned := 0)");
- pp_string (buffer, " is ");
+ pp_string (pp, " is ");
/* Check whether we have an Ada interface compatible class.
That is only have a vtable non-static data member and no
TREE_VISITED (t) = 1;
if (is_interface)
{
- pp_string (buffer, "limited interface -- ");
- dump_sloc (buffer, t);
- newline_and_indent (buffer, spc);
- pp_string (buffer, "with Import => True,");
- newline_and_indent (buffer, spc + 5);
- pp_string (buffer, "Convention => CPP");
-
- dump_ada_methods (buffer, TREE_TYPE (t), spc);
+ pp_string (pp, "limited interface -- ");
+ dump_sloc (pp, t);
+ newline_and_indent (pp, spc);
+ pp_string (pp, "with Import => True,");
+ newline_and_indent (pp, spc + 5);
+ pp_string (pp, "Convention => CPP");
+
+ dump_ada_methods (pp, TREE_TYPE (t), spc);
}
else
{
if (is_abstract_record)
- pp_string (buffer, "abstract ");
- dump_ada_node (buffer, t, t, spc, false, false);
+ pp_string (pp, "abstract ");
+ dump_ada_node (pp, t, t, spc, false, false);
}
}
else
if ((TREE_CODE (t) == FIELD_DECL || VAR_P (t))
&& DECL_NAME (t))
- check_type_name_conflict (buffer, t);
+ check_type_name_conflict (pp, t);
/* Print variable/type's name. */
- dump_ada_node (buffer, t, t, spc, false, true);
+ dump_ada_node (pp, t, t, spc, false, true);
if (TREE_CODE (t) == TYPE_DECL)
{
const bool is_subtype = TYPE_NAME (orig);
if (!is_subtype && TREE_CODE (TREE_TYPE (t)) == UNION_TYPE)
- pp_string (buffer, " (discr : unsigned := 0)");
+ pp_string (pp, " (discr : unsigned := 0)");
- pp_string (buffer, " is ");
+ pp_string (pp, " is ");
- dump_ada_node (buffer, orig, t, spc, false, is_subtype);
+ dump_ada_node (pp, orig, t, spc, false, is_subtype);
}
else
{
if (spc == INDENT_INCR || TREE_STATIC (t))
is_var = true;
- pp_string (buffer, " : ");
+ pp_string (pp, " : ");
if (TREE_CODE (TREE_TYPE (t)) != POINTER_TYPE
&& (TYPE_NAME (TREE_TYPE (t))
|| (TREE_CODE (TREE_TYPE (t)) != INTEGER_TYPE
&& TREE_CODE (TREE_TYPE (t)) != ENUMERAL_TYPE))
&& !packed_layout)
- pp_string (buffer, "aliased ");
+ pp_string (pp, "aliased ");
if (TREE_READONLY (t) && TREE_CODE (t) != FIELD_DECL)
- pp_string (buffer, "constant ");
+ pp_string (pp, "constant ");
if (TYPE_NAME (TREE_TYPE (t))
|| (!RECORD_OR_UNION_TYPE_P (TREE_TYPE (t))
&& TREE_CODE (TREE_TYPE (t)) != ENUMERAL_TYPE))
- dump_ada_node (buffer, TREE_TYPE (t), t, spc, false, true);
+ dump_ada_node (pp, TREE_TYPE (t), t, spc, false, true);
else if (type)
- dump_anonymous_type_name (buffer, TREE_TYPE (t));
+ dump_anonymous_type_name (pp, TREE_TYPE (t));
}
}
if (is_class)
{
spc -= INDENT_INCR;
- newline_and_indent (buffer, spc);
- pp_string (buffer, "end;");
- newline_and_indent (buffer, spc);
- pp_string (buffer, "use Class_");
- dump_ada_node (buffer, t, type, spc, false, true);
- pp_semicolon (buffer);
- pp_newline (buffer);
+ newline_and_indent (pp, spc);
+ pp_string (pp, "end;");
+ newline_and_indent (pp, spc);
+ pp_string (pp, "use Class_");
+ dump_ada_node (pp, t, type, spc, false, true);
+ pp_semicolon (pp);
+ pp_newline (pp);
/* All needed indentation/newline performed already, so return 0. */
return 0;
}
else if (is_var)
{
- pp_string (buffer, " -- ");
- dump_sloc (buffer, t);
- newline_and_indent (buffer, spc);
- dump_ada_import (buffer, t, spc);
+ pp_string (pp, " -- ");
+ dump_sloc (pp, t);
+ newline_and_indent (pp, spc);
+ dump_ada_import (pp, t, spc);
}
else
{
- pp_string (buffer, "; -- ");
- dump_sloc (buffer, t);
+ pp_string (pp, "; -- ");
+ dump_sloc (pp, t);
}
return 1;
}
-/* Dump in BUFFER a structure NODE of type TYPE in Ada syntax. If NESTED is
+/* Dump in PP a structure NODE of type TYPE in Ada syntax. If NESTED is
true, it's an anonymous nested type. SPC is the indentation level. */
static void
-dump_ada_structure (pretty_printer *buffer, tree node, tree type, bool nested,
+dump_ada_structure (pretty_printer *pp, tree node, tree type, bool nested,
int spc)
{
const bool is_union = (TREE_CODE (node) == UNION_TYPE);
bitfield_used = false;
/* Print the contents of the structure. */
- pp_string (buffer, "record");
+ pp_string (pp, "record");
if (is_union)
{
- newline_and_indent (buffer, spc + INDENT_INCR);
- pp_string (buffer, "case discr is");
+ newline_and_indent (pp, spc + INDENT_INCR);
+ pp_string (pp, "case discr is");
field_spc = spc + INDENT_INCR * 3;
}
- pp_newline (buffer);
+ pp_newline (pp);
/* Print the non-static fields of the structure. */
for (tree tmp = TYPE_FIELDS (node); tmp; tmp = TREE_CHAIN (tmp))
if (!is_tagged_type (TREE_TYPE (tmp)))
{
if (!TYPE_NAME (TREE_TYPE (tmp)))
- dump_ada_declaration (buffer, tmp, type, field_spc);
+ dump_ada_declaration (pp, tmp, type, field_spc);
else
{
INDENT (field_spc);
if (field_num == 0)
- pp_string (buffer, "parent : aliased ");
+ pp_string (pp, "parent : aliased ");
else
{
sprintf (buf, "field_%d : aliased ", field_num + 1);
- pp_string (buffer, buf);
+ pp_string (pp, buf);
}
- dump_ada_decl_name (buffer, TYPE_NAME (TREE_TYPE (tmp)),
+ dump_ada_decl_name (pp, TYPE_NAME (TREE_TYPE (tmp)),
false);
- pp_semicolon (buffer);
+ pp_semicolon (pp);
}
- pp_newline (buffer);
+ pp_newline (pp);
field_num++;
}
}
sprintf (buf, "when others =>");
INDENT (spc + INDENT_INCR * 2);
- pp_string (buffer, buf);
- pp_newline (buffer);
+ pp_string (pp, buf);
+ pp_newline (pp);
}
- if (dump_ada_declaration (buffer, tmp, type, field_spc))
+ if (dump_ada_declaration (pp, tmp, type, field_spc))
{
- pp_newline (buffer);
+ pp_newline (pp);
field_num++;
}
}
if (is_union)
{
INDENT (spc + INDENT_INCR);
- pp_string (buffer, "end case;");
- pp_newline (buffer);
+ pp_string (pp, "end case;");
+ pp_newline (pp);
}
if (field_num == 0)
{
INDENT (spc + INDENT_INCR);
- pp_string (buffer, "null;");
- pp_newline (buffer);
+ pp_string (pp, "null;");
+ pp_newline (pp);
}
INDENT (spc);
- pp_string (buffer, "end record");
+ pp_string (pp, "end record");
- newline_and_indent (buffer, spc);
+ newline_and_indent (pp, spc);
/* We disregard the methods for anonymous nested types. */
if (has_nontrivial_methods (node) && !nested)
{
- pp_string (buffer, "with Import => True,");
- newline_and_indent (buffer, spc + 5);
- pp_string (buffer, "Convention => CPP");
+ pp_string (pp, "with Import => True,");
+ newline_and_indent (pp, spc + 5);
+ pp_string (pp, "Convention => CPP");
}
else
- pp_string (buffer, "with Convention => C_Pass_By_Copy");
+ pp_string (pp, "with Convention => C_Pass_By_Copy");
if (is_union)
{
- pp_comma (buffer);
- newline_and_indent (buffer, spc + 5);
- pp_string (buffer, "Unchecked_Union => True");
+ pp_comma (pp);
+ newline_and_indent (pp, spc + 5);
+ pp_string (pp, "Unchecked_Union => True");
}
if (bitfield_used || packed_layout)
{
char buf[32];
- pp_comma (buffer);
- newline_and_indent (buffer, spc + 5);
- pp_string (buffer, "Pack => True");
- pp_comma (buffer);
- newline_and_indent (buffer, spc + 5);
+ pp_comma (pp);
+ newline_and_indent (pp, spc + 5);
+ pp_string (pp, "Pack => True");
+ pp_comma (pp);
+ newline_and_indent (pp, spc + 5);
sprintf (buf, "Alignment => %d", TYPE_ALIGN (node) / BITS_PER_UNIT);
- pp_string (buffer, buf);
+ pp_string (pp, buf);
bitfield_used = false;
packed_layout = false;
}
if (nested)
return;
- need_semicolon = !dump_ada_methods (buffer, node, spc);
+ need_semicolon = !dump_ada_methods (pp, node, spc);
/* Print the static fields of the structure, if any. */
for (tree tmp = TYPE_FIELDS (node); tmp; tmp = TREE_CHAIN (tmp))
if (need_semicolon)
{
need_semicolon = false;
- pp_semicolon (buffer);
+ pp_semicolon (pp);
}
- pp_newline (buffer);
- pp_newline (buffer);
- dump_ada_declaration (buffer, tmp, type, spc);
+ pp_newline (pp);
+ pp_newline (pp);
+ dump_ada_declaration (pp, tmp, type, spc);
}
}
}
#endif
#define INDENT(SPACE) \
- do { int i; for (i = 0; i < SPACE; i++) pp_space (buffer); } while (0)
+ do { int i; for (i = 0; i < SPACE; i++) pp_space (pp); } while (0)
-#define GIMPLE_NIY do_niy (buffer,gs)
+#define GIMPLE_NIY do_niy (pp,gs)
-/* Try to print on BUFFER a default message for the unrecognized
+/* Try to print on PP a default message for the unrecognized
gimple statement GS. */
static void
-do_niy (pretty_printer *buffer, const gimple *gs)
+do_niy (pretty_printer *pp, const gimple *gs)
{
- pp_printf (buffer, "<<< Unknown GIMPLE statement: %s >>>\n",
+ pp_printf (pp, "<<< Unknown GIMPLE statement: %s >>>\n",
gimple_code_name[(int) gimple_code (gs)]);
}
-/* Emit a newline and SPC indentation spaces to BUFFER. */
+/* Emit a newline and SPC indentation spaces to PP. */
static void
-newline_and_indent (pretty_printer *buffer, int spc)
+newline_and_indent (pretty_printer *pp, int spc)
{
- pp_newline (buffer);
+ pp_newline (pp);
INDENT (spc);
}
return ret;
}
-/* Dump E probability to BUFFER. */
+/* Dump E probability to PP. */
static void
-dump_edge_probability (pretty_printer *buffer, edge e)
+dump_edge_probability (pretty_printer *pp, edge e)
{
- pp_scalar (buffer, " %s", dump_probability (e->probability));
+ pp_scalar (pp, " %s", dump_probability (e->probability));
}
/* Print GIMPLE statement G to FILE using SPC indentation spaces and
void
print_gimple_stmt (FILE *file, gimple *g, int spc, dump_flags_t flags)
{
- pretty_printer buffer;
- pp_needs_newline (&buffer) = true;
- buffer.buffer->stream = file;
- pp_gimple_stmt_1 (&buffer, g, spc, flags);
- pp_newline_and_flush (&buffer);
+ pretty_printer pp;
+ pp_needs_newline (&pp) = true;
+ pp.buffer->stream = file;
+ pp_gimple_stmt_1 (&pp, g, spc, flags);
+ pp_newline_and_flush (&pp);
}
DEBUG_FUNCTION void
print_gimple_expr (FILE *file, gimple *g, int spc, dump_flags_t flags)
{
flags |= TDF_RHS_ONLY;
- pretty_printer buffer;
- pp_needs_newline (&buffer) = true;
- buffer.buffer->stream = file;
- pp_gimple_stmt_1 (&buffer, g, spc, flags);
- pp_flush (&buffer);
+ pretty_printer pp;
+ pp_needs_newline (&pp) = true;
+ pp.buffer->stream = file;
+ pp_gimple_stmt_1 (&pp, g, spc, flags);
+ pp_flush (&pp);
}
-/* Print the GIMPLE sequence SEQ on BUFFER using SPC indentation
+/* Print the GIMPLE sequence SEQ on PP using SPC indentation
spaces and FLAGS as in pp_gimple_stmt_1.
- The caller is responsible for calling pp_flush on BUFFER to finalize
+ The caller is responsible for calling pp_flush on PP to finalize
the pretty printer. */
static void
-dump_gimple_seq (pretty_printer *buffer, gimple_seq seq, int spc,
+dump_gimple_seq (pretty_printer *pp, gimple_seq seq, int spc,
dump_flags_t flags)
{
gimple_stmt_iterator i;
{
gimple *gs = gsi_stmt (i);
INDENT (spc);
- pp_gimple_stmt_1 (buffer, gs, spc, flags);
+ pp_gimple_stmt_1 (pp, gs, spc, flags);
if (!gsi_one_before_end_p (i))
- pp_newline (buffer);
+ pp_newline (pp);
}
}
void
print_gimple_seq (FILE *file, gimple_seq seq, int spc, dump_flags_t flags)
{
- pretty_printer buffer;
- pp_needs_newline (&buffer) = true;
- buffer.buffer->stream = file;
- dump_gimple_seq (&buffer, seq, spc, flags);
- pp_newline_and_flush (&buffer);
+ pretty_printer pp;
+ pp_needs_newline (&pp) = true;
+ pp.buffer->stream = file;
+ dump_gimple_seq (&pp, seq, spc, flags);
+ pp_newline_and_flush (&pp);
}
'-' - decreases indent by 2 then outputs a newline. */
static void
-dump_gimple_fmt (pretty_printer *buffer, int spc, dump_flags_t flags,
+dump_gimple_fmt (pretty_printer *pp, int spc, dump_flags_t flags,
const char *fmt, ...)
{
va_list args;
case 'G':
g = va_arg (args, gimple *);
tmp = gimple_code_name[gimple_code (g)];
- pp_string (buffer, tmp);
+ pp_string (pp, tmp);
break;
case 'S':
seq = va_arg (args, gimple_seq);
- pp_newline (buffer);
- dump_gimple_seq (buffer, seq, spc + 2, flags);
- newline_and_indent (buffer, spc);
+ pp_newline (pp);
+ dump_gimple_seq (pp, seq, spc + 2, flags);
+ newline_and_indent (pp, spc);
break;
case 'T':
t = va_arg (args, tree);
if (t == NULL_TREE)
- pp_string (buffer, "NULL");
+ pp_string (pp, "NULL");
else
- dump_generic_node (buffer, t, spc, flags, false);
+ dump_generic_node (pp, t, spc, flags, false);
break;
case 'd':
- pp_decimal_int (buffer, va_arg (args, int));
+ pp_decimal_int (pp, va_arg (args, int));
break;
case 's':
- pp_string (buffer, va_arg (args, char *));
+ pp_string (pp, va_arg (args, char *));
break;
case 'n':
- newline_and_indent (buffer, spc);
+ newline_and_indent (pp, spc);
break;
case 'x':
- pp_scalar (buffer, "%x", va_arg (args, int));
+ pp_scalar (pp, "%x", va_arg (args, int));
break;
case '+':
spc += 2;
- newline_and_indent (buffer, spc);
+ newline_and_indent (pp, spc);
break;
case '-':
spc -= 2;
- newline_and_indent (buffer, spc);
+ newline_and_indent (pp, spc);
break;
default:
}
}
else
- pp_character (buffer, *c);
+ pp_character (pp, *c);
}
va_end (args);
}
/* Helper for dump_gimple_assign. Print the unary RHS of the
- assignment GS. BUFFER, SPC and FLAGS are as in pp_gimple_stmt_1. */
+ assignment GS. PP, SPC and FLAGS are as in pp_gimple_stmt_1. */
static void
-dump_unary_rhs (pretty_printer *buffer, const gassign *gs, int spc,
+dump_unary_rhs (pretty_printer *pp, const gassign *gs, int spc,
dump_flags_t flags)
{
enum tree_code rhs_code = gimple_assign_rhs_code (gs);
switch (rhs_code)
{
case VIEW_CONVERT_EXPR:
- dump_generic_node (buffer, rhs, spc, flags, false);
+ dump_generic_node (pp, rhs, spc, flags, false);
break;
case FIXED_CONVERT_EXPR:
case FIX_TRUNC_EXPR:
case FLOAT_EXPR:
CASE_CONVERT:
- pp_left_paren (buffer);
- dump_generic_node (buffer, TREE_TYPE (lhs), spc, flags, false);
- pp_string (buffer, ") ");
+ pp_left_paren (pp);
+ dump_generic_node (pp, TREE_TYPE (lhs), spc, flags, false);
+ pp_string (pp, ") ");
if (op_prio (rhs) < op_code_prio (rhs_code))
{
- pp_left_paren (buffer);
- dump_generic_node (buffer, rhs, spc, flags, false);
- pp_right_paren (buffer);
+ pp_left_paren (pp);
+ dump_generic_node (pp, rhs, spc, flags, false);
+ pp_right_paren (pp);
}
else
- dump_generic_node (buffer, rhs, spc, flags, false);
+ dump_generic_node (pp, rhs, spc, flags, false);
break;
case PAREN_EXPR:
- pp_string (buffer, "((");
- dump_generic_node (buffer, rhs, spc, flags, false);
- pp_string (buffer, "))");
+ pp_string (pp, "((");
+ dump_generic_node (pp, rhs, spc, flags, false);
+ pp_string (pp, "))");
break;
case ABS_EXPR:
case ABSU_EXPR:
if (flags & TDF_GIMPLE)
{
- pp_string (buffer,
+ pp_string (pp,
rhs_code == ABS_EXPR ? "__ABS " : "__ABSU ");
- dump_generic_node (buffer, rhs, spc, flags, false);
+ dump_generic_node (pp, rhs, spc, flags, false);
}
else
{
- pp_string (buffer,
+ pp_string (pp,
rhs_code == ABS_EXPR ? "ABS_EXPR <" : "ABSU_EXPR <");
- dump_generic_node (buffer, rhs, spc, flags, false);
- pp_greater (buffer);
+ dump_generic_node (pp, rhs, spc, flags, false);
+ pp_greater (pp);
}
break;
|| rhs_code == ADDR_EXPR
|| rhs_code == CONSTRUCTOR)
{
- dump_generic_node (buffer, rhs, spc, flags, false);
+ dump_generic_node (pp, rhs, spc, flags, false);
break;
}
else if (rhs_code == BIT_NOT_EXPR)
- pp_complement (buffer);
+ pp_complement (pp);
else if (rhs_code == TRUTH_NOT_EXPR)
- pp_exclamation (buffer);
+ pp_exclamation (pp);
else if (rhs_code == NEGATE_EXPR)
- pp_minus (buffer);
+ pp_minus (pp);
else
{
- pp_left_bracket (buffer);
- pp_string (buffer, get_tree_code_name (rhs_code));
- pp_string (buffer, "] ");
+ pp_left_bracket (pp);
+ pp_string (pp, get_tree_code_name (rhs_code));
+ pp_string (pp, "] ");
}
if (op_prio (rhs) < op_code_prio (rhs_code))
{
- pp_left_paren (buffer);
- dump_generic_node (buffer, rhs, spc, flags, false);
- pp_right_paren (buffer);
+ pp_left_paren (pp);
+ dump_generic_node (pp, rhs, spc, flags, false);
+ pp_right_paren (pp);
}
else
- dump_generic_node (buffer, rhs, spc, flags, false);
+ dump_generic_node (pp, rhs, spc, flags, false);
break;
}
}
/* Helper for dump_gimple_assign. Print the binary RHS of the
- assignment GS. BUFFER, SPC and FLAGS are as in pp_gimple_stmt_1. */
+ assignment GS. PP, SPC and FLAGS are as in pp_gimple_stmt_1. */
static void
-dump_binary_rhs (pretty_printer *buffer, const gassign *gs, int spc,
+dump_binary_rhs (pretty_printer *pp, const gassign *gs, int spc,
dump_flags_t flags)
{
const char *p;
case MAX_EXPR:
if (flags & TDF_GIMPLE)
{
- pp_string (buffer, code == MIN_EXPR ? "__MIN (" : "__MAX (");
- dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags,
+ pp_string (pp, code == MIN_EXPR ? "__MIN (" : "__MAX (");
+ dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags,
false);
- pp_string (buffer, ", ");
- dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags,
+ pp_string (pp, ", ");
+ dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags,
false);
- pp_string (buffer, ")");
+ pp_string (pp, ")");
break;
}
else
case VEC_WIDEN_LSHIFT_LO_EXPR:
case VEC_SERIES_EXPR:
for (p = get_tree_code_name (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_greater (buffer);
+ pp_character (pp, TOUPPER (*p));
+ pp_string (pp, " <");
+ dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false);
+ pp_string (pp, ", ");
+ dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false);
+ pp_greater (pp);
break;
default:
if (op_prio (gimple_assign_rhs1 (gs)) <= op_code_prio (code))
{
- pp_left_paren (buffer);
- dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags,
+ pp_left_paren (pp);
+ dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags,
false);
- pp_right_paren (buffer);
+ pp_right_paren (pp);
}
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), flags));
- pp_space (buffer);
+ dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false);
+ pp_space (pp);
+ pp_string (pp, op_symbol_code (gimple_assign_rhs_code (gs), flags));
+ pp_space (pp);
if (op_prio (gimple_assign_rhs2 (gs)) <= op_code_prio (code))
{
- pp_left_paren (buffer);
- dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags,
+ pp_left_paren (pp);
+ dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags,
false);
- pp_right_paren (buffer);
+ pp_right_paren (pp);
}
else
- dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
+ dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false);
}
}
/* Helper for dump_gimple_assign. Print the ternary RHS of the
- assignment GS. BUFFER, SPC and FLAGS are as in pp_gimple_stmt_1. */
+ assignment GS. PP, SPC and FLAGS are as in pp_gimple_stmt_1. */
static void
-dump_ternary_rhs (pretty_printer *buffer, const gassign *gs, int spc,
+dump_ternary_rhs (pretty_printer *pp, const gassign *gs, int spc,
dump_flags_t flags)
{
const char *p;
case WIDEN_MULT_PLUS_EXPR:
case WIDEN_MULT_MINUS_EXPR:
for (p = get_tree_code_name (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, ", ");
- dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
- pp_greater (buffer);
+ pp_character (pp, TOUPPER (*p));
+ pp_string (pp, " <");
+ dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false);
+ pp_string (pp, ", ");
+ dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false);
+ pp_string (pp, ", ");
+ dump_generic_node (pp, gimple_assign_rhs3 (gs), spc, flags, false);
+ pp_greater (pp);
break;
case DOT_PROD_EXPR:
- pp_string (buffer, "DOT_PROD_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, ", ");
- dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
- pp_greater (buffer);
+ pp_string (pp, "DOT_PROD_EXPR <");
+ dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false);
+ pp_string (pp, ", ");
+ dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false);
+ pp_string (pp, ", ");
+ dump_generic_node (pp, gimple_assign_rhs3 (gs), spc, flags, false);
+ pp_greater (pp);
break;
case SAD_EXPR:
- pp_string (buffer, "SAD_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, ", ");
- dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
- pp_greater (buffer);
+ pp_string (pp, "SAD_EXPR <");
+ dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false);
+ pp_string (pp, ", ");
+ dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false);
+ pp_string (pp, ", ");
+ dump_generic_node (pp, gimple_assign_rhs3 (gs), spc, flags, false);
+ pp_greater (pp);
break;
case VEC_PERM_EXPR:
if (flags & TDF_GIMPLE)
- pp_string (buffer, "__VEC_PERM (");
+ pp_string (pp, "__VEC_PERM (");
else
- pp_string (buffer, "VEC_PERM_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, ", ");
- dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
+ pp_string (pp, "VEC_PERM_EXPR <");
+ dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false);
+ pp_string (pp, ", ");
+ dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false);
+ pp_string (pp, ", ");
+ dump_generic_node (pp, gimple_assign_rhs3 (gs), spc, flags, false);
if (flags & TDF_GIMPLE)
- pp_right_paren (buffer);
+ pp_right_paren (pp);
else
- pp_greater (buffer);
+ pp_greater (pp);
break;
case REALIGN_LOAD_EXPR:
- pp_string (buffer, "REALIGN_LOAD <");
- 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, ", ");
- dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
- pp_greater (buffer);
+ pp_string (pp, "REALIGN_LOAD <");
+ dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false);
+ pp_string (pp, ", ");
+ dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false);
+ pp_string (pp, ", ");
+ dump_generic_node (pp, gimple_assign_rhs3 (gs), spc, flags, false);
+ pp_greater (pp);
break;
case COND_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, " : ");
- dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
+ dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false);
+ pp_string (pp, " ? ");
+ dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false);
+ pp_string (pp, " : ");
+ dump_generic_node (pp, gimple_assign_rhs3 (gs), spc, flags, false);
break;
case VEC_COND_EXPR:
- pp_string (buffer, "VEC_COND_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, ", ");
- dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
- pp_greater (buffer);
+ pp_string (pp, "VEC_COND_EXPR <");
+ dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false);
+ pp_string (pp, ", ");
+ dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false);
+ pp_string (pp, ", ");
+ dump_generic_node (pp, gimple_assign_rhs3 (gs), spc, flags, false);
+ pp_greater (pp);
break;
case BIT_INSERT_EXPR:
if (flags & TDF_GIMPLE)
{
- pp_string (buffer, "__BIT_INSERT (");
- dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc,
+ pp_string (pp, "__BIT_INSERT (");
+ dump_generic_node (pp, gimple_assign_rhs1 (gs), spc,
flags | TDF_SLIM, false);
- pp_string (buffer, ", ");
- dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc,
+ pp_string (pp, ", ");
+ dump_generic_node (pp, gimple_assign_rhs2 (gs), spc,
flags | TDF_SLIM, false);
- pp_string (buffer, ", ");
- dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc,
+ pp_string (pp, ", ");
+ dump_generic_node (pp, gimple_assign_rhs3 (gs), spc,
flags | TDF_SLIM, false);
- pp_right_paren (buffer);
+ pp_right_paren (pp);
}
else
{
- pp_string (buffer, "BIT_INSERT_EXPR <");
- dump_generic_node (buffer, gimple_assign_rhs1 (gs),
+ pp_string (pp, "BIT_INSERT_EXPR <");
+ dump_generic_node (pp, gimple_assign_rhs1 (gs),
spc, flags, false);
- pp_string (buffer, ", ");
- dump_generic_node (buffer, gimple_assign_rhs2 (gs),
+ pp_string (pp, ", ");
+ dump_generic_node (pp, gimple_assign_rhs2 (gs),
spc, flags, false);
- pp_string (buffer, ", ");
- dump_generic_node (buffer, gimple_assign_rhs3 (gs),
+ pp_string (pp, ", ");
+ dump_generic_node (pp, gimple_assign_rhs3 (gs),
spc, flags, false);
if (INTEGRAL_TYPE_P (TREE_TYPE (gimple_assign_rhs2 (gs))))
{
- pp_string (buffer, " (");
- pp_decimal_int (buffer, TYPE_PRECISION
+ pp_string (pp, " (");
+ pp_decimal_int (pp, TYPE_PRECISION
(TREE_TYPE (gimple_assign_rhs2 (gs))));
- pp_string (buffer, " bits)");
+ pp_string (pp, " bits)");
}
- pp_greater (buffer);
+ pp_greater (pp);
}
break;
}
-/* Dump the gimple assignment GS. BUFFER, SPC and FLAGS are as in
+/* Dump the gimple assignment GS. PP, SPC and FLAGS are as in
pp_gimple_stmt_1. */
static void
-dump_gimple_assign (pretty_printer *buffer, const gassign *gs, int spc,
+dump_gimple_assign (pretty_printer *pp, const gassign *gs, int spc,
dump_flags_t flags)
{
if (flags & TDF_RAW)
gcc_unreachable ();
}
- dump_gimple_fmt (buffer, spc, flags, "%G <%s, %T, %T, %T, %T>", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G <%s, %T, %T, %T, %T>", gs,
get_tree_code_name (gimple_assign_rhs_code (gs)),
gimple_assign_lhs (gs), arg1, arg2, arg3);
}
{
if (!(flags & TDF_RHS_ONLY))
{
- dump_generic_node (buffer, gimple_assign_lhs (gs), spc, flags, false);
- pp_space (buffer);
- pp_equal (buffer);
+ dump_generic_node (pp, gimple_assign_lhs (gs), spc, flags, false);
+ pp_space (pp);
+ pp_equal (pp);
if (gimple_assign_nontemporal_move_p (gs))
- pp_string (buffer, "{nt}");
+ pp_string (pp, "{nt}");
if (gimple_has_volatile_ops (gs))
- pp_string (buffer, "{v}");
+ pp_string (pp, "{v}");
- pp_space (buffer);
+ pp_space (pp);
}
if (gimple_num_ops (gs) == 2)
- dump_unary_rhs (buffer, gs, spc,
+ dump_unary_rhs (pp, gs, spc,
((flags & TDF_GIMPLE)
&& gimple_assign_rhs_class (gs) != GIMPLE_SINGLE_RHS)
? (flags | TDF_GIMPLE_VAL) : flags);
else if (gimple_num_ops (gs) == 3)
- dump_binary_rhs (buffer, gs, spc,
+ dump_binary_rhs (pp, gs, spc,
(flags & TDF_GIMPLE)
? (flags | TDF_GIMPLE_VAL) : flags);
else if (gimple_num_ops (gs) == 4)
- dump_ternary_rhs (buffer, gs, spc,
+ dump_ternary_rhs (pp, gs, spc,
(flags & TDF_GIMPLE)
? (flags | TDF_GIMPLE_VAL) : flags);
else
gcc_unreachable ();
if (!(flags & TDF_RHS_ONLY))
- pp_semicolon (buffer);
+ pp_semicolon (pp);
}
}
-/* Dump the return statement GS. BUFFER, SPC and FLAGS are as in
+/* Dump the return statement GS. PP, SPC and FLAGS are as in
pp_gimple_stmt_1. */
static void
-dump_gimple_return (pretty_printer *buffer, const greturn *gs, int spc,
+dump_gimple_return (pretty_printer *pp, const greturn *gs, int spc,
dump_flags_t flags)
{
tree t;
t = gimple_return_retval (gs);
if (flags & TDF_RAW)
- dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, t);
+ dump_gimple_fmt (pp, spc, flags, "%G <%T>", gs, t);
else
{
- pp_string (buffer, "return");
+ pp_string (pp, "return");
if (t)
{
- pp_space (buffer);
- dump_generic_node (buffer, t, spc, flags, false);
+ pp_space (pp);
+ dump_generic_node (pp, t, spc, flags, false);
}
- pp_semicolon (buffer);
+ pp_semicolon (pp);
}
}
-/* Dump the call arguments for a gimple call. BUFFER, FLAGS are as in
+/* Dump the call arguments for a gimple call. PP, FLAGS are as in
dump_gimple_call. */
static void
-dump_gimple_call_args (pretty_printer *buffer, const gcall *gs,
+dump_gimple_call_args (pretty_printer *pp, const gcall *gs,
dump_flags_t flags)
{
size_t i = 0;
&& (v = tree_to_shwi (arg0)) >= 0 && v < limit)
{
i++;
- pp_string (buffer, enums[v]);
+ pp_string (pp, enums[v]);
}
}
}
for (; i < gimple_call_num_args (gs); i++)
{
if (i)
- pp_string (buffer, ", ");
- dump_generic_node (buffer, gimple_call_arg (gs, i), 0, flags, false);
+ pp_string (pp, ", ");
+ dump_generic_node (pp, gimple_call_arg (gs, i), 0, flags, false);
}
if (gimple_call_va_arg_pack_p (gs))
{
if (i)
- pp_string (buffer, ", ");
+ pp_string (pp, ", ");
- pp_string (buffer, "__builtin_va_arg_pack ()");
+ pp_string (pp, "__builtin_va_arg_pack ()");
}
}
-/* Dump the points-to solution *PT to BUFFER. */
+/* Dump the points-to solution *PT to PP. */
static void
-pp_points_to_solution (pretty_printer *buffer, const pt_solution *pt)
+pp_points_to_solution (pretty_printer *pp, const pt_solution *pt)
{
if (pt->anything)
{
- pp_string (buffer, "anything ");
+ pp_string (pp, "anything ");
return;
}
if (pt->nonlocal)
- pp_string (buffer, "nonlocal ");
+ pp_string (pp, "nonlocal ");
if (pt->escaped)
- pp_string (buffer, "escaped ");
+ pp_string (pp, "escaped ");
if (pt->ipa_escaped)
- pp_string (buffer, "unit-escaped ");
+ pp_string (pp, "unit-escaped ");
if (pt->null)
- pp_string (buffer, "null ");
+ pp_string (pp, "null ");
if (pt->const_pool)
- pp_string (buffer, "const-pool ");
+ pp_string (pp, "const-pool ");
if (pt->vars
&& !bitmap_empty_p (pt->vars))
{
bitmap_iterator bi;
unsigned i;
- pp_string (buffer, "{ ");
+ pp_string (pp, "{ ");
EXECUTE_IF_SET_IN_BITMAP (pt->vars, 0, i, bi)
{
- pp_string (buffer, "D.");
- pp_decimal_int (buffer, i);
- pp_space (buffer);
+ pp_string (pp, "D.");
+ pp_decimal_int (pp, i);
+ pp_space (pp);
}
- pp_right_brace (buffer);
+ pp_right_brace (pp);
if (pt->vars_contains_nonlocal
|| pt->vars_contains_escaped
|| pt->vars_contains_escaped_heap
|| pt->vars_contains_interposable)
{
const char *comma = "";
- pp_string (buffer, " (");
+ pp_string (pp, " (");
if (pt->vars_contains_nonlocal)
{
- pp_string (buffer, "nonlocal");
+ pp_string (pp, "nonlocal");
comma = ", ";
}
if (pt->vars_contains_escaped)
{
- pp_string (buffer, comma);
- pp_string (buffer, "escaped");
+ pp_string (pp, comma);
+ pp_string (pp, "escaped");
comma = ", ";
}
if (pt->vars_contains_escaped_heap)
{
- pp_string (buffer, comma);
- pp_string (buffer, "escaped heap");
+ pp_string (pp, comma);
+ pp_string (pp, "escaped heap");
comma = ", ";
}
if (pt->vars_contains_restrict)
{
- pp_string (buffer, comma);
- pp_string (buffer, "restrict");
+ pp_string (pp, comma);
+ pp_string (pp, "restrict");
comma = ", ";
}
if (pt->vars_contains_interposable)
{
- pp_string (buffer, comma);
- pp_string (buffer, "interposable");
+ pp_string (pp, comma);
+ pp_string (pp, "interposable");
}
- pp_string (buffer, ")");
+ pp_string (pp, ")");
}
}
}
-/* Dump the call statement GS. BUFFER, SPC and FLAGS are as in
+/* Dump the call statement GS. PP, SPC and FLAGS are as in
pp_gimple_stmt_1. */
static void
-dump_gimple_call (pretty_printer *buffer, const gcall *gs, int spc,
+dump_gimple_call (pretty_printer *pp, const gcall *gs, int spc,
dump_flags_t flags)
{
tree lhs = gimple_call_lhs (gs);
pt = gimple_call_use_set (gs);
if (!pt_solution_empty_p (pt))
{
- pp_string (buffer, "# USE = ");
- pp_points_to_solution (buffer, pt);
- newline_and_indent (buffer, spc);
+ pp_string (pp, "# USE = ");
+ pp_points_to_solution (pp, pt);
+ newline_and_indent (pp, spc);
}
pt = gimple_call_clobber_set (gs);
if (!pt_solution_empty_p (pt))
{
- pp_string (buffer, "# CLB = ");
- pp_points_to_solution (buffer, pt);
- newline_and_indent (buffer, spc);
+ pp_string (pp, "# CLB = ");
+ pp_points_to_solution (pp, pt);
+ newline_and_indent (pp, spc);
}
}
if (flags & TDF_RAW)
{
if (gimple_call_internal_p (gs))
- dump_gimple_fmt (buffer, spc, flags, "%G <.%s, %T", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G <.%s, %T", gs,
internal_fn_name (gimple_call_internal_fn (gs)), lhs);
else
- dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T", gs, fn, lhs);
+ dump_gimple_fmt (pp, spc, flags, "%G <%T, %T", gs, fn, lhs);
if (gimple_call_num_args (gs) > 0)
{
- pp_string (buffer, ", ");
- dump_gimple_call_args (buffer, gs, flags);
+ pp_string (pp, ", ");
+ dump_gimple_call_args (pp, gs, flags);
}
- pp_greater (buffer);
+ pp_greater (pp);
}
else
{
if (lhs && !(flags & TDF_RHS_ONLY))
{
- dump_generic_node (buffer, lhs, spc, flags, false);
- pp_string (buffer, " =");
+ dump_generic_node (pp, lhs, spc, flags, false);
+ pp_string (pp, " =");
if (gimple_has_volatile_ops (gs))
- pp_string (buffer, "{v}");
+ pp_string (pp, "{v}");
- pp_space (buffer);
+ pp_space (pp);
}
if (gimple_call_internal_p (gs))
{
- pp_dot (buffer);
- pp_string (buffer, internal_fn_name (gimple_call_internal_fn (gs)));
+ pp_dot (pp);
+ pp_string (pp, internal_fn_name (gimple_call_internal_fn (gs)));
}
else
- print_call_name (buffer, fn, flags);
- pp_string (buffer, " (");
- dump_gimple_call_args (buffer, gs, flags);
- pp_right_paren (buffer);
+ print_call_name (pp, fn, flags);
+ pp_string (pp, " (");
+ dump_gimple_call_args (pp, gs, flags);
+ pp_right_paren (pp);
if (!(flags & TDF_RHS_ONLY))
- pp_semicolon (buffer);
+ pp_semicolon (pp);
}
if (gimple_call_chain (gs))
{
- pp_string (buffer, " [static-chain: ");
- dump_generic_node (buffer, gimple_call_chain (gs), spc, flags, false);
- pp_right_bracket (buffer);
+ pp_string (pp, " [static-chain: ");
+ dump_generic_node (pp, gimple_call_chain (gs), spc, flags, false);
+ pp_right_bracket (pp);
}
if (gimple_call_return_slot_opt_p (gs))
- pp_string (buffer, " [return slot optimization]");
+ pp_string (pp, " [return slot optimization]");
if (gimple_call_tail_p (gs))
- pp_string (buffer, " [tail call]");
+ pp_string (pp, " [tail call]");
if (gimple_call_must_tail_p (gs))
- pp_string (buffer, " [must tail call]");
+ pp_string (pp, " [must tail call]");
if (fn == NULL)
return;
if (TREE_CODE (fn) == ADDR_EXPR)
fn = TREE_OPERAND (fn, 0);
if (TREE_CODE (fn) == FUNCTION_DECL && decl_is_tm_clone (fn))
- pp_string (buffer, " [tm-clone]");
+ pp_string (pp, " [tm-clone]");
if (TREE_CODE (fn) == FUNCTION_DECL
&& fndecl_built_in_p (fn, BUILT_IN_TM_START)
&& gimple_call_num_args (gs) > 0)
unsigned HOST_WIDE_INT props;
gcc_assert (TREE_CODE (t) == INTEGER_CST);
- pp_string (buffer, " [ ");
+ pp_string (pp, " [ ");
/* Get the transaction code properties. */
props = TREE_INT_CST_LOW (t);
if (props & PR_INSTRUMENTEDCODE)
- pp_string (buffer, "instrumentedCode ");
+ pp_string (pp, "instrumentedCode ");
if (props & PR_UNINSTRUMENTEDCODE)
- pp_string (buffer, "uninstrumentedCode ");
+ pp_string (pp, "uninstrumentedCode ");
if (props & PR_HASNOXMMUPDATE)
- pp_string (buffer, "hasNoXMMUpdate ");
+ pp_string (pp, "hasNoXMMUpdate ");
if (props & PR_HASNOABORT)
- pp_string (buffer, "hasNoAbort ");
+ pp_string (pp, "hasNoAbort ");
if (props & PR_HASNOIRREVOCABLE)
- pp_string (buffer, "hasNoIrrevocable ");
+ pp_string (pp, "hasNoIrrevocable ");
if (props & PR_DOESGOIRREVOCABLE)
- pp_string (buffer, "doesGoIrrevocable ");
+ pp_string (pp, "doesGoIrrevocable ");
if (props & PR_HASNOSIMPLEREADS)
- pp_string (buffer, "hasNoSimpleReads ");
+ pp_string (pp, "hasNoSimpleReads ");
if (props & PR_AWBARRIERSOMITTED)
- pp_string (buffer, "awBarriersOmitted ");
+ pp_string (pp, "awBarriersOmitted ");
if (props & PR_RARBARRIERSOMITTED)
- pp_string (buffer, "RaRBarriersOmitted ");
+ pp_string (pp, "RaRBarriersOmitted ");
if (props & PR_UNDOLOGCODE)
- pp_string (buffer, "undoLogCode ");
+ pp_string (pp, "undoLogCode ");
if (props & PR_PREFERUNINSTRUMENTED)
- pp_string (buffer, "preferUninstrumented ");
+ pp_string (pp, "preferUninstrumented ");
if (props & PR_EXCEPTIONBLOCK)
- pp_string (buffer, "exceptionBlock ");
+ pp_string (pp, "exceptionBlock ");
if (props & PR_HASELSE)
- pp_string (buffer, "hasElse ");
+ pp_string (pp, "hasElse ");
if (props & PR_READONLY)
- pp_string (buffer, "readOnly ");
+ pp_string (pp, "readOnly ");
- pp_right_bracket (buffer);
+ pp_right_bracket (pp);
}
}
-/* Dump the switch statement GS. BUFFER, SPC and FLAGS are as in
+/* Dump the switch statement GS. PP, SPC and FLAGS are as in
pp_gimple_stmt_1. */
static void
-dump_gimple_switch (pretty_printer *buffer, const gswitch *gs, int spc,
+dump_gimple_switch (pretty_printer *pp, const gswitch *gs, int spc,
dump_flags_t flags)
{
unsigned int i;
GIMPLE_CHECK (gs, GIMPLE_SWITCH);
if (flags & TDF_RAW)
- dump_gimple_fmt (buffer, spc, flags, "%G <%T, ", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G <%T, ", gs,
gimple_switch_index (gs));
else
{
- pp_string (buffer, "switch (");
- dump_generic_node (buffer, gimple_switch_index (gs), spc, flags, true);
+ pp_string (pp, "switch (");
+ dump_generic_node (pp, gimple_switch_index (gs), spc, flags, true);
if (flags & TDF_GIMPLE)
- pp_string (buffer, ") {");
+ pp_string (pp, ") {");
else
- pp_string (buffer, ") <");
+ pp_string (pp, ") <");
}
for (i = 0; i < gimple_switch_num_labels (gs); i++)
{
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_space (buffer);
+ dump_generic_node (pp, case_label, spc, flags, false);
+ pp_space (pp);
tree label = CASE_LABEL (case_label);
- dump_generic_node (buffer, label, spc, flags, false);
+ dump_generic_node (pp, label, spc, flags, false);
if (cfun && cfun->cfg)
{
{
edge label_edge = find_edge (gimple_bb (gs), dest);
if (label_edge && !(flags & TDF_GIMPLE))
- dump_edge_probability (buffer, label_edge);
+ dump_edge_probability (pp, label_edge);
}
}
if (i < gimple_switch_num_labels (gs) - 1)
{
if (flags & TDF_GIMPLE)
- pp_string (buffer, "; ");
+ pp_string (pp, "; ");
else
- pp_string (buffer, ", ");
+ pp_string (pp, ", ");
}
}
if (flags & TDF_GIMPLE)
- pp_string (buffer, "; }");
+ pp_string (pp, "; }");
else
- pp_greater (buffer);
+ pp_greater (pp);
}
-/* Dump the gimple conditional GS. BUFFER, SPC and FLAGS are as in
+/* Dump the gimple conditional GS. PP, SPC and FLAGS are as in
pp_gimple_stmt_1. */
static void
-dump_gimple_cond (pretty_printer *buffer, const gcond *gs, int spc,
+dump_gimple_cond (pretty_printer *pp, const gcond *gs, int spc,
dump_flags_t flags)
{
if (flags & TDF_RAW)
- dump_gimple_fmt (buffer, spc, flags, "%G <%s, %T, %T, %T, %T>", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G <%s, %T, %T, %T, %T>", gs,
get_tree_code_name (gimple_cond_code (gs)),
gimple_cond_lhs (gs), gimple_cond_rhs (gs),
gimple_cond_true_label (gs), gimple_cond_false_label (gs));
else
{
if (!(flags & TDF_RHS_ONLY))
- pp_string (buffer, "if (");
- dump_generic_node (buffer, gimple_cond_lhs (gs), spc,
+ pp_string (pp, "if (");
+ dump_generic_node (pp, gimple_cond_lhs (gs), spc,
flags | ((flags & TDF_GIMPLE) ? TDF_GIMPLE_VAL : TDF_NONE),
false);
- pp_space (buffer);
- pp_string (buffer, op_symbol_code (gimple_cond_code (gs), flags));
- pp_space (buffer);
- dump_generic_node (buffer, gimple_cond_rhs (gs), spc,
+ pp_space (pp);
+ pp_string (pp, op_symbol_code (gimple_cond_code (gs), flags));
+ pp_space (pp);
+ dump_generic_node (pp, gimple_cond_rhs (gs), spc,
flags | ((flags & TDF_GIMPLE) ? TDF_GIMPLE_VAL : TDF_NONE),
false);
if (!(flags & TDF_RHS_ONLY))
bool has_edge_info = true_edge != NULL && false_edge != NULL;
- pp_right_paren (buffer);
+ pp_right_paren (pp);
if (gimple_cond_true_label (gs))
{
- pp_string (buffer, " goto ");
- dump_generic_node (buffer, gimple_cond_true_label (gs),
+ pp_string (pp, " goto ");
+ dump_generic_node (pp, gimple_cond_true_label (gs),
spc, flags, false);
if (has_edge_info && !(flags & TDF_GIMPLE))
- dump_edge_probability (buffer, true_edge);
- pp_semicolon (buffer);
+ dump_edge_probability (pp, true_edge);
+ pp_semicolon (pp);
}
if (gimple_cond_false_label (gs))
{
- pp_string (buffer, " else goto ");
- dump_generic_node (buffer, gimple_cond_false_label (gs),
+ pp_string (pp, " else goto ");
+ dump_generic_node (pp, gimple_cond_false_label (gs),
spc, flags, false);
if (has_edge_info && !(flags & TDF_GIMPLE))
- dump_edge_probability (buffer, false_edge);
+ dump_edge_probability (pp, false_edge);
- pp_semicolon (buffer);
+ pp_semicolon (pp);
}
}
}
}
-/* Dump a GIMPLE_LABEL tuple on the pretty_printer BUFFER, SPC
+/* Dump a GIMPLE_LABEL tuple on the pretty_printer PP, SPC
spaces of indent. FLAGS specifies details to show in the dump (see
TDF_* in dumpfils.h). */
static void
-dump_gimple_label (pretty_printer *buffer, const glabel *gs, int spc,
+dump_gimple_label (pretty_printer *pp, const glabel *gs, int spc,
dump_flags_t flags)
{
tree label = gimple_label_label (gs);
if (flags & TDF_RAW)
- dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, label);
+ dump_gimple_fmt (pp, spc, flags, "%G <%T>", gs, label);
else
{
- dump_generic_node (buffer, label, spc, flags, false);
- pp_colon (buffer);
+ dump_generic_node (pp, label, spc, flags, false);
+ pp_colon (pp);
}
if (flags & TDF_GIMPLE)
return;
if (DECL_NONLOCAL (label))
- pp_string (buffer, " [non-local]");
+ pp_string (pp, " [non-local]");
if ((flags & TDF_EH) && EH_LANDING_PAD_NR (label))
- pp_printf (buffer, " [LP %d]", EH_LANDING_PAD_NR (label));
+ pp_printf (pp, " [LP %d]", EH_LANDING_PAD_NR (label));
}
-/* Dump a GIMPLE_GOTO tuple on the pretty_printer BUFFER, SPC
+/* Dump a GIMPLE_GOTO tuple on the pretty_printer PP, SPC
spaces of indent. FLAGS specifies details to show in the dump (see
TDF_* in dumpfile.h). */
static void
-dump_gimple_goto (pretty_printer *buffer, const ggoto *gs, int spc,
+dump_gimple_goto (pretty_printer *pp, const ggoto *gs, int spc,
dump_flags_t flags)
{
tree label = gimple_goto_dest (gs);
if (flags & TDF_RAW)
- dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, label);
+ dump_gimple_fmt (pp, spc, flags, "%G <%T>", gs, label);
else
- dump_gimple_fmt (buffer, spc, flags, "goto %T;", label);
+ dump_gimple_fmt (pp, spc, flags, "goto %T;", label);
}
-/* Dump a GIMPLE_BIND tuple on the pretty_printer BUFFER, SPC
+/* Dump a GIMPLE_BIND tuple on the pretty_printer PP, SPC
spaces of indent. FLAGS specifies details to show in the dump (see
TDF_* in dumpfile.h). */
static void
-dump_gimple_bind (pretty_printer *buffer, const gbind *gs, int spc,
+dump_gimple_bind (pretty_printer *pp, const gbind *gs, int spc,
dump_flags_t flags)
{
if (flags & TDF_RAW)
- dump_gimple_fmt (buffer, spc, flags, "%G <", gs);
+ dump_gimple_fmt (pp, spc, flags, "%G <", gs);
else
- pp_left_brace (buffer);
+ pp_left_brace (pp);
if (!(flags & TDF_SLIM))
{
tree var;
for (var = gimple_bind_vars (gs); var; var = DECL_CHAIN (var))
{
- newline_and_indent (buffer, 2);
- print_declaration (buffer, var, spc, flags);
+ newline_and_indent (pp, 2);
+ print_declaration (pp, var, spc, flags);
}
if (gimple_bind_vars (gs))
- pp_newline (buffer);
+ pp_newline (pp);
}
- pp_newline (buffer);
- dump_gimple_seq (buffer, gimple_bind_body (gs), spc + 2, flags);
- newline_and_indent (buffer, spc);
+ pp_newline (pp);
+ dump_gimple_seq (pp, gimple_bind_body (gs), spc + 2, flags);
+ newline_and_indent (pp, spc);
if (flags & TDF_RAW)
- pp_greater (buffer);
+ pp_greater (pp);
else
- pp_right_brace (buffer);
+ pp_right_brace (pp);
}
-/* Dump a GIMPLE_TRY tuple on the pretty_printer BUFFER, SPC spaces of
+/* Dump a GIMPLE_TRY tuple on the pretty_printer PP, SPC spaces of
indent. FLAGS specifies details to show in the dump (see TDF_* in
dumpfile.h). */
static void
-dump_gimple_try (pretty_printer *buffer, const gtry *gs, int spc,
+dump_gimple_try (pretty_printer *pp, const gtry *gs, int spc,
dump_flags_t flags)
{
if (flags & TDF_RAW)
type = "GIMPLE_TRY_FINALLY";
else
type = "UNKNOWN GIMPLE_TRY";
- dump_gimple_fmt (buffer, spc, flags,
+ dump_gimple_fmt (pp, spc, flags,
"%G <%s,%+EVAL <%S>%nCLEANUP <%S>%->", gs, type,
gimple_try_eval (gs), gimple_try_cleanup (gs));
}
else
{
- pp_string (buffer, "try");
- newline_and_indent (buffer, spc + 2);
- pp_left_brace (buffer);
- pp_newline (buffer);
+ pp_string (pp, "try");
+ newline_and_indent (pp, spc + 2);
+ pp_left_brace (pp);
+ pp_newline (pp);
- dump_gimple_seq (buffer, gimple_try_eval (gs), spc + 4, flags);
- newline_and_indent (buffer, spc + 2);
- pp_right_brace (buffer);
+ dump_gimple_seq (pp, gimple_try_eval (gs), spc + 4, flags);
+ newline_and_indent (pp, spc + 2);
+ pp_right_brace (pp);
gimple_seq seq = gimple_try_cleanup (gs);
if (gimple_try_kind (gs) == GIMPLE_TRY_CATCH)
{
- newline_and_indent (buffer, spc);
- pp_string (buffer, "catch");
- newline_and_indent (buffer, spc + 2);
- pp_left_brace (buffer);
+ newline_and_indent (pp, spc);
+ pp_string (pp, "catch");
+ newline_and_indent (pp, spc + 2);
+ pp_left_brace (pp);
}
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_left_brace (buffer);
+ newline_and_indent (pp, spc);
+ pp_string (pp, "finally");
+ newline_and_indent (pp, spc + 2);
+ pp_left_brace (pp);
if (seq && is_a <geh_else *> (gimple_seq_first_stmt (seq))
&& gimple_seq_nondebug_singleton_p (seq))
{
geh_else *stmt = as_a <geh_else *> (gimple_seq_first_stmt (seq));
seq = gimple_eh_else_n_body (stmt);
- pp_newline (buffer);
- dump_gimple_seq (buffer, seq, spc + 4, flags);
- newline_and_indent (buffer, spc + 2);
- pp_right_brace (buffer);
+ pp_newline (pp);
+ dump_gimple_seq (pp, seq, spc + 4, flags);
+ newline_and_indent (pp, spc + 2);
+ pp_right_brace (pp);
seq = gimple_eh_else_e_body (stmt);
- newline_and_indent (buffer, spc);
- pp_string (buffer, "else");
- newline_and_indent (buffer, spc + 2);
- pp_left_brace (buffer);
+ newline_and_indent (pp, spc);
+ pp_string (pp, "else");
+ newline_and_indent (pp, spc + 2);
+ pp_left_brace (pp);
}
}
else
- pp_string (buffer, " <UNKNOWN GIMPLE_TRY> {");
+ pp_string (pp, " <UNKNOWN GIMPLE_TRY> {");
- pp_newline (buffer);
- dump_gimple_seq (buffer, seq, spc + 4, flags);
- newline_and_indent (buffer, spc + 2);
- pp_right_brace (buffer);
+ pp_newline (pp);
+ dump_gimple_seq (pp, seq, spc + 4, flags);
+ newline_and_indent (pp, spc + 2);
+ pp_right_brace (pp);
}
}
-/* Dump a GIMPLE_CATCH tuple on the pretty_printer BUFFER, SPC spaces of
+/* Dump a GIMPLE_CATCH tuple on the pretty_printer PP, SPC spaces of
indent. FLAGS specifies details to show in the dump (see TDF_* in
dumpfile.h). */
static void
-dump_gimple_catch (pretty_printer *buffer, const gcatch *gs, int spc,
+dump_gimple_catch (pretty_printer *pp, const gcatch *gs, int spc,
dump_flags_t flags)
{
if (flags & TDF_RAW)
- dump_gimple_fmt (buffer, spc, flags, "%G <%T, %+CATCH <%S>%->", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G <%T, %+CATCH <%S>%->", gs,
gimple_catch_types (gs), gimple_catch_handler (gs));
else
- dump_gimple_fmt (buffer, spc, flags, "catch (%T)%+{%S}",
+ dump_gimple_fmt (pp, spc, flags, "catch (%T)%+{%S}",
gimple_catch_types (gs), gimple_catch_handler (gs));
}
-/* Dump a GIMPLE_EH_FILTER tuple on the pretty_printer BUFFER, SPC spaces of
+/* Dump a GIMPLE_EH_FILTER tuple on the pretty_printer PP, SPC spaces of
indent. FLAGS specifies details to show in the dump (see TDF_* in
dumpfile.h). */
static void
-dump_gimple_eh_filter (pretty_printer *buffer, const geh_filter *gs, int spc,
+dump_gimple_eh_filter (pretty_printer *pp, const geh_filter *gs, int spc,
dump_flags_t flags)
{
if (flags & TDF_RAW)
- dump_gimple_fmt (buffer, spc, flags, "%G <%T, %+FAILURE <%S>%->", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G <%T, %+FAILURE <%S>%->", gs,
gimple_eh_filter_types (gs),
gimple_eh_filter_failure (gs));
else
- dump_gimple_fmt (buffer, spc, flags, "<<<eh_filter (%T)>>>%+{%+%S%-}",
+ dump_gimple_fmt (pp, spc, flags, "<<<eh_filter (%T)>>>%+{%+%S%-}",
gimple_eh_filter_types (gs),
gimple_eh_filter_failure (gs));
}
/* Dump a GIMPLE_EH_MUST_NOT_THROW tuple. */
static void
-dump_gimple_eh_must_not_throw (pretty_printer *buffer,
+dump_gimple_eh_must_not_throw (pretty_printer *pp,
const geh_mnt *gs, int spc, dump_flags_t flags)
{
if (flags & TDF_RAW)
- dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G <%T>", gs,
gimple_eh_must_not_throw_fndecl (gs));
else
- dump_gimple_fmt (buffer, spc, flags, "<<<eh_must_not_throw (%T)>>>",
+ dump_gimple_fmt (pp, spc, flags, "<<<eh_must_not_throw (%T)>>>",
gimple_eh_must_not_throw_fndecl (gs));
}
-/* Dump a GIMPLE_EH_ELSE tuple on the pretty_printer BUFFER, SPC spaces of
+/* Dump a GIMPLE_EH_ELSE tuple on the pretty_printer PP, SPC spaces of
indent. FLAGS specifies details to show in the dump (see TDF_* in
dumpfile.h). */
static void
-dump_gimple_eh_else (pretty_printer *buffer, const geh_else *gs, int spc,
+dump_gimple_eh_else (pretty_printer *pp, const geh_else *gs, int spc,
dump_flags_t flags)
{
if (flags & TDF_RAW)
- dump_gimple_fmt (buffer, spc, flags,
+ dump_gimple_fmt (pp, spc, flags,
"%G <%+N_BODY <%S>%nE_BODY <%S>%->", gs,
gimple_eh_else_n_body (gs), gimple_eh_else_e_body (gs));
else
- dump_gimple_fmt (buffer, spc, flags,
+ dump_gimple_fmt (pp, spc, flags,
"<<<if_normal_exit>>>%+{%S}%-<<<else_eh_exit>>>%+{%S}",
gimple_eh_else_n_body (gs), gimple_eh_else_e_body (gs));
}
-/* Dump a GIMPLE_RESX tuple on the pretty_printer BUFFER, SPC spaces of
+/* Dump a GIMPLE_RESX tuple on the pretty_printer PP, SPC spaces of
indent. FLAGS specifies details to show in the dump (see TDF_* in
dumpfile.h). */
static void
-dump_gimple_resx (pretty_printer *buffer, const gresx *gs, int spc,
+dump_gimple_resx (pretty_printer *pp, const gresx *gs, int spc,
dump_flags_t flags)
{
if (flags & TDF_RAW)
- dump_gimple_fmt (buffer, spc, flags, "%G <%d>", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G <%d>", gs,
gimple_resx_region (gs));
else
- dump_gimple_fmt (buffer, spc, flags, "resx %d", gimple_resx_region (gs));
+ dump_gimple_fmt (pp, spc, flags, "resx %d", gimple_resx_region (gs));
}
-/* Dump a GIMPLE_EH_DISPATCH tuple on the pretty_printer BUFFER. */
+/* Dump a GIMPLE_EH_DISPATCH tuple on the pretty_printer PP. */
static void
-dump_gimple_eh_dispatch (pretty_printer *buffer, const geh_dispatch *gs,
+dump_gimple_eh_dispatch (pretty_printer *pp, const geh_dispatch *gs,
int spc, dump_flags_t flags)
{
if (flags & TDF_RAW)
- dump_gimple_fmt (buffer, spc, flags, "%G <%d>", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G <%d>", gs,
gimple_eh_dispatch_region (gs));
else
- dump_gimple_fmt (buffer, spc, flags, "eh_dispatch %d",
+ dump_gimple_fmt (pp, spc, flags, "eh_dispatch %d",
gimple_eh_dispatch_region (gs));
}
-/* Dump a GIMPLE_DEBUG tuple on the pretty_printer BUFFER, SPC spaces
+/* Dump a GIMPLE_DEBUG tuple on the pretty_printer PP, SPC spaces
of indent. FLAGS specifies details to show in the dump (see TDF_*
in dumpfile.h). */
static void
-dump_gimple_debug (pretty_printer *buffer, const gdebug *gs, int spc,
+dump_gimple_debug (pretty_printer *pp, const gdebug *gs, int spc,
dump_flags_t flags)
{
switch (gs->subcode)
{
case GIMPLE_DEBUG_BIND:
if (flags & TDF_RAW)
- dump_gimple_fmt (buffer, spc, flags, "%G BIND <%T, %T>", gs,
+ dump_gimple_fmt (pp, 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",
+ dump_gimple_fmt (pp, spc, flags, "# DEBUG %T => %T",
gimple_debug_bind_get_var (gs),
gimple_debug_bind_get_value (gs));
break;
case GIMPLE_DEBUG_SOURCE_BIND:
if (flags & TDF_RAW)
- dump_gimple_fmt (buffer, spc, flags, "%G SRCBIND <%T, %T>", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G SRCBIND <%T, %T>", gs,
gimple_debug_source_bind_get_var (gs),
gimple_debug_source_bind_get_value (gs));
else
- dump_gimple_fmt (buffer, spc, flags, "# DEBUG %T s=> %T",
+ dump_gimple_fmt (pp, spc, flags, "# DEBUG %T s=> %T",
gimple_debug_source_bind_get_var (gs),
gimple_debug_source_bind_get_value (gs));
break;
case GIMPLE_DEBUG_BEGIN_STMT:
if (flags & TDF_RAW)
- dump_gimple_fmt (buffer, spc, flags, "%G BEGIN_STMT", gs);
+ dump_gimple_fmt (pp, spc, flags, "%G BEGIN_STMT", gs);
else
- dump_gimple_fmt (buffer, spc, flags, "# DEBUG BEGIN_STMT");
+ dump_gimple_fmt (pp, spc, flags, "# DEBUG BEGIN_STMT");
break;
case GIMPLE_DEBUG_INLINE_ENTRY:
if (flags & TDF_RAW)
- dump_gimple_fmt (buffer, spc, flags, "%G INLINE_ENTRY %T", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G INLINE_ENTRY %T", gs,
gimple_block (gs)
? block_ultimate_origin (gimple_block (gs))
: NULL_TREE);
else
- dump_gimple_fmt (buffer, spc, flags, "# DEBUG INLINE_ENTRY %T",
+ dump_gimple_fmt (pp, spc, flags, "# DEBUG INLINE_ENTRY %T",
gimple_block (gs)
? block_ultimate_origin (gimple_block (gs))
: NULL_TREE);
}
}
-/* Dump a GIMPLE_OMP_FOR tuple on the pretty_printer BUFFER. */
+/* Dump a GIMPLE_OMP_FOR tuple on the pretty_printer PP. */
static void
-dump_gimple_omp_for (pretty_printer *buffer, const gomp_for *gs, int spc,
+dump_gimple_omp_for (pretty_printer *pp, const gomp_for *gs, int spc,
dump_flags_t flags)
{
size_t i;
default:
gcc_unreachable ();
}
- dump_gimple_fmt (buffer, spc, flags, "%G%s <%+BODY <%S>%nCLAUSES <", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G%s <%+BODY <%S>%nCLAUSES <", gs,
kind, gimple_omp_body (gs));
- dump_omp_clauses (buffer, gimple_omp_for_clauses (gs), spc, flags);
- dump_gimple_fmt (buffer, spc, flags, " >,");
+ dump_omp_clauses (pp, gimple_omp_for_clauses (gs), spc, flags);
+ dump_gimple_fmt (pp, spc, flags, " >,");
for (i = 0; i < gimple_omp_for_collapse (gs); i++)
- dump_gimple_fmt (buffer, spc, flags,
+ dump_gimple_fmt (pp, spc, flags,
"%+%T, %T, %T, %s, %T,%n",
gimple_omp_for_index (gs, i),
gimple_omp_for_initial (gs, i),
gimple_omp_for_final (gs, i),
get_tree_code_name (gimple_omp_for_cond (gs, i)),
gimple_omp_for_incr (gs, i));
- dump_gimple_fmt (buffer, spc, flags, "PRE_BODY <%S>%->",
+ dump_gimple_fmt (pp, spc, flags, "PRE_BODY <%S>%->",
gimple_omp_for_pre_body (gs));
}
else
switch (gimple_omp_for_kind (gs))
{
case GF_OMP_FOR_KIND_FOR:
- pp_string (buffer, "#pragma omp for");
+ pp_string (pp, "#pragma omp for");
break;
case GF_OMP_FOR_KIND_DISTRIBUTE:
- pp_string (buffer, "#pragma omp distribute");
+ pp_string (pp, "#pragma omp distribute");
break;
case GF_OMP_FOR_KIND_TASKLOOP:
- pp_string (buffer, "#pragma omp taskloop");
+ pp_string (pp, "#pragma omp taskloop");
break;
case GF_OMP_FOR_KIND_OACC_LOOP:
- pp_string (buffer, "#pragma acc loop");
+ pp_string (pp, "#pragma acc loop");
break;
case GF_OMP_FOR_KIND_SIMD:
- pp_string (buffer, "#pragma omp simd");
+ pp_string (pp, "#pragma omp simd");
break;
default:
gcc_unreachable ();
}
- dump_omp_clauses (buffer, gimple_omp_for_clauses (gs), spc, flags);
+ dump_omp_clauses (pp, gimple_omp_for_clauses (gs), spc, flags);
for (i = 0; i < gimple_omp_for_collapse (gs); i++)
{
if (i)
spc += 2;
- newline_and_indent (buffer, spc);
- pp_string (buffer, "for (");
- dump_generic_node (buffer, gimple_omp_for_index (gs, i), spc,
+ newline_and_indent (pp, spc);
+ pp_string (pp, "for (");
+ dump_generic_node (pp, gimple_omp_for_index (gs, i), spc,
flags, false);
- pp_string (buffer, " = ");
+ pp_string (pp, " = ");
tree init = gimple_omp_for_initial (gs, i);
if (TREE_CODE (init) != TREE_VEC)
- dump_generic_node (buffer, init, spc, flags, false);
+ dump_generic_node (pp, init, spc, flags, false);
else
- dump_omp_loop_non_rect_expr (buffer, init, spc, flags);
- pp_string (buffer, "; ");
+ dump_omp_loop_non_rect_expr (pp, init, spc, flags);
+ pp_string (pp, "; ");
- dump_generic_node (buffer, gimple_omp_for_index (gs, i), spc,
+ dump_generic_node (pp, gimple_omp_for_index (gs, i), spc,
flags, false);
- pp_space (buffer);
+ pp_space (pp);
switch (gimple_omp_for_cond (gs, i))
{
case LT_EXPR:
- pp_less (buffer);
+ pp_less (pp);
break;
case GT_EXPR:
- pp_greater (buffer);
+ pp_greater (pp);
break;
case LE_EXPR:
- pp_less_equal (buffer);
+ pp_less_equal (pp);
break;
case GE_EXPR:
- pp_greater_equal (buffer);
+ pp_greater_equal (pp);
break;
case NE_EXPR:
- pp_string (buffer, "!=");
+ pp_string (pp, "!=");
break;
default:
gcc_unreachable ();
}
- pp_space (buffer);
+ pp_space (pp);
tree cond = gimple_omp_for_final (gs, i);
if (TREE_CODE (cond) != TREE_VEC)
- dump_generic_node (buffer, cond, spc, flags, false);
+ dump_generic_node (pp, cond, spc, flags, false);
else
- dump_omp_loop_non_rect_expr (buffer, cond, spc, flags);
- pp_string (buffer, "; ");
+ dump_omp_loop_non_rect_expr (pp, cond, spc, flags);
+ pp_string (pp, "; ");
- dump_generic_node (buffer, gimple_omp_for_index (gs, i), spc,
+ dump_generic_node (pp, gimple_omp_for_index (gs, i), spc,
flags, false);
- pp_string (buffer, " = ");
- dump_generic_node (buffer, gimple_omp_for_incr (gs, i), spc,
+ pp_string (pp, " = ");
+ dump_generic_node (pp, gimple_omp_for_incr (gs, i), spc,
flags, false);
- pp_right_paren (buffer);
+ pp_right_paren (pp);
}
if (!gimple_seq_empty_p (gimple_omp_body (gs)))
{
- newline_and_indent (buffer, spc + 2);
- 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_right_brace (buffer);
+ newline_and_indent (pp, spc + 2);
+ pp_left_brace (pp);
+ pp_newline (pp);
+ dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags);
+ newline_and_indent (pp, spc + 2);
+ pp_right_brace (pp);
}
}
}
-/* Dump a GIMPLE_OMP_CONTINUE tuple on the pretty_printer BUFFER. */
+/* Dump a GIMPLE_OMP_CONTINUE tuple on the pretty_printer PP. */
static void
-dump_gimple_omp_continue (pretty_printer *buffer, const gomp_continue *gs,
+dump_gimple_omp_continue (pretty_printer *pp, const gomp_continue *gs,
int spc, dump_flags_t flags)
{
if (flags & TDF_RAW)
{
- dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T>", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G <%T, %T>", gs,
gimple_omp_continue_control_def (gs),
gimple_omp_continue_control_use (gs));
}
else
{
- pp_string (buffer, "#pragma omp continue (");
- dump_generic_node (buffer, gimple_omp_continue_control_def (gs),
+ pp_string (pp, "#pragma omp continue (");
+ dump_generic_node (pp, gimple_omp_continue_control_def (gs),
spc, flags, false);
- pp_comma (buffer);
- pp_space (buffer);
- dump_generic_node (buffer, gimple_omp_continue_control_use (gs),
+ pp_comma (pp);
+ pp_space (pp);
+ dump_generic_node (pp, gimple_omp_continue_control_use (gs),
spc, flags, false);
- pp_right_paren (buffer);
+ pp_right_paren (pp);
}
}
-/* Dump a GIMPLE_OMP_SINGLE tuple on the pretty_printer BUFFER. */
+/* Dump a GIMPLE_OMP_SINGLE tuple on the pretty_printer PP. */
static void
-dump_gimple_omp_single (pretty_printer *buffer, const gomp_single *gs,
+dump_gimple_omp_single (pretty_printer *pp, const gomp_single *gs,
int spc, dump_flags_t flags)
{
if (flags & TDF_RAW)
{
- dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
gimple_omp_body (gs));
- dump_omp_clauses (buffer, gimple_omp_single_clauses (gs), spc, flags);
- dump_gimple_fmt (buffer, spc, flags, " >");
+ dump_omp_clauses (pp, gimple_omp_single_clauses (gs), spc, flags);
+ dump_gimple_fmt (pp, spc, flags, " >");
}
else
{
- pp_string (buffer, "#pragma omp single");
- dump_omp_clauses (buffer, gimple_omp_single_clauses (gs), spc, flags);
+ pp_string (pp, "#pragma omp single");
+ dump_omp_clauses (pp, gimple_omp_single_clauses (gs), spc, flags);
if (!gimple_seq_empty_p (gimple_omp_body (gs)))
{
- newline_and_indent (buffer, spc + 2);
- 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_right_brace (buffer);
+ newline_and_indent (pp, spc + 2);
+ pp_left_brace (pp);
+ pp_newline (pp);
+ dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags);
+ newline_and_indent (pp, spc + 2);
+ pp_right_brace (pp);
}
}
}
-/* Dump a GIMPLE_OMP_TASKGROUP tuple on the pretty_printer BUFFER. */
+/* Dump a GIMPLE_OMP_TASKGROUP tuple on the pretty_printer PP. */
static void
-dump_gimple_omp_taskgroup (pretty_printer *buffer, const gimple *gs,
+dump_gimple_omp_taskgroup (pretty_printer *pp, const gimple *gs,
int spc, dump_flags_t flags)
{
if (flags & TDF_RAW)
{
- dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
gimple_omp_body (gs));
- dump_omp_clauses (buffer, gimple_omp_taskgroup_clauses (gs), spc, flags);
- dump_gimple_fmt (buffer, spc, flags, " >");
+ dump_omp_clauses (pp, gimple_omp_taskgroup_clauses (gs), spc, flags);
+ dump_gimple_fmt (pp, spc, flags, " >");
}
else
{
- pp_string (buffer, "#pragma omp taskgroup");
- dump_omp_clauses (buffer, gimple_omp_taskgroup_clauses (gs), spc, flags);
+ pp_string (pp, "#pragma omp taskgroup");
+ dump_omp_clauses (pp, gimple_omp_taskgroup_clauses (gs), spc, flags);
if (!gimple_seq_empty_p (gimple_omp_body (gs)))
{
- newline_and_indent (buffer, spc + 2);
- 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_right_brace (buffer);
+ newline_and_indent (pp, spc + 2);
+ pp_left_brace (pp);
+ pp_newline (pp);
+ dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags);
+ newline_and_indent (pp, spc + 2);
+ pp_right_brace (pp);
}
}
}
-/* Dump a GIMPLE_OMP_MASKED tuple on the pretty_printer BUFFER. */
+/* Dump a GIMPLE_OMP_MASKED tuple on the pretty_printer PP. */
static void
-dump_gimple_omp_masked (pretty_printer *buffer, const gimple *gs,
+dump_gimple_omp_masked (pretty_printer *pp, const gimple *gs,
int spc, dump_flags_t flags)
{
if (flags & TDF_RAW)
{
- dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
gimple_omp_body (gs));
- dump_omp_clauses (buffer, gimple_omp_masked_clauses (gs), spc, flags);
- dump_gimple_fmt (buffer, spc, flags, " >");
+ dump_omp_clauses (pp, gimple_omp_masked_clauses (gs), spc, flags);
+ dump_gimple_fmt (pp, spc, flags, " >");
}
else
{
- pp_string (buffer, "#pragma omp masked");
- dump_omp_clauses (buffer, gimple_omp_masked_clauses (gs), spc, flags);
+ pp_string (pp, "#pragma omp masked");
+ dump_omp_clauses (pp, gimple_omp_masked_clauses (gs), spc, flags);
if (!gimple_seq_empty_p (gimple_omp_body (gs)))
{
- newline_and_indent (buffer, spc + 2);
- 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_right_brace (buffer);
+ newline_and_indent (pp, spc + 2);
+ pp_left_brace (pp);
+ pp_newline (pp);
+ dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags);
+ newline_and_indent (pp, spc + 2);
+ pp_right_brace (pp);
}
}
}
-/* Dump a GIMPLE_OMP_SCOPE tuple on the pretty_printer BUFFER. */
+/* Dump a GIMPLE_OMP_SCOPE tuple on the pretty_printer PP. */
static void
-dump_gimple_omp_scope (pretty_printer *buffer, const gimple *gs,
+dump_gimple_omp_scope (pretty_printer *pp, const gimple *gs,
int spc, dump_flags_t flags)
{
if (flags & TDF_RAW)
{
- dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
gimple_omp_body (gs));
- dump_omp_clauses (buffer, gimple_omp_scope_clauses (gs), spc, flags);
- dump_gimple_fmt (buffer, spc, flags, " >");
+ dump_omp_clauses (pp, gimple_omp_scope_clauses (gs), spc, flags);
+ dump_gimple_fmt (pp, spc, flags, " >");
}
else
{
- pp_string (buffer, "#pragma omp scope");
- dump_omp_clauses (buffer, gimple_omp_scope_clauses (gs), spc, flags);
+ pp_string (pp, "#pragma omp scope");
+ dump_omp_clauses (pp, gimple_omp_scope_clauses (gs), spc, flags);
if (!gimple_seq_empty_p (gimple_omp_body (gs)))
{
- newline_and_indent (buffer, spc + 2);
- 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_right_brace (buffer);
+ newline_and_indent (pp, spc + 2);
+ pp_left_brace (pp);
+ pp_newline (pp);
+ dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags);
+ newline_and_indent (pp, spc + 2);
+ pp_right_brace (pp);
}
}
}
-/* Dump a GIMPLE_OMP_TARGET tuple on the pretty_printer BUFFER. */
+/* Dump a GIMPLE_OMP_TARGET tuple on the pretty_printer PP. */
static void
-dump_gimple_omp_target (pretty_printer *buffer, const gomp_target *gs,
+dump_gimple_omp_target (pretty_printer *pp, const gomp_target *gs,
int spc, dump_flags_t flags)
{
const char *kind;
}
if (flags & TDF_RAW)
{
- dump_gimple_fmt (buffer, spc, flags, "%G%s <%+BODY <%S>%nCLAUSES <", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G%s <%+BODY <%S>%nCLAUSES <", gs,
kind, gimple_omp_body (gs));
- dump_omp_clauses (buffer, gimple_omp_target_clauses (gs), spc, flags);
- dump_gimple_fmt (buffer, spc, flags, " >, %T, %T%n>",
+ dump_omp_clauses (pp, gimple_omp_target_clauses (gs), spc, flags);
+ dump_gimple_fmt (pp, spc, flags, " >, %T, %T%n>",
gimple_omp_target_child_fn (gs),
gimple_omp_target_data_arg (gs));
}
else
{
- pp_string (buffer, "#pragma omp target");
- pp_string (buffer, kind);
- dump_omp_clauses (buffer, gimple_omp_target_clauses (gs), spc, flags);
+ pp_string (pp, "#pragma omp target");
+ pp_string (pp, kind);
+ dump_omp_clauses (pp, gimple_omp_target_clauses (gs), spc, flags);
if (gimple_omp_target_child_fn (gs))
{
- pp_string (buffer, " [child fn: ");
- dump_generic_node (buffer, gimple_omp_target_child_fn (gs),
+ pp_string (pp, " [child fn: ");
+ dump_generic_node (pp, gimple_omp_target_child_fn (gs),
spc, flags, false);
- pp_string (buffer, " (");
+ pp_string (pp, " (");
if (gimple_omp_target_data_arg (gs))
- dump_generic_node (buffer, gimple_omp_target_data_arg (gs),
+ dump_generic_node (pp, gimple_omp_target_data_arg (gs),
spc, flags, false);
else
- pp_string (buffer, "???");
- pp_string (buffer, ")]");
+ pp_string (pp, "???");
+ pp_string (pp, ")]");
}
gimple_seq body = gimple_omp_body (gs);
if (body && gimple_code (gimple_seq_first_stmt (body)) != GIMPLE_BIND)
{
- newline_and_indent (buffer, spc + 2);
- pp_left_brace (buffer);
- pp_newline (buffer);
- dump_gimple_seq (buffer, body, spc + 4, flags);
- newline_and_indent (buffer, spc + 2);
- pp_right_brace (buffer);
+ newline_and_indent (pp, spc + 2);
+ pp_left_brace (pp);
+ pp_newline (pp);
+ dump_gimple_seq (pp, body, spc + 4, flags);
+ newline_and_indent (pp, spc + 2);
+ pp_right_brace (pp);
}
else if (body)
{
- pp_newline (buffer);
- dump_gimple_seq (buffer, body, spc + 2, flags);
+ pp_newline (pp);
+ dump_gimple_seq (pp, body, spc + 2, flags);
}
}
}
-/* Dump a GIMPLE_OMP_TEAMS tuple on the pretty_printer BUFFER. */
+/* Dump a GIMPLE_OMP_TEAMS tuple on the pretty_printer PP. */
static void
-dump_gimple_omp_teams (pretty_printer *buffer, const gomp_teams *gs, int spc,
+dump_gimple_omp_teams (pretty_printer *pp, const gomp_teams *gs, int spc,
dump_flags_t flags)
{
if (flags & TDF_RAW)
{
- dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
gimple_omp_body (gs));
- dump_omp_clauses (buffer, gimple_omp_teams_clauses (gs), spc, flags);
- dump_gimple_fmt (buffer, spc, flags, " >");
+ dump_omp_clauses (pp, gimple_omp_teams_clauses (gs), spc, flags);
+ dump_gimple_fmt (pp, spc, flags, " >");
}
else
{
- pp_string (buffer, "#pragma omp teams");
- dump_omp_clauses (buffer, gimple_omp_teams_clauses (gs), spc, flags);
+ pp_string (pp, "#pragma omp teams");
+ dump_omp_clauses (pp, gimple_omp_teams_clauses (gs), spc, flags);
if (!gimple_seq_empty_p (gimple_omp_body (gs)))
{
- newline_and_indent (buffer, spc + 2);
- pp_character (buffer, '{');
- pp_newline (buffer);
- dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
- newline_and_indent (buffer, spc + 2);
- pp_character (buffer, '}');
+ newline_and_indent (pp, spc + 2);
+ pp_character (pp, '{');
+ pp_newline (pp);
+ dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags);
+ newline_and_indent (pp, spc + 2);
+ pp_character (pp, '}');
}
}
}
-/* Dump a GIMPLE_OMP_SECTIONS tuple on the pretty_printer BUFFER. */
+/* Dump a GIMPLE_OMP_SECTIONS tuple on the pretty_printer PP. */
static void
-dump_gimple_omp_sections (pretty_printer *buffer, const gomp_sections *gs,
+dump_gimple_omp_sections (pretty_printer *pp, const gomp_sections *gs,
int spc, dump_flags_t flags)
{
if (flags & TDF_RAW)
{
- dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
gimple_omp_body (gs));
- dump_omp_clauses (buffer, gimple_omp_sections_clauses (gs), spc, flags);
- dump_gimple_fmt (buffer, spc, flags, " >");
+ dump_omp_clauses (pp, gimple_omp_sections_clauses (gs), spc, flags);
+ dump_gimple_fmt (pp, spc, flags, " >");
}
else
{
- pp_string (buffer, "#pragma omp sections");
+ pp_string (pp, "#pragma omp sections");
if (gimple_omp_sections_control (gs))
{
- pp_string (buffer, " <");
- dump_generic_node (buffer, gimple_omp_sections_control (gs), spc,
+ pp_string (pp, " <");
+ dump_generic_node (pp, gimple_omp_sections_control (gs), spc,
flags, false);
- pp_greater (buffer);
+ pp_greater (pp);
}
- dump_omp_clauses (buffer, gimple_omp_sections_clauses (gs), spc, flags);
+ dump_omp_clauses (pp, gimple_omp_sections_clauses (gs), spc, flags);
if (!gimple_seq_empty_p (gimple_omp_body (gs)))
{
- newline_and_indent (buffer, spc + 2);
- 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_right_brace (buffer);
+ newline_and_indent (pp, spc + 2);
+ pp_left_brace (pp);
+ pp_newline (pp);
+ dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags);
+ newline_and_indent (pp, spc + 2);
+ pp_right_brace (pp);
}
}
}
/* Dump a GIMPLE_OMP_{MASTER,ORDERED,SECTION,STRUCTURED_BLOCK} tuple on the
- pretty_printer BUFFER. */
+ pretty_printer PP. */
static void
-dump_gimple_omp_block (pretty_printer *buffer, const gimple *gs, int spc,
+dump_gimple_omp_block (pretty_printer *pp, const gimple *gs, int spc,
dump_flags_t flags)
{
if (flags & TDF_RAW)
- dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S> >", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S> >", gs,
gimple_omp_body (gs));
else
{
switch (gimple_code (gs))
{
case GIMPLE_OMP_MASTER:
- pp_string (buffer, "#pragma omp master");
+ pp_string (pp, "#pragma omp master");
break;
case GIMPLE_OMP_SECTION:
- pp_string (buffer, "#pragma omp section");
+ pp_string (pp, "#pragma omp section");
break;
case GIMPLE_OMP_STRUCTURED_BLOCK:
- pp_string (buffer, "#pragma omp __structured_block");
+ pp_string (pp, "#pragma omp __structured_block");
break;
default:
gcc_unreachable ();
}
if (!gimple_seq_empty_p (gimple_omp_body (gs)))
{
- newline_and_indent (buffer, spc + 2);
- 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_right_brace (buffer);
+ newline_and_indent (pp, spc + 2);
+ pp_left_brace (pp);
+ pp_newline (pp);
+ dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags);
+ newline_and_indent (pp, spc + 2);
+ pp_right_brace (pp);
}
}
}
-/* Dump a GIMPLE_OMP_CRITICAL tuple on the pretty_printer BUFFER. */
+/* Dump a GIMPLE_OMP_CRITICAL tuple on the pretty_printer PP. */
static void
-dump_gimple_omp_critical (pretty_printer *buffer, const gomp_critical *gs,
+dump_gimple_omp_critical (pretty_printer *pp, const gomp_critical *gs,
int spc, dump_flags_t flags)
{
if (flags & TDF_RAW)
- dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S> >", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S> >", gs,
gimple_omp_body (gs));
else
{
- pp_string (buffer, "#pragma omp critical");
+ pp_string (pp, "#pragma omp critical");
if (gimple_omp_critical_name (gs))
{
- pp_string (buffer, " (");
- dump_generic_node (buffer, gimple_omp_critical_name (gs), spc,
+ pp_string (pp, " (");
+ dump_generic_node (pp, gimple_omp_critical_name (gs), spc,
flags, false);
- pp_right_paren (buffer);
+ pp_right_paren (pp);
}
- dump_omp_clauses (buffer, gimple_omp_critical_clauses (gs), spc, flags);
+ dump_omp_clauses (pp, gimple_omp_critical_clauses (gs), spc, flags);
if (!gimple_seq_empty_p (gimple_omp_body (gs)))
{
- newline_and_indent (buffer, spc + 2);
- 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_right_brace (buffer);
+ newline_and_indent (pp, spc + 2);
+ pp_left_brace (pp);
+ pp_newline (pp);
+ dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags);
+ newline_and_indent (pp, spc + 2);
+ pp_right_brace (pp);
}
}
}
-/* Dump a GIMPLE_OMP_ORDERED tuple on the pretty_printer BUFFER. */
+/* Dump a GIMPLE_OMP_ORDERED tuple on the pretty_printer PP. */
static void
-dump_gimple_omp_ordered (pretty_printer *buffer, const gomp_ordered *gs,
+dump_gimple_omp_ordered (pretty_printer *pp, const gomp_ordered *gs,
int spc, dump_flags_t flags)
{
if (flags & TDF_RAW)
- dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S> >", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S> >", gs,
gimple_omp_body (gs));
else
{
- pp_string (buffer, "#pragma omp ordered");
- dump_omp_clauses (buffer, gimple_omp_ordered_clauses (gs), spc, flags);
+ pp_string (pp, "#pragma omp ordered");
+ dump_omp_clauses (pp, gimple_omp_ordered_clauses (gs), spc, flags);
if (!gimple_seq_empty_p (gimple_omp_body (gs)))
{
- newline_and_indent (buffer, spc + 2);
- 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_right_brace (buffer);
+ newline_and_indent (pp, spc + 2);
+ pp_left_brace (pp);
+ pp_newline (pp);
+ dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags);
+ newline_and_indent (pp, spc + 2);
+ pp_right_brace (pp);
}
}
}
-/* Dump a GIMPLE_OMP_SCAN tuple on the pretty_printer BUFFER. */
+/* Dump a GIMPLE_OMP_SCAN tuple on the pretty_printer PP. */
static void
-dump_gimple_omp_scan (pretty_printer *buffer, const gomp_scan *gs,
+dump_gimple_omp_scan (pretty_printer *pp, const gomp_scan *gs,
int spc, dump_flags_t flags)
{
if (flags & TDF_RAW)
- dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S> >", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S> >", gs,
gimple_omp_body (gs));
else
{
if (gimple_omp_scan_clauses (gs))
{
- pp_string (buffer, "#pragma omp scan");
- dump_omp_clauses (buffer, gimple_omp_scan_clauses (gs), spc, flags);
+ pp_string (pp, "#pragma omp scan");
+ dump_omp_clauses (pp, gimple_omp_scan_clauses (gs), spc, flags);
}
if (!gimple_seq_empty_p (gimple_omp_body (gs)))
{
- newline_and_indent (buffer, spc + 2);
- 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_right_brace (buffer);
+ newline_and_indent (pp, spc + 2);
+ pp_left_brace (pp);
+ pp_newline (pp);
+ dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags);
+ newline_and_indent (pp, spc + 2);
+ pp_right_brace (pp);
}
}
}
-/* Dump a GIMPLE_OMP_RETURN tuple on the pretty_printer BUFFER. */
+/* Dump a GIMPLE_OMP_RETURN tuple on the pretty_printer PP. */
static void
-dump_gimple_omp_return (pretty_printer *buffer, const gimple *gs, int spc,
+dump_gimple_omp_return (pretty_printer *pp, const gimple *gs, int spc,
dump_flags_t flags)
{
if (flags & TDF_RAW)
{
- dump_gimple_fmt (buffer, spc, flags, "%G <nowait=%d", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G <nowait=%d", gs,
(int) gimple_omp_return_nowait_p (gs));
if (gimple_omp_return_lhs (gs))
- dump_gimple_fmt (buffer, spc, flags, ", lhs=%T>",
+ dump_gimple_fmt (pp, spc, flags, ", lhs=%T>",
gimple_omp_return_lhs (gs));
else
- dump_gimple_fmt (buffer, spc, flags, ">");
+ dump_gimple_fmt (pp, spc, flags, ">");
}
else
{
- pp_string (buffer, "#pragma omp return");
+ pp_string (pp, "#pragma omp return");
if (gimple_omp_return_nowait_p (gs))
- pp_string (buffer, "(nowait)");
+ pp_string (pp, "(nowait)");
if (gimple_omp_return_lhs (gs))
{
- pp_string (buffer, " (set ");
- dump_generic_node (buffer, gimple_omp_return_lhs (gs),
+ pp_string (pp, " (set ");
+ dump_generic_node (pp, gimple_omp_return_lhs (gs),
spc, flags, false);
- pp_character (buffer, ')');
+ pp_character (pp, ')');
}
}
}
-/* Dump a GIMPLE_ASSUME tuple on the pretty_printer BUFFER. */
+/* Dump a GIMPLE_ASSUME tuple on the pretty_printer PP. */
static void
-dump_gimple_assume (pretty_printer *buffer, const gimple *gs,
+dump_gimple_assume (pretty_printer *pp, const gimple *gs,
int spc, dump_flags_t flags)
{
if (flags & TDF_RAW)
- dump_gimple_fmt (buffer, spc, flags,
+ dump_gimple_fmt (pp, spc, flags,
"%G [GUARD=%T] <%+BODY <%S> >",
gs, gimple_assume_guard (gs),
gimple_assume_body (gs));
else
{
- pp_string (buffer, "[[assume (");
- dump_generic_node (buffer, gimple_assume_guard (gs), spc, flags, false);
- pp_string (buffer, ")]]");
- newline_and_indent (buffer, spc + 2);
- pp_left_brace (buffer);
- pp_newline (buffer);
- dump_gimple_seq (buffer, gimple_assume_body (gs), spc + 4, flags);
- newline_and_indent (buffer, spc + 2);
- pp_right_brace (buffer);
+ pp_string (pp, "[[assume (");
+ dump_generic_node (pp, gimple_assume_guard (gs), spc, flags, false);
+ pp_string (pp, ")]]");
+ newline_and_indent (pp, spc + 2);
+ pp_left_brace (pp);
+ pp_newline (pp);
+ dump_gimple_seq (pp, gimple_assume_body (gs), spc + 4, flags);
+ newline_and_indent (pp, spc + 2);
+ pp_right_brace (pp);
}
}
-/* Dump a GIMPLE_TRANSACTION tuple on the pretty_printer BUFFER. */
+/* Dump a GIMPLE_TRANSACTION tuple on the pretty_printer PP. */
static void
-dump_gimple_transaction (pretty_printer *buffer, const gtransaction *gs,
+dump_gimple_transaction (pretty_printer *pp, const gtransaction *gs,
int spc, dump_flags_t flags)
{
unsigned subcode = gimple_transaction_subcode (gs);
if (flags & TDF_RAW)
{
- dump_gimple_fmt (buffer, spc, flags,
+ dump_gimple_fmt (pp, spc, flags,
"%G [SUBCODE=%x,NORM=%T,UNINST=%T,OVER=%T] "
"<%+BODY <%S> >",
gs, subcode, gimple_transaction_label_norm (gs),
else
{
if (subcode & GTMA_IS_OUTER)
- pp_string (buffer, "__transaction_atomic [[outer]]");
+ pp_string (pp, "__transaction_atomic [[outer]]");
else if (subcode & GTMA_IS_RELAXED)
- pp_string (buffer, "__transaction_relaxed");
+ pp_string (pp, "__transaction_relaxed");
else
- pp_string (buffer, "__transaction_atomic");
+ pp_string (pp, "__transaction_atomic");
subcode &= ~GTMA_DECLARATION_MASK;
if (gimple_transaction_body (gs))
{
- newline_and_indent (buffer, spc + 2);
- pp_left_brace (buffer);
- pp_newline (buffer);
- dump_gimple_seq (buffer, gimple_transaction_body (gs),
+ newline_and_indent (pp, spc + 2);
+ pp_left_brace (pp);
+ pp_newline (pp);
+ dump_gimple_seq (pp, gimple_transaction_body (gs),
spc + 4, flags);
- newline_and_indent (buffer, spc + 2);
- pp_right_brace (buffer);
+ newline_and_indent (pp, spc + 2);
+ pp_right_brace (pp);
}
else
{
- pp_string (buffer, " //");
+ pp_string (pp, " //");
if (gimple_transaction_label_norm (gs))
{
- pp_string (buffer, " NORM=");
- dump_generic_node (buffer, gimple_transaction_label_norm (gs),
+ pp_string (pp, " NORM=");
+ dump_generic_node (pp, gimple_transaction_label_norm (gs),
spc, flags, false);
}
if (gimple_transaction_label_uninst (gs))
{
- pp_string (buffer, " UNINST=");
- dump_generic_node (buffer, gimple_transaction_label_uninst (gs),
+ pp_string (pp, " UNINST=");
+ dump_generic_node (pp, gimple_transaction_label_uninst (gs),
spc, flags, false);
}
if (gimple_transaction_label_over (gs))
{
- pp_string (buffer, " OVER=");
- dump_generic_node (buffer, gimple_transaction_label_over (gs),
+ pp_string (pp, " OVER=");
+ dump_generic_node (pp, gimple_transaction_label_over (gs),
spc, flags, false);
}
if (subcode)
{
- pp_string (buffer, " SUBCODE=[ ");
+ pp_string (pp, " SUBCODE=[ ");
if (subcode & GTMA_HAVE_ABORT)
{
- pp_string (buffer, "GTMA_HAVE_ABORT ");
+ pp_string (pp, "GTMA_HAVE_ABORT ");
subcode &= ~GTMA_HAVE_ABORT;
}
if (subcode & GTMA_HAVE_LOAD)
{
- pp_string (buffer, "GTMA_HAVE_LOAD ");
+ pp_string (pp, "GTMA_HAVE_LOAD ");
subcode &= ~GTMA_HAVE_LOAD;
}
if (subcode & GTMA_HAVE_STORE)
{
- pp_string (buffer, "GTMA_HAVE_STORE ");
+ pp_string (pp, "GTMA_HAVE_STORE ");
subcode &= ~GTMA_HAVE_STORE;
}
if (subcode & GTMA_MAY_ENTER_IRREVOCABLE)
{
- pp_string (buffer, "GTMA_MAY_ENTER_IRREVOCABLE ");
+ pp_string (pp, "GTMA_MAY_ENTER_IRREVOCABLE ");
subcode &= ~GTMA_MAY_ENTER_IRREVOCABLE;
}
if (subcode & GTMA_DOES_GO_IRREVOCABLE)
{
- pp_string (buffer, "GTMA_DOES_GO_IRREVOCABLE ");
+ pp_string (pp, "GTMA_DOES_GO_IRREVOCABLE ");
subcode &= ~GTMA_DOES_GO_IRREVOCABLE;
}
if (subcode & GTMA_HAS_NO_INSTRUMENTATION)
{
- pp_string (buffer, "GTMA_HAS_NO_INSTRUMENTATION ");
+ pp_string (pp, "GTMA_HAS_NO_INSTRUMENTATION ");
subcode &= ~GTMA_HAS_NO_INSTRUMENTATION;
}
if (subcode)
- pp_printf (buffer, "0x%x ", subcode);
- pp_right_bracket (buffer);
+ pp_printf (pp, "0x%x ", subcode);
+ pp_right_bracket (pp);
}
}
}
}
-/* Dump a GIMPLE_ASM tuple on the pretty_printer BUFFER, SPC spaces of
+/* Dump a GIMPLE_ASM tuple on the pretty_printer PP, SPC spaces of
indent. FLAGS specifies details to show in the dump (see TDF_* in
dumpfile.h). */
static void
-dump_gimple_asm (pretty_printer *buffer, const gasm *gs, int spc,
+dump_gimple_asm (pretty_printer *pp, const gasm *gs, int spc,
dump_flags_t flags)
{
unsigned int i, n, f, fields;
if (flags & TDF_RAW)
{
- dump_gimple_fmt (buffer, spc, flags, "%G <%+STRING <%n%s%n>", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G <%+STRING <%n%s%n>", gs,
gimple_asm_string (gs));
n = gimple_asm_noutputs (gs);
if (n)
{
- newline_and_indent (buffer, spc + 2);
- pp_string (buffer, "OUTPUT: ");
+ newline_and_indent (pp, spc + 2);
+ pp_string (pp, "OUTPUT: ");
for (i = 0; i < n; i++)
{
- dump_generic_node (buffer, gimple_asm_output_op (gs, i),
+ dump_generic_node (pp, gimple_asm_output_op (gs, i),
spc, flags, false);
if (i < n - 1)
- pp_string (buffer, ", ");
+ pp_string (pp, ", ");
}
}
n = gimple_asm_ninputs (gs);
if (n)
{
- newline_and_indent (buffer, spc + 2);
- pp_string (buffer, "INPUT: ");
+ newline_and_indent (pp, spc + 2);
+ pp_string (pp, "INPUT: ");
for (i = 0; i < n; i++)
{
- dump_generic_node (buffer, gimple_asm_input_op (gs, i),
+ dump_generic_node (pp, gimple_asm_input_op (gs, i),
spc, flags, false);
if (i < n - 1)
- pp_string (buffer, ", ");
+ pp_string (pp, ", ");
}
}
n = gimple_asm_nclobbers (gs);
if (n)
{
- newline_and_indent (buffer, spc + 2);
- pp_string (buffer, "CLOBBER: ");
+ newline_and_indent (pp, spc + 2);
+ pp_string (pp, "CLOBBER: ");
for (i = 0; i < n; i++)
{
- dump_generic_node (buffer, gimple_asm_clobber_op (gs, i),
+ dump_generic_node (pp, gimple_asm_clobber_op (gs, i),
spc, flags, false);
if (i < n - 1)
- pp_string (buffer, ", ");
+ pp_string (pp, ", ");
}
}
n = gimple_asm_nlabels (gs);
if (n)
{
- newline_and_indent (buffer, spc + 2);
- pp_string (buffer, "LABEL: ");
+ newline_and_indent (pp, spc + 2);
+ pp_string (pp, "LABEL: ");
for (i = 0; i < n; i++)
{
- dump_generic_node (buffer, gimple_asm_label_op (gs, i),
+ dump_generic_node (pp, gimple_asm_label_op (gs, i),
spc, flags, false);
if (i < n - 1)
- pp_string (buffer, ", ");
+ pp_string (pp, ", ");
}
}
- newline_and_indent (buffer, spc);
- pp_greater (buffer);
+ newline_and_indent (pp, spc);
+ pp_greater (pp);
}
else
{
- pp_string (buffer, "__asm__");
+ pp_string (pp, "__asm__");
if (gimple_asm_volatile_p (gs))
- pp_string (buffer, " __volatile__");
+ pp_string (pp, " __volatile__");
if (gimple_asm_inline_p (gs))
- pp_string (buffer, " __inline__");
+ pp_string (pp, " __inline__");
if (gimple_asm_nlabels (gs))
- pp_string (buffer, " goto");
- pp_string (buffer, "(\"");
- pp_string (buffer, gimple_asm_string (gs));
- pp_string (buffer, "\"");
+ pp_string (pp, " goto");
+ pp_string (pp, "(\"");
+ pp_string (pp, gimple_asm_string (gs));
+ pp_string (pp, "\"");
if (gimple_asm_nlabels (gs))
fields = 4;
for (f = 0; f < fields; ++f)
{
- pp_string (buffer, " : ");
+ pp_string (pp, " : ");
switch (f)
{
n = gimple_asm_noutputs (gs);
for (i = 0; i < n; i++)
{
- dump_generic_node (buffer, gimple_asm_output_op (gs, i),
+ dump_generic_node (pp, gimple_asm_output_op (gs, i),
spc, flags, false);
if (i < n - 1)
- pp_string (buffer, ", ");
+ pp_string (pp, ", ");
}
break;
n = gimple_asm_ninputs (gs);
for (i = 0; i < n; i++)
{
- dump_generic_node (buffer, gimple_asm_input_op (gs, i),
+ dump_generic_node (pp, gimple_asm_input_op (gs, i),
spc, flags, false);
if (i < n - 1)
- pp_string (buffer, ", ");
+ pp_string (pp, ", ");
}
break;
n = gimple_asm_nclobbers (gs);
for (i = 0; i < n; i++)
{
- dump_generic_node (buffer, gimple_asm_clobber_op (gs, i),
+ dump_generic_node (pp, gimple_asm_clobber_op (gs, i),
spc, flags, false);
if (i < n - 1)
- pp_string (buffer, ", ");
+ pp_string (pp, ", ");
}
break;
n = gimple_asm_nlabels (gs);
for (i = 0; i < n; i++)
{
- dump_generic_node (buffer, gimple_asm_label_op (gs, i),
+ dump_generic_node (pp, gimple_asm_label_op (gs, i),
spc, flags, false);
if (i < n - 1)
- pp_string (buffer, ", ");
+ pp_string (pp, ", ");
}
break;
}
}
- pp_string (buffer, ");");
+ pp_string (pp, ");");
}
}
-/* Dump ptr_info and range_info for NODE on pretty_printer BUFFER with
+/* Dump ptr_info and range_info for NODE on pretty_printer PP with
SPC spaces of indent. */
static void
-dump_ssaname_info (pretty_printer *buffer, tree node, int spc)
+dump_ssaname_info (pretty_printer *pp, tree node, int spc)
{
if (TREE_CODE (node) != SSA_NAME)
return;
{
unsigned int align, misalign;
struct ptr_info_def *pi = SSA_NAME_PTR_INFO (node);
- pp_string (buffer, "# PT = ");
- pp_points_to_solution (buffer, &pi->pt);
- newline_and_indent (buffer, spc);
+ pp_string (pp, "# PT = ");
+ pp_points_to_solution (pp, &pi->pt);
+ newline_and_indent (pp, spc);
if (get_ptr_info_alignment (pi, &align, &misalign))
{
- pp_printf (buffer, "# ALIGN = %u, MISALIGN = %u", align, misalign);
- newline_and_indent (buffer, spc);
+ pp_printf (pp, "# ALIGN = %u, MISALIGN = %u", align, misalign);
+ newline_and_indent (pp, spc);
}
}
{
Value_Range r (TREE_TYPE (node));
get_global_range_query ()->range_of_expr (r, node);
- pp_string (buffer, "# RANGE ");
- pp_vrange (buffer, &r);
- newline_and_indent (buffer, spc);
+ pp_string (pp, "# RANGE ");
+ pp_vrange (pp, &r);
+ newline_and_indent (pp, spc);
}
}
void
dump_ssaname_info_to_file (FILE *file, tree node, int spc)
{
- pretty_printer buffer;
- pp_needs_newline (&buffer) = true;
- buffer.buffer->stream = file;
- dump_ssaname_info (&buffer, node, spc);
- pp_flush (&buffer);
+ pretty_printer pp;
+ pp_needs_newline (&pp) = true;
+ pp.buffer->stream = file;
+ dump_ssaname_info (&pp, node, spc);
+ pp_flush (&pp);
}
-/* Dump a PHI node PHI. BUFFER, SPC and FLAGS are as in pp_gimple_stmt_1.
- The caller is responsible for calling pp_flush on BUFFER to finalize
+/* Dump a PHI node PHI. PP, SPC and FLAGS are as in pp_gimple_stmt_1.
+ The caller is responsible for calling pp_flush on PP to finalize
pretty printer. If COMMENT is true, print this after #. */
static void
-dump_gimple_phi (pretty_printer *buffer, const gphi *phi, int spc, bool comment,
+dump_gimple_phi (pretty_printer *pp, const gphi *phi, int spc, bool comment,
dump_flags_t flags)
{
size_t i;
tree lhs = gimple_phi_result (phi);
if (flags & TDF_ALIAS)
- dump_ssaname_info (buffer, lhs, spc);
+ dump_ssaname_info (pp, lhs, spc);
if (comment)
- pp_string (buffer, "# ");
+ pp_string (pp, "# ");
if (flags & TDF_RAW)
- dump_gimple_fmt (buffer, spc, flags, "%G <%T, ", phi,
+ dump_gimple_fmt (pp, spc, flags, "%G <%T, ", phi,
gimple_phi_result (phi));
else
{
- dump_generic_node (buffer, lhs, spc, flags, false);
+ dump_generic_node (pp, lhs, spc, flags, false);
if (flags & TDF_GIMPLE)
- pp_string (buffer, " = __PHI (");
+ pp_string (pp, " = __PHI (");
else
- pp_string (buffer, " = PHI <");
+ pp_string (pp, " = PHI <");
}
for (i = 0; i < gimple_phi_num_args (phi); i++)
{
if ((flags & TDF_LINENO) && gimple_phi_arg_has_location (phi, i))
- dump_location (buffer, gimple_phi_arg_location (phi, i));
+ dump_location (pp, gimple_phi_arg_location (phi, i));
basic_block src = gimple_phi_arg_edge (phi, i)->src;
if (flags & TDF_GIMPLE)
{
- pp_string (buffer, "__BB");
- pp_decimal_int (buffer, src->index);
- pp_string (buffer, ": ");
+ pp_string (pp, "__BB");
+ pp_decimal_int (pp, src->index);
+ pp_string (pp, ": ");
}
- dump_generic_node (buffer, gimple_phi_arg_def (phi, i), spc, flags,
+ dump_generic_node (pp, gimple_phi_arg_def (phi, i), spc, flags,
false);
if (! (flags & TDF_GIMPLE))
{
- pp_left_paren (buffer);
- pp_decimal_int (buffer, src->index);
- pp_right_paren (buffer);
+ pp_left_paren (pp);
+ pp_decimal_int (pp, src->index);
+ pp_right_paren (pp);
}
if (i < gimple_phi_num_args (phi) - 1)
- pp_string (buffer, ", ");
+ pp_string (pp, ", ");
}
if (flags & TDF_GIMPLE)
- pp_string (buffer, ");");
+ pp_string (pp, ");");
else
- pp_greater (buffer);
+ pp_greater (pp);
}
-/* Dump a GIMPLE_OMP_PARALLEL tuple on the pretty_printer BUFFER, SPC spaces
+/* Dump a GIMPLE_OMP_PARALLEL tuple on the pretty_printer PP, SPC spaces
of indent. FLAGS specifies details to show in the dump (see TDF_* in
dumpfile.h). */
static void
-dump_gimple_omp_parallel (pretty_printer *buffer, const gomp_parallel *gs,
+dump_gimple_omp_parallel (pretty_printer *pp, const gomp_parallel *gs,
int spc, dump_flags_t flags)
{
if (flags & TDF_RAW)
{
- dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
gimple_omp_body (gs));
- dump_omp_clauses (buffer, gimple_omp_parallel_clauses (gs), spc, flags);
- dump_gimple_fmt (buffer, spc, flags, " >, %T, %T%n>",
+ dump_omp_clauses (pp, gimple_omp_parallel_clauses (gs), spc, flags);
+ dump_gimple_fmt (pp, spc, flags, " >, %T, %T%n>",
gimple_omp_parallel_child_fn (gs),
gimple_omp_parallel_data_arg (gs));
}
else
{
gimple_seq body;
- pp_string (buffer, "#pragma omp parallel");
- dump_omp_clauses (buffer, gimple_omp_parallel_clauses (gs), spc, flags);
+ pp_string (pp, "#pragma omp parallel");
+ dump_omp_clauses (pp, gimple_omp_parallel_clauses (gs), spc, flags);
if (gimple_omp_parallel_child_fn (gs))
{
- pp_string (buffer, " [child fn: ");
- dump_generic_node (buffer, gimple_omp_parallel_child_fn (gs),
+ pp_string (pp, " [child fn: ");
+ dump_generic_node (pp, gimple_omp_parallel_child_fn (gs),
spc, flags, false);
- pp_string (buffer, " (");
+ pp_string (pp, " (");
if (gimple_omp_parallel_data_arg (gs))
- dump_generic_node (buffer, gimple_omp_parallel_data_arg (gs),
+ dump_generic_node (pp, gimple_omp_parallel_data_arg (gs),
spc, flags, false);
else
- pp_string (buffer, "???");
- pp_string (buffer, ")]");
+ pp_string (pp, "???");
+ pp_string (pp, ")]");
}
body = gimple_omp_body (gs);
if (body && gimple_code (gimple_seq_first_stmt (body)) != GIMPLE_BIND)
{
- newline_and_indent (buffer, spc + 2);
- pp_left_brace (buffer);
- pp_newline (buffer);
- dump_gimple_seq (buffer, body, spc + 4, flags);
- newline_and_indent (buffer, spc + 2);
- pp_right_brace (buffer);
+ newline_and_indent (pp, spc + 2);
+ pp_left_brace (pp);
+ pp_newline (pp);
+ dump_gimple_seq (pp, body, spc + 4, flags);
+ newline_and_indent (pp, spc + 2);
+ pp_right_brace (pp);
}
else if (body)
{
- pp_newline (buffer);
- dump_gimple_seq (buffer, body, spc + 2, flags);
+ pp_newline (pp);
+ dump_gimple_seq (pp, body, spc + 2, flags);
}
}
}
-/* Dump a GIMPLE_OMP_TASK tuple on the pretty_printer BUFFER, SPC spaces
+/* Dump a GIMPLE_OMP_TASK tuple on the pretty_printer PP, SPC spaces
of indent. FLAGS specifies details to show in the dump (see TDF_* in
dumpfile.h). */
static void
-dump_gimple_omp_task (pretty_printer *buffer, const gomp_task *gs, int spc,
+dump_gimple_omp_task (pretty_printer *pp, const gomp_task *gs, int spc,
dump_flags_t flags)
{
if (flags & TDF_RAW)
{
- dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
gimple_omp_body (gs));
- dump_omp_clauses (buffer, gimple_omp_task_clauses (gs), spc, flags);
- dump_gimple_fmt (buffer, spc, flags, " >, %T, %T, %T, %T, %T%n>",
+ dump_omp_clauses (pp, gimple_omp_task_clauses (gs), spc, flags);
+ dump_gimple_fmt (pp, spc, flags, " >, %T, %T, %T, %T, %T%n>",
gimple_omp_task_child_fn (gs),
gimple_omp_task_data_arg (gs),
gimple_omp_task_copy_fn (gs),
{
gimple_seq body;
if (gimple_omp_task_taskloop_p (gs))
- pp_string (buffer, "#pragma omp taskloop");
+ pp_string (pp, "#pragma omp taskloop");
else if (gimple_omp_task_taskwait_p (gs))
- pp_string (buffer, "#pragma omp taskwait");
+ pp_string (pp, "#pragma omp taskwait");
else
- pp_string (buffer, "#pragma omp task");
- dump_omp_clauses (buffer, gimple_omp_task_clauses (gs), spc, flags);
+ pp_string (pp, "#pragma omp task");
+ dump_omp_clauses (pp, gimple_omp_task_clauses (gs), spc, flags);
if (gimple_omp_task_child_fn (gs))
{
- pp_string (buffer, " [child fn: ");
- dump_generic_node (buffer, gimple_omp_task_child_fn (gs),
+ pp_string (pp, " [child fn: ");
+ dump_generic_node (pp, gimple_omp_task_child_fn (gs),
spc, flags, false);
- pp_string (buffer, " (");
+ pp_string (pp, " (");
if (gimple_omp_task_data_arg (gs))
- dump_generic_node (buffer, gimple_omp_task_data_arg (gs),
+ dump_generic_node (pp, gimple_omp_task_data_arg (gs),
spc, flags, false);
else
- pp_string (buffer, "???");
- pp_string (buffer, ")]");
+ pp_string (pp, "???");
+ pp_string (pp, ")]");
}
body = gimple_omp_body (gs);
if (body && gimple_code (gimple_seq_first_stmt (body)) != GIMPLE_BIND)
{
- newline_and_indent (buffer, spc + 2);
- pp_left_brace (buffer);
- pp_newline (buffer);
- dump_gimple_seq (buffer, body, spc + 4, flags);
- newline_and_indent (buffer, spc + 2);
- pp_right_brace (buffer);
+ newline_and_indent (pp, spc + 2);
+ pp_left_brace (pp);
+ pp_newline (pp);
+ dump_gimple_seq (pp, body, spc + 4, flags);
+ newline_and_indent (pp, spc + 2);
+ pp_right_brace (pp);
}
else if (body)
{
- pp_newline (buffer);
- dump_gimple_seq (buffer, body, spc + 2, flags);
+ pp_newline (pp);
+ dump_gimple_seq (pp, body, spc + 2, flags);
}
}
}
-/* Dump a GIMPLE_OMP_ATOMIC_LOAD tuple on the pretty_printer BUFFER, SPC
+/* Dump a GIMPLE_OMP_ATOMIC_LOAD tuple on the pretty_printer PP, SPC
spaces of indent. FLAGS specifies details to show in the dump (see TDF_*
in dumpfile.h). */
static void
-dump_gimple_omp_atomic_load (pretty_printer *buffer, const gomp_atomic_load *gs,
+dump_gimple_omp_atomic_load (pretty_printer *pp, const gomp_atomic_load *gs,
int spc, dump_flags_t flags)
{
if (flags & TDF_RAW)
{
- dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T>", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G <%T, %T>", gs,
gimple_omp_atomic_load_lhs (gs),
gimple_omp_atomic_load_rhs (gs));
}
else
{
- pp_string (buffer, "#pragma omp atomic_load");
- dump_omp_atomic_memory_order (buffer,
+ pp_string (pp, "#pragma omp atomic_load");
+ dump_omp_atomic_memory_order (pp,
gimple_omp_atomic_memory_order (gs));
if (gimple_omp_atomic_need_value_p (gs))
- pp_string (buffer, " [needed]");
+ pp_string (pp, " [needed]");
if (gimple_omp_atomic_weak_p (gs))
- pp_string (buffer, " [weak]");
- newline_and_indent (buffer, spc + 2);
- dump_generic_node (buffer, gimple_omp_atomic_load_lhs (gs),
+ pp_string (pp, " [weak]");
+ newline_and_indent (pp, spc + 2);
+ dump_generic_node (pp, gimple_omp_atomic_load_lhs (gs),
spc, flags, false);
- pp_space (buffer);
- pp_equal (buffer);
- pp_space (buffer);
- pp_star (buffer);
- dump_generic_node (buffer, gimple_omp_atomic_load_rhs (gs),
+ pp_space (pp);
+ pp_equal (pp);
+ pp_space (pp);
+ pp_star (pp);
+ dump_generic_node (pp, gimple_omp_atomic_load_rhs (gs),
spc, flags, false);
}
}
-/* Dump a GIMPLE_OMP_ATOMIC_STORE tuple on the pretty_printer BUFFER, SPC
+/* Dump a GIMPLE_OMP_ATOMIC_STORE tuple on the pretty_printer PP, SPC
spaces of indent. FLAGS specifies details to show in the dump (see TDF_*
in dumpfile.h). */
static void
-dump_gimple_omp_atomic_store (pretty_printer *buffer,
+dump_gimple_omp_atomic_store (pretty_printer *pp,
const gomp_atomic_store *gs, int spc,
dump_flags_t flags)
{
if (flags & TDF_RAW)
{
- dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs,
+ dump_gimple_fmt (pp, spc, flags, "%G <%T>", gs,
gimple_omp_atomic_store_val (gs));
}
else
{
- pp_string (buffer, "#pragma omp atomic_store");
- dump_omp_atomic_memory_order (buffer,
+ pp_string (pp, "#pragma omp atomic_store");
+ dump_omp_atomic_memory_order (pp,
gimple_omp_atomic_memory_order (gs));
- pp_space (buffer);
+ pp_space (pp);
if (gimple_omp_atomic_need_value_p (gs))
- pp_string (buffer, "[needed] ");
+ pp_string (pp, "[needed] ");
if (gimple_omp_atomic_weak_p (gs))
- pp_string (buffer, "[weak] ");
- pp_left_paren (buffer);
- dump_generic_node (buffer, gimple_omp_atomic_store_val (gs),
+ pp_string (pp, "[weak] ");
+ pp_left_paren (pp);
+ dump_generic_node (pp, gimple_omp_atomic_store_val (gs),
spc, flags, false);
- pp_right_paren (buffer);
+ pp_right_paren (pp);
}
}
-/* Dump all the memory operands for statement GS. BUFFER, SPC and
+/* Dump all the memory operands for statement GS. PP, SPC and
FLAGS are as in pp_gimple_stmt_1. */
static void
-dump_gimple_mem_ops (pretty_printer *buffer, const gimple *gs, int spc,
+dump_gimple_mem_ops (pretty_printer *pp, const gimple *gs, int spc,
dump_flags_t flags)
{
tree vdef = gimple_vdef (gs);
if (vdef != NULL_TREE)
{
- 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_greater (buffer);
- newline_and_indent (buffer, spc);
+ pp_string (pp, "# ");
+ dump_generic_node (pp, vdef, spc + 2, flags, false);
+ pp_string (pp, " = VDEF <");
+ dump_generic_node (pp, vuse, spc + 2, flags, false);
+ pp_greater (pp);
+ newline_and_indent (pp, spc);
}
else if (vuse != NULL_TREE)
{
- pp_string (buffer, "# VUSE <");
- dump_generic_node (buffer, vuse, spc + 2, flags, false);
- pp_greater (buffer);
- newline_and_indent (buffer, spc);
+ pp_string (pp, "# VUSE <");
+ dump_generic_node (pp, vuse, spc + 2, flags, false);
+ pp_greater (pp);
+ newline_and_indent (pp, spc);
}
}
-/* Print the gimple statement GS on the pretty printer BUFFER, SPC
+/* Print the gimple statement GS on the pretty printer PP, SPC
spaces of indent. FLAGS specifies details to show in the dump (see
TDF_* in dumpfile.h). The caller is responsible for calling
- pp_flush on BUFFER to finalize the pretty printer. */
+ pp_flush on PP to finalize the pretty printer. */
void
-pp_gimple_stmt_1 (pretty_printer *buffer, const gimple *gs, int spc,
+pp_gimple_stmt_1 (pretty_printer *pp, const gimple *gs, int spc,
dump_flags_t flags)
{
if (!gs)
return;
if (flags & TDF_STMTADDR)
- pp_printf (buffer, "<&%p> ", (const void *) gs);
+ pp_printf (pp, "<&%p> ", (const void *) gs);
if ((flags & TDF_LINENO) && gimple_has_location (gs))
- dump_location (buffer, gimple_location (gs));
+ dump_location (pp, gimple_location (gs));
if (flags & TDF_EH)
{
int lp_nr = lookup_stmt_eh_lp (gs);
if (lp_nr > 0)
- pp_printf (buffer, "[LP %d] ", lp_nr);
+ pp_printf (pp, "[LP %d] ", lp_nr);
else if (lp_nr < 0)
- pp_printf (buffer, "[MNT %d] ", -lp_nr);
+ pp_printf (pp, "[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_mem_ops (pp, gs, spc, flags);
if (gimple_has_lhs (gs)
&& (flags & TDF_ALIAS))
- dump_ssaname_info (buffer, gimple_get_lhs (gs), spc);
+ dump_ssaname_info (pp, gimple_get_lhs (gs), spc);
switch (gimple_code (gs))
{
case GIMPLE_ASM:
- dump_gimple_asm (buffer, as_a <const gasm *> (gs), spc, flags);
+ dump_gimple_asm (pp, as_a <const gasm *> (gs), spc, flags);
break;
case GIMPLE_ASSIGN:
- dump_gimple_assign (buffer, as_a <const gassign *> (gs), spc, flags);
+ dump_gimple_assign (pp, as_a <const gassign *> (gs), spc, flags);
break;
case GIMPLE_BIND:
- dump_gimple_bind (buffer, as_a <const gbind *> (gs), spc, flags);
+ dump_gimple_bind (pp, as_a <const gbind *> (gs), spc, flags);
break;
case GIMPLE_CALL:
- dump_gimple_call (buffer, as_a <const gcall *> (gs), spc, flags);
+ dump_gimple_call (pp, as_a <const gcall *> (gs), spc, flags);
break;
case GIMPLE_COND:
- dump_gimple_cond (buffer, as_a <const gcond *> (gs), spc, flags);
+ dump_gimple_cond (pp, as_a <const gcond *> (gs), spc, flags);
break;
case GIMPLE_LABEL:
- dump_gimple_label (buffer, as_a <const glabel *> (gs), spc, flags);
+ dump_gimple_label (pp, as_a <const glabel *> (gs), spc, flags);
break;
case GIMPLE_GOTO:
- dump_gimple_goto (buffer, as_a <const ggoto *> (gs), spc, flags);
+ dump_gimple_goto (pp, as_a <const ggoto *> (gs), spc, flags);
break;
case GIMPLE_NOP:
- pp_string (buffer, "GIMPLE_NOP");
+ pp_string (pp, "GIMPLE_NOP");
break;
case GIMPLE_RETURN:
- dump_gimple_return (buffer, as_a <const greturn *> (gs), spc, flags);
+ dump_gimple_return (pp, as_a <const greturn *> (gs), spc, flags);
break;
case GIMPLE_SWITCH:
- dump_gimple_switch (buffer, as_a <const gswitch *> (gs), spc, flags);
+ dump_gimple_switch (pp, as_a <const gswitch *> (gs), spc, flags);
break;
case GIMPLE_TRY:
- dump_gimple_try (buffer, as_a <const gtry *> (gs), spc, flags);
+ dump_gimple_try (pp, as_a <const gtry *> (gs), spc, flags);
break;
case GIMPLE_PHI:
- dump_gimple_phi (buffer, as_a <const gphi *> (gs), spc, false, flags);
+ dump_gimple_phi (pp, as_a <const gphi *> (gs), spc, false, flags);
break;
case GIMPLE_OMP_PARALLEL:
- dump_gimple_omp_parallel (buffer, as_a <const gomp_parallel *> (gs), spc,
+ dump_gimple_omp_parallel (pp, as_a <const gomp_parallel *> (gs), spc,
flags);
break;
case GIMPLE_OMP_TASK:
- dump_gimple_omp_task (buffer, as_a <const gomp_task *> (gs), spc, flags);
+ dump_gimple_omp_task (pp, as_a <const gomp_task *> (gs), spc, flags);
break;
case GIMPLE_OMP_ATOMIC_LOAD:
- dump_gimple_omp_atomic_load (buffer, as_a <const gomp_atomic_load *> (gs),
+ dump_gimple_omp_atomic_load (pp, as_a <const gomp_atomic_load *> (gs),
spc, flags);
break;
case GIMPLE_OMP_ATOMIC_STORE:
- dump_gimple_omp_atomic_store (buffer,
+ dump_gimple_omp_atomic_store (pp,
as_a <const gomp_atomic_store *> (gs),
spc, flags);
break;
case GIMPLE_OMP_FOR:
- dump_gimple_omp_for (buffer, as_a <const gomp_for *> (gs), spc, flags);
+ dump_gimple_omp_for (pp, as_a <const gomp_for *> (gs), spc, flags);
break;
case GIMPLE_OMP_CONTINUE:
- dump_gimple_omp_continue (buffer, as_a <const gomp_continue *> (gs), spc,
+ dump_gimple_omp_continue (pp, as_a <const gomp_continue *> (gs), spc,
flags);
break;
case GIMPLE_OMP_SINGLE:
- dump_gimple_omp_single (buffer, as_a <const gomp_single *> (gs), spc,
+ dump_gimple_omp_single (pp, as_a <const gomp_single *> (gs), spc,
flags);
break;
case GIMPLE_OMP_TARGET:
- dump_gimple_omp_target (buffer, as_a <const gomp_target *> (gs), spc,
+ dump_gimple_omp_target (pp, as_a <const gomp_target *> (gs), spc,
flags);
break;
case GIMPLE_OMP_TEAMS:
- dump_gimple_omp_teams (buffer, as_a <const gomp_teams *> (gs), spc,
+ dump_gimple_omp_teams (pp, as_a <const gomp_teams *> (gs), spc,
flags);
break;
case GIMPLE_OMP_RETURN:
- dump_gimple_omp_return (buffer, gs, spc, flags);
+ dump_gimple_omp_return (pp, gs, spc, flags);
break;
case GIMPLE_OMP_SECTIONS:
- dump_gimple_omp_sections (buffer, as_a <const gomp_sections *> (gs),
+ dump_gimple_omp_sections (pp, as_a <const gomp_sections *> (gs),
spc, flags);
break;
case GIMPLE_OMP_SECTIONS_SWITCH:
- pp_string (buffer, "GIMPLE_SECTIONS_SWITCH");
+ pp_string (pp, "GIMPLE_SECTIONS_SWITCH");
break;
case GIMPLE_OMP_TASKGROUP:
- dump_gimple_omp_taskgroup (buffer, gs, spc, flags);
+ dump_gimple_omp_taskgroup (pp, gs, spc, flags);
break;
case GIMPLE_OMP_MASKED:
- dump_gimple_omp_masked (buffer, gs, spc, flags);
+ dump_gimple_omp_masked (pp, gs, spc, flags);
break;
case GIMPLE_OMP_SCOPE:
- dump_gimple_omp_scope (buffer, gs, spc, flags);
+ dump_gimple_omp_scope (pp, gs, spc, flags);
break;
case GIMPLE_OMP_MASTER:
case GIMPLE_OMP_SECTION:
case GIMPLE_OMP_STRUCTURED_BLOCK:
- dump_gimple_omp_block (buffer, gs, spc, flags);
+ dump_gimple_omp_block (pp, gs, spc, flags);
break;
case GIMPLE_OMP_ORDERED:
- dump_gimple_omp_ordered (buffer, as_a <const gomp_ordered *> (gs), spc,
+ dump_gimple_omp_ordered (pp, as_a <const gomp_ordered *> (gs), spc,
flags);
break;
case GIMPLE_OMP_SCAN:
- dump_gimple_omp_scan (buffer, as_a <const gomp_scan *> (gs), spc,
+ dump_gimple_omp_scan (pp, as_a <const gomp_scan *> (gs), spc,
flags);
break;
case GIMPLE_OMP_CRITICAL:
- dump_gimple_omp_critical (buffer, as_a <const gomp_critical *> (gs), spc,
+ dump_gimple_omp_critical (pp, as_a <const gomp_critical *> (gs), spc,
flags);
break;
case GIMPLE_CATCH:
- dump_gimple_catch (buffer, as_a <const gcatch *> (gs), spc, flags);
+ dump_gimple_catch (pp, as_a <const gcatch *> (gs), spc, flags);
break;
case GIMPLE_EH_FILTER:
- dump_gimple_eh_filter (buffer, as_a <const geh_filter *> (gs), spc,
+ dump_gimple_eh_filter (pp, as_a <const geh_filter *> (gs), spc,
flags);
break;
case GIMPLE_EH_MUST_NOT_THROW:
- dump_gimple_eh_must_not_throw (buffer,
+ dump_gimple_eh_must_not_throw (pp,
as_a <const geh_mnt *> (gs),
spc, flags);
break;
case GIMPLE_EH_ELSE:
- dump_gimple_eh_else (buffer, as_a <const geh_else *> (gs), spc, flags);
+ dump_gimple_eh_else (pp, as_a <const geh_else *> (gs), spc, flags);
break;
case GIMPLE_RESX:
- dump_gimple_resx (buffer, as_a <const gresx *> (gs), spc, flags);
+ dump_gimple_resx (pp, as_a <const gresx *> (gs), spc, flags);
break;
case GIMPLE_EH_DISPATCH:
- dump_gimple_eh_dispatch (buffer, as_a <const geh_dispatch *> (gs), spc,
+ dump_gimple_eh_dispatch (pp, as_a <const geh_dispatch *> (gs), spc,
flags);
break;
case GIMPLE_DEBUG:
- dump_gimple_debug (buffer, as_a <const gdebug *> (gs), spc, flags);
+ dump_gimple_debug (pp, as_a <const gdebug *> (gs), spc, flags);
break;
case GIMPLE_PREDICT:
- pp_string (buffer, "// predicted ");
+ pp_string (pp, "// predicted ");
if (gimple_predict_outcome (gs))
- pp_string (buffer, "likely by ");
+ pp_string (pp, "likely by ");
else
- pp_string (buffer, "unlikely by ");
- pp_string (buffer, predictor_name (gimple_predict_predictor (gs)));
- pp_string (buffer, " predictor.");
+ pp_string (pp, "unlikely by ");
+ pp_string (pp, predictor_name (gimple_predict_predictor (gs)));
+ pp_string (pp, " predictor.");
break;
case GIMPLE_ASSUME:
- dump_gimple_assume (buffer, gs, spc, flags);
+ dump_gimple_assume (pp, gs, spc, flags);
break;
case GIMPLE_TRANSACTION:
- dump_gimple_transaction (buffer, as_a <const gtransaction *> (gs), spc,
+ dump_gimple_transaction (pp, as_a <const gtransaction *> (gs), spc,
flags);
break;
}
-/* Dumps end of basic block BB to buffer BUFFER indented by INDENT
+/* Dumps end of basic block BB to PP indented by INDENT
spaces. */
static void
}
-/* Dump PHI nodes of basic block BB to BUFFER with details described
+/* Dump PHI nodes of basic block BB to PP with details described
by FLAGS and indented by INDENT spaces. */
static void
-dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent,
+dump_phi_nodes (pretty_printer *pp, basic_block bb, int indent,
dump_flags_t flags)
{
gphi_iterator i;
if (!virtual_operand_p (gimple_phi_result (phi)) || (flags & TDF_VOPS))
{
INDENT (indent);
- dump_gimple_phi (buffer, phi, indent,
+ dump_gimple_phi (pp, phi, indent,
(flags & TDF_GIMPLE) ? false : true, flags);
- pp_newline (buffer);
+ pp_newline (pp);
}
}
}
/* Dump jump to basic block BB that is represented implicitly in the cfg
- to BUFFER. */
+ to PP. */
static void
-pp_cfg_jump (pretty_printer *buffer, edge e, dump_flags_t flags)
+pp_cfg_jump (pretty_printer *pp, edge e, dump_flags_t flags)
{
if (flags & TDF_GIMPLE)
{
- pp_string (buffer, "goto __BB");
- pp_decimal_int (buffer, e->dest->index);
+ pp_string (pp, "goto __BB");
+ pp_decimal_int (pp, e->dest->index);
if (e->probability.initialized_p ())
{
- pp_string (buffer, "(");
- pp_string (buffer,
+ pp_string (pp, "(");
+ pp_string (pp,
profile_quality_as_string (e->probability.quality ()));
- pp_string (buffer, "(");
- pp_decimal_int (buffer, e->probability.value ());
- pp_string (buffer, "))");
+ pp_string (pp, "(");
+ pp_decimal_int (pp, e->probability.value ());
+ pp_string (pp, "))");
}
- pp_semicolon (buffer);
+ pp_semicolon (pp);
}
else
{
- pp_string (buffer, "goto <bb ");
- pp_decimal_int (buffer, e->dest->index);
- pp_greater (buffer);
- pp_semicolon (buffer);
+ pp_string (pp, "goto <bb ");
+ pp_decimal_int (pp, e->dest->index);
+ pp_greater (pp);
+ pp_semicolon (pp);
- dump_edge_probability (buffer, e);
+ dump_edge_probability (pp, e);
}
}
-/* Dump edges represented implicitly in basic block BB to BUFFER, indented
+/* Dump edges represented implicitly in basic block BB to PP, indented
by INDENT spaces, with details given by FLAGS. */
static void
-dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,
+dump_implicit_edges (pretty_printer *pp, basic_block bb, int indent,
dump_flags_t flags)
{
edge e;
extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
INDENT (indent + 2);
- pp_cfg_jump (buffer, true_edge, flags);
- newline_and_indent (buffer, indent);
- pp_string (buffer, "else");
- newline_and_indent (buffer, indent + 2);
- pp_cfg_jump (buffer, false_edge, flags);
- pp_newline (buffer);
+ pp_cfg_jump (pp, true_edge, flags);
+ newline_and_indent (pp, indent);
+ pp_string (pp, "else");
+ newline_and_indent (pp, indent + 2);
+ pp_cfg_jump (pp, false_edge, flags);
+ pp_newline (pp);
return;
}
if ((flags & TDF_LINENO)
&& e->goto_locus != UNKNOWN_LOCATION)
- dump_location (buffer, e->goto_locus);
+ dump_location (pp, e->goto_locus);
- pp_cfg_jump (buffer, e, flags);
- pp_newline (buffer);
+ pp_cfg_jump (pp, e, flags);
+ pp_newline (pp);
}
}
-/* Dumps basic block BB to buffer BUFFER with details described by FLAGS and
+/* Dumps basic block BB to PP with details described by FLAGS and
indented by INDENT spaces. */
static void
-gimple_dump_bb_buff (pretty_printer *buffer, basic_block bb, int indent,
+gimple_dump_bb_buff (pretty_printer *pp, basic_block bb, int indent,
dump_flags_t flags)
{
gimple_stmt_iterator gsi;
if (label_indent < 0)
label_indent = 0;
- dump_phi_nodes (buffer, bb, indent, flags);
+ dump_phi_nodes (pp, bb, indent, flags);
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
curr_indent = gimple_code (stmt) == GIMPLE_LABEL ? label_indent : indent;
INDENT (curr_indent);
- pp_gimple_stmt_1 (buffer, stmt, curr_indent, flags);
- pp_newline_and_flush (buffer);
+ pp_gimple_stmt_1 (pp, stmt, curr_indent, flags);
+ pp_newline_and_flush (pp);
gcc_checking_assert (DECL_STRUCT_FUNCTION (current_function_decl));
dump_histograms_for_stmt (DECL_STRUCT_FUNCTION (current_function_decl),
- pp_buffer (buffer)->stream, stmt);
+ pp_buffer (pp)->stream, stmt);
}
- dump_implicit_edges (buffer, bb, indent, flags);
- pp_flush (buffer);
+ dump_implicit_edges (pp, bb, indent, flags);
+ pp_flush (pp);
}
dump_gimple_bb_header (file, bb, indent, flags);
if (bb->index >= NUM_FIXED_BLOCKS)
{
- pretty_printer buffer;
- pp_needs_newline (&buffer) = true;
- buffer.buffer->stream = file;
- gimple_dump_bb_buff (&buffer, bb, indent, flags);
+ pretty_printer pp;
+ pp_needs_newline (&pp) = true;
+ pp.buffer->stream = file;
+ gimple_dump_bb_buff (&pp, bb, indent, flags);
}
dump_gimple_bb_footer (file, bb, indent, flags);
}
projects / thirdparty / gcc.git / commitdiff
