Return to print-tree.c CVS log

Up to [Apple XNU] / GNUtools / cc

Annotation of GNUtools/cc/print-tree.c, revision 1.1

1.1     ! root        1: /* Prints out tree in human readable form - GNU C-compiler
        !             2:    Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc.
        !             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 "tree.h"
        !            23: #include <stdio.h>
        !            24: 
        !            25: extern char **tree_code_name;
        !            26: 
        !            27: extern char *mode_name[];
        !            28: 
        !            29: void print_node ();
        !            30: void indent_to ();
        !            31: 
        !            32: /* Define the hash table of nodes already seen.
        !            33:    Such nodes are not repeated; brief cross-references are used.  */
        !            34: 
        !            35: #define HASH_SIZE 37
        !            36: 
        !            37: struct bucket
        !            38: {
        !            39:   tree node;
        !            40:   struct bucket *next;
        !            41: };
        !            42: 
        !            43: static struct bucket **table;
        !            44: 
        !            45: /* Print the node NODE on standard error, for debugging.
        !            46:    Most nodes referred to by this one are printed recursively
        !            47:    down to a depth of six.  */
        !            48: 
        !            49: void
        !            50: debug_tree (node)
        !            51:      tree node;
        !            52: {
        !            53:   char *object = (char *) oballoc (0);
        !            54:   table = (struct bucket **) oballoc (HASH_SIZE * sizeof (struct bucket *));
        !            55:   bzero (table, HASH_SIZE * sizeof (struct bucket *));
        !            56:   print_node (stderr, "", node, 0);
        !            57:   table = 0;
        !            58:   obfree (object);
        !            59:   fprintf (stderr, "\n");
        !            60: }
        !            61: 
        !            62: /* Print a node in brief fashion, with just the code, address and name.  */
        !            63: 
        !            64: void
        !            65: print_node_brief (file, prefix, node, indent)
        !            66:      FILE *file;
        !            67:      char *prefix;
        !            68:      tree node;
        !            69:      int indent;
        !            70: {
        !            71:   char class;
        !            72: 
        !            73:   if (node == 0)
        !            74:     return;
        !            75: 
        !            76:   class = TREE_CODE_CLASS (TREE_CODE (node));
        !            77: 
        !            78:   /* Always print the slot this node is in, and its code, address and
        !            79:      name if any.  */
        !            80:   if (indent > 0)
        !            81:     fprintf (file, " ");
        !            82:   fprintf (file, "%s <%s ", prefix, tree_code_name[(int) TREE_CODE (node)]);
        !            83:   fprintf (file, HOST_PTR_PRINTF, (HOST_WIDE_INT) node);
        !            84: 
        !            85:   if (class == 'd')
        !            86:     {
        !            87:       if (DECL_NAME (node))
        !            88:        fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
        !            89:     }
        !            90:   else if (class == 't')
        !            91:     {
        !            92:       if (TYPE_NAME (node))
        !            93:        {
        !            94:          if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
        !            95:            fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node)));
        !            96:          else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
        !            97:                   && DECL_NAME (TYPE_NAME (node)))
        !            98:            fprintf (file, " %s",
        !            99:                     IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node))));
        !           100:        }
        !           101:     }
        !           102:   if (TREE_CODE (node) == IDENTIFIER_NODE)
        !           103:     fprintf (file, " %s", IDENTIFIER_POINTER (node));
        !           104:   /* We might as well always print the value of an integer.  */
        !           105:   if (TREE_CODE (node) == INTEGER_CST)
        !           106:     {
        !           107:       if (TREE_INT_CST_HIGH (node) == 0)
        !           108:        fprintf (file, " %1u", TREE_INT_CST_LOW (node));
        !           109:       else if (TREE_INT_CST_HIGH (node) == -1
        !           110:               && TREE_INT_CST_LOW (node) != 0)
        !           111:        fprintf (file, " -%1u", -TREE_INT_CST_LOW (node));
        !           112:       else
        !           113:        fprintf (file,
        !           114: #if HOST_BITS_PER_WIDE_INT == 64
        !           115: #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
        !           116:                 " 0x%lx%016lx",
        !           117: #else
        !           118:                 " 0x%x%016x",
        !           119: #endif
        !           120: #else
        !           121: #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
        !           122:                 " 0x%lx%08lx",
        !           123: #else
        !           124:                 " 0x%x%08x",
        !           125: #endif
        !           126: #endif
        !           127:                 TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
        !           128:     }
        !           129:   if (TREE_CODE (node) == REAL_CST)
        !           130:     {
        !           131: #ifndef REAL_IS_NOT_DOUBLE
        !           132:       fprintf (file, " %e", TREE_REAL_CST (node));
        !           133: #else
        !           134:       {
        !           135:        int i;
        !           136:        unsigned char *p = (unsigned char *) &TREE_REAL_CST (node);
        !           137:        fprintf (file, " 0x");
        !           138:        for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
        !           139:          fprintf (file, "%02x", *p++);
        !           140:        fprintf (file, "");
        !           141:       }
        !           142: #endif /* REAL_IS_NOT_DOUBLE */
        !           143:     }
        !           144: 
        !           145:   fprintf (file, ">");
        !           146: }
        !           147: 
        !           148: void
        !           149: indent_to (file, column)
        !           150:      FILE *file;
        !           151:      int column;
        !           152: {
        !           153:   int i;
        !           154: 
        !           155:   /* Since this is the long way, indent to desired column.  */
        !           156:   if (column > 0)
        !           157:     fprintf (file, "\n");
        !           158:   for (i = 0; i < column; i++)
        !           159:     fprintf (file, " ");
        !           160: }
        !           161: 
        !           162: /* Print the node NODE in full on file FILE, preceded by PREFIX,
        !           163:    starting in column INDENT.  */
        !           164: 
        !           165: void
        !           166: print_node (file, prefix, node, indent)
        !           167:      FILE *file;
        !           168:      char *prefix;
        !           169:      tree node;
        !           170:      int indent;
        !           171: {
        !           172:   int hash;
        !           173:   struct bucket *b;
        !           174:   enum machine_mode mode;
        !           175:   char class;
        !           176:   int len;
        !           177:   int first_rtl;
        !           178:   int i;
        !           179: 
        !           180:   if (node == 0)
        !           181:     return;
        !           182: 
        !           183:   class = TREE_CODE_CLASS (TREE_CODE (node));
        !           184: 
        !           185:   /* Don't get too deep in nesting.  If the user wants to see deeper,
        !           186:      it is easy to use the address of a lowest-level node
        !           187:      as an argument in another call to debug_tree.  */
        !           188: 
        !           189:   if (indent > 24)
        !           190:     {
        !           191:       print_node_brief (file, prefix, node, indent);
        !           192:       return;
        !           193:     }
        !           194: 
        !           195:   if (indent > 8 && (class == 't' || class == 'd'))
        !           196:     {
        !           197:       print_node_brief (file, prefix, node, indent);
        !           198:       return;
        !           199:     }
        !           200: 
        !           201:   /* It is unsafe to look at any other filds of an ERROR_MARK node. */
        !           202:   if (TREE_CODE (node) == ERROR_MARK)
        !           203:     {
        !           204:       print_node_brief (file, prefix, node, indent);
        !           205:       return;
        !           206:     }
        !           207: 
        !           208:   hash = ((unsigned HOST_WIDE_INT) node) % HASH_SIZE;
        !           209: 
        !           210:   /* If node is in the table, just mention its address.  */
        !           211:   for (b = table[hash]; b; b = b->next)
        !           212:     if (b->node == node)
        !           213:       {
        !           214:        print_node_brief (file, prefix, node, indent);
        !           215:        return;
        !           216:       }
        !           217: 
        !           218:   /* Add this node to the table.  */
        !           219:   b = (struct bucket *) oballoc (sizeof (struct bucket));
        !           220:   b->node = node;
        !           221:   b->next = table[hash];
        !           222:   table[hash] = b;
        !           223: 
        !           224:   /* Indent to the specified column, since this is the long form.  */
        !           225:   indent_to (file, indent);
        !           226: 
        !           227:   /* Print the slot this node is in, and its code, and address.  */
        !           228:   fprintf (file, "%s <%s ", prefix, tree_code_name[(int) TREE_CODE (node)]);
        !           229:   fprintf (file, HOST_PTR_PRINTF, (HOST_WIDE_INT) node);
        !           230: 
        !           231:   /* Print the name, if any.  */
        !           232:   if (class == 'd')
        !           233:     {
        !           234:       if (DECL_NAME (node))
        !           235:        fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
        !           236:     }
        !           237:   else if (class == 't')
        !           238:     {
        !           239:       if (TYPE_NAME (node))
        !           240:        {
        !           241:          if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
        !           242:            fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node)));
        !           243:          else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
        !           244:                   && DECL_NAME (TYPE_NAME (node)))
        !           245:            fprintf (file, " %s",
        !           246:                     IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node))));
        !           247:        }
        !           248:     }
        !           249:   if (TREE_CODE (node) == IDENTIFIER_NODE)
        !           250:     fprintf (file, " %s", IDENTIFIER_POINTER (node));
        !           251: 
        !           252:   if (TREE_CODE (node) == INTEGER_CST)
        !           253:     {
        !           254:       if (indent <= 4)
        !           255:        print_node_brief (file, "type", TREE_TYPE (node), indent + 4);
        !           256:     }
        !           257:   else
        !           258:     {
        !           259:       print_node (file, "type", TREE_TYPE (node), indent + 4);
        !           260:       if (TREE_TYPE (node))
        !           261:        indent_to (file, indent + 3);
        !           262: 
        !           263:       print_obstack_name ((char *) node, file, "");
        !           264:       indent_to (file, indent + 3);
        !           265:     }
        !           266: 
        !           267:   /* If a permanent object is in the wrong obstack, or the reverse, warn.  */
        !           268:   if (object_permanent_p (node) != TREE_PERMANENT (node))
        !           269:     {
        !           270:       if (TREE_PERMANENT (node))
        !           271:        fputs (" !!permanent object in non-permanent obstack!!", file);
        !           272:       else
        !           273:        fputs (" !!non-permanent object in permanent obstack!!", file);
        !           274:       indent_to (file, indent + 3);
        !           275:     }
        !           276: 
        !           277:   if (TREE_SIDE_EFFECTS (node))
        !           278:     fputs (" side-effects", file);
        !           279:   if (TREE_READONLY (node))
        !           280:     fputs (" readonly", file);
        !           281:   if (TREE_CONSTANT (node))
        !           282:     fputs (" constant", file);
        !           283:   if (TREE_ADDRESSABLE (node))
        !           284:     fputs (" addressable", file);
        !           285:   if (TREE_THIS_VOLATILE (node))
        !           286:     fputs (" volatile", file);
        !           287:   if (TREE_UNSIGNED (node))
        !           288:     fputs (" unsigned", file);
        !           289:   if (TREE_ASM_WRITTEN (node))
        !           290:     fputs (" asm_written", file);
        !           291:   if (TREE_USED (node))
        !           292:     fputs (" used", file);
        !           293:   if (TREE_RAISES (node))
        !           294:     fputs (" raises", file);
        !           295:   if (TREE_PERMANENT (node))
        !           296:     fputs (" permanent", file);
        !           297:   if (TREE_PUBLIC (node))
        !           298:     fputs (" public", file);
        !           299:   if (TREE_STATIC (node))
        !           300:     fputs (" static", file);
        !           301:   if (TREE_LANG_FLAG_0 (node))
        !           302:     fputs (" tree_0", file);
        !           303:   if (TREE_LANG_FLAG_1 (node))
        !           304:     fputs (" tree_1", file);
        !           305:   if (TREE_LANG_FLAG_2 (node))
        !           306:     fputs (" tree_2", file);
        !           307:   if (TREE_LANG_FLAG_3 (node))
        !           308:     fputs (" tree_3", file);
        !           309:   if (TREE_LANG_FLAG_4 (node))
        !           310:     fputs (" tree_4", file);
        !           311:   if (TREE_LANG_FLAG_5 (node))
        !           312:     fputs (" tree_5", file);
        !           313:   if (TREE_LANG_FLAG_6 (node))
        !           314:     fputs (" tree_6", file);
        !           315: 
        !           316:   /* DECL_ nodes have additional attributes.  */
        !           317: 
        !           318:   switch (TREE_CODE_CLASS (TREE_CODE (node)))
        !           319:     {
        !           320:     case 'd':
        !           321:       mode = DECL_MODE (node);
        !           322: 
        !           323:       if (DECL_EXTERNAL (node))
        !           324:        fputs (" external", file);
        !           325:       if (DECL_NONLOCAL (node))
        !           326:        fputs (" nonlocal", file);
        !           327:       if (DECL_REGISTER (node))
        !           328:        fputs (" regdecl", file);
        !           329:       if (DECL_INLINE (node))
        !           330:        fputs (" inline", file);
        !           331:       if (DECL_BIT_FIELD (node))
        !           332:        fputs (" bit-field", file);
        !           333:       if (DECL_VIRTUAL_P (node))
        !           334:        fputs (" virtual", file);
        !           335:       if (DECL_IGNORED_P (node))
        !           336:        fputs (" ignored", file);
        !           337:       if (DECL_IN_SYSTEM_HEADER (node))
        !           338:        fputs (" in_system_header", file);
        !           339:       if (DECL_LANG_FLAG_0 (node))
        !           340:        fputs (" decl_0", file);
        !           341:       if (DECL_LANG_FLAG_1 (node))
        !           342:        fputs (" decl_1", file);
        !           343:       if (DECL_LANG_FLAG_2 (node))
        !           344:        fputs (" decl_2", file);
        !           345:       if (DECL_LANG_FLAG_3 (node))
        !           346:        fputs (" decl_3", file);
        !           347:       if (DECL_LANG_FLAG_4 (node))
        !           348:        fputs (" decl_4", file);
        !           349:       if (DECL_LANG_FLAG_5 (node))
        !           350:        fputs (" decl_5", file);
        !           351:       if (DECL_LANG_FLAG_6 (node))
        !           352:        fputs (" decl_6", file);
        !           353:       if (DECL_LANG_FLAG_7 (node))
        !           354:        fputs (" decl_7", file);
        !           355: 
        !           356:       fprintf (file, " %s", mode_name[(int) mode]);
        !           357: 
        !           358:       fprintf (file, " file %s line %d",
        !           359:               DECL_SOURCE_FILE (node), DECL_SOURCE_LINE (node));
        !           360: 
        !           361:       print_node (file, "size", DECL_SIZE (node), indent + 4);
        !           362:       indent_to (file, indent + 3);
        !           363:       if (TREE_CODE (node) != FUNCTION_DECL)
        !           364:        fprintf (file, " align %d", DECL_ALIGN (node));
        !           365:       else if (DECL_INLINE (node))
        !           366:        fprintf (file, " frame_size %d", DECL_FRAME_SIZE (node));
        !           367:       else if (DECL_BUILT_IN (node))
        !           368:        fprintf (file, " built-in code %d", DECL_FUNCTION_CODE (node));
        !           369:       if (TREE_CODE (node) == FIELD_DECL)
        !           370:        print_node (file, "bitpos", DECL_FIELD_BITPOS (node), indent + 4);
        !           371:       print_node_brief (file, "context", DECL_CONTEXT (node), indent + 4);
        !           372:       print_node_brief (file, "abstract_origin",
        !           373:                        DECL_ABSTRACT_ORIGIN (node), indent + 4);
        !           374: 
        !           375:       print_node (file, "arguments", DECL_ARGUMENTS (node), indent + 4);
        !           376:       print_node (file, "result", DECL_RESULT (node), indent + 4);
        !           377:       print_node_brief (file, "initial", DECL_INITIAL (node), indent + 4);
        !           378: 
        !           379:       print_lang_decl (file, node, indent);
        !           380: 
        !           381:       if (DECL_RTL (node) != 0)
        !           382:        {
        !           383:          indent_to (file, indent + 4);
        !           384:          print_rtl (file, DECL_RTL (node));
        !           385:        }
        !           386: 
        !           387:       if (DECL_SAVED_INSNS (node) != 0)
        !           388:        {
        !           389:          indent_to (file, indent + 4);
        !           390:          if (TREE_CODE (node) == PARM_DECL)
        !           391:            {
        !           392:              fprintf (file, "incoming-rtl ");
        !           393:              print_rtl (file, DECL_INCOMING_RTL (node));
        !           394:            }
        !           395:          else if (TREE_CODE (node) == FUNCTION_DECL)
        !           396:            {
        !           397:              fprintf (file, "saved-insns ");
        !           398:              fprintf (file, HOST_PTR_PRINTF,
        !           399:                       (HOST_WIDE_INT) DECL_SAVED_INSNS (node));
        !           400:            }
        !           401:        }
        !           402: 
        !           403:       /* Print the decl chain only if decl is at second level.  */
        !           404:       if (indent == 4)
        !           405:        print_node (file, "chain", TREE_CHAIN (node), indent + 4);
        !           406:       else
        !           407:        print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
        !           408:       break;
        !           409: 
        !           410:     case 't':
        !           411:       if (TYPE_NO_FORCE_BLK (node))
        !           412:        fputs (" no_force_blk", file);
        !           413:       if (TYPE_LANG_FLAG_0 (node))
        !           414:        fputs (" type_0", file);
        !           415:       if (TYPE_LANG_FLAG_1 (node))
        !           416:        fputs (" type_1", file);
        !           417:       if (TYPE_LANG_FLAG_2 (node))
        !           418:        fputs (" type_2", file);
        !           419:       if (TYPE_LANG_FLAG_3 (node))
        !           420:        fputs (" type_3", file);
        !           421:       if (TYPE_LANG_FLAG_4 (node))
        !           422:        fputs (" type_4", file);
        !           423:       if (TYPE_LANG_FLAG_5 (node))
        !           424:        fputs (" type_5", file);
        !           425:       if (TYPE_LANG_FLAG_6 (node))
        !           426:        fputs (" type_6", file);
        !           427: 
        !           428:       mode = TYPE_MODE (node);
        !           429:       fprintf (file, " %s", mode_name[(int) mode]);
        !           430: 
        !           431:       print_node (file, "size", TYPE_SIZE (node), indent + 4);
        !           432:       indent_to (file, indent + 3);
        !           433: 
        !           434:       fprintf (file, " align %d", TYPE_ALIGN (node));
        !           435:       fprintf (file, " symtab %d", TYPE_SYMTAB_ADDRESS (node));
        !           436: 
        !           437:       if (TREE_CODE (node) == ARRAY_TYPE || TREE_CODE (node) == SET_TYPE)
        !           438:        print_node (file, "domain", TYPE_DOMAIN (node), indent + 4);
        !           439:       else if (TREE_CODE (node) == INTEGER_TYPE
        !           440:               || TREE_CODE (node) == BOOLEAN_TYPE
        !           441:               || TREE_CODE (node) == CHAR_TYPE)
        !           442:        {
        !           443:          fprintf (file, " precision %d", TYPE_PRECISION (node));
        !           444:          print_node (file, "min", TYPE_MIN_VALUE (node), indent + 4);
        !           445:          print_node (file, "max", TYPE_MAX_VALUE (node), indent + 4);
        !           446:        }
        !           447:       else if (TREE_CODE (node) == ENUMERAL_TYPE)
        !           448:        {
        !           449:          fprintf (file, " precision %d", TYPE_PRECISION (node));
        !           450:          print_node (file, "min", TYPE_MIN_VALUE (node), indent + 4);
        !           451:          print_node (file, "max", TYPE_MAX_VALUE (node), indent + 4);
        !           452:          print_node (file, "values", TYPE_VALUES (node), indent + 4);
        !           453:        }
        !           454:       else if (TREE_CODE (node) == REAL_TYPE)
        !           455:        fprintf (file, " precision %d", TYPE_PRECISION (node));
        !           456:       else if (TREE_CODE (node) == RECORD_TYPE
        !           457:               || TREE_CODE (node) == UNION_TYPE
        !           458:               || TREE_CODE (node) == QUAL_UNION_TYPE)
        !           459:        print_node (file, "fields", TYPE_FIELDS (node), indent + 4);
        !           460:       else if (TREE_CODE (node) == FUNCTION_TYPE || TREE_CODE (node) == METHOD_TYPE)
        !           461:        {
        !           462:          if (TYPE_METHOD_BASETYPE (node))
        !           463:            print_node_brief (file, "method basetype", TYPE_METHOD_BASETYPE (node), indent + 4);
        !           464:          print_node (file, "arg-types", TYPE_ARG_TYPES (node), indent + 4);
        !           465:        }
        !           466:       if (TYPE_CONTEXT (node))
        !           467:        print_node_brief (file, "context", TYPE_CONTEXT (node), indent + 4);
        !           468: 
        !           469:       print_lang_type (file, node, indent);
        !           470: 
        !           471:       if (TYPE_POINTER_TO (node) || TREE_CHAIN (node))
        !           472:        indent_to (file, indent + 3);
        !           473:       print_node_brief (file, "pointer_to_this", TYPE_POINTER_TO (node), indent + 4);
        !           474:       print_node_brief (file, "reference_to_this", TYPE_REFERENCE_TO (node), indent + 4);
        !           475:       print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
        !           476:       break;
        !           477: 
        !           478:     case 'b':
        !           479:       print_node (file, "vars", BLOCK_VARS (node), indent + 4);
        !           480:       print_node (file, "tags", BLOCK_TYPE_TAGS (node), indent + 4);
        !           481:       print_node (file, "supercontext", BLOCK_SUPERCONTEXT (node), indent + 4);
        !           482:       print_node (file, "subblocks", BLOCK_SUBBLOCKS (node), indent + 4);
        !           483:       print_node (file, "chain", BLOCK_CHAIN (node), indent + 4);
        !           484:       print_node (file, "abstract_origin",
        !           485:                  BLOCK_ABSTRACT_ORIGIN (node), indent + 4);
        !           486:       return;
        !           487: 
        !           488:     case 'e':
        !           489:     case '<':
        !           490:     case '1':
        !           491:     case '2':
        !           492:     case 'r':
        !           493:     case 's':
        !           494:       switch (TREE_CODE (node))
        !           495:        {
        !           496:        case BIND_EXPR:
        !           497:          print_node (file, "vars", TREE_OPERAND (node, 0), indent + 4);
        !           498:          print_node (file, "body", TREE_OPERAND (node, 1), indent + 4);
        !           499:          print_node (file, "block", TREE_OPERAND (node, 2), indent + 4);
        !           500:          return;
        !           501:        }
        !           502: 
        !           503:       first_rtl = len = tree_code_length[(int) TREE_CODE (node)];
        !           504:       /* These kinds of nodes contain rtx's, not trees,
        !           505:         after a certain point.  Print the rtx's as rtx's.  */
        !           506:       switch (TREE_CODE (node))
        !           507:        {
        !           508:        case SAVE_EXPR:
        !           509:          first_rtl = 2;
        !           510:          break;
        !           511:        case CALL_EXPR:
        !           512:          first_rtl = 2;
        !           513:          break;
        !           514:        case METHOD_CALL_EXPR:
        !           515:          first_rtl = 3;
        !           516:          break;
        !           517:        case WITH_CLEANUP_EXPR:
        !           518:          /* Should be defined to be 2.  */
        !           519:          first_rtl = 1;
        !           520:          break;
        !           521:        case RTL_EXPR:
        !           522:          first_rtl = 0;
        !           523:        }
        !           524:       for (i = 0; i < len; i++)
        !           525:        {
        !           526:          if (i >= first_rtl)
        !           527:            {
        !           528:              indent_to (file, indent + 4);
        !           529:              fprintf (file, "rtl %d ", i);
        !           530:              if (TREE_OPERAND (node, i))
        !           531:                print_rtl (file, (struct rtx_def *) TREE_OPERAND (node, i));
        !           532:              else
        !           533:                fprintf (file, "(nil)");
        !           534:              fprintf (file, "\n");
        !           535:            }
        !           536:          else
        !           537:            {
        !           538:              char temp[10];
        !           539: 
        !           540:              sprintf (temp, "arg %d", i);
        !           541:              print_node (file, temp, TREE_OPERAND (node, i), indent + 4);
        !           542:            }
        !           543:        }
        !           544:       break;
        !           545: 
        !           546:     case 'c':
        !           547:     case 'x':
        !           548:       switch (TREE_CODE (node))
        !           549:        {
        !           550:        case INTEGER_CST:
        !           551:          if (TREE_INT_CST_HIGH (node) == 0)
        !           552:            fprintf (file, " %1u", TREE_INT_CST_LOW (node));
        !           553:          else if (TREE_INT_CST_HIGH (node) == -1
        !           554:                   && TREE_INT_CST_LOW (node) != 0)
        !           555:            fprintf (file, " -%1u", -TREE_INT_CST_LOW (node));
        !           556:          else
        !           557:            fprintf (file,
        !           558: #if HOST_BITS_PER_WIDE_INT == 64
        !           559: #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
        !           560:                     " 0x%lx%016lx",
        !           561: #else
        !           562:                     " 0x%x%016x",
        !           563: #endif
        !           564: #else
        !           565: #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
        !           566:                     " 0x%lx%08lx",
        !           567: #else
        !           568:                     " 0x%x%08x",
        !           569: #endif
        !           570: #endif
        !           571:                     TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
        !           572:          break;
        !           573: 
        !           574:        case REAL_CST:
        !           575: #ifndef REAL_IS_NOT_DOUBLE
        !           576:          fprintf (file, " %e", TREE_REAL_CST (node));
        !           577: #else
        !           578:          {
        !           579:            char *p = (char *) &TREE_REAL_CST (node);
        !           580:            fprintf (file, " 0x");
        !           581:            for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
        !           582:              fprintf (file, "%02x", *p++);
        !           583:            fprintf (file, "");
        !           584:          }
        !           585: #endif /* REAL_IS_NOT_DOUBLE */
        !           586:          break;
        !           587: 
        !           588:        case COMPLEX_CST:
        !           589:          print_node (file, "real", TREE_REALPART (node), indent + 4);
        !           590:          print_node (file, "imag", TREE_IMAGPART (node), indent + 4);
        !           591:          break;
        !           592: 
        !           593:        case STRING_CST:
        !           594:          fprintf (file, " \"%s\"", TREE_STRING_POINTER (node));
        !           595:          /* Print the chain at second level.  */
        !           596:          if (indent == 4)
        !           597:            print_node (file, "chain", TREE_CHAIN (node), indent + 4);
        !           598:          else
        !           599:            print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
        !           600:          break;
        !           601: 
        !           602:        case IDENTIFIER_NODE:
        !           603:          print_lang_identifier (file, node, indent);
        !           604:          break;
        !           605: 
        !           606:        case TREE_LIST:
        !           607:          print_node (file, "purpose", TREE_PURPOSE (node), indent + 4);
        !           608:          print_node (file, "value", TREE_VALUE (node), indent + 4);
        !           609:          print_node (file, "chain", TREE_CHAIN (node), indent + 4);
        !           610:          break;
        !           611: 
        !           612:        case TREE_VEC:
        !           613:          len = TREE_VEC_LENGTH (node);
        !           614:          for (i = 0; i < len; i++)
        !           615:            if (TREE_VEC_ELT (node, i))
        !           616:              {
        !           617:                char temp[10];
        !           618:                sprintf (temp, "elt %d", i);
        !           619:                indent_to (file, indent + 4);
        !           620:                print_node_brief (file, temp, TREE_VEC_ELT (node, i), 0);
        !           621:              }
        !           622:          break;
        !           623: 
        !           624:        case OP_IDENTIFIER:
        !           625:          print_node (file, "op1", TREE_PURPOSE (node), indent + 4);
        !           626:          print_node (file, "op2", TREE_VALUE (node), indent + 4);
        !           627:        }
        !           628: 
        !           629:       break;
        !           630:     }
        !           631: 
        !           632:   fprintf (file, ">");
        !           633: }

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