From 013a8899f5d9469a835cf1f6ccb1b29f69344959 Mon Sep 17 00:00:00 2001 From: Jeff Law Date: Tue, 20 Oct 2015 23:56:37 -0600 Subject: [PATCH] [PATCH] Move RTL printing code from sched-vis.c into print-rtl.c * Makefile.in (OBJS): Remove sched-vis.c * sched-vis.c: Removed. Code moved into... * print-rtl.c: Here. Include cfg.h, pretty-print.h and print-rtl.h. * rtl.h: Remove prototypes for functions now living in print-rtl.c * print-rtl.h Add prototypes for new functions in print-rtl.c. * auto-inc-dec.c: Include print-rtl.h * cfgrtl.c, combine.c, final.c haifa-sched.c: Likewise. * ira.c, lra-constraints.c, lra.c, sel-sched-dump.c: Likewise. From-SVN: r229110 --- gcc/ChangeLog | 9 + gcc/Makefile.in | 1 - gcc/auto-inc-dec.c | 1 + gcc/cfgrtl.c | 1 + gcc/combine.c | 1 + gcc/final.c | 1 + gcc/haifa-sched.c | 1 + gcc/ira.c | 1 + gcc/lra-constraints.c | 1 + gcc/lra.c | 1 + gcc/print-rtl.c | 880 ++++++++++++++++++++++++++++++++++++++++++++++++ gcc/print-rtl.h | 9 + gcc/rtl.h | 13 - gcc/sched-vis.c | 908 -------------------------------------------------- gcc/sel-sched-dump.c | 1 + 15 files changed, 907 insertions(+), 922 deletions(-) delete mode 100644 gcc/sched-vis.c diff --git a/gcc/ChangeLog b/gcc/ChangeLog index a626aa4..c3ed26a 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,5 +1,14 @@ 2015-10-21 Jeff Law + * Makefile.in (OBJS): Remove sched-vis.c + * sched-vis.c: Removed. Code moved into... + * print-rtl.c: Here. Include cfg.h, pretty-print.h and print-rtl.h. + * rtl.h: Remove prototypes for functions now living in print-rtl.c + * print-rtl.h Add prototypes for new functions in print-rtl.c. + * auto-inc-dec.c: Include print-rtl.h + * cfgrtl.c, combine.c, final.c haifa-sched.c: Likewise. + * ira.c, lra-constraints.c, lra.c, sel-sched-dump.c: Likewise. + * varasm.c (handle_vtv_comdat_section): Mark 2nd parameter with ATTRIBUTE_UNUSED. diff --git a/gcc/Makefile.in b/gcc/Makefile.in index 783e4c9..f7137ee 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -1385,7 +1385,6 @@ OBJS = \ sched-deps.o \ sched-ebb.o \ sched-rgn.o \ - sched-vis.o \ sdbout.o \ sel-sched-ir.o \ sel-sched-dump.o \ diff --git a/gcc/auto-inc-dec.c b/gcc/auto-inc-dec.c index 3b9a1f3..e003b13 100644 --- a/gcc/auto-inc-dec.c +++ b/gcc/auto-inc-dec.c @@ -46,6 +46,7 @@ along with GCC; see the file COPYING3. If not see #include "tree-pass.h" #include "dbgcnt.h" #include "target.h" +#include "print-rtl.h" /* This pass was originally removed from flow.c. However there is almost nothing that remains of that code. diff --git a/gcc/cfgrtl.c b/gcc/cfgrtl.c index 15ce8a7..ef73b49 100644 --- a/gcc/cfgrtl.c +++ b/gcc/cfgrtl.c @@ -70,6 +70,7 @@ along with GCC; see the file COPYING3. If not see #include "common/common-target.h" #include "cfgloop.h" #include "tree-pass.h" +#include "print-rtl.h" /* Holds the interesting leading and trailing notes for the function. Only applicable if the CFG is in cfglayout mode. */ diff --git a/gcc/combine.c b/gcc/combine.c index fd3e19c..f755127 100644 --- a/gcc/combine.c +++ b/gcc/combine.c @@ -112,6 +112,7 @@ along with GCC; see the file COPYING3. If not see #include "valtrack.h" #include "cgraph.h" #include "rtl-iter.h" +#include "print-rtl.h" #ifndef LOAD_EXTEND_OP #define LOAD_EXTEND_OP(M) UNKNOWN diff --git a/gcc/final.c b/gcc/final.c index f01f4fc..b604c44 100644 --- a/gcc/final.c +++ b/gcc/final.c @@ -86,6 +86,7 @@ along with GCC; see the file COPYING3. If not see #include "asan.h" #include "wide-int-print.h" #include "rtl-iter.h" +#include "print-rtl.h" #ifdef XCOFF_DEBUGGING_INFO #include "xcoffout.h" /* Needed for external data diff --git a/gcc/haifa-sched.c b/gcc/haifa-sched.c index 46751fe..3350e37 100644 --- a/gcc/haifa-sched.c +++ b/gcc/haifa-sched.c @@ -148,6 +148,7 @@ along with GCC; see the file COPYING3. If not see #include "ira.h" #include "emit-rtl.h" /* FIXME: Can go away once crtl is moved to rtl.h. */ #include "dumpfile.h" +#include "print-rtl.h" #ifdef INSN_SCHEDULING diff --git a/gcc/ira.c b/gcc/ira.c index 28517c1..4e94632 100644 --- a/gcc/ira.c +++ b/gcc/ira.c @@ -402,6 +402,7 @@ along with GCC; see the file COPYING3. If not see #include "dbgcnt.h" #include "rtl-iter.h" #include "shrink-wrap.h" +#include "print-rtl.h" struct target_ira default_target_ira; struct target_ira_int default_target_ira_int; diff --git a/gcc/lra-constraints.c b/gcc/lra-constraints.c index f8fb36e..afe885a 100644 --- a/gcc/lra-constraints.c +++ b/gcc/lra-constraints.c @@ -141,6 +141,7 @@ #include "lra.h" #include "insn-attr.h" #include "lra-int.h" +#include "print-rtl.h" /* Value of LRA_CURR_RELOAD_NUM at the beginning of BB of the current insn. Remember that LRA_CURR_RELOAD_NUM is the number of emitted diff --git a/gcc/lra.c b/gcc/lra.c index bdbfe51..55b856f 100644 --- a/gcc/lra.c +++ b/gcc/lra.c @@ -137,6 +137,7 @@ along with GCC; see the file COPYING3. If not see #include "lra.h" #include "insn-attr.h" #include "lra-int.h" +#include "print-rtl.h" /* Dump bitmap SET with TITLE and BB INDEX. */ void diff --git a/gcc/print-rtl.c b/gcc/print-rtl.c index b541d83..9153be8 100644 --- a/gcc/print-rtl.c +++ b/gcc/print-rtl.c @@ -35,6 +35,7 @@ along with GCC; see the file COPYING3. If not see #ifndef GENERATOR_FILE #include "alias.h" #include "tree.h" +#include "cfg.h" #include "print-tree.h" #include "flags.h" #include "predict.h" @@ -46,8 +47,11 @@ along with GCC; see the file COPYING3. If not see #include "cselib.h" #include "dumpfile.h" /* for dump_flags */ #include "dwarf2out.h" +#include "pretty-print.h" #endif +#include "print-rtl.h" + static FILE *outfile; static int sawclose = 0; @@ -865,3 +869,879 @@ print_simple_rtl (FILE *outf, const_rtx x) print_rtl (outf, x); flag_simple = 0; } + +#ifndef GENERATOR_FILE +/* The functions below 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. + + 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. */ + +/* For insns we print patterns, and for some patterns we print insns... */ +static void print_insn_with_notes (pretty_printer *, const rtx_insn *); + +/* 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 (pretty_printer *pp, const_rtx x, int verbose) +{ + const char *st[4]; + const char *fun; + rtx op[4]; + int i; + + fun = (char *) 0; + for (i = 0; i < 4; i++) + { + st[i] = (char *) 0; + op[i] = NULL_RTX; + } + + switch (GET_CODE (x)) + { + case PLUS: + op[0] = XEXP (x, 0); + if (CONST_INT_P (XEXP (x, 1)) + && INTVAL (XEXP (x, 1)) < 0) + { + st[1] = "-"; + op[1] = GEN_INT (-INTVAL (XEXP (x, 1))); + } + else + { + st[1] = "+"; + op[1] = XEXP (x, 1); + } + break; + case LO_SUM: + op[0] = XEXP (x, 0); + st[1] = "+low("; + op[1] = XEXP (x, 1); + st[2] = ")"; + break; + case MINUS: + op[0] = XEXP (x, 0); + st[1] = "-"; + op[1] = XEXP (x, 1); + break; + case COMPARE: + fun = "cmp"; + op[0] = XEXP (x, 0); + op[1] = XEXP (x, 1); + break; + case NEG: + st[0] = "-"; + op[0] = XEXP (x, 0); + break; + case FMA: + st[0] = "{"; + op[0] = XEXP (x, 0); + st[1] = "*"; + op[1] = XEXP (x, 1); + st[2] = "+"; + op[2] = XEXP (x, 2); + st[3] = "}"; + break; + case MULT: + op[0] = XEXP (x, 0); + st[1] = "*"; + op[1] = XEXP (x, 1); + break; + case DIV: + op[0] = XEXP (x, 0); + st[1] = "/"; + op[1] = XEXP (x, 1); + break; + case UDIV: + fun = "udiv"; + op[0] = XEXP (x, 0); + op[1] = XEXP (x, 1); + break; + case MOD: + op[0] = XEXP (x, 0); + st[1] = "%"; + op[1] = XEXP (x, 1); + break; + case UMOD: + fun = "umod"; + op[0] = XEXP (x, 0); + op[1] = XEXP (x, 1); + break; + case SMIN: + fun = "smin"; + op[0] = XEXP (x, 0); + op[1] = XEXP (x, 1); + break; + case SMAX: + fun = "smax"; + op[0] = XEXP (x, 0); + op[1] = XEXP (x, 1); + break; + case UMIN: + fun = "umin"; + op[0] = XEXP (x, 0); + op[1] = XEXP (x, 1); + break; + case UMAX: + fun = "umax"; + op[0] = XEXP (x, 0); + op[1] = XEXP (x, 1); + break; + case NOT: + st[0] = "!"; + op[0] = XEXP (x, 0); + break; + case AND: + op[0] = XEXP (x, 0); + st[1] = "&"; + op[1] = XEXP (x, 1); + break; + case IOR: + op[0] = XEXP (x, 0); + st[1] = "|"; + op[1] = XEXP (x, 1); + break; + case XOR: + op[0] = XEXP (x, 0); + st[1] = "^"; + op[1] = XEXP (x, 1); + break; + case ASHIFT: + op[0] = XEXP (x, 0); + st[1] = "<<"; + op[1] = XEXP (x, 1); + break; + case LSHIFTRT: + op[0] = XEXP (x, 0); + st[1] = " 0>>"; + op[1] = XEXP (x, 1); + break; + case ASHIFTRT: + op[0] = XEXP (x, 0); + st[1] = ">>"; + op[1] = XEXP (x, 1); + break; + case ROTATE: + op[0] = XEXP (x, 0); + st[1] = "<-<"; + op[1] = XEXP (x, 1); + break; + case ROTATERT: + op[0] = XEXP (x, 0); + st[1] = ">->"; + op[1] = XEXP (x, 1); + break; + case NE: + op[0] = XEXP (x, 0); + st[1] = "!="; + op[1] = XEXP (x, 1); + break; + case EQ: + op[0] = XEXP (x, 0); + st[1] = "=="; + op[1] = XEXP (x, 1); + break; + case GE: + op[0] = XEXP (x, 0); + st[1] = ">="; + op[1] = XEXP (x, 1); + break; + case GT: + op[0] = XEXP (x, 0); + st[1] = ">"; + op[1] = XEXP (x, 1); + break; + case LE: + op[0] = XEXP (x, 0); + st[1] = "<="; + op[1] = XEXP (x, 1); + break; + case LT: + op[0] = XEXP (x, 0); + st[1] = "<"; + op[1] = XEXP (x, 1); + break; + case SIGN_EXTRACT: + fun = (verbose) ? "sign_extract" : "sxt"; + op[0] = XEXP (x, 0); + op[1] = XEXP (x, 1); + op[2] = XEXP (x, 2); + break; + case ZERO_EXTRACT: + fun = (verbose) ? "zero_extract" : "zxt"; + op[0] = XEXP (x, 0); + op[1] = XEXP (x, 1); + op[2] = XEXP (x, 2); + break; + case SIGN_EXTEND: + fun = (verbose) ? "sign_extend" : "sxn"; + op[0] = XEXP (x, 0); + break; + case ZERO_EXTEND: + fun = (verbose) ? "zero_extend" : "zxn"; + op[0] = XEXP (x, 0); + break; + case FLOAT_EXTEND: + fun = (verbose) ? "float_extend" : "fxn"; + op[0] = XEXP (x, 0); + break; + case TRUNCATE: + fun = (verbose) ? "trunc" : "trn"; + op[0] = XEXP (x, 0); + break; + case FLOAT_TRUNCATE: + fun = (verbose) ? "float_trunc" : "ftr"; + op[0] = XEXP (x, 0); + break; + case FLOAT: + fun = (verbose) ? "float" : "flt"; + op[0] = XEXP (x, 0); + break; + case UNSIGNED_FLOAT: + fun = (verbose) ? "uns_float" : "ufl"; + op[0] = XEXP (x, 0); + break; + case FIX: + fun = "fix"; + op[0] = XEXP (x, 0); + break; + case UNSIGNED_FIX: + fun = (verbose) ? "uns_fix" : "ufx"; + op[0] = XEXP (x, 0); + break; + case PRE_DEC: + st[0] = "--"; + op[0] = XEXP (x, 0); + break; + case PRE_INC: + st[0] = "++"; + op[0] = XEXP (x, 0); + break; + case POST_DEC: + op[0] = XEXP (x, 0); + st[1] = "--"; + break; + case POST_INC: + op[0] = XEXP (x, 0); + st[1] = "++"; + break; + case PRE_MODIFY: + st[0] = "pre "; + op[0] = XEXP (XEXP (x, 1), 0); + st[1] = "+="; + op[1] = XEXP (XEXP (x, 1), 1); + break; + case POST_MODIFY: + st[0] = "post "; + op[0] = XEXP (XEXP (x, 1), 0); + st[1] = "+="; + op[1] = XEXP (XEXP (x, 1), 1); + break; + case CALL: + st[0] = "call "; + op[0] = XEXP (x, 0); + if (verbose) + { + st[1] = " argc:"; + op[1] = XEXP (x, 1); + } + break; + case IF_THEN_ELSE: + st[0] = "{("; + op[0] = XEXP (x, 0); + st[1] = ")?"; + op[1] = XEXP (x, 1); + st[2] = ":"; + op[2] = XEXP (x, 2); + st[3] = "}"; + break; + case TRAP_IF: + fun = "trap_if"; + op[0] = TRAP_CONDITION (x); + break; + case PREFETCH: + fun = "prefetch"; + op[0] = XEXP (x, 0); + op[1] = XEXP (x, 1); + op[2] = XEXP (x, 2); + break; + case UNSPEC: + case UNSPEC_VOLATILE: + { + pp_string (pp, "unspec"); + if (GET_CODE (x) == UNSPEC_VOLATILE) + pp_string (pp, "/v"); + pp_left_bracket (pp); + for (i = 0; i < XVECLEN (x, 0); i++) + { + if (i != 0) + pp_comma (pp); + print_pattern (pp, XVECEXP (x, 0, i), verbose); + } + pp_string (pp, "] "); + pp_decimal_int (pp, XINT (x, 1)); + } + break; + default: + { + /* Most unhandled codes can be printed as pseudo-functions. */ + if (GET_RTX_CLASS (GET_CODE (x)) == RTX_UNARY) + { + fun = GET_RTX_NAME (GET_CODE (x)); + op[0] = XEXP (x, 0); + } + else if (GET_RTX_CLASS (GET_CODE (x)) == RTX_COMPARE + || GET_RTX_CLASS (GET_CODE (x)) == RTX_COMM_COMPARE + || GET_RTX_CLASS (GET_CODE (x)) == RTX_BIN_ARITH + || GET_RTX_CLASS (GET_CODE (x)) == RTX_COMM_ARITH) + { + fun = GET_RTX_NAME (GET_CODE (x)); + op[0] = XEXP (x, 0); + op[1] = XEXP (x, 1); + } + else if (GET_RTX_CLASS (GET_CODE (x)) == RTX_TERNARY) + { + fun = GET_RTX_NAME (GET_CODE (x)); + op[0] = XEXP (x, 0); + op[1] = XEXP (x, 1); + op[2] = XEXP (x, 2); + } + else + /* Give up, just print the RTX name. */ + st[0] = GET_RTX_NAME (GET_CODE (x)); + } + break; + } + + /* Print this as a function? */ + if (fun) + { + pp_string (pp, fun); + pp_left_paren (pp); + } + + for (i = 0; i < 4; i++) + { + if (st[i]) + pp_string (pp, st[i]); + + if (op[i]) + { + if (fun && i != 0) + pp_comma (pp); + print_value (pp, op[i], verbose); + } + } + + if (fun) + pp_right_paren (pp); +} /* print_exp */ + +/* Prints rtxes, I customarily classified as values. They're constants, + registers, labels, symbols and memory accesses. */ + +void +print_value (pretty_printer *pp, const_rtx x, int verbose) +{ + char tmp[1024]; + + if (!x) + { + pp_string (pp, "(nil)"); + return; + } + switch (GET_CODE (x)) + { + case CONST_INT: + pp_scalar (pp, HOST_WIDE_INT_PRINT_HEX, + (unsigned HOST_WIDE_INT) INTVAL (x)); + break; + + case CONST_WIDE_INT: + { + const char *sep = "<"; + int i; + for (i = CONST_WIDE_INT_NUNITS (x) - 1; i >= 0; i--) + { + pp_string (pp, sep); + sep = ","; + sprintf (tmp, HOST_WIDE_INT_PRINT_HEX, + (unsigned HOST_WIDE_INT) CONST_WIDE_INT_ELT (x, i)); + pp_string (pp, tmp); + } + pp_greater (pp); + } + break; + + case CONST_DOUBLE: + if (FLOAT_MODE_P (GET_MODE (x))) + { + real_to_decimal (tmp, CONST_DOUBLE_REAL_VALUE (x), + sizeof (tmp), 0, 1); + pp_string (pp, tmp); + } + else + 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 (tmp, CONST_FIXED_VALUE (x), sizeof (tmp)); + pp_string (pp, tmp); + break; + case CONST_STRING: + pp_printf (pp, "\"%s\"", XSTR (x, 0)); + break; + case SYMBOL_REF: + pp_printf (pp, "`%s'", XSTR (x, 0)); + break; + case LABEL_REF: + pp_printf (pp, "L%d", INSN_UID (LABEL_REF_LABEL (x))); + break; + case CONST: + case HIGH: + case STRICT_LOW_PART: + pp_printf (pp, "%s(", GET_RTX_NAME (GET_CODE (x))); + print_value (pp, XEXP (x, 0), verbose); + pp_right_paren (pp); + break; + case REG: + if (REGNO (x) < FIRST_PSEUDO_REGISTER) + { + if (ISDIGIT (reg_names[REGNO (x)][0])) + pp_modulo (pp); + pp_string (pp, reg_names[REGNO (x)]); + } + else + pp_printf (pp, "r%d", REGNO (x)); + if (verbose) + pp_printf (pp, ":%s", GET_MODE_NAME (GET_MODE (x))); + break; + case SUBREG: + print_value (pp, SUBREG_REG (x), verbose); + pp_printf (pp, "#%d", SUBREG_BYTE (x)); + break; + case SCRATCH: + case CC0: + case PC: + pp_string (pp, GET_RTX_NAME (GET_CODE (x))); + break; + case MEM: + pp_left_bracket (pp); + print_value (pp, XEXP (x, 0), verbose); + pp_right_bracket (pp); + break; + case DEBUG_EXPR: + pp_printf (pp, "D#%i", DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x))); + break; + default: + print_exp (pp, x, verbose); + break; + } +} /* print_value */ + +/* The next step in insn detalization, its pattern recognition. */ + +void +print_pattern (pretty_printer *pp, const_rtx x, int verbose) +{ + if (! x) + { + pp_string (pp, "(nil)"); + return; + } + + switch (GET_CODE (x)) + { + case SET: + print_value (pp, SET_DEST (x), verbose); + pp_equal (pp); + print_value (pp, SET_SRC (x), verbose); + break; + case RETURN: + case SIMPLE_RETURN: + case EH_RETURN: + pp_string (pp, GET_RTX_NAME (GET_CODE (x))); + break; + case CALL: + print_exp (pp, x, verbose); + break; + case CLOBBER: + case USE: + pp_printf (pp, "%s ", GET_RTX_NAME (GET_CODE (x))); + print_value (pp, XEXP (x, 0), verbose); + break; + case VAR_LOCATION: + pp_string (pp, "loc "); + print_value (pp, PAT_VAR_LOCATION_LOC (x), verbose); + break; + case COND_EXEC: + pp_left_paren (pp); + if (GET_CODE (COND_EXEC_TEST (x)) == NE + && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx) + print_value (pp, XEXP (COND_EXEC_TEST (x), 0), verbose); + else if (GET_CODE (COND_EXEC_TEST (x)) == EQ + && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx) + { + pp_exclamation (pp); + print_value (pp, XEXP (COND_EXEC_TEST (x), 0), verbose); + } + else + print_value (pp, COND_EXEC_TEST (x), verbose); + pp_string (pp, ") "); + print_pattern (pp, COND_EXEC_CODE (x), verbose); + break; + case PARALLEL: + { + int i; + + pp_left_brace (pp); + for (i = 0; i < XVECLEN (x, 0); i++) + { + print_pattern (pp, XVECEXP (x, 0, i), verbose); + pp_semicolon (pp); + } + pp_right_brace (pp); + } + break; + case SEQUENCE: + { + const rtx_sequence *seq = as_a (x); + pp_string (pp, "sequence{"); + if (INSN_P (seq->element (0))) + { + /* Print the sequence insns indented. */ + const char * save_print_rtx_head = print_rtx_head; + char indented_print_rtx_head[32]; + + pp_newline (pp); + gcc_assert (strlen (print_rtx_head) < sizeof (indented_print_rtx_head) - 4); + snprintf (indented_print_rtx_head, + sizeof (indented_print_rtx_head), + "%s ", print_rtx_head); + print_rtx_head = indented_print_rtx_head; + for (int i = 0; i < seq->len (); i++) + print_insn_with_notes (pp, seq->insn (i)); + pp_printf (pp, "%s ", save_print_rtx_head); + print_rtx_head = save_print_rtx_head; + } + else + { + for (int i = 0; i < seq->len (); i++) + { + print_pattern (pp, seq->element (i), verbose); + pp_semicolon (pp); + } + } + pp_right_brace (pp); + } + break; + case ASM_INPUT: + pp_printf (pp, "asm {%s}", XSTR (x, 0)); + break; + case ADDR_VEC: + for (int i = 0; i < XVECLEN (x, 0); i++) + { + print_value (pp, XVECEXP (x, 0, i), verbose); + pp_semicolon (pp); + } + break; + case ADDR_DIFF_VEC: + for (int i = 0; i < XVECLEN (x, 1); i++) + { + print_value (pp, XVECEXP (x, 1, i), verbose); + pp_semicolon (pp); + } + break; + case TRAP_IF: + 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 (pp, x, verbose); + } +} /* print_pattern */ + +/* This is the main function in slim rtl visualization mechanism. + + 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 + form). + + If VERBOSE is TRUE, insns are printed with more complete (but + longer) pattern names and with extra information, and prefixed + with their INSN_UIDs. */ + +void +print_insn (pretty_printer *pp, const rtx_insn *x, int verbose) +{ + 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 (pp, PATTERN (x), verbose); + break; + + case DEBUG_INSN: + { + const char *name = "?"; + + if (DECL_P (INSN_VAR_LOCATION_DECL (x))) + { + tree id = DECL_NAME (INSN_VAR_LOCATION_DECL (x)); + char idbuf[32]; + if (id) + name = IDENTIFIER_POINTER (id); + else if (TREE_CODE (INSN_VAR_LOCATION_DECL (x)) + == DEBUG_EXPR_DECL) + { + sprintf (idbuf, "D#%i", + DEBUG_TEMP_UID (INSN_VAR_LOCATION_DECL (x))); + name = idbuf; + } + else + { + sprintf (idbuf, "D.%i", + DECL_UID (INSN_VAR_LOCATION_DECL (x))); + name = idbuf; + } + } + pp_printf (pp, "debug %s => ", name); + if (VAR_LOC_UNKNOWN_P (INSN_VAR_LOCATION_LOC (x))) + pp_string (pp, "optimized away"); + else + print_pattern (pp, INSN_VAR_LOCATION_LOC (x), verbose); + } + break; + + case JUMP_INSN: + print_pattern (pp, PATTERN (x), verbose); + break; + case CALL_INSN: + if (GET_CODE (PATTERN (x)) == PARALLEL) + print_pattern (pp, XVECEXP (PATTERN (x), 0, 0), verbose); + else + print_pattern (pp, PATTERN (x), verbose); + break; + case CODE_LABEL: + pp_printf (pp, "L%d:", INSN_UID (x)); + break; + case JUMP_TABLE_DATA: + pp_string (pp, "jump_table_data{\n"); + print_pattern (pp, PATTERN (x), verbose); + pp_right_brace (pp); + break; + case 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: + pp_printf (pp, " %d", NOTE_EH_HANDLER (x)); + break; + + case NOTE_INSN_BLOCK_BEG: + case NOTE_INSN_BLOCK_END: + pp_printf (pp, " %d", BLOCK_NUMBER (NOTE_BLOCK (x))); + break; + + case NOTE_INSN_BASIC_BLOCK: + pp_printf (pp, " %d", NOTE_BASIC_BLOCK (x)->index); + break; + + case NOTE_INSN_DELETED_LABEL: + case NOTE_INSN_DELETED_DEBUG_LABEL: + { + const char *label = NOTE_DELETED_LABEL_NAME (x); + if (label == NULL) + label = ""; + pp_printf (pp, " (\"%s\")", label); + } + break; + + case NOTE_INSN_VAR_LOCATION: + case NOTE_INSN_CALL_ARG_LOCATION: + pp_left_brace (pp); + print_pattern (pp, NOTE_VAR_LOCATION (x), verbose); + pp_right_brace (pp); + break; + + default: + break; + } + break; + } + default: + gcc_unreachable (); + } +} /* print_insn */ + +/* Pretty-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_insn *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))); + if (GET_CODE (note) == INT_LIST) + pp_printf (pp, "%d", XINT (note, 0)); + else + print_pattern (pp, XEXP (note, 0), 1); + pp_newline (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 rtl_slim_pp; + rtl_slim_pp.buffer->stream = f; + print_value (&rtl_slim_pp, x, verbose); + pp_flush (&rtl_slim_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_insn *x) +{ + pretty_printer rtl_slim_pp; + rtl_slim_pp.buffer->stream = f; + print_insn_with_notes (&rtl_slim_pp, x); + pp_flush (&rtl_slim_pp); +} + +/* Same as above, but stop at LAST or when COUNT == 0. + If COUNT < 0 it will stop only at LAST or NULL rtx. */ + +void +dump_rtl_slim (FILE *f, const rtx_insn *first, const rtx_insn *last, + int count, int flags ATTRIBUTE_UNUSED) +{ + const rtx_insn *insn, *tail; + pretty_printer rtl_slim_pp; + rtl_slim_pp.buffer->stream = f; + + tail = last ? NEXT_INSN (last) : NULL; + for (insn = first; + (insn != NULL) && (insn != tail) && (count != 0); + insn = NEXT_INSN (insn)) + { + print_insn_with_notes (&rtl_slim_pp, insn); + if (count > 0) + count--; + } + + pp_flush (&rtl_slim_pp); +} + +/* Dumps basic block BB to pretty-printer PP in slim form and without and + no indentation, for use as a label of a DOT graph record-node. */ + +void +rtl_dump_bb_for_graph (pretty_printer *pp, basic_block bb) +{ + rtx_insn *insn; + bool first = true; + + /* TODO: inter-bb stuff. */ + FOR_BB_INSNS (bb, insn) + { + if (! first) + { + pp_bar (pp); + pp_write_text_to_stream (pp); + } + first = false; + print_insn_with_notes (pp, insn); + pp_write_text_as_dot_label_to_stream (pp, /*for_record=*/true); + } +} + +/* 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 rtl_slim_pp; + print_pattern (&rtl_slim_pp, x, 0); + return ggc_strdup (pp_formatted_text (&rtl_slim_pp)); +} + +/* Emit a slim dump of X (an insn) to stderr. */ +extern void debug_insn_slim (const rtx_insn *); +DEBUG_FUNCTION void +debug_insn_slim (const rtx_insn *x) +{ + dump_insn_slim (stderr, x); +} + +/* Same as above, but using dump_rtl_slim. */ +extern void debug_rtl_slim (FILE *, const rtx_insn *, const rtx_insn *, + int, int); +DEBUG_FUNCTION void +debug_rtl_slim (const rtx_insn *first, const rtx_insn *last, int count, + int flags) +{ + dump_rtl_slim (stderr, first, last, count, flags); +} + +extern void debug_bb_slim (basic_block); +DEBUG_FUNCTION void +debug_bb_slim (basic_block bb) +{ + dump_bb (stderr, bb, 0, TDF_SLIM | TDF_BLOCKS); +} + +extern void debug_bb_n_slim (int); +DEBUG_FUNCTION void +debug_bb_n_slim (int n) +{ + basic_block bb = BASIC_BLOCK_FOR_FN (cfun, n); + debug_bb_slim (bb); +} + +#endif diff --git a/gcc/print-rtl.h b/gcc/print-rtl.h index c9b7154..eb079af 100644 --- a/gcc/print-rtl.h +++ b/gcc/print-rtl.h @@ -24,4 +24,13 @@ along with GCC; see the file COPYING3. If not see extern void print_rtl (FILE *, const_rtx); #endif +extern void dump_value_slim (FILE *, const_rtx, int); +extern void dump_insn_slim (FILE *, const rtx_insn *); +extern void dump_rtl_slim (FILE *, const rtx_insn *, const rtx_insn *, + int, int); +extern void print_value (pretty_printer *, const_rtx, int); +extern void print_pattern (pretty_printer *, const_rtx, int); +extern void rtl_dump_bb_for_graph (pretty_printer *, basic_block); +extern const char *str_pattern_slim (const_rtx); + #endif // GCC_PRINT_RTL_H diff --git a/gcc/rtl.h b/gcc/rtl.h index d6edc71..ad0cf6a 100644 --- a/gcc/rtl.h +++ b/gcc/rtl.h @@ -3565,19 +3565,6 @@ 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. 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_insn *); -extern void dump_rtl_slim (FILE *, const rtx_insn *, const rtx_insn *, - int, 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_insn *, int); -extern void rtl_dump_bb_for_graph (pretty_printer *, basic_block); -extern const char *str_pattern_slim (const_rtx); - /* In stmt.c */ extern void expand_null_return (void); extern void expand_naked_return (void); diff --git a/gcc/sched-vis.c b/gcc/sched-vis.c deleted file mode 100644 index f115e0a..0000000 --- a/gcc/sched-vis.c +++ /dev/null @@ -1,908 +0,0 @@ -/* Printing of RTL in "slim", mnemonic like form. - Copyright (C) 1992-2015 Free Software Foundation, Inc. - Contributed by Michael Tiemann (tiemann@cygnus.com) Enhanced by, - and currently maintained by, Jim Wilson (wilson@cygnus.com) - -This file is part of GCC. - -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 -Software Foundation; either version 3, or (at your option) any later -version. - -GCC is distributed in the hope that it will be useful, but WITHOUT ANY -WARRANTY; without even the implied warranty of MERCHANTABILITY or -FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -for more details. - -You should have received a copy of the GNU General Public License -along with GCC; see the file COPYING3. If not see -. */ - -/* Historically this form of RTL dumping was introduced along with - the Haifa instruction scheduling pass, hence the name of this file. - But there is nothing in this file left that is scheduler-specific. */ - -#include "config.h" -#include "system.h" -#include "coretypes.h" -#include "backend.h" -#include "rtl.h" -#include "alias.h" -#include "tree.h" -#include "dumpfile.h" /* for the TDF_* flags */ -#include "pretty-print.h" - -/* 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. - - 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. */ - -/* For insns we print patterns, and for some patterns we print insns... */ -static void print_insn_with_notes (pretty_printer *, const rtx_insn *); - -/* 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 (pretty_printer *pp, const_rtx x, int verbose) -{ - const char *st[4]; - const char *fun; - rtx op[4]; - int i; - - fun = (char *) 0; - for (i = 0; i < 4; i++) - { - st[i] = (char *) 0; - op[i] = NULL_RTX; - } - - switch (GET_CODE (x)) - { - case PLUS: - op[0] = XEXP (x, 0); - if (CONST_INT_P (XEXP (x, 1)) - && INTVAL (XEXP (x, 1)) < 0) - { - st[1] = "-"; - op[1] = GEN_INT (-INTVAL (XEXP (x, 1))); - } - else - { - st[1] = "+"; - op[1] = XEXP (x, 1); - } - break; - case LO_SUM: - op[0] = XEXP (x, 0); - st[1] = "+low("; - op[1] = XEXP (x, 1); - st[2] = ")"; - break; - case MINUS: - op[0] = XEXP (x, 0); - st[1] = "-"; - op[1] = XEXP (x, 1); - break; - case COMPARE: - fun = "cmp"; - op[0] = XEXP (x, 0); - op[1] = XEXP (x, 1); - break; - case NEG: - st[0] = "-"; - op[0] = XEXP (x, 0); - break; - case FMA: - st[0] = "{"; - op[0] = XEXP (x, 0); - st[1] = "*"; - op[1] = XEXP (x, 1); - st[2] = "+"; - op[2] = XEXP (x, 2); - st[3] = "}"; - break; - case MULT: - op[0] = XEXP (x, 0); - st[1] = "*"; - op[1] = XEXP (x, 1); - break; - case DIV: - op[0] = XEXP (x, 0); - st[1] = "/"; - op[1] = XEXP (x, 1); - break; - case UDIV: - fun = "udiv"; - op[0] = XEXP (x, 0); - op[1] = XEXP (x, 1); - break; - case MOD: - op[0] = XEXP (x, 0); - st[1] = "%"; - op[1] = XEXP (x, 1); - break; - case UMOD: - fun = "umod"; - op[0] = XEXP (x, 0); - op[1] = XEXP (x, 1); - break; - case SMIN: - fun = "smin"; - op[0] = XEXP (x, 0); - op[1] = XEXP (x, 1); - break; - case SMAX: - fun = "smax"; - op[0] = XEXP (x, 0); - op[1] = XEXP (x, 1); - break; - case UMIN: - fun = "umin"; - op[0] = XEXP (x, 0); - op[1] = XEXP (x, 1); - break; - case UMAX: - fun = "umax"; - op[0] = XEXP (x, 0); - op[1] = XEXP (x, 1); - break; - case NOT: - st[0] = "!"; - op[0] = XEXP (x, 0); - break; - case AND: - op[0] = XEXP (x, 0); - st[1] = "&"; - op[1] = XEXP (x, 1); - break; - case IOR: - op[0] = XEXP (x, 0); - st[1] = "|"; - op[1] = XEXP (x, 1); - break; - case XOR: - op[0] = XEXP (x, 0); - st[1] = "^"; - op[1] = XEXP (x, 1); - break; - case ASHIFT: - op[0] = XEXP (x, 0); - st[1] = "<<"; - op[1] = XEXP (x, 1); - break; - case LSHIFTRT: - op[0] = XEXP (x, 0); - st[1] = " 0>>"; - op[1] = XEXP (x, 1); - break; - case ASHIFTRT: - op[0] = XEXP (x, 0); - st[1] = ">>"; - op[1] = XEXP (x, 1); - break; - case ROTATE: - op[0] = XEXP (x, 0); - st[1] = "<-<"; - op[1] = XEXP (x, 1); - break; - case ROTATERT: - op[0] = XEXP (x, 0); - st[1] = ">->"; - op[1] = XEXP (x, 1); - break; - case NE: - op[0] = XEXP (x, 0); - st[1] = "!="; - op[1] = XEXP (x, 1); - break; - case EQ: - op[0] = XEXP (x, 0); - st[1] = "=="; - op[1] = XEXP (x, 1); - break; - case GE: - op[0] = XEXP (x, 0); - st[1] = ">="; - op[1] = XEXP (x, 1); - break; - case GT: - op[0] = XEXP (x, 0); - st[1] = ">"; - op[1] = XEXP (x, 1); - break; - case LE: - op[0] = XEXP (x, 0); - st[1] = "<="; - op[1] = XEXP (x, 1); - break; - case LT: - op[0] = XEXP (x, 0); - st[1] = "<"; - op[1] = XEXP (x, 1); - break; - case SIGN_EXTRACT: - fun = (verbose) ? "sign_extract" : "sxt"; - op[0] = XEXP (x, 0); - op[1] = XEXP (x, 1); - op[2] = XEXP (x, 2); - break; - case ZERO_EXTRACT: - fun = (verbose) ? "zero_extract" : "zxt"; - op[0] = XEXP (x, 0); - op[1] = XEXP (x, 1); - op[2] = XEXP (x, 2); - break; - case SIGN_EXTEND: - fun = (verbose) ? "sign_extend" : "sxn"; - op[0] = XEXP (x, 0); - break; - case ZERO_EXTEND: - fun = (verbose) ? "zero_extend" : "zxn"; - op[0] = XEXP (x, 0); - break; - case FLOAT_EXTEND: - fun = (verbose) ? "float_extend" : "fxn"; - op[0] = XEXP (x, 0); - break; - case TRUNCATE: - fun = (verbose) ? "trunc" : "trn"; - op[0] = XEXP (x, 0); - break; - case FLOAT_TRUNCATE: - fun = (verbose) ? "float_trunc" : "ftr"; - op[0] = XEXP (x, 0); - break; - case FLOAT: - fun = (verbose) ? "float" : "flt"; - op[0] = XEXP (x, 0); - break; - case UNSIGNED_FLOAT: - fun = (verbose) ? "uns_float" : "ufl"; - op[0] = XEXP (x, 0); - break; - case FIX: - fun = "fix"; - op[0] = XEXP (x, 0); - break; - case UNSIGNED_FIX: - fun = (verbose) ? "uns_fix" : "ufx"; - op[0] = XEXP (x, 0); - break; - case PRE_DEC: - st[0] = "--"; - op[0] = XEXP (x, 0); - break; - case PRE_INC: - st[0] = "++"; - op[0] = XEXP (x, 0); - break; - case POST_DEC: - op[0] = XEXP (x, 0); - st[1] = "--"; - break; - case POST_INC: - op[0] = XEXP (x, 0); - st[1] = "++"; - break; - case PRE_MODIFY: - st[0] = "pre "; - op[0] = XEXP (XEXP (x, 1), 0); - st[1] = "+="; - op[1] = XEXP (XEXP (x, 1), 1); - break; - case POST_MODIFY: - st[0] = "post "; - op[0] = XEXP (XEXP (x, 1), 0); - st[1] = "+="; - op[1] = XEXP (XEXP (x, 1), 1); - break; - case CALL: - st[0] = "call "; - op[0] = XEXP (x, 0); - if (verbose) - { - st[1] = " argc:"; - op[1] = XEXP (x, 1); - } - break; - case IF_THEN_ELSE: - st[0] = "{("; - op[0] = XEXP (x, 0); - st[1] = ")?"; - op[1] = XEXP (x, 1); - st[2] = ":"; - op[2] = XEXP (x, 2); - st[3] = "}"; - break; - case TRAP_IF: - fun = "trap_if"; - op[0] = TRAP_CONDITION (x); - break; - case PREFETCH: - fun = "prefetch"; - op[0] = XEXP (x, 0); - op[1] = XEXP (x, 1); - op[2] = XEXP (x, 2); - break; - case UNSPEC: - case UNSPEC_VOLATILE: - { - pp_string (pp, "unspec"); - if (GET_CODE (x) == UNSPEC_VOLATILE) - pp_string (pp, "/v"); - pp_left_bracket (pp); - for (i = 0; i < XVECLEN (x, 0); i++) - { - if (i != 0) - pp_comma (pp); - print_pattern (pp, XVECEXP (x, 0, i), verbose); - } - pp_string (pp, "] "); - pp_decimal_int (pp, XINT (x, 1)); - } - break; - default: - { - /* Most unhandled codes can be printed as pseudo-functions. */ - if (GET_RTX_CLASS (GET_CODE (x)) == RTX_UNARY) - { - fun = GET_RTX_NAME (GET_CODE (x)); - op[0] = XEXP (x, 0); - } - else if (GET_RTX_CLASS (GET_CODE (x)) == RTX_COMPARE - || GET_RTX_CLASS (GET_CODE (x)) == RTX_COMM_COMPARE - || GET_RTX_CLASS (GET_CODE (x)) == RTX_BIN_ARITH - || GET_RTX_CLASS (GET_CODE (x)) == RTX_COMM_ARITH) - { - fun = GET_RTX_NAME (GET_CODE (x)); - op[0] = XEXP (x, 0); - op[1] = XEXP (x, 1); - } - else if (GET_RTX_CLASS (GET_CODE (x)) == RTX_TERNARY) - { - fun = GET_RTX_NAME (GET_CODE (x)); - op[0] = XEXP (x, 0); - op[1] = XEXP (x, 1); - op[2] = XEXP (x, 2); - } - else - /* Give up, just print the RTX name. */ - st[0] = GET_RTX_NAME (GET_CODE (x)); - } - break; - } - - /* Print this as a function? */ - if (fun) - { - pp_string (pp, fun); - pp_left_paren (pp); - } - - for (i = 0; i < 4; i++) - { - if (st[i]) - pp_string (pp, st[i]); - - if (op[i]) - { - if (fun && i != 0) - pp_comma (pp); - print_value (pp, op[i], verbose); - } - } - - if (fun) - pp_right_paren (pp); -} /* print_exp */ - -/* Prints rtxes, I customarily classified as values. They're constants, - registers, labels, symbols and memory accesses. */ - -void -print_value (pretty_printer *pp, const_rtx x, int verbose) -{ - char tmp[1024]; - - if (!x) - { - pp_string (pp, "(nil)"); - return; - } - switch (GET_CODE (x)) - { - case CONST_INT: - pp_scalar (pp, HOST_WIDE_INT_PRINT_HEX, - (unsigned HOST_WIDE_INT) INTVAL (x)); - break; - - case CONST_WIDE_INT: - { - const char *sep = "<"; - int i; - for (i = CONST_WIDE_INT_NUNITS (x) - 1; i >= 0; i--) - { - pp_string (pp, sep); - sep = ","; - sprintf (tmp, HOST_WIDE_INT_PRINT_HEX, - (unsigned HOST_WIDE_INT) CONST_WIDE_INT_ELT (x, i)); - pp_string (pp, tmp); - } - pp_greater (pp); - } - break; - - case CONST_DOUBLE: - if (FLOAT_MODE_P (GET_MODE (x))) - { - real_to_decimal (tmp, CONST_DOUBLE_REAL_VALUE (x), - sizeof (tmp), 0, 1); - pp_string (pp, tmp); - } - else - 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 (tmp, CONST_FIXED_VALUE (x), sizeof (tmp)); - pp_string (pp, tmp); - break; - case CONST_STRING: - pp_printf (pp, "\"%s\"", XSTR (x, 0)); - break; - case SYMBOL_REF: - pp_printf (pp, "`%s'", XSTR (x, 0)); - break; - case LABEL_REF: - pp_printf (pp, "L%d", INSN_UID (LABEL_REF_LABEL (x))); - break; - case CONST: - case HIGH: - case STRICT_LOW_PART: - pp_printf (pp, "%s(", GET_RTX_NAME (GET_CODE (x))); - print_value (pp, XEXP (x, 0), verbose); - pp_right_paren (pp); - break; - case REG: - if (REGNO (x) < FIRST_PSEUDO_REGISTER) - { - if (ISDIGIT (reg_names[REGNO (x)][0])) - pp_modulo (pp); - pp_string (pp, reg_names[REGNO (x)]); - } - else - pp_printf (pp, "r%d", REGNO (x)); - if (verbose) - pp_printf (pp, ":%s", GET_MODE_NAME (GET_MODE (x))); - break; - case SUBREG: - print_value (pp, SUBREG_REG (x), verbose); - pp_printf (pp, "#%d", SUBREG_BYTE (x)); - break; - case SCRATCH: - case CC0: - case PC: - pp_string (pp, GET_RTX_NAME (GET_CODE (x))); - break; - case MEM: - pp_left_bracket (pp); - print_value (pp, XEXP (x, 0), verbose); - pp_right_bracket (pp); - break; - case DEBUG_EXPR: - pp_printf (pp, "D#%i", DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x))); - break; - default: - print_exp (pp, x, verbose); - break; - } -} /* print_value */ - -/* The next step in insn detalization, its pattern recognition. */ - -void -print_pattern (pretty_printer *pp, const_rtx x, int verbose) -{ - if (! x) - { - pp_string (pp, "(nil)"); - return; - } - - switch (GET_CODE (x)) - { - case SET: - print_value (pp, SET_DEST (x), verbose); - pp_equal (pp); - print_value (pp, SET_SRC (x), verbose); - break; - case RETURN: - case SIMPLE_RETURN: - case EH_RETURN: - pp_string (pp, GET_RTX_NAME (GET_CODE (x))); - break; - case CALL: - print_exp (pp, x, verbose); - break; - case CLOBBER: - case USE: - pp_printf (pp, "%s ", GET_RTX_NAME (GET_CODE (x))); - print_value (pp, XEXP (x, 0), verbose); - break; - case VAR_LOCATION: - pp_string (pp, "loc "); - print_value (pp, PAT_VAR_LOCATION_LOC (x), verbose); - break; - case COND_EXEC: - pp_left_paren (pp); - if (GET_CODE (COND_EXEC_TEST (x)) == NE - && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx) - print_value (pp, XEXP (COND_EXEC_TEST (x), 0), verbose); - else if (GET_CODE (COND_EXEC_TEST (x)) == EQ - && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx) - { - pp_exclamation (pp); - print_value (pp, XEXP (COND_EXEC_TEST (x), 0), verbose); - } - else - print_value (pp, COND_EXEC_TEST (x), verbose); - pp_string (pp, ") "); - print_pattern (pp, COND_EXEC_CODE (x), verbose); - break; - case PARALLEL: - { - int i; - - pp_left_brace (pp); - for (i = 0; i < XVECLEN (x, 0); i++) - { - print_pattern (pp, XVECEXP (x, 0, i), verbose); - pp_semicolon (pp); - } - pp_right_brace (pp); - } - break; - case SEQUENCE: - { - const rtx_sequence *seq = as_a (x); - pp_string (pp, "sequence{"); - if (INSN_P (seq->element (0))) - { - /* Print the sequence insns indented. */ - const char * save_print_rtx_head = print_rtx_head; - char indented_print_rtx_head[32]; - - pp_newline (pp); - gcc_assert (strlen (print_rtx_head) < sizeof (indented_print_rtx_head) - 4); - snprintf (indented_print_rtx_head, - sizeof (indented_print_rtx_head), - "%s ", print_rtx_head); - print_rtx_head = indented_print_rtx_head; - for (int i = 0; i < seq->len (); i++) - print_insn_with_notes (pp, seq->insn (i)); - pp_printf (pp, "%s ", save_print_rtx_head); - print_rtx_head = save_print_rtx_head; - } - else - { - for (int i = 0; i < seq->len (); i++) - { - print_pattern (pp, seq->element (i), verbose); - pp_semicolon (pp); - } - } - pp_right_brace (pp); - } - break; - case ASM_INPUT: - pp_printf (pp, "asm {%s}", XSTR (x, 0)); - break; - case ADDR_VEC: - for (int i = 0; i < XVECLEN (x, 0); i++) - { - print_value (pp, XVECEXP (x, 0, i), verbose); - pp_semicolon (pp); - } - break; - case ADDR_DIFF_VEC: - for (int i = 0; i < XVECLEN (x, 1); i++) - { - print_value (pp, XVECEXP (x, 1, i), verbose); - pp_semicolon (pp); - } - break; - case TRAP_IF: - 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 (pp, x, verbose); - } -} /* print_pattern */ - -/* This is the main function in slim rtl visualization mechanism. - - 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 - form). - - If VERBOSE is TRUE, insns are printed with more complete (but - longer) pattern names and with extra information, and prefixed - with their INSN_UIDs. */ - -void -print_insn (pretty_printer *pp, const rtx_insn *x, int verbose) -{ - 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 (pp, PATTERN (x), verbose); - break; - - case DEBUG_INSN: - { - const char *name = "?"; - - if (DECL_P (INSN_VAR_LOCATION_DECL (x))) - { - tree id = DECL_NAME (INSN_VAR_LOCATION_DECL (x)); - char idbuf[32]; - if (id) - name = IDENTIFIER_POINTER (id); - else if (TREE_CODE (INSN_VAR_LOCATION_DECL (x)) - == DEBUG_EXPR_DECL) - { - sprintf (idbuf, "D#%i", - DEBUG_TEMP_UID (INSN_VAR_LOCATION_DECL (x))); - name = idbuf; - } - else - { - sprintf (idbuf, "D.%i", - DECL_UID (INSN_VAR_LOCATION_DECL (x))); - name = idbuf; - } - } - pp_printf (pp, "debug %s => ", name); - if (VAR_LOC_UNKNOWN_P (INSN_VAR_LOCATION_LOC (x))) - pp_string (pp, "optimized away"); - else - print_pattern (pp, INSN_VAR_LOCATION_LOC (x), verbose); - } - break; - - case JUMP_INSN: - print_pattern (pp, PATTERN (x), verbose); - break; - case CALL_INSN: - if (GET_CODE (PATTERN (x)) == PARALLEL) - print_pattern (pp, XVECEXP (PATTERN (x), 0, 0), verbose); - else - print_pattern (pp, PATTERN (x), verbose); - break; - case CODE_LABEL: - pp_printf (pp, "L%d:", INSN_UID (x)); - break; - case JUMP_TABLE_DATA: - pp_string (pp, "jump_table_data{\n"); - print_pattern (pp, PATTERN (x), verbose); - pp_right_brace (pp); - break; - case 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: - pp_printf (pp, " %d", NOTE_EH_HANDLER (x)); - break; - - case NOTE_INSN_BLOCK_BEG: - case NOTE_INSN_BLOCK_END: - pp_printf (pp, " %d", BLOCK_NUMBER (NOTE_BLOCK (x))); - break; - - case NOTE_INSN_BASIC_BLOCK: - pp_printf (pp, " %d", NOTE_BASIC_BLOCK (x)->index); - break; - - case NOTE_INSN_DELETED_LABEL: - case NOTE_INSN_DELETED_DEBUG_LABEL: - { - const char *label = NOTE_DELETED_LABEL_NAME (x); - if (label == NULL) - label = ""; - pp_printf (pp, " (\"%s\")", label); - } - break; - - case NOTE_INSN_VAR_LOCATION: - case NOTE_INSN_CALL_ARG_LOCATION: - pp_left_brace (pp); - print_pattern (pp, NOTE_VAR_LOCATION (x), verbose); - pp_right_brace (pp); - break; - - default: - break; - } - break; - } - default: - gcc_unreachable (); - } -} /* print_insn */ - -/* Pretty-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_insn *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))); - if (GET_CODE (note) == INT_LIST) - pp_printf (pp, "%d", XINT (note, 0)); - else - print_pattern (pp, XEXP (note, 0), 1); - pp_newline (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 rtl_slim_pp; - rtl_slim_pp.buffer->stream = f; - print_value (&rtl_slim_pp, x, verbose); - pp_flush (&rtl_slim_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_insn *x) -{ - pretty_printer rtl_slim_pp; - rtl_slim_pp.buffer->stream = f; - print_insn_with_notes (&rtl_slim_pp, x); - pp_flush (&rtl_slim_pp); -} - -/* Same as above, but stop at LAST or when COUNT == 0. - If COUNT < 0 it will stop only at LAST or NULL rtx. */ - -void -dump_rtl_slim (FILE *f, const rtx_insn *first, const rtx_insn *last, - int count, int flags ATTRIBUTE_UNUSED) -{ - const rtx_insn *insn, *tail; - pretty_printer rtl_slim_pp; - rtl_slim_pp.buffer->stream = f; - - tail = last ? NEXT_INSN (last) : NULL; - for (insn = first; - (insn != NULL) && (insn != tail) && (count != 0); - insn = NEXT_INSN (insn)) - { - print_insn_with_notes (&rtl_slim_pp, insn); - if (count > 0) - count--; - } - - pp_flush (&rtl_slim_pp); -} - -/* Dumps basic block BB to pretty-printer PP in slim form and without and - no indentation, for use as a label of a DOT graph record-node. */ - -void -rtl_dump_bb_for_graph (pretty_printer *pp, basic_block bb) -{ - rtx_insn *insn; - bool first = true; - - /* TODO: inter-bb stuff. */ - FOR_BB_INSNS (bb, insn) - { - if (! first) - { - pp_bar (pp); - pp_write_text_to_stream (pp); - } - first = false; - print_insn_with_notes (pp, insn); - pp_write_text_as_dot_label_to_stream (pp, /*for_record=*/true); - } -} - -/* 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 rtl_slim_pp; - print_pattern (&rtl_slim_pp, x, 0); - return ggc_strdup (pp_formatted_text (&rtl_slim_pp)); -} - -/* Emit a slim dump of X (an insn) to stderr. */ -extern void debug_insn_slim (const rtx_insn *); -DEBUG_FUNCTION void -debug_insn_slim (const rtx_insn *x) -{ - dump_insn_slim (stderr, x); -} - -/* Same as above, but using dump_rtl_slim. */ -extern void debug_rtl_slim (FILE *, const rtx_insn *, const rtx_insn *, - int, int); -DEBUG_FUNCTION void -debug_rtl_slim (const rtx_insn *first, const rtx_insn *last, int count, - int flags) -{ - dump_rtl_slim (stderr, first, last, count, flags); -} - -extern void debug_bb_slim (basic_block); -DEBUG_FUNCTION void -debug_bb_slim (basic_block bb) -{ - dump_bb (stderr, bb, 0, TDF_SLIM | TDF_BLOCKS); -} - -extern void debug_bb_n_slim (int); -DEBUG_FUNCTION void -debug_bb_n_slim (int n) -{ - basic_block bb = BASIC_BLOCK_FOR_FN (cfun, n); - debug_bb_slim (bb); -} - diff --git a/gcc/sel-sched-dump.c b/gcc/sel-sched-dump.c index bc1cdad..e032086 100644 --- a/gcc/sel-sched-dump.c +++ b/gcc/sel-sched-dump.c @@ -40,6 +40,7 @@ along with GCC; see the file COPYING3. If not see #include "cfgloop.h" #include "sel-sched-ir.h" #include "sel-sched-dump.h" +#include "print-rtl.h" /* These variables control high-level pretty printing. */ -- 2.7.4