2 Copyright (C) 2002, 2003 Free Software Foundation, Inc.
3 Contributed by Sebastian Pop <s.pop@laposte.net>
5 This file is part of GCC.
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 2, or (at your option) any later
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
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
24 #include "coretypes.h"
28 #include "tree-inline.h"
29 #include "diagnostic.h"
33 #define TB_OUT_FILE stdout
34 #define TB_IN_FILE stdin
35 #define TB_NIY fprintf (TB_OUT_FILE, "Sorry this command is not yet implemented.\n")
36 #define TB_WF fprintf (TB_OUT_FILE, "Warning, this command failed.\n")
39 /* Structures for handling Tree Browser's commands. */
40 #define DEFTBCODE(COMMAND, STRING, HELP) COMMAND,
42 #include "tree-browser.def"
46 typedef enum TB_Comm_code TB_CODE;
50 const char *comm_text;
55 #define DEFTBCODE(code, str, help) { help, str, sizeof(str) - 1, code },
57 static struct tb_command tb_commands[] =
59 static const struct tb_command tb_commands[] =
62 #include "tree-browser.def"
66 #define TB_COMMAND_LEN(N) (tb_commands[N].comm_len)
67 #define TB_COMMAND_TEXT(N) (tb_commands[N].comm_text)
68 #define TB_COMMAND_CODE(N) (tb_commands[N].comm_code)
69 #define TB_COMMAND_HELP(N) (tb_commands[N].help_msg)
72 /* Next structure is for parsing TREE_CODEs. */
75 const char *code_string;
76 size_t code_string_len;
79 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) { SYM, STRING, sizeof (STRING) - 1 },
81 static struct tb_tree_code tb_tree_codes[] =
83 static const struct tb_tree_code tb_tree_codes[] =
90 #define TB_TREE_CODE(N) (tb_tree_codes[N].code)
91 #define TB_TREE_CODE_TEXT(N) (tb_tree_codes[N].code_string)
92 #define TB_TREE_CODE_LEN(N) (tb_tree_codes[N].code_string_len)
95 /* Function declarations. */
97 static long TB_getline (char **, long *, FILE *);
98 static TB_CODE TB_get_command (char *);
99 static enum tree_code TB_get_tree_code (char *);
100 static tree find_node_with_code (tree *, int *, void *);
101 static tree store_child_info (tree *, int *, void *);
102 static void TB_update_up (tree);
103 static tree TB_current_chain_node (tree);
104 static tree TB_prev_expr (tree);
105 static tree TB_next_expr (tree);
106 static tree TB_up_expr (tree);
107 static tree TB_first_in_bind (tree);
108 static tree TB_last_in_bind (tree);
109 static int TB_parent_eq (const void *, const void *);
110 static tree TB_history_prev (void);
112 /* FIXME: To be declared in a .h file. */
113 void browse_tree (tree);
115 /* Static variables. */
116 static htab_t TB_up_ht;
117 static tree TB_history_stack = NULL_TREE;
118 static int TB_verbose = 1;
121 /* Entry point in the Tree Browser. */
124 browse_tree (tree begin)
127 TB_CODE tbc = TB_UNUSED_COMMAND;
132 fprintf (TB_OUT_FILE, "\nTree Browser\n");
134 #define TB_SET_HEAD(N) do { \
135 TB_history_stack = tree_cons (NULL_TREE, (N), TB_history_stack); \
140 print_generic_expr (TB_OUT_FILE, head, 0); \
141 fprintf (TB_OUT_FILE, "\n"); \
147 /* Store in a hashtable information about previous and upper statements. */
149 TB_up_ht = htab_create (1023, htab_hash_pointer, &TB_parent_eq, NULL);
155 fprintf (TB_OUT_FILE, "TB> ");
156 rd = TB_getline (&input, &input_size, TB_IN_FILE);
163 /* Get a new command. Otherwise the user just pressed enter, and thus
164 she expects the last command to be reexecuted. */
165 tbc = TB_get_command (input);
174 if (head && (INTEGRAL_TYPE_P (head)
175 || TREE_CODE (head) == REAL_TYPE))
176 TB_SET_HEAD (TYPE_MAX_VALUE (head));
182 if (head && (INTEGRAL_TYPE_P (head)
183 || TREE_CODE (head) == REAL_TYPE))
184 TB_SET_HEAD (TYPE_MIN_VALUE (head));
190 if (head && TREE_CODE (head) == TREE_VEC)
192 /* This command takes another argument: the element number:
193 for example "elt 1". */
196 else if (head && TREE_CODE (head) == VECTOR_CST)
198 /* This command takes another argument: the element number:
199 for example "elt 1". */
207 if (head && TREE_CODE (head) == TREE_LIST)
208 TB_SET_HEAD (TREE_VALUE (head));
214 if (head && TREE_CODE (head) == TREE_LIST)
215 TB_SET_HEAD (TREE_PURPOSE (head));
221 if (head && TREE_CODE (head) == COMPLEX_CST)
222 TB_SET_HEAD (TREE_IMAGPART (head));
228 if (head && TREE_CODE (head) == COMPLEX_CST)
229 TB_SET_HEAD (TREE_REALPART (head));
235 if (head && TREE_CODE (head) == BIND_EXPR)
236 TB_SET_HEAD (TREE_OPERAND (head, 2));
242 if (head && TREE_CODE (head) == BLOCK)
243 TB_SET_HEAD (BLOCK_SUBBLOCKS (head));
248 case TB_SUPERCONTEXT:
249 if (head && TREE_CODE (head) == BLOCK)
250 TB_SET_HEAD (BLOCK_SUPERCONTEXT (head));
256 if (head && TREE_CODE (head) == BLOCK)
257 TB_SET_HEAD (BLOCK_VARS (head));
258 else if (head && TREE_CODE (head) == BIND_EXPR)
259 TB_SET_HEAD (TREE_OPERAND (head, 0));
264 case TB_REFERENCE_TO_THIS:
265 if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 't')
266 TB_SET_HEAD (TYPE_REFERENCE_TO (head));
271 case TB_POINTER_TO_THIS:
272 if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 't')
273 TB_SET_HEAD (TYPE_POINTER_TO (head));
279 if (head && TREE_CODE (head) == OFFSET_TYPE)
280 TB_SET_HEAD (TYPE_OFFSET_BASETYPE (head));
286 if (head && (TREE_CODE (head) == FUNCTION_TYPE
287 || TREE_CODE (head) == METHOD_TYPE))
288 TB_SET_HEAD (TYPE_ARG_TYPES (head));
293 case TB_METHOD_BASE_TYPE:
294 if (head && (TREE_CODE (head) == FUNCTION_TYPE
295 || TREE_CODE (head) == METHOD_TYPE)
296 && TYPE_METHOD_BASETYPE (head))
297 TB_SET_HEAD (TYPE_METHOD_BASETYPE (head));
303 if (head && (TREE_CODE (head) == RECORD_TYPE
304 || TREE_CODE (head) == UNION_TYPE
305 || TREE_CODE (head) == QUAL_UNION_TYPE))
306 TB_SET_HEAD (TYPE_FIELDS (head));
312 if (head && (TREE_CODE (head) == ARRAY_TYPE
313 || TREE_CODE (head) == SET_TYPE))
314 TB_SET_HEAD (TYPE_DOMAIN (head));
320 if (head && TREE_CODE (head) == ENUMERAL_TYPE)
321 TB_SET_HEAD (TYPE_VALUES (head));
326 case TB_ARG_TYPE_AS_WRITTEN:
327 if (head && TREE_CODE (head) == PARM_DECL)
328 TB_SET_HEAD (DECL_ARG_TYPE_AS_WRITTEN (head));
334 if (head && TREE_CODE (head) == PARM_DECL)
335 TB_SET_HEAD (DECL_ARG_TYPE (head));
341 if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 'd')
342 TB_SET_HEAD (DECL_INITIAL (head));
348 if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 'd')
349 TB_SET_HEAD (DECL_RESULT_FLD (head));
355 if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 'd')
356 TB_SET_HEAD (DECL_ARGUMENTS (head));
361 case TB_ABSTRACT_ORIGIN:
362 if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 'd')
363 TB_SET_HEAD (DECL_ABSTRACT_ORIGIN (head));
364 else if (head && TREE_CODE (head) == BLOCK)
365 TB_SET_HEAD (BLOCK_ABSTRACT_ORIGIN (head));
371 if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 'd')
372 TB_SET_HEAD (DECL_ATTRIBUTES (head));
373 else if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 't')
374 TB_SET_HEAD (TYPE_ATTRIBUTES (head));
380 if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 'd')
381 TB_SET_HEAD (DECL_CONTEXT (head));
382 else if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 't'
383 && TYPE_CONTEXT (head))
384 TB_SET_HEAD (TYPE_CONTEXT (head));
390 if (head && TREE_CODE (head) == FIELD_DECL)
391 TB_SET_HEAD (DECL_FIELD_OFFSET (head));
397 if (head && TREE_CODE (head) == FIELD_DECL)
398 TB_SET_HEAD (DECL_FIELD_BIT_OFFSET (head));
404 if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 'd')
405 TB_SET_HEAD (DECL_SIZE_UNIT (head));
406 else if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 't')
407 TB_SET_HEAD (TYPE_SIZE_UNIT (head));
413 if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 'd')
414 TB_SET_HEAD (DECL_SIZE (head));
415 else if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 't')
416 TB_SET_HEAD (TYPE_SIZE (head));
422 if (head && TREE_TYPE (head))
423 TB_SET_HEAD (TREE_TYPE (head));
428 case TB_DECL_SAVED_TREE:
429 if (head && TREE_CODE (head) == FUNCTION_DECL
430 && DECL_SAVED_TREE (head))
431 TB_SET_HEAD (DECL_SAVED_TREE (head));
437 if (head && TREE_CODE (head) == BIND_EXPR)
438 TB_SET_HEAD (TREE_OPERAND (head, 1));
444 if (head && IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (head)))
445 && TREE_OPERAND (head, 0))
446 TB_SET_HEAD (TREE_OPERAND (head, 0));
452 if (head && IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (head)))
453 && TREE_OPERAND (head, 1))
454 TB_SET_HEAD (TREE_OPERAND (head, 1));
460 if (head && IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (head)))
461 && TREE_OPERAND (head, 2))
462 TB_SET_HEAD (TREE_OPERAND (head, 2));
468 if (head && IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (head)))
469 && TREE_OPERAND (head, 3))
470 TB_SET_HEAD (TREE_OPERAND (head, 3));
482 case TB_PRETTY_PRINT:
485 print_generic_stmt (TB_OUT_FILE, head, 0);
486 fprintf (TB_OUT_FILE, "\n");
501 arg_text = strchr (input, ' ');
502 if (arg_text == NULL)
504 fprintf (TB_OUT_FILE, "First argument is missing. This isn't a valid search command. \n");
507 code = TB_get_tree_code (arg_text + 1);
509 /* Search in the subtree a node with the given code. */
513 res = walk_tree (&head, find_node_with_code, &code, NULL);
514 if (res == NULL_TREE)
516 fprintf (TB_OUT_FILE, "There's no node with this code (reachable via the walk_tree function from this node).\n");
520 fprintf (TB_OUT_FILE, "Achoo! I got this node in the tree.\n");
527 #define TB_MOVE_HEAD(FCT) do { \
542 TB_MOVE_HEAD (TB_first_in_bind);
546 TB_MOVE_HEAD (TB_last_in_bind);
550 TB_MOVE_HEAD (TB_up_expr);
554 TB_MOVE_HEAD (TB_prev_expr);
558 TB_MOVE_HEAD (TB_next_expr);
562 /* This command is a little bit special, since it deals with history
563 stack. For this reason it should keep the "head = ..." statement
564 and not use TB_MOVE_HEAD. */
568 t = TB_history_prev ();
574 print_generic_expr (TB_OUT_FILE, head, 0);
575 fprintf (TB_OUT_FILE, "\n");
586 /* Don't go further if it's the last node in this chain. */
587 if (head && TREE_CODE (head) == BLOCK)
588 TB_SET_HEAD (BLOCK_CHAIN (head));
589 else if (head && TREE_CHAIN (head))
590 TB_SET_HEAD (TREE_CHAIN (head));
596 /* Go up to the current function declaration. */
597 TB_SET_HEAD (current_function_decl);
598 fprintf (TB_OUT_FILE, "Current function declaration.\n");
602 /* Display a help message. */
605 fprintf (TB_OUT_FILE, "Possible commands are:\n\n");
606 for (i = 0; i < TB_UNUSED_COMMAND; i++)
608 fprintf (TB_OUT_FILE, "%20s - %s\n", TB_COMMAND_TEXT (i), TB_COMMAND_HELP (i));
617 fprintf (TB_OUT_FILE, "Verbose on.\n");
622 fprintf (TB_OUT_FILE, "Verbose off.\n");
628 /* Just exit from this function. */
637 htab_delete (TB_up_ht);
642 /* Search the first node in this BIND_EXPR. */
645 TB_first_in_bind (tree node)
649 if (node == NULL_TREE)
652 while ((t = TB_prev_expr (node)))
658 /* Search the last node in this BIND_EXPR. */
661 TB_last_in_bind (tree node)
665 if (node == NULL_TREE)
668 while ((t = TB_next_expr (node)))
674 /* Search the parent expression for this node. */
677 TB_up_expr (tree node)
680 if (node == NULL_TREE)
683 res = (tree) htab_find (TB_up_ht, node);
687 /* Search the previous expression in this BIND_EXPR. */
690 TB_prev_expr (tree node)
692 node = TB_current_chain_node (node);
694 if (node == NULL_TREE)
697 node = TB_up_expr (node);
698 if (node && TREE_CODE (node) == COMPOUND_EXPR)
704 /* Search the next expression in this BIND_EXPR. */
707 TB_next_expr (tree node)
709 node = TB_current_chain_node (node);
711 if (node == NULL_TREE)
714 node = TREE_OPERAND (node, 1);
719 TB_current_chain_node (tree node)
721 if (node == NULL_TREE)
724 if (TREE_CODE (node) == COMPOUND_EXPR)
727 node = TB_up_expr (node);
730 if (TREE_CODE (node) == COMPOUND_EXPR)
733 node = TB_up_expr (node);
734 if (TREE_CODE (node) == COMPOUND_EXPR)
741 /* For each node store in its children nodes that the current node is their
742 parent. This function is used by walk_tree. */
745 store_child_info (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
746 void *data ATTRIBUTE_UNUSED)
753 /* 'node' is the parent of 'TREE_OPERAND (node, *)'. */
754 if (TREE_CODE_CLASS (TREE_CODE (node)) == 'e')
757 #define STORE_CHILD(N) do { \
758 tree op = TREE_OPERAND (node, N); \
759 slot = htab_find_slot (TB_up_ht, op, INSERT); \
760 *slot = (void *) node; \
763 switch (TREE_CODE_LENGTH (TREE_CODE (node)))
789 /* No children: nothing to do. */
795 /* Never stop walk_tree. */
799 /* Function used in TB_up_ht. */
802 TB_parent_eq (const void *p1, const void *p2)
808 if (p1 == NULL || p2 == NULL)
811 if (TREE_CODE_CLASS(TREE_CODE(parent)) == 'e')
814 #define TEST_CHILD(N) do { \
815 if (node == TREE_OPERAND (parent, N)) \
819 switch (TREE_CODE_LENGTH (TREE_CODE (parent)))
845 /* No children: nothing to do. */
854 /* Update information about upper expressions in the hash table. */
857 TB_update_up (tree node)
861 walk_tree (&node, store_child_info, NULL, NULL);
863 /* Walk function's body. */
864 if (TREE_CODE (node) == FUNCTION_DECL)
865 if (DECL_SAVED_TREE (node))
866 walk_tree (&DECL_SAVED_TREE (node), store_child_info, NULL, NULL);
868 /* Walk rest of the chain. */
869 node = TREE_CHAIN (node);
871 fprintf (TB_OUT_FILE, "Up/prev expressions updated.\n");
874 /* Parse the input string for determining the command the user asked for. */
877 TB_get_command (char *input)
879 unsigned int mn, size_tok;
883 space = strchr (input, ' ');
885 size_tok = strlen (input) - strlen (space);
887 size_tok = strlen (input) - 1;
889 for (mn = 0; mn < TB_UNUSED_COMMAND; mn++)
891 if (size_tok != TB_COMMAND_LEN (mn))
894 comp = memcmp (input, TB_COMMAND_TEXT (mn), TB_COMMAND_LEN (mn));
896 /* Here we just determined the command. If this command takes
897 an argument, then the argument is determined later. */
898 return TB_COMMAND_CODE (mn);
901 /* Not a valid command. */
902 return TB_UNUSED_COMMAND;
905 /* Parse the input string for determining the tree code. */
907 static enum tree_code
908 TB_get_tree_code (char *input)
910 unsigned int mn, size_tok;
914 space = strchr (input, ' ');
916 size_tok = strlen (input) - strlen (space);
918 size_tok = strlen (input) - 1;
920 for (mn = 0; mn < LAST_AND_UNUSED_TREE_CODE; mn++)
922 if (size_tok != TB_TREE_CODE_LEN (mn))
925 comp = memcmp (input, TB_TREE_CODE_TEXT (mn), TB_TREE_CODE_LEN (mn));
928 fprintf (TB_OUT_FILE, "%s\n", TB_TREE_CODE_TEXT (mn));
929 return TB_TREE_CODE (mn);
933 /* This isn't a valid code. */
934 return LAST_AND_UNUSED_TREE_CODE;
937 /* Find a node with a given code. This function is used as an argument to
941 find_node_with_code (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
944 enum tree_code *code;
945 code = (enum tree_code *) data;
946 if (*code == TREE_CODE (*tp))
952 /* Returns a pointer to the last visited node. */
955 TB_history_prev (void)
957 if (TB_history_stack)
959 TB_history_stack = TREE_CHAIN (TB_history_stack);
960 if (TB_history_stack)
961 return TREE_VALUE (TB_history_stack);
966 /* Read up to (and including) a '\n' from STREAM into *LINEPTR
967 (and null-terminate it). *LINEPTR is a pointer returned from malloc
968 (or NULL), pointing to *N characters of space. It is realloc'd as
969 necessary. Returns the number of characters read (not including the
970 null terminator), or -1 on error or EOF.
971 This function comes from sed (and is supposed to be a portable version
975 TB_getline (char **lineptr, long *n, FILE *stream)
980 if (lineptr == NULL || n == NULL)
989 /* Make sure we have a line buffer to start with. */
990 if (*lineptr == NULL || *n < 2) /* !seen and no buf yet need 2 chars. */
993 #define MAX_CANON 256
995 line = (char *) xrealloc (*lineptr, MAX_CANON);
1014 register int c = getc (stream);
1017 else if ((*p++ = c) == '\n')
1021 /* Need to enlarge the line buffer. */
1024 line = (char *) xrealloc (line, size);
1037 /* Return a partial line since we got an error in the middle. */
1039 #if defined(WIN32) || defined(_WIN32) || defined(__CYGWIN__) || defined(MSDOS)
1040 if (p - 2 >= *lineptr && p[-2] == '\r')
1044 return p - *lineptr;