* coretypes.h (struct pretty_print_info): Make a coretype. (typedef pretty_printer): Likewise. * pretty-print.h (typedef pretty_printer): Not needed here anymore. * pretty-print.c (pp_write_text_as_dot_label_to_stream): New function. * rtl.h (str_pattern_slim): New prototype. (print_value, print_pattern, print_insn): Adjust prototypes to take a pretty-printer rather than a char buffer. * sched-vis.c (safe_concat): Remove. (print_exp): Print into a pretty-printer. (print_value): Likewise. (print_pattern): Likewise. (print_insn): Likewise. (print_insn_with_notes): New static function. (init_rtl_slim_pretty_print): New function. (dump_value_slim): Simplify. Print into and flush a pretty-printer. (dump_insn_slim): Likewise. (dump_rtl_slim): Likewise. (str_pattern_slim): New function. * haifa-sched.c (model_recompute): Use str_pattern_slim instead of static buffers. (model_record_pressures): Likewise. (schedule_insn): Likewise. * sel-sched-dump.c (dump_insn_rtx_1): Likewise. (sel_prepare_string_for_dot_label): Refer to graph.c CFG dumper code. * graph.c: Include pretty-print.h. (init_graph_slim_pretty_print): New function. (print_escaped_line): Removed here, and reincarnated as pp_write_text_as_dot_label_to_stream. (draw_cfg_node): Print into a pretty printer. (draw_cfg_node_succ_edges): Likewise. (print_rtl_graph_with_bb): Likewise. Index: coretypes.h =================================================================== --- coretypes.h (revision 193926) +++ coretypes.h (working copy) @@ -58,10 +58,11 @@ typedef struct rtvec_def *rtvec; typedef const struct rtvec_def *const_rtvec; union tree_node; typedef union tree_node *tree; +typedef const union tree_node *const_tree; union gimple_statement_d; typedef union gimple_statement_d *gimple; -typedef const union tree_node *const_tree; typedef const union gimple_statement_d *const_gimple; +typedef gimple gimple_seq; union section; typedef union section section; struct gcc_options; @@ -72,7 +73,8 @@ struct cl_decoded_option; struct cl_option_handlers; struct diagnostic_context; typedef struct diagnostic_context diagnostic_context; -typedef gimple gimple_seq; +struct pretty_print_info; +typedef struct pretty_print_info pretty_printer; /* Address space number for named address space support. */ typedef unsigned char addr_space_t; Index: pretty-print.h =================================================================== --- pretty-print.h (revision 193926) +++ pretty-print.h (working copy) @@ -132,7 +132,6 @@ typedef struct /* The type of a hook that formats client-specific data onto a pretty_pinter. A client-supplied formatter returns true if everything goes well, otherwise it returns false. */ -typedef struct pretty_print_info pretty_printer; typedef bool (*printer_fn) (pretty_printer *, text_info *, const char *, int, bool, bool, bool); @@ -343,7 +342,8 @@ extern void pp_base_indent (pretty_printer *); extern void pp_base_newline (pretty_printer *); extern void pp_base_character (pretty_printer *, int); extern void pp_base_string (pretty_printer *, const char *); -extern void pp_write_text_to_stream (pretty_printer *pp); +extern void pp_write_text_to_stream (pretty_printer *); +extern void pp_write_text_as_dot_label_to_stream (pretty_printer *, bool); extern void pp_base_maybe_space (pretty_printer *); /* Switch into verbatim mode and return the old mode. */ Index: pretty-print.c =================================================================== --- pretty-print.c (revision 193926) +++ pretty-print.c (working copy) @@ -99,6 +99,58 @@ pp_write_text_to_stream (pretty_printer *pp) pp_clear_output_area (pp); } +/* As pp_write_text_to_stream, but for GraphViz label output. + + Flush the formatted text of pretty-printer PP onto the attached stream. + Replace characters in PPF that have special meaning in a GraphViz .dot + file. + + This routine is not very fast, but it doesn't have to be as this is only + be used by routines dumping intermediate representations in graph form. */ + +void +pp_write_text_as_dot_label_to_stream (pretty_printer *pp, bool for_record) +{ + const char *text = pp_formatted_text (pp); + const char *p = text; + FILE *fp = pp->buffer->stream; + + while (*p) + { + switch (*p) + { + /* Print newlines as a left-aligned newline. */ + case '\n': + fputs ("\\l\\\n", fp); + break; + + /* A pipe is only special for record-shape nodes. */ + case '|': + if (for_record) + fputc ('\\', fp); + fputc (*p, fp); + break; + + /* The following characters always have to be escaped + for use in labels. */ + case '{': + case '}': + case '<': + case '>': + case '"': + case ' ': + fputc ('\\', fp); + /* fall through */ + default: + fputc (*p, fp); + break; + } + p++; + } + + pp_clear_output_area (pp); +} + /* Wrap a text delimited by START and END into PRETTY-PRINTER. */ static void pp_wrap_text (pretty_printer *pp, const char *start, const char *end) Index: rtl.h =================================================================== --- rtl.h (revision 193926) +++ rtl.h (working copy) @@ -2597,16 +2597,16 @@ extern int print_rtl_single (FILE *, const_rtx); extern int print_rtl_single_with_indent (FILE *, const_rtx, int); extern void print_inline_rtx (FILE *, const_rtx, int); -/* Functions in sched-vis.c. These must be outside INSN_SCHEDULING as - sched-vis.c is compiled always. FIXME: Ideally these functions would +/* Functions in sched-vis.c. FIXME: Ideally these functions would not be in sched-vis.c but in rtl.c, because they are not only used by the scheduler anymore but for all "slim" RTL dumping. */ extern void dump_value_slim (FILE *, const_rtx, int); extern void dump_insn_slim (FILE *, const_rtx); extern void dump_rtl_slim (FILE *, const_rtx, const_rtx, int, int); -extern void print_value (char *, const_rtx, int); -extern void print_pattern (char *, const_rtx, int); -extern void print_insn (char *, const_rtx, int); +extern void print_value (pretty_printer *, const_rtx, int); +extern void print_pattern (pretty_printer *, const_rtx, int); +extern void print_insn (pretty_printer *, const_rtx, int); +extern const char *str_pattern_slim (const_rtx); /* In function.c */ extern void reposition_prologue_and_epilogue_notes (void); Index: sched-vis.c =================================================================== --- sched-vis.c (revision 193926) +++ sched-vis.c (working copy) @@ -30,50 +30,41 @@ along with GCC; see the file COPYING3. If not see #include "tm.h" #include "rtl.h" #include "tree.h" /* FIXME: To dump INSN_VAR_LOCATION_DECL. */ -#include "obstack.h" -#include "hard-reg-set.h" #include "basic-block.h" -#include "insn-attr.h" #include "dumpfile.h" /* for the TDF_* flags */ +#include "pretty-print.h" -static char *safe_concat (char *, char *, const char *); +/* The functions in this file try to print RTL in a form resembling assembler + mnemonics. Because this form is more concise than the "traditional" form + of RTL printing in Lisp-style, the form printed by this file is called + "slim". RTL dumps in slim format can be obtained by appending the "-slim" + option to -fdump-rtl-. Control flow graph output as a DOT file is + always printed in slim form. -#define BUF_LEN 2048 + The normal interface to the functionality provided in this pretty-printer + is through the dump_*_slim functions to print to a stream, or via the + print_*_slim functions to print into a user's pretty-printer. + + It is also possible to obtain a string for a single pattern as a string + pointer, via str_pattern_slim, but this usage is discouraged. */ -static char * -safe_concat (char *buf, char *cur, const char *str) -{ - char *end = buf + BUF_LEN - 2; /* Leave room for null. */ - int c; +/* A pretty-printer for slim rtl printing. */ +static bool rtl_slim_pp_initialized = false; +static pretty_printer rtl_slim_pp; - if (cur > end) - { - *end = '\0'; - return end; - } - - while (cur < end && (c = *str++) != '\0') - *cur++ = c; - - *cur = '\0'; - return cur; -} - -/* This recognizes rtx, I classified as expressions. These are always +/* This recognizes rtx'en classified as expressions. These are always represent some action on values or results of other expression, that may be stored in objects representing values. */ static void -print_exp (char *buf, const_rtx x, int verbose) +print_exp (pretty_printer *pp, const_rtx x, int verbose) { - char tmp[BUF_LEN]; const char *st[4]; - char *cur = buf; - const char *fun = (char *) 0; - const char *sep; + const char *fun; rtx op[4]; int i; + fun = (char *) 0; for (i = 0; i < 4; i++) { st[i] = (char *) 0; @@ -351,21 +342,18 @@ static void case UNSPEC: case UNSPEC_VOLATILE: { - cur = safe_concat (buf, cur, "unspec"); + pp_string (pp, "unspec"); if (GET_CODE (x) == UNSPEC_VOLATILE) - cur = safe_concat (buf, cur, "/v"); - cur = safe_concat (buf, cur, "["); - sep = ""; + pp_string (pp, "/v"); + pp_character (pp, '['); for (i = 0; i < XVECLEN (x, 0); i++) { - print_pattern (tmp, XVECEXP (x, 0, i), verbose); - cur = safe_concat (buf, cur, sep); - cur = safe_concat (buf, cur, tmp); - sep = ","; + if (i != 0) + pp_character (pp, ','); + print_pattern (pp, XVECEXP (x, 0, i), verbose); } - cur = safe_concat (buf, cur, "] "); - sprintf (tmp, "%d", XINT (x, 1)); - cur = safe_concat (buf, cur, tmp); + pp_string (pp, "] "); + pp_decimal_int (pp, XINT (x, 1)); } break; default: @@ -402,266 +390,213 @@ static void /* Print this as a function? */ if (fun) { - cur = safe_concat (buf, cur, fun); - cur = safe_concat (buf, cur, "("); + pp_string (pp, fun); + pp_character (pp, '('); } for (i = 0; i < 4; i++) { if (st[i]) - cur = safe_concat (buf, cur, st[i]); + pp_string (pp, st[i]); if (op[i]) { if (fun && i != 0) - cur = safe_concat (buf, cur, ","); - - print_value (tmp, op[i], verbose); - cur = safe_concat (buf, cur, tmp); + pp_character (pp, ','); + print_value (pp, op[i], verbose); } } if (fun) - cur = safe_concat (buf, cur, ")"); + pp_character (pp, ')'); } /* print_exp */ /* Prints rtxes, I customarily classified as values. They're constants, registers, labels, symbols and memory accesses. */ void -print_value (char *buf, const_rtx x, int verbose) +print_value (pretty_printer *pp, const_rtx x, int verbose) { - char t[BUF_LEN]; - char *cur = buf; + char tmp[1024]; if (!x) { - safe_concat (buf, buf, "(nil)"); + pp_string (pp, "(nil)"); return; } switch (GET_CODE (x)) { case CONST_INT: - sprintf (t, HOST_WIDE_INT_PRINT_HEX, - (unsigned HOST_WIDE_INT) INTVAL (x)); - cur = safe_concat (buf, cur, t); + pp_scalar (pp, HOST_WIDE_INT_PRINT_HEX, + (unsigned HOST_WIDE_INT) INTVAL (x)); break; case CONST_DOUBLE: if (FLOAT_MODE_P (GET_MODE (x))) - real_to_decimal (t, CONST_DOUBLE_REAL_VALUE (x), sizeof (t), 0, 1); + { + real_to_decimal (tmp, CONST_DOUBLE_REAL_VALUE (x), + sizeof (tmp), 0, 1); + pp_string (pp, tmp); + } else - sprintf (t, - "<" HOST_WIDE_INT_PRINT_HEX "," HOST_WIDE_INT_PRINT_HEX ">", - (unsigned HOST_WIDE_INT) CONST_DOUBLE_LOW (x), - (unsigned HOST_WIDE_INT) CONST_DOUBLE_HIGH (x)); - cur = safe_concat (buf, cur, t); + pp_printf (pp, "<%wx,%wx>", + (unsigned HOST_WIDE_INT) CONST_DOUBLE_LOW (x), + (unsigned HOST_WIDE_INT) CONST_DOUBLE_HIGH (x)); break; case CONST_FIXED: - fixed_to_decimal (t, CONST_FIXED_VALUE (x), sizeof (t)); - cur = safe_concat (buf, cur, t); + fixed_to_decimal (tmp, CONST_FIXED_VALUE (x), sizeof (tmp)); + pp_string (pp, tmp); break; case CONST_STRING: - cur = safe_concat (buf, cur, "\""); - cur = safe_concat (buf, cur, XSTR (x, 0)); - cur = safe_concat (buf, cur, "\""); + pp_printf (pp, "\"%s\"", XSTR (x, 0)); break; case SYMBOL_REF: - cur = safe_concat (buf, cur, "`"); - cur = safe_concat (buf, cur, XSTR (x, 0)); - cur = safe_concat (buf, cur, "'"); + pp_printf (pp, "`%s'", XSTR (x, 0)); break; case LABEL_REF: - sprintf (t, "L%d", INSN_UID (XEXP (x, 0))); - cur = safe_concat (buf, cur, t); + pp_printf (pp, "L%d", INSN_UID (XEXP (x, 0))); break; case CONST: - print_value (t, XEXP (x, 0), verbose); - cur = safe_concat (buf, cur, "const("); - cur = safe_concat (buf, cur, t); - cur = safe_concat (buf, cur, ")"); - break; case HIGH: - print_value (t, XEXP (x, 0), verbose); - cur = safe_concat (buf, cur, "high("); - cur = safe_concat (buf, cur, t); - cur = safe_concat (buf, cur, ")"); + case STRICT_LOW_PART: + pp_printf (pp, "%s(", GET_RTX_NAME (GET_CODE (x))); + print_value (pp, XEXP (x, 0), verbose); + pp_character (pp, ')'); break; case REG: if (REGNO (x) < FIRST_PSEUDO_REGISTER) { - int c = reg_names[REGNO (x)][0]; - if (ISDIGIT (c)) - cur = safe_concat (buf, cur, "%"); - - cur = safe_concat (buf, cur, reg_names[REGNO (x)]); + if (ISDIGIT (reg_names[REGNO (x)][0])) + pp_character (pp, '%'); + pp_string (pp, reg_names[REGNO (x)]); } else - { - sprintf (t, "r%d", REGNO (x)); - cur = safe_concat (buf, cur, t); - } + pp_printf (pp, "r%d", REGNO (x)); if (verbose) - { - sprintf (t, ":%s", GET_MODE_NAME (GET_MODE (x))); - cur = safe_concat (buf, cur, t); - } + pp_printf (pp, ":%s", GET_MODE_NAME (GET_MODE (x))); break; case SUBREG: - print_value (t, SUBREG_REG (x), verbose); - cur = safe_concat (buf, cur, t); - sprintf (t, "#%d", SUBREG_BYTE (x)); - cur = safe_concat (buf, cur, t); + print_value (pp, SUBREG_REG (x), verbose); + pp_printf (pp, "#%d", SUBREG_BYTE (x)); break; - case STRICT_LOW_PART: - print_value (t, XEXP (x, 0), verbose); - cur = safe_concat (buf, cur, "strict_low_part("); - cur = safe_concat (buf, cur, t); - cur = safe_concat (buf, cur, ")"); - break; case SCRATCH: - cur = safe_concat (buf, cur, "scratch"); - break; case CC0: - cur = safe_concat (buf, cur, "cc0"); - break; case PC: - cur = safe_concat (buf, cur, "pc"); + pp_string (pp, GET_RTX_NAME (GET_CODE (x))); break; case MEM: - print_value (t, XEXP (x, 0), verbose); - cur = safe_concat (buf, cur, "["); - cur = safe_concat (buf, cur, t); - cur = safe_concat (buf, cur, "]"); + pp_character (pp, '['); + print_value (pp, XEXP (x, 0), verbose); + pp_character (pp, ']'); break; case DEBUG_EXPR: - sprintf (t, "D#%i", DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x))); - cur = safe_concat (buf, cur, t); + pp_printf (pp, "D#%i", DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x))); break; default: - print_exp (t, x, verbose); - cur = safe_concat (buf, cur, t); + print_exp (pp, x, verbose); break; } } /* print_value */ -/* Print X, an RTL value node, to file F in slim format. Include - additional information if VERBOSE is nonzero. - - Value nodes are constants, registers, labels, symbols and - memory. */ - -void -dump_value_slim (FILE *f, const_rtx x, int verbose) -{ - char buf[BUF_LEN]; - - print_value (buf, x, verbose); - fprintf (f, "%s", buf); -} - /* The next step in insn detalization, its pattern recognition. */ void -print_pattern (char *buf, const_rtx x, int verbose) +print_pattern (pretty_printer *pp, const_rtx x, int verbose) { - char t1[BUF_LEN], t2[BUF_LEN], t3[BUF_LEN]; - if (! x) { - sprintf (buf, "(nil)"); + pp_string (pp, "(nil)"); return; } switch (GET_CODE (x)) { case SET: - print_value (t1, SET_DEST (x), verbose); - print_value (t2, SET_SRC (x), verbose); - sprintf (buf, "%s=%s", t1, t2); + print_value (pp, SET_DEST (x), verbose); + pp_character (pp, '='); + print_value (pp, SET_SRC (x), verbose); break; case RETURN: case SIMPLE_RETURN: case EH_RETURN: - sprintf (buf, GET_RTX_NAME (GET_CODE (x))); + pp_string (pp, GET_RTX_NAME (GET_CODE (x))); break; case CALL: - print_exp (buf, x, verbose); + print_exp (pp, x, verbose); break; case CLOBBER: case USE: - print_value (t1, XEXP (x, 0), verbose); - sprintf (buf, "%s %s", GET_RTX_NAME (GET_CODE (x)), t1); + pp_printf (pp, "%s ", GET_RTX_NAME (GET_CODE (x))); + print_value (pp, XEXP (x, 0), verbose); break; case VAR_LOCATION: - print_value (t1, PAT_VAR_LOCATION_LOC (x), verbose); - sprintf (buf, "loc %s", t1); + pp_string (pp, "loc "); + print_value (pp, PAT_VAR_LOCATION_LOC (x), verbose); break; case COND_EXEC: + pp_character (pp, '('); if (GET_CODE (COND_EXEC_TEST (x)) == NE && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx) - print_value (t1, XEXP (COND_EXEC_TEST (x), 0), verbose); + print_value (pp, XEXP (COND_EXEC_TEST (x), 0), verbose); else if (GET_CODE (COND_EXEC_TEST (x)) == EQ && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx) { - t1[0] = '!'; - print_value (t1 + 1, XEXP (COND_EXEC_TEST (x), 0), verbose); + pp_character (pp, '!'); + print_value (pp, XEXP (COND_EXEC_TEST (x), 0), verbose); } else - print_value (t1, COND_EXEC_TEST (x), verbose); - print_pattern (t2, COND_EXEC_CODE (x), verbose); - sprintf (buf, "(%s) %s", t1, t2); + print_value (pp, COND_EXEC_TEST (x), verbose); + pp_string (pp, ") "); + print_pattern (pp, COND_EXEC_CODE (x), verbose); break; case PARALLEL: { int i; - sprintf (t1, "{"); + pp_character (pp, '{'); for (i = 0; i < XVECLEN (x, 0); i++) { - print_pattern (t2, XVECEXP (x, 0, i), verbose); - sprintf (t3, "%s%s;", t1, t2); - strcpy (t1, t3); + print_pattern (pp, XVECEXP (x, 0, i), verbose); + pp_character (pp, ';'); } - sprintf (buf, "%s}", t1); + pp_character (pp, '}'); } break; case SEQUENCE: { int i; - sprintf (t1, "sequence{"); + pp_string (pp, "sequence{"); for (i = 0; i < XVECLEN (x, 0); i++) { - print_pattern (t2, XVECEXP (x, 0, i), verbose); - sprintf (t3, "%s%s;", t1, t2); - strcpy (t1, t3); + print_pattern (pp, XVECEXP (x, 0, i), verbose); + pp_character (pp, ';'); } - sprintf (buf, "%s}", t1); + pp_character (pp, '}'); } break; case ASM_INPUT: - sprintf (buf, "asm {%s}", XSTR (x, 0)); + pp_printf (pp, "asm {%s}", XSTR (x, 0)); break; case ADDR_VEC: /* Fall through. */ case ADDR_DIFF_VEC: - print_value (buf, XEXP (x, 0), verbose); + print_value (pp, XEXP (x, 0), verbose); break; case TRAP_IF: - print_value (t1, TRAP_CONDITION (x), verbose); - sprintf (buf, "trap_if %s", t1); + pp_string (pp, "trap_if "); + print_value (pp, TRAP_CONDITION (x), verbose); break; case UNSPEC: case UNSPEC_VOLATILE: /* Fallthru -- leave UNSPECs to print_exp. */ default: - print_value (buf, x, verbose); + print_value (pp, x, verbose); } } /* print_pattern */ /* This is the main function in slim rtl visualization mechanism. - X is an insn, to be printed into BUF. + X is an insn, to be printed into PP. This function tries to print it properly in human-readable form, resembling assembler mnemonics (instead of the older Lisp-style @@ -672,15 +607,20 @@ void with their INSN_UIDs. */ void -print_insn (char *buf, const_rtx x, int verbose) +print_insn (pretty_printer *pp, const_rtx x, int verbose) { - /* Collect the string to output for X in t1. t2 is a scratch area. */ - char t1[BUF_LEN], t2[BUF_LEN]; + if (verbose) + { + /* Blech, pretty-print can't print integers with a specified width. */ + char uid_prefix[32]; + snprintf (uid_prefix, sizeof uid_prefix, " %4d: ", INSN_UID (x)); + pp_string (pp, uid_prefix); + } switch (GET_CODE (x)) { case INSN: - print_pattern (t1, PATTERN (x), verbose); + print_pattern (pp, PATTERN (x), verbose); break; case DEBUG_INSN: @@ -707,47 +647,46 @@ void name = idbuf; } } + pp_printf (pp, "debug %s => ", name); if (VAR_LOC_UNKNOWN_P (INSN_VAR_LOCATION_LOC (x))) - sprintf (t1, "debug %s optimized away", name); + pp_string (pp, "optimized away"); else - { - print_pattern (t2, INSN_VAR_LOCATION_LOC (x), verbose); - sprintf (t1, "debug %s => %s", name, t2); - } + print_pattern (pp, INSN_VAR_LOCATION_LOC (x), verbose); } break; case JUMP_INSN: - print_pattern (t1, PATTERN (x), verbose); + print_pattern (pp, PATTERN (x), verbose); break; case CALL_INSN: if (GET_CODE (PATTERN (x)) == PARALLEL) - print_pattern (t1, XVECEXP (PATTERN (x), 0, 0), verbose); + print_pattern (pp, XVECEXP (PATTERN (x), 0, 0), verbose); else - print_pattern (t1, PATTERN (x), verbose); + print_pattern (pp, PATTERN (x), verbose); break; case CODE_LABEL: - sprintf (t1, "L%d:", INSN_UID (x)); + pp_printf (pp, "L%d:", INSN_UID (x)); break; case BARRIER: - sprintf (t1, "barrier"); + pp_string (pp, "barrier"); break; case NOTE: { + pp_string (pp, GET_NOTE_INSN_NAME (NOTE_KIND (x))); switch (NOTE_KIND (x)) { case NOTE_INSN_EH_REGION_BEG: case NOTE_INSN_EH_REGION_END: - sprintf (t2, "%d", NOTE_EH_HANDLER (x)); + pp_printf (pp, " %d", NOTE_EH_HANDLER (x)); break; case NOTE_INSN_BLOCK_BEG: case NOTE_INSN_BLOCK_END: - sprintf (t2, "%d", BLOCK_NUMBER (NOTE_BLOCK (x))); + pp_printf (pp, " %d", BLOCK_NUMBER (NOTE_BLOCK (x))); break; case NOTE_INSN_BASIC_BLOCK: - sprintf (t2, "%d", NOTE_BASIC_BLOCK (x)->index); + pp_printf (pp, " %d", NOTE_BASIC_BLOCK (x)->index); break; case NOTE_INSN_DELETED_LABEL: @@ -756,57 +695,86 @@ void const char *label = NOTE_DELETED_LABEL_NAME (x); if (label == NULL) label = ""; - sprintf (t2, "(\"%s\")", label); + pp_printf (pp, " (\"%s\")", label); } break; case NOTE_INSN_VAR_LOCATION: case NOTE_INSN_CALL_ARG_LOCATION: - /* It's safe here to use t1 for scratch because the output - is printed in t2 and put back in t1 at the bottom of - the inner switch statement. */ - print_pattern (t1, NOTE_VAR_LOCATION (x), verbose); - sprintf (t2, "{%s}", t1); + pp_character (pp, '{'); + print_pattern (pp, NOTE_VAR_LOCATION (x), verbose); + pp_character (pp, '}'); break; default: - t2[0] = '\0'; break; } - sprintf (t1, "%s %s", GET_NOTE_INSN_NAME (NOTE_KIND (x)), t2); break; } default: - sprintf (t1, "", GET_RTX_NAME (GET_CODE (x))); - break; + gcc_unreachable (); } +} /* print_insn */ - if (verbose) - sprintf (buf, " %4d: %s", INSN_UID (x), t1); +/* Prerry-print a slim dump of X (an insn) to PP, including any register + note attached to the instruction. */ + +static void +print_insn_with_notes (pretty_printer *pp, const_rtx x) +{ + pp_string (pp, print_rtx_head); + print_insn (pp, x, 1); + pp_newline (pp); + if (INSN_P (x) && REG_NOTES (x)) + for (rtx note = REG_NOTES (x); note; note = XEXP (note, 1)) + { + pp_printf (pp, "%s %s", print_rtx_head, + GET_REG_NOTE_NAME (REG_NOTE_KIND (note))); + print_pattern (pp, XEXP (note, 0), 1); + pp_newline (pp); + } +} + +/* Return a pretty-print buffer set up to print to file F. */ + +static pretty_printer * +init_rtl_slim_pretty_print (FILE *f) +{ + if (! rtl_slim_pp_initialized) + { + pp_construct (&rtl_slim_pp, /*prefix=*/NULL, /*linewidth=*/0); + rtl_slim_pp_initialized = true; + } else - sprintf (buf, "%s", t1); -} /* print_insn */ + /* Clean out any data that str_insn_slim may have left here. */ + pp_clear_output_area (&rtl_slim_pp); + rtl_slim_pp.buffer->stream = f; + return &rtl_slim_pp; +} + +/* Print X, an RTL value node, to file F in slim format. Include + additional information if VERBOSE is nonzero. + + Value nodes are constants, registers, labels, symbols and + memory. */ + +void +dump_value_slim (FILE *f, const_rtx x, int verbose) +{ + pretty_printer *pp = init_rtl_slim_pretty_print (f); + print_value (pp, x, verbose); + pp_flush (pp); +} + /* Emit a slim dump of X (an insn) to the file F, including any register note attached to the instruction. */ void dump_insn_slim (FILE *f, const_rtx x) { - char t[BUF_LEN + 32]; - rtx note; - - print_insn (t, x, 1); - fputs (print_rtx_head, f); - fputs (t, f); - putc ('\n', f); - if (INSN_P (x) && REG_NOTES (x)) - for (note = REG_NOTES (x); note; note = XEXP (note, 1)) - { - fputs (print_rtx_head, f); - print_pattern (t, XEXP (note, 0), 1); - fprintf (f, " %s: %s\n", - GET_REG_NOTE_NAME (REG_NOTE_KIND (note)), t); - } + pretty_printer *pp = init_rtl_slim_pretty_print (f); + print_insn_with_notes (pp, x); + pp_flush (pp); } /* Same as above, but stop at LAST or when COUNT == 0. @@ -817,18 +785,35 @@ dump_rtl_slim (FILE *f, const_rtx first, const_rtx int count, int flags ATTRIBUTE_UNUSED) { const_rtx insn, tail; + pretty_printer *pp = init_rtl_slim_pretty_print (f); tail = last ? NEXT_INSN (last) : NULL_RTX; for (insn = first; (insn != NULL) && (insn != tail) && (count != 0); insn = NEXT_INSN (insn)) { - dump_insn_slim (f, insn); + print_insn_with_notes (pp, insn); if (count > 0) count--; } + + pp_flush (pp); } +/* Pretty-print pattern X of some insn in non-verbose mode. + Return a string pointer to the pretty-printer buffer. + + This function is only exported exists only to accommodate some older users + of the slim RTL pretty printers. Please do not use it for new code. */ + +const char * +str_pattern_slim (const_rtx x) +{ + pretty_printer *pp = init_rtl_slim_pretty_print (NULL); + print_pattern (pp, x, 0); + return pp_base_formatted_text (pp); +} + /* Emit a slim dump of X (an insn) to stderr. */ extern void debug_insn_slim (const_rtx); DEBUG_FUNCTION void Index: haifa-sched.c =================================================================== --- haifa-sched.c (revision 193926) +++ haifa-sched.c (working copy) @@ -2168,8 +2168,6 @@ model_recompute (rtx insn) if (sched_verbose >= 5) { - char buf[2048]; - if (!print_p) { fprintf (sched_dump, MODEL_BAR); @@ -2179,9 +2177,9 @@ model_recompute (rtx insn) print_p = true; } - print_pattern (buf, PATTERN (insn), 0); fprintf (sched_dump, ";;\t\t| %3d %4d %-30s ", - point, INSN_UID (insn), buf); + point, INSN_UID (insn), + str_pattern_slim (PATTERN (insn))); for (pci = 0; pci < ira_pressure_classes_num; pci++) { cl = ira_pressure_classes[pci]; @@ -3343,18 +3341,16 @@ model_record_pressures (struct model_insn_info *in point = model_index (insn->insn); if (sched_verbose >= 2) { - char buf[2048]; - if (point == 0) { fprintf (sched_dump, "\n;;\tModel schedule:\n;;\n"); fprintf (sched_dump, ";;\t| idx insn | mpri hght dpth prio |\n"); } - print_pattern (buf, PATTERN (insn->insn), 0); fprintf (sched_dump, ";;\t| %3d %4d | %4d %4d %4d %4d | %-30s ", point, INSN_UID (insn->insn), insn->model_priority, insn->depth + insn->alap, insn->depth, - INSN_PRIORITY (insn->insn), buf); + INSN_PRIORITY (insn->insn), + str_pattern_slim (PATTERN (insn->insn))); } calculate_reg_deaths (insn->insn, death); reg_pressure = INSN_REG_PRESSURE (insn->insn); @@ -3715,12 +3711,9 @@ schedule_insn (rtx insn) if (sched_verbose >= 1) { struct reg_pressure_data *pressure_info; - char buf[2048]; - - print_insn (buf, insn, 0); - buf[40] = 0; fprintf (sched_dump, ";;\t%3i--> %s%-40s:", - clock_var, (*current_sched_info->print_insn) (insn, 1), buf); + clock_var, (*current_sched_info->print_insn) (insn, 1), + str_pattern_slim (PATTERN (insn))); if (recog_memoized (insn) < 0) fprintf (sched_dump, "nothing"); Index: sel-sched-dump.c =================================================================== --- sel-sched-dump.c (revision 193926) +++ sel-sched-dump.c (working copy) @@ -136,13 +136,8 @@ dump_insn_rtx_1 (rtx insn, int flags) sel_print ("%d;", INSN_UID (insn)); if (flags & DUMP_INSN_RTX_PATTERN) - { - char buf[2048]; + sel_print ("%s;", str_pattern_slim (insn)); - print_insn (buf, insn, 0); - sel_print ("%s;", buf); - } - if (flags & DUMP_INSN_RTX_BBN) { basic_block bb = BLOCK_FOR_INSN (insn); @@ -522,6 +517,7 @@ sel_print_insn (const_rtx insn, int aligned ATTRIB /* Functions for pretty printing of CFG. */ +/* FIXME: Using pretty-print here could simplify this stuff. */ /* Replace all occurencies of STR1 to STR2 in BUF. The BUF must be large enough to hold the result. */ @@ -564,7 +560,8 @@ replace_str_in_buf (char *buf, const char *str1, c while (p); } -/* Replace characters in BUF that have special meaning in .dot file. */ +/* Replace characters in BUF that have special meaning in .dot file. + Similar to pp_write_text_as_dot_label_to_stream. */ static void sel_prepare_string_for_dot_label (char *buf) { Index: graph.c =================================================================== --- graph.c (revision 193926) +++ graph.c (working copy) @@ -29,6 +29,7 @@ along with GCC; see the file COPYING3. If not see #include "rtl.h" #include "tree.h" #include "graph.h" +#include "pretty-print.h" /* DOT files with the .dot extension are recognized as document templates by a well-known piece of word processing software out of Redmond, WA. @@ -56,45 +57,30 @@ open_graph_file (const char *base, const char *mod return fp; } -/* Print the output from print_insn or print_pattern with GraphViz-special - characters escaped as necessary. */ -void -print_escaped_line (FILE *fp, const char *buf) +/* Return a pretty-print buffer for output to file FP. */ + +static pretty_printer * +init_graph_slim_pretty_print (FILE *fp) { - const char *p = buf; + static bool initialized = false; + static pretty_printer graph_slim_pp; - while (*p) + if (! initialized) { - switch (*p) - { - case '\n': - /* Print newlines as a left-aligned newline. */ - fputs ("\\l\\\n", fp); - break; - - case '{': - case '}': - case '<': - case '>': - case '|': - case '"': - case ' ': - /* These characters have to be escaped to work with record-shape nodes. */ - fputc ('\\', fp); - /* fall through */ - default: - fputc (*p, fp); - break; - } - p++; + pp_construct (&graph_slim_pp, /*prefix=*/NULL, /*linewidth=*/0); + initialized = true; } - fputs ("\\l\\\n", fp); + else + gcc_assert (! pp_last_position_in_text (&graph_slim_pp)); + + graph_slim_pp.buffer->stream = fp; + return &graph_slim_pp; } /* Draw a basic block BB belonging to the function with FNDECL_UID as its unique number. */ static void -draw_cfg_node (FILE *fp, int fndecl_uid, basic_block bb) +draw_cfg_node (pretty_printer *pp, int fndecl_uid, basic_block bb) { rtx insn; bool first = true; @@ -115,48 +101,53 @@ static void : "lightgrey"; } - fprintf (fp, - "\tfn_%d_basic_block_%d [shape=%s,style=filled,fillcolor=%s,label=\"", - fndecl_uid, bb->index, shape, fillcolor); + pp_printf (pp, + "\tfn_%d_basic_block_%d " + "[shape=%s,style=filled,fillcolor=%s,label=\"", + fndecl_uid, bb->index, shape, fillcolor); if (bb->index == ENTRY_BLOCK) - fputs ("ENTRY", fp); + pp_string (pp, "ENTRY"); else if (bb->index == EXIT_BLOCK) - fputs ("EXIT", fp); + pp_string (pp, "EXIT"); else { - fputc ('{', fp); + pp_character (pp, '{'); + pp_write_text_to_stream (pp); + /* TODO: inter-bb stuff. */ FOR_BB_INSNS (bb, insn) { - char buf[2048]; - if (! first) - fputc ('|', fp); + { + pp_character (pp, '|'); + pp_write_text_to_stream (pp); + } + first = false; - print_insn (buf, insn, 1); - print_escaped_line (fp, buf); + print_insn (pp, insn, 1); + pp_newline (pp); if (INSN_P (insn) && REG_NOTES (insn)) for (rtx note = REG_NOTES (insn); note; note = XEXP (note, 1)) { - fprintf (fp, " %s: ", - GET_REG_NOTE_NAME (REG_NOTE_KIND (note))); - print_pattern (buf, XEXP (note, 0), 1); - print_escaped_line (fp, buf); + pp_printf (pp, " %s: ", + GET_REG_NOTE_NAME (REG_NOTE_KIND (note))); + print_pattern (pp, XEXP (note, 0), 1); + pp_newline (pp); } - - first = false; + pp_write_text_as_dot_label_to_stream (pp, /*for_record=*/true); } - fputc ('}', fp); + pp_character (pp, '}'); } - fputs ("\"];\n\n", fp); + pp_string (pp, "\"];\n\n"); + pp_flush (pp); } /* Draw all successor edges of a basic block BB belonging to the function with FNDECL_UID as its unique number. */ static void -draw_cfg_node_succ_edges (FILE *fp, int fndecl_uid, basic_block bb) +draw_cfg_node_succ_edges (pretty_printer *pp, int fndecl_uid, basic_block bb) { edge e; edge_iterator ei; @@ -187,14 +178,15 @@ static void if (e->flags & EDGE_ABNORMAL) color = "red"; - fprintf (fp, - "\tfn_%d_basic_block_%d:s -> fn_%d_basic_block_%d:n " - "[style=%s,color=%s,weight=%d,constraint=%s];\n", - fndecl_uid, e->src->index, - fndecl_uid, e->dest->index, - style, color, weight, - (e->flags & (EDGE_FAKE | EDGE_DFS_BACK)) ? "false" : "true"); + pp_printf (pp, + "\tfn_%d_basic_block_%d:s -> fn_%d_basic_block_%d:n " + "[style=%s,color=%s,weight=%d,constraint=%s];\n", + fndecl_uid, e->src->index, + fndecl_uid, e->dest->index, + style, color, weight, + (e->flags & (EDGE_FAKE | EDGE_DFS_BACK)) ? "false" : "true"); } + pp_flush (pp); } /* Print a graphical representation of the CFG of function FUN. @@ -208,19 +200,19 @@ print_rtl_graph_with_bb (const char *base, tree fn int *rpo = XNEWVEC (int, n_basic_blocks); basic_block bb; int i, n; + pretty_printer *pp = init_graph_slim_pretty_print (fp); - fprintf (fp, - "subgraph \"%s\" {\n" - "\tcolor=\"black\";\n" - "\tlabel=\"%s\";\n", - funcname, funcname); + pp_printf (pp, "subgraph \"%s\" {\n" + "\tcolor=\"black\";\n" + "\tlabel=\"%s\";\n", + funcname, funcname); /* First print all basic blocks. Visit the blocks in reverse post order to get a good ranking of the nodes. */ n = pre_and_rev_post_order_compute (NULL, rpo, true); for (i = 0; i < n; i++) - draw_cfg_node (fp, fndecl_uid, BASIC_BLOCK (rpo[i])); + draw_cfg_node (pp, fndecl_uid, BASIC_BLOCK (rpo[i])); /* Draw all edges at the end to get subgraphs right for GraphViz, which requires nodes to be defined before edges to cluster @@ -232,10 +224,10 @@ print_rtl_graph_with_bb (const char *base, tree fn for ourselves is also not desirable.) */ mark_dfs_back_edges (); FOR_ALL_BB (bb) - draw_cfg_node_succ_edges (fp, fndecl_uid, bb); + draw_cfg_node_succ_edges (pp, fndecl_uid, bb); - fputs ("\t}\n", fp); - + pp_printf (pp, "\t}\n"); + pp_flush (pp); fclose (fp); }