URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [tree-pretty-print.c] - Diff between revs 154 and 816

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 154	Rev 816
`/* Pretty formatting of GENERIC trees in C syntax.`	`/* Pretty formatting of GENERIC trees in C syntax.`
`Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007`	`Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007`
`Free Software Foundation, Inc.`	`Free Software Foundation, Inc.`
`Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>`	`Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>`

`This file is part of GCC.`	`This file is part of GCC.`

`GCC is free software; you can redistribute it and/or modify it under`	`GCC is free software; you can redistribute it and/or modify it under`
`the terms of the GNU General Public License as published by the Free`	`the terms of the GNU General Public License as published by the Free`
`Software Foundation; either version 3, or (at your option) any later`	`Software Foundation; either version 3, or (at your option) any later`
`version.`	`version.`

`GCC is distributed in the hope that it will be useful, but WITHOUT ANY`	`GCC is distributed in the hope that it will be useful, but WITHOUT ANY`
`WARRANTY; without even the implied warranty of MERCHANTABILITY or`	`WARRANTY; without even the implied warranty of MERCHANTABILITY or`
`FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License`	`FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License`
`for more details.`	`for more details.`

`You should have received a copy of the GNU General Public License`	`You should have received a copy of the GNU General Public License`
`along with GCC; see the file COPYING3. If not see`	`along with GCC; see the file COPYING3. If not see`
`<http://www.gnu.org/licenses/>. */`	`<http://www.gnu.org/licenses/>. */`

`#include "config.h"`	`#include "config.h"`
`#include "system.h"`	`#include "system.h"`
`#include "coretypes.h"`	`#include "coretypes.h"`
`#include "tm.h"`	`#include "tm.h"`
`#include "tree.h"`	`#include "tree.h"`
`#include "diagnostic.h"`	`#include "diagnostic.h"`
`#include "real.h"`	`#include "real.h"`
`#include "hashtab.h"`	`#include "hashtab.h"`
`#include "tree-flow.h"`	`#include "tree-flow.h"`
`#include "langhooks.h"`	`#include "langhooks.h"`
`#include "tree-iterator.h"`	`#include "tree-iterator.h"`
`#include "tree-chrec.h"`	`#include "tree-chrec.h"`
`#include "tree-pass.h"`	`#include "tree-pass.h"`

`/* Local functions, macros and variables. */`	`/* Local functions, macros and variables. */`
`static int op_prio (tree);`	`static int op_prio (tree);`
`static const char *op_symbol_1 (enum tree_code);`	`static const char *op_symbol_1 (enum tree_code);`
`static const char *op_symbol (tree);`	`static const char *op_symbol (tree);`
`static void pretty_print_string (pretty_printer , const char);`	`static void pretty_print_string (pretty_printer , const char);`
`static void print_call_name (pretty_printer *, tree);`	`static void print_call_name (pretty_printer *, tree);`
`static void newline_and_indent (pretty_printer *, int);`	`static void newline_and_indent (pretty_printer *, int);`
`static void maybe_init_pretty_print (FILE *);`	`static void maybe_init_pretty_print (FILE *);`
`static void print_declaration (pretty_printer *, tree, int, int);`	`static void print_declaration (pretty_printer *, tree, int, int);`
`static void print_struct_decl (pretty_printer *, tree, int, int);`	`static void print_struct_decl (pretty_printer *, tree, int, int);`
`static void do_niy (pretty_printer *, tree);`	`static void do_niy (pretty_printer *, tree);`
`static void dump_vops (pretty_printer *, tree, int, int);`	`static void dump_vops (pretty_printer *, tree, int, int);`
`static void dump_generic_bb_buff (pretty_printer *, basic_block, int, int);`	`static void dump_generic_bb_buff (pretty_printer *, basic_block, int, int);`

`#define INDENT(SPACE) do { \`	`#define INDENT(SPACE) do { \`
`int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)`	`int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)`

`#define NIY do_niy(buffer,node)`	`#define NIY do_niy(buffer,node)`

`#define PRINT_FUNCTION_NAME(NODE) pp_printf \`	`#define PRINT_FUNCTION_NAME(NODE) pp_printf \`
`(buffer, "%s", TREE_CODE (NODE) == NOP_EXPR ? \`	`(buffer, "%s", TREE_CODE (NODE) == NOP_EXPR ? \`
`lang_hooks.decl_printable_name (TREE_OPERAND (NODE, 0), 1) : \`	`lang_hooks.decl_printable_name (TREE_OPERAND (NODE, 0), 1) : \`
`lang_hooks.decl_printable_name (NODE, 1))`	`lang_hooks.decl_printable_name (NODE, 1))`

`static pretty_printer buffer;`	`static pretty_printer buffer;`
`static int initialized = 0;`	`static int initialized = 0;`

`/* Try to print something for an unknown tree code. */`	`/* Try to print something for an unknown tree code. */`

`static void`	`static void`
`do_niy (pretty_printer *buffer, tree node)`	`do_niy (pretty_printer *buffer, tree node)`
`{`	`{`
`int i, len;`	`int i, len;`

`pp_string (buffer, "<<< Unknown tree: ");`	`pp_string (buffer, "<<< Unknown tree: ");`
`pp_string (buffer, tree_code_name[(int) TREE_CODE (node)]);`	`pp_string (buffer, tree_code_name[(int) TREE_CODE (node)]);`

`if (EXPR_P (node))`	`if (EXPR_P (node))`
`{`	`{`
`len = TREE_CODE_LENGTH (TREE_CODE (node));`	`len = TREE_CODE_LENGTH (TREE_CODE (node));`
`for (i = 0; i < len; ++i)`	`for (i = 0; i < len; ++i)`
`{`	`{`
`newline_and_indent (buffer, 2);`	`newline_and_indent (buffer, 2);`
`dump_generic_node (buffer, TREE_OPERAND (node, i), 2, 0, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, i), 2, 0, false);`
`}`	`}`
`}`	`}`

`pp_string (buffer, " >>>\n");`	`pp_string (buffer, " >>>\n");`
`}`	`}`

`void`	`void`
`debug_generic_expr (tree t)`	`debug_generic_expr (tree t)`
`{`	`{`
`print_generic_expr (stderr, t, TDF_VOPS\|TDF_UID);`	`print_generic_expr (stderr, t, TDF_VOPS\|TDF_UID);`
`fprintf (stderr, "\n");`	`fprintf (stderr, "\n");`
`}`	`}`

`void`	`void`
`debug_generic_stmt (tree t)`	`debug_generic_stmt (tree t)`
`{`	`{`
`print_generic_stmt (stderr, t, TDF_VOPS\|TDF_UID);`	`print_generic_stmt (stderr, t, TDF_VOPS\|TDF_UID);`
`fprintf (stderr, "\n");`	`fprintf (stderr, "\n");`
`}`	`}`

`void`	`void`
`debug_tree_chain (tree t)`	`debug_tree_chain (tree t)`
`{`	`{`
`while (t)`	`while (t)`
`{`	`{`
`print_generic_expr (stderr, t, TDF_VOPS\|TDF_UID);`	`print_generic_expr (stderr, t, TDF_VOPS\|TDF_UID);`
`fprintf(stderr, " ");`	`fprintf(stderr, " ");`
`t = TREE_CHAIN (t);`	`t = TREE_CHAIN (t);`
`}`	`}`
`fprintf (stderr, "\n");`	`fprintf (stderr, "\n");`
`}`	`}`

`/* Prints declaration DECL to the FILE with details specified by FLAGS. */`	`/* Prints declaration DECL to the FILE with details specified by FLAGS. */`
`void`	`void`
`print_generic_decl (FILE *file, tree decl, int flags)`	`print_generic_decl (FILE *file, tree decl, int flags)`
`{`	`{`
`maybe_init_pretty_print (file);`	`maybe_init_pretty_print (file);`
`print_declaration (&buffer, decl, 2, flags);`	`print_declaration (&buffer, decl, 2, flags);`
`pp_write_text_to_stream (&buffer);`	`pp_write_text_to_stream (&buffer);`
`}`	`}`

`/* Print tree T, and its successors, on file FILE. FLAGS specifies details`	`/* Print tree T, and its successors, on file FILE. FLAGS specifies details`
`to show in the dump. See TDF_* in tree.h. */`	`to show in the dump. See TDF_* in tree.h. */`

`void`	`void`
`print_generic_stmt (FILE *file, tree t, int flags)`	`print_generic_stmt (FILE *file, tree t, int flags)`
`{`	`{`
`maybe_init_pretty_print (file);`	`maybe_init_pretty_print (file);`
`dump_generic_node (&buffer, t, 0, flags, true);`	`dump_generic_node (&buffer, t, 0, flags, true);`
`pp_flush (&buffer);`	`pp_flush (&buffer);`
`}`	`}`

`/* Print tree T, and its successors, on file FILE. FLAGS specifies details`	`/* Print tree T, and its successors, on file FILE. FLAGS specifies details`
`to show in the dump. See TDF_* in tree.h. The output is indented by`	`to show in the dump. See TDF_* in tree.h. The output is indented by`
`INDENT spaces. */`	`INDENT spaces. */`

`void`	`void`
`print_generic_stmt_indented (FILE *file, tree t, int flags, int indent)`	`print_generic_stmt_indented (FILE *file, tree t, int flags, int indent)`
`{`	`{`
`int i;`	`int i;`

`maybe_init_pretty_print (file);`	`maybe_init_pretty_print (file);`

`for (i = 0; i < indent; i++)`	`for (i = 0; i < indent; i++)`
`pp_space (&buffer);`	`pp_space (&buffer);`
`dump_generic_node (&buffer, t, indent, flags, true);`	`dump_generic_node (&buffer, t, indent, flags, true);`
`pp_flush (&buffer);`	`pp_flush (&buffer);`
`}`	`}`

`/* Print a single expression T on file FILE. FLAGS specifies details to show`	`/* Print a single expression T on file FILE. FLAGS specifies details to show`
`in the dump. See TDF_* in tree.h. */`	`in the dump. See TDF_* in tree.h. */`

`void`	`void`
`print_generic_expr (FILE *file, tree t, int flags)`	`print_generic_expr (FILE *file, tree t, int flags)`
`{`	`{`
`maybe_init_pretty_print (file);`	`maybe_init_pretty_print (file);`
`dump_generic_node (&buffer, t, 0, flags, false);`	`dump_generic_node (&buffer, t, 0, flags, false);`
`}`	`}`

`/* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set`	`/* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set`
`in FLAGS. */`	`in FLAGS. */`

`static void`	`static void`
`dump_decl_name (pretty_printer *buffer, tree node, int flags)`	`dump_decl_name (pretty_printer *buffer, tree node, int flags)`
`{`	`{`
`tree t = node;`	`tree t = node;`

`if (DECL_NAME (t))`	`if (DECL_NAME (t))`
`pp_tree_identifier (buffer, DECL_NAME (t));`	`pp_tree_identifier (buffer, DECL_NAME (t));`
`if ((flags & TDF_UID)`	`if ((flags & TDF_UID)`
`\|\| DECL_NAME (t) == NULL_TREE)`	`\|\| DECL_NAME (t) == NULL_TREE)`
`{`	`{`
`if (TREE_CODE (t) == LABEL_DECL`	`if (TREE_CODE (t) == LABEL_DECL`
`&& LABEL_DECL_UID (t) != -1)`	`&& LABEL_DECL_UID (t) != -1)`
`pp_printf (buffer, "L." HOST_WIDE_INT_PRINT_DEC,`	`pp_printf (buffer, "L." HOST_WIDE_INT_PRINT_DEC,`
`LABEL_DECL_UID (t));`	`LABEL_DECL_UID (t));`
`else`	`else`
`{`	`{`
`char c = TREE_CODE (t) == CONST_DECL ? 'C' : 'D';`	`char c = TREE_CODE (t) == CONST_DECL ? 'C' : 'D';`
`pp_printf (buffer, "%c.%u", c, DECL_UID (t));`	`pp_printf (buffer, "%c.%u", c, DECL_UID (t));`
`}`	`}`
`}`	`}`
`}`	`}`

`/* Like the above, but used for pretty printing function calls. */`	`/* Like the above, but used for pretty printing function calls. */`

`static void`	`static void`
`dump_function_name (pretty_printer *buffer, tree node)`	`dump_function_name (pretty_printer *buffer, tree node)`
`{`	`{`
`if (DECL_NAME (node))`	`if (DECL_NAME (node))`
`PRINT_FUNCTION_NAME (node);`	`PRINT_FUNCTION_NAME (node);`
`else`	`else`
`dump_decl_name (buffer, node, 0);`	`dump_decl_name (buffer, node, 0);`
`}`	`}`

`/* Dump a function declaration. NODE is the FUNCTION_TYPE. BUFFER, SPC and`	`/* Dump a function declaration. NODE is the FUNCTION_TYPE. BUFFER, SPC and`
`FLAGS are as in dump_generic_node. */`	`FLAGS are as in dump_generic_node. */`

`static void`	`static void`
`dump_function_declaration (pretty_printer *buffer, tree node,`	`dump_function_declaration (pretty_printer *buffer, tree node,`
`int spc, int flags)`	`int spc, int flags)`
`{`	`{`
`bool wrote_arg = false;`	`bool wrote_arg = false;`
`tree arg;`	`tree arg;`

`pp_space (buffer);`	`pp_space (buffer);`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`

`/* Print the argument types. The last element in the list is a VOID_TYPE.`	`/* Print the argument types. The last element in the list is a VOID_TYPE.`
`The following avoids printing the last element. */`	`The following avoids printing the last element. */`
`arg = TYPE_ARG_TYPES (node);`	`arg = TYPE_ARG_TYPES (node);`
`while (arg && TREE_CHAIN (arg) && arg != error_mark_node)`	`while (arg && TREE_CHAIN (arg) && arg != error_mark_node)`
`{`	`{`
`wrote_arg = true;`	`wrote_arg = true;`
`dump_generic_node (buffer, TREE_VALUE (arg), spc, flags, false);`	`dump_generic_node (buffer, TREE_VALUE (arg), spc, flags, false);`
`arg = TREE_CHAIN (arg);`	`arg = TREE_CHAIN (arg);`
`if (TREE_CHAIN (arg) && TREE_CODE (TREE_CHAIN (arg)) == TREE_LIST)`	`if (TREE_CHAIN (arg) && TREE_CODE (TREE_CHAIN (arg)) == TREE_LIST)`
`{`	`{`
`pp_character (buffer, ',');`	`pp_character (buffer, ',');`
`pp_space (buffer);`	`pp_space (buffer);`
`}`	`}`
`}`	`}`

`if (!wrote_arg)`	`if (!wrote_arg)`
`pp_string (buffer, "void");`	`pp_string (buffer, "void");`

`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`}`	`}`

`/* Dump the domain associated with an array. */`	`/* Dump the domain associated with an array. */`

`static void`	`static void`
`dump_array_domain (pretty_printer *buffer, tree domain, int spc, int flags)`	`dump_array_domain (pretty_printer *buffer, tree domain, int spc, int flags)`
`{`	`{`
`pp_character (buffer, '[');`	`pp_character (buffer, '[');`
`if (domain)`	`if (domain)`
`{`	`{`
`tree min = TYPE_MIN_VALUE (domain);`	`tree min = TYPE_MIN_VALUE (domain);`
`tree max = TYPE_MAX_VALUE (domain);`	`tree max = TYPE_MAX_VALUE (domain);`

`if (min && max`	`if (min && max`
`&& integer_zerop (min)`	`&& integer_zerop (min)`
`&& host_integerp (max, 0))`	`&& host_integerp (max, 0))`
`pp_wide_integer (buffer, TREE_INT_CST_LOW (max) + 1);`	`pp_wide_integer (buffer, TREE_INT_CST_LOW (max) + 1);`
`else`	`else`
`{`	`{`
`if (min)`	`if (min)`
`dump_generic_node (buffer, min, spc, flags, false);`	`dump_generic_node (buffer, min, spc, flags, false);`
`pp_character (buffer, ':');`	`pp_character (buffer, ':');`
`if (max)`	`if (max)`
`dump_generic_node (buffer, max, spc, flags, false);`	`dump_generic_node (buffer, max, spc, flags, false);`
`}`	`}`
`}`	`}`
`else`	`else`
`pp_string (buffer, "<unknown>");`	`pp_string (buffer, "<unknown>");`
`pp_character (buffer, ']');`	`pp_character (buffer, ']');`
`}`	`}`


`/* Dump OpenMP clause CLAUSE. BUFFER, CLAUSE, SPC and FLAGS are as in`	`/* Dump OpenMP clause CLAUSE. BUFFER, CLAUSE, SPC and FLAGS are as in`
`dump_generic_node. */`	`dump_generic_node. */`

`static void`	`static void`
`dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)`	`dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)`
`{`	`{`
`const char *name;`	`const char *name;`

`switch (OMP_CLAUSE_CODE (clause))`	`switch (OMP_CLAUSE_CODE (clause))`
`{`	`{`
`case OMP_CLAUSE_PRIVATE:`	`case OMP_CLAUSE_PRIVATE:`
`name = "private";`	`name = "private";`
`goto print_remap;`	`goto print_remap;`
`case OMP_CLAUSE_SHARED:`	`case OMP_CLAUSE_SHARED:`
`name = "shared";`	`name = "shared";`
`goto print_remap;`	`goto print_remap;`
`case OMP_CLAUSE_FIRSTPRIVATE:`	`case OMP_CLAUSE_FIRSTPRIVATE:`
`name = "firstprivate";`	`name = "firstprivate";`
`goto print_remap;`	`goto print_remap;`
`case OMP_CLAUSE_LASTPRIVATE:`	`case OMP_CLAUSE_LASTPRIVATE:`
`name = "lastprivate";`	`name = "lastprivate";`
`goto print_remap;`	`goto print_remap;`
`case OMP_CLAUSE_COPYIN:`	`case OMP_CLAUSE_COPYIN:`
`name = "copyin";`	`name = "copyin";`
`goto print_remap;`	`goto print_remap;`
`case OMP_CLAUSE_COPYPRIVATE:`	`case OMP_CLAUSE_COPYPRIVATE:`
`name = "copyprivate";`	`name = "copyprivate";`
`goto print_remap;`	`goto print_remap;`
`print_remap:`	`print_remap:`
`pp_string (buffer, name);`	`pp_string (buffer, name);`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`
`dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),`	`dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),`
`spc, flags, false);`	`spc, flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`break;`	`break;`

`case OMP_CLAUSE_REDUCTION:`	`case OMP_CLAUSE_REDUCTION:`
`pp_string (buffer, "reduction(");`	`pp_string (buffer, "reduction(");`
`pp_string (buffer, op_symbol_1 (OMP_CLAUSE_REDUCTION_CODE (clause)));`	`pp_string (buffer, op_symbol_1 (OMP_CLAUSE_REDUCTION_CODE (clause)));`
`pp_character (buffer, ':');`	`pp_character (buffer, ':');`
`dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),`	`dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),`
`spc, flags, false);`	`spc, flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`break;`	`break;`

`case OMP_CLAUSE_IF:`	`case OMP_CLAUSE_IF:`
`pp_string (buffer, "if(");`	`pp_string (buffer, "if(");`
`dump_generic_node (buffer, OMP_CLAUSE_IF_EXPR (clause),`	`dump_generic_node (buffer, OMP_CLAUSE_IF_EXPR (clause),`
`spc, flags, false);`	`spc, flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`break;`	`break;`

`case OMP_CLAUSE_NUM_THREADS:`	`case OMP_CLAUSE_NUM_THREADS:`
`pp_string (buffer, "num_threads(");`	`pp_string (buffer, "num_threads(");`
`dump_generic_node (buffer, OMP_CLAUSE_NUM_THREADS_EXPR (clause),`	`dump_generic_node (buffer, OMP_CLAUSE_NUM_THREADS_EXPR (clause),`
`spc, flags, false);`	`spc, flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`break;`	`break;`

`case OMP_CLAUSE_NOWAIT:`	`case OMP_CLAUSE_NOWAIT:`
`pp_string (buffer, "nowait");`	`pp_string (buffer, "nowait");`
`break;`	`break;`
`case OMP_CLAUSE_ORDERED:`	`case OMP_CLAUSE_ORDERED:`
`pp_string (buffer, "ordered");`	`pp_string (buffer, "ordered");`
`break;`	`break;`

`case OMP_CLAUSE_DEFAULT:`	`case OMP_CLAUSE_DEFAULT:`
`pp_string (buffer, "default(");`	`pp_string (buffer, "default(");`
`switch (OMP_CLAUSE_DEFAULT_KIND (clause))`	`switch (OMP_CLAUSE_DEFAULT_KIND (clause))`
`{`	`{`
`case OMP_CLAUSE_DEFAULT_UNSPECIFIED:`	`case OMP_CLAUSE_DEFAULT_UNSPECIFIED:`
`break;`	`break;`
`case OMP_CLAUSE_DEFAULT_SHARED:`	`case OMP_CLAUSE_DEFAULT_SHARED:`
`pp_string (buffer, "shared");`	`pp_string (buffer, "shared");`
`break;`	`break;`
`case OMP_CLAUSE_DEFAULT_NONE:`	`case OMP_CLAUSE_DEFAULT_NONE:`
`pp_string (buffer, "none");`	`pp_string (buffer, "none");`
`break;`	`break;`
`case OMP_CLAUSE_DEFAULT_PRIVATE:`	`case OMP_CLAUSE_DEFAULT_PRIVATE:`
`pp_string (buffer, "private");`	`pp_string (buffer, "private");`
`break;`	`break;`
`default:`	`default:`
`gcc_unreachable ();`	`gcc_unreachable ();`
`}`	`}`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`break;`	`break;`

`case OMP_CLAUSE_SCHEDULE:`	`case OMP_CLAUSE_SCHEDULE:`
`pp_string (buffer, "schedule(");`	`pp_string (buffer, "schedule(");`
`switch (OMP_CLAUSE_SCHEDULE_KIND (clause))`	`switch (OMP_CLAUSE_SCHEDULE_KIND (clause))`
`{`	`{`
`case OMP_CLAUSE_SCHEDULE_STATIC:`	`case OMP_CLAUSE_SCHEDULE_STATIC:`
`pp_string (buffer, "static");`	`pp_string (buffer, "static");`
`break;`	`break;`
`case OMP_CLAUSE_SCHEDULE_DYNAMIC:`	`case OMP_CLAUSE_SCHEDULE_DYNAMIC:`
`pp_string (buffer, "dynamic");`	`pp_string (buffer, "dynamic");`
`break;`	`break;`
`case OMP_CLAUSE_SCHEDULE_GUIDED:`	`case OMP_CLAUSE_SCHEDULE_GUIDED:`
`pp_string (buffer, "guided");`	`pp_string (buffer, "guided");`
`break;`	`break;`
`case OMP_CLAUSE_SCHEDULE_RUNTIME:`	`case OMP_CLAUSE_SCHEDULE_RUNTIME:`
`pp_string (buffer, "runtime");`	`pp_string (buffer, "runtime");`
`break;`	`break;`
`default:`	`default:`
`gcc_unreachable ();`	`gcc_unreachable ();`
`}`	`}`
`if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))`	`if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))`
`{`	`{`
`pp_character (buffer, ',');`	`pp_character (buffer, ',');`
`dump_generic_node (buffer,`	`dump_generic_node (buffer,`
`OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause),`	`OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause),`
`spc, flags, false);`	`spc, flags, false);`
`}`	`}`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`break;`	`break;`

`default:`	`default:`
`/* Should never happen. */`	`/* Should never happen. */`
`dump_generic_node (buffer, clause, spc, flags, false);`	`dump_generic_node (buffer, clause, spc, flags, false);`
`break;`	`break;`
`}`	`}`
`}`	`}`


`/* Dump the list of OpenMP clauses. BUFFER, SPC and FLAGS are as in`	`/* Dump the list of OpenMP clauses. BUFFER, SPC and FLAGS are as in`
`dump_generic_node. */`	`dump_generic_node. */`

`static void`	`static void`
`dump_omp_clauses (pretty_printer *buffer, tree clause, int spc, int flags)`	`dump_omp_clauses (pretty_printer *buffer, tree clause, int spc, int flags)`
`{`	`{`
`if (clause == NULL)`	`if (clause == NULL)`
`return;`	`return;`

`pp_space (buffer);`	`pp_space (buffer);`
`while (1)`	`while (1)`
`{`	`{`
`dump_omp_clause (buffer, clause, spc, flags);`	`dump_omp_clause (buffer, clause, spc, flags);`
`clause = OMP_CLAUSE_CHAIN (clause);`	`clause = OMP_CLAUSE_CHAIN (clause);`
`if (clause == NULL)`	`if (clause == NULL)`
`return;`	`return;`
`pp_space (buffer);`	`pp_space (buffer);`
`}`	`}`
`}`	`}`


`/* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of indent.`	`/* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of indent.`
`FLAGS specifies details to show in the dump (see TDF_* in tree.h). If`	`FLAGS specifies details to show in the dump (see TDF_* in tree.h). If`
`IS_STMT is true, the object printed is considered to be a statement`	`IS_STMT is true, the object printed is considered to be a statement`
`and it is terminated by ';' if appropriate. */`	`and it is terminated by ';' if appropriate. */`

`int`	`int`
`dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,`	`dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,`
`bool is_stmt)`	`bool is_stmt)`
`{`	`{`
`tree type;`	`tree type;`
`tree op0, op1;`	`tree op0, op1;`
`const char *str;`	`const char *str;`
`bool is_expr;`	`bool is_expr;`

`if (node == NULL_TREE)`	`if (node == NULL_TREE)`
`return spc;`	`return spc;`

`is_expr = EXPR_P (node);`	`is_expr = EXPR_P (node);`

`if (TREE_CODE (node) != ERROR_MARK`	`if (TREE_CODE (node) != ERROR_MARK`
`&& is_gimple_stmt (node)`	`&& is_gimple_stmt (node)`
`&& (flags & TDF_VOPS)`	`&& (flags & TDF_VOPS)`
`&& stmt_ann (node)`	`&& stmt_ann (node)`
`&& TREE_CODE (node) != PHI_NODE)`	`&& TREE_CODE (node) != PHI_NODE)`
`dump_vops (buffer, node, spc, flags);`	`dump_vops (buffer, node, spc, flags);`

`if (is_stmt && (flags & TDF_STMTADDR))`	`if (is_stmt && (flags & TDF_STMTADDR))`
`pp_printf (buffer, "<&%p> ", (void *)node);`	`pp_printf (buffer, "<&%p> ", (void *)node);`

`if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node))`	`if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node))`
`{`	`{`
`expanded_location xloc = expand_location (EXPR_LOCATION (node));`	`expanded_location xloc = expand_location (EXPR_LOCATION (node));`
`pp_character (buffer, '[');`	`pp_character (buffer, '[');`
`if (xloc.file)`	`if (xloc.file)`
`{`	`{`
`pp_string (buffer, xloc.file);`	`pp_string (buffer, xloc.file);`
`pp_string (buffer, " : ");`	`pp_string (buffer, " : ");`
`}`	`}`
`pp_decimal_int (buffer, xloc.line);`	`pp_decimal_int (buffer, xloc.line);`
`pp_string (buffer, "] ");`	`pp_string (buffer, "] ");`
`}`	`}`

`switch (TREE_CODE (node))`	`switch (TREE_CODE (node))`
`{`	`{`
`case ERROR_MARK:`	`case ERROR_MARK:`
`pp_string (buffer, "<<< error >>>");`	`pp_string (buffer, "<<< error >>>");`
`break;`	`break;`

`case IDENTIFIER_NODE:`	`case IDENTIFIER_NODE:`
`pp_tree_identifier (buffer, node);`	`pp_tree_identifier (buffer, node);`
`break;`	`break;`

`case TREE_LIST:`	`case TREE_LIST:`
`while (node && node != error_mark_node)`	`while (node && node != error_mark_node)`
`{`	`{`
`if (TREE_PURPOSE (node))`	`if (TREE_PURPOSE (node))`
`{`	`{`
`dump_generic_node (buffer, TREE_PURPOSE (node), spc, flags, false);`	`dump_generic_node (buffer, TREE_PURPOSE (node), spc, flags, false);`
`pp_space (buffer);`	`pp_space (buffer);`
`}`	`}`
`dump_generic_node (buffer, TREE_VALUE (node), spc, flags, false);`	`dump_generic_node (buffer, TREE_VALUE (node), spc, flags, false);`
`node = TREE_CHAIN (node);`	`node = TREE_CHAIN (node);`
`if (node && TREE_CODE (node) == TREE_LIST)`	`if (node && TREE_CODE (node) == TREE_LIST)`
`{`	`{`
`pp_character (buffer, ',');`	`pp_character (buffer, ',');`
`pp_space (buffer);`	`pp_space (buffer);`
`}`	`}`
`}`	`}`
`break;`	`break;`

`case TREE_BINFO:`	`case TREE_BINFO:`
`dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false);`	`dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false);`

`case TREE_VEC:`	`case TREE_VEC:`
`{`	`{`
`size_t i;`	`size_t i;`
`if (TREE_VEC_LENGTH (node) > 0)`	`if (TREE_VEC_LENGTH (node) > 0)`
`{`	`{`
`size_t len = TREE_VEC_LENGTH (node);`	`size_t len = TREE_VEC_LENGTH (node);`
`for (i = 0; i < len - 1; i++)`	`for (i = 0; i < len - 1; i++)`
`{`	`{`
`dump_generic_node (buffer, TREE_VEC_ELT (node, i), spc, flags,`	`dump_generic_node (buffer, TREE_VEC_ELT (node, i), spc, flags,`
`false);`	`false);`
`pp_character (buffer, ',');`	`pp_character (buffer, ',');`
`pp_space (buffer);`	`pp_space (buffer);`
`}`	`}`
`dump_generic_node (buffer, TREE_VEC_ELT (node, len - 1), spc,`	`dump_generic_node (buffer, TREE_VEC_ELT (node, len - 1), spc,`
`flags, false);`	`flags, false);`
`}`	`}`
`}`	`}`
`break;`	`break;`

`case VOID_TYPE:`	`case VOID_TYPE:`
`case INTEGER_TYPE:`	`case INTEGER_TYPE:`
`case REAL_TYPE:`	`case REAL_TYPE:`
`case COMPLEX_TYPE:`	`case COMPLEX_TYPE:`
`case VECTOR_TYPE:`	`case VECTOR_TYPE:`
`case ENUMERAL_TYPE:`	`case ENUMERAL_TYPE:`
`case BOOLEAN_TYPE:`	`case BOOLEAN_TYPE:`
`{`	`{`
`unsigned int quals = TYPE_QUALS (node);`	`unsigned int quals = TYPE_QUALS (node);`
`enum tree_code_class class;`	`enum tree_code_class class;`

`if (quals & TYPE_QUAL_CONST)`	`if (quals & TYPE_QUAL_CONST)`
`pp_string (buffer, "const ");`	`pp_string (buffer, "const ");`
`else if (quals & TYPE_QUAL_VOLATILE)`	`else if (quals & TYPE_QUAL_VOLATILE)`
`pp_string (buffer, "volatile ");`	`pp_string (buffer, "volatile ");`
`else if (quals & TYPE_QUAL_RESTRICT)`	`else if (quals & TYPE_QUAL_RESTRICT)`
`pp_string (buffer, "restrict ");`	`pp_string (buffer, "restrict ");`

`class = TREE_CODE_CLASS (TREE_CODE (node));`	`class = TREE_CODE_CLASS (TREE_CODE (node));`

`if (class == tcc_declaration)`	`if (class == tcc_declaration)`
`{`	`{`
`if (DECL_NAME (node))`	`if (DECL_NAME (node))`
`dump_decl_name (buffer, node, flags);`	`dump_decl_name (buffer, node, flags);`
`else`	`else`
`pp_string (buffer, "<unnamed type decl>");`	`pp_string (buffer, "<unnamed type decl>");`
`}`	`}`
`else if (class == tcc_type)`	`else if (class == tcc_type)`
`{`	`{`
`if (TYPE_NAME (node))`	`if (TYPE_NAME (node))`
`{`	`{`
`if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)`	`if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)`
`pp_tree_identifier (buffer, TYPE_NAME (node));`	`pp_tree_identifier (buffer, TYPE_NAME (node));`
`else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL`	`else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL`
`&& DECL_NAME (TYPE_NAME (node)))`	`&& DECL_NAME (TYPE_NAME (node)))`
`dump_decl_name (buffer, TYPE_NAME (node), flags);`	`dump_decl_name (buffer, TYPE_NAME (node), flags);`
`else`	`else`
`pp_string (buffer, "<unnamed type>");`	`pp_string (buffer, "<unnamed type>");`
`}`	`}`
`else if (TREE_CODE (node) == VECTOR_TYPE)`	`else if (TREE_CODE (node) == VECTOR_TYPE)`
`{`	`{`
`pp_string (buffer, "vector ");`	`pp_string (buffer, "vector ");`
`dump_generic_node (buffer, TREE_TYPE (node),`	`dump_generic_node (buffer, TREE_TYPE (node),`
`spc, flags, false);`	`spc, flags, false);`
`}`	`}`
`else`	`else`
`pp_string (buffer, "<unnamed type>");`	`pp_string (buffer, "<unnamed type>");`
`}`	`}`
`break;`	`break;`
`}`	`}`

`case POINTER_TYPE:`	`case POINTER_TYPE:`
`case REFERENCE_TYPE:`	`case REFERENCE_TYPE:`
`str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&");`	`str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&");`

`if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)`	`if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)`
`{`	`{`
`tree fnode = TREE_TYPE (node);`	`tree fnode = TREE_TYPE (node);`

`dump_generic_node (buffer, TREE_TYPE (fnode), spc, flags, false);`	`dump_generic_node (buffer, TREE_TYPE (fnode), spc, flags, false);`
`pp_space (buffer);`	`pp_space (buffer);`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`
`pp_string (buffer, str);`	`pp_string (buffer, str);`
`if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))`	`if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))`
`dump_decl_name (buffer, TYPE_NAME (node), flags);`	`dump_decl_name (buffer, TYPE_NAME (node), flags);`
`else`	`else`
`pp_printf (buffer, "<T%x>", TYPE_UID (node));`	`pp_printf (buffer, "<T%x>", TYPE_UID (node));`

`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`dump_function_declaration (buffer, fnode, spc, flags);`	`dump_function_declaration (buffer, fnode, spc, flags);`
`}`	`}`
`else`	`else`
`{`	`{`
`unsigned int quals = TYPE_QUALS (node);`	`unsigned int quals = TYPE_QUALS (node);`

`dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);`	`dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);`
`pp_space (buffer);`	`pp_space (buffer);`
`pp_string (buffer, str);`	`pp_string (buffer, str);`

`if (quals & TYPE_QUAL_CONST)`	`if (quals & TYPE_QUAL_CONST)`
`pp_string (buffer, " const");`	`pp_string (buffer, " const");`
`else if (quals & TYPE_QUAL_VOLATILE)`	`else if (quals & TYPE_QUAL_VOLATILE)`
`pp_string (buffer, "volatile");`	`pp_string (buffer, "volatile");`
`else if (quals & TYPE_QUAL_RESTRICT)`	`else if (quals & TYPE_QUAL_RESTRICT)`
`pp_string (buffer, " restrict");`	`pp_string (buffer, " restrict");`

`if (TYPE_REF_CAN_ALIAS_ALL (node))`	`if (TYPE_REF_CAN_ALIAS_ALL (node))`
`pp_string (buffer, " {ref-all}");`	`pp_string (buffer, " {ref-all}");`
`}`	`}`
`break;`	`break;`

`case OFFSET_TYPE:`	`case OFFSET_TYPE:`
`NIY;`	`NIY;`
`break;`	`break;`

`case METHOD_TYPE:`	`case METHOD_TYPE:`
`dump_decl_name (buffer, TYPE_NAME (TYPE_METHOD_BASETYPE (node)), flags);`	`dump_decl_name (buffer, TYPE_NAME (TYPE_METHOD_BASETYPE (node)), flags);`
`pp_string (buffer, "::");`	`pp_string (buffer, "::");`
`break;`	`break;`

`case TARGET_MEM_REF:`	`case TARGET_MEM_REF:`
`{`	`{`
`const char *sep = "";`	`const char *sep = "";`
`tree tmp;`	`tree tmp;`

`pp_string (buffer, "MEM[");`	`pp_string (buffer, "MEM[");`

`tmp = TMR_SYMBOL (node);`	`tmp = TMR_SYMBOL (node);`
`if (tmp)`	`if (tmp)`
`{`	`{`
`pp_string (buffer, sep);`	`pp_string (buffer, sep);`
`sep = ", ";`	`sep = ", ";`
`pp_string (buffer, "symbol: ");`	`pp_string (buffer, "symbol: ");`
`dump_generic_node (buffer, tmp, spc, flags, false);`	`dump_generic_node (buffer, tmp, spc, flags, false);`
`}`	`}`
`tmp = TMR_BASE (node);`	`tmp = TMR_BASE (node);`
`if (tmp)`	`if (tmp)`
`{`	`{`
`pp_string (buffer, sep);`	`pp_string (buffer, sep);`
`sep = ", ";`	`sep = ", ";`
`pp_string (buffer, "base: ");`	`pp_string (buffer, "base: ");`
`dump_generic_node (buffer, tmp, spc, flags, false);`	`dump_generic_node (buffer, tmp, spc, flags, false);`
`}`	`}`
`tmp = TMR_INDEX (node);`	`tmp = TMR_INDEX (node);`
`if (tmp)`	`if (tmp)`
`{`	`{`
`pp_string (buffer, sep);`	`pp_string (buffer, sep);`
`sep = ", ";`	`sep = ", ";`
`pp_string (buffer, "index: ");`	`pp_string (buffer, "index: ");`
`dump_generic_node (buffer, tmp, spc, flags, false);`	`dump_generic_node (buffer, tmp, spc, flags, false);`
`}`	`}`
`tmp = TMR_STEP (node);`	`tmp = TMR_STEP (node);`
`if (tmp)`	`if (tmp)`
`{`	`{`
`pp_string (buffer, sep);`	`pp_string (buffer, sep);`
`sep = ", ";`	`sep = ", ";`
`pp_string (buffer, "step: ");`	`pp_string (buffer, "step: ");`
`dump_generic_node (buffer, tmp, spc, flags, false);`	`dump_generic_node (buffer, tmp, spc, flags, false);`
`}`	`}`
`tmp = TMR_OFFSET (node);`	`tmp = TMR_OFFSET (node);`
`if (tmp)`	`if (tmp)`
`{`	`{`
`pp_string (buffer, sep);`	`pp_string (buffer, sep);`
`sep = ", ";`	`sep = ", ";`
`pp_string (buffer, "offset: ");`	`pp_string (buffer, "offset: ");`
`dump_generic_node (buffer, tmp, spc, flags, false);`	`dump_generic_node (buffer, tmp, spc, flags, false);`
`}`	`}`
`pp_string (buffer, "]");`	`pp_string (buffer, "]");`
`if (flags & TDF_DETAILS)`	`if (flags & TDF_DETAILS)`
`{`	`{`
`pp_string (buffer, "{");`	`pp_string (buffer, "{");`
`dump_generic_node (buffer, TMR_ORIGINAL (node), spc, flags,`	`dump_generic_node (buffer, TMR_ORIGINAL (node), spc, flags,`
`false);`	`false);`
`pp_string (buffer, "}");`	`pp_string (buffer, "}");`
`}`	`}`
`}`	`}`
`break;`	`break;`

`case ARRAY_TYPE:`	`case ARRAY_TYPE:`
`{`	`{`
`tree tmp;`	`tree tmp;`

`/* Print the innermost component type. */`	`/* Print the innermost component type. */`
`for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE;`	`for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE;`
`tmp = TREE_TYPE (tmp))`	`tmp = TREE_TYPE (tmp))`
`;`	`;`
`dump_generic_node (buffer, tmp, spc, flags, false);`	`dump_generic_node (buffer, tmp, spc, flags, false);`

`/* Print the dimensions. */`	`/* Print the dimensions. */`
`for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp))`	`for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp))`
`dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);`	`dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);`
`break;`	`break;`
`}`	`}`

`case RECORD_TYPE:`	`case RECORD_TYPE:`
`case UNION_TYPE:`	`case UNION_TYPE:`
`case QUAL_UNION_TYPE:`	`case QUAL_UNION_TYPE:`
`/* Print the name of the structure. */`	`/* Print the name of the structure. */`
`if (TREE_CODE (node) == RECORD_TYPE)`	`if (TREE_CODE (node) == RECORD_TYPE)`
`pp_string (buffer, "struct ");`	`pp_string (buffer, "struct ");`
`else if (TREE_CODE (node) == UNION_TYPE)`	`else if (TREE_CODE (node) == UNION_TYPE)`
`pp_string (buffer, "union ");`	`pp_string (buffer, "union ");`

`if (TYPE_NAME (node))`	`if (TYPE_NAME (node))`
`dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false);`	`dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false);`
`else`	`else`
`print_struct_decl (buffer, node, spc, flags);`	`print_struct_decl (buffer, node, spc, flags);`
`break;`	`break;`

