gcc/tree-browser.c

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