X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fprint-rtl.c;h=b46d1c6181bc4c18ffdbadb2bbdabd1160cb2b86;hb=821960c78df37188d9dc47e55e9d0d4d6eb3339b;hp=ef8a40204ae2eb388f20438356ee982e223407d8;hpb=bfee5366682048696e3c2a1f699ca043082c17eb;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/print-rtl.c b/gcc/print-rtl.c index ef8a40204ae..b46d1c6181b 100644 --- a/gcc/print-rtl.c +++ b/gcc/print-rtl.c @@ -1,33 +1,40 @@ -/* Print RTL for GNU C Compiler. - Copyright (C) 1987, 1988, 1992, 1997, 1998, 1999 +/* Print RTL for GCC. + Copyright (C) 1987, 1988, 1992, 1997, 1998, 1999, 2000, 2002, 2003 Free Software Foundation, Inc. -This file is part of GNU CC. +This file is part of GCC. -GNU CC 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 2, or (at your option) -any later version. +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 2, or (at your option) any later +version. -GNU CC 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. +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 GNU CC; see the file COPYING. If not, write to -the Free Software Foundation, 59 Temple Place - Suite 330, -Boston, MA 02111-1307, USA. */ +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. */ #include "config.h" #include "system.h" +#include "coretypes.h" +#include "tm.h" #include "rtl.h" + +/* We don't want the tree code checking code for the access to the + DECL_NAME to be included in the gen* programs. */ +#undef ENABLE_TREE_CHECKING +#include "tree.h" #include "real.h" #include "flags.h" +#include "hard-reg-set.h" #include "basic-block.h" - /* How to print out a register name. We don't use PRINT_REG because some definitions of PRINT_REG don't work here. */ @@ -39,44 +46,83 @@ Boston, MA 02111-1307, USA. */ /* Array containing all of the register names */ #ifdef DEBUG_REGISTER_NAMES -static const char * const reg_names[] = DEBUG_REGISTER_NAMES; +static const char * const debug_reg_names[] = DEBUG_REGISTER_NAMES; +#define reg_names debug_reg_names #else -static const char * const reg_names[] = REGISTER_NAMES; +const char * reg_names[] = REGISTER_NAMES; #endif static FILE *outfile; -static const char xspaces[] = " "; - static int sawclose = 0; static int indent; -static void print_rtx PROTO ((rtx)); +static void print_rtx (rtx); + +/* String printed at beginning of each RTL when it is dumped. + This string is set to ASM_COMMENT_START when the RTL is dumped in + the assembly output file. */ +const char *print_rtx_head = ""; /* Nonzero means suppress output of instruction numbers and line number notes in debugging dumps. This must be defined here so that programs like gencodes can be linked. */ int flag_dump_unnumbered = 0; +/* Nonzero means use simplified format without flags, modes, etc. */ +int flag_simple = 0; + /* Nonzero if we are dumping graphical description. */ int dump_for_graph; +/* Nonzero to dump all call_placeholder alternatives. */ +static int debug_call_placeholder_verbose; + +void +print_mem_expr (FILE *outfile, tree expr) +{ + if (TREE_CODE (expr) == COMPONENT_REF) + { + if (TREE_OPERAND (expr, 0)) + print_mem_expr (outfile, TREE_OPERAND (expr, 0)); + else + fputs (" ", outfile); + if (DECL_NAME (TREE_OPERAND (expr, 1))) + fprintf (outfile, ".%s", + IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (expr, 1)))); + } + else if (TREE_CODE (expr) == INDIRECT_REF) + { + fputs (" (*", outfile); + print_mem_expr (outfile, TREE_OPERAND (expr, 0)); + fputs (")", outfile); + } + else if (DECL_NAME (expr)) + fprintf (outfile, " %s", IDENTIFIER_POINTER (DECL_NAME (expr))); + else if (TREE_CODE (expr) == RESULT_DECL) + fputs (" ", outfile); + else + fputs (" ", outfile); +} + /* Print IN_RTX onto OUTFILE. This is the recursive part of printing. */ static void -print_rtx (in_rtx) - register rtx in_rtx; +print_rtx (rtx in_rtx) { - register int i = 0; - register int j; - register const char *format_ptr; - register int is_insn; + int i = 0; + int j; + const char *format_ptr; + int is_insn; + rtx tem; if (sawclose) { - fprintf (outfile, "\n%s", - (xspaces + (sizeof xspaces - 1 - indent * 2))); + if (flag_simple) + fputc (' ', outfile); + else + fprintf (outfile, "\n%s%*s", print_rtx_head, indent * 2, ""); sawclose = 0; } @@ -86,68 +132,99 @@ print_rtx (in_rtx) sawclose = 1; return; } + else if (GET_CODE (in_rtx) > NUM_RTX_CODE) + { + fprintf (outfile, "(??? bad code %d\n)", GET_CODE (in_rtx)); + sawclose = 1; + return; + } - is_insn = (GET_RTX_CLASS (GET_CODE (in_rtx)) == 'i'); + is_insn = INSN_P (in_rtx); /* When printing in VCG format we write INSNs, NOTE, LABEL, and BARRIER in separate nodes and therefore have to handle them special here. */ - if (dump_for_graph && - (is_insn || GET_CODE (in_rtx) == NOTE || GET_CODE (in_rtx) == CODE_LABEL - || GET_CODE (in_rtx) == BARRIER)) + if (dump_for_graph + && (is_insn || GET_CODE (in_rtx) == NOTE + || GET_CODE (in_rtx) == CODE_LABEL || GET_CODE (in_rtx) == BARRIER)) { i = 3; indent = 0; } else { - /* print name of expression code */ - fprintf (outfile, "(%s", GET_RTX_NAME (GET_CODE (in_rtx))); + /* Print name of expression code. */ + if (flag_simple && GET_CODE (in_rtx) == CONST_INT) + fputc ('(', outfile); + else + fprintf (outfile, "(%s", GET_RTX_NAME (GET_CODE (in_rtx))); - if (in_rtx->in_struct) - fputs ("/s", outfile); + if (! flag_simple) + { + if (RTX_FLAG (in_rtx, in_struct)) + fputs ("/s", outfile); - if (in_rtx->volatil) - fputs ("/v", outfile); + if (RTX_FLAG (in_rtx, volatil)) + fputs ("/v", outfile); - if (in_rtx->unchanging) - fputs ("/u", outfile); + if (RTX_FLAG (in_rtx, unchanging)) + fputs ("/u", outfile); - if (in_rtx->integrated) - fputs ("/i", outfile); + if (RTX_FLAG (in_rtx, integrated)) + fputs ("/i", outfile); - if (in_rtx->frame_related) - fputs ("/f", outfile); + if (RTX_FLAG (in_rtx, frame_related)) + fputs ("/f", outfile); - if (in_rtx->jump) - fputs ("/j", outfile); + if (RTX_FLAG (in_rtx, jump)) + fputs ("/j", outfile); - if (in_rtx->call) - fputs ("/c", outfile); + if (RTX_FLAG (in_rtx, call)) + fputs ("/c", outfile); - if (GET_MODE (in_rtx) != VOIDmode) - { - /* Print REG_NOTE names for EXPR_LIST and INSN_LIST. */ - if (GET_CODE (in_rtx) == EXPR_LIST || GET_CODE (in_rtx) == INSN_LIST) - fprintf (outfile, ":%s", GET_REG_NOTE_NAME (GET_MODE (in_rtx))); - else - fprintf (outfile, ":%s", GET_MODE_NAME (GET_MODE (in_rtx))); + if (GET_MODE (in_rtx) != VOIDmode) + { + /* Print REG_NOTE names for EXPR_LIST and INSN_LIST. */ + if (GET_CODE (in_rtx) == EXPR_LIST + || GET_CODE (in_rtx) == INSN_LIST) + fprintf (outfile, ":%s", + GET_REG_NOTE_NAME (GET_MODE (in_rtx))); + else + fprintf (outfile, ":%s", GET_MODE_NAME (GET_MODE (in_rtx))); + } } } +#ifndef GENERATOR_FILE + if (GET_CODE (in_rtx) == CONST_DOUBLE && FLOAT_MODE_P (GET_MODE (in_rtx))) + i = 5; +#endif + /* Get the format string and skip the first elements if we have handled them already. */ format_ptr = GET_RTX_FORMAT (GET_CODE (in_rtx)) + i; - for (; i < GET_RTX_LENGTH (GET_CODE (in_rtx)); i++) switch (*format_ptr++) { + const char *str; + + case 'T': + str = XTMPL (in_rtx, i); + goto string; + case 'S': case 's': - if (XSTR (in_rtx, i) == 0) + str = XSTR (in_rtx, i); + string: + + if (str == 0) fputs (dump_for_graph ? " \\\"\\\"" : " \"\"", outfile); else - fprintf (outfile, dump_for_graph ? " (\\\"%s\\\")" : " (\"%s\")", - XSTR (in_rtx, i)); + { + if (dump_for_graph) + fprintf (outfile, " (\\\"%s\\\")", str); + else + fprintf (outfile, " (\"%s\")", str); + } sawclose = 1; break; @@ -155,46 +232,98 @@ print_rtx (in_rtx) An exception is the third field of a NOTE, where it indicates that the field has several different valid contents. */ case '0': - if (i == 3 && GET_CODE (in_rtx) == NOTE) + if (i == 1 && GET_CODE (in_rtx) == REG) + { + if (REGNO (in_rtx) != ORIGINAL_REGNO (in_rtx)) + fprintf (outfile, " [%d]", ORIGINAL_REGNO (in_rtx)); + } +#ifndef GENERATOR_FILE + else if (i == 1 && GET_CODE (in_rtx) == SYMBOL_REF) { - if (NOTE_LINE_NUMBER (in_rtx) == NOTE_INSN_EH_REGION_BEG - || NOTE_LINE_NUMBER (in_rtx) == NOTE_INSN_EH_REGION_END) + int flags = SYMBOL_REF_FLAGS (in_rtx); + if (flags) + fprintf (outfile, " [flags 0x%x]", flags); + } + else if (i == 2 && GET_CODE (in_rtx) == SYMBOL_REF) + { + tree decl = SYMBOL_REF_DECL (in_rtx); + if (decl) + print_node_brief (outfile, "", decl, 0); + } +#endif + else if (i == 4 && GET_CODE (in_rtx) == NOTE) + { + switch (NOTE_LINE_NUMBER (in_rtx)) { - fprintf (outfile, " %d", NOTE_EH_HANDLER (in_rtx)); + case NOTE_INSN_EH_REGION_BEG: + case NOTE_INSN_EH_REGION_END: + if (flag_dump_unnumbered) + fprintf (outfile, " #"); + else + fprintf (outfile, " %d", NOTE_EH_HANDLER (in_rtx)); sawclose = 1; - } - else if (NOTE_LINE_NUMBER (in_rtx) == NOTE_INSN_BLOCK_BEG - || NOTE_LINE_NUMBER (in_rtx) == NOTE_INSN_BLOCK_END) - { + break; + + case NOTE_INSN_BLOCK_BEG: + case NOTE_INSN_BLOCK_END: fprintf (outfile, " "); - fprintf (outfile, HOST_PTR_PRINTF, - (char *) NOTE_BLOCK (in_rtx)); + if (flag_dump_unnumbered) + fprintf (outfile, "#"); + else + fprintf (outfile, HOST_PTR_PRINTF, + (char *) NOTE_BLOCK (in_rtx)); sawclose = 1; - } - else if (NOTE_LINE_NUMBER (in_rtx) == NOTE_INSN_RANGE_START - || NOTE_LINE_NUMBER (in_rtx) == NOTE_INSN_RANGE_END - || NOTE_LINE_NUMBER (in_rtx) == NOTE_INSN_LIVE) - { + break; + + case NOTE_INSN_BASIC_BLOCK: + { + basic_block bb = NOTE_BASIC_BLOCK (in_rtx); + if (bb != 0) + fprintf (outfile, " [bb %d]", bb->index); + break; + } + + case NOTE_INSN_EXPECTED_VALUE: indent += 2; if (!sawclose) fprintf (outfile, " "); - print_rtx (NOTE_RANGE_INFO (in_rtx)); + print_rtx (NOTE_EXPECTED_VALUE (in_rtx)); indent -= 2; - } - else if (NOTE_LINE_NUMBER (in_rtx) == NOTE_INSN_BASIC_BLOCK) - { - basic_block bb = NOTE_BASIC_BLOCK (in_rtx); - fprintf (outfile, " [bb %d]", bb->index); - } - else - { - char *str = X0STR (in_rtx, i); - if (str == 0) - fputs (dump_for_graph ? " \\\"\\\"" : " \"\"", outfile); + break; + + case NOTE_INSN_DELETED_LABEL: + if (NOTE_SOURCE_FILE (in_rtx)) + fprintf (outfile, " (\"%s\")", NOTE_SOURCE_FILE (in_rtx)); else - fprintf (outfile, - dump_for_graph ? " (\\\"%s\\\")" : " (\"%s\")", - str); + fprintf (outfile, " \"\""); + break; + + case NOTE_INSN_PREDICTION: + if (NOTE_PREDICTION (in_rtx)) + fprintf (outfile, " [ %d %d ] ", + (int)NOTE_PREDICTION_ALG (in_rtx), + (int) NOTE_PREDICTION_FLAGS (in_rtx)); + else + fprintf (outfile, " [ ERROR ]"); + break; + + default: + { + const char * const str = X0STR (in_rtx, i); + + if (NOTE_LINE_NUMBER (in_rtx) < 0) + ; + else if (str == 0) + fputs (dump_for_graph ? " \\\"\\\"" : " \"\"", outfile); + else + { + if (dump_for_graph) + fprintf (outfile, " (\\\"%s\\\")", str); + else + fprintf (outfile, " (\"%s\")", str); + } + break; + } } } break; @@ -213,11 +342,11 @@ print_rtx (in_rtx) indent += 2; if (sawclose) { - fprintf (outfile, "\n%s", - (xspaces + (sizeof xspaces - 1 - indent * 2))); + fprintf (outfile, "\n%s%*s", + print_rtx_head, indent * 2, ""); sawclose = 0; } - fputs ("[ ", outfile); + fputs (" [", outfile); if (NULL != XVEC (in_rtx, i)) { indent += 2; @@ -230,66 +359,100 @@ print_rtx (in_rtx) indent -= 2; } if (sawclose) - fprintf (outfile, "\n%s", - (xspaces + (sizeof xspaces - 1 - indent * 2))); + fprintf (outfile, "\n%s%*s", print_rtx_head, indent * 2, ""); - fputs ("] ", outfile); + fputs ("]", outfile); sawclose = 1; indent -= 2; break; case 'w': - fprintf (outfile, " "); + if (! flag_simple) + fprintf (outfile, " "); fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, XWINT (in_rtx, i)); - fprintf (outfile, " ["); - fprintf (outfile, HOST_WIDE_INT_PRINT_HEX, XWINT (in_rtx, i)); - fprintf (outfile, "]"); + if (! flag_simple) + fprintf (outfile, " [" HOST_WIDE_INT_PRINT_HEX "]", + XWINT (in_rtx, i)); break; case 'i': - { - register int value = XINT (in_rtx, i); - const char *name; + if (i == 4 && INSN_P (in_rtx)) + { +#ifndef GENERATOR_FILE + /* Pretty-print insn locators. Ignore scoping as it is mostly + redundant with line number information and do not print anything + when there is no location information available. */ + if (INSN_LOCATOR (in_rtx) && insn_file (in_rtx)) + fprintf(outfile, " %s:%i", insn_file (in_rtx), insn_line (in_rtx)); +#endif + } + else if (i == 6 && GET_CODE (in_rtx) == NOTE) + { + /* This field is only used for NOTE_INSN_DELETED_LABEL, and + other times often contains garbage from INSN->NOTE death. */ + if (NOTE_LINE_NUMBER (in_rtx) == NOTE_INSN_DELETED_LABEL) + fprintf (outfile, " %d", XINT (in_rtx, i)); + } + else + { + int value = XINT (in_rtx, i); + const char *name; - if (GET_CODE (in_rtx) == REG && value < FIRST_PSEUDO_REGISTER) - { - fputc (' ', outfile); - DEBUG_PRINT_REG (in_rtx, 0, outfile); - } - else if (GET_CODE (in_rtx) == REG && value <= LAST_VIRTUAL_REGISTER) - { - if (value == VIRTUAL_INCOMING_ARGS_REGNUM) - fprintf (outfile, " %d virtual-incoming-args", value); - else if (value == VIRTUAL_STACK_VARS_REGNUM) - fprintf (outfile, " %d virtual-stack-vars", value); - else if (value == VIRTUAL_STACK_DYNAMIC_REGNUM) - fprintf (outfile, " %d virtual-stack-dynamic", value); - else if (value == VIRTUAL_OUTGOING_ARGS_REGNUM) - fprintf (outfile, " %d virtual-outgoing-args", value); - else if (value == VIRTUAL_CFA_REGNUM) - fprintf (outfile, " %d virtual-cfa", value); - else - fprintf (outfile, " %d virtual-reg-%d", value, - value-FIRST_VIRTUAL_REGISTER); - } - else if (flag_dump_unnumbered - && (is_insn || GET_CODE (in_rtx) == NOTE)) - fputc ('#', outfile); - else - fprintf (outfile, " %d", value); - - if (is_insn && &INSN_CODE (in_rtx) == &XINT (in_rtx, i) - && XINT (in_rtx, i) >= 0 - && (name = get_insn_name (XINT (in_rtx, i))) != NULL) - fprintf (outfile, " {%s}", name); - sawclose = 0; - } + if (GET_CODE (in_rtx) == REG && value < FIRST_PSEUDO_REGISTER) + { + fputc (' ', outfile); + DEBUG_PRINT_REG (in_rtx, 0, outfile); + } + else if (GET_CODE (in_rtx) == REG + && value <= LAST_VIRTUAL_REGISTER) + { + if (value == VIRTUAL_INCOMING_ARGS_REGNUM) + fprintf (outfile, " %d virtual-incoming-args", value); + else if (value == VIRTUAL_STACK_VARS_REGNUM) + fprintf (outfile, " %d virtual-stack-vars", value); + else if (value == VIRTUAL_STACK_DYNAMIC_REGNUM) + fprintf (outfile, " %d virtual-stack-dynamic", value); + else if (value == VIRTUAL_OUTGOING_ARGS_REGNUM) + fprintf (outfile, " %d virtual-outgoing-args", value); + else if (value == VIRTUAL_CFA_REGNUM) + fprintf (outfile, " %d virtual-cfa", value); + else + fprintf (outfile, " %d virtual-reg-%d", value, + value-FIRST_VIRTUAL_REGISTER); + } + else if (flag_dump_unnumbered + && (is_insn || GET_CODE (in_rtx) == NOTE)) + fputc ('#', outfile); + else + fprintf (outfile, " %d", value); + + if (GET_CODE (in_rtx) == REG && REG_ATTRS (in_rtx)) + { + fputs (" [", outfile); + if (ORIGINAL_REGNO (in_rtx) != REGNO (in_rtx)) + fprintf (outfile, "orig:%i", ORIGINAL_REGNO (in_rtx)); + if (REG_EXPR (in_rtx)) + print_mem_expr (outfile, REG_EXPR (in_rtx)); + + if (REG_OFFSET (in_rtx)) + fprintf (outfile, "+" HOST_WIDE_INT_PRINT_DEC, + REG_OFFSET (in_rtx)); + fputs (" ]", outfile); + } + + if (is_insn && &INSN_CODE (in_rtx) == &XINT (in_rtx, i) + && XINT (in_rtx, i) >= 0 + && (name = get_insn_name (XINT (in_rtx, i))) != NULL) + fprintf (outfile, " {%s}", name); + sawclose = 0; + } break; /* Print NOTE_INSN names rather than integer codes. */ case 'n': - if (XINT (in_rtx, i) <= 0) + if (XINT (in_rtx, i) >= (int) NOTE_INSN_BIAS + && XINT (in_rtx, i) < (int) NOTE_INSN_MAX) fprintf (outfile, " %s", GET_NOTE_INSN_NAME (XINT (in_rtx, i))); else fprintf (outfile, " %d", XINT (in_rtx, i)); @@ -302,12 +465,25 @@ print_rtx (in_rtx) rtx sub = XEXP (in_rtx, i); enum rtx_code subc = GET_CODE (sub); - if (GET_CODE (in_rtx) == LABEL_REF - && subc != CODE_LABEL) - goto do_e; + if (GET_CODE (in_rtx) == LABEL_REF) + { + if (subc == NOTE + && NOTE_LINE_NUMBER (sub) == NOTE_INSN_DELETED_LABEL) + { + if (flag_dump_unnumbered) + fprintf (outfile, " [# deleted]"); + else + fprintf (outfile, " [%d deleted]", INSN_UID (sub)); + sawclose = 0; + break; + } + + if (subc != CODE_LABEL) + goto do_e; + } if (flag_dump_unnumbered) - fputc ('#', outfile); + fputs (" #", outfile); else fprintf (outfile, " %d", INSN_UID (sub)); } @@ -325,8 +501,7 @@ print_rtx (in_rtx) break; case 't': - putc (' ', outfile); - fprintf (outfile, HOST_PTR_PRINTF, (char *) XTREE (in_rtx, i)); + fprintf (outfile, " " HOST_PTR_PRINTF, (void *) XTREE (in_rtx, i)); break; case '*': @@ -334,6 +509,11 @@ print_rtx (in_rtx) sawclose = 0; break; + case 'B': + if (XBBDEF (in_rtx, i)) + fprintf (outfile, " %i", XBBDEF (in_rtx, i)->index); + break; + default: fprintf (stderr, "switch format wrong in rtl.print_rtx(). format was: %c.\n", @@ -341,25 +521,104 @@ print_rtx (in_rtx) abort (); } - if (GET_CODE (in_rtx) == MEM) - fprintf (outfile, " %d", MEM_ALIAS_SET (in_rtx)); - -#if HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT && LONG_DOUBLE_TYPE_SIZE == 64 - if (GET_CODE (in_rtx) == CONST_DOUBLE && FLOAT_MODE_P (GET_MODE (in_rtx))) + switch (GET_CODE (in_rtx)) { - double val; - REAL_VALUE_FROM_CONST_DOUBLE (val, in_rtx); - fprintf (outfile, " [%.16g]", val); - } +#ifndef GENERATOR_FILE + case MEM: + fprintf (outfile, " [" HOST_WIDE_INT_PRINT_DEC, MEM_ALIAS_SET (in_rtx)); + + if (MEM_EXPR (in_rtx)) + print_mem_expr (outfile, MEM_EXPR (in_rtx)); + + if (MEM_OFFSET (in_rtx)) + fprintf (outfile, "+" HOST_WIDE_INT_PRINT_DEC, + INTVAL (MEM_OFFSET (in_rtx))); + + if (MEM_SIZE (in_rtx)) + fprintf (outfile, " S" HOST_WIDE_INT_PRINT_DEC, + INTVAL (MEM_SIZE (in_rtx))); + + if (MEM_ALIGN (in_rtx) != 1) + fprintf (outfile, " A%u", MEM_ALIGN (in_rtx)); + + fputc (']', outfile); + break; + + case CONST_DOUBLE: + if (FLOAT_MODE_P (GET_MODE (in_rtx))) + { + char s[60]; + + real_to_decimal (s, CONST_DOUBLE_REAL_VALUE (in_rtx), + sizeof (s), 0, 1); + fprintf (outfile, " %s", s); + + real_to_hexadecimal (s, CONST_DOUBLE_REAL_VALUE (in_rtx), + sizeof (s), 0, 1); + fprintf (outfile, " [%s]", s); + } + break; #endif - if (GET_CODE (in_rtx) == CODE_LABEL) - { - fprintf (outfile, " [num uses: %d]", LABEL_NUSES (in_rtx)); - if (LABEL_ALTERNATE_NAME (in_rtx)) - fprintf (outfile, " [alternate name: %s]", LABEL_ALTERNATE_NAME (in_rtx)); + case CODE_LABEL: + fprintf (outfile, " [%d uses]", LABEL_NUSES (in_rtx)); + switch (LABEL_KIND (in_rtx)) + { + case LABEL_NORMAL: break; + case LABEL_STATIC_ENTRY: fputs (" [entry]", outfile); break; + case LABEL_GLOBAL_ENTRY: fputs (" [global entry]", outfile); break; + case LABEL_WEAK_ENTRY: fputs (" [weak entry]", outfile); break; + default: abort(); + } + break; + + case CALL_PLACEHOLDER: + if (debug_call_placeholder_verbose) + { + fputs (" (cond [\n (const_string \"normal\") (sequence [", outfile); + for (tem = XEXP (in_rtx, 0); tem != 0; tem = NEXT_INSN (tem)) + { + fputs ("\n ", outfile); + print_inline_rtx (outfile, tem, 4); + } + + tem = XEXP (in_rtx, 1); + if (tem) + fputs ("\n ])\n (const_string \"tail_call\") (sequence [", + outfile); + for (; tem != 0; tem = NEXT_INSN (tem)) + { + fputs ("\n ", outfile); + print_inline_rtx (outfile, tem, 4); + } + + tem = XEXP (in_rtx, 2); + if (tem) + fputs ("\n ])\n (const_string \"tail_recursion\") (sequence [", + outfile); + for (; tem != 0; tem = NEXT_INSN (tem)) + { + fputs ("\n ", outfile); + print_inline_rtx (outfile, tem, 4); + } + + fputs ("\n ])\n ])", outfile); + break; + } + + for (tem = XEXP (in_rtx, 0); tem != 0; tem = NEXT_INSN (tem)) + if (GET_CODE (tem) == CALL_INSN) + { + fprintf (outfile, " "); + print_rtx (tem); + break; + } + break; + + default: + break; } - + if (dump_for_graph && (is_insn || GET_CODE (in_rtx) == NOTE || GET_CODE (in_rtx) == CODE_LABEL || GET_CODE (in_rtx) == BARRIER)) @@ -375,10 +634,7 @@ print_rtx (in_rtx) characters. */ void -print_inline_rtx (outf, x, ind) - FILE *outf; - rtx x; - int ind; +print_inline_rtx (FILE *outf, rtx x, int ind) { int oldsaw = sawclose; int oldindent = indent; @@ -394,10 +650,10 @@ print_inline_rtx (outf, x, ind) /* Call this function from the debugger to see what X looks like. */ void -debug_rtx (x) - rtx x; +debug_rtx (rtx x) { outfile = stderr; + sawclose = 0; print_rtx (x); fprintf (stderr, "\n"); } @@ -414,9 +670,7 @@ int debug_rtx_count = 0; /* 0 is treated as equivalent to 1 */ EG: -5 prints 2 rtx's on either side (in addition to the specified rtx). */ void -debug_rtx_list (x, n) - rtx x; - int n; +debug_rtx_list (rtx x, int n) { int i,count; rtx insn; @@ -434,7 +688,25 @@ debug_rtx_list (x, n) } for (i = count, insn = x; i > 0 && insn != 0; i--, insn = NEXT_INSN (insn)) - debug_rtx (insn); + { + debug_rtx (insn); + fprintf (stderr, "\n"); + } +} + +/* Call this function to print an rtx list from START to END inclusive. */ + +void +debug_rtx_range (rtx start, rtx end) +{ + while (1) + { + debug_rtx (start); + fprintf (stderr, "\n"); + if (!start || start == end) + break; + start = NEXT_INSN (start); + } } /* Call this function to search an rtx list to find one with insn uid UID, @@ -442,9 +714,7 @@ debug_rtx_list (x, n) The found insn is returned to enable further debugging analysis. */ rtx -debug_rtx_find (x, uid) - rtx x; - int uid; +debug_rtx_find (rtx x, int uid) { while (x != 0 && INSN_UID (x) != uid) x = NEXT_INSN (x); @@ -467,17 +737,18 @@ debug_rtx_find (x, uid) If RTX_FIRST is not an insn, then it alone is printed, with no newline. */ void -print_rtl (outf, rtx_first) - FILE *outf; - rtx rtx_first; +print_rtl (FILE *outf, rtx rtx_first) { - register rtx tmp_rtx; + rtx tmp_rtx; outfile = outf; sawclose = 0; if (rtx_first == 0) - fputs ("(nil)\n", outf); + { + fputs (print_rtx_head, outf); + fputs ("(nil)\n", outf); + } else switch (GET_CODE (rtx_first)) { @@ -487,19 +758,18 @@ print_rtl (outf, rtx_first) case NOTE: case CODE_LABEL: case BARRIER: - for (tmp_rtx = rtx_first; NULL != tmp_rtx; tmp_rtx = NEXT_INSN (tmp_rtx)) - { - if (! flag_dump_unnumbered - || GET_CODE (tmp_rtx) != NOTE - || NOTE_LINE_NUMBER (tmp_rtx) < 0) - { - print_rtx (tmp_rtx); - fprintf (outfile, "\n"); - } - } + for (tmp_rtx = rtx_first; tmp_rtx != 0; tmp_rtx = NEXT_INSN (tmp_rtx)) + if (! flag_dump_unnumbered + || GET_CODE (tmp_rtx) != NOTE || NOTE_LINE_NUMBER (tmp_rtx) < 0) + { + fputs (print_rtx_head, outfile); + print_rtx (tmp_rtx); + fprintf (outfile, "\n"); + } break; default: + fputs (print_rtx_head, outfile); print_rtx (rtx_first); } } @@ -508,18 +778,29 @@ print_rtl (outf, rtx_first) /* Return nonzero if we actually printed anything. */ int -print_rtl_single (outf, x) - FILE *outf; - rtx x; +print_rtl_single (FILE *outf, rtx x) { outfile = outf; sawclose = 0; if (! flag_dump_unnumbered || GET_CODE (x) != NOTE || NOTE_LINE_NUMBER (x) < 0) { + fputs (print_rtx_head, outfile); print_rtx (x); putc ('\n', outf); return 1; } return 0; } + + +/* Like print_rtl except without all the detail; for example, + if RTX is a CONST_INT then print in decimal format. */ + +void +print_simple_rtl (FILE *outf, rtx x) +{ + flag_simple = 1; + print_rtl (outf, x); + flag_simple = 0; +}