`case LANG_TYPE:`	`case LANG_TYPE:`
`NIY;`	`NIY;`
`break;`	`break;`

`case INTEGER_CST:`	`case INTEGER_CST:`
`if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE)`	`if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE)`
`{`	`{`
`/* In the case of a pointer, one may want to divide by the`	`/* In the case of a pointer, one may want to divide by the`
`size of the pointed-to type. Unfortunately, this not`	`size of the pointed-to type. Unfortunately, this not`
`straightforward. The C front-end maps expressions`	`straightforward. The C front-end maps expressions`

`(int *) 5`	`(int *) 5`
`int *p; (p + 5)`	`int *p; (p + 5)`

`in such a way that the two INTEGER_CST nodes for "5" have`	`in such a way that the two INTEGER_CST nodes for "5" have`
`different values but identical types. In the latter`	`different values but identical types. In the latter`
`case, the 5 is multiplied by sizeof (int) in c-common.c`	`case, the 5 is multiplied by sizeof (int) in c-common.c`
`(pointer_int_sum) to convert it to a byte address, and`	`(pointer_int_sum) to convert it to a byte address, and`
`yet the type of the node is left unchanged. Argh. What`	`yet the type of the node is left unchanged. Argh. What`
`is consistent though is that the number value corresponds`	`is consistent though is that the number value corresponds`
`to bytes (UNITS) offset.`	`to bytes (UNITS) offset.`

`NB: Neither of the following divisors can be trivially`	`NB: Neither of the following divisors can be trivially`
`used to recover the original literal:`	`used to recover the original literal:`

`TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))`	`TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))`
`TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */`	`TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */`
`pp_wide_integer (buffer, TREE_INT_CST_LOW (node));`	`pp_wide_integer (buffer, TREE_INT_CST_LOW (node));`
`pp_string (buffer, "B"); /* pseudo-unit */`	`pp_string (buffer, "B"); /* pseudo-unit */`
`}`	`}`
`else if (! host_integerp (node, 0))`	`else if (! host_integerp (node, 0))`
`{`	`{`
`tree val = node;`	`tree val = node;`

`if (tree_int_cst_sgn (val) < 0)`	`if (tree_int_cst_sgn (val) < 0)`
`{`	`{`
`pp_character (buffer, '-');`	`pp_character (buffer, '-');`
`val = build_int_cst_wide (NULL_TREE,`	`val = build_int_cst_wide (NULL_TREE,`
`-TREE_INT_CST_LOW (val),`	`-TREE_INT_CST_LOW (val),`
`~TREE_INT_CST_HIGH (val)`	`~TREE_INT_CST_HIGH (val)`
`+ !TREE_INT_CST_LOW (val));`	`+ !TREE_INT_CST_LOW (val));`
`}`	`}`
`/* Would "%x%0x" or "%x%0x" get zero-padding on all`	`/* Would "%x%0x" or "%x%0x" get zero-padding on all`
`systems? */`	`systems? */`
`{`	`{`
`static char format[10]; /* "%x%09999x\0" */`	`static char format[10]; /* "%x%09999x\0" */`
`if (!format[0])`	`if (!format[0])`
`sprintf (format, "%%x%%0%dx", HOST_BITS_PER_INT / 4);`	`sprintf (format, "%%x%%0%dx", HOST_BITS_PER_INT / 4);`
`sprintf (pp_buffer (buffer)->digit_buffer, format,`	`sprintf (pp_buffer (buffer)->digit_buffer, format,`
`TREE_INT_CST_HIGH (val),`	`TREE_INT_CST_HIGH (val),`
`TREE_INT_CST_LOW (val));`	`TREE_INT_CST_LOW (val));`
`pp_string (buffer, pp_buffer (buffer)->digit_buffer);`	`pp_string (buffer, pp_buffer (buffer)->digit_buffer);`
`}`	`}`
`}`	`}`
`else`	`else`
`pp_wide_integer (buffer, TREE_INT_CST_LOW (node));`	`pp_wide_integer (buffer, TREE_INT_CST_LOW (node));`
`break;`	`break;`

`case REAL_CST:`	`case REAL_CST:`
`/* Code copied from print_node. */`	`/* Code copied from print_node. */`
`{`	`{`
`REAL_VALUE_TYPE d;`	`REAL_VALUE_TYPE d;`
`if (TREE_OVERFLOW (node))`	`if (TREE_OVERFLOW (node))`
`pp_string (buffer, " overflow");`	`pp_string (buffer, " overflow");`

`#if !defined(REAL_IS_NOT_DOUBLE) \|\| defined(REAL_ARITHMETIC)`	`#if !defined(REAL_IS_NOT_DOUBLE) \|\| defined(REAL_ARITHMETIC)`
`d = TREE_REAL_CST (node);`	`d = TREE_REAL_CST (node);`
`if (REAL_VALUE_ISINF (d))`	`if (REAL_VALUE_ISINF (d))`
`pp_string (buffer, " Inf");`	`pp_string (buffer, " Inf");`
`else if (REAL_VALUE_ISNAN (d))`	`else if (REAL_VALUE_ISNAN (d))`
`pp_string (buffer, " Nan");`	`pp_string (buffer, " Nan");`
`else`	`else`
`{`	`{`
`char string[100];`	`char string[100];`
`real_to_decimal (string, &d, sizeof (string), 0, 1);`	`real_to_decimal (string, &d, sizeof (string), 0, 1);`
`pp_string (buffer, string);`	`pp_string (buffer, string);`
`}`	`}`
`#else`	`#else`
`{`	`{`
`HOST_WIDE_INT i;`	`HOST_WIDE_INT i;`
`unsigned char p = (unsigned char ) &TREE_REAL_CST (node);`	`unsigned char p = (unsigned char ) &TREE_REAL_CST (node);`
`pp_string (buffer, "0x");`	`pp_string (buffer, "0x");`
`for (i = 0; i < sizeof TREE_REAL_CST (node); i++)`	`for (i = 0; i < sizeof TREE_REAL_CST (node); i++)`
`output_formatted_integer (buffer, "%02x", *p++);`	`output_formatted_integer (buffer, "%02x", *p++);`
`}`	`}`
`#endif`	`#endif`
`break;`	`break;`
`}`	`}`

`case COMPLEX_CST:`	`case COMPLEX_CST:`
`pp_string (buffer, "__complex__ (");`	`pp_string (buffer, "__complex__ (");`
`dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false);`	`dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, TREE_IMAGPART (node), spc, flags, false);`	`dump_generic_node (buffer, TREE_IMAGPART (node), spc, flags, false);`
`pp_string (buffer, ")");`	`pp_string (buffer, ")");`
`break;`	`break;`

`case STRING_CST:`	`case STRING_CST:`
`pp_string (buffer, "\"");`	`pp_string (buffer, "\"");`
`pretty_print_string (buffer, TREE_STRING_POINTER (node));`	`pretty_print_string (buffer, TREE_STRING_POINTER (node));`
`pp_string (buffer, "\"");`	`pp_string (buffer, "\"");`
`break;`	`break;`

`case VECTOR_CST:`	`case VECTOR_CST:`
`{`	`{`
`tree elt;`	`tree elt;`
`pp_string (buffer, "{ ");`	`pp_string (buffer, "{ ");`
`for (elt = TREE_VECTOR_CST_ELTS (node); elt; elt = TREE_CHAIN (elt))`	`for (elt = TREE_VECTOR_CST_ELTS (node); elt; elt = TREE_CHAIN (elt))`
`{`	`{`
`dump_generic_node (buffer, TREE_VALUE (elt), spc, flags, false);`	`dump_generic_node (buffer, TREE_VALUE (elt), spc, flags, false);`
`if (TREE_CHAIN (elt))`	`if (TREE_CHAIN (elt))`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`}`	`}`
`pp_string (buffer, " }");`	`pp_string (buffer, " }");`
`}`	`}`
`break;`	`break;`

`case FUNCTION_TYPE:`	`case FUNCTION_TYPE:`
`break;`	`break;`

`case FUNCTION_DECL:`	`case FUNCTION_DECL:`
`case CONST_DECL:`	`case CONST_DECL:`
`dump_decl_name (buffer, node, flags);`	`dump_decl_name (buffer, node, flags);`
`break;`	`break;`

`case LABEL_DECL:`	`case LABEL_DECL:`
`if (DECL_NAME (node))`	`if (DECL_NAME (node))`
`dump_decl_name (buffer, node, flags);`	`dump_decl_name (buffer, node, flags);`
`else if (LABEL_DECL_UID (node) != -1)`	`else if (LABEL_DECL_UID (node) != -1)`
`pp_printf (buffer, "<L" HOST_WIDE_INT_PRINT_DEC ">",`	`pp_printf (buffer, "<L" HOST_WIDE_INT_PRINT_DEC ">",`
`LABEL_DECL_UID (node));`	`LABEL_DECL_UID (node));`
`else`	`else`
`pp_printf (buffer, "<D%u>", DECL_UID (node));`	`pp_printf (buffer, "<D%u>", DECL_UID (node));`
`break;`	`break;`

`case TYPE_DECL:`	`case TYPE_DECL:`
`if (DECL_IS_BUILTIN (node))`	`if (DECL_IS_BUILTIN (node))`
`{`	`{`
`/* Don't print the declaration of built-in types. */`	`/* Don't print the declaration of built-in types. */`
`break;`	`break;`
`}`	`}`
`if (DECL_NAME (node))`	`if (DECL_NAME (node))`
`dump_decl_name (buffer, node, flags);`	`dump_decl_name (buffer, node, flags);`
`else`	`else`
`{`	`{`
`if ((TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE`	`if ((TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE`
`\|\| TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)`	`\|\| TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)`
`&& TYPE_METHODS (TREE_TYPE (node)))`	`&& TYPE_METHODS (TREE_TYPE (node)))`
`{`	`{`
`/* The type is a c++ class: all structures have at least`	`/* The type is a c++ class: all structures have at least`
`4 methods. */`	`4 methods. */`
`pp_string (buffer, "class ");`	`pp_string (buffer, "class ");`
`dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);`	`dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);`
`}`	`}`
`else`	`else`
`{`	`{`
`pp_string (buffer,`	`pp_string (buffer,`
`(TREE_CODE (TREE_TYPE (node)) == UNION_TYPE`	`(TREE_CODE (TREE_TYPE (node)) == UNION_TYPE`
`? "union" : "struct "));`	`? "union" : "struct "));`
`dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);`	`dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);`
`}`	`}`
`}`	`}`
`break;`	`break;`

`case SYMBOL_MEMORY_TAG:`	`case SYMBOL_MEMORY_TAG:`
`case NAME_MEMORY_TAG:`	`case NAME_MEMORY_TAG:`
`case STRUCT_FIELD_TAG:`	`case STRUCT_FIELD_TAG:`
`case VAR_DECL:`	`case VAR_DECL:`
`case PARM_DECL:`	`case PARM_DECL:`
`case FIELD_DECL:`	`case FIELD_DECL:`
`case NAMESPACE_DECL:`	`case NAMESPACE_DECL:`
`dump_decl_name (buffer, node, flags);`	`dump_decl_name (buffer, node, flags);`
`break;`	`break;`

`case RESULT_DECL:`	`case RESULT_DECL:`
`pp_string (buffer, "<retval>");`	`pp_string (buffer, "<retval>");`
`break;`	`break;`

`case COMPONENT_REF:`	`case COMPONENT_REF:`
`op0 = TREE_OPERAND (node, 0);`	`op0 = TREE_OPERAND (node, 0);`
`str = ".";`	`str = ".";`
`if (TREE_CODE (op0) == INDIRECT_REF)`	`if (TREE_CODE (op0) == INDIRECT_REF)`
`{`	`{`
`op0 = TREE_OPERAND (op0, 0);`	`op0 = TREE_OPERAND (op0, 0);`
`str = "->";`	`str = "->";`
`}`	`}`
`if (op_prio (op0) < op_prio (node))`	`if (op_prio (op0) < op_prio (node))`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`
`dump_generic_node (buffer, op0, spc, flags, false);`	`dump_generic_node (buffer, op0, spc, flags, false);`
`if (op_prio (op0) < op_prio (node))`	`if (op_prio (op0) < op_prio (node))`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`pp_string (buffer, str);`	`pp_string (buffer, str);`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`

`if (TREE_CODE (op0) != VALUE_HANDLE)`	`if (TREE_CODE (op0) != VALUE_HANDLE)`
`{`	`{`
`op0 = component_ref_field_offset (node);`	`op0 = component_ref_field_offset (node);`
`if (op0 && TREE_CODE (op0) != INTEGER_CST)`	`if (op0 && TREE_CODE (op0) != INTEGER_CST)`
`{`	`{`
`pp_string (buffer, "{off: ");`	`pp_string (buffer, "{off: ");`
`dump_generic_node (buffer, op0, spc, flags, false);`	`dump_generic_node (buffer, op0, spc, flags, false);`
`pp_character (buffer, '}');`	`pp_character (buffer, '}');`
`}`	`}`
`}`	`}`
`break;`	`break;`

`case BIT_FIELD_REF:`	`case BIT_FIELD_REF:`
`pp_string (buffer, "BIT_FIELD_REF <");`	`pp_string (buffer, "BIT_FIELD_REF <");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);`
`pp_string (buffer, ">");`	`pp_string (buffer, ">");`
`break;`	`break;`

`case ARRAY_REF:`	`case ARRAY_REF:`
`case ARRAY_RANGE_REF:`	`case ARRAY_RANGE_REF:`
`op0 = TREE_OPERAND (node, 0);`	`op0 = TREE_OPERAND (node, 0);`
`if (op_prio (op0) < op_prio (node))`	`if (op_prio (op0) < op_prio (node))`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`
`dump_generic_node (buffer, op0, spc, flags, false);`	`dump_generic_node (buffer, op0, spc, flags, false);`
`if (op_prio (op0) < op_prio (node))`	`if (op_prio (op0) < op_prio (node))`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`pp_character (buffer, '[');`	`pp_character (buffer, '[');`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`if (TREE_CODE (node) == ARRAY_RANGE_REF)`	`if (TREE_CODE (node) == ARRAY_RANGE_REF)`
`pp_string (buffer, " ...");`	`pp_string (buffer, " ...");`
`pp_character (buffer, ']');`	`pp_character (buffer, ']');`

`op0 = array_ref_low_bound (node);`	`op0 = array_ref_low_bound (node);`
`op1 = array_ref_element_size (node);`	`op1 = array_ref_element_size (node);`

`if (!integer_zerop (op0)`	`if (!integer_zerop (op0)`
`\|\| (TYPE_SIZE_UNIT (TREE_TYPE (node))`	`\|\| (TYPE_SIZE_UNIT (TREE_TYPE (node))`
`&& !operand_equal_p (op1, TYPE_SIZE_UNIT (TREE_TYPE (node)), 0)))`	`&& !operand_equal_p (op1, TYPE_SIZE_UNIT (TREE_TYPE (node)), 0)))`
`{`	`{`
`pp_string (buffer, "{lb: ");`	`pp_string (buffer, "{lb: ");`
`dump_generic_node (buffer, op0, spc, flags, false);`	`dump_generic_node (buffer, op0, spc, flags, false);`
`pp_string (buffer, " sz: ");`	`pp_string (buffer, " sz: ");`
`dump_generic_node (buffer, op1, spc, flags, false);`	`dump_generic_node (buffer, op1, spc, flags, false);`
`pp_character (buffer, '}');`	`pp_character (buffer, '}');`
`}`	`}`
`break;`	`break;`

`case CONSTRUCTOR:`	`case CONSTRUCTOR:`
`{`	`{`
`unsigned HOST_WIDE_INT ix;`	`unsigned HOST_WIDE_INT ix;`
`tree field, val;`	`tree field, val;`
`bool is_struct_init = FALSE;`	`bool is_struct_init = FALSE;`
`pp_character (buffer, '{');`	`pp_character (buffer, '{');`
`if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE`	`if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE`
`\|\| TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)`	`\|\| TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)`
`is_struct_init = TRUE;`	`is_struct_init = TRUE;`
`FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)`	`FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)`
`{`	`{`
`if (field && is_struct_init)`	`if (field && is_struct_init)`
`{`	`{`
`pp_character (buffer, '.');`	`pp_character (buffer, '.');`
`dump_generic_node (buffer, field, spc, flags, false);`	`dump_generic_node (buffer, field, spc, flags, false);`
`pp_string (buffer, "=");`	`pp_string (buffer, "=");`
`}`	`}`
`if (val && TREE_CODE (val) == ADDR_EXPR)`	`if (val && TREE_CODE (val) == ADDR_EXPR)`
`if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)`	`if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)`
`val = TREE_OPERAND (val, 0);`	`val = TREE_OPERAND (val, 0);`
`if (val && TREE_CODE (val) == FUNCTION_DECL)`	`if (val && TREE_CODE (val) == FUNCTION_DECL)`
`dump_decl_name (buffer, val, flags);`	`dump_decl_name (buffer, val, flags);`
`else`	`else`
`dump_generic_node (buffer, val, spc, flags, false);`	`dump_generic_node (buffer, val, spc, flags, false);`
`if (ix != VEC_length (constructor_elt, CONSTRUCTOR_ELTS (node)) - 1)`	`if (ix != VEC_length (constructor_elt, CONSTRUCTOR_ELTS (node)) - 1)`
`{`	`{`
`pp_character (buffer, ',');`	`pp_character (buffer, ',');`
`pp_space (buffer);`	`pp_space (buffer);`
`}`	`}`
`}`	`}`
`pp_character (buffer, '}');`	`pp_character (buffer, '}');`
`}`	`}`
`break;`	`break;`

`case COMPOUND_EXPR:`	`case COMPOUND_EXPR:`
`{`	`{`
`tree *tp;`	`tree *tp;`
`if (flags & TDF_SLIM)`	`if (flags & TDF_SLIM)`
`{`	`{`
`pp_string (buffer, "<COMPOUND_EXPR>");`	`pp_string (buffer, "<COMPOUND_EXPR>");`
`break;`	`break;`
`}`	`}`

`dump_generic_node (buffer, TREE_OPERAND (node, 0),`	`dump_generic_node (buffer, TREE_OPERAND (node, 0),`
`spc, flags, !(flags & TDF_SLIM));`	`spc, flags, !(flags & TDF_SLIM));`
`if (flags & TDF_SLIM)`	`if (flags & TDF_SLIM)`
`newline_and_indent (buffer, spc);`	`newline_and_indent (buffer, spc);`
`else`	`else`
`{`	`{`
`pp_character (buffer, ',');`	`pp_character (buffer, ',');`
`pp_space (buffer);`	`pp_space (buffer);`
`}`	`}`

`for (tp = &TREE_OPERAND (node, 1);`	`for (tp = &TREE_OPERAND (node, 1);`
`TREE_CODE (*tp) == COMPOUND_EXPR;`	`TREE_CODE (*tp) == COMPOUND_EXPR;`
`tp = &TREE_OPERAND (*tp, 1))`	`tp = &TREE_OPERAND (*tp, 1))`
`{`	`{`
`dump_generic_node (buffer, TREE_OPERAND (*tp, 0),`	`dump_generic_node (buffer, TREE_OPERAND (*tp, 0),`
`spc, flags, !(flags & TDF_SLIM));`	`spc, flags, !(flags & TDF_SLIM));`
`if (flags & TDF_SLIM)`	`if (flags & TDF_SLIM)`
`newline_and_indent (buffer, spc);`	`newline_and_indent (buffer, spc);`
`else`	`else`
`{`	`{`
`pp_character (buffer, ',');`	`pp_character (buffer, ',');`
`pp_space (buffer);`	`pp_space (buffer);`
`}`	`}`
`}`	`}`

`dump_generic_node (buffer, *tp, spc, flags, !(flags & TDF_SLIM));`	`dump_generic_node (buffer, *tp, spc, flags, !(flags & TDF_SLIM));`
`}`	`}`
`break;`	`break;`

`case STATEMENT_LIST:`	`case STATEMENT_LIST:`
`{`	`{`
`tree_stmt_iterator si;`	`tree_stmt_iterator si;`
`bool first = true;`	`bool first = true;`

`if (flags & TDF_SLIM)`	`if (flags & TDF_SLIM)`
`{`	`{`
`pp_string (buffer, "<STATEMENT_LIST>");`	`pp_string (buffer, "<STATEMENT_LIST>");`
`break;`	`break;`
`}`	`}`

`for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))`	`for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))`
`{`	`{`
`if (!first)`	`if (!first)`
`newline_and_indent (buffer, spc);`	`newline_and_indent (buffer, spc);`
`else`	`else`
`first = false;`	`first = false;`
`dump_generic_node (buffer, tsi_stmt (si), spc, flags, true);`	`dump_generic_node (buffer, tsi_stmt (si), spc, flags, true);`
`}`	`}`
`}`	`}`
`break;`	`break;`

`case MODIFY_EXPR:`	`case MODIFY_EXPR:`
`case INIT_EXPR:`	`case INIT_EXPR:`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_space (buffer);`	`pp_space (buffer);`
`pp_character (buffer, '=');`	`pp_character (buffer, '=');`
`pp_space (buffer);`	`pp_space (buffer);`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`break;`	`break;`

