Annotation of gcc/print-rtl.c, revision 1.1.1.3

1.1       root        1: /* Print RTL for GNU C Compiler.
1.1.1.3 ! root        2:    Copyright (C) 1987-1991 Free Software Foundation, Inc.
1.1       root        3: 
                      4: This file is part of GNU CC.
                      5: 
                      6: GNU CC is free software; you can redistribute it and/or modify
                      7: it under the terms of the GNU General Public License as published by
                      8: the Free Software Foundation; either version 2, or (at your option)
                      9: any later version.
                     10: 
                     11: GNU CC is distributed in the hope that it will be useful,
                     12: but WITHOUT ANY WARRANTY; without even the implied warranty of
                     13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                     14: GNU General Public License for more details.
                     15: 
                     16: You should have received a copy of the GNU General Public License
                     17: along with GNU CC; see the file COPYING.  If not, write to
                     18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
                     19: 
                     20: 
                     21: #include "config.h"
                     22: #include <ctype.h>
                     23: #include <stdio.h>
                     24: #include "rtl.h"
                     25: 
                     26: 
1.1.1.3 ! root       27: /* How to print out a register name.
        !            28:    We don't use PRINT_REG because some definitions of PRINT_REG
        !            29:    don't work here.  */
        !            30: #ifndef DEBUG_PRINT_REG
        !            31: #define DEBUG_PRINT_REG(RTX, CODE, FILE) \
        !            32:   fprintf ((FILE), "%d %s", REGNO (RTX), reg_names[REGNO (RTX)])
        !            33: #endif
        !            34: 
        !            35: /* Array containing all of the register names */
        !            36: 
        !            37: #ifdef DEBUG_REGISTER_NAMES
        !            38: static char *reg_names[] = DEBUG_REGISTER_NAMES;
        !            39: #else
        !            40: static char *reg_names[] = REGISTER_NAMES;
        !            41: #endif
        !            42: 
1.1       root       43: static FILE *outfile;
                     44: 
                     45: char spaces[] = "                                                                                                                                                                ";
                     46: 
                     47: static int sawclose = 0;
                     48: 
                     49: /* Names for patterns.  Non-zero only when linked with insn-output.c.  */
                     50: 
                     51: extern char **insn_name_ptr;
                     52: 
                     53: /* Print IN_RTX onto OUTFILE.  This is the recursive part of printing.  */
                     54: 
                     55: static void
                     56: print_rtx (in_rtx)
                     57:      register rtx in_rtx;
                     58: {
                     59:   static int indent;
                     60:   register int i, j;
                     61:   register char *format_ptr;
                     62:   register int is_insn;
                     63: 
                     64:   if (sawclose)
                     65:     {
                     66:       fprintf (outfile, "\n%s",
1.1.1.3 ! root       67:               (spaces + (sizeof spaces - 1 - indent * 2)));
1.1       root       68:       sawclose = 0;
                     69:     }
                     70: 
                     71:   if (in_rtx == 0)
                     72:     {
                     73:       fprintf (outfile, "(nil)");
                     74:       sawclose = 1;
                     75:       return;
                     76:     }
                     77: 
                     78:   /* print name of expression code */
                     79:   fprintf (outfile, "(%s", GET_RTX_NAME (GET_CODE (in_rtx)));
                     80: 
                     81:   if (in_rtx->in_struct)
                     82:     fprintf (outfile, "/s");
                     83: 
                     84:   if (in_rtx->volatil)
                     85:     fprintf (outfile, "/v");
                     86: 
                     87:   if (in_rtx->unchanging)
                     88:     fprintf (outfile, "/u");
                     89: 
                     90:   if (in_rtx->integrated)
                     91:     fprintf (outfile, "/i");
                     92: 
                     93:   if (GET_MODE (in_rtx) != VOIDmode)
                     94:     {
                     95:       /* Print REG_NOTE names for EXPR_LIST and INSN_LIST.  */
                     96:       if (GET_CODE (in_rtx) == EXPR_LIST || GET_CODE (in_rtx) == INSN_LIST)
                     97:        fprintf (outfile, ":%s", GET_REG_NOTE_NAME (GET_MODE (in_rtx)));
                     98:       else
                     99:        fprintf (outfile, ":%s", GET_MODE_NAME (GET_MODE (in_rtx)));
                    100:     }
                    101: 
                    102:   is_insn = (GET_RTX_CLASS (GET_CODE (in_rtx)) == 'i');
                    103:   format_ptr = GET_RTX_FORMAT (GET_CODE (in_rtx));
                    104: 
                    105:   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (in_rtx)); i++)
                    106:     switch (*format_ptr++)
                    107:       {
                    108:       case 'S':
                    109:       case 's':
                    110:        if (XSTR (in_rtx, i) == 0)
                    111:          fprintf (outfile, " \"\"");
                    112:        else
                    113:          fprintf (outfile, " (\"%s\")", XSTR (in_rtx, i));
                    114:        sawclose = 1;
                    115:        break;
                    116: 
                    117:        /* 0 indicates a field for internal use that should not be printed.  */
                    118:       case '0':
                    119:        break;
                    120: 
                    121:       case 'e':
                    122:        indent += 2;
                    123:        if (!sawclose)
                    124:          fprintf (outfile, " ");
                    125:        print_rtx (XEXP (in_rtx, i));
                    126:        indent -= 2;
                    127:        break;
                    128: 
                    129:       case 'E':
                    130:       case 'V':
                    131:        indent += 2;
                    132:        if (sawclose)
                    133:          {
                    134:            fprintf (outfile, "\n%s",
1.1.1.3 ! root      135:                     (spaces + (sizeof spaces - 1 - indent * 2)));
1.1       root      136:            sawclose = 0;
                    137:          }
                    138:        fprintf (outfile, "[ ");
                    139:        if (NULL != XVEC (in_rtx, i))
                    140:          {
                    141:            indent += 2;
                    142:            if (XVECLEN (in_rtx, i))
                    143:              sawclose = 1;
                    144: 
                    145:            for (j = 0; j < XVECLEN (in_rtx, i); j++)
                    146:              print_rtx (XVECEXP (in_rtx, i, j));
                    147: 
                    148:            indent -= 2;
                    149:          }
                    150:        if (sawclose)
                    151:          fprintf (outfile, "\n%s",
1.1.1.3 ! root      152:                   (spaces + (sizeof spaces - 1 - indent * 2)));
1.1       root      153: 
                    154:        fprintf (outfile, "] ");
                    155:        sawclose = 1;
                    156:        indent -= 2;
                    157:        break;
                    158: 
1.1.1.3 ! root      159:       case 'w':
        !           160:        fprintf (outfile,
        !           161: #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
        !           162:                 " %d",
        !           163: #else
        !           164:                 " %ld",
        !           165: #endif
        !           166:                 XWINT (in_rtx, i));
        !           167:        break;
        !           168: 
1.1       root      169:       case 'i':
1.1.1.3 ! root      170:        {
        !           171:          register int value = XINT (in_rtx, i);
        !           172: 
        !           173:          if (GET_CODE (in_rtx) == REG && value < FIRST_PSEUDO_REGISTER)
        !           174:            {
        !           175:              fputc (' ', outfile);
        !           176:              DEBUG_PRINT_REG (in_rtx, 0, outfile);
        !           177:            }
        !           178:          else
        !           179:            fprintf (outfile, " %d", value);
        !           180:        }
1.1       root      181:        if (is_insn && &INSN_CODE (in_rtx) == &XINT (in_rtx, i)
                    182:            && insn_name_ptr
                    183:            && XINT (in_rtx, i) >= 0)
1.1.1.3 ! root      184:          fprintf (outfile, " {%s}", insn_name_ptr[XINT (in_rtx, i)]);
1.1       root      185:        sawclose = 0;
                    186:        break;
                    187: 
                    188:       /* Print NOTE_INSN names rather than integer codes.  */
                    189: 
                    190:       case 'n':
                    191:        if (XINT (in_rtx, i) <= 0)
                    192:          fprintf (outfile, " %s", GET_NOTE_INSN_NAME (XINT (in_rtx, i)));
                    193:        else
                    194:          fprintf (outfile, " %d", XINT (in_rtx, i));
                    195:        sawclose = 0;
                    196:        break;
                    197: 
                    198:       case 'u':
                    199:        if (XEXP (in_rtx, i) != NULL)
1.1.1.2   root      200:          fprintf (outfile, " %d", INSN_UID (XEXP (in_rtx, i)));
1.1       root      201:        else
1.1.1.2   root      202:          fprintf (outfile, " 0");
                    203:        sawclose = 0;
                    204:        break;
                    205: 
                    206:       case '*':
                    207:        fprintf (outfile, " Unknown");
1.1       root      208:        sawclose = 0;
                    209:        break;
                    210: 
                    211:       default:
                    212:        fprintf (stderr,
                    213:                 "switch format wrong in rtl.print_rtx(). format was: %c.\n",
                    214:                 format_ptr[-1]);
                    215:        abort ();
                    216:       }
                    217: 
                    218:   fprintf (outfile, ")");
                    219:   sawclose = 1;
                    220: }
                    221: 
                    222: /* Call this function from the debugger to see what X looks like.  */
                    223: 
                    224: void
                    225: debug_rtx (x)
                    226:      rtx x;
                    227: {
                    228:   outfile = stderr;
                    229:   print_rtx (x);
                    230:   fprintf (stderr, "\n");
                    231: }
                    232: 
                    233: /* External entry point for printing a chain of insns
                    234:    starting with RTX_FIRST onto file OUTF.
                    235:    A blank line separates insns.
                    236: 
                    237:    If RTX_FIRST is not an insn, then it alone is printed, with no newline.  */
                    238: 
                    239: void
                    240: print_rtl (outf, rtx_first)
                    241:      FILE *outf;
                    242:      rtx rtx_first;
                    243: {
                    244:   register rtx tmp_rtx;
                    245: 
                    246:   outfile = outf;
                    247:   sawclose = 0;
                    248: 
                    249:   if (rtx_first == 0)
                    250:     fprintf (outf, "(nil)\n");
                    251:   else
                    252:     switch (GET_CODE (rtx_first))
                    253:       {
                    254:       case INSN:
                    255:       case JUMP_INSN:
                    256:       case CALL_INSN:
                    257:       case NOTE:
                    258:       case CODE_LABEL:
                    259:       case BARRIER:
                    260:        for (tmp_rtx = rtx_first; NULL != tmp_rtx; tmp_rtx = NEXT_INSN (tmp_rtx))
                    261:          {
                    262:            print_rtx (tmp_rtx);
                    263:            fprintf (outfile, "\n");
                    264:          }
                    265:        break;
                    266: 
                    267:       default:
                    268:        print_rtx (rtx_first);
                    269:       }
                    270: }

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.