X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Ftree-pretty-print.c;h=d33d8315adae0130c48def3129903279ae80e839;hb=4e970fe40fcb363c66c7d513409dbff8e35c611c;hp=ce1f750125a3aab7f62463b7cf52132704271669;hpb=318a728f904732ccea8f616d2694af282ccfc848;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/tree-pretty-print.c b/gcc/tree-pretty-print.c index ce1f750125a..d33d8315ada 100644 --- a/gcc/tree-pretty-print.c +++ b/gcc/tree-pretty-print.c @@ -1,5 +1,6 @@ /* Pretty formatting of GENERIC trees in C syntax. - Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc. + Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 + Free Software Foundation, Inc. Adapted from c-pretty-print.c by Diego Novillo This file is part of GCC. @@ -16,14 +17,13 @@ for more details. You should have received a copy of the GNU General Public License along with GCC; see the file COPYING. If not, write to the Free -Software Foundation, 59 Temple Place - Suite 330, Boston, MA -02111-1307, USA. */ +Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301, USA. */ #include "config.h" #include "system.h" #include "coretypes.h" #include "tm.h" -#include "errors.h" #include "tree.h" #include "diagnostic.h" #include "real.h" @@ -31,9 +31,12 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "tree-flow.h" #include "langhooks.h" #include "tree-iterator.h" +#include "tree-chrec.h" +#include "tree-pass.h" /* Local functions, macros and variables. */ static int op_prio (tree); +static const char *op_symbol_1 (enum tree_code); static const char *op_symbol (tree); static void pretty_print_string (pretty_printer *, const char*); static void print_call_name (pretty_printer *, tree); @@ -55,11 +58,8 @@ static void dump_generic_bb_buff (pretty_printer *, basic_block, int, int); lang_hooks.decl_printable_name (TREE_OPERAND (NODE, 0), 1) : \ lang_hooks.decl_printable_name (NODE, 1)) -#define MASK_POINTER(P) ((unsigned)((unsigned long)(P) & 0xffff)) - static pretty_printer buffer; static int initialized = 0; -static bool dumping_stmts; /* Try to print something for an unknown tree code. */ @@ -71,9 +71,9 @@ do_niy (pretty_printer *buffer, tree node) pp_string (buffer, "<<< Unknown tree: "); pp_string (buffer, tree_code_name[(int) TREE_CODE (node)]); - if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (node)))) + if (EXPR_P (node)) { - len = first_rtl_op (TREE_CODE (node)); + len = TREE_CODE_LENGTH (TREE_CODE (node)); for (i = 0; i < len; ++i) { newline_and_indent (buffer, 2); @@ -98,12 +98,23 @@ debug_generic_stmt (tree t) fprintf (stderr, "\n"); } +void +debug_tree_chain (tree t) +{ + while (t) + { + print_generic_expr (stderr, t, TDF_VOPS|TDF_UID); + fprintf(stderr, " "); + t = TREE_CHAIN (t); + } + fprintf (stderr, "\n"); +} + /* Prints declaration DECL to the FILE with details specified by FLAGS. */ void print_generic_decl (FILE *file, tree decl, int flags) { maybe_init_pretty_print (file); - dumping_stmts = true; print_declaration (&buffer, decl, 2, flags); pp_write_text_to_stream (&buffer); } @@ -115,7 +126,6 @@ void print_generic_stmt (FILE *file, tree t, int flags) { maybe_init_pretty_print (file); - dumping_stmts = true; dump_generic_node (&buffer, t, 0, flags, true); pp_flush (&buffer); } @@ -130,7 +140,6 @@ print_generic_stmt_indented (FILE *file, tree t, int flags, int indent) int i; maybe_init_pretty_print (file); - dumping_stmts = true; for (i = 0; i < indent; i++) pp_space (&buffer); @@ -145,7 +154,6 @@ void print_generic_expr (FILE *file, tree t, int flags) { maybe_init_pretty_print (file); - dumping_stmts = false; dump_generic_node (&buffer, t, 0, flags, false); } @@ -155,21 +163,245 @@ print_generic_expr (FILE *file, tree t, int flags) static void dump_decl_name (pretty_printer *buffer, tree node, int flags) { - if (DECL_NAME (node)) - pp_tree_identifier (buffer, DECL_NAME (node)); + tree t = node; + if (DECL_NAME (t)) + pp_tree_identifier (buffer, DECL_NAME (t)); if ((flags & TDF_UID) - || DECL_NAME (node) == NULL_TREE) + || DECL_NAME (t) == NULL_TREE) { - if (TREE_CODE (node) == LABEL_DECL - && LABEL_DECL_UID (node) != -1) - pp_printf (buffer, "", - LABEL_DECL_UID (node)); + if (TREE_CODE (t) == LABEL_DECL + && LABEL_DECL_UID (t) != -1) + pp_printf (buffer, "L." HOST_WIDE_INT_PRINT_DEC, + LABEL_DECL_UID (t)); + else + { + char c = TREE_CODE (t) == CONST_DECL ? 'C' : 'D'; + pp_printf (buffer, "%c.%u", c, DECL_UID (t)); + } + } +} + +/* Like the above, but used for pretty printing function calls. */ + +static void +dump_function_name (pretty_printer *buffer, tree node) +{ + if (DECL_NAME (node)) + PRINT_FUNCTION_NAME (node); + else + dump_decl_name (buffer, node, 0); +} + +/* Dump a function declaration. NODE is the FUNCTION_TYPE. BUFFER, SPC and + FLAGS are as in dump_generic_node. */ + +static void +dump_function_declaration (pretty_printer *buffer, tree node, + int spc, int flags) +{ + bool wrote_arg = false; + tree arg; + + pp_space (buffer); + pp_character (buffer, '('); + + /* Print the argument types. The last element in the list is a VOID_TYPE. + The following avoids printing the last element. */ + arg = TYPE_ARG_TYPES (node); + while (arg && TREE_CHAIN (arg) && arg != error_mark_node) + { + wrote_arg = true; + dump_generic_node (buffer, TREE_VALUE (arg), spc, flags, false); + arg = TREE_CHAIN (arg); + if (TREE_CHAIN (arg) && TREE_CODE (TREE_CHAIN (arg)) == TREE_LIST) + { + pp_character (buffer, ','); + pp_space (buffer); + } + } + + if (!wrote_arg) + pp_string (buffer, "void"); + + pp_character (buffer, ')'); +} + +/* Dump the domain associated with an array. */ + +static void +dump_array_domain (pretty_printer *buffer, tree domain, int spc, int flags) +{ + pp_character (buffer, '['); + if (domain) + { + tree min = TYPE_MIN_VALUE (domain); + tree max = TYPE_MAX_VALUE (domain); + + if (min && max + && integer_zerop (min) + && host_integerp (max, 0)) + pp_wide_integer (buffer, TREE_INT_CST_LOW (max) + 1); else - pp_printf (buffer, "", DECL_UID (node)); + { + if (min) + dump_generic_node (buffer, min, spc, flags, false); + pp_character (buffer, ':'); + if (max) + dump_generic_node (buffer, max, spc, flags, false); + } + } + else + pp_string (buffer, ""); + pp_character (buffer, ']'); +} + + +/* Dump OpenMP clause CLAUSE. BUFFER, CLAUSE, SPC and FLAGS are as in + dump_generic_node. */ + +static void +dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags) +{ + const char *name; + + switch (OMP_CLAUSE_CODE (clause)) + { + case OMP_CLAUSE_PRIVATE: + name = "private"; + goto print_remap; + case OMP_CLAUSE_SHARED: + name = "shared"; + goto print_remap; + case OMP_CLAUSE_FIRSTPRIVATE: + name = "firstprivate"; + goto print_remap; + case OMP_CLAUSE_LASTPRIVATE: + name = "lastprivate"; + goto print_remap; + case OMP_CLAUSE_COPYIN: + name = "copyin"; + goto print_remap; + case OMP_CLAUSE_COPYPRIVATE: + name = "copyprivate"; + goto print_remap; + print_remap: + pp_string (buffer, name); + pp_character (buffer, '('); + dump_generic_node (buffer, OMP_CLAUSE_DECL (clause), + spc, flags, false); + pp_character (buffer, ')'); + break; + + case OMP_CLAUSE_REDUCTION: + pp_string (buffer, "reduction("); + pp_string (buffer, op_symbol_1 (OMP_CLAUSE_REDUCTION_CODE (clause))); + pp_character (buffer, ':'); + dump_generic_node (buffer, OMP_CLAUSE_DECL (clause), + spc, flags, false); + pp_character (buffer, ')'); + break; + + case OMP_CLAUSE_IF: + pp_string (buffer, "if("); + dump_generic_node (buffer, OMP_CLAUSE_IF_EXPR (clause), + spc, flags, false); + pp_character (buffer, ')'); + break; + + case OMP_CLAUSE_NUM_THREADS: + pp_string (buffer, "num_threads("); + dump_generic_node (buffer, OMP_CLAUSE_NUM_THREADS_EXPR (clause), + spc, flags, false); + pp_character (buffer, ')'); + break; + + case OMP_CLAUSE_NOWAIT: + pp_string (buffer, "nowait"); + break; + case OMP_CLAUSE_ORDERED: + pp_string (buffer, "ordered"); + break; + + case OMP_CLAUSE_DEFAULT: + pp_string (buffer, "default("); + switch (OMP_CLAUSE_DEFAULT_KIND (clause)) + { + case OMP_CLAUSE_DEFAULT_UNSPECIFIED: + break; + case OMP_CLAUSE_DEFAULT_SHARED: + pp_string (buffer, "shared"); + break; + case OMP_CLAUSE_DEFAULT_NONE: + pp_string (buffer, "none"); + break; + case OMP_CLAUSE_DEFAULT_PRIVATE: + pp_string (buffer, "private"); + break; + default: + gcc_unreachable (); + } + pp_character (buffer, ')'); + break; + + case OMP_CLAUSE_SCHEDULE: + pp_string (buffer, "schedule("); + switch (OMP_CLAUSE_SCHEDULE_KIND (clause)) + { + case OMP_CLAUSE_SCHEDULE_STATIC: + pp_string (buffer, "static"); + break; + case OMP_CLAUSE_SCHEDULE_DYNAMIC: + pp_string (buffer, "dynamic"); + break; + case OMP_CLAUSE_SCHEDULE_GUIDED: + pp_string (buffer, "guided"); + break; + case OMP_CLAUSE_SCHEDULE_RUNTIME: + pp_string (buffer, "runtime"); + break; + default: + gcc_unreachable (); + } + if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause)) + { + pp_character (buffer, ','); + dump_generic_node (buffer, + OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause), + spc, flags, false); + } + pp_character (buffer, ')'); + break; + + default: + /* Should never happen. */ + dump_generic_node (buffer, clause, spc, flags, false); + break; + } +} + + +/* Dump the list of OpenMP clauses. BUFFER, SPC and FLAGS are as in + dump_generic_node. */ + +static void +dump_omp_clauses (pretty_printer *buffer, tree clause, int spc, int flags) +{ + if (clause == NULL) + return; + + pp_space (buffer); + while (1) + { + dump_omp_clause (buffer, clause, spc, flags); + clause = OMP_CLAUSE_CHAIN (clause); + if (clause == NULL) + return; + pp_space (buffer); } } + /* 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 IS_STMT is true, the object printed is considered to be a statement @@ -181,7 +413,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, { tree type; tree op0, op1; - const char* str; + const char *str; bool is_expr; if (node == NULL_TREE) @@ -189,23 +421,30 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, is_expr = EXPR_P (node); + /* We use has_stmt_ann because CALL_EXPR can be both an expression + and a statement, and we have no guarantee that it will have a + stmt_ann when it is used as an RHS expression. stmt_ann will assert + if you call it on something with a non-stmt annotation attached. */ if (TREE_CODE (node) != ERROR_MARK && is_gimple_stmt (node) && (flags & TDF_VOPS) - && stmt_ann (node)) + && has_stmt_ann (node) + && TREE_CODE (node) != PHI_NODE) dump_vops (buffer, node, spc, flags); - if (dumping_stmts - && (flags & TDF_LINENO) - && EXPR_HAS_LOCATION (node)) + if (is_stmt && (flags & TDF_STMTADDR)) + pp_printf (buffer, "<&%p> ", (void *)node); + + if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node)) { + expanded_location xloc = expand_location (EXPR_LOCATION (node)); pp_character (buffer, '['); - if (EXPR_FILENAME (node)) + if (xloc.file) { - pp_string (buffer, EXPR_FILENAME (node)); + pp_string (buffer, xloc.file); pp_string (buffer, " : "); } - pp_decimal_int (buffer, EXPR_LINENO (node)); + pp_decimal_int (buffer, xloc.line); pp_string (buffer, "] "); } @@ -237,12 +476,26 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, } break; - case TREE_VEC: + case TREE_BINFO: dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false); - break; - case BLOCK: - NIY; + case TREE_VEC: + { + size_t i; + if (TREE_VEC_LENGTH (node) > 0) + { + size_t len = TREE_VEC_LENGTH (node); + for (i = 0; i < len - 1; i++) + { + dump_generic_node (buffer, TREE_VEC_ELT (node, i), spc, flags, + false); + pp_character (buffer, ','); + pp_space (buffer); + } + dump_generic_node (buffer, TREE_VEC_ELT (node, len - 1), spc, + flags, false); + } + } break; case VOID_TYPE: @@ -252,10 +505,9 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, case VECTOR_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE: - case CHAR_TYPE: { unsigned int quals = TYPE_QUALS (node); - char class; + enum tree_code_class class; if (quals & TYPE_QUAL_CONST) pp_string (buffer, "const "); @@ -266,14 +518,14 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, class = TREE_CODE_CLASS (TREE_CODE (node)); - if (class == 'd') + if (class == tcc_declaration) { if (DECL_NAME (node)) dump_decl_name (buffer, node, flags); else pp_string (buffer, ""); } - else if (class == 't') + else if (class == tcc_type) { if (TYPE_NAME (node)) { @@ -283,7 +535,13 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, && DECL_NAME (TYPE_NAME (node))) dump_decl_name (buffer, TYPE_NAME (node), flags); else - pp_string (buffer, ""); + pp_string (buffer, ""); + } + else if (TREE_CODE (node) == VECTOR_TYPE) + { + pp_string (buffer, "vector "); + dump_generic_node (buffer, TREE_TYPE (node), + spc, flags, false); } else pp_string (buffer, ""); @@ -298,6 +556,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE) { tree fnode = TREE_TYPE (node); + dump_generic_node (buffer, TREE_TYPE (fnode), spc, flags, false); pp_space (buffer); pp_character (buffer, '('); @@ -308,24 +567,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, pp_printf (buffer, "", TYPE_UID (node)); pp_character (buffer, ')'); - pp_space (buffer); - pp_character (buffer, '('); - /* Print the argument types. The last element in the list is a - VOID_TYPE. The following avoid to print the last element. */ - { - tree tmp = TYPE_ARG_TYPES (fnode); - while (tmp && TREE_CHAIN (tmp) && tmp != error_mark_node) - { - dump_generic_node (buffer, TREE_VALUE (tmp), spc, flags, false); - tmp = TREE_CHAIN (tmp); - if (TREE_CHAIN (tmp) && TREE_CODE (TREE_CHAIN (tmp)) == TREE_LIST) - { - pp_character (buffer, ','); - pp_space (buffer); - } - } - } - pp_character (buffer, ')'); + dump_function_declaration (buffer, fnode, spc, flags); } else { @@ -341,6 +583,9 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, pp_string (buffer, "volatile"); else if (quals & TYPE_QUAL_RESTRICT) pp_string (buffer, " restrict"); + + if (TYPE_REF_CAN_ALIAS_ALL (node)) + pp_string (buffer, " {ref-all}"); } break; @@ -353,45 +598,83 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, pp_string (buffer, "::"); break; - case FILE_TYPE: - NIY; + case TARGET_MEM_REF: + { + const char *sep = ""; + tree tmp; + + pp_string (buffer, "MEM["); + + tmp = TMR_SYMBOL (node); + if (tmp) + { + pp_string (buffer, sep); + sep = ", "; + pp_string (buffer, "symbol: "); + dump_generic_node (buffer, tmp, spc, flags, false); + } + tmp = TMR_BASE (node); + if (tmp) + { + pp_string (buffer, sep); + sep = ", "; + pp_string (buffer, "base: "); + dump_generic_node (buffer, tmp, spc, flags, false); + } + tmp = TMR_INDEX (node); + if (tmp) + { + pp_string (buffer, sep); + sep = ", "; + pp_string (buffer, "index: "); + dump_generic_node (buffer, tmp, spc, flags, false); + } + tmp = TMR_STEP (node); + if (tmp) + { + pp_string (buffer, sep); + sep = ", "; + pp_string (buffer, "step: "); + dump_generic_node (buffer, tmp, spc, flags, false); + } + tmp = TMR_OFFSET (node); + if (tmp) + { + pp_string (buffer, sep); + sep = ", "; + pp_string (buffer, "offset: "); + dump_generic_node (buffer, tmp, spc, flags, false); + } + pp_string (buffer, "]"); + if (flags & TDF_DETAILS) + { + pp_string (buffer, "{"); + dump_generic_node (buffer, TMR_ORIGINAL (node), spc, flags, + false); + pp_string (buffer, "}"); + } + } break; case ARRAY_TYPE: { tree tmp; - /* Print the array type. */ - dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false); + /* Print the innermost component type. */ + for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE; + tmp = TREE_TYPE (tmp)) + ; + dump_generic_node (buffer, tmp, spc, flags, false); /* Print the dimensions. */ - tmp = node; - while (tmp && TREE_CODE (tmp) == ARRAY_TYPE) - { - pp_character (buffer, '['); - if (TYPE_SIZE (tmp)) - { - tree size = TYPE_SIZE (tmp); - if (TREE_CODE (size) == INTEGER_CST) - pp_wide_integer (buffer, - TREE_INT_CST_LOW (TYPE_SIZE (tmp)) / - TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (tmp)))); - else if (TREE_CODE (size) == MULT_EXPR) - dump_generic_node (buffer, TREE_OPERAND (size, 0), spc, flags, false); - /* else punt. */ - } - pp_character (buffer, ']'); - 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); break; } - case SET_TYPE: - NIY; - break; - case RECORD_TYPE: case UNION_TYPE: + case QUAL_UNION_TYPE: /* Print the name of the structure. */ if (TREE_CODE (node) == RECORD_TYPE) pp_string (buffer, "struct "); @@ -404,11 +687,6 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, print_struct_decl (buffer, node, spc, flags); break; - case QUAL_UNION_TYPE: - NIY; - break; - - case LANG_TYPE: NIY; break; @@ -446,17 +724,15 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, if (tree_int_cst_sgn (val) < 0) { pp_character (buffer, '-'); - val = build_int_2 (-TREE_INT_CST_LOW (val), - ~TREE_INT_CST_HIGH (val) - + !TREE_INT_CST_LOW (val)); + val = build_int_cst_wide (NULL_TREE, + -TREE_INT_CST_LOW (val), + ~TREE_INT_CST_HIGH (val) + + !TREE_INT_CST_LOW (val)); } /* Would "%x%0*x" or "%x%*0x" get zero-padding on all systems? */ { - static char format[10]; /* "%x%09999x\0" */ - if (!format[0]) - sprintf (format, "%%x%%0%dx", HOST_BITS_PER_INT / 4); - sprintf (pp_buffer (buffer)->digit_buffer, format, + sprintf (pp_buffer (buffer)->digit_buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX, TREE_INT_CST_HIGH (val), TREE_INT_CST_LOW (val)); pp_string (buffer, pp_buffer (buffer)->digit_buffer); @@ -476,7 +752,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC) d = TREE_REAL_CST (node); if (REAL_VALUE_ISINF (d)) - pp_string (buffer, " Inf"); + pp_string (buffer, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf"); else if (REAL_VALUE_ISNAN (d)) pp_string (buffer, " Nan"); else @@ -544,34 +820,37 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, break; case TYPE_DECL: - if (strcmp (DECL_SOURCE_FILE (node), "") == 0) + if (DECL_IS_BUILTIN (node)) { /* Don't print the declaration of built-in types. */ break; } if (DECL_NAME (node)) - { - dump_decl_name (buffer, node, flags); - } + dump_decl_name (buffer, node, flags); else { - if (TYPE_METHODS (TREE_TYPE (node))) + if ((TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE + || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE) + && TYPE_METHODS (TREE_TYPE (node))) { /* The type is a c++ class: all structures have at least - 4 methods. */ + 4 methods. */ pp_string (buffer, "class "); dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false); } else { - pp_string (buffer, "struct "); + pp_string (buffer, + (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE + ? "union" : "struct ")); dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false); - pp_character (buffer, ';'); - pp_newline (buffer); } } break; + case SYMBOL_MEMORY_TAG: + case NAME_MEMORY_TAG: + case STRUCT_FIELD_TAG: case VAR_DECL: case PARM_DECL: case FIELD_DECL: @@ -598,6 +877,17 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, pp_character (buffer, ')'); pp_string (buffer, str); dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); + + if (TREE_CODE (op0) != VALUE_HANDLE) + { + op0 = component_ref_field_offset (node); + if (op0 && TREE_CODE (op0) != INTEGER_CST) + { + pp_string (buffer, "{off: "); + dump_generic_node (buffer, op0, spc, flags, false); + pp_character (buffer, '}'); + } + } break; case BIT_FIELD_REF: @@ -610,11 +900,8 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, pp_string (buffer, ">"); break; - case BUFFER_REF: - NIY; - break; - case ARRAY_REF: + case ARRAY_RANGE_REF: op0 = TREE_OPERAND (node, 0); if (op_prio (op0) < op_prio (node)) pp_character (buffer, '('); @@ -623,45 +910,50 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, pp_character (buffer, ')'); pp_character (buffer, '['); dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); + if (TREE_CODE (node) == ARRAY_RANGE_REF) + pp_string (buffer, " ..."); pp_character (buffer, ']'); - break; - case ARRAY_RANGE_REF: - NIY; + op0 = array_ref_low_bound (node); + op1 = array_ref_element_size (node); + + if (!integer_zerop (op0) + || (TYPE_SIZE_UNIT (TREE_TYPE (node)) + && !operand_equal_p (op1, TYPE_SIZE_UNIT (TREE_TYPE (node)), 0))) + { + pp_string (buffer, "{lb: "); + dump_generic_node (buffer, op0, spc, flags, false); + pp_string (buffer, " sz: "); + dump_generic_node (buffer, op1, spc, flags, false); + pp_character (buffer, '}'); + } break; case CONSTRUCTOR: { - tree lnode; + unsigned HOST_WIDE_INT ix; + tree field, val; bool is_struct_init = FALSE; pp_character (buffer, '{'); - lnode = CONSTRUCTOR_ELTS (node); if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE) is_struct_init = TRUE; - while (lnode && lnode != error_mark_node) + FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val) { - tree val; - if (TREE_PURPOSE (lnode) && is_struct_init) + if (field && is_struct_init) { pp_character (buffer, '.'); - dump_generic_node (buffer, TREE_PURPOSE (lnode), spc, flags, false); + dump_generic_node (buffer, field, spc, flags, false); pp_string (buffer, "="); } - val = TREE_VALUE (lnode); if (val && TREE_CODE (val) == ADDR_EXPR) if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL) val = TREE_OPERAND (val, 0); if (val && TREE_CODE (val) == FUNCTION_DECL) - { dump_decl_name (buffer, val, flags); - } else - { - dump_generic_node (buffer, TREE_VALUE (lnode), spc, flags, false); - } - lnode = TREE_CHAIN (lnode); - if (lnode && TREE_CODE (lnode) == TREE_LIST) + dump_generic_node (buffer, val, spc, flags, false); + if (ix != VEC_length (constructor_elt, CONSTRUCTOR_ELTS (node)) - 1) { pp_character (buffer, ','); pp_space (buffer); @@ -681,8 +973,8 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, } dump_generic_node (buffer, TREE_OPERAND (node, 0), - spc, flags, dumping_stmts); - if (dumping_stmts) + spc, flags, !(flags & TDF_SLIM)); + if (flags & TDF_SLIM) newline_and_indent (buffer, spc); else { @@ -695,8 +987,8 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, tp = &TREE_OPERAND (*tp, 1)) { dump_generic_node (buffer, TREE_OPERAND (*tp, 0), - spc, flags, dumping_stmts); - if (dumping_stmts) + spc, flags, !(flags & TDF_SLIM)); + if (flags & TDF_SLIM) newline_and_indent (buffer, spc); else { @@ -705,7 +997,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, } } - dump_generic_node (buffer, *tp, spc, flags, dumping_stmts); + dump_generic_node (buffer, *tp, spc, flags, !(flags & TDF_SLIM)); } break; @@ -713,8 +1005,8 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, { tree_stmt_iterator si; bool first = true; - - if ((flags & TDF_SLIM) || !dumping_stmts) + + if (flags & TDF_SLIM) { pp_string (buffer, ""); break; @@ -741,23 +1033,32 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, break; case TARGET_EXPR: - dump_generic_node (buffer, TYPE_NAME (TREE_TYPE (node)), spc, flags, false); - pp_character (buffer, '('); + pp_string (buffer, "TARGET_EXPR <"); + dump_generic_node (buffer, TARGET_EXPR_SLOT (node), spc, flags, false); + pp_character (buffer, ','); + pp_space (buffer); dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false); - pp_character (buffer, ')'); + pp_character (buffer, '>'); + break; + + case DECL_EXPR: + print_declaration (buffer, DECL_EXPR_DECL (node), spc, flags); + is_stmt = false; break; case COND_EXPR: - if (TREE_TYPE (node) == void_type_node) + if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node) { pp_string (buffer, "if ("); dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false); pp_character (buffer, ')'); /* The lowered cond_exprs should always be printed in full. */ if (COND_EXPR_THEN (node) - && TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR + && (IS_EMPTY_STMT (COND_EXPR_THEN (node)) + || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR) && COND_EXPR_ELSE (node) - && TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR) + && (IS_EMPTY_STMT (COND_EXPR_ELSE (node)) + || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR)) { pp_space (buffer); dump_generic_node (buffer, COND_EXPR_THEN (node), 0, flags, true); @@ -850,6 +1151,8 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, pp_character (buffer, ']'); } + if (CALL_EXPR_RETURN_SLOT_OPT (node)) + pp_string (buffer, " [return slot optimization]"); if (CALL_EXPR_TAILCALL (node)) pp_string (buffer, " [tail call]"); break; @@ -865,10 +1168,14 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, break; case PLACEHOLDER_EXPR: - NIY; + pp_string (buffer, "'); break; /* Binary arithmetic and logic expressions. */ + case WIDEN_SUM_EXPR: + case WIDEN_MULT_EXPR: case MULT_EXPR: case PLUS_EXPR: case MINUS_EXPR: @@ -886,6 +1193,8 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, case RSHIFT_EXPR: case LROTATE_EXPR: case RROTATE_EXPR: + case VEC_LSHIFT_EXPR: + case VEC_RSHIFT_EXPR: case BIT_IOR_EXPR: case BIT_XOR_EXPR: case BIT_AND_EXPR: @@ -946,9 +1255,10 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, case BIT_NOT_EXPR: case TRUTH_NOT_EXPR: case ADDR_EXPR: - case REFERENCE_EXPR: case PREDECREMENT_EXPR: case PREINCREMENT_EXPR: + case ALIGN_INDIRECT_REF: + case MISALIGNED_INDIRECT_REF: case INDIRECT_REF: if (TREE_CODE (node) == ADDR_EXPR && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST @@ -965,6 +1275,13 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, } else dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); + + if (TREE_CODE (node) == MISALIGNED_INDIRECT_REF) + { + pp_string (buffer, "{misalignment: "); + dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); + pp_character (buffer, '}'); + } break; case POSTDECREMENT_EXPR: @@ -1002,26 +1319,11 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, pp_character (buffer, '>'); break; - case IN_EXPR: - NIY; - break; - - case SET_LE_EXPR: - NIY; - break; - - case CARD_EXPR: - NIY; - break; - case RANGE_EXPR: NIY; break; case FIX_TRUNC_EXPR: - case FIX_CEIL_EXPR: - case FIX_FLOOR_EXPR: - case FIX_ROUND_EXPR: case FLOAT_EXPR: case CONVERT_EXPR: case NOP_EXPR: @@ -1031,7 +1333,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, { pp_character (buffer, '('); dump_generic_node (buffer, type, spc, flags, false); - pp_string (buffer, ")"); + pp_string (buffer, ") "); } if (op_prio (op0) < op_prio (node)) pp_character (buffer, '('); @@ -1060,20 +1362,6 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, pp_character (buffer, '>'); break; - case UNSAVE_EXPR: - pp_string (buffer, "UNSAVE_EXPR <"); - dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); - pp_character (buffer, '>'); - break; - - case RTL_EXPR: - NIY; - break; - - case ENTRY_VALUE_EXPR: - NIY; - break; - case COMPLEX_EXPR: pp_string (buffer, "COMPLEX_EXPR <"); dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); @@ -1153,10 +1441,6 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, is_expr = false; break; - case GOTO_SUBROUTINE_EXPR: - NIY; - break; - case LABEL_EXPR: op0 = TREE_OPERAND (node, 0); /* If this is for break or continue, don't bother printing it. */ @@ -1173,48 +1457,6 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, pp_string (buffer, " [non-local]"); break; - case LABELED_BLOCK_EXPR: - op0 = LABELED_BLOCK_LABEL (node); - /* If this is for break or continue, don't bother printing it. */ - if (DECL_NAME (op0)) - { - const char *name = IDENTIFIER_POINTER (DECL_NAME (op0)); - if (strcmp (name, "break") == 0 - || strcmp (name, "continue") == 0) - { - dump_generic_node (buffer, LABELED_BLOCK_BODY (node), spc, flags, false); - break; - } - } - dump_generic_node (buffer, LABELED_BLOCK_LABEL (node), spc, flags, false); - pp_string (buffer, ": {"); - if (!(flags & TDF_SLIM)) - newline_and_indent (buffer, spc+2); - dump_generic_node (buffer, LABELED_BLOCK_BODY (node), spc+2, flags, true); - if (!flags) - newline_and_indent (buffer, spc); - pp_character (buffer, '}'); - is_expr = false; - break; - - case EXIT_BLOCK_EXPR: - op0 = LABELED_BLOCK_LABEL (EXIT_BLOCK_LABELED_BLOCK (node)); - /* If this is for a break or continue, print it accordingly. */ - if (DECL_NAME (op0)) - { - const char *name = IDENTIFIER_POINTER (DECL_NAME (op0)); - if (strcmp (name, "break") == 0 - || strcmp (name, "continue") == 0) - { - pp_string (buffer, name); - break; - } - } - pp_string (buffer, "<<>>"); - break; - case EXC_PTR_EXPR: pp_string (buffer, "<<>>"); break; @@ -1267,7 +1509,8 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, if (SWITCH_BODY (node)) { newline_and_indent (buffer, spc+4); - dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags, true); + dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags, + true); } else { @@ -1277,10 +1520,16 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, { tree elt = TREE_VEC_ELT (vec, i); newline_and_indent (buffer, spc+4); - dump_generic_node (buffer, elt, spc+4, flags, false); - pp_string (buffer, " goto "); - dump_generic_node (buffer, CASE_LABEL (elt), spc+4, flags, true); - pp_semicolon (buffer); + if (elt) + { + dump_generic_node (buffer, elt, spc+4, flags, false); + pp_string (buffer, " goto "); + dump_generic_node (buffer, CASE_LABEL (elt), spc+4, + flags, true); + pp_semicolon (buffer); + } + else + pp_string (buffer, "case ???: goto ???;"); } } newline_and_indent (buffer, spc+2); @@ -1291,9 +1540,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, case GOTO_EXPR: 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)); if (strcmp (name, "break") == 0 @@ -1308,8 +1555,8 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, break; case RESX_EXPR: - pp_string (buffer, "resx"); - /* ??? Any sensible way to present the eh region? */ + pp_string (buffer, "resx "); + dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); break; case ASM_EXPR: @@ -1348,96 +1595,17 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, pp_character (buffer, ':'); break; - case VTABLE_REF: - pp_string (buffer, "VTABLE_REF <("); - dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); - pp_string (buffer, "),"); - dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); - pp_character (buffer, ','); - dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false); + case OBJ_TYPE_REF: + pp_string (buffer, "OBJ_TYPE_REF("); + dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false); + pp_character (buffer, ';'); + dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false); + pp_character (buffer, '-'); pp_character (buffer, '>'); + dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false); + pp_character (buffer, ')'); break; - case EPHI_NODE: - { - int i; - - pp_string (buffer, " EPHI ("); - dump_generic_node (buffer, EREF_NAME (node), spc, flags, false); - pp_string (buffer, ") "); - pp_character (buffer, '['); - pp_string (buffer, " class:"); - pp_decimal_int (buffer, EREF_CLASS (node)); - if (EPHI_DOWNSAFE (node)) - pp_string (buffer, " downsafe"); - if (EPHI_CANT_BE_AVAIL (node)) - pp_string (buffer, " cant_be_avail"); - if (EPHI_STOPS (node)) - pp_string (buffer, " stops"); - pp_string (buffer, " bb:"); - pp_decimal_int (buffer, bb_for_stmt (node)->index); - pp_character (buffer, ']'); - if (! (flags & TDF_SLIM)) - { - pp_string (buffer, " <"); - for (i = 0; i < EPHI_NUM_ARGS (node); i++) - { - if (EPHI_ARG_DEF (node, i)) - { - newline_and_indent (buffer, spc + 2); - pp_string (buffer, " edge "); - pp_decimal_int (buffer, EPHI_ARG_EDGE (node, i)->src->index); - pp_string (buffer, "->"); - pp_decimal_int (buffer, EPHI_ARG_EDGE (node, i)->dest->index); - pp_string (buffer, " [ "); - if (EPHI_ARG_HAS_REAL_USE (node, i)) - pp_string (buffer, " real use"); - if (EPHI_ARG_INJURED (node, i)) - pp_string (buffer, " injured"); - if (EPHI_ARG_STOPS (node, i)) - pp_string (buffer, " stops"); - pp_string (buffer, " ] "); - pp_string (buffer, " defined by:"); - dump_generic_node (buffer, EPHI_ARG_DEF (node, i), - spc + 4, flags | TDF_SLIM, false); - } - } - } - pp_string (buffer, " >"); - } - break; - case EEXIT_NODE: - case EKILL_NODE: - if (TREE_CODE (node) == EEXIT_NODE) - pp_string (buffer, "EEXIT ("); - else if (TREE_CODE (node) == EKILL_NODE) - pp_string (buffer, "EKILL ("); - dump_generic_node (buffer, EREF_NAME (node), spc, flags, false); - pp_string (buffer, ") "); - pp_character (buffer, '['); - pp_string (buffer, "class:"); - pp_decimal_int (buffer, EREF_CLASS (node)); - pp_string (buffer, " bb:"); - pp_decimal_int (buffer, bb_for_stmt (node)->index); - pp_character (buffer, ']'); - break; - case EUSE_NODE: - pp_string (buffer, " EUSE ("); - dump_generic_node (buffer, EREF_NAME (node), spc, flags, false); - - pp_string (buffer, ") "); - pp_character (buffer, '['); - pp_string (buffer, "class:"); - pp_decimal_int (buffer, EREF_CLASS (node)); - pp_string (buffer, " phiop:"); - pp_decimal_int (buffer, EUSE_PHIOP (node)); - pp_string (buffer, " bb:"); - pp_decimal_int (buffer, bb_for_stmt (node)->index); - if (EUSE_LVAL (node)) - pp_string (buffer, " left-occurrence"); - pp_string (buffer, " ]"); - - break; case PHI_NODE: { int i; @@ -1461,6 +1629,364 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false); pp_string (buffer, "_"); pp_decimal_int (buffer, SSA_NAME_VERSION (node)); + if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node)) + pp_string (buffer, "(ab)"); + break; + + case WITH_SIZE_EXPR: + pp_string (buffer, "WITH_SIZE_EXPR <"); + dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); + pp_string (buffer, ", "); + dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); + pp_string (buffer, ">"); + break; + + case VALUE_HANDLE: + pp_printf (buffer, "VH.%d", VALUE_HANDLE_ID (node)); + break; + + case ASSERT_EXPR: + pp_string (buffer, "ASSERT_EXPR <"); + dump_generic_node (buffer, ASSERT_EXPR_VAR (node), spc, flags, false); + pp_string (buffer, ", "); + dump_generic_node (buffer, ASSERT_EXPR_COND (node), spc, flags, false); + pp_string (buffer, ">"); + break; + + case SCEV_KNOWN: + pp_string (buffer, "scev_known"); + break; + + case SCEV_NOT_KNOWN: + pp_string (buffer, "scev_not_known"); + break; + + case POLYNOMIAL_CHREC: + pp_string (buffer, "{"); + dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false); + pp_string (buffer, ", +, "); + dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false); + pp_string (buffer, "}_"); + dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false); + is_stmt = false; + break; + + case REALIGN_LOAD_EXPR: + pp_string (buffer, "REALIGN_LOAD <"); + dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); + pp_string (buffer, ", "); + dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); + pp_string (buffer, ", "); + dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false); + pp_string (buffer, ">"); + break; + + case VEC_COND_EXPR: + pp_string (buffer, " VEC_COND_EXPR < "); + dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); + pp_string (buffer, " , "); + dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); + pp_string (buffer, " , "); + dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false); + pp_string (buffer, " > "); + break; + + case DOT_PROD_EXPR: + pp_string (buffer, " DOT_PROD_EXPR < "); + dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); + pp_string (buffer, ", "); + dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); + pp_string (buffer, ", "); + dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false); + pp_string (buffer, " > "); + break; + + case OMP_PARALLEL: + pp_string (buffer, "#pragma omp parallel"); + dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags); + if (OMP_PARALLEL_FN (node)) + { + pp_string (buffer, " [child fn: "); + dump_generic_node (buffer, OMP_PARALLEL_FN (node), spc, flags, false); + + pp_string (buffer, " ("); + + if (OMP_PARALLEL_DATA_ARG (node)) + dump_generic_node (buffer, OMP_PARALLEL_DATA_ARG (node), spc, flags, + false); + else + pp_string (buffer, "???"); + + pp_string (buffer, ")]"); + } + + dump_omp_body: + if (!(flags & TDF_SLIM) && OMP_BODY (node)) + { + newline_and_indent (buffer, spc + 2); + pp_character (buffer, '{'); + newline_and_indent (buffer, spc + 4); + dump_generic_node (buffer, OMP_BODY (node), spc + 4, flags, false); + newline_and_indent (buffer, spc + 2); + pp_character (buffer, '}'); + } + is_expr = false; + break; + + case OMP_FOR: + pp_string (buffer, "#pragma omp for"); + dump_omp_clauses (buffer, OMP_FOR_CLAUSES (node), spc, flags); + + if (!(flags & TDF_SLIM)) + { + if (OMP_FOR_PRE_BODY (node)) + { + newline_and_indent (buffer, spc + 2); + pp_character (buffer, '{'); + spc += 4; + newline_and_indent (buffer, spc); + dump_generic_node (buffer, OMP_FOR_PRE_BODY (node), + spc, flags, false); + } + newline_and_indent (buffer, spc); + pp_string (buffer, "for ("); + dump_generic_node (buffer, OMP_FOR_INIT (node), spc, flags, false); + pp_string (buffer, "; "); + dump_generic_node (buffer, OMP_FOR_COND (node), spc, flags, false); + pp_string (buffer, "; "); + dump_generic_node (buffer, OMP_FOR_INCR (node), spc, flags, false); + pp_string (buffer, ")"); + if (OMP_FOR_BODY (node)) + { + newline_and_indent (buffer, spc + 2); + pp_character (buffer, '{'); + newline_and_indent (buffer, spc + 4); + dump_generic_node (buffer, OMP_FOR_BODY (node), spc + 4, flags, + false); + newline_and_indent (buffer, spc + 2); + pp_character (buffer, '}'); + } + if (OMP_FOR_PRE_BODY (node)) + { + spc -= 4; + newline_and_indent (buffer, spc + 2); + pp_character (buffer, '}'); + } + } + is_expr = false; + break; + + case OMP_SECTIONS: + pp_string (buffer, "#pragma omp sections"); + dump_omp_clauses (buffer, OMP_SECTIONS_CLAUSES (node), spc, flags); + goto dump_omp_body; + + case OMP_SECTION: + pp_string (buffer, "#pragma omp section"); + goto dump_omp_body; + + case OMP_MASTER: + pp_string (buffer, "#pragma omp master"); + goto dump_omp_body; + + case OMP_ORDERED: + pp_string (buffer, "#pragma omp ordered"); + goto dump_omp_body; + + case OMP_CRITICAL: + pp_string (buffer, "#pragma omp critical"); + if (OMP_CRITICAL_NAME (node)) + { + pp_space (buffer); + pp_character (buffer, '('); + dump_generic_node (buffer, OMP_CRITICAL_NAME (node), spc, + flags, false); + pp_character (buffer, ')'); + } + goto dump_omp_body; + + case OMP_ATOMIC: + pp_string (buffer, "#pragma omp atomic"); + newline_and_indent (buffer, spc + 2); + dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); + pp_space (buffer); + pp_character (buffer, '='); + pp_space (buffer); + dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); + break; + + case OMP_SINGLE: + pp_string (buffer, "#pragma omp single"); + dump_omp_clauses (buffer, OMP_SINGLE_CLAUSES (node), spc, flags); + goto dump_omp_body; + + case OMP_RETURN: + pp_string (buffer, "OMP_RETURN"); + if (OMP_RETURN_NOWAIT (node)) + pp_string (buffer, " [nowait]"); + is_expr = false; + break; + + case OMP_CONTINUE: + pp_string (buffer, "OMP_CONTINUE"); + is_expr = false; + break; + + case OMP_CLAUSE: + dump_omp_clause (buffer, node, spc, flags); + is_expr = false; + break; + + case REDUC_MAX_EXPR: + pp_string (buffer, " REDUC_MAX_EXPR < "); + dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); + pp_string (buffer, " > "); + break; + + case REDUC_MIN_EXPR: + pp_string (buffer, " REDUC_MIN_EXPR < "); + dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); + pp_string (buffer, " > "); + break; + + case REDUC_PLUS_EXPR: + pp_string (buffer, " REDUC_PLUS_EXPR < "); + dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); + pp_string (buffer, " > "); + break; + + case VEC_WIDEN_MULT_HI_EXPR: + pp_string (buffer, " VEC_WIDEN_MULT_HI_EXPR < "); + dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); + pp_string (buffer, ", "); + dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); + pp_string (buffer, " > "); + break; + + case VEC_WIDEN_MULT_LO_EXPR: + pp_string (buffer, " VEC_WIDEN_MULT_LO_EXPR < "); + dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); + pp_string (buffer, ", "); + dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); + pp_string (buffer, " > "); + break; + + case VEC_UNPACK_HI_EXPR: + pp_string (buffer, " VEC_UNPACK_HI_EXPR < "); + dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); + pp_string (buffer, " > "); + break; + + case VEC_UNPACK_LO_EXPR: + pp_string (buffer, " VEC_UNPACK_LO_EXPR < "); + dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); + pp_string (buffer, " > "); + break; + + case VEC_PACK_MOD_EXPR: + pp_string (buffer, " VEC_PACK_MOD_EXPR < "); + dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); + pp_string (buffer, ", "); + dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); + pp_string (buffer, " > "); + break; + + case VEC_PACK_SAT_EXPR: + pp_string (buffer, " VEC_PACK_SAT_EXPR < "); + dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); + pp_string (buffer, ", "); + dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); + pp_string (buffer, " > "); + break; + + case BLOCK: + { + tree t; + pp_string (buffer, "BLOCK"); + + if (BLOCK_ABSTRACT (node)) + pp_string (buffer, " [abstract]"); + + if (TREE_ASM_WRITTEN (node)) + pp_string (buffer, " [written]"); + + newline_and_indent (buffer, spc + 2); + + if (BLOCK_SUPERCONTEXT (node)) + { + pp_string (buffer, "SUPERCONTEXT: "); + if (TREE_CODE (BLOCK_SUPERCONTEXT (node)) == BLOCK) + pp_printf (buffer, "BLOCK %p", + (void *)BLOCK_SUPERCONTEXT (node)); + else + dump_generic_node (buffer, BLOCK_SUPERCONTEXT (node), 0, flags, + false); + newline_and_indent (buffer, spc + 2); + } + + if (BLOCK_SUBBLOCKS (node)) + { + pp_string (buffer, "SUBBLOCKS: "); + for (t = BLOCK_SUBBLOCKS (node); t; t = BLOCK_CHAIN (t)) + pp_printf (buffer, "%p ", (void *)t); + newline_and_indent (buffer, spc + 2); + } + + if (BLOCK_VARS (node)) + { + pp_string (buffer, "VARS: "); + for (t = BLOCK_VARS (node); t; t = TREE_CHAIN (t)) + { + dump_generic_node (buffer, t, 0, flags, false); + pp_string (buffer, " "); + } + newline_and_indent (buffer, spc + 2); + } + + if (BLOCK_ABSTRACT_ORIGIN (node)) + { + pp_string (buffer, "ABSTRACT_ORIGIN: "); + if (TREE_CODE (BLOCK_ABSTRACT_ORIGIN (node)) == BLOCK) + pp_printf (buffer, "BLOCK %p", + (void *)BLOCK_ABSTRACT_ORIGIN (node)); + else + dump_generic_node (buffer, BLOCK_ABSTRACT_ORIGIN (node), 0, flags, + false); + newline_and_indent (buffer, spc + 2); + } + } + break; + + case VEC_EXTRACT_EVEN_EXPR: + pp_string (buffer, " VEC_EXTRACT_EVEN_EXPR < "); + dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); + pp_string (buffer, ", "); + dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); + pp_string (buffer, " > "); + break; + + case VEC_EXTRACT_ODD_EXPR: + pp_string (buffer, " VEC_EXTRACT_ODD_EXPR < "); + dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); + pp_string (buffer, ", "); + dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); + pp_string (buffer, " > "); + break; + + case VEC_INTERLEAVE_HIGH_EXPR: + pp_string (buffer, " VEC_INTERLEAVE_HIGH_EXPR < "); + dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); + pp_string (buffer, ", "); + dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); + pp_string (buffer, " > "); + break; + + case VEC_INTERLEAVE_LOW_EXPR: + pp_string (buffer, " VEC_INTERLEAVE_LOW_EXPR < "); + dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); + pp_string (buffer, ", "); + dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); + pp_string (buffer, " > "); break; default: @@ -1479,13 +2005,12 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, static void print_declaration (pretty_printer *buffer, tree t, int spc, int flags) { - /* Don't print type declarations. */ - if (TREE_CODE (t) == TYPE_DECL) - return; - INDENT (spc); - if (DECL_REGISTER (t)) + if (TREE_CODE (t) == TYPE_DECL) + pp_string (buffer, "typedef "); + + if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t)) pp_string (buffer, "register "); if (TREE_PUBLIC (t) && DECL_EXTERNAL (t)) @@ -1512,21 +2037,17 @@ print_declaration (pretty_printer *buffer, tree t, int spc, int flags) tmp = TREE_TYPE (t); while (TREE_CODE (tmp) == ARRAY_TYPE) { - pp_character (buffer, '['); - if (TYPE_DOMAIN (tmp)) - { - if (TREE_CODE (TYPE_SIZE (tmp)) == INTEGER_CST) - pp_wide_integer (buffer, - TREE_INT_CST_LOW (TYPE_SIZE (tmp)) / - TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (tmp)))); - else - dump_generic_node (buffer, TYPE_SIZE_UNIT (tmp), spc, flags, - false); - } - pp_character (buffer, ']'); + dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags); tmp = TREE_TYPE (tmp); } } + else if (TREE_CODE (t) == FUNCTION_DECL) + { + dump_generic_node (buffer, TREE_TYPE (TREE_TYPE (t)), spc, flags, false); + pp_space (buffer); + dump_decl_name (buffer, t, flags); + dump_function_declaration (buffer, TREE_TYPE (t), spc, flags); + } else { /* Print type declaration. */ @@ -1537,6 +2058,14 @@ print_declaration (pretty_printer *buffer, tree t, int spc, int flags) dump_generic_node (buffer, t, spc, flags, false); } + if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t)) + { + pp_string (buffer, " __asm__ "); + pp_character (buffer, '('); + dump_generic_node (buffer, DECL_ASSEMBLER_NAME (t), spc, flags, false); + pp_character (buffer, ')'); + } + /* The initial value of a function serves to determine wether the function is declared or defined. So the following does not apply to function nodes. */ @@ -1552,6 +2081,13 @@ print_declaration (pretty_printer *buffer, tree t, int spc, int flags) } } + if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t)) + { + pp_string (buffer, " [value-expr: "); + dump_generic_node (buffer, DECL_VALUE_EXPR (t), spc, flags, false); + pp_character (buffer, ']'); + } + pp_character (buffer, ';'); } @@ -1568,10 +2104,10 @@ print_struct_decl (pretty_printer *buffer, tree node, int spc, int flags) INDENT (spc); if (TREE_CODE (node) == RECORD_TYPE) pp_string (buffer, "struct "); - else if (TREE_CODE (node) == UNION_TYPE) + else if ((TREE_CODE (node) == UNION_TYPE + || TREE_CODE (node) == QUAL_UNION_TYPE)) pp_string (buffer, "union "); - else - NIY; + dump_generic_node (buffer, TYPE_NAME (node), spc, 0, false); } @@ -1593,16 +2129,12 @@ print_struct_decl (pretty_printer *buffer, tree node, int spc, int flags) Maybe this could be solved by looking at the scope in which the structure was declared. */ if (TREE_TYPE (tmp) != node - || (TREE_CODE (TREE_TYPE (tmp)) == POINTER_TYPE && - TREE_TYPE (TREE_TYPE (tmp)) != node)) + || (TREE_CODE (TREE_TYPE (tmp)) == POINTER_TYPE + && TREE_TYPE (TREE_TYPE (tmp)) != node)) { print_declaration (buffer, tmp, spc+2, flags); pp_newline (buffer); } - else - { - - } tmp = TREE_CHAIN (tmp); } } @@ -1696,10 +2228,15 @@ op_prio (tree op) case RROTATE_EXPR: return 11; + case WIDEN_SUM_EXPR: case PLUS_EXPR: case MINUS_EXPR: return 12; + case VEC_WIDEN_MULT_HI_EXPR: + case VEC_WIDEN_MULT_LO_EXPR: + case WIDEN_MULT_EXPR: + case DOT_PROD_EXPR: case MULT_EXPR: case TRUNC_DIV_EXPR: case CEIL_DIV_EXPR: @@ -1720,20 +2257,20 @@ op_prio (tree op) case PREINCREMENT_EXPR: case PREDECREMENT_EXPR: case NEGATE_EXPR: + case ALIGN_INDIRECT_REF: + case MISALIGNED_INDIRECT_REF: case INDIRECT_REF: case ADDR_EXPR: case FLOAT_EXPR: case NOP_EXPR: case CONVERT_EXPR: case FIX_TRUNC_EXPR: - case FIX_CEIL_EXPR: - case FIX_FLOOR_EXPR: - case FIX_ROUND_EXPR: case TARGET_EXPR: return 14; case CALL_EXPR: case ARRAY_REF: + case ARRAY_RANGE_REF: case COMPONENT_REF: return 15; @@ -1743,6 +2280,15 @@ op_prio (tree op) case ABS_EXPR: case REALPART_EXPR: case IMAGPART_EXPR: + case REDUC_MAX_EXPR: + case REDUC_MIN_EXPR: + case REDUC_PLUS_EXPR: + case VEC_LSHIFT_EXPR: + case VEC_RSHIFT_EXPR: + case VEC_UNPACK_HI_EXPR: + case VEC_UNPACK_LO_EXPR: + case VEC_PACK_MOD_EXPR: + case VEC_PACK_SAT_EXPR: return 16; case SAVE_EXPR: @@ -1760,12 +2306,9 @@ op_prio (tree op) /* Return the symbol associated with operator OP. */ static const char * -op_symbol (tree op) +op_symbol_1 (enum tree_code code) { - if (op == NULL) - abort (); - - switch (TREE_CODE (op)) + switch (code) { case MODIFY_EXPR: return "="; @@ -1831,9 +2374,30 @@ op_symbol (tree op) case RSHIFT_EXPR: return ">>"; + case LROTATE_EXPR: + return "r<<"; + + case RROTATE_EXPR: + return "r>>"; + + case VEC_LSHIFT_EXPR: + return "v<<"; + + case VEC_RSHIFT_EXPR: + return "v>>"; + case PLUS_EXPR: return "+"; + case REDUC_PLUS_EXPR: + return "r+"; + + case WIDEN_SUM_EXPR: + return "w+"; + + case WIDEN_MULT_EXPR: + return "w*"; + case NEGATE_EXPR: case MINUS_EXPR: return "-"; @@ -1848,19 +2412,39 @@ op_symbol (tree op) case INDIRECT_REF: return "*"; + case ALIGN_INDIRECT_REF: + return "A*"; + + case MISALIGNED_INDIRECT_REF: + return "M*"; + case TRUNC_DIV_EXPR: + case RDIV_EXPR: + return "/"; + case CEIL_DIV_EXPR: + return "/[cl]"; + case FLOOR_DIV_EXPR: + return "/[fl]"; + case ROUND_DIV_EXPR: - case RDIV_EXPR: + return "/[rd]"; + case EXACT_DIV_EXPR: - return "/"; + return "/[ex]"; case TRUNC_MOD_EXPR: + return "%"; + case CEIL_MOD_EXPR: + return "%[cl]"; + case FLOOR_MOD_EXPR: + return "%[fl]"; + case ROUND_MOD_EXPR: - return "%"; + return "%[rd]"; case PREDECREMENT_EXPR: return " --"; @@ -1874,14 +2458,23 @@ op_symbol (tree op) case POSTINCREMENT_EXPR: return "++ "; - case REFERENCE_EXPR: - return ""; + case MAX_EXPR: + return "max"; + + case MIN_EXPR: + return "min"; default: return "<<< ??? >>>"; } } +static const char * +op_symbol (tree op) +{ + return op_symbol_1 (TREE_CODE (op)); +} + /* Prints the name of a CALL_EXPR. */ static void @@ -1889,8 +2482,7 @@ print_call_name (pretty_printer *buffer, tree node) { tree op0; - if (TREE_CODE (node) != CALL_EXPR) - abort (); + gcc_assert (TREE_CODE (node) == CALL_EXPR); op0 = TREE_OPERAND (node, 0); @@ -1901,7 +2493,7 @@ print_call_name (pretty_printer *buffer, tree node) { case VAR_DECL: case PARM_DECL: - PRINT_FUNCTION_NAME (op0); + dump_function_name (buffer, op0); break; case ADDR_EXPR: @@ -1923,7 +2515,7 @@ print_call_name (pretty_printer *buffer, tree node) /* The function is a pointer contained in a structure. */ if (TREE_CODE (TREE_OPERAND (op0, 0)) == INDIRECT_REF || TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL) - PRINT_FUNCTION_NAME (TREE_OPERAND (op0, 1)); + dump_function_name (buffer, TREE_OPERAND (op0, 1)); else dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false); /* else @@ -1934,12 +2526,13 @@ print_call_name (pretty_printer *buffer, tree node) case ARRAY_REF: if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL) - PRINT_FUNCTION_NAME (TREE_OPERAND (op0, 0)); + dump_function_name (buffer, TREE_OPERAND (op0, 0)); else dump_generic_node (buffer, op0, 0, 0, false); break; case SSA_NAME: + case OBJ_TYPE_REF: dump_generic_node (buffer, op0, 0, 0, false); break; @@ -1996,9 +2589,7 @@ pretty_print_string (pretty_printer *buffer, const char *str) pp_string (buffer, "\\'"); break; - case '\0': - pp_string (buffer, "\\0"); - break; + /* No need to handle \0; the loop terminates on \0. */ case '\1': pp_string (buffer, "\\1"); @@ -2059,26 +2650,43 @@ newline_and_indent (pretty_printer *buffer, int spc) static void dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags) { - size_t i; - stmt_ann_t ann = stmt_ann (stmt); - vdef_optype vdefs = VDEF_OPS (ann); - vuse_optype vuses = VUSE_OPS (ann); + tree use; + use_operand_p use_p; + def_operand_p def_p; + use_operand_p kill_p; + ssa_op_iter iter; + + if (!ssa_operands_active ()) + return; - for (i = 0; i < NUM_VDEFS (vdefs); i++) + FOR_EACH_SSA_MAYDEF_OPERAND (def_p, use_p, stmt, iter) { pp_string (buffer, "# "); - dump_generic_node (buffer, VDEF_RESULT (vdefs, i), spc + 2, flags, false); - pp_string (buffer, " = VDEF <"); - dump_generic_node (buffer, VDEF_OP (vdefs, i), spc + 2, flags, false); + dump_generic_node (buffer, DEF_FROM_PTR (def_p), + spc + 2, flags, false); + pp_string (buffer, " = V_MAY_DEF <"); + dump_generic_node (buffer, USE_FROM_PTR (use_p), + spc + 2, flags, false); pp_string (buffer, ">;"); newline_and_indent (buffer, spc); } - for (i = 0; i < NUM_VUSES (vuses); i++) + FOR_EACH_SSA_MUSTDEF_OPERAND (def_p, kill_p, stmt, iter) + { + pp_string (buffer, "# "); + dump_generic_node (buffer, DEF_FROM_PTR (def_p), + spc + 2, flags, false); + pp_string (buffer, " = V_MUST_DEF <"); + dump_generic_node (buffer, USE_FROM_PTR (kill_p), + spc + 2, flags, false); + pp_string (buffer, ">;"); + newline_and_indent (buffer, spc); + } + + FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_VUSE) { - tree vuse = VUSE_OP (vuses, i); pp_string (buffer, "# VUSE <"); - dump_generic_node (buffer, vuse, spc + 2, flags, false); + dump_generic_node (buffer, use, spc + 2, flags, false); pp_string (buffer, ">;"); newline_and_indent (buffer, spc); } @@ -2091,7 +2699,6 @@ void dump_generic_bb (FILE *file, basic_block bb, int indent, int flags) { maybe_init_pretty_print (file); - dumping_stmts = true; dump_generic_bb_buff (&buffer, bb, indent, flags); pp_flush (&buffer); } @@ -2104,12 +2711,23 @@ dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags) { edge e; tree stmt; + edge_iterator ei; if (flags & TDF_BLOCKS) { INDENT (indent); pp_string (buffer, "# BLOCK "); pp_decimal_int (buffer, bb->index); + if (bb->frequency) + { + pp_string (buffer, " freq:"); + pp_decimal_int (buffer, bb->frequency); + } + if (bb->count) + { + pp_string (buffer, " count:"); + pp_widest_integer (buffer, bb->count); + } if (flags & TDF_LINENO) { @@ -2127,8 +2745,8 @@ dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags) pp_string (buffer, "# PRED:"); pp_write_text_to_stream (buffer); - for (e = bb->pred; e; e = e->pred_next) - if (flags & TDF_SLIM) + FOR_EACH_EDGE (e, ei, bb->preds) + if (flags & TDF_SLIM) { pp_string (buffer, " "); if (e->src == ENTRY_BLOCK_PTR) @@ -2152,6 +2770,8 @@ dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags) pp_newline (buffer); } } + pp_write_text_to_stream (buffer); + check_bb_profile (bb, buffer->buffer->stream); } /* Dumps end of basic block BB to buffer BUFFER indented by INDENT @@ -2161,11 +2781,12 @@ static void dump_bb_end (pretty_printer *buffer, basic_block bb, int indent, int flags) { edge e; + edge_iterator ei; INDENT (indent); pp_string (buffer, "# SUCC:"); pp_write_text_to_stream (buffer); - for (e = bb->succ; e; e = e->succ_next) + FOR_EACH_EDGE (e, ei, bb->succs) if (flags & TDF_SLIM) { pp_string (buffer, " "); @@ -2189,7 +2810,7 @@ dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags) if (!phi) return; - for (; phi; phi = TREE_CHAIN (phi)) + for (; phi; phi = PHI_CHAIN (phi)) { if (is_gimple_reg (PHI_RESULT (phi)) || (flags & TDF_VOPS)) { @@ -2227,18 +2848,45 @@ pp_cfg_jump (pretty_printer *buffer, basic_block bb) by INDENT spaces, with details given by FLAGS. */ static void -dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent) +dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent, + int flags) { edge e; + edge_iterator ei; /* If there is a fallthru edge, we may need to add an artificial goto to the dump. */ - for (e = bb->succ; e; e = e->succ_next) + FOR_EACH_EDGE (e, ei, bb->succs) if (e->flags & EDGE_FALLTHRU) break; if (e && e->dest != bb->next_bb) { INDENT (indent); + + if ((flags & TDF_LINENO) +#ifdef USE_MAPPED_LOCATION + && e->goto_locus != UNKNOWN_LOCATION +#else + && e->goto_locus +#endif + ) + { + expanded_location goto_xloc; +#ifdef USE_MAPPED_LOCATION + goto_xloc = expand_location (e->goto_locus); +#else + goto_xloc = *e->goto_locus; +#endif + pp_character (buffer, '['); + if (goto_xloc.file) + { + pp_string (buffer, goto_xloc.file); + pp_string (buffer, " : "); + } + pp_decimal_int (buffer, goto_xloc.line); + pp_string (buffer, "] "); + } + pp_cfg_jump (buffer, e->dest); pp_newline (buffer); } @@ -2260,9 +2908,8 @@ dump_generic_bb_buff (pretty_printer *buffer, basic_block bb, dump_bb_header (buffer, bb, indent, flags); - if (bb_ann (bb)) - 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)) { int curr_indent; @@ -2276,7 +2923,7 @@ dump_generic_bb_buff (pretty_printer *buffer, basic_block bb, pp_newline (buffer); } - dump_implicit_edges (buffer, bb, indent); + dump_implicit_edges (buffer, bb, indent, flags); if (flags & TDF_BLOCKS) dump_bb_end (buffer, bb, indent, flags);