`case TARGET_EXPR:`	`case TARGET_EXPR:`
`pp_string (buffer, "TARGET_EXPR <");`	`pp_string (buffer, "TARGET_EXPR <");`
`dump_generic_node (buffer, TARGET_EXPR_SLOT (node), spc, flags, false);`	`dump_generic_node (buffer, TARGET_EXPR_SLOT (node), spc, flags, false);`
`pp_character (buffer, ',');`	`pp_character (buffer, ',');`
`pp_space (buffer);`	`pp_space (buffer);`
`dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false);`	`dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false);`
`pp_character (buffer, '>');`	`pp_character (buffer, '>');`
`break;`	`break;`

`case DECL_EXPR:`	`case DECL_EXPR:`
`print_declaration (buffer, DECL_EXPR_DECL (node), spc, flags);`	`print_declaration (buffer, DECL_EXPR_DECL (node), spc, flags);`
`is_stmt = false;`	`is_stmt = false;`
`break;`	`break;`

`case COND_EXPR:`	`case COND_EXPR:`
`if (TREE_TYPE (node) == NULL \|\| TREE_TYPE (node) == void_type_node)`	`if (TREE_TYPE (node) == NULL \|\| TREE_TYPE (node) == void_type_node)`
`{`	`{`
`pp_string (buffer, "if (");`	`pp_string (buffer, "if (");`
`dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false);`	`dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`/* The lowered cond_exprs should always be printed in full. */`	`/* The lowered cond_exprs should always be printed in full. */`
`if (COND_EXPR_THEN (node)`	`if (COND_EXPR_THEN (node)`
`&& (IS_EMPTY_STMT (COND_EXPR_THEN (node))`	`&& (IS_EMPTY_STMT (COND_EXPR_THEN (node))`
`\|\| TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)`	`\|\| TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)`
`&& COND_EXPR_ELSE (node)`	`&& COND_EXPR_ELSE (node)`
`&& (IS_EMPTY_STMT (COND_EXPR_ELSE (node))`	`&& (IS_EMPTY_STMT (COND_EXPR_ELSE (node))`
`\|\| TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))`	`\|\| TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))`
`{`	`{`
`pp_space (buffer);`	`pp_space (buffer);`
`dump_generic_node (buffer, COND_EXPR_THEN (node), 0, flags, true);`	`dump_generic_node (buffer, COND_EXPR_THEN (node), 0, flags, true);`
`pp_string (buffer, " else ");`	`pp_string (buffer, " else ");`
`dump_generic_node (buffer, COND_EXPR_ELSE (node), 0, flags, true);`	`dump_generic_node (buffer, COND_EXPR_ELSE (node), 0, flags, true);`
`}`	`}`
`else if (!(flags & TDF_SLIM))`	`else if (!(flags & TDF_SLIM))`
`{`	`{`
`/* Output COND_EXPR_THEN. */`	`/* Output COND_EXPR_THEN. */`
`if (COND_EXPR_THEN (node))`	`if (COND_EXPR_THEN (node))`
`{`	`{`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_character (buffer, '{');`	`pp_character (buffer, '{');`
`newline_and_indent (buffer, spc+4);`	`newline_and_indent (buffer, spc+4);`
`dump_generic_node (buffer, COND_EXPR_THEN (node), spc+4,`	`dump_generic_node (buffer, COND_EXPR_THEN (node), spc+4,`
`flags, true);`	`flags, true);`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_character (buffer, '}');`	`pp_character (buffer, '}');`
`}`	`}`

`/* Output COND_EXPR_ELSE. */`	`/* Output COND_EXPR_ELSE. */`
`if (COND_EXPR_ELSE (node))`	`if (COND_EXPR_ELSE (node))`
`{`	`{`
`newline_and_indent (buffer, spc);`	`newline_and_indent (buffer, spc);`
`pp_string (buffer, "else");`	`pp_string (buffer, "else");`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_character (buffer, '{');`	`pp_character (buffer, '{');`
`newline_and_indent (buffer, spc+4);`	`newline_and_indent (buffer, spc+4);`
`dump_generic_node (buffer, COND_EXPR_ELSE (node), spc+4,`	`dump_generic_node (buffer, COND_EXPR_ELSE (node), spc+4,`
`flags, true);`	`flags, true);`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_character (buffer, '}');`	`pp_character (buffer, '}');`
`}`	`}`
`}`	`}`
`is_expr = false;`	`is_expr = false;`
`}`	`}`
`else`	`else`
`{`	`{`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_space (buffer);`	`pp_space (buffer);`
`pp_character (buffer, '?');`	`pp_character (buffer, '?');`
`pp_space (buffer);`	`pp_space (buffer);`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`pp_space (buffer);`	`pp_space (buffer);`
`pp_character (buffer, ':');`	`pp_character (buffer, ':');`
`pp_space (buffer);`	`pp_space (buffer);`
`dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);`
`}`	`}`
`break;`	`break;`

`case BIND_EXPR:`	`case BIND_EXPR:`
`pp_character (buffer, '{');`	`pp_character (buffer, '{');`
`if (!(flags & TDF_SLIM))`	`if (!(flags & TDF_SLIM))`
`{`	`{`
`if (BIND_EXPR_VARS (node))`	`if (BIND_EXPR_VARS (node))`
`{`	`{`
`pp_newline (buffer);`	`pp_newline (buffer);`

`for (op0 = BIND_EXPR_VARS (node); op0; op0 = TREE_CHAIN (op0))`	`for (op0 = BIND_EXPR_VARS (node); op0; op0 = TREE_CHAIN (op0))`
`{`	`{`
`print_declaration (buffer, op0, spc+2, flags);`	`print_declaration (buffer, op0, spc+2, flags);`
`pp_newline (buffer);`	`pp_newline (buffer);`
`}`	`}`
`}`	`}`

`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`dump_generic_node (buffer, BIND_EXPR_BODY (node), spc+2, flags, true);`	`dump_generic_node (buffer, BIND_EXPR_BODY (node), spc+2, flags, true);`
`newline_and_indent (buffer, spc);`	`newline_and_indent (buffer, spc);`
`pp_character (buffer, '}');`	`pp_character (buffer, '}');`
`}`	`}`
`is_expr = false;`	`is_expr = false;`
`break;`	`break;`

`case CALL_EXPR:`	`case CALL_EXPR:`
`print_call_name (buffer, node);`	`print_call_name (buffer, node);`

`/* Print parameters. */`	`/* Print parameters. */`
`pp_space (buffer);`	`pp_space (buffer);`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`
`op1 = TREE_OPERAND (node, 1);`	`op1 = TREE_OPERAND (node, 1);`
`if (op1)`	`if (op1)`
`dump_generic_node (buffer, op1, spc, flags, false);`	`dump_generic_node (buffer, op1, spc, flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`

`op1 = TREE_OPERAND (node, 2);`	`op1 = TREE_OPERAND (node, 2);`
`if (op1)`	`if (op1)`
`{`	`{`
`pp_string (buffer, " [static-chain: ");`	`pp_string (buffer, " [static-chain: ");`
`dump_generic_node (buffer, op1, spc, flags, false);`	`dump_generic_node (buffer, op1, spc, flags, false);`
`pp_character (buffer, ']');`	`pp_character (buffer, ']');`
`}`	`}`

`if (CALL_EXPR_RETURN_SLOT_OPT (node))`	`if (CALL_EXPR_RETURN_SLOT_OPT (node))`
`pp_string (buffer, " [return slot optimization]");`	`pp_string (buffer, " [return slot optimization]");`
`if (CALL_EXPR_TAILCALL (node))`	`if (CALL_EXPR_TAILCALL (node))`
`pp_string (buffer, " [tail call]");`	`pp_string (buffer, " [tail call]");`
`break;`	`break;`

`case WITH_CLEANUP_EXPR:`	`case WITH_CLEANUP_EXPR:`
`NIY;`	`NIY;`
`break;`	`break;`

`case CLEANUP_POINT_EXPR:`	`case CLEANUP_POINT_EXPR:`
`pp_string (buffer, "<<cleanup_point ");`	`pp_string (buffer, "<<cleanup_point ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ">>");`	`pp_string (buffer, ">>");`
`break;`	`break;`

`case PLACEHOLDER_EXPR:`	`case PLACEHOLDER_EXPR:`
`pp_string (buffer, "<PLACEHOLDER_EXPR ");`	`pp_string (buffer, "<PLACEHOLDER_EXPR ");`
`dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);`	`dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);`
`pp_character (buffer, '>');`	`pp_character (buffer, '>');`
`break;`	`break;`

`/* Binary arithmetic and logic expressions. */`	`/* Binary arithmetic and logic expressions. */`
`case WIDEN_SUM_EXPR:`	`case WIDEN_SUM_EXPR:`
`case WIDEN_MULT_EXPR:`	`case WIDEN_MULT_EXPR:`
`case MULT_EXPR:`	`case MULT_EXPR:`
`case PLUS_EXPR:`	`case PLUS_EXPR:`
`case MINUS_EXPR:`	`case MINUS_EXPR:`
`case TRUNC_DIV_EXPR:`	`case TRUNC_DIV_EXPR:`
`case CEIL_DIV_EXPR:`	`case CEIL_DIV_EXPR:`
`case FLOOR_DIV_EXPR:`	`case FLOOR_DIV_EXPR:`
`case ROUND_DIV_EXPR:`	`case ROUND_DIV_EXPR:`
`case TRUNC_MOD_EXPR:`	`case TRUNC_MOD_EXPR:`
`case CEIL_MOD_EXPR:`	`case CEIL_MOD_EXPR:`
`case FLOOR_MOD_EXPR:`	`case FLOOR_MOD_EXPR:`
`case ROUND_MOD_EXPR:`	`case ROUND_MOD_EXPR:`
`case RDIV_EXPR:`	`case RDIV_EXPR:`
`case EXACT_DIV_EXPR:`	`case EXACT_DIV_EXPR:`
`case LSHIFT_EXPR:`	`case LSHIFT_EXPR:`
`case RSHIFT_EXPR:`	`case RSHIFT_EXPR:`
`case LROTATE_EXPR:`	`case LROTATE_EXPR:`
`case RROTATE_EXPR:`	`case RROTATE_EXPR:`
`case VEC_LSHIFT_EXPR:`	`case VEC_LSHIFT_EXPR:`
`case VEC_RSHIFT_EXPR:`	`case VEC_RSHIFT_EXPR:`
`case BIT_IOR_EXPR:`	`case BIT_IOR_EXPR:`
`case BIT_XOR_EXPR:`	`case BIT_XOR_EXPR:`
`case BIT_AND_EXPR:`	`case BIT_AND_EXPR:`
`case TRUTH_ANDIF_EXPR:`	`case TRUTH_ANDIF_EXPR:`
`case TRUTH_ORIF_EXPR:`	`case TRUTH_ORIF_EXPR:`
`case TRUTH_AND_EXPR:`	`case TRUTH_AND_EXPR:`
`case TRUTH_OR_EXPR:`	`case TRUTH_OR_EXPR:`
`case TRUTH_XOR_EXPR:`	`case TRUTH_XOR_EXPR:`
`case LT_EXPR:`	`case LT_EXPR:`
`case LE_EXPR:`	`case LE_EXPR:`
`case GT_EXPR:`	`case GT_EXPR:`
`case GE_EXPR:`	`case GE_EXPR:`
`case EQ_EXPR:`	`case EQ_EXPR:`
`case NE_EXPR:`	`case NE_EXPR:`
`case UNLT_EXPR:`	`case UNLT_EXPR:`
`case UNLE_EXPR:`	`case UNLE_EXPR:`
`case UNGT_EXPR:`	`case UNGT_EXPR:`
`case UNGE_EXPR:`	`case UNGE_EXPR:`
`case UNEQ_EXPR:`	`case UNEQ_EXPR:`
`case LTGT_EXPR:`	`case LTGT_EXPR:`
`case ORDERED_EXPR:`	`case ORDERED_EXPR:`
`case UNORDERED_EXPR:`	`case UNORDERED_EXPR:`
`{`	`{`
`const char *op = op_symbol (node);`	`const char *op = op_symbol (node);`
`op0 = TREE_OPERAND (node, 0);`	`op0 = TREE_OPERAND (node, 0);`
`op1 = TREE_OPERAND (node, 1);`	`op1 = TREE_OPERAND (node, 1);`

`/* When the operands are expressions with less priority,`	`/* When the operands are expressions with less priority,`
`keep semantics of the tree representation. */`	`keep semantics of the tree representation. */`
`if (op_prio (op0) < op_prio (node))`	`if (op_prio (op0) < op_prio (node))`
`{`	`{`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`
`dump_generic_node (buffer, op0, spc, flags, false);`	`dump_generic_node (buffer, op0, spc, flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`}`	`}`
`else`	`else`
`dump_generic_node (buffer, op0, spc, flags, false);`	`dump_generic_node (buffer, op0, spc, flags, false);`

`pp_space (buffer);`	`pp_space (buffer);`
`pp_string (buffer, op);`	`pp_string (buffer, op);`
`pp_space (buffer);`	`pp_space (buffer);`

`/* When the operands are expressions with less priority,`	`/* When the operands are expressions with less priority,`
`keep semantics of the tree representation. */`	`keep semantics of the tree representation. */`
`if (op_prio (op1) < op_prio (node))`	`if (op_prio (op1) < op_prio (node))`
`{`	`{`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`
`dump_generic_node (buffer, op1, spc, flags, false);`	`dump_generic_node (buffer, op1, spc, flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`}`	`}`
`else`	`else`
`dump_generic_node (buffer, op1, spc, flags, false);`	`dump_generic_node (buffer, op1, spc, flags, false);`
`}`	`}`
`break;`	`break;`

`/* Unary arithmetic and logic expressions. */`	`/* Unary arithmetic and logic expressions. */`
`case NEGATE_EXPR:`	`case NEGATE_EXPR:`
`case BIT_NOT_EXPR:`	`case BIT_NOT_EXPR:`
`case TRUTH_NOT_EXPR:`	`case TRUTH_NOT_EXPR:`
`case ADDR_EXPR:`	`case ADDR_EXPR:`
`case PREDECREMENT_EXPR:`	`case PREDECREMENT_EXPR:`
`case PREINCREMENT_EXPR:`	`case PREINCREMENT_EXPR:`
`case ALIGN_INDIRECT_REF:`	`case ALIGN_INDIRECT_REF:`
`case MISALIGNED_INDIRECT_REF:`	`case MISALIGNED_INDIRECT_REF:`
`case INDIRECT_REF:`	`case INDIRECT_REF:`
`if (TREE_CODE (node) == ADDR_EXPR`	`if (TREE_CODE (node) == ADDR_EXPR`
`&& (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST`	`&& (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST`
`\|\| TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))`	`\|\| TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))`
`; /* Do not output '&' for strings and function pointers. */`	`; /* Do not output '&' for strings and function pointers. */`
`else`	`else`
`pp_string (buffer, op_symbol (node));`	`pp_string (buffer, op_symbol (node));`

`if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))`	`if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))`
`{`	`{`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`}`	`}`
`else`	`else`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`

`if (TREE_CODE (node) == MISALIGNED_INDIRECT_REF)`	`if (TREE_CODE (node) == MISALIGNED_INDIRECT_REF)`
`{`	`{`
`pp_string (buffer, "{misalignment: ");`	`pp_string (buffer, "{misalignment: ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`pp_character (buffer, '}');`	`pp_character (buffer, '}');`
`}`	`}`
`break;`	`break;`

`case POSTDECREMENT_EXPR:`	`case POSTDECREMENT_EXPR:`
`case POSTINCREMENT_EXPR:`	`case POSTINCREMENT_EXPR:`
`if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))`	`if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))`
`{`	`{`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`}`	`}`
`else`	`else`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, op_symbol (node));`	`pp_string (buffer, op_symbol (node));`
`break;`	`break;`

`case MIN_EXPR:`	`case MIN_EXPR:`
`pp_string (buffer, "MIN_EXPR <");`	`pp_string (buffer, "MIN_EXPR <");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`pp_character (buffer, '>');`	`pp_character (buffer, '>');`
`break;`	`break;`

`case MAX_EXPR:`	`case MAX_EXPR:`
`pp_string (buffer, "MAX_EXPR <");`	`pp_string (buffer, "MAX_EXPR <");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`pp_character (buffer, '>');`	`pp_character (buffer, '>');`
`break;`	`break;`

`case ABS_EXPR:`	`case ABS_EXPR:`
`pp_string (buffer, "ABS_EXPR <");`	`pp_string (buffer, "ABS_EXPR <");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_character (buffer, '>');`	`pp_character (buffer, '>');`
`break;`	`break;`

`case RANGE_EXPR:`	`case RANGE_EXPR:`
`NIY;`	`NIY;`
`break;`	`break;`

`case FIX_TRUNC_EXPR:`	`case FIX_TRUNC_EXPR:`
`case FIX_CEIL_EXPR:`	`case FIX_CEIL_EXPR:`
`case FIX_FLOOR_EXPR:`	`case FIX_FLOOR_EXPR:`
`case FIX_ROUND_EXPR:`	`case FIX_ROUND_EXPR:`
`case FLOAT_EXPR:`	`case FLOAT_EXPR:`
`case CONVERT_EXPR:`	`case CONVERT_EXPR:`
`case NOP_EXPR:`	`case NOP_EXPR:`
`type = TREE_TYPE (node);`	`type = TREE_TYPE (node);`
`op0 = TREE_OPERAND (node, 0);`	`op0 = TREE_OPERAND (node, 0);`
`if (type != TREE_TYPE (op0))`	`if (type != TREE_TYPE (op0))`
`{`	`{`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`
`dump_generic_node (buffer, type, spc, flags, false);`	`dump_generic_node (buffer, type, spc, flags, false);`
`pp_string (buffer, ") ");`	`pp_string (buffer, ") ");`
`}`	`}`
`if (op_prio (op0) < op_prio (node))`	`if (op_prio (op0) < op_prio (node))`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`
`dump_generic_node (buffer, op0, spc, flags, false);`	`dump_generic_node (buffer, op0, spc, flags, false);`
`if (op_prio (op0) < op_prio (node))`	`if (op_prio (op0) < op_prio (node))`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`break;`	`break;`

`case VIEW_CONVERT_EXPR:`	`case VIEW_CONVERT_EXPR:`
`pp_string (buffer, "VIEW_CONVERT_EXPR<");`	`pp_string (buffer, "VIEW_CONVERT_EXPR<");`
`dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);`	`dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);`
`pp_string (buffer, ">(");`	`pp_string (buffer, ">(");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`break;`	`break;`

`case NON_LVALUE_EXPR:`	`case NON_LVALUE_EXPR:`
`pp_string (buffer, "NON_LVALUE_EXPR <");`	`pp_string (buffer, "NON_LVALUE_EXPR <");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_character (buffer, '>');`	`pp_character (buffer, '>');`
`break;`	`break;`

`case SAVE_EXPR:`	`case SAVE_EXPR:`
`pp_string (buffer, "SAVE_EXPR <");`	`pp_string (buffer, "SAVE_EXPR <");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_character (buffer, '>');`	`pp_character (buffer, '>');`
`break;`	`break;`

`case COMPLEX_EXPR:`	`case COMPLEX_EXPR:`
`pp_string (buffer, "COMPLEX_EXPR <");`	`pp_string (buffer, "COMPLEX_EXPR <");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`pp_string (buffer, ">");`	`pp_string (buffer, ">");`
`break;`	`break;`

`case CONJ_EXPR:`	`case CONJ_EXPR:`
`pp_string (buffer, "CONJ_EXPR <");`	`pp_string (buffer, "CONJ_EXPR <");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ">");`	`pp_string (buffer, ">");`
`break;`	`break;`

`case REALPART_EXPR:`	`case REALPART_EXPR:`
`pp_string (buffer, "REALPART_EXPR <");`	`pp_string (buffer, "REALPART_EXPR <");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ">");`	`pp_string (buffer, ">");`
`break;`	`break;`

`case IMAGPART_EXPR:`	`case IMAGPART_EXPR:`
`pp_string (buffer, "IMAGPART_EXPR <");`	`pp_string (buffer, "IMAGPART_EXPR <");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ">");`	`pp_string (buffer, ">");`
`break;`	`break;`

`case VA_ARG_EXPR:`	`case VA_ARG_EXPR:`
`pp_string (buffer, "VA_ARG_EXPR <");`	`pp_string (buffer, "VA_ARG_EXPR <");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ">");`	`pp_string (buffer, ">");`
`break;`	`break;`

`case TRY_FINALLY_EXPR:`	`case TRY_FINALLY_EXPR:`
`case TRY_CATCH_EXPR:`	`case TRY_CATCH_EXPR:`
`pp_string (buffer, "try");`	`pp_string (buffer, "try");`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_string (buffer, "{");`	`pp_string (buffer, "{");`
`newline_and_indent (buffer, spc+4);`	`newline_and_indent (buffer, spc+4);`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc+4, flags, true);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc+4, flags, true);`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_string (buffer, "}");`	`pp_string (buffer, "}");`
`newline_and_indent (buffer, spc);`	`newline_and_indent (buffer, spc);`
`pp_string (buffer,`	`pp_string (buffer,`
`(TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");`	`(TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_string (buffer, "{");`	`pp_string (buffer, "{");`
`newline_and_indent (buffer, spc+4);`	`newline_and_indent (buffer, spc+4);`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc+4, flags, true);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc+4, flags, true);`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_string (buffer, "}");`	`pp_string (buffer, "}");`
`is_expr = false;`	`is_expr = false;`
`break;`	`break;`

