gcc/tree-browser.c

   1 /* Tree browser.
   2    Copyright (C) 2002, 2003, 2004, 2007 Free Software Foundation, Inc.
   3    Contributed by Sebastian Pop <s.pop@laposte.net>
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "tm.h"
  25 #include "tree.h"
  26 #include "tree-inline.h"
  27 #include "diagnostic.h"
  28 #include "hashtab.h"
  29
  30
  31 #define TB_OUT_FILE stdout
  32 #define TB_IN_FILE stdin
  33 #define TB_NIY fprintf (TB_OUT_FILE, "Sorry this command is not yet implemented.\n")
  34 #define TB_WF fprintf (TB_OUT_FILE, "Warning, this command failed.\n")
  35
  36
  37 /* Structures for handling Tree Browser's commands.  */
  38 #define DEFTBCODE(COMMAND, STRING, HELP)   COMMAND,
  39 enum TB_Comm_code {
  40 #include "tree-browser.def"
  41   TB_UNUSED_COMMAND
  42 };
  43 #undef DEFTBCODE
  44 typedef enum TB_Comm_code TB_CODE;
  45
  46 struct tb_command {
  47   const char *help_msg;
  48   const char *comm_text;
  49   size_t comm_len;
  50   TB_CODE comm_code;
  51 };
  52
  53 #define DEFTBCODE(code, str, help) { help, str, sizeof(str) - 1, code },
  54 static const struct tb_command tb_commands[] =
  55 {
  56 #include "tree-browser.def"
  57 };
  58 #undef DEFTBCODE
  59
  60 #define TB_COMMAND_LEN(N) (tb_commands[N].comm_len)
  61 #define TB_COMMAND_TEXT(N) (tb_commands[N].comm_text)
  62 #define TB_COMMAND_CODE(N) (tb_commands[N].comm_code)
  63 #define TB_COMMAND_HELP(N) (tb_commands[N].help_msg)
  64
  65
  66 /* Next structure is for parsing TREE_CODEs.  */
  67 struct tb_tree_code {
  68   enum tree_code code;
  69   const char *code_string;
  70   size_t code_string_len;
  71 };
  72
  73 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) { SYM, STRING, sizeof (STRING) - 1 },
  74 static const struct tb_tree_code tb_tree_codes[] =
  75 {
  76 #include "tree.def"
  77 };
  78 #undef DEFTREECODE
  79
  80 #define TB_TREE_CODE(N) (tb_tree_codes[N].code)
  81 #define TB_TREE_CODE_TEXT(N) (tb_tree_codes[N].code_string)
  82 #define TB_TREE_CODE_LEN(N) (tb_tree_codes[N].code_string_len)
  83
  84
  85 /* Function declarations.  */
  86
  87 static long TB_getline (char **, long *, FILE *);
  88 static TB_CODE TB_get_command (char *);
  89 static enum tree_code TB_get_tree_code (char *);
  90 static tree find_node_with_code (tree *, int *, void *);
  91 static tree store_child_info (tree *, int *, void *);
  92 static void TB_update_up (tree);
  93 static tree TB_current_chain_node (tree);
  94 static tree TB_prev_expr (tree);
  95 static tree TB_next_expr (tree);
  96 static tree TB_up_expr (tree);
  97 static tree TB_first_in_bind (tree);
  98 static tree TB_last_in_bind (tree);
  99 static int  TB_parent_eq (const void *, const void *);
 100 static tree TB_history_prev (void);
 101
 102 /* FIXME: To be declared in a .h file.  */
 103 void browse_tree (tree);
 104
 105 /* Static variables.  */
 106 static htab_t TB_up_ht;
 107 static tree TB_history_stack = NULL_TREE;
 108 static int TB_verbose = 1;
 109
 110
 111 /* Entry point in the Tree Browser.  */
 112
 113 void
 114 browse_tree (tree begin)
 115 {
 116   tree head;
 117   TB_CODE tbc = TB_UNUSED_COMMAND;
 118   ssize_t rd;
 119   char *input = NULL;
 120   long input_size = 0;
 121
 122   fprintf (TB_OUT_FILE, "\nTree Browser\n");
 123
 124 #define TB_SET_HEAD(N) do {                                           \
 125   TB_history_stack = tree_cons (NULL_TREE, (N), TB_history_stack);    \
 126   head = N;                                                           \
 127   if (TB_verbose)                                                     \
 128     if (head)                                                         \
 129       {                                                               \
 130         print_generic_expr (TB_OUT_FILE, head, 0);                    \
 131         fprintf (TB_OUT_FILE, "\n");                                  \
 132       }                                                               \
 133 } while (0)
 134
 135   TB_SET_HEAD (begin);
 136
 137   /* Store in a hashtable information about previous and upper statements.  */
 138   {
 139     TB_up_ht = htab_create (1023, htab_hash_pointer, &TB_parent_eq, NULL);
 140     TB_update_up (head);
 141   }
 142
 143   while (24)
 144     {
 145       fprintf (TB_OUT_FILE, "TB> ");
 146       rd = TB_getline (&input, &input_size, TB_IN_FILE);
 147
 148       if (rd == -1)
 149         /* EOF.  */
 150         goto ret;
 151
 152       if (rd != 1)
 153         /* Get a new command.  Otherwise the user just pressed enter, and thus
 154            she expects the last command to be reexecuted.  */
 155         tbc = TB_get_command (input);
 156
 157       switch (tbc)
 158         {
 159         case TB_UPDATE_UP:
 160           TB_update_up (head);
 161           break;
 162
 163         case TB_MAX:
 164           if (head && (INTEGRAL_TYPE_P (head)
 165                        || TREE_CODE (head) == REAL_TYPE))
 166             TB_SET_HEAD (TYPE_MAX_VALUE (head));
 167           else
 168             TB_WF;
 169           break;
 170
 171         case TB_MIN:
 172           if (head && (INTEGRAL_TYPE_P (head)
 173                        || TREE_CODE (head) == REAL_TYPE))
 174             TB_SET_HEAD (TYPE_MIN_VALUE (head));
 175           else
 176             TB_WF;
 177           break;
 178
 179         case TB_ELT:
 180           if (head && TREE_CODE (head) == TREE_VEC)
 181             {
 182               /* This command takes another argument: the element number:
 183                  for example "elt 1".  */
 184               TB_NIY;
 185             }
 186           else if (head && TREE_CODE (head) == VECTOR_CST)
 187             {
 188               /* This command takes another argument: the element number:
 189                  for example "elt 1".  */
 190               TB_NIY;
 191             }
 192           else
 193             TB_WF;
 194           break;
 195
 196         case TB_VALUE:
 197           if (head && TREE_CODE (head) == TREE_LIST)
 198             TB_SET_HEAD (TREE_VALUE (head));
 199           else
 200             TB_WF;
 201           break;
 202
 203         case TB_PURPOSE:
 204           if (head && TREE_CODE (head) == TREE_LIST)
 205             TB_SET_HEAD (TREE_PURPOSE (head));
 206           else
 207             TB_WF;
 208           break;
 209
 210         case TB_IMAG:
 211           if (head && TREE_CODE (head) == COMPLEX_CST)
 212             TB_SET_HEAD (TREE_IMAGPART (head));
 213           else
 214             TB_WF;
 215           break;
 216
 217         case TB_REAL:
 218           if (head && TREE_CODE (head) == COMPLEX_CST)
 219             TB_SET_HEAD (TREE_REALPART (head));
 220           else
 221             TB_WF;
 222           break;
 223
 224         case TB_BLOCK:
 225           if (head && TREE_CODE (head) == BIND_EXPR)
 226             TB_SET_HEAD (TREE_OPERAND (head, 2));
 227           else
 228             TB_WF;
 229           break;
 230
 231         case TB_SUBBLOCKS:
 232           if (head && TREE_CODE (head) == BLOCK)
 233             TB_SET_HEAD (BLOCK_SUBBLOCKS (head));
 234           else
 235             TB_WF;
 236           break;
 237
 238         case TB_SUPERCONTEXT:
 239           if (head && TREE_CODE (head) == BLOCK)
 240             TB_SET_HEAD (BLOCK_SUPERCONTEXT (head));
 241           else
 242             TB_WF;
 243           break;
 244
 245         case TB_VARS:
 246           if (head && TREE_CODE (head) == BLOCK)
 247             TB_SET_HEAD (BLOCK_VARS (head));
 248           else if (head && TREE_CODE (head) == BIND_EXPR)
 249             TB_SET_HEAD (TREE_OPERAND (head, 0));
 250           else
 251             TB_WF;
 252           break;
 253
 254         case TB_REFERENCE_TO_THIS:
 255           if (head && TYPE_P (head))
 256             TB_SET_HEAD (TYPE_REFERENCE_TO (head));
 257           else
 258             TB_WF;
 259           break;
 260
 261         case TB_POINTER_TO_THIS:
 262           if (head && TYPE_P (head))
 263             TB_SET_HEAD (TYPE_POINTER_TO (head));
 264           else
 265             TB_WF;
 266           break;
 267
 268         case TB_BASETYPE:
 269           if (head && TREE_CODE (head) == OFFSET_TYPE)
 270             TB_SET_HEAD (TYPE_OFFSET_BASETYPE (head));
 271           else
 272             TB_WF;
 273           break;
 274
 275         case TB_ARG_TYPES:
 276           if (head && (TREE_CODE (head) == FUNCTION_TYPE
 277                        || TREE_CODE (head) == METHOD_TYPE))
 278             TB_SET_HEAD (TYPE_ARG_TYPES (head));
 279           else
 280             TB_WF;
 281           break;
 282
 283         case TB_METHOD_BASE_TYPE:
 284           if (head && (TREE_CODE (head) == FUNCTION_TYPE
 285                        || TREE_CODE (head) == METHOD_TYPE)
 286               && TYPE_METHOD_BASETYPE (head))
 287             TB_SET_HEAD (TYPE_METHOD_BASETYPE (head));
 288           else
 289             TB_WF;
 290           break;
 291
 292         case TB_FIELDS:
 293           if (head && (TREE_CODE (head) == RECORD_TYPE
 294                        || TREE_CODE (head) == UNION_TYPE
 295                        || TREE_CODE (head) == QUAL_UNION_TYPE))
 296             TB_SET_HEAD (TYPE_FIELDS (head));
 297           else
 298             TB_WF;
 299           break;
 300
 301         case TB_DOMAIN:
 302           if (head && TREE_CODE (head) == ARRAY_TYPE)
 303             TB_SET_HEAD (TYPE_DOMAIN (head));
 304           else
 305             TB_WF;
 306           break;
 307
 308         case TB_VALUES:
 309           if (head && TREE_CODE (head) == ENUMERAL_TYPE)
 310             TB_SET_HEAD (TYPE_VALUES (head));
 311           else
 312             TB_WF;
 313           break;
 314
 315         case TB_ARG_TYPE:
 316           if (head && TREE_CODE (head) == PARM_DECL)
 317             TB_SET_HEAD (DECL_ARG_TYPE (head));
 318           else
 319             TB_WF;
 320           break;
 321
 322         case TB_INITIAL:
 323           if (head && DECL_P (head))
 324             TB_SET_HEAD (DECL_INITIAL (head));
 325           else
 326             TB_WF;
 327           break;
 328
 329         case TB_RESULT:
 330           if (head && DECL_P (head))
 331             TB_SET_HEAD (DECL_RESULT_FLD (head));
 332           else
 333             TB_WF;
 334           break;
 335
 336         case TB_ARGUMENTS:
 337           if (head && DECL_P (head))
 338             TB_SET_HEAD (DECL_ARGUMENTS (head));
 339           else
 340             TB_WF;
 341           break;
 342
 343         case TB_ABSTRACT_ORIGIN:
 344           if (head && DECL_P (head))
 345             TB_SET_HEAD (DECL_ABSTRACT_ORIGIN (head));
 346           else if (head && TREE_CODE (head) == BLOCK)
 347             TB_SET_HEAD (BLOCK_ABSTRACT_ORIGIN (head));
 348           else
 349             TB_WF;
 350           break;
 351
 352         case TB_ATTRIBUTES:
 353           if (head && DECL_P (head))
 354             TB_SET_HEAD (DECL_ATTRIBUTES (head));
 355           else if (head && TYPE_P (head))
 356             TB_SET_HEAD (TYPE_ATTRIBUTES (head));
 357           else
 358             TB_WF;
 359           break;
 360
 361         case TB_CONTEXT:
 362           if (head && DECL_P (head))
 363             TB_SET_HEAD (DECL_CONTEXT (head));
 364           else if (head && TYPE_P (head)
 365                    && TYPE_CONTEXT (head))
 366             TB_SET_HEAD (TYPE_CONTEXT (head));
 367           else
 368             TB_WF;
 369           break;
 370
 371         case TB_OFFSET:
 372           if (head && TREE_CODE (head) == FIELD_DECL)
 373             TB_SET_HEAD (DECL_FIELD_OFFSET (head));
 374           else
 375             TB_WF;
 376           break;
 377
 378         case TB_BIT_OFFSET:
 379           if (head && TREE_CODE (head) == FIELD_DECL)
 380             TB_SET_HEAD (DECL_FIELD_BIT_OFFSET (head));
 381           else
 382             TB_WF;
 383           break;
 384
 385         case TB_UNIT_SIZE:
 386           if (head && DECL_P (head))
 387             TB_SET_HEAD (DECL_SIZE_UNIT (head));
 388           else if (head && TYPE_P (head))
 389             TB_SET_HEAD (TYPE_SIZE_UNIT (head));
 390           else
 391             TB_WF;
 392           break;
 393
 394         case TB_SIZE:
 395           if (head && DECL_P (head))
 396             TB_SET_HEAD (DECL_SIZE (head));
 397           else if (head && TYPE_P (head))
 398             TB_SET_HEAD (TYPE_SIZE (head));
 399           else
 400             TB_WF;
 401           break;
 402
 403         case TB_TYPE:
 404           if (head && TREE_TYPE (head))
 405             TB_SET_HEAD (TREE_TYPE (head));
 406           else
 407             TB_WF;
 408           break;
 409
 410         case TB_DECL_SAVED_TREE:
 411           if (head && TREE_CODE (head) == FUNCTION_DECL
 412               && DECL_SAVED_TREE (head))
 413             TB_SET_HEAD (DECL_SAVED_TREE (head));
 414           else
 415             TB_WF;
 416           break;
 417
 418         case TB_BODY:
 419           if (head && TREE_CODE (head) == BIND_EXPR)
 420             TB_SET_HEAD (TREE_OPERAND (head, 1));
 421           else
 422             TB_WF;
 423           break;
 424
 425         case TB_CHILD_0:
 426           if (head && EXPR_P (head) && TREE_OPERAND (head, 0))
 427             TB_SET_HEAD (TREE_OPERAND (head, 0));
 428           else
 429             TB_WF;
 430           break;
 431
 432         case TB_CHILD_1:
 433           if (head && EXPR_P (head) && TREE_OPERAND (head, 1))
 434             TB_SET_HEAD (TREE_OPERAND (head, 1));
 435           else
 436             TB_WF;
 437           break;
 438
 439         case TB_CHILD_2:
 440           if (head && EXPR_P (head) && TREE_OPERAND (head, 2))
 441             TB_SET_HEAD (TREE_OPERAND (head, 2));
 442           else
 443             TB_WF;
 444           break;
 445
 446         case TB_CHILD_3:
 447           if (head && EXPR_P (head) && TREE_OPERAND (head, 3))
 448             TB_SET_HEAD (TREE_OPERAND (head, 3));
 449           else
 450             TB_WF;
 451           break;
 452
 453         case TB_PRINT:
 454           if (head)
 455             debug_tree (head);
 456           else
 457             TB_WF;
 458           break;
 459
 460         case TB_PRETTY_PRINT:
 461           if (head)
 462             {
 463               print_generic_stmt (TB_OUT_FILE, head, 0);
 464               fprintf (TB_OUT_FILE, "\n");
 465             }
 466           else
 467             TB_WF;
 468           break;
 469
 470         case TB_SEARCH_NAME:
 471
 472           break;
 473
 474         case TB_SEARCH_CODE:
 475           {
 476             enum tree_code code;
 477             char *arg_text;
 478
 479             arg_text = strchr (input, ' ');
 480             if (arg_text == NULL)
 481               {
 482                 fprintf (TB_OUT_FILE, "First argument is missing.  This isn't a valid search command.  \n");
 483                 break;
 484               }
 485             code = TB_get_tree_code (arg_text + 1);
 486
 487             /* Search in the subtree a node with the given code.  */
 488             {
 489               tree res;
 490
 491               res = walk_tree (&head, find_node_with_code, &code, NULL);
 492               if (res == NULL_TREE)
 493                 {
 494                   fprintf (TB_OUT_FILE, "There's no node with this code (reachable via the walk_tree function from this node).\n");
 495                 }
 496               else
 497                 {
 498                   fprintf (TB_OUT_FILE, "Achoo!  I got this node in the tree.\n");
 499                   TB_SET_HEAD (res);
 500                 }
 501             }
 502             break;
 503           }
 504
 505 #define TB_MOVE_HEAD(FCT) do {       \
 506   if (head)                          \
 507     {                                \
 508       tree t;                        \
 509       t = FCT (head);                \
 510       if (t)                         \
 511         TB_SET_HEAD (t);             \
 512       else                           \
 513         TB_WF;                       \
 514     }                                \
 515   else                               \
 516     TB_WF;                           \
 517 } while (0)
 518
 519         case TB_FIRST:
 520           TB_MOVE_HEAD (TB_first_in_bind);
 521           break;
 522
 523         case TB_LAST:
 524           TB_MOVE_HEAD (TB_last_in_bind);
 525           break;
 526
 527         case TB_UP:
 528           TB_MOVE_HEAD (TB_up_expr);
 529           break;
 530
 531         case TB_PREV:
 532           TB_MOVE_HEAD (TB_prev_expr);
 533           break;
 534
 535         case TB_NEXT:
 536           TB_MOVE_HEAD (TB_next_expr);
 537           break;
 538
 539         case TB_HPREV:
 540           /* This command is a little bit special, since it deals with history
 541              stack.  For this reason it should keep the "head = ..." statement
 542              and not use TB_MOVE_HEAD.  */
 543           if (head)
 544             {
 545               tree t;
 546               t = TB_history_prev ();
 547               if (t)
 548                 {
 549                   head = t;
 550                   if (TB_verbose)
 551                     {
 552                       print_generic_expr (TB_OUT_FILE, head, 0);
 553                       fprintf (TB_OUT_FILE, "\n");
 554                     }
 555                 }
 556               else
 557                 TB_WF;
 558             }
 559           else
 560             TB_WF;
 561           break;
 562
 563         case TB_CHAIN:
 564           /* Don't go further if it's the last node in this chain.  */
 565           if (head && TREE_CODE (head) == BLOCK)
 566             TB_SET_HEAD (BLOCK_CHAIN (head));
 567           else if (head && TREE_CHAIN (head))
 568             TB_SET_HEAD (TREE_CHAIN (head));
 569           else
 570             TB_WF;
 571           break;
 572
 573         case TB_FUN:
 574           /* Go up to the current function declaration.  */
 575           TB_SET_HEAD (current_function_decl);
 576           fprintf (TB_OUT_FILE, "Current function declaration.\n");
 577           break;
 578
 579         case TB_HELP:
 580           /* Display a help message.  */
 581           {
 582             int i;
 583             fprintf (TB_OUT_FILE, "Possible commands are:\n\n");
 584             for (i = 0; i < TB_UNUSED_COMMAND; i++)
 585               {
 586                 fprintf (TB_OUT_FILE, "%20s  -  %s\n", TB_COMMAND_TEXT (i), TB_COMMAND_HELP (i));
 587               }
 588           }
 589           break;
 590
 591         case TB_VERBOSE:
 592           if (TB_verbose == 0)
 593             {
 594               TB_verbose = 1;
 595               fprintf (TB_OUT_FILE, "Verbose on.\n");
 596             }
 597           else
 598             {
 599               TB_verbose = 0;
 600               fprintf (TB_OUT_FILE, "Verbose off.\n");
 601             }
 602           break;
 603
 604         case TB_EXIT:
 605         case TB_QUIT:
 606           /* Just exit from this function.  */
 607           goto ret;
 608
 609         default:
 610           TB_NIY;
 611         }
 612     }
 613
 614  ret:;
 615   htab_delete (TB_up_ht);
 616   return;
 617 }
 618
 619
 620 /* Search the first node in this BIND_EXPR.  */
 621
 622 static tree
 623 TB_first_in_bind (tree node)
 624 {
 625   tree t;
 626
 627   if (node == NULL_TREE)
 628     return NULL_TREE;
 629
 630   while ((t = TB_prev_expr (node)))
 631     node = t;
 632
 633   return node;
 634 }
 635
 636 /* Search the last node in this BIND_EXPR.  */
 637
 638 static tree
 639 TB_last_in_bind (tree node)
 640 {
 641   tree t;
 642
 643   if (node == NULL_TREE)
 644     return NULL_TREE;
 645
 646   while ((t = TB_next_expr (node)))
 647     node = t;
 648
 649   return node;
 650 }
 651
 652 /* Search the parent expression for this node.  */
 653
 654 static tree
 655 TB_up_expr (tree node)
 656 {
 657   tree res;
 658   if (node == NULL_TREE)
 659     return NULL_TREE;
 660
 661   res = (tree) htab_find (TB_up_ht, node);
 662   return res;
 663 }
 664
 665 /* Search the previous expression in this BIND_EXPR.  */
 666
 667 static tree
 668 TB_prev_expr (tree node)
 669 {
 670   node = TB_current_chain_node (node);
 671
 672   if (node == NULL_TREE)
 673     return NULL_TREE;
 674
 675   node = TB_up_expr (node);
 676   if (node && TREE_CODE (node) == COMPOUND_EXPR)
 677     return node;
 678   else
 679     return NULL_TREE;
 680 }
 681
 682 /* Search the next expression in this BIND_EXPR.  */
 683
 684 static tree
 685 TB_next_expr (tree node)
 686 {
 687   node = TB_current_chain_node (node);
 688
 689   if (node == NULL_TREE)
 690     return NULL_TREE;
 691
 692   node = TREE_OPERAND (node, 1);
 693   return node;
 694 }
 695
 696 static tree
 697 TB_current_chain_node (tree node)
 698 {
 699   if (node == NULL_TREE)
 700     return NULL_TREE;
 701
 702   if (TREE_CODE (node) == COMPOUND_EXPR)
 703     return node;
 704
 705   node = TB_up_expr (node);
 706   if (node)
 707     {
 708       if (TREE_CODE (node) == COMPOUND_EXPR)
 709         return node;
 710
 711       node = TB_up_expr (node);
 712       if (TREE_CODE (node) == COMPOUND_EXPR)
 713         return node;
 714     }
 715
 716   return NULL_TREE;
 717 }
 718
 719 /* For each node store in its children nodes that the current node is their
 720    parent.  This function is used by walk_tree.  */
 721
 722 static tree
 723 store_child_info (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
 724                   void *data ATTRIBUTE_UNUSED)
 725 {
 726   tree node;
 727   void **slot;
 728
 729   node = *tp;
 730
 731   /* 'node' is the parent of 'TREE_OPERAND (node, *)'.  */
 732   if (EXPRESSION_CLASS_P (node))
 733     {
 734
 735 #define STORE_CHILD(N) do {                                                \
 736   tree op = TREE_OPERAND (node, N);                                        \
 737   slot = htab_find_slot (TB_up_ht, op, INSERT);                               \
 738   *slot = (void *) node;                                                   \
 739 } while (0)
 740
 741       switch (TREE_CODE_LENGTH (TREE_CODE (node)))
 742         {
 743         case 4:
 744           STORE_CHILD (0);
 745           STORE_CHILD (1);
 746           STORE_CHILD (2);
 747           STORE_CHILD (3);
 748           break;
 749
 750         case 3:
 751           STORE_CHILD (0);
 752           STORE_CHILD (1);
 753           STORE_CHILD (2);
 754           break;
 755
 756         case 2:
 757           STORE_CHILD (0);
 758           STORE_CHILD (1);
 759           break;
 760
 761         case 1:
 762           STORE_CHILD (0);
 763           break;
 764
 765         case 0:
 766         default:
 767           /* No children: nothing to do.  */
 768           break;
 769         }
 770 #undef STORE_CHILD
 771     }
 772
 773   /* Never stop walk_tree.  */
 774   return NULL_TREE;
 775 }
 776
 777 /* Function used in TB_up_ht.  */
 778
 779 static int
 780 TB_parent_eq (const void *p1, const void *p2)
 781 {
 782   tree node, parent;
 783   node = (tree) p2;
 784   parent = (tree) p1;
 785
 786   if (p1 == NULL || p2 == NULL)
 787     return 0;
 788
 789   if (EXPRESSION_CLASS_P (parent))
 790     {
 791
 792 #define TEST_CHILD(N) do {               \
 793   if (node == TREE_OPERAND (parent, N))  \
 794     return 1;                            \
 795 } while (0)
 796
 797     switch (TREE_CODE_LENGTH (TREE_CODE (parent)))
 798       {
 799       case 4:
 800         TEST_CHILD (0);
 801         TEST_CHILD (1);
 802         TEST_CHILD (2);
 803         TEST_CHILD (3);
 804         break;
 805
 806       case 3:
 807         TEST_CHILD (0);
 808         TEST_CHILD (1);
 809         TEST_CHILD (2);
 810         break;
 811
 812       case 2:
 813         TEST_CHILD (0);
 814         TEST_CHILD (1);
 815         break;
 816
 817       case 1:
 818         TEST_CHILD (0);
 819         break;
 820
 821       case 0:
 822       default:
 823         /* No children: nothing to do.  */
 824         break;
 825       }
 826 #undef TEST_CHILD
 827     }
 828
 829   return 0;
 830 }
 831
 832 /* Update information about upper expressions in the hash table.  */
 833
 834 static void
 835 TB_update_up (tree node)
 836 {
 837   while (node)
 838     {
 839       walk_tree (&node, store_child_info, NULL, NULL);
 840
 841       /* Walk function's body.  */
 842       if (TREE_CODE (node) == FUNCTION_DECL)
 843         if (DECL_SAVED_TREE (node))
 844           walk_tree (&DECL_SAVED_TREE (node), store_child_info, NULL, NULL);
 845
 846       /* Walk rest of the chain.  */
 847       node = TREE_CHAIN (node);
 848     }
 849   fprintf (TB_OUT_FILE, "Up/prev expressions updated.\n");
 850 }
 851
 852 /* Parse the input string for determining the command the user asked for.  */
 853
 854 static TB_CODE
 855 TB_get_command (char *input)
 856 {
 857   unsigned int mn, size_tok;
 858   int comp;
 859   char *space;
 860
 861   space = strchr (input, ' ');
 862   if (space != NULL)
 863     size_tok = strlen (input) - strlen (space);
 864   else
 865     size_tok = strlen (input) - 1;
 866
 867   for (mn = 0; mn < TB_UNUSED_COMMAND; mn++)
 868     {
 869       if (size_tok != TB_COMMAND_LEN (mn))
 870         continue;
 871
 872       comp = memcmp (input, TB_COMMAND_TEXT (mn), TB_COMMAND_LEN (mn));
 873       if (comp == 0)
 874         /* Here we just determined the command.  If this command takes
 875            an argument, then the argument is determined later.  */
 876         return TB_COMMAND_CODE (mn);
 877     }
 878
 879   /* Not a valid command.  */
 880   return TB_UNUSED_COMMAND;
 881 }
 882
 883 /* Parse the input string for determining the tree code.  */
 884
 885 static enum tree_code
 886 TB_get_tree_code (char *input)
 887 {
 888   unsigned int mn, size_tok;
 889   int comp;
 890   char *space;
 891
 892   space = strchr (input, ' ');
 893   if (space != NULL)
 894     size_tok = strlen (input) - strlen (space);
 895   else
 896     size_tok = strlen (input) - 1;
 897
 898   for (mn = 0; mn < LAST_AND_UNUSED_TREE_CODE; mn++)
 899     {
 900       if (size_tok != TB_TREE_CODE_LEN (mn))
 901         continue;
 902
 903       comp = memcmp (input, TB_TREE_CODE_TEXT (mn), TB_TREE_CODE_LEN (mn));
 904       if (comp == 0)
 905         {
 906           fprintf (TB_OUT_FILE, "%s\n", TB_TREE_CODE_TEXT (mn));
 907           return TB_TREE_CODE (mn);
 908         }
 909     }
 910
 911   /* This isn't a valid code.  */
 912   return LAST_AND_UNUSED_TREE_CODE;
 913 }
 914
 915 /* Find a node with a given code.  This function is used as an argument to
 916    walk_tree.  */
 917
 918 static tree
 919 find_node_with_code (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
 920                      void *data)
 921 {
 922   enum tree_code *code;
 923   code = (enum tree_code *) data;
 924   if (*code == TREE_CODE (*tp))
 925     return *tp;
 926
 927   return NULL_TREE;
 928 }
 929
 930 /* Returns a pointer to the last visited node.  */
 931
 932 static tree
 933 TB_history_prev (void)
 934 {
 935   if (TB_history_stack)
 936     {
 937       TB_history_stack = TREE_CHAIN (TB_history_stack);
 938       if (TB_history_stack)
 939         return TREE_VALUE (TB_history_stack);
 940     }
 941   return NULL_TREE;
 942 }
 943
 944 /* Read up to (and including) a '\n' from STREAM into *LINEPTR
 945    (and null-terminate it). *LINEPTR is a pointer returned from malloc
 946    (or NULL), pointing to *N characters of space.  It is realloc'd as
 947    necessary.  Returns the number of characters read (not including the
 948    null terminator), or -1 on error or EOF.
 949    This function comes from sed (and is supposed to be a portable version
 950    of getline).  */
 951
 952 static long
 953 TB_getline (char **lineptr, long *n, FILE *stream)
 954 {
 955   char *line, *p;
 956   long size, copy;
 957
 958   if (lineptr == NULL || n == NULL)
 959     {
 960       errno = EINVAL;
 961       return -1;
 962     }
 963
 964   if (ferror (stream))
 965     return -1;
 966
 967   /* Make sure we have a line buffer to start with.  */
 968   if (*lineptr == NULL || *n < 2) /* !seen and no buf yet need 2 chars.  */
 969     {
 970 #ifndef MAX_CANON
 971 #define MAX_CANON       256
 972 #endif
 973       line = (char *) xrealloc (*lineptr, MAX_CANON);
 974       if (line == NULL)
 975         return -1;
 976       *lineptr = line;
 977       *n = MAX_CANON;
 978     }
 979
 980   line = *lineptr;
 981   size = *n;
 982
 983   copy = size;
 984   p = line;
 985
 986   while (1)
 987     {
 988       long len;
 989
 990       while (--copy > 0)
 991         {
 992           register int c = getc (stream);
 993           if (c == EOF)
 994             goto lose;
 995           else if ((*p++ = c) == '\n')
 996             goto win;
 997         }
 998
 999       /* Need to enlarge the line buffer.  */
1000       len = p - line;
1001       size *= 2;
1002       line = (char *) xrealloc (line, size);
1003       if (line == NULL)
1004         goto lose;
1005       *lineptr = line;
1006       *n = size;
1007       p = line + len;
1008       copy = size - len;
1009     }
1010
1011  lose:
1012   if (p == *lineptr)
1013     return -1;
1014
1015   /* Return a partial line since we got an error in the middle.  */
1016  win:
1017 #if defined(WIN32) || defined(_WIN32) || defined(__CYGWIN__) || defined(MSDOS)
1018   if (p - 2 >= *lineptr && p[-2] == '\r')
1019     p[-2] = p[-1], --p;
1020 #endif
1021   *p = '\0';
1022   return p - *lineptr;
1023 }