]> git.ipfire.org Git - thirdparty/gcc.git/blame - gcc/print-tree.c
projects / thirdparty / gcc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tree-ssa-20020619-branch into mainline.
[thirdparty/gcc.git] / gcc / print-tree.c
CommitLineData
bccafa26 1/* Prints out tree in human readable form - GCC
8153450c 2 Copyright (C) 1990, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
9f5f9308 3 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
3ff560b7 4
f12b58b3 5This file is part of GCC.
3ff560b7 6
f12b58b3 7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 2, or (at your option) any later
10version.
3ff560b7 11
f12b58b3 12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15for more details.
3ff560b7 16
17You should have received a copy of the GNU General Public License
f12b58b3 18along with GCC; see the file COPYING. If not, write to the Free
19Software Foundation, 59 Temple Place - Suite 330, Boston, MA
2002111-1307, USA. */
3ff560b7 21
22
23#include "config.h"
405711de 24#include "system.h"
805e22b2 25#include "coretypes.h"
26#include "tm.h"
3ff560b7 27#include "tree.h"
ef258422 28#include "real.h"
1bfd55c5 29#include "ggc.h"
b7fced5e 30#include "langhooks.h"
3ff560b7 31
3ff560b7 32/* Define the hash table of nodes already seen.
33 Such nodes are not repeated; brief cross-references are used. */
34
35#define HASH_SIZE 37
36
37struct bucket
38{
39 tree node;
40 struct bucket *next;
41};
42
43static struct bucket **table;
44
45/* Print the node NODE on standard error, for debugging.
46 Most nodes referred to by this one are printed recursively
47 down to a depth of six. */
48
49void
3ad4992f 50debug_tree (tree node)
3ff560b7 51{
f0af5a88 52 table = xcalloc (HASH_SIZE, sizeof (struct bucket *));
3ff560b7 53 print_node (stderr, "", node, 0);
78a75ebd 54 free (table);
3ff560b7 55 table = 0;
78a75ebd 56 putc ('\n', stderr);
3ff560b7 57}
58
59/* Print a node in brief fashion, with just the code, address and name. */
60
61void
3ad4992f 62print_node_brief (FILE *file, const char *prefix, tree node, int indent)
3ff560b7 63{
64 char class;
65
66 if (node == 0)
67 return;
68
69 class = TREE_CODE_CLASS (TREE_CODE (node));
70
71 /* Always print the slot this node is in, and its code, address and
72 name if any. */
73 if (indent > 0)
74 fprintf (file, " ");
6f817829 75 fprintf (file, "%s <%s " HOST_PTR_PRINTF,
76 prefix, tree_code_name[(int) TREE_CODE (node)], (char *) node);
3ff560b7 77
78 if (class == 'd')
79 {
80 if (DECL_NAME (node))
81 fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
82 }
83 else if (class == 't')
84 {
85 if (TYPE_NAME (node))
86 {
87 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
88 fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node)));
89 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
90 && DECL_NAME (TYPE_NAME (node)))
91 fprintf (file, " %s",
92 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node))));
93 }
94 }
95 if (TREE_CODE (node) == IDENTIFIER_NODE)
96 fprintf (file, " %s", IDENTIFIER_POINTER (node));
16de2a82 97
98 /* We might as well always print the value of an integer or real. */
3ff560b7 99 if (TREE_CODE (node) == INTEGER_CST)
100 {
5575b8e4 101 if (TREE_CONSTANT_OVERFLOW (node))
102 fprintf (file, " overflow");
103
9656bfb2 104 fprintf (file, " ");
3ff560b7 105 if (TREE_INT_CST_HIGH (node) == 0)
9656bfb2 106 fprintf (file, HOST_WIDE_INT_PRINT_UNSIGNED, TREE_INT_CST_LOW (node));
3ff560b7 107 else if (TREE_INT_CST_HIGH (node) == -1
108 && TREE_INT_CST_LOW (node) != 0)
85aa12f7 109 fprintf (file, "-" HOST_WIDE_INT_PRINT_UNSIGNED,
110 -TREE_INT_CST_LOW (node));
3ff560b7 111 else
9656bfb2 112 fprintf (file, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
b572011e 113 TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
3ff560b7 114 }
115 if (TREE_CODE (node) == REAL_CST)
116 {
e50f2bd2 117 REAL_VALUE_TYPE d;
118
127c4264 119 if (TREE_OVERFLOW (node))
120 fprintf (file, " overflow");
121
e50f2bd2 122 d = TREE_REAL_CST (node);
127c4264 123 if (REAL_VALUE_ISINF (d))
124 fprintf (file, " Inf");
125 else if (REAL_VALUE_ISNAN (d))
126 fprintf (file, " Nan");
127 else
128 {
c7fbc741 129 char string[60];
130 real_to_decimal (string, &d, sizeof (string), 0, 1);
127c4264 131 fprintf (file, " %s", string);
132 }
3ff560b7 133 }
134
135 fprintf (file, ">");
136}
137
138void
3ad4992f 139indent_to (FILE *file, int column)
3ff560b7 140{
141 int i;
142
143 /* Since this is the long way, indent to desired column. */
144 if (column > 0)
145 fprintf (file, "\n");
146 for (i = 0; i < column; i++)
147 fprintf (file, " ");
148}
149\f
150/* Print the node NODE in full on file FILE, preceded by PREFIX,
151 starting in column INDENT. */
152
153void
3ad4992f 154print_node (FILE *file, const char *prefix, tree node, int indent)
3ff560b7 155{
156 int hash;
157 struct bucket *b;
158 enum machine_mode mode;
159 char class;
160 int len;
161 int first_rtl;
162 int i;
163
164 if (node == 0)
165 return;
166
167 class = TREE_CODE_CLASS (TREE_CODE (node));
168
169 /* Don't get too deep in nesting. If the user wants to see deeper,
170 it is easy to use the address of a lowest-level node
171 as an argument in another call to debug_tree. */
172
173 if (indent > 24)
174 {
175 print_node_brief (file, prefix, node, indent);
176 return;
177 }
178
179 if (indent > 8 && (class == 't' || class == 'd'))
180 {
181 print_node_brief (file, prefix, node, indent);
182 return;
183 }
184
41a6f238 185 /* It is unsafe to look at any other fields of an ERROR_MARK node. */
3ff560b7 186 if (TREE_CODE (node) == ERROR_MARK)
187 {
188 print_node_brief (file, prefix, node, indent);
189 return;
190 }
191
7040045e 192 hash = ((unsigned long) node) % HASH_SIZE;
3ff560b7 193
194 /* If node is in the table, just mention its address. */
195 for (b = table[hash]; b; b = b->next)
196 if (b->node == node)
197 {
198 print_node_brief (file, prefix, node, indent);
199 return;
200 }
201
202 /* Add this node to the table. */
f0af5a88 203 b = xmalloc (sizeof (struct bucket));
3ff560b7 204 b->node = node;
205 b->next = table[hash];
206 table[hash] = b;
207
208 /* Indent to the specified column, since this is the long form. */
209 indent_to (file, indent);
210
211 /* Print the slot this node is in, and its code, and address. */
6f817829 212 fprintf (file, "%s <%s " HOST_PTR_PRINTF,
213 prefix, tree_code_name[(int) TREE_CODE (node)], (void *) node);
3ff560b7 214
215 /* Print the name, if any. */
216 if (class == 'd')
217 {
218 if (DECL_NAME (node))
219 fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
220 }
221 else if (class == 't')
222 {
223 if (TYPE_NAME (node))
224 {
225 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
226 fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node)));
227 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
228 && DECL_NAME (TYPE_NAME (node)))
229 fprintf (file, " %s",
230 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node))));
231 }
232 }
233 if (TREE_CODE (node) == IDENTIFIER_NODE)
234 fprintf (file, " %s", IDENTIFIER_POINTER (node));
235
236 if (TREE_CODE (node) == INTEGER_CST)
237 {
238 if (indent <= 4)
239 print_node_brief (file, "type", TREE_TYPE (node), indent + 4);
240 }
241 else
242 {
243 print_node (file, "type", TREE_TYPE (node), indent + 4);
244 if (TREE_TYPE (node))
245 indent_to (file, indent + 3);
3ff560b7 246 }
247
66d12a6c 248 if (!TYPE_P (node) && TREE_SIDE_EFFECTS (node))
3ff560b7 249 fputs (" side-effects", file);
66d12a6c 250
251 if (TYPE_P (node) ? TYPE_READONLY (node) : TREE_READONLY (node))
3ff560b7 252 fputs (" readonly", file);
66d12a6c 253 if (!TYPE_P (node) && TREE_CONSTANT (node))
3ff560b7 254 fputs (" constant", file);
4ee9c684 255 if (TREE_INVARIANT (node))
256 fputs (" invariant", file);
3ff560b7 257 if (TREE_ADDRESSABLE (node))
258 fputs (" addressable", file);
259 if (TREE_THIS_VOLATILE (node))
260 fputs (" volatile", file);
3ff560b7 261 if (TREE_ASM_WRITTEN (node))
262 fputs (" asm_written", file);
263 if (TREE_USED (node))
264 fputs (" used", file);
00dd2e9e 265 if (TREE_NOTHROW (node))
9f5f9308 266 fputs (TYPE_P (node) ? " align-ok" : " nothrow", file);
3ff560b7 267 if (TREE_PUBLIC (node))
268 fputs (" public", file);
c5d7050a 269 if (TREE_PRIVATE (node))
270 fputs (" private", file);
271 if (TREE_PROTECTED (node))
272 fputs (" protected", file);
3ff560b7 273 if (TREE_STATIC (node))
274 fputs (" static", file);
88da234d 275 if (TREE_DEPRECATED (node))
276 fputs (" deprecated", file);
4ee9c684 277 if (TREE_VISITED (node))
278 fputs (" visited", file);
3ff560b7 279 if (TREE_LANG_FLAG_0 (node))
280 fputs (" tree_0", file);
281 if (TREE_LANG_FLAG_1 (node))
282 fputs (" tree_1", file);
283 if (TREE_LANG_FLAG_2 (node))
284 fputs (" tree_2", file);
285 if (TREE_LANG_FLAG_3 (node))
286 fputs (" tree_3", file);
287 if (TREE_LANG_FLAG_4 (node))
288 fputs (" tree_4", file);
289 if (TREE_LANG_FLAG_5 (node))
290 fputs (" tree_5", file);
291 if (TREE_LANG_FLAG_6 (node))
292 fputs (" tree_6", file);
293
294 /* DECL_ nodes have additional attributes. */
295
296 switch (TREE_CODE_CLASS (TREE_CODE (node)))
297 {
298 case 'd':
299 mode = DECL_MODE (node);
300
86ae60fd 301 if (DECL_UNSIGNED (node))
302 fputs (" unsigned", file);
5c5a04c6 303 if (DECL_IGNORED_P (node))
304 fputs (" ignored", file);
305 if (DECL_ABSTRACT (node))
306 fputs (" abstract", file);
307 if (DECL_IN_SYSTEM_HEADER (node))
308 fputs (" in_system_header", file);
309 if (DECL_COMMON (node))
310 fputs (" common", file);
2cf6e2c5 311 if (DECL_EXTERNAL (node))
3ff560b7 312 fputs (" external", file);
5626f4cd 313 if (DECL_WEAK (node))
314 fputs (" weak", file);
ab03e5be 315 if (DECL_REGISTER (node) && TREE_CODE (node) != FIELD_DECL
316 && TREE_CODE (node) != FUNCTION_DECL
317 && TREE_CODE (node) != LABEL_DECL)
3ff560b7 318 fputs (" regdecl", file);
5c5a04c6 319 if (DECL_NONLOCAL (node))
320 fputs (" nonlocal", file);
5c5a04c6 321
322 if (TREE_CODE (node) == TYPE_DECL && TYPE_DECL_SUPPRESS_DEBUG (node))
e770cc2d 323 fputs (" suppress-debug", file);
5c5a04c6 324
746149b7 325 if (TREE_CODE (node) == FUNCTION_DECL && DECL_INLINE (node))
326 fputs (DECL_DECLARED_INLINE_P (node) ? " inline" : " autoinline", file);
5c5a04c6 327 if (TREE_CODE (node) == FUNCTION_DECL && DECL_BUILT_IN (node))
328 fputs (" built-in", file);
ab03e5be 329 if (TREE_CODE (node) == FUNCTION_DECL && DECL_NO_STATIC_CHAIN (node))
330 fputs (" no-static-chain", file);
5c5a04c6 331
b8e0d419 332 if (TREE_CODE (node) == FIELD_DECL && DECL_PACKED (node))
333 fputs (" packed", file);
5c5a04c6 334 if (TREE_CODE (node) == FIELD_DECL && DECL_BIT_FIELD (node))
3ff560b7 335 fputs (" bit-field", file);
9dd6501e 336 if (TREE_CODE (node) == FIELD_DECL && DECL_NONADDRESSABLE_P (node))
337 fputs (" nonaddressable", file);
b8e0d419 338
5c5a04c6 339 if (TREE_CODE (node) == LABEL_DECL && DECL_TOO_LATE (node))
340 fputs (" too-late", file);
ab03e5be 341 if (TREE_CODE (node) == LABEL_DECL && DECL_ERROR_ISSUED (node))
342 fputs (" error-issued", file);
b8e0d419 343
5c5a04c6 344 if (TREE_CODE (node) == VAR_DECL && DECL_IN_TEXT_SECTION (node))
345 fputs (" in-text-section", file);
2a6f0f81 346 if (TREE_CODE (node) == VAR_DECL && DECL_THREAD_LOCAL (node))
347 fputs (" thread-local", file);
5c5a04c6 348
b8e0d419 349 if (TREE_CODE (node) == PARM_DECL && DECL_TRANSPARENT_UNION (node))
350 fputs (" transparent-union", file);
351
3ff560b7 352 if (DECL_VIRTUAL_P (node))
353 fputs (" virtual", file);
5c5a04c6 354 if (DECL_DEFER_OUTPUT (node))
355 fputs (" defer-output", file);
5c5a04c6 356
3ff560b7 357 if (DECL_LANG_FLAG_0 (node))
358 fputs (" decl_0", file);
359 if (DECL_LANG_FLAG_1 (node))
360 fputs (" decl_1", file);
361 if (DECL_LANG_FLAG_2 (node))
362 fputs (" decl_2", file);
363 if (DECL_LANG_FLAG_3 (node))
364 fputs (" decl_3", file);
365 if (DECL_LANG_FLAG_4 (node))
366 fputs (" decl_4", file);
367 if (DECL_LANG_FLAG_5 (node))
368 fputs (" decl_5", file);
369 if (DECL_LANG_FLAG_6 (node))
370 fputs (" decl_6", file);
371 if (DECL_LANG_FLAG_7 (node))
372 fputs (" decl_7", file);
373
47c251e5 374 fprintf (file, " %s", GET_MODE_NAME (mode));
3ff560b7 375 fprintf (file, " file %s line %d",
346064d9 376 DECL_SOURCE_FILE (node), DECL_SOURCE_LINE (node));
3ff560b7 377
378 print_node (file, "size", DECL_SIZE (node), indent + 4);
b278476e 379 print_node (file, "unit size", DECL_SIZE_UNIT (node), indent + 4);
195731ad 380
ab7943b9 381 if (TREE_CODE (node) != FUNCTION_DECL
382 || DECL_INLINE (node) || DECL_BUILT_IN (node))
383 indent_to (file, indent + 3);
384
e5d7f72a 385 if (TREE_CODE (node) != FUNCTION_DECL)
83598ce4 386 {
16de2a82 387 if (DECL_USER_ALIGN (node))
388 fprintf (file, " user");
389
83598ce4 390 fprintf (file, " align %d", DECL_ALIGN (node));
391 if (TREE_CODE (node) == FIELD_DECL)
85aa12f7 392 fprintf (file, " offset_align " HOST_WIDE_INT_PRINT_UNSIGNED,
393 DECL_OFFSET_ALIGN (node));
83598ce4 394 }
e5d7f72a 395 else if (DECL_BUILT_IN (node))
c2ff255e 396 {
397 if (DECL_BUILT_IN_CLASS (node) == BUILT_IN_MD)
398 fprintf (file, " built-in BUILT_IN_MD %d", DECL_FUNCTION_CODE (node));
399 else
400 fprintf (file, " built-in %s:%s",
401 built_in_class_names[(int) DECL_BUILT_IN_CLASS (node)],
402 built_in_names[(int) DECL_FUNCTION_CODE (node)]);
403 }
ab7943b9 404
a5b1863e 405 if (DECL_POINTER_ALIAS_SET_KNOWN_P (node))
85aa12f7 406 fprintf (file, " alias set " HOST_WIDE_INT_PRINT_DEC,
407 DECL_POINTER_ALIAS_SET (node));
ab7943b9 408
409 if (TREE_CODE (node) == FIELD_DECL)
02e7a332 410 {
411 print_node (file, "offset", DECL_FIELD_OFFSET (node), indent + 4);
412 print_node (file, "bit offset", DECL_FIELD_BIT_OFFSET (node),
413 indent + 4);
414 }
ab7943b9 415
3ff560b7 416 print_node_brief (file, "context", DECL_CONTEXT (node), indent + 4);
e3c541f0 417 print_node_brief (file, "attributes",
418 DECL_ATTRIBUTES (node), indent + 4);
f7a75810 419 print_node_brief (file, "abstract_origin",
420 DECL_ABSTRACT_ORIGIN (node), indent + 4);
3ff560b7 421
422 print_node (file, "arguments", DECL_ARGUMENTS (node), indent + 4);
b8e0d419 423 print_node (file, "result", DECL_RESULT_FLD (node), indent + 4);
3ff560b7 424 print_node_brief (file, "initial", DECL_INITIAL (node), indent + 4);
425
dc24ddbd 426 lang_hooks.print_decl (file, node, indent);
3ff560b7 427
0e8e37b2 428 if (DECL_RTL_SET_P (node))
3ff560b7 429 {
430 indent_to (file, indent + 4);
431 print_rtl (file, DECL_RTL (node));
432 }
433
a2ef9391 434 if (TREE_CODE (node) == PARM_DECL)
b8e0d419 435 {
a2ef9391 436 print_node (file, "arg-type", DECL_ARG_TYPE (node), indent + 4);
437 print_node (file, "arg-type-as-written",
438 DECL_ARG_TYPE_AS_WRITTEN (node), indent + 4);
439
440 if (DECL_INCOMING_RTL (node) != 0)
441 {
442 indent_to (file, indent + 4);
443 fprintf (file, "incoming-rtl ");
444 print_rtl (file, DECL_INCOMING_RTL (node));
445 }
b8e0d419 446 }
447 else if (TREE_CODE (node) == FUNCTION_DECL
cbc44df5 448 && DECL_STRUCT_FUNCTION (node) != 0)
3ff560b7 449 {
450 indent_to (file, indent + 4);
6f817829 451 fprintf (file, "saved-insns " HOST_PTR_PRINTF,
cbc44df5 452 (void *) DECL_STRUCT_FUNCTION (node));
3ff560b7 453 }
454
455 /* Print the decl chain only if decl is at second level. */
456 if (indent == 4)
457 print_node (file, "chain", TREE_CHAIN (node), indent + 4);
458 else
459 print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
460 break;
461
462 case 't':
86ae60fd 463 if (TYPE_UNSIGNED (node))
464 fputs (" unsigned", file);
465
2973ed28 466 /* The no-force-blk flag is used for different things in
467 different types. */
468 if ((TREE_CODE (node) == RECORD_TYPE
469 || TREE_CODE (node) == UNION_TYPE
470 || TREE_CODE (node) == QUAL_UNION_TYPE)
471 && TYPE_NO_FORCE_BLK (node))
5c5a04c6 472 fputs (" no-force-blk", file);
2973ed28 473 else if (TREE_CODE (node) == INTEGER_TYPE
474 && TYPE_IS_SIZETYPE (node))
475 fputs (" sizetype", file);
476 else if (TREE_CODE (node) == FUNCTION_TYPE
477 && TYPE_RETURNS_STACK_DEPRESSED (node))
478 fputs (" returns-stack-depressed", file);
479
5c5a04c6 480 if (TYPE_STRING_FLAG (node))
481 fputs (" string-flag", file);
482 if (TYPE_NEEDS_CONSTRUCTING (node))
483 fputs (" needs-constructing", file);
2973ed28 484
8c202488 485 /* The transparent-union flag is used for different things in
486 different nodes. */
2973ed28 487 if (TREE_CODE (node) == UNION_TYPE && TYPE_TRANSPARENT_UNION (node))
488 fputs (" transparent-union", file);
489 else if (TREE_CODE (node) == ARRAY_TYPE
490 && TYPE_NONALIASED_COMPONENT (node))
491 fputs (" nonaliased-component", file);
2973ed28 492
1f1dfbdb 493 if (TYPE_PACKED (node))
494 fputs (" packed", file);
5c5a04c6 495
9063fcc8 496 if (TYPE_RESTRICT (node))
497 fputs (" restrict", file);
498
3ff560b7 499 if (TYPE_LANG_FLAG_0 (node))
500 fputs (" type_0", file);
501 if (TYPE_LANG_FLAG_1 (node))
502 fputs (" type_1", file);
503 if (TYPE_LANG_FLAG_2 (node))
504 fputs (" type_2", file);
505 if (TYPE_LANG_FLAG_3 (node))
506 fputs (" type_3", file);
507 if (TYPE_LANG_FLAG_4 (node))
508 fputs (" type_4", file);
509 if (TYPE_LANG_FLAG_5 (node))
510 fputs (" type_5", file);
511 if (TYPE_LANG_FLAG_6 (node))
512 fputs (" type_6", file);
513
514 mode = TYPE_MODE (node);
47c251e5 515 fprintf (file, " %s", GET_MODE_NAME (mode));
3ff560b7 516
517 print_node (file, "size", TYPE_SIZE (node), indent + 4);
b278476e 518 print_node (file, "unit size", TYPE_SIZE_UNIT (node), indent + 4);
3ff560b7 519 indent_to (file, indent + 3);
520
16de2a82 521 if (TYPE_USER_ALIGN (node))
522 fprintf (file, " user");
523
85aa12f7 524 fprintf (file, " align %d symtab %d alias set " HOST_WIDE_INT_PRINT_DEC,
525 TYPE_ALIGN (node), TYPE_SYMTAB_ADDRESS (node),
526 TYPE_ALIAS_SET (node));
3ff560b7 527
506f531e 528 print_node (file, "attributes", TYPE_ATTRIBUTES (node), indent + 4);
529
16de2a82 530 if (INTEGRAL_TYPE_P (node) || TREE_CODE (node) == REAL_TYPE)
3ff560b7 531 {
532 fprintf (file, " precision %d", TYPE_PRECISION (node));
16de2a82 533 print_node_brief (file, "min", TYPE_MIN_VALUE (node), indent + 4);
534 print_node_brief (file, "max", TYPE_MAX_VALUE (node), indent + 4);
3ff560b7 535 }
16de2a82 536
537 if (TREE_CODE (node) == ENUMERAL_TYPE)
538 print_node (file, "values", TYPE_VALUES (node), indent + 4);
539 else if (TREE_CODE (node) == ARRAY_TYPE || TREE_CODE (node) == SET_TYPE)
540 print_node (file, "domain", TYPE_DOMAIN (node), indent + 4);
7f8a347a 541 else if (TREE_CODE (node) == RECORD_TYPE
542 || TREE_CODE (node) == UNION_TYPE
543 || TREE_CODE (node) == QUAL_UNION_TYPE)
3ff560b7 544 print_node (file, "fields", TYPE_FIELDS (node), indent + 4);
2973ed28 545 else if (TREE_CODE (node) == FUNCTION_TYPE
546 || TREE_CODE (node) == METHOD_TYPE)
3ff560b7 547 {
548 if (TYPE_METHOD_BASETYPE (node))
2973ed28 549 print_node_brief (file, "method basetype",
550 TYPE_METHOD_BASETYPE (node), indent + 4);
3ff560b7 551 print_node (file, "arg-types", TYPE_ARG_TYPES (node), indent + 4);
552 }
777ddd59 553 else if (TREE_CODE (node) == OFFSET_TYPE)
554 print_node_brief (file, "basetype", TYPE_OFFSET_BASETYPE (node),
555 indent + 4);
16de2a82 556
3ff560b7 557 if (TYPE_CONTEXT (node))
558 print_node_brief (file, "context", TYPE_CONTEXT (node), indent + 4);
559
dc24ddbd 560 lang_hooks.print_type (file, node, indent);
3ff560b7 561
562 if (TYPE_POINTER_TO (node) || TREE_CHAIN (node))
563 indent_to (file, indent + 3);
16de2a82 564
565 print_node_brief (file, "pointer_to_this", TYPE_POINTER_TO (node),
566 indent + 4);
567 print_node_brief (file, "reference_to_this", TYPE_REFERENCE_TO (node),
568 indent + 4);
3ff560b7 569 print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
570 break;
571
21b4c21c 572 case 'b':
573 print_node (file, "vars", BLOCK_VARS (node), indent + 4);
21b4c21c 574 print_node (file, "supercontext", BLOCK_SUPERCONTEXT (node), indent + 4);
575 print_node (file, "subblocks", BLOCK_SUBBLOCKS (node), indent + 4);
576 print_node (file, "chain", BLOCK_CHAIN (node), indent + 4);
577 print_node (file, "abstract_origin",
578 BLOCK_ABSTRACT_ORIGIN (node), indent + 4);
cfb5f4ad 579 break;
21b4c21c 580
3ff560b7 581 case 'e':
582 case '<':
583 case '1':
584 case '2':
585 case 'r':
586 case 's':
86ae60fd 587 if (TREE_CODE (node) == BIT_FIELD_REF && BIT_FIELD_REF_UNSIGNED (node))
588 fputs (" unsigned", file);
589 else if (TREE_CODE (node) == SAVE_EXPR && SAVE_EXPR_NOPLACEHOLDER (node))
590 fputs (" noplaceholder", file);
b4dae43c 591 if (TREE_CODE (node) == BIND_EXPR)
3ff560b7 592 {
3ff560b7 593 print_node (file, "vars", TREE_OPERAND (node, 0), indent + 4);
594 print_node (file, "body", TREE_OPERAND (node, 1), indent + 4);
0f0b4dbc 595 print_node (file, "block", TREE_OPERAND (node, 2), indent + 4);
cfb5f4ad 596 break;
3ff560b7 597 }
598
f3c6d29a 599 len = TREE_CODE_LENGTH (TREE_CODE (node));
600
bc280274 601 /* Some nodes contain rtx's, not trees,
3ff560b7 602 after a certain point. Print the rtx's as rtx's. */
bc280274 603 first_rtl = first_rtl_op (TREE_CODE (node));
f3c6d29a 604
3ff560b7 605 for (i = 0; i < len; i++)
606 {
607 if (i >= first_rtl)
608 {
609 indent_to (file, indent + 4);
610 fprintf (file, "rtl %d ", i);
611 if (TREE_OPERAND (node, i))
00ea394c 612 print_rtl (file, (rtx) TREE_OPERAND (node, i));
3ff560b7 613 else
614 fprintf (file, "(nil)");
615 fprintf (file, "\n");
616 }
617 else
618 {
619 char temp[10];
620
621 sprintf (temp, "arg %d", i);
622 print_node (file, temp, TREE_OPERAND (node, i), indent + 4);
623 }
624 }
dae7d8ad 625
4c71ff38 626 print_node (file, "chain", TREE_CHAIN (node), indent + 4);
3ff560b7 627 break;
628
629 case 'c':
630 case 'x':
631 switch (TREE_CODE (node))
632 {
633 case INTEGER_CST:
5575b8e4 634 if (TREE_CONSTANT_OVERFLOW (node))
635 fprintf (file, " overflow");
636
9656bfb2 637 fprintf (file, " ");
3ff560b7 638 if (TREE_INT_CST_HIGH (node) == 0)
9656bfb2 639 fprintf (file, HOST_WIDE_INT_PRINT_UNSIGNED,
b9f6f285 640 TREE_INT_CST_LOW (node));
3ff560b7 641 else if (TREE_INT_CST_HIGH (node) == -1
642 && TREE_INT_CST_LOW (node) != 0)
85aa12f7 643 fprintf (file, "-" HOST_WIDE_INT_PRINT_UNSIGNED,
644 -TREE_INT_CST_LOW (node));
3ff560b7 645 else
9656bfb2 646 fprintf (file, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
b572011e 647 TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
3ff560b7 648 break;
649
650 case REAL_CST:
3ff560b7 651 {
e50f2bd2 652 REAL_VALUE_TYPE d;
653
127c4264 654 if (TREE_OVERFLOW (node))
655 fprintf (file, " overflow");
656
e50f2bd2 657 d = TREE_REAL_CST (node);
127c4264 658 if (REAL_VALUE_ISINF (d))
659 fprintf (file, " Inf");
660 else if (REAL_VALUE_ISNAN (d))
661 fprintf (file, " Nan");
662 else
663 {
c7fbc741 664 char string[64];
665 real_to_decimal (string, &d, sizeof (string), 0, 1);
127c4264 666 fprintf (file, " %s", string);
667 }
3ff560b7 668 }
3ff560b7 669 break;
670
886cfd4f 671 case VECTOR_CST:
672 {
673 tree vals = TREE_VECTOR_CST_ELTS (node);
674 char buf[10];
675 tree link;
676 int i;
677
678 i = 0;
679 for (link = vals; link; link = TREE_CHAIN (link), ++i)
680 {
681 sprintf (buf, "elt%d: ", i);
682 print_node (file, buf, TREE_VALUE (link), indent + 4);
683 }
684 }
685 break;
686
3ff560b7 687 case COMPLEX_CST:
688 print_node (file, "real", TREE_REALPART (node), indent + 4);
689 print_node (file, "imag", TREE_IMAGPART (node), indent + 4);
690 break;
691
692 case STRING_CST:
7eb2fa37 693 {
694 const char *p = TREE_STRING_POINTER (node);
695 int i = TREE_STRING_LENGTH (node);
696 fputs (" \"", file);
697 while (--i >= 0)
698 {
699 char ch = *p++;
700 if (ch >= ' ' && ch < 127)
701 putc (ch, file);
702 else
703 fprintf(file, "\\%03o", ch & 0xFF);
704 }
705 fputc ('\"', file);
706 }
0dc2bbb8 707 /* Print the chain at second level. */
708 if (indent == 4)
709 print_node (file, "chain", TREE_CHAIN (node), indent + 4);
710 else
711 print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
3ff560b7 712 break;
713
714 case IDENTIFIER_NODE:
dc24ddbd 715 lang_hooks.print_identifier (file, node, indent);
3ff560b7 716 break;
717
718 case TREE_LIST:
719 print_node (file, "purpose", TREE_PURPOSE (node), indent + 4);
720 print_node (file, "value", TREE_VALUE (node), indent + 4);
721 print_node (file, "chain", TREE_CHAIN (node), indent + 4);
722 break;
723
724 case TREE_VEC:
725 len = TREE_VEC_LENGTH (node);
726 for (i = 0; i < len; i++)
0b68d9e6 727 if (TREE_VEC_ELT (node, i))
728 {
729 char temp[10];
730 sprintf (temp, "elt %d", i);
731 indent_to (file, indent + 4);
732 print_node_brief (file, temp, TREE_VEC_ELT (node, i), 0);
733 }
3ff560b7 734 break;
735
b4dae43c 736 default:
c83f9123 737 if (TREE_CODE_CLASS (TREE_CODE (node)) == 'x')
dc24ddbd 738 lang_hooks.print_xnode (file, node, indent);
b4dae43c 739 break;
3ff560b7 740 }
741
742 break;
743 }
9e718c95 744
4ee9c684 745 if (EXPR_HAS_LOCATION (node))
746 {
747 indent_to (file, indent+4);
748 fprintf (file, "%s:%d",
749 EXPR_FILENAME (node),
750 EXPR_LINENO (node));
751 }
752
9e718c95 753 fprintf (file, ">");
3ff560b7 754}
Mirror of https://gcc.gnu.org/git/gcc.git