`case CATCH_EXPR:`	`case CATCH_EXPR:`
`pp_string (buffer, "catch (");`	`pp_string (buffer, "catch (");`
`dump_generic_node (buffer, CATCH_TYPES (node), spc+2, flags, false);`	`dump_generic_node (buffer, CATCH_TYPES (node), spc+2, flags, false);`
`pp_string (buffer, ")");`	`pp_string (buffer, ")");`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_string (buffer, "{");`	`pp_string (buffer, "{");`
`newline_and_indent (buffer, spc+4);`	`newline_and_indent (buffer, spc+4);`
`dump_generic_node (buffer, CATCH_BODY (node), spc+4, flags, true);`	`dump_generic_node (buffer, CATCH_BODY (node), spc+4, flags, true);`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_string (buffer, "}");`	`pp_string (buffer, "}");`
`is_expr = false;`	`is_expr = false;`
`break;`	`break;`

`case EH_FILTER_EXPR:`	`case EH_FILTER_EXPR:`
`pp_string (buffer, "<<<eh_filter (");`	`pp_string (buffer, "<<<eh_filter (");`
`dump_generic_node (buffer, EH_FILTER_TYPES (node), spc+2, flags, false);`	`dump_generic_node (buffer, EH_FILTER_TYPES (node), spc+2, flags, false);`
`pp_string (buffer, ")>>>");`	`pp_string (buffer, ")>>>");`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_string (buffer, "{");`	`pp_string (buffer, "{");`
`newline_and_indent (buffer, spc+4);`	`newline_and_indent (buffer, spc+4);`
`dump_generic_node (buffer, EH_FILTER_FAILURE (node), spc+4, flags, true);`	`dump_generic_node (buffer, EH_FILTER_FAILURE (node), spc+4, flags, true);`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_string (buffer, "}");`	`pp_string (buffer, "}");`
`is_expr = false;`	`is_expr = false;`
`break;`	`break;`

`case LABEL_EXPR:`	`case LABEL_EXPR:`
`op0 = TREE_OPERAND (node, 0);`	`op0 = TREE_OPERAND (node, 0);`
`/* If this is for break or continue, don't bother printing it. */`	`/* If this is for break or continue, don't bother printing it. */`
`if (DECL_NAME (op0))`	`if (DECL_NAME (op0))`
`{`	`{`
`const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));`	`const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));`
`if (strcmp (name, "break") == 0`	`if (strcmp (name, "break") == 0`
`\|\| strcmp (name, "continue") == 0)`	`\|\| strcmp (name, "continue") == 0)`
`break;`	`break;`
`}`	`}`
`dump_generic_node (buffer, op0, spc, flags, false);`	`dump_generic_node (buffer, op0, spc, flags, false);`
`pp_character (buffer, ':');`	`pp_character (buffer, ':');`
`if (DECL_NONLOCAL (op0))`	`if (DECL_NONLOCAL (op0))`
`pp_string (buffer, " [non-local]");`	`pp_string (buffer, " [non-local]");`
`break;`	`break;`

`case EXC_PTR_EXPR:`	`case EXC_PTR_EXPR:`
`pp_string (buffer, "<<<exception object>>>");`	`pp_string (buffer, "<<<exception object>>>");`
`break;`	`break;`

`case FILTER_EXPR:`	`case FILTER_EXPR:`
`pp_string (buffer, "<<<filter object>>>");`	`pp_string (buffer, "<<<filter object>>>");`
`break;`	`break;`

`case LOOP_EXPR:`	`case LOOP_EXPR:`
`pp_string (buffer, "while (1)");`	`pp_string (buffer, "while (1)");`
`if (!(flags & TDF_SLIM))`	`if (!(flags & TDF_SLIM))`
`{`	`{`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_character (buffer, '{');`	`pp_character (buffer, '{');`
`newline_and_indent (buffer, spc+4);`	`newline_and_indent (buffer, spc+4);`
`dump_generic_node (buffer, LOOP_EXPR_BODY (node), spc+4, flags, true);`	`dump_generic_node (buffer, LOOP_EXPR_BODY (node), spc+4, flags, true);`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_character (buffer, '}');`	`pp_character (buffer, '}');`
`}`	`}`
`is_expr = false;`	`is_expr = false;`
`break;`	`break;`

`case RETURN_EXPR:`	`case RETURN_EXPR:`
`pp_string (buffer, "return");`	`pp_string (buffer, "return");`
`op0 = TREE_OPERAND (node, 0);`	`op0 = TREE_OPERAND (node, 0);`
`if (op0)`	`if (op0)`
`{`	`{`
`pp_space (buffer);`	`pp_space (buffer);`
`if (TREE_CODE (op0) == MODIFY_EXPR)`	`if (TREE_CODE (op0) == MODIFY_EXPR)`
`dump_generic_node (buffer, TREE_OPERAND (op0, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (op0, 1), spc, flags, false);`
`else`	`else`
`dump_generic_node (buffer, op0, spc, flags, false);`	`dump_generic_node (buffer, op0, spc, flags, false);`
`}`	`}`
`break;`	`break;`

`case EXIT_EXPR:`	`case EXIT_EXPR:`
`pp_string (buffer, "if (");`	`pp_string (buffer, "if (");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ") break");`	`pp_string (buffer, ") break");`
`break;`	`break;`

`case SWITCH_EXPR:`	`case SWITCH_EXPR:`
`pp_string (buffer, "switch (");`	`pp_string (buffer, "switch (");`
`dump_generic_node (buffer, SWITCH_COND (node), spc, flags, false);`	`dump_generic_node (buffer, SWITCH_COND (node), spc, flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`if (!(flags & TDF_SLIM))`	`if (!(flags & TDF_SLIM))`
`{`	`{`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_character (buffer, '{');`	`pp_character (buffer, '{');`
`if (SWITCH_BODY (node))`	`if (SWITCH_BODY (node))`
`{`	`{`
`newline_and_indent (buffer, spc+4);`	`newline_and_indent (buffer, spc+4);`
`dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags,`	`dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags,`
`true);`	`true);`
`}`	`}`
`else`	`else`
`{`	`{`
`tree vec = SWITCH_LABELS (node);`	`tree vec = SWITCH_LABELS (node);`
`size_t i, n = TREE_VEC_LENGTH (vec);`	`size_t i, n = TREE_VEC_LENGTH (vec);`
`for (i = 0; i < n; ++i)`	`for (i = 0; i < n; ++i)`
`{`	`{`
`tree elt = TREE_VEC_ELT (vec, i);`	`tree elt = TREE_VEC_ELT (vec, i);`
`newline_and_indent (buffer, spc+4);`	`newline_and_indent (buffer, spc+4);`
`if (elt)`	`if (elt)`
`{`	`{`
`dump_generic_node (buffer, elt, spc+4, flags, false);`	`dump_generic_node (buffer, elt, spc+4, flags, false);`
`pp_string (buffer, " goto ");`	`pp_string (buffer, " goto ");`
`dump_generic_node (buffer, CASE_LABEL (elt), spc+4,`	`dump_generic_node (buffer, CASE_LABEL (elt), spc+4,`
`flags, true);`	`flags, true);`
`pp_semicolon (buffer);`	`pp_semicolon (buffer);`
`}`	`}`
`else`	`else`
`pp_string (buffer, "case ???: goto ???;");`	`pp_string (buffer, "case ???: goto ???;");`
`}`	`}`
`}`	`}`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_character (buffer, '}');`	`pp_character (buffer, '}');`
`}`	`}`
`is_expr = false;`	`is_expr = false;`
`break;`	`break;`

`case GOTO_EXPR:`	`case GOTO_EXPR:`
`op0 = GOTO_DESTINATION (node);`	`op0 = GOTO_DESTINATION (node);`
`if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))`	`if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))`
`{`	`{`
`const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));`	`const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));`
`if (strcmp (name, "break") == 0`	`if (strcmp (name, "break") == 0`
`\|\| strcmp (name, "continue") == 0)`	`\|\| strcmp (name, "continue") == 0)`
`{`	`{`
`pp_string (buffer, name);`	`pp_string (buffer, name);`
`break;`	`break;`
`}`	`}`
`}`	`}`
`pp_string (buffer, "goto ");`	`pp_string (buffer, "goto ");`
`dump_generic_node (buffer, op0, spc, flags, false);`	`dump_generic_node (buffer, op0, spc, flags, false);`
`break;`	`break;`

`case RESX_EXPR:`	`case RESX_EXPR:`
`pp_string (buffer, "resx ");`	`pp_string (buffer, "resx ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`break;`	`break;`

`case ASM_EXPR:`	`case ASM_EXPR:`
`pp_string (buffer, "__asm__");`	`pp_string (buffer, "__asm__");`
`if (ASM_VOLATILE_P (node))`	`if (ASM_VOLATILE_P (node))`
`pp_string (buffer, " __volatile__");`	`pp_string (buffer, " __volatile__");`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`
`dump_generic_node (buffer, ASM_STRING (node), spc, flags, false);`	`dump_generic_node (buffer, ASM_STRING (node), spc, flags, false);`
`pp_character (buffer, ':');`	`pp_character (buffer, ':');`
`dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false);`	`dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false);`
`pp_character (buffer, ':');`	`pp_character (buffer, ':');`
`dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false);`	`dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false);`
`if (ASM_CLOBBERS (node))`	`if (ASM_CLOBBERS (node))`
`{`	`{`
`pp_character (buffer, ':');`	`pp_character (buffer, ':');`
`dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false);`	`dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false);`
`}`	`}`
`pp_string (buffer, ")");`	`pp_string (buffer, ")");`
`break;`	`break;`

`case CASE_LABEL_EXPR:`	`case CASE_LABEL_EXPR:`
`if (CASE_LOW (node) && CASE_HIGH (node))`	`if (CASE_LOW (node) && CASE_HIGH (node))`
`{`	`{`
`pp_string (buffer, "case ");`	`pp_string (buffer, "case ");`
`dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);`	`dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);`
`pp_string (buffer, " ... ");`	`pp_string (buffer, " ... ");`
`dump_generic_node (buffer, CASE_HIGH (node), spc, flags, false);`	`dump_generic_node (buffer, CASE_HIGH (node), spc, flags, false);`
`}`	`}`
`else if (CASE_LOW (node))`	`else if (CASE_LOW (node))`
`{`	`{`
`pp_string (buffer, "case ");`	`pp_string (buffer, "case ");`
`dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);`	`dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);`
`}`	`}`
`else`	`else`
`pp_string (buffer, "default ");`	`pp_string (buffer, "default ");`
`pp_character (buffer, ':');`	`pp_character (buffer, ':');`
`break;`	`break;`

`case OBJ_TYPE_REF:`	`case OBJ_TYPE_REF:`
`pp_string (buffer, "OBJ_TYPE_REF(");`	`pp_string (buffer, "OBJ_TYPE_REF(");`
`dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false);`	`dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false);`
`pp_character (buffer, ';');`	`pp_character (buffer, ';');`
`dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);`	`dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);`
`pp_character (buffer, '-');`	`pp_character (buffer, '-');`
`pp_character (buffer, '>');`	`pp_character (buffer, '>');`
`dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);`	`dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`break;`	`break;`

`case PHI_NODE:`	`case PHI_NODE:`
`{`	`{`
`int i;`	`int i;`

`dump_generic_node (buffer, PHI_RESULT (node), spc, flags, false);`	`dump_generic_node (buffer, PHI_RESULT (node), spc, flags, false);`
`pp_string (buffer, " = PHI <");`	`pp_string (buffer, " = PHI <");`
`for (i = 0; i < PHI_NUM_ARGS (node); i++)`	`for (i = 0; i < PHI_NUM_ARGS (node); i++)`
`{`	`{`
`dump_generic_node (buffer, PHI_ARG_DEF (node, i), spc, flags, false);`	`dump_generic_node (buffer, PHI_ARG_DEF (node, i), spc, flags, false);`
`pp_string (buffer, "(");`	`pp_string (buffer, "(");`
`pp_decimal_int (buffer, PHI_ARG_EDGE (node, i)->src->index);`	`pp_decimal_int (buffer, PHI_ARG_EDGE (node, i)->src->index);`
`pp_string (buffer, ")");`	`pp_string (buffer, ")");`
`if (i < PHI_NUM_ARGS (node) - 1)`	`if (i < PHI_NUM_ARGS (node) - 1)`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`}`	`}`
`pp_string (buffer, ">;");`	`pp_string (buffer, ">;");`
`}`	`}`
`break;`	`break;`

`case SSA_NAME:`	`case SSA_NAME:`
`dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false);`	`dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false);`
`pp_string (buffer, "_");`	`pp_string (buffer, "_");`
`pp_decimal_int (buffer, SSA_NAME_VERSION (node));`	`pp_decimal_int (buffer, SSA_NAME_VERSION (node));`
`if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))`	`if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))`
`pp_string (buffer, "(ab)");`	`pp_string (buffer, "(ab)");`
`break;`	`break;`

`case WITH_SIZE_EXPR:`	`case WITH_SIZE_EXPR:`
`pp_string (buffer, "WITH_SIZE_EXPR <");`	`pp_string (buffer, "WITH_SIZE_EXPR <");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`pp_string (buffer, ">");`	`pp_string (buffer, ">");`
`break;`	`break;`

`case VALUE_HANDLE:`	`case VALUE_HANDLE:`
`pp_printf (buffer, "VH.%d", VALUE_HANDLE_ID (node));`	`pp_printf (buffer, "VH.%d", VALUE_HANDLE_ID (node));`
`break;`	`break;`

`case ASSERT_EXPR:`	`case ASSERT_EXPR:`
`pp_string (buffer, "ASSERT_EXPR <");`	`pp_string (buffer, "ASSERT_EXPR <");`
`dump_generic_node (buffer, ASSERT_EXPR_VAR (node), spc, flags, false);`	`dump_generic_node (buffer, ASSERT_EXPR_VAR (node), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, ASSERT_EXPR_COND (node), spc, flags, false);`	`dump_generic_node (buffer, ASSERT_EXPR_COND (node), spc, flags, false);`
`pp_string (buffer, ">");`	`pp_string (buffer, ">");`
`break;`	`break;`

`case SCEV_KNOWN:`	`case SCEV_KNOWN:`
`pp_string (buffer, "scev_known");`	`pp_string (buffer, "scev_known");`
`break;`	`break;`

`case SCEV_NOT_KNOWN:`	`case SCEV_NOT_KNOWN:`
`pp_string (buffer, "scev_not_known");`	`pp_string (buffer, "scev_not_known");`
`break;`	`break;`

`case POLYNOMIAL_CHREC:`	`case POLYNOMIAL_CHREC:`
`pp_string (buffer, "{");`	`pp_string (buffer, "{");`
`dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false);`	`dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false);`
`pp_string (buffer, ", +, ");`	`pp_string (buffer, ", +, ");`
`dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false);`	`dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false);`
`pp_string (buffer, "}_");`	`pp_string (buffer, "}_");`
`dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false);`	`dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false);`
`is_stmt = false;`	`is_stmt = false;`
`break;`	`break;`

`case REALIGN_LOAD_EXPR:`	`case REALIGN_LOAD_EXPR:`
`pp_string (buffer, "REALIGN_LOAD <");`	`pp_string (buffer, "REALIGN_LOAD <");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);`
`pp_string (buffer, ">");`	`pp_string (buffer, ">");`
`break;`	`break;`

`case VEC_COND_EXPR:`	`case VEC_COND_EXPR:`
`pp_string (buffer, " VEC_COND_EXPR < ");`	`pp_string (buffer, " VEC_COND_EXPR < ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, " , ");`	`pp_string (buffer, " , ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`pp_string (buffer, " , ");`	`pp_string (buffer, " , ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);`
`pp_string (buffer, " > ");`	`pp_string (buffer, " > ");`
`break;`	`break;`

`case DOT_PROD_EXPR:`	`case DOT_PROD_EXPR:`
`pp_string (buffer, " DOT_PROD_EXPR < ");`	`pp_string (buffer, " DOT_PROD_EXPR < ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, " , ");`	`pp_string (buffer, " , ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`pp_string (buffer, " , ");`	`pp_string (buffer, " , ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);`
`pp_string (buffer, " > ");`	`pp_string (buffer, " > ");`
`break;`	`break;`

`case OMP_PARALLEL:`	`case OMP_PARALLEL:`
`pp_string (buffer, "#pragma omp parallel");`	`pp_string (buffer, "#pragma omp parallel");`
`dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags);`	`dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags);`
`if (OMP_PARALLEL_FN (node))`	`if (OMP_PARALLEL_FN (node))`
`{`	`{`
`pp_string (buffer, " [child fn: ");`	`pp_string (buffer, " [child fn: ");`
`dump_generic_node (buffer, OMP_PARALLEL_FN (node), spc, flags, false);`	`dump_generic_node (buffer, OMP_PARALLEL_FN (node), spc, flags, false);`

`pp_string (buffer, " (");`	`pp_string (buffer, " (");`

`if (OMP_PARALLEL_DATA_ARG (node))`	`if (OMP_PARALLEL_DATA_ARG (node))`
`dump_generic_node (buffer, OMP_PARALLEL_DATA_ARG (node), spc, flags,`	`dump_generic_node (buffer, OMP_PARALLEL_DATA_ARG (node), spc, flags,`
`false);`	`false);`
`else`	`else`
`pp_string (buffer, "???");`	`pp_string (buffer, "???");`

`pp_string (buffer, ")]");`	`pp_string (buffer, ")]");`
`}`	`}`

`dump_omp_body:`	`dump_omp_body:`
`if (!(flags & TDF_SLIM) && OMP_BODY (node))`	`if (!(flags & TDF_SLIM) && OMP_BODY (node))`
`{`	`{`
`newline_and_indent (buffer, spc + 2);`	`newline_and_indent (buffer, spc + 2);`
`pp_character (buffer, '{');`	`pp_character (buffer, '{');`
`newline_and_indent (buffer, spc + 4);`	`newline_and_indent (buffer, spc + 4);`
`dump_generic_node (buffer, OMP_BODY (node), spc + 4, flags, false);`	`dump_generic_node (buffer, OMP_BODY (node), spc + 4, flags, false);`
`newline_and_indent (buffer, spc + 2);`	`newline_and_indent (buffer, spc + 2);`
`pp_character (buffer, '}');`	`pp_character (buffer, '}');`
`}`	`}`
`is_expr = false;`	`is_expr = false;`
`break;`	`break;`

`case OMP_FOR:`	`case OMP_FOR:`
`pp_string (buffer, "#pragma omp for");`	`pp_string (buffer, "#pragma omp for");`
`dump_omp_clauses (buffer, OMP_FOR_CLAUSES (node), spc, flags);`	`dump_omp_clauses (buffer, OMP_FOR_CLAUSES (node), spc, flags);`

`if (!(flags & TDF_SLIM))`	`if (!(flags & TDF_SLIM))`
`{`	`{`
`if (OMP_FOR_PRE_BODY (node))`	`if (OMP_FOR_PRE_BODY (node))`
`{`	`{`
`newline_and_indent (buffer, spc + 2);`	`newline_and_indent (buffer, spc + 2);`
`pp_character (buffer, '{');`	`pp_character (buffer, '{');`
`spc += 4;`	`spc += 4;`
`newline_and_indent (buffer, spc);`	`newline_and_indent (buffer, spc);`
`dump_generic_node (buffer, OMP_FOR_PRE_BODY (node),`	`dump_generic_node (buffer, OMP_FOR_PRE_BODY (node),`
`spc, flags, false);`	`spc, flags, false);`
`}`	`}`
`newline_and_indent (buffer, spc);`	`newline_and_indent (buffer, spc);`
`pp_string (buffer, "for (");`	`pp_string (buffer, "for (");`
`dump_generic_node (buffer, OMP_FOR_INIT (node), spc, flags, false);`	`dump_generic_node (buffer, OMP_FOR_INIT (node), spc, flags, false);`
`pp_string (buffer, "; ");`	`pp_string (buffer, "; ");`
`dump_generic_node (buffer, OMP_FOR_COND (node), spc, flags, false);`	`dump_generic_node (buffer, OMP_FOR_COND (node), spc, flags, false);`
`pp_string (buffer, "; ");`	`pp_string (buffer, "; ");`
`dump_generic_node (buffer, OMP_FOR_INCR (node), spc, flags, false);`	`dump_generic_node (buffer, OMP_FOR_INCR (node), spc, flags, false);`
`pp_string (buffer, ")");`	`pp_string (buffer, ")");`
`if (OMP_FOR_BODY (node))`	`if (OMP_FOR_BODY (node))`
`{`	`{`
`newline_and_indent (buffer, spc + 2);`	`newline_and_indent (buffer, spc + 2);`
`pp_character (buffer, '{');`	`pp_character (buffer, '{');`
`newline_and_indent (buffer, spc + 4);`	`newline_and_indent (buffer, spc + 4);`
`dump_generic_node (buffer, OMP_FOR_BODY (node), spc + 4, flags,`	`dump_generic_node (buffer, OMP_FOR_BODY (node), spc + 4, flags,`
`false);`	`false);`
`newline_and_indent (buffer, spc + 2);`	`newline_and_indent (buffer, spc + 2);`
`pp_character (buffer, '}');`	`pp_character (buffer, '}');`
`}`	`}`
`if (OMP_FOR_PRE_BODY (node))`	`if (OMP_FOR_PRE_BODY (node))`
`{`	`{`
`spc -= 4;`	`spc -= 4;`
`newline_and_indent (buffer, spc + 2);`	`newline_and_indent (buffer, spc + 2);`
`pp_character (buffer, '}');`	`pp_character (buffer, '}');`
`}`	`}`
`}`	`}`
`is_expr = false;`	`is_expr = false;`
`break;`	`break;`

`case OMP_SECTIONS:`	`case OMP_SECTIONS:`
`pp_string (buffer, "#pragma omp sections");`	`pp_string (buffer, "#pragma omp sections");`
`dump_omp_clauses (buffer, OMP_SECTIONS_CLAUSES (node), spc, flags);`	`dump_omp_clauses (buffer, OMP_SECTIONS_CLAUSES (node), spc, flags);`
`goto dump_omp_body;`	`goto dump_omp_body;`

`case OMP_SECTION:`	`case OMP_SECTION:`
`pp_string (buffer, "#pragma omp section");`	`pp_string (buffer, "#pragma omp section");`
`goto dump_omp_body;`	`goto dump_omp_body;`

`case OMP_MASTER:`	`case OMP_MASTER:`
`pp_string (buffer, "#pragma omp master");`	`pp_string (buffer, "#pragma omp master");`
`goto dump_omp_body;`	`goto dump_omp_body;`

`case OMP_ORDERED:`	`case OMP_ORDERED:`
`pp_string (buffer, "#pragma omp ordered");`	`pp_string (buffer, "#pragma omp ordered");`
`goto dump_omp_body;`	`goto dump_omp_body;`

`case OMP_CRITICAL:`	`case OMP_CRITICAL:`
`pp_string (buffer, "#pragma omp critical");`	`pp_string (buffer, "#pragma omp critical");`
`if (OMP_CRITICAL_NAME (node))`	`if (OMP_CRITICAL_NAME (node))`
`{`	`{`
`pp_space (buffer);`	`pp_space (buffer);`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`
`dump_generic_node (buffer, OMP_CRITICAL_NAME (node), spc,`	`dump_generic_node (buffer, OMP_CRITICAL_NAME (node), spc,`
`flags, false);`	`flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`}`	`}`
`goto dump_omp_body;`	`goto dump_omp_body;`

`case OMP_ATOMIC:`	`case OMP_ATOMIC:`
`pp_string (buffer, "#pragma omp atomic");`	`pp_string (buffer, "#pragma omp atomic");`
`newline_and_indent (buffer, spc + 2);`	`newline_and_indent (buffer, spc + 2);`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_space (buffer);`	`pp_space (buffer);`
`pp_character (buffer, '=');`	`pp_character (buffer, '=');`
`pp_space (buffer);`	`pp_space (buffer);`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`break;`	`break;`

`case OMP_SINGLE:`	`case OMP_SINGLE:`
`pp_string (buffer, "#pragma omp single");`	`pp_string (buffer, "#pragma omp single");`
`dump_omp_clauses (buffer, OMP_SINGLE_CLAUSES (node), spc, flags);`	`dump_omp_clauses (buffer, OMP_SINGLE_CLAUSES (node), spc, flags);`
`goto dump_omp_body;`	`goto dump_omp_body;`

`case OMP_RETURN:`	`case OMP_RETURN:`
`pp_string (buffer, "OMP_RETURN");`	`pp_string (buffer, "OMP_RETURN");`
`if (OMP_RETURN_NOWAIT (node))`	`if (OMP_RETURN_NOWAIT (node))`
`pp_string (buffer, " [nowait]");`	`pp_string (buffer, " [nowait]");`
`is_expr = false;`	`is_expr = false;`
`break;`	`break;`

`case OMP_CONTINUE:`	`case OMP_CONTINUE:`
`pp_string (buffer, "OMP_CONTINUE");`	`pp_string (buffer, "OMP_CONTINUE");`
`is_expr = false;`	`is_expr = false;`
`break;`	`break;`

`case OMP_CLAUSE:`	`case OMP_CLAUSE:`
`dump_omp_clause (buffer, node, spc, flags);`	`dump_omp_clause (buffer, node, spc, flags);`
`is_expr = false;`	`is_expr = false;`
`break;`	`break;`

`case REDUC_MAX_EXPR:`	`case REDUC_MAX_EXPR:`
`pp_string (buffer, " REDUC_MAX_EXPR < ");`	`pp_string (buffer, " REDUC_MAX_EXPR < ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, " > ");`	`pp_string (buffer, " > ");`
`break;`	`break;`

`case REDUC_MIN_EXPR:`	`case REDUC_MIN_EXPR:`
`pp_string (buffer, " REDUC_MIN_EXPR < ");`	`pp_string (buffer, " REDUC_MIN_EXPR < ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, " > ");`	`pp_string (buffer, " > ");`
`break;`	`break;`

`case REDUC_PLUS_EXPR:`	`case REDUC_PLUS_EXPR:`
`pp_string (buffer, " REDUC_PLUS_EXPR < ");`	`pp_string (buffer, " REDUC_PLUS_EXPR < ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, " > ");`	`pp_string (buffer, " > ");`
`break;`	`break;`

`case BLOCK:`	`case BLOCK:`
`{`	`{`
`tree t;`	`tree t;`
`pp_string (buffer, "BLOCK");`	`pp_string (buffer, "BLOCK");`

`if (BLOCK_ABSTRACT (node))`	`if (BLOCK_ABSTRACT (node))`
`pp_string (buffer, " [abstract]");`	`pp_string (buffer, " [abstract]");`

`if (TREE_ASM_WRITTEN (node))`	`if (TREE_ASM_WRITTEN (node))`
`pp_string (buffer, " [written]");`	`pp_string (buffer, " [written]");`

`newline_and_indent (buffer, spc + 2);`	`newline_and_indent (buffer, spc + 2);`

`if (BLOCK_SUPERCONTEXT (node))`	`if (BLOCK_SUPERCONTEXT (node))`
`{`	`{`
`pp_string (buffer, "SUPERCONTEXT: ");`	`pp_string (buffer, "SUPERCONTEXT: ");`
`if (TREE_CODE (BLOCK_SUPERCONTEXT (node)) == BLOCK)`	`if (TREE_CODE (BLOCK_SUPERCONTEXT (node)) == BLOCK)`
`pp_printf (buffer, "BLOCK %p",`	`pp_printf (buffer, "BLOCK %p",`
`(void *)BLOCK_SUPERCONTEXT (node));`	`(void *)BLOCK_SUPERCONTEXT (node));`
`else`	`else`
`dump_generic_node (buffer, BLOCK_SUPERCONTEXT (node), 0, flags,`	`dump_generic_node (buffer, BLOCK_SUPERCONTEXT (node), 0, flags,`
`false);`	`false);`
`newline_and_indent (buffer, spc + 2);`	`newline_and_indent (buffer, spc + 2);`
`}`	`}`

`if (BLOCK_SUBBLOCKS (node))`	`if (BLOCK_SUBBLOCKS (node))`
`{`	`{`
`pp_string (buffer, "SUBBLOCKS: ");`	`pp_string (buffer, "SUBBLOCKS: ");`
`for (t = BLOCK_SUBBLOCKS (node); t; t = BLOCK_CHAIN (t))`	`for (t = BLOCK_SUBBLOCKS (node); t; t = BLOCK_CHAIN (t))`
`pp_printf (buffer, "%p ", (void *)t);`	`pp_printf (buffer, "%p ", (void *)t);`
`newline_and_indent (buffer, spc + 2);`	`newline_and_indent (buffer, spc + 2);`
`}`	`}`

`if (BLOCK_VARS (node))`	`if (BLOCK_VARS (node))`
`{`	`{`
`pp_string (buffer, "VARS: ");`	`pp_string (buffer, "VARS: ");`
`for (t = BLOCK_VARS (node); t; t = TREE_CHAIN (t))`	`for (t = BLOCK_VARS (node); t; t = TREE_CHAIN (t))`
`{`	`{`
`dump_generic_node (buffer, t, 0, flags, false);`	`dump_generic_node (buffer, t, 0, flags, false);`
`pp_string (buffer, " ");`	`pp_string (buffer, " ");`
`}`	`}`
`newline_and_indent (buffer, spc + 2);`	`newline_and_indent (buffer, spc + 2);`
`}`	`}`

`if (BLOCK_ABSTRACT_ORIGIN (node))`	`if (BLOCK_ABSTRACT_ORIGIN (node))`
`{`	`{`
`pp_string (buffer, "ABSTRACT_ORIGIN: ");`	`pp_string (buffer, "ABSTRACT_ORIGIN: ");`
`if (TREE_CODE (BLOCK_ABSTRACT_ORIGIN (node)) == BLOCK)`	`if (TREE_CODE (BLOCK_ABSTRACT_ORIGIN (node)) == BLOCK)`
`pp_printf (buffer, "BLOCK %p",`	`pp_printf (buffer, "BLOCK %p",`
`(void *)BLOCK_ABSTRACT_ORIGIN (node));`	`(void *)BLOCK_ABSTRACT_ORIGIN (node));`
`else`	`else`
`dump_generic_node (buffer, BLOCK_ABSTRACT_ORIGIN (node), 0, flags,`	`dump_generic_node (buffer, BLOCK_ABSTRACT_ORIGIN (node), 0, flags,`
`false);`	`false);`
`newline_and_indent (buffer, spc + 2);`	`newline_and_indent (buffer, spc + 2);`
`}`	`}`
`}`	`}`
`break;`	`break;`

`default:`	`default:`
`NIY;`	`NIY;`
`}`	`}`

`if (is_stmt && is_expr)`	`if (is_stmt && is_expr)`
`pp_semicolon (buffer);`	`pp_semicolon (buffer);`
`pp_write_text_to_stream (buffer);`	`pp_write_text_to_stream (buffer);`

`return spc;`	`return spc;`
`}`	`}`

`/* Print the declaration of a variable. */`	`/* Print the declaration of a variable. */`

`static void`	`static void`
`print_declaration (pretty_printer *buffer, tree t, int spc, int flags)`	`print_declaration (pretty_printer *buffer, tree t, int spc, int flags)`
`{`	`{`
`INDENT (spc);`	`INDENT (spc);`

`if (TREE_CODE (t) == TYPE_DECL)`	`if (TREE_CODE (t) == TYPE_DECL)`
`pp_string (buffer, "typedef ");`	`pp_string (buffer, "typedef ");`

`if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t))`	`if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t))`
`pp_string (buffer, "register ");`	`pp_string (buffer, "register ");`

`if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))`	`if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))`
`pp_string (buffer, "extern ");`	`pp_string (buffer, "extern ");`
`else if (TREE_STATIC (t))`	`else if (TREE_STATIC (t))`
`pp_string (buffer, "static ");`	`pp_string (buffer, "static ");`

`/* Print the type and name. */`	`/* Print the type and name. */`
`if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)`	`if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)`
`{`	`{`
`tree tmp;`	`tree tmp;`

`/* Print array's type. */`	`/* Print array's type. */`
`tmp = TREE_TYPE (t);`	`tmp = TREE_TYPE (t);`
`while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)`	`while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)`
`tmp = TREE_TYPE (tmp);`	`tmp = TREE_TYPE (tmp);`
`dump_generic_node (buffer, TREE_TYPE (tmp), spc, flags, false);`	`dump_generic_node (buffer, TREE_TYPE (tmp), spc, flags, false);`

`/* Print variable's name. */`	`/* Print variable's name. */`
`pp_space (buffer);`	`pp_space (buffer);`
`dump_generic_node (buffer, t, spc, flags, false);`	`dump_generic_node (buffer, t, spc, flags, false);`

`/* Print the dimensions. */`	`/* Print the dimensions. */`
`tmp = TREE_TYPE (t);`	`tmp = TREE_TYPE (t);`
`while (TREE_CODE (tmp) == ARRAY_TYPE)`	`while (TREE_CODE (tmp) == ARRAY_TYPE)`
`{`	`{`
`dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);`	`dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);`
`tmp = TREE_TYPE (tmp);`	`tmp = TREE_TYPE (tmp);`
`}`	`}`
`}`	`}`
`else if (TREE_CODE (t) == FUNCTION_DECL)`	`else if (TREE_CODE (t) == FUNCTION_DECL)`
`{`	`{`
`dump_generic_node (buffer, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);`	`dump_generic_node (buffer, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);`
`pp_space (buffer);`	`pp_space (buffer);`
`dump_decl_name (buffer, t, flags);`	`dump_decl_name (buffer, t, flags);`
`dump_function_declaration (buffer, TREE_TYPE (t), spc, flags);`	`dump_function_declaration (buffer, TREE_TYPE (t), spc, flags);`
`}`	`}`
`else`	`else`
`{`	`{`
`/* Print type declaration. */`	`/* Print type declaration. */`
`dump_generic_node (buffer, TREE_TYPE (t), spc, flags, false);`	`dump_generic_node (buffer, TREE_TYPE (t), spc, flags, false);`

`/* Print variable's name. */`	`/* Print variable's name. */`
`pp_space (buffer);`	`pp_space (buffer);`
`dump_generic_node (buffer, t, spc, flags, false);`	`dump_generic_node (buffer, t, spc, flags, false);`
`}`	`}`

`if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))`	`if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))`
`{`	`{`
`pp_string (buffer, " __asm__ ");`	`pp_string (buffer, " __asm__ ");`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`
`dump_generic_node (buffer, DECL_ASSEMBLER_NAME (t), spc, flags, false);`	`dump_generic_node (buffer, DECL_ASSEMBLER_NAME (t), spc, flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`}`	`}`

`/* The initial value of a function serves to determine wether the function`	`/* The initial value of a function serves to determine wether the function`
`is declared or defined. So the following does not apply to function`	`is declared or defined. So the following does not apply to function`
`nodes. */`	`nodes. */`
`if (TREE_CODE (t) != FUNCTION_DECL)`	`if (TREE_CODE (t) != FUNCTION_DECL)`
`{`	`{`
`/* Print the initial value. */`	`/* Print the initial value. */`
`if (DECL_INITIAL (t))`	`if (DECL_INITIAL (t))`
`{`	`{`
`pp_space (buffer);`	`pp_space (buffer);`
`pp_character (buffer, '=');`	`pp_character (buffer, '=');`
`pp_space (buffer);`	`pp_space (buffer);`
`dump_generic_node (buffer, DECL_INITIAL (t), spc, flags, false);`	`dump_generic_node (buffer, DECL_INITIAL (t), spc, flags, false);`
`}`	`}`
`}`	`}`

`if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t))`	`if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t))`
`{`	`{`
`pp_string (buffer, " [value-expr: ");`	`pp_string (buffer, " [value-expr: ");`
`dump_generic_node (buffer, DECL_VALUE_EXPR (t), spc, flags, false);`	`dump_generic_node (buffer, DECL_VALUE_EXPR (t), spc, flags, false);`
`pp_character (buffer, ']');`	`pp_character (buffer, ']');`
`}`	`}`

`pp_character (buffer, ';');`	`pp_character (buffer, ';');`
`}`	`}`


`/* Prints a structure: name, fields, and methods.`	`/* Prints a structure: name, fields, and methods.`
`FIXME: Still incomplete. */`	`FIXME: Still incomplete. */`

`static void`	`static void`
`print_struct_decl (pretty_printer *buffer, tree node, int spc, int flags)`	`print_struct_decl (pretty_printer *buffer, tree node, int spc, int flags)`
`{`	`{`
`/* Print the name of the structure. */`	`/* Print the name of the structure. */`
`if (TYPE_NAME (node))`	`if (TYPE_NAME (node))`
`{`	`{`
`INDENT (spc);`	`INDENT (spc);`
`if (TREE_CODE (node) == RECORD_TYPE)`	`if (TREE_CODE (node) == RECORD_TYPE)`
`pp_string (buffer, "struct ");`	`pp_string (buffer, "struct ");`
`else if ((TREE_CODE (node) == UNION_TYPE`	`else if ((TREE_CODE (node) == UNION_TYPE`
`\|\| TREE_CODE (node) == QUAL_UNION_TYPE))`	`\|\| TREE_CODE (node) == QUAL_UNION_TYPE))`
`pp_string (buffer, "union ");`	`pp_string (buffer, "union ");`

`dump_generic_node (buffer, TYPE_NAME (node), spc, 0, false);`	`dump_generic_node (buffer, TYPE_NAME (node), spc, 0, false);`
`}`	`}`

`/* Print the contents of the structure. */`	`/* Print the contents of the structure. */`
`pp_newline (buffer);`	`pp_newline (buffer);`
`INDENT (spc);`	`INDENT (spc);`
`pp_character (buffer, '{');`	`pp_character (buffer, '{');`
`pp_newline (buffer);`	`pp_newline (buffer);`

`/* Print the fields of the structure. */`	`/* Print the fields of the structure. */`
`{`	`{`
`tree tmp;`	`tree tmp;`
`tmp = TYPE_FIELDS (node);`	`tmp = TYPE_FIELDS (node);`
`while (tmp)`	`while (tmp)`
`{`	`{`
`/* Avoid to print recursively the structure. */`	`/* Avoid to print recursively the structure. */`
`/* FIXME : Not implemented correctly...,`	`/* FIXME : Not implemented correctly...,`
`what about the case when we have a cycle in the contain graph? ...`	`what about the case when we have a cycle in the contain graph? ...`
`Maybe this could be solved by looking at the scope in which the`	`Maybe this could be solved by looking at the scope in which the`
`structure was declared. */`	`structure was declared. */`
`if (TREE_TYPE (tmp) != node`	`if (TREE_TYPE (tmp) != node`
`\|\| (TREE_CODE (TREE_TYPE (tmp)) == POINTER_TYPE`	`\|\| (TREE_CODE (TREE_TYPE (tmp)) == POINTER_TYPE`
`&& TREE_TYPE (TREE_TYPE (tmp)) != node))`	`&& TREE_TYPE (TREE_TYPE (tmp)) != node))`
`{`	`{`
`print_declaration (buffer, tmp, spc+2, flags);`	`print_declaration (buffer, tmp, spc+2, flags);`
`pp_newline (buffer);`	`pp_newline (buffer);`
`}`	`}`
`tmp = TREE_CHAIN (tmp);`	`tmp = TREE_CHAIN (tmp);`
`}`	`}`
`}`	`}`
`INDENT (spc);`	`INDENT (spc);`
`pp_character (buffer, '}');`	`pp_character (buffer, '}');`
`}`	`}`

`/* Return the priority of the operator OP.`	`/* Return the priority of the operator OP.`

`From lowest to highest precedence with either left-to-right (L-R)`	`From lowest to highest precedence with either left-to-right (L-R)`
`or right-to-left (R-L) associativity]:`	`or right-to-left (R-L) associativity]:`

`1 [L-R] ,`	`1 [L-R] ,`
`2 [R-L] = += -= *= /= %= &= ^= \|= <<= >>=`	`2 [R-L] = += -= *= /= %= &= ^= \|= <<= >>=`
`3 [R-L] ?:`	`3 [R-L] ?:`
`4 [L-R] \|\|`	`4 [L-R] \|\|`
`5 [L-R] &&`	`5 [L-R] &&`
`6 [L-R] \|`	`6 [L-R] \|`
`7 [L-R] ^`	`7 [L-R] ^`
`8 [L-R] &`	`8 [L-R] &`
`9 [L-R] == !=`	`9 [L-R] == !=`
`10 [L-R] < <= > >=`	`10 [L-R] < <= > >=`
`11 [L-R] << >>`	`11 [L-R] << >>`
`12 [L-R] + -`	`12 [L-R] + -`
`13 [L-R] * / %`	`13 [L-R] * / %`
`14 [R-L] ! ~ ++ -- + - * & (type) sizeof`	`14 [R-L] ! ~ ++ -- + - * & (type) sizeof`
`15 [L-R] fn() [] -> .`	`15 [L-R] fn() [] -> .`

`unary +, - and * have higher precedence than the corresponding binary`	`unary +, - and * have higher precedence than the corresponding binary`
`operators. */`	`operators. */`

`static int`	`static int`
`op_prio (tree op)`	`op_prio (tree op)`
`{`	`{`
`if (op == NULL)`	`if (op == NULL)`
`return 9999;`	`return 9999;`

`switch (TREE_CODE (op))`	`switch (TREE_CODE (op))`
`{`	`{`
`case TREE_LIST:`	`case TREE_LIST:`
`case COMPOUND_EXPR:`	`case COMPOUND_EXPR:`
`case BIND_EXPR:`	`case BIND_EXPR:`
`return 1;`	`return 1;`

`case MODIFY_EXPR:`	`case MODIFY_EXPR:`
`case INIT_EXPR:`	`case INIT_EXPR:`
`return 2;`	`return 2;`

`case COND_EXPR:`	`case COND_EXPR:`
`return 3;`	`return 3;`

`case TRUTH_OR_EXPR:`	`case TRUTH_OR_EXPR:`
`case TRUTH_ORIF_EXPR:`	`case TRUTH_ORIF_EXPR:`
`return 4;`	`return 4;`

`case TRUTH_AND_EXPR:`	`case TRUTH_AND_EXPR:`
`case TRUTH_ANDIF_EXPR:`	`case TRUTH_ANDIF_EXPR:`
`return 5;`	`return 5;`

`case BIT_IOR_EXPR:`	`case BIT_IOR_EXPR:`
`return 6;`	`return 6;`

`case BIT_XOR_EXPR:`	`case BIT_XOR_EXPR:`
`case TRUTH_XOR_EXPR:`	`case TRUTH_XOR_EXPR:`
`return 7;`	`return 7;`

`case BIT_AND_EXPR:`	`case BIT_AND_EXPR:`
`return 8;`	`return 8;`

`case EQ_EXPR:`	`case EQ_EXPR:`
`case NE_EXPR:`	`case NE_EXPR:`
`return 9;`	`return 9;`

`case UNLT_EXPR:`	`case UNLT_EXPR:`
`case UNLE_EXPR:`	`case UNLE_EXPR:`
`case UNGT_EXPR:`	`case UNGT_EXPR:`
`case UNGE_EXPR:`	`case UNGE_EXPR:`
`case UNEQ_EXPR:`	`case UNEQ_EXPR:`
`case LTGT_EXPR:`	`case LTGT_EXPR:`
`case ORDERED_EXPR:`	`case ORDERED_EXPR:`
`case UNORDERED_EXPR:`	`case UNORDERED_EXPR:`
`case LT_EXPR:`	`case LT_EXPR:`
`case LE_EXPR:`	`case LE_EXPR:`
`case GT_EXPR:`	`case GT_EXPR:`
`case GE_EXPR:`	`case GE_EXPR:`
`return 10;`	`return 10;`

`case LSHIFT_EXPR:`	`case LSHIFT_EXPR:`
`case RSHIFT_EXPR:`	`case RSHIFT_EXPR:`
`case LROTATE_EXPR:`	`case LROTATE_EXPR:`
`case RROTATE_EXPR:`	`case RROTATE_EXPR:`
`return 11;`	`return 11;`

`case WIDEN_SUM_EXPR:`	`case WIDEN_SUM_EXPR:`
`case PLUS_EXPR:`	`case PLUS_EXPR:`
`case MINUS_EXPR:`	`case MINUS_EXPR:`
`return 12;`	`return 12;`

`case WIDEN_MULT_EXPR:`	`case WIDEN_MULT_EXPR:`
`case DOT_PROD_EXPR:`	`case DOT_PROD_EXPR:`
`case MULT_EXPR:`	`case MULT_EXPR:`
`case TRUNC_DIV_EXPR:`	`case TRUNC_DIV_EXPR:`
`case CEIL_DIV_EXPR:`	`case CEIL_DIV_EXPR:`
`case FLOOR_DIV_EXPR:`	`case FLOOR_DIV_EXPR:`
`case ROUND_DIV_EXPR:`	`case ROUND_DIV_EXPR:`
`case RDIV_EXPR:`	`case RDIV_EXPR:`
`case EXACT_DIV_EXPR:`	`case EXACT_DIV_EXPR:`
`case TRUNC_MOD_EXPR:`	`case TRUNC_MOD_EXPR:`
`case CEIL_MOD_EXPR:`	`case CEIL_MOD_EXPR:`
`case FLOOR_MOD_EXPR:`	`case FLOOR_MOD_EXPR:`
`case ROUND_MOD_EXPR:`	`case ROUND_MOD_EXPR:`
`return 13;`	`return 13;`

`case TRUTH_NOT_EXPR:`	`case TRUTH_NOT_EXPR:`
`case BIT_NOT_EXPR:`	`case BIT_NOT_EXPR:`
`case POSTINCREMENT_EXPR:`	`case POSTINCREMENT_EXPR:`
`case POSTDECREMENT_EXPR:`	`case POSTDECREMENT_EXPR:`
`case PREINCREMENT_EXPR:`	`case PREINCREMENT_EXPR:`
`case PREDECREMENT_EXPR:`	`case PREDECREMENT_EXPR:`
`case NEGATE_EXPR:`	`case NEGATE_EXPR:`
`case ALIGN_INDIRECT_REF:`	`case ALIGN_INDIRECT_REF:`
`case MISALIGNED_INDIRECT_REF:`	`case MISALIGNED_INDIRECT_REF:`
`case INDIRECT_REF:`	`case INDIRECT_REF:`
`case ADDR_EXPR:`	`case ADDR_EXPR:`
`case FLOAT_EXPR:`	`case FLOAT_EXPR:`
`case NOP_EXPR:`	`case NOP_EXPR:`
`case CONVERT_EXPR:`	`case CONVERT_EXPR:`
`case FIX_TRUNC_EXPR:`	`case FIX_TRUNC_EXPR:`
`case FIX_CEIL_EXPR:`	`case FIX_CEIL_EXPR:`
`case FIX_FLOOR_EXPR:`	`case FIX_FLOOR_EXPR:`
`case FIX_ROUND_EXPR:`	`case FIX_ROUND_EXPR:`
`case TARGET_EXPR:`	`case TARGET_EXPR:`
`return 14;`	`return 14;`

`case CALL_EXPR:`	`case CALL_EXPR:`
`case ARRAY_REF:`	`case ARRAY_REF:`
`case ARRAY_RANGE_REF:`	`case ARRAY_RANGE_REF:`
`case COMPONENT_REF:`	`case COMPONENT_REF:`
`return 15;`	`return 15;`

`/* Special expressions. */`	`/* Special expressions. */`
`case MIN_EXPR:`	`case MIN_EXPR:`
`case MAX_EXPR:`	`case MAX_EXPR:`
`case ABS_EXPR:`	`case ABS_EXPR:`
`case REALPART_EXPR:`	`case REALPART_EXPR:`
`case IMAGPART_EXPR:`	`case IMAGPART_EXPR:`
`case REDUC_MAX_EXPR:`	`case REDUC_MAX_EXPR:`
`case REDUC_MIN_EXPR:`	`case REDUC_MIN_EXPR:`
`case REDUC_PLUS_EXPR:`	`case REDUC_PLUS_EXPR:`
`case VEC_LSHIFT_EXPR:`	`case VEC_LSHIFT_EXPR:`
`case VEC_RSHIFT_EXPR:`	`case VEC_RSHIFT_EXPR:`
`return 16;`	`return 16;`

`case SAVE_EXPR:`	`case SAVE_EXPR:`
`case NON_LVALUE_EXPR:`	`case NON_LVALUE_EXPR:`
`return op_prio (TREE_OPERAND (op, 0));`	`return op_prio (TREE_OPERAND (op, 0));`

`default:`	`default:`
`/* Return an arbitrarily high precedence to avoid surrounding single`	`/* Return an arbitrarily high precedence to avoid surrounding single`
`VAR_DECLs in ()s. */`	`VAR_DECLs in ()s. */`
`return 9999;`	`return 9999;`
`}`	`}`
`}`	`}`


`/* Return the symbol associated with operator OP. */`	`/* Return the symbol associated with operator OP. */`

`static const char *`	`static const char *`
`op_symbol_1 (enum tree_code code)`	`op_symbol_1 (enum tree_code code)`
`{`	`{`
`switch (code)`	`switch (code)`
`{`	`{`
`case MODIFY_EXPR:`	`case MODIFY_EXPR:`
`return "=";`	`return "=";`

`case TRUTH_OR_EXPR:`	`case TRUTH_OR_EXPR:`
`case TRUTH_ORIF_EXPR:`	`case TRUTH_ORIF_EXPR:`
`return "\|\|";`	`return "\|\|";`

`case TRUTH_AND_EXPR:`	`case TRUTH_AND_EXPR:`
`case TRUTH_ANDIF_EXPR:`	`case TRUTH_ANDIF_EXPR:`
`return "&&";`	`return "&&";`

`case BIT_IOR_EXPR:`	`case BIT_IOR_EXPR:`
`return "\|";`	`return "\|";`

`case TRUTH_XOR_EXPR:`	`case TRUTH_XOR_EXPR:`
`case BIT_XOR_EXPR:`	`case BIT_XOR_EXPR:`
`return "^";`	`return "^";`

`case ADDR_EXPR:`	`case ADDR_EXPR:`
`case BIT_AND_EXPR:`	`case BIT_AND_EXPR:`
`return "&";`	`return "&";`

`case ORDERED_EXPR:`	`case ORDERED_EXPR:`
`return "ord";`	`return "ord";`
`case UNORDERED_EXPR:`	`case UNORDERED_EXPR:`
`return "unord";`	`return "unord";`

`case EQ_EXPR:`	`case EQ_EXPR:`
`return "==";`	`return "==";`
`case UNEQ_EXPR:`	`case UNEQ_EXPR:`
`return "u==";`	`return "u==";`

`case NE_EXPR:`	`case NE_EXPR:`
`return "!=";`	`return "!=";`

`case LT_EXPR:`	`case LT_EXPR:`
`return "<";`	`return "<";`
`case UNLT_EXPR:`	`case UNLT_EXPR:`
`return "u<";`	`return "u<";`

`case LE_EXPR:`	`case LE_EXPR:`
`return "<=";`	`return "<=";`
`case UNLE_EXPR:`	`case UNLE_EXPR:`
`return "u<=";`	`return "u<=";`

`case GT_EXPR:`	`case GT_EXPR:`
`return ">";`	`return ">";`
`case UNGT_EXPR:`	`case UNGT_EXPR:`
`return "u>";`	`return "u>";`

`case GE_EXPR:`	`case GE_EXPR:`
`return ">=";`	`return ">=";`
`case UNGE_EXPR:`	`case UNGE_EXPR:`
`return "u>=";`	`return "u>=";`

`case LTGT_EXPR:`	`case LTGT_EXPR:`
`return "<>";`	`return "<>";`

`case LSHIFT_EXPR:`	`case LSHIFT_EXPR:`
`return "<<";`	`return "<<";`

`case RSHIFT_EXPR:`	`case RSHIFT_EXPR:`
`return ">>";`	`return ">>";`

`case LROTATE_EXPR:`	`case LROTATE_EXPR:`
`return "r<<";`	`return "r<<";`

`case RROTATE_EXPR:`	`case RROTATE_EXPR:`
`return "r>>";`	`return "r>>";`

`case VEC_LSHIFT_EXPR:`	`case VEC_LSHIFT_EXPR:`
`return "v<<";`	`return "v<<";`

`case VEC_RSHIFT_EXPR:`	`case VEC_RSHIFT_EXPR:`
`return "v>>";`	`return "v>>";`

`case PLUS_EXPR:`	`case PLUS_EXPR:`
`return "+";`	`return "+";`

`case REDUC_PLUS_EXPR:`	`case REDUC_PLUS_EXPR:`
`return "r+";`	`return "r+";`

`case WIDEN_SUM_EXPR:`	`case WIDEN_SUM_EXPR:`
`return "w+";`	`return "w+";`

`case WIDEN_MULT_EXPR:`	`case WIDEN_MULT_EXPR:`
`return "w*";`	`return "w*";`

`case NEGATE_EXPR:`	`case NEGATE_EXPR:`
`case MINUS_EXPR:`	`case MINUS_EXPR:`
`return "-";`	`return "-";`

`case BIT_NOT_EXPR:`	`case BIT_NOT_EXPR:`
`return "~";`	`return "~";`

`case TRUTH_NOT_EXPR:`	`case TRUTH_NOT_EXPR:`
`return "!";`	`return "!";`

`case MULT_EXPR:`	`case MULT_EXPR:`
`case INDIRECT_REF:`	`case INDIRECT_REF:`
`return "*";`	`return "*";`

`case ALIGN_INDIRECT_REF:`	`case ALIGN_INDIRECT_REF:`
`return "A*";`	`return "A*";`

`case MISALIGNED_INDIRECT_REF:`	`case MISALIGNED_INDIRECT_REF:`
`return "M*";`	`return "M*";`

`case TRUNC_DIV_EXPR:`	`case TRUNC_DIV_EXPR:`
`case RDIV_EXPR:`	`case RDIV_EXPR:`
`return "/";`	`return "/";`

`case CEIL_DIV_EXPR:`	`case CEIL_DIV_EXPR:`
`return "/[cl]";`	`return "/[cl]";`

`case FLOOR_DIV_EXPR:`	`case FLOOR_DIV_EXPR:`
`return "/[fl]";`	`return "/[fl]";`

`case ROUND_DIV_EXPR:`	`case ROUND_DIV_EXPR:`
`return "/[rd]";`	`return "/[rd]";`

`case EXACT_DIV_EXPR:`	`case EXACT_DIV_EXPR:`
`return "/[ex]";`	`return "/[ex]";`

`case TRUNC_MOD_EXPR:`	`case TRUNC_MOD_EXPR:`
`return "%";`	`return "%";`

`case CEIL_MOD_EXPR:`	`case CEIL_MOD_EXPR:`
`return "%[cl]";`	`return "%[cl]";`

`case FLOOR_MOD_EXPR:`	`case FLOOR_MOD_EXPR:`
`return "%[fl]";`	`return "%[fl]";`

`case ROUND_MOD_EXPR:`	`case ROUND_MOD_EXPR:`
`return "%[rd]";`	`return "%[rd]";`

`case PREDECREMENT_EXPR:`	`case PREDECREMENT_EXPR:`
`return " --";`	`return " --";`

`case PREINCREMENT_EXPR:`	`case PREINCREMENT_EXPR:`
`return " ++";`	`return " ++";`

`case POSTDECREMENT_EXPR:`	`case POSTDECREMENT_EXPR:`
`return "-- ";`	`return "-- ";`

`case POSTINCREMENT_EXPR:`	`case POSTINCREMENT_EXPR:`
`return "++ ";`	`return "++ ";`

`case MAX_EXPR:`	`case MAX_EXPR:`
`return "max";`	`return "max";`

`case MIN_EXPR:`	`case MIN_EXPR:`
`return "min";`	`return "min";`

`default:`	`default:`
`return "<<< ??? >>>";`	`return "<<< ??? >>>";`
`}`	`}`
`}`	`}`

`static const char *`	`static const char *`
`op_symbol (tree op)`	`op_symbol (tree op)`
`{`	`{`
`return op_symbol_1 (TREE_CODE (op));`	`return op_symbol_1 (TREE_CODE (op));`
`}`	`}`

`/* Prints the name of a CALL_EXPR. */`	`/* Prints the name of a CALL_EXPR. */`

`static void`	`static void`
`print_call_name (pretty_printer *buffer, tree node)`	`print_call_name (pretty_printer *buffer, tree node)`
`{`	`{`
`tree op0;`	`tree op0;`

`gcc_assert (TREE_CODE (node) == CALL_EXPR);`	`gcc_assert (TREE_CODE (node) == CALL_EXPR);`

`op0 = TREE_OPERAND (node, 0);`	`op0 = TREE_OPERAND (node, 0);`

`if (TREE_CODE (op0) == NON_LVALUE_EXPR)`	`if (TREE_CODE (op0) == NON_LVALUE_EXPR)`
`op0 = TREE_OPERAND (op0, 0);`	`op0 = TREE_OPERAND (op0, 0);`

`switch (TREE_CODE (op0))`	`switch (TREE_CODE (op0))`
`{`	`{`
`case VAR_DECL:`	`case VAR_DECL:`
`case PARM_DECL:`	`case PARM_DECL:`
`dump_function_name (buffer, op0);`	`dump_function_name (buffer, op0);`
`break;`	`break;`

`case ADDR_EXPR:`	`case ADDR_EXPR:`
`case INDIRECT_REF:`	`case INDIRECT_REF:`
`case NOP_EXPR:`	`case NOP_EXPR:`
`dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);`	`dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);`
`break;`	`break;`

`case COND_EXPR:`	`case COND_EXPR:`
`pp_string (buffer, "(");`	`pp_string (buffer, "(");`
`dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);`	`dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);`
`pp_string (buffer, ") ? ");`	`pp_string (buffer, ") ? ");`
`dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, 0, false);`	`dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, 0, false);`
`pp_string (buffer, " : ");`	`pp_string (buffer, " : ");`
`dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, 0, false);`	`dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, 0, false);`
`break;`	`break;`

`case COMPONENT_REF:`	`case COMPONENT_REF:`
`/* The function is a pointer contained in a structure. */`	`/* The function is a pointer contained in a structure. */`
`if (TREE_CODE (TREE_OPERAND (op0, 0)) == INDIRECT_REF \|\|`	`if (TREE_CODE (TREE_OPERAND (op0, 0)) == INDIRECT_REF \|\|`
`TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)`	`TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)`
`dump_function_name (buffer, TREE_OPERAND (op0, 1));`	`dump_function_name (buffer, TREE_OPERAND (op0, 1));`
`else`	`else`
`dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);`	`dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);`
`/* else`	`/* else`
`We can have several levels of structures and a function`	`We can have several levels of structures and a function`
`pointer inside. This is not implemented yet... */`	`pointer inside. This is not implemented yet... */`
`/* NIY;*/`	`/* NIY;*/`
`break;`	`break;`

`case ARRAY_REF:`	`case ARRAY_REF:`
`if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)`	`if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)`
`dump_function_name (buffer, TREE_OPERAND (op0, 0));`	`dump_function_name (buffer, TREE_OPERAND (op0, 0));`
`else`	`else`
`dump_generic_node (buffer, op0, 0, 0, false);`	`dump_generic_node (buffer, op0, 0, 0, false);`
`break;`	`break;`

`case SSA_NAME:`	`case SSA_NAME:`
`case OBJ_TYPE_REF:`	`case OBJ_TYPE_REF:`
`dump_generic_node (buffer, op0, 0, 0, false);`	`dump_generic_node (buffer, op0, 0, 0, false);`
`break;`	`break;`

`default:`	`default:`
`NIY;`	`NIY;`
`}`	`}`
`}`	`}`

`/* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */`	`/* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */`

`static void`	`static void`
`pretty_print_string (pretty_printer buffer, const char str)`	`pretty_print_string (pretty_printer buffer, const char str)`
`{`	`{`
`if (str == NULL)`	`if (str == NULL)`
`return;`	`return;`

`while (*str)`	`while (*str)`
`{`	`{`
`switch (str[0])`	`switch (str[0])`
`{`	`{`
`case '\b':`	`case '\b':`
`pp_string (buffer, "\\b");`	`pp_string (buffer, "\\b");`
`break;`	`break;`

`case '\f':`	`case '\f':`
`pp_string (buffer, "\\f");`	`pp_string (buffer, "\\f");`
`break;`	`break;`

`case '\n':`	`case '\n':`
`pp_string (buffer, "\\n");`	`pp_string (buffer, "\\n");`
`break;`	`break;`

`case '\r':`	`case '\r':`
`pp_string (buffer, "\\r");`	`pp_string (buffer, "\\r");`
`break;`	`break;`

`case '\t':`	`case '\t':`
`pp_string (buffer, "\\t");`	`pp_string (buffer, "\\t");`
`break;`	`break;`

`case '\v':`	`case '\v':`
`pp_string (buffer, "\\v");`	`pp_string (buffer, "\\v");`
`break;`	`break;`

`case '\\':`	`case '\\':`
`pp_string (buffer, "\\\\");`	`pp_string (buffer, "\\\\");`
`break;`	`break;`

`case '\"':`	`case '\"':`
`pp_string (buffer, "\\\"");`	`pp_string (buffer, "\\\"");`
`break;`	`break;`

`case '\'':`	`case '\'':`
`pp_string (buffer, "\\'");`	`pp_string (buffer, "\\'");`
`break;`	`break;`

`/* No need to handle \0; the loop terminates on \0. */`	`/* No need to handle \0; the loop terminates on \0. */`

`case '\1':`	`case '\1':`
`pp_string (buffer, "\\1");`	`pp_string (buffer, "\\1");`
`break;`	`break;`

`case '\2':`	`case '\2':`
`pp_string (buffer, "\\2");`	`pp_string (buffer, "\\2");`
`break;`	`break;`

`case '\3':`	`case '\3':`
`pp_string (buffer, "\\3");`	`pp_string (buffer, "\\3");`
`break;`	`break;`

`case '\4':`	`case '\4':`
`pp_string (buffer, "\\4");`	`pp_string (buffer, "\\4");`
`break;`	`break;`

`case '\5':`	`case '\5':`
`pp_string (buffer, "\\5");`	`pp_string (buffer, "\\5");`
`break;`	`break;`

`case '\6':`	`case '\6':`
`pp_string (buffer, "\\6");`	`pp_string (buffer, "\\6");`
`break;`	`break;`

`case '\7':`	`case '\7':`
`pp_string (buffer, "\\7");`	`pp_string (buffer, "\\7");`
`break;`	`break;`

`default:`	`default:`
`pp_character (buffer, str[0]);`	`pp_character (buffer, str[0]);`
`break;`	`break;`
`}`	`}`
`str++;`	`str++;`
`}`	`}`
`}`	`}`

`static void`	`static void`
`maybe_init_pretty_print (FILE *file)`	`maybe_init_pretty_print (FILE *file)`
`{`	`{`
`if (!initialized)`	`if (!initialized)`
`{`	`{`
`pp_construct (&buffer, /* prefix /NULL, / line-width */0);`	`pp_construct (&buffer, /* prefix /NULL, / line-width */0);`
`pp_needs_newline (&buffer) = true;`	`pp_needs_newline (&buffer) = true;`
`initialized = 1;`	`initialized = 1;`
`}`	`}`

`buffer.buffer->stream = file;`	`buffer.buffer->stream = file;`
`}`	`}`

`static void`	`static void`
`newline_and_indent (pretty_printer *buffer, int spc)`	`newline_and_indent (pretty_printer *buffer, int spc)`
`{`	`{`
`pp_newline (buffer);`	`pp_newline (buffer);`
`INDENT (spc);`	`INDENT (spc);`
`}`	`}`

`static void`	`static void`
`dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags)`	`dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags)`
`{`	`{`
`tree use;`	`tree use;`
`use_operand_p use_p;`	`use_operand_p use_p;`
`def_operand_p def_p;`	`def_operand_p def_p;`
`use_operand_p kill_p;`	`use_operand_p kill_p;`
`ssa_op_iter iter;`	`ssa_op_iter iter;`

`if (!ssa_operands_active ())`	`if (!ssa_operands_active ())`
`return;`	`return;`

`FOR_EACH_SSA_MAYDEF_OPERAND (def_p, use_p, stmt, iter)`	`FOR_EACH_SSA_MAYDEF_OPERAND (def_p, use_p, stmt, iter)`
`{`	`{`
`pp_string (buffer, "# ");`	`pp_string (buffer, "# ");`
`dump_generic_node (buffer, DEF_FROM_PTR (def_p),`	`dump_generic_node (buffer, DEF_FROM_PTR (def_p),`
`spc + 2, flags, false);`	`spc + 2, flags, false);`
`pp_string (buffer, " = V_MAY_DEF <");`	`pp_string (buffer, " = V_MAY_DEF <");`
`dump_generic_node (buffer, USE_FROM_PTR (use_p),`	`dump_generic_node (buffer, USE_FROM_PTR (use_p),`
`spc + 2, flags, false);`	`spc + 2, flags, false);`
`pp_string (buffer, ">;");`	`pp_string (buffer, ">;");`
`newline_and_indent (buffer, spc);`	`newline_and_indent (buffer, spc);`
`}`	`}`

`FOR_EACH_SSA_MUSTDEF_OPERAND (def_p, kill_p, stmt, iter)`	`FOR_EACH_SSA_MUSTDEF_OPERAND (def_p, kill_p, stmt, iter)`
`{`	`{`
`pp_string (buffer, "# ");`	`pp_string (buffer, "# ");`
`dump_generic_node (buffer, DEF_FROM_PTR (def_p),`	`dump_generic_node (buffer, DEF_FROM_PTR (def_p),`
`spc + 2, flags, false);`	`spc + 2, flags, false);`
`pp_string (buffer, " = V_MUST_DEF <");`	`pp_string (buffer, " = V_MUST_DEF <");`
`dump_generic_node (buffer, USE_FROM_PTR (kill_p),`	`dump_generic_node (buffer, USE_FROM_PTR (kill_p),`
`spc + 2, flags, false);`	`spc + 2, flags, false);`
`pp_string (buffer, ">;");`	`pp_string (buffer, ">;");`
`newline_and_indent (buffer, spc);`	`newline_and_indent (buffer, spc);`
`}`	`}`

`FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_VUSE)`	`FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_VUSE)`
`{`	`{`
`pp_string (buffer, "# VUSE <");`	`pp_string (buffer, "# VUSE <");`
`dump_generic_node (buffer, use, spc + 2, flags, false);`	`dump_generic_node (buffer, use, spc + 2, flags, false);`
`pp_string (buffer, ">;");`	`pp_string (buffer, ">;");`
`newline_and_indent (buffer, spc);`	`newline_and_indent (buffer, spc);`
`}`	`}`
`}`	`}`

`/* Dumps basic block BB to FILE with details described by FLAGS and`	`/* Dumps basic block BB to FILE with details described by FLAGS and`
`indented by INDENT spaces. */`	`indented by INDENT spaces. */`

`void`	`void`
`dump_generic_bb (FILE *file, basic_block bb, int indent, int flags)`	`dump_generic_bb (FILE *file, basic_block bb, int indent, int flags)`
`{`	`{`
`maybe_init_pretty_print (file);`	`maybe_init_pretty_print (file);`
`dump_generic_bb_buff (&buffer, bb, indent, flags);`	`dump_generic_bb_buff (&buffer, bb, indent, flags);`
`pp_flush (&buffer);`	`pp_flush (&buffer);`
`}`	`}`

`/* Dumps header of basic block BB to buffer BUFFER indented by INDENT`	`/* Dumps header of basic block BB to buffer BUFFER indented by INDENT`
`spaces and details described by flags. */`	`spaces and details described by flags. */`

`static void`	`static void`
`dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags)`	`dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags)`
`{`	`{`
`edge e;`	`edge e;`
`tree stmt;`	`tree stmt;`
`edge_iterator ei;`	`edge_iterator ei;`

`if (flags & TDF_BLOCKS)`	`if (flags & TDF_BLOCKS)`
`{`	`{`
`INDENT (indent);`	`INDENT (indent);`
`pp_string (buffer, "# BLOCK ");`	`pp_string (buffer, "# BLOCK ");`
`pp_decimal_int (buffer, bb->index);`	`pp_decimal_int (buffer, bb->index);`
`if (bb->frequency)`	`if (bb->frequency)`
`{`	`{`
`pp_string (buffer, " freq:");`	`pp_string (buffer, " freq:");`
`pp_decimal_int (buffer, bb->frequency);`	`pp_decimal_int (buffer, bb->frequency);`
`}`	`}`
`if (bb->count)`	`if (bb->count)`
`{`	`{`
`pp_string (buffer, " count:");`	`pp_string (buffer, " count:");`
`pp_widest_integer (buffer, bb->count);`	`pp_widest_integer (buffer, bb->count);`
`}`	`}`

`if (flags & TDF_LINENO)`	`if (flags & TDF_LINENO)`
`{`	`{`
`block_stmt_iterator bsi;`	`block_stmt_iterator bsi;`

`for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))`	`for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))`
`if (get_lineno (bsi_stmt (bsi)) != -1)`	`if (get_lineno (bsi_stmt (bsi)) != -1)`
`{`	`{`
`pp_string (buffer, ", starting at line ");`	`pp_string (buffer, ", starting at line ");`
`pp_decimal_int (buffer, get_lineno (bsi_stmt (bsi)));`	`pp_decimal_int (buffer, get_lineno (bsi_stmt (bsi)));`
`break;`	`break;`
`}`	`}`
`}`	`}`
`newline_and_indent (buffer, indent);`	`newline_and_indent (buffer, indent);`

`pp_string (buffer, "# PRED:");`	`pp_string (buffer, "# PRED:");`
`pp_write_text_to_stream (buffer);`	`pp_write_text_to_stream (buffer);`
`FOR_EACH_EDGE (e, ei, bb->preds)`	`FOR_EACH_EDGE (e, ei, bb->preds)`
`if (flags & TDF_SLIM)`	`if (flags & TDF_SLIM)`
`{`	`{`
`pp_string (buffer, " ");`	`pp_string (buffer, " ");`
`if (e->src == ENTRY_BLOCK_PTR)`	`if (e->src == ENTRY_BLOCK_PTR)`
`pp_string (buffer, "ENTRY");`	`pp_string (buffer, "ENTRY");`
`else`	`else`
`pp_decimal_int (buffer, e->src->index);`	`pp_decimal_int (buffer, e->src->index);`
`}`	`}`
`else`	`else`
`dump_edge_info (buffer->buffer->stream, e, 0);`	`dump_edge_info (buffer->buffer->stream, e, 0);`
`pp_newline (buffer);`	`pp_newline (buffer);`
`}`	`}`
`else`	`else`
`{`	`{`
`stmt = first_stmt (bb);`	`stmt = first_stmt (bb);`
`if (!stmt \|\| TREE_CODE (stmt) != LABEL_EXPR)`	`if (!stmt \|\| TREE_CODE (stmt) != LABEL_EXPR)`
`{`	`{`
`INDENT (indent - 2);`	`INDENT (indent - 2);`
`pp_string (buffer, "<bb ");`	`pp_string (buffer, "<bb ");`
`pp_decimal_int (buffer, bb->index);`	`pp_decimal_int (buffer, bb->index);`
`pp_string (buffer, ">:");`	`pp_string (buffer, ">:");`
`pp_newline (buffer);`	`pp_newline (buffer);`
`}`	`}`
`}`	`}`
`pp_write_text_to_stream (buffer);`	`pp_write_text_to_stream (buffer);`
`check_bb_profile (bb, buffer->buffer->stream);`	`check_bb_profile (bb, buffer->buffer->stream);`
`}`	`}`

`/* Dumps end of basic block BB to buffer BUFFER indented by INDENT`	`/* Dumps end of basic block BB to buffer BUFFER indented by INDENT`
`spaces. */`	`spaces. */`

`static void`	`static void`
`dump_bb_end (pretty_printer *buffer, basic_block bb, int indent, int flags)`	`dump_bb_end (pretty_printer *buffer, basic_block bb, int indent, int flags)`
`{`	`{`
`edge e;`	`edge e;`
`edge_iterator ei;`	`edge_iterator ei;`

`INDENT (indent);`	`INDENT (indent);`
`pp_string (buffer, "# SUCC:");`	`pp_string (buffer, "# SUCC:");`
`pp_write_text_to_stream (buffer);`	`pp_write_text_to_stream (buffer);`
`FOR_EACH_EDGE (e, ei, bb->succs)`	`FOR_EACH_EDGE (e, ei, bb->succs)`
`if (flags & TDF_SLIM)`	`if (flags & TDF_SLIM)`
`{`	`{`
`pp_string (buffer, " ");`	`pp_string (buffer, " ");`
`if (e->dest == EXIT_BLOCK_PTR)`	`if (e->dest == EXIT_BLOCK_PTR)`
`pp_string (buffer, "EXIT");`	`pp_string (buffer, "EXIT");`
`else`	`else`
`pp_decimal_int (buffer, e->dest->index);`	`pp_decimal_int (buffer, e->dest->index);`
`}`	`}`
`else`	`else`
`dump_edge_info (buffer->buffer->stream, e, 1);`	`dump_edge_info (buffer->buffer->stream, e, 1);`
`pp_newline (buffer);`	`pp_newline (buffer);`
`}`	`}`

`/* Dumps phi nodes of basic block BB to buffer BUFFER with details described by`	`/* Dumps phi nodes of basic block BB to buffer BUFFER with details described by`
`FLAGS indented by INDENT spaces. */`	`FLAGS indented by INDENT spaces. */`

`static void`	`static void`
`dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags)`	`dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags)`
`{`	`{`
`tree phi = phi_nodes (bb);`	`tree phi = phi_nodes (bb);`
`if (!phi)`	`if (!phi)`
`return;`	`return;`

`for (; phi; phi = PHI_CHAIN (phi))`	`for (; phi; phi = PHI_CHAIN (phi))`
`{`	`{`
`if (is_gimple_reg (PHI_RESULT (phi)) \|\| (flags & TDF_VOPS))`	`if (is_gimple_reg (PHI_RESULT (phi)) \|\| (flags & TDF_VOPS))`
`{`	`{`
`INDENT (indent);`	`INDENT (indent);`
`pp_string (buffer, "# ");`	`pp_string (buffer, "# ");`
`dump_generic_node (buffer, phi, indent, flags, false);`	`dump_generic_node (buffer, phi, indent, flags, false);`
`pp_newline (buffer);`	`pp_newline (buffer);`
`}`	`}`
`}`	`}`
`}`	`}`

`/* Dump jump to basic block BB that is represented implicitly in the cfg`	`/* Dump jump to basic block BB that is represented implicitly in the cfg`
`to BUFFER. */`	`to BUFFER. */`

`static void`	`static void`
`pp_cfg_jump (pretty_printer *buffer, basic_block bb)`	`pp_cfg_jump (pretty_printer *buffer, basic_block bb)`
`{`	`{`
`tree stmt;`	`tree stmt;`

`stmt = first_stmt (bb);`	`stmt = first_stmt (bb);`

`pp_string (buffer, "goto <bb ");`	`pp_string (buffer, "goto <bb ");`
`pp_decimal_int (buffer, bb->index);`	`pp_decimal_int (buffer, bb->index);`
`pp_string (buffer, ">");`	`pp_string (buffer, ">");`
`if (stmt && TREE_CODE (stmt) == LABEL_EXPR)`	`if (stmt && TREE_CODE (stmt) == LABEL_EXPR)`
`{`	`{`
`pp_string (buffer, " (");`	`pp_string (buffer, " (");`
`dump_generic_node (buffer, LABEL_EXPR_LABEL (stmt), 0, 0, false);`	`dump_generic_node (buffer, LABEL_EXPR_LABEL (stmt), 0, 0, false);`
`pp_string (buffer, ")");`	`pp_string (buffer, ")");`
`}`	`}`
`pp_semicolon (buffer);`	`pp_semicolon (buffer);`
`}`	`}`

`/* Dump edges represented implicitly in basic block BB to BUFFER, indented`	`/* Dump edges represented implicitly in basic block BB to BUFFER, indented`
`by INDENT spaces, with details given by FLAGS. */`	`by INDENT spaces, with details given by FLAGS. */`

`static void`	`static void`
`dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,`	`dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,`
`int flags)`	`int flags)`
`{`	`{`
`edge e;`	`edge e;`
`edge_iterator ei;`	`edge_iterator ei;`

`/* If there is a fallthru edge, we may need to add an artificial goto to the`	`/* If there is a fallthru edge, we may need to add an artificial goto to the`
`dump. */`	`dump. */`
`FOR_EACH_EDGE (e, ei, bb->succs)`	`FOR_EACH_EDGE (e, ei, bb->succs)`
`if (e->flags & EDGE_FALLTHRU)`	`if (e->flags & EDGE_FALLTHRU)`
`break;`	`break;`
`if (e && e->dest != bb->next_bb)`	`if (e && e->dest != bb->next_bb)`
`{`	`{`
`INDENT (indent);`	`INDENT (indent);`

`if ((flags & TDF_LINENO)`	`if ((flags & TDF_LINENO)`
`#ifdef USE_MAPPED_LOCATION`	`#ifdef USE_MAPPED_LOCATION`
`&& e->goto_locus != UNKNOWN_LOCATION`	`&& e->goto_locus != UNKNOWN_LOCATION`
`#else`	`#else`
`&& e->goto_locus`	`&& e->goto_locus`
`#endif`	`#endif`
`)`	`)`
`{`	`{`
`expanded_location goto_xloc;`	`expanded_location goto_xloc;`
`#ifdef USE_MAPPED_LOCATION`	`#ifdef USE_MAPPED_LOCATION`
`goto_xloc = expand_location (e->goto_locus);`	`goto_xloc = expand_location (e->goto_locus);`
`#else`	`#else`
`goto_xloc = *e->goto_locus;`	`goto_xloc = *e->goto_locus;`
`#endif`	`#endif`
`pp_character (buffer, '[');`	`pp_character (buffer, '[');`
`if (goto_xloc.file)`	`if (goto_xloc.file)`
`{`	`{`
`pp_string (buffer, goto_xloc.file);`	`pp_string (buffer, goto_xloc.file);`
`pp_string (buffer, " : ");`	`pp_string (buffer, " : ");`
`}`	`}`
`pp_decimal_int (buffer, goto_xloc.line);`	`pp_decimal_int (buffer, goto_xloc.line);`
`pp_string (buffer, "] ");`	`pp_string (buffer, "] ");`
`}`	`}`

`pp_cfg_jump (buffer, e->dest);`	`pp_cfg_jump (buffer, e->dest);`
`pp_newline (buffer);`	`pp_newline (buffer);`
`}`	`}`
`}`	`}`

`/* Dumps basic block BB to buffer BUFFER with details described by FLAGS and`	`/* Dumps basic block BB to buffer BUFFER with details described by FLAGS and`
`indented by INDENT spaces. */`	`indented by INDENT spaces. */`

`static void`	`static void`
`dump_generic_bb_buff (pretty_printer *buffer, basic_block bb,`	`dump_generic_bb_buff (pretty_printer *buffer, basic_block bb,`
`int indent, int flags)`	`int indent, int flags)`
`{`	`{`
`block_stmt_iterator bsi;`	`block_stmt_iterator bsi;`
`tree stmt;`	`tree stmt;`
`int label_indent = indent - 2;`	`int label_indent = indent - 2;`

`if (label_indent < 0)`	`if (label_indent < 0)`
`label_indent = 0;`	`label_indent = 0;`

`dump_bb_header (buffer, bb, indent, flags);`	`dump_bb_header (buffer, bb, indent, flags);`

`dump_phi_nodes (buffer, bb, indent, flags);`	`dump_phi_nodes (buffer, bb, indent, flags);`

`for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))`	`for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))`
`{`	`{`
`int curr_indent;`	`int curr_indent;`

`stmt = bsi_stmt (bsi);`	`stmt = bsi_stmt (bsi);`

`curr_indent = TREE_CODE (stmt) == LABEL_EXPR ? label_indent : indent;`	`curr_indent = TREE_CODE (stmt) == LABEL_EXPR ? label_indent : indent;`

`INDENT (curr_indent);`	`INDENT (curr_indent);`
`dump_generic_node (buffer, stmt, curr_indent, flags, true);`	`dump_generic_node (buffer, stmt, curr_indent, flags, true);`
`pp_newline (buffer);`	`pp_newline (buffer);`
`}`	`}`

`dump_implicit_edges (buffer, bb, indent, flags);`	`dump_implicit_edges (buffer, bb, indent, flags);`

`if (flags & TDF_BLOCKS)`	`if (flags & TDF_BLOCKS)`
`dump_bb_end (buffer, bb, indent, flags);`	`dump_bb_end (buffer, bb, indent, flags);`
`}`	`}`

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [tree-pretty-print.c] - Diff between revs 154 and 816