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