Return to print-tree.c CVS log

Up to [GCC 2.x] / gcc

Annotation of gcc/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 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 %x", prefix,
        !            83:           tree_code_name[(int) TREE_CODE (node)], (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, " 0x%x%08x",
        !           114:                 TREE_INT_CST_HIGH (node),
        !           115:                 TREE_INT_CST_LOW (node));
        !           116:     }
        !           117:   if (TREE_CODE (node) == REAL_CST)
        !           118:     {
        !           119: #ifndef REAL_IS_NOT_DOUBLE
        !           120:       fprintf (file, " %e", TREE_REAL_CST (node));
        !           121: #else
        !           122:       {
        !           123:        int i;
        !           124:        char *p = (char *) &TREE_REAL_CST (node);
        !           125:        fprintf (file, " 0x");
        !           126:        for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
        !           127:          fprintf (file, "%02x", *p++);
        !           128:        fprintf (file, "");
        !           129:       }
        !           130: #endif /* REAL_IS_NOT_DOUBLE */
        !           131:     }
        !           132: 
        !           133:   fprintf (file, ">");
        !           134: }
        !           135: 
        !           136: void
        !           137: indent_to (file, column)
        !           138:      FILE *file;
        !           139:      int column;
        !           140: {
        !           141:   int i;
        !           142: 
        !           143:   /* Since this is the long way, indent to desired column.  */
        !           144:   if (column > 0)
        !           145:     fprintf (file, "\n");
        !           146:   for (i = 0; i < column; i++)
        !           147:     fprintf (file, " ");
        !           148: }
        !           149: 
        !           150: /* Print the node NODE in full on file FILE, preceded by PREFIX,
        !           151:    starting in column INDENT.  */
        !           152: 
        !           153: void
        !           154: print_node (file, prefix, node, indent)
        !           155:      FILE *file;
        !           156:      char *prefix;
        !           157:      tree node;
        !           158:      int indent;
        !           159: {
        !           160:   int hash;
        !           161:   struct bucket *b;
        !           162:   enum machine_mode mode;
        !           163:   char class;
        !           164:   int len;
        !           165:   int first_rtl;
        !           166:   int i;
        !           167: 
        !           168:   if (node == 0)
        !           169:     return;
        !           170: 
        !           171:   class = TREE_CODE_CLASS (TREE_CODE (node));
        !           172: 
        !           173:   /* Don't get too deep in nesting.  If the user wants to see deeper,
        !           174:      it is easy to use the address of a lowest-level node
        !           175:      as an argument in another call to debug_tree.  */
        !           176: 
        !           177:   if (indent > 24)
        !           178:     {
        !           179:       print_node_brief (file, prefix, node, indent);
        !           180:       return;
        !           181:     }
        !           182: 
        !           183:   if (indent > 8 && (class == 't' || class == 'd'))
        !           184:     {
        !           185:       print_node_brief (file, prefix, node, indent);
        !           186:       return;
        !           187:     }
        !           188: 
        !           189:   /* It is unsafe to look at any other filds of an ERROR_MARK node. */
        !           190:   if (TREE_CODE (node) == ERROR_MARK)
        !           191:     {
        !           192:       print_node_brief (file, prefix, node, indent);
        !           193:       return;
        !           194:     }
        !           195: 
        !           196:   hash = ((int) node & ~(1 << (HOST_BITS_PER_INT - 1))) % HASH_SIZE;
        !           197: 
        !           198:   /* If node is in the table, just mention its address.  */
        !           199:   for (b = table[hash]; b; b = b->next)
        !           200:     if (b->node == node)
        !           201:       {
        !           202:        print_node_brief (file, prefix, node, indent);
        !           203:        return;
        !           204:       }
        !           205: 
        !           206:   /* Add this node to the table.  */
        !           207:   b = (struct bucket *) oballoc (sizeof (struct bucket));
        !           208:   b->node = node;
        !           209:   b->next = table[hash];
        !           210:   table[hash] = b;
        !           211: 
        !           212:   /* Indent to the specified column, since this is the long form.  */
        !           213:   indent_to (file, indent);
        !           214: 
        !           215:   /* Print the slot this node is in, and its code, and address.  */
        !           216:   fprintf (file, "%s <%s %x", prefix,
        !           217:           tree_code_name[(int) TREE_CODE (node)], (int) node);
        !           218: 
        !           219:   /* Print the name, if any.  */
        !           220:   if (class == 'd')
        !           221:     {
        !           222:       if (DECL_NAME (node))
        !           223:        fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
        !           224:     }
        !           225:   else if (class == 't')
        !           226:     {
        !           227:       if (TYPE_NAME (node))
        !           228:        {
        !           229:          if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
        !           230:            fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node)));
        !           231:          else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
        !           232:                   && DECL_NAME (TYPE_NAME (node)))
        !           233:            fprintf (file, " %s",
        !           234:                     IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node))));
        !           235:        }
        !           236:     }
        !           237:   if (TREE_CODE (node) == IDENTIFIER_NODE)
        !           238:     fprintf (file, " %s", IDENTIFIER_POINTER (node));
        !           239: 
        !           240:   if (TREE_CODE (node) == INTEGER_CST)
        !           241:     {
        !           242:       if (indent <= 4)
        !           243:        print_node_brief (file, "type", TREE_TYPE (node), indent + 4);
        !           244:     }
        !           245:   else
        !           246:     {
        !           247:       print_node (file, "type", TREE_TYPE (node), indent + 4);
        !           248:       if (TREE_TYPE (node))
        !           249:        indent_to (file, indent + 3);
        !           250:     }
        !           251: 
        !           252:   /* If a permanent object is in the wrong obstack, or the reverse, warn.  */
        !           253:   if (object_permanent_p (node) != TREE_PERMANENT (node))
        !           254:     {
        !           255:       if (TREE_PERMANENT (node))
        !           256:        fputs (" !!permanent object in non-permanent obstack!!", file);
        !           257:       else
        !           258:        fputs (" !!non-permanent object in permanent obstack!!", file);
        !           259:       indent_to (file, indent + 3);
        !           260:     }
        !           261: 
        !           262:   if (TREE_SIDE_EFFECTS (node))
        !           263:     fputs (" side-effects", file);
        !           264:   if (TREE_READONLY (node))
        !           265:     fputs (" readonly", file);
        !           266:   if (TREE_CONSTANT (node))
        !           267:     fputs (" constant", file);
        !           268:   if (TREE_ADDRESSABLE (node))
        !           269:     fputs (" addressable", file);
        !           270:   if (TREE_THIS_VOLATILE (node))
        !           271:     fputs (" volatile", file);
        !           272:   if (TREE_UNSIGNED (node))
        !           273:     fputs (" unsigned", file);
        !           274:   if (TREE_ASM_WRITTEN (node))
        !           275:     fputs (" asm_written", file);
        !           276:   if (TREE_USED (node))
        !           277:     fputs (" used", file);
        !           278:   if (TREE_PERMANENT (node))
        !           279:     fputs (" permanent", file);
        !           280:   if (TREE_PUBLIC (node))
        !           281:     fputs (" public", file);
        !           282:   if (TREE_STATIC (node))
        !           283:     fputs (" static", file);
        !           284:   if (TREE_LANG_FLAG_0 (node))
        !           285:     fputs (" tree_0", file);
        !           286:   if (TREE_LANG_FLAG_1 (node))
        !           287:     fputs (" tree_1", file);
        !           288:   if (TREE_LANG_FLAG_2 (node))
        !           289:     fputs (" tree_2", file);
        !           290:   if (TREE_LANG_FLAG_3 (node))
        !           291:     fputs (" tree_3", file);
        !           292:   if (TREE_LANG_FLAG_4 (node))
        !           293:     fputs (" tree_4", file);
        !           294:   if (TREE_LANG_FLAG_5 (node))
        !           295:     fputs (" tree_5", file);
        !           296:   if (TREE_LANG_FLAG_6 (node))
        !           297:     fputs (" tree_6", file);
        !           298: 
        !           299:   /* DECL_ nodes have additional attributes.  */
        !           300: 
        !           301:   switch (TREE_CODE_CLASS (TREE_CODE (node)))
        !           302:     {
        !           303:     case 'd':
        !           304:       mode = DECL_MODE (node);
        !           305: 
        !           306:       if (TREE_EXTERNAL (node))
        !           307:        fputs (" external", file);
        !           308:       if (TREE_NONLOCAL (node))
        !           309:        fputs (" nonlocal", file);
        !           310:       if (TREE_REGDECL (node))
        !           311:        fputs (" regdecl", file);
        !           312:       if (TREE_INLINE (node))
        !           313:        fputs (" inline", file);
        !           314:       if (DECL_BIT_FIELD (node))
        !           315:        fputs (" bit-field", file);
        !           316:       if (DECL_VIRTUAL_P (node))
        !           317:        fputs (" virtual", file);
        !           318:       if (DECL_FROM_INLINE (node))
        !           319:        fputs (" from_inline", file);
        !           320:       if (DECL_IGNORED_P (node))
        !           321:        fputs (" ignored", file);
        !           322:       if (DECL_LANG_FLAG_0 (node))
        !           323:        fputs (" decl_0", file);
        !           324:       if (DECL_LANG_FLAG_1 (node))
        !           325:        fputs (" decl_1", file);
        !           326:       if (DECL_LANG_FLAG_2 (node))
        !           327:        fputs (" decl_2", file);
        !           328:       if (DECL_LANG_FLAG_3 (node))
        !           329:        fputs (" decl_3", file);
        !           330:       if (DECL_LANG_FLAG_4 (node))
        !           331:        fputs (" decl_4", file);
        !           332:       if (DECL_LANG_FLAG_5 (node))
        !           333:        fputs (" decl_5", file);
        !           334:       if (DECL_LANG_FLAG_6 (node))
        !           335:        fputs (" decl_6", file);
        !           336:       if (DECL_LANG_FLAG_7 (node))
        !           337:        fputs (" decl_7", file);
        !           338: 
        !           339:       fprintf (file, " %s", mode_name[(int) mode]);
        !           340: 
        !           341:       fprintf (file, " file %s line %d",
        !           342:               DECL_SOURCE_FILE (node), DECL_SOURCE_LINE (node));
        !           343: 
        !           344:       print_node (file, "size", DECL_SIZE (node), indent + 4);
        !           345:       indent_to (file, indent + 3);
        !           346:       fprintf (file, " align %d", DECL_ALIGN (node));
        !           347:       fprintf (file, " frame_size %d", DECL_FRAME_SIZE (node));
        !           348:       if (TREE_CODE (node) == FIELD_DECL)
        !           349:        print_node (file, "bitpos", DECL_FIELD_BITPOS (node), indent + 4);
        !           350:       print_node_brief (file, "context", DECL_CONTEXT (node), indent + 4);
        !           351: 
        !           352:       print_node (file, "arguments", DECL_ARGUMENTS (node), indent + 4);
        !           353:       print_node (file, "result", DECL_RESULT (node), indent + 4);
        !           354:       print_node_brief (file, "initial", DECL_INITIAL (node), indent + 4);
        !           355: 
        !           356:       print_lang_decl (file, node, indent);
        !           357: 
        !           358:       if (DECL_RTL (node) != 0)
        !           359:        {
        !           360:          indent_to (file, indent + 4);
        !           361:          print_rtl (file, DECL_RTL (node));
        !           362:        }
        !           363: 
        !           364:       if (DECL_SAVED_INSNS (node) != 0)
        !           365:        {
        !           366:          indent_to (file, indent + 4);
        !           367:          if (TREE_CODE (node) == PARM_DECL)
        !           368:            {
        !           369:              fprintf (file, "incoming-rtl ");
        !           370:              print_rtl (file, DECL_INCOMING_RTL (node));
        !           371:            }
        !           372:          else if (TREE_CODE (node) == FUNCTION_DECL)
        !           373:            fprintf (file, "saved-insns 0x%x", DECL_SAVED_INSNS (node));
        !           374:        }
        !           375: 
        !           376:       /* Print the decl chain only if decl is at second level.  */
        !           377:       if (indent == 4)
        !           378:        print_node (file, "chain", TREE_CHAIN (node), indent + 4);
        !           379:       else
        !           380:        print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
        !           381:       break;
        !           382: 
        !           383:     case 't':
        !           384:       if (TYPE_NO_FORCE_BLK (node))
        !           385:        fputs (" no_force_blk", file);
        !           386:       if (TYPE_LANG_FLAG_0 (node))
        !           387:        fputs (" type_0", file);
        !           388:       if (TYPE_LANG_FLAG_1 (node))
        !           389:        fputs (" type_1", file);
        !           390:       if (TYPE_LANG_FLAG_2 (node))
        !           391:        fputs (" type_2", file);
        !           392:       if (TYPE_LANG_FLAG_3 (node))
        !           393:        fputs (" type_3", file);
        !           394:       if (TYPE_LANG_FLAG_4 (node))
        !           395:        fputs (" type_4", file);
        !           396:       if (TYPE_LANG_FLAG_5 (node))
        !           397:        fputs (" type_5", file);
        !           398:       if (TYPE_LANG_FLAG_6 (node))
        !           399:        fputs (" type_6", file);
        !           400: 
        !           401:       mode = TYPE_MODE (node);
        !           402:       fprintf (file, " %s", mode_name[(int) mode]);
        !           403: 
        !           404:       print_node (file, "size", TYPE_SIZE (node), indent + 4);
        !           405:       indent_to (file, indent + 3);
        !           406: 
        !           407:       fprintf (file, " align %d", TYPE_ALIGN (node));
        !           408:       fprintf (file, " symtab %d", TYPE_SYMTAB_ADDRESS (node));
        !           409: 
        !           410:       if (TREE_CODE (node) == ARRAY_TYPE || TREE_CODE (node) == SET_TYPE)
        !           411:        print_node (file, "domain", TYPE_DOMAIN (node), indent + 4);
        !           412:       else if (TREE_CODE (node) == INTEGER_TYPE)
        !           413:        {
        !           414:          fprintf (file, " precision %d", TYPE_PRECISION (node));
        !           415:          print_node (file, "min", TYPE_MIN_VALUE (node), indent + 4);
        !           416:          print_node (file, "max", TYPE_MAX_VALUE (node), indent + 4);
        !           417:        }
        !           418:       else if (TREE_CODE (node) == ENUMERAL_TYPE)
        !           419:        {
        !           420:          fprintf (file, " precision %d", TYPE_PRECISION (node));
        !           421:          print_node (file, "min", TYPE_MIN_VALUE (node), indent + 4);
        !           422:          print_node (file, "max", TYPE_MAX_VALUE (node), indent + 4);
        !           423:          print_node (file, "values", TYPE_VALUES (node), indent + 4);
        !           424:        }
        !           425:       else if (TREE_CODE (node) == REAL_TYPE)
        !           426:        fprintf (file, " precision %d", TYPE_PRECISION (node));
        !           427:       else if (TREE_CODE (node) == RECORD_TYPE || TREE_CODE (node) == UNION_TYPE)
        !           428:        print_node (file, "fields", TYPE_FIELDS (node), indent + 4);
        !           429:       else if (TREE_CODE (node) == FUNCTION_TYPE || TREE_CODE (node) == METHOD_TYPE)
        !           430:        {
        !           431:          if (TYPE_METHOD_BASETYPE (node))
        !           432:            print_node_brief (file, "method basetype", TYPE_METHOD_BASETYPE (node), indent + 4);
        !           433:          print_node (file, "arg-types", TYPE_ARG_TYPES (node), indent + 4);
        !           434:        }
        !           435:       if (TYPE_CONTEXT (node))
        !           436:        print_node_brief (file, "context", TYPE_CONTEXT (node), indent + 4);
        !           437: 
        !           438:       print_lang_type (file, node, indent);
        !           439: 
        !           440:       if (TYPE_POINTER_TO (node) || TREE_CHAIN (node))
        !           441:        indent_to (file, indent + 3);
        !           442:       print_node_brief (file, "pointer_to_this", TYPE_POINTER_TO (node), indent + 4);
        !           443:       print_node_brief (file, "reference_to_this", TYPE_REFERENCE_TO (node), indent + 4);
        !           444:       print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
        !           445:       break;
        !           446: 
        !           447:     case 'e':
        !           448:     case '<':
        !           449:     case '1':
        !           450:     case '2':
        !           451:     case 'r':
        !           452:     case 's':
        !           453:       switch (TREE_CODE (node))
        !           454:        {
        !           455:        case BLOCK:
        !           456:          print_node (file, "vars", BLOCK_VARS (node), indent + 4);
        !           457:          print_node (file, "tags", BLOCK_TYPE_TAGS (node), indent + 4);
        !           458:          print_node (file, "supercontext", BLOCK_SUPERCONTEXT (node), indent + 4);
        !           459:          print_node (file, "subblocks", BLOCK_SUBBLOCKS (node), indent + 4);
        !           460:          print_node (file, "chain", BLOCK_CHAIN (node), indent + 4);
        !           461:          return;
        !           462: 
        !           463:        case BIND_EXPR:
        !           464:          print_node (file, "vars", TREE_OPERAND (node, 0), indent + 4);
        !           465:          print_node (file, "body", TREE_OPERAND (node, 1), indent + 4);
        !           466:          return;
        !           467:        }
        !           468: 
        !           469:       first_rtl = len = tree_code_length[(int) TREE_CODE (node)];
        !           470:       /* These kinds of nodes contain rtx's, not trees,
        !           471:         after a certain point.  Print the rtx's as rtx's.  */
        !           472:       switch (TREE_CODE (node))
        !           473:        {
        !           474:        case SAVE_EXPR:
        !           475:          first_rtl = 2;
        !           476:          break;
        !           477:        case CALL_EXPR:
        !           478:          first_rtl = 2;
        !           479:          break;
        !           480:        case METHOD_CALL_EXPR:
        !           481:          first_rtl = 3;
        !           482:          break;
        !           483:        case WITH_CLEANUP_EXPR:
        !           484:          /* Should be defined to be 2.  */
        !           485:          first_rtl = 1;
        !           486:          break;
        !           487:        case RTL_EXPR:
        !           488:          first_rtl = 0;
        !           489:        }
        !           490:       for (i = 0; i < len; i++)
        !           491:        {
        !           492:          if (i >= first_rtl)
        !           493:            {
        !           494:              indent_to (file, indent + 4);
        !           495:              fprintf (file, "rtl %d ", i);
        !           496:              if (TREE_OPERAND (node, i))
        !           497:                print_rtl (file, TREE_OPERAND (node, i));
        !           498:              else
        !           499:                fprintf (file, "(nil)");
        !           500:              fprintf (file, "\n");
        !           501:            }
        !           502:          else
        !           503:            {
        !           504:              char temp[10];
        !           505: 
        !           506:              sprintf (temp, "arg %d", i);
        !           507:              print_node (file, temp, TREE_OPERAND (node, i), indent + 4);
        !           508:            }
        !           509:        }
        !           510:       break;
        !           511: 
        !           512:     case 'c':
        !           513:     case 'x':
        !           514:       switch (TREE_CODE (node))
        !           515:        {
        !           516:        case INTEGER_CST:
        !           517:          if (TREE_INT_CST_HIGH (node) == 0)
        !           518:            fprintf (file, " %1u", TREE_INT_CST_LOW (node));
        !           519:          else if (TREE_INT_CST_HIGH (node) == -1
        !           520:                   && TREE_INT_CST_LOW (node) != 0)
        !           521:            fprintf (file, " -%1u", -TREE_INT_CST_LOW (node));
        !           522:          else
        !           523:            fprintf (file, " 0x%x%08x",
        !           524:                     TREE_INT_CST_HIGH (node),
        !           525:                     TREE_INT_CST_LOW (node));
        !           526:          break;
        !           527: 
        !           528:        case REAL_CST:
        !           529: #ifndef REAL_IS_NOT_DOUBLE
        !           530:          fprintf (file, " %e", TREE_REAL_CST (node));
        !           531: #else
        !           532:          {
        !           533:            char *p = (char *) &TREE_REAL_CST (node);
        !           534:            fprintf (file, " 0x");
        !           535:            for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
        !           536:              fprintf (file, "%02x", *p++);
        !           537:            fprintf (file, "");
        !           538:          }
        !           539: #endif /* REAL_IS_NOT_DOUBLE */
        !           540:          break;
        !           541: 
        !           542:        case COMPLEX_CST:
        !           543:          print_node (file, "real", TREE_REALPART (node), indent + 4);
        !           544:          print_node (file, "imag", TREE_IMAGPART (node), indent + 4);
        !           545:          break;
        !           546: 
        !           547:        case STRING_CST:
        !           548:          fprintf (file, " \"%s\"", TREE_STRING_POINTER (node));
        !           549:          break;
        !           550: 
        !           551:        case IDENTIFIER_NODE:
        !           552:          print_lang_identifier (file, node, indent);
        !           553:          break;
        !           554: 
        !           555:        case TREE_LIST:
        !           556:          print_node (file, "purpose", TREE_PURPOSE (node), indent + 4);
        !           557:          print_node (file, "value", TREE_VALUE (node), indent + 4);
        !           558:          print_node (file, "chain", TREE_CHAIN (node), indent + 4);
        !           559:          break;
        !           560: 
        !           561:        case TREE_VEC:
        !           562:          len = TREE_VEC_LENGTH (node);
        !           563:          for (i = 0; i < len; i++)
        !           564:            {
        !           565:              char temp[10];
        !           566:              sprintf (temp, "elt %d", i);
        !           567:              indent_to (file, indent + 4);
        !           568:              print_node_brief (file, temp, TREE_VEC_ELT (node, i), 0);
        !           569:            }
        !           570:          break;
        !           571: 
        !           572:        case OP_IDENTIFIER:
        !           573:          print_node (file, "op1", TREE_PURPOSE (node), indent + 4);
        !           574:          print_node (file, "op2", TREE_VALUE (node), indent + 4);
        !           575:        }
        !           576: 
        !           577:       break;
        !           578:     }
        !           579: }

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