]> git.ipfire.org Git - thirdparty/gcc.git/blame - gcc/tree-pretty-print.c
projects / thirdparty / gcc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Update Copyright years for files modified in 2011 and/or 2012.
[thirdparty/gcc.git] / gcc / tree-pretty-print.c
CommitLineData
4ee9c684 1/* Pretty formatting of GENERIC trees in C syntax.
fe1fdd37 2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
71e45bc2 3 2011, 2012 Free Software Foundation, Inc.
4ee9c684 4 Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
5
6This file is part of GCC.
7
8GCC is free software; you can redistribute it and/or modify it under
9the terms of the GNU General Public License as published by the Free
8c4c00c1 10Software Foundation; either version 3, or (at your option) any later
4ee9c684 11version.
12
13GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14WARRANTY; without even the implied warranty of MERCHANTABILITY or
15FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16for more details.
17
18You should have received a copy of the GNU General Public License
8c4c00c1 19along with GCC; see the file COPYING3. If not see
20<http://www.gnu.org/licenses/>. */
4ee9c684 21
22#include "config.h"
23#include "system.h"
24#include "coretypes.h"
25#include "tm.h"
4ee9c684 26#include "tree.h"
ce084dfc 27#include "tree-pretty-print.h"
4ee9c684 28#include "hashtab.h"
29#include "tree-flow.h"
30#include "langhooks.h"
31#include "tree-iterator.h"
101d9422 32#include "tree-chrec.h"
b9ed1410 33#include "dumpfile.h"
4992f399 34#include "value-prof.h"
4a1849e3 35#include "predict.h"
4ee9c684 36
37/* Local functions, macros and variables. */
b4b34335 38static const char *op_symbol (const_tree);
4ee9c684 39static void pretty_print_string (pretty_printer *, const char*);
4ee9c684 40static void newline_and_indent (pretty_printer *, int);
41static void maybe_init_pretty_print (FILE *);
b4b34335 42static void print_struct_decl (pretty_printer *, const_tree, int, int);
43static void do_niy (pretty_printer *, const_tree);
4ee9c684 44
45#define INDENT(SPACE) do { \
46 int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)
47
48#define NIY do_niy(buffer,node)
49
4ee9c684 50static pretty_printer buffer;
51static int initialized = 0;
4ee9c684 52
53/* Try to print something for an unknown tree code. */
54
55static void
b4b34335 56do_niy (pretty_printer *buffer, const_tree node)
4ee9c684 57{
58 int i, len;
59
60 pp_string (buffer, "<<< Unknown tree: ");
61 pp_string (buffer, tree_code_name[(int) TREE_CODE (node)]);
62
ce45a448 63 if (EXPR_P (node))
4ee9c684 64 {
c2f47e15 65 len = TREE_OPERAND_LENGTH (node);
4ee9c684 66 for (i = 0; i < len; ++i)
67 {
68 newline_and_indent (buffer, 2);
69 dump_generic_node (buffer, TREE_OPERAND (node, i), 2, 0, false);
70 }
71 }
72
5c304dd0 73 pp_string (buffer, " >>>");
4ee9c684 74}
75
4726380a 76/* Debugging function to print out a generic expression. */
77
4b987fac 78DEBUG_FUNCTION void
4ee9c684 79debug_generic_expr (tree t)
80{
4fb5e5ca 81 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS);
4ee9c684 82 fprintf (stderr, "\n");
83}
84
4726380a 85/* Debugging function to print out a generic statement. */
86
4b987fac 87DEBUG_FUNCTION void
4ee9c684 88debug_generic_stmt (tree t)
89{
4fb5e5ca 90 print_generic_stmt (stderr, t, TDF_VOPS|TDF_MEMSYMS);
4ee9c684 91 fprintf (stderr, "\n");
92}
93
4726380a 94/* Debugging function to print out a chain of trees . */
95
4b987fac 96DEBUG_FUNCTION void
1e8e9920 97debug_tree_chain (tree t)
98{
77c223c3 99 struct pointer_set_t *seen = pointer_set_create ();
100
4d735392 101 while (t)
77c223c3 102 {
103 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);
104 fprintf (stderr, " ");
105 t = TREE_CHAIN (t);
106 if (pointer_set_insert (seen, t))
107 {
108 fprintf (stderr, "... [cycled back to ");
109 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);
110 fprintf (stderr, "]");
111 break;
112 }
113 }
1e8e9920 114 fprintf (stderr, "\n");
77c223c3 115
116 pointer_set_destroy (seen);
1e8e9920 117}
118
4ee9c684 119/* Prints declaration DECL to the FILE with details specified by FLAGS. */
120void
121print_generic_decl (FILE *file, tree decl, int flags)
122{
123 maybe_init_pretty_print (file);
4ee9c684 124 print_declaration (&buffer, decl, 2, flags);
125 pp_write_text_to_stream (&buffer);
126}
127
128/* Print tree T, and its successors, on file FILE. FLAGS specifies details
b9ed1410 129 to show in the dump. See TDF_* in dumpfile.h. */
4ee9c684 130
131void
132print_generic_stmt (FILE *file, tree t, int flags)
133{
134 maybe_init_pretty_print (file);
4ee9c684 135 dump_generic_node (&buffer, t, 0, flags, true);
5f7f600e 136 pp_newline_and_flush (&buffer);
4ee9c684 137}
138
139/* Print tree T, and its successors, on file FILE. FLAGS specifies details
b9ed1410 140 to show in the dump. See TDF_* in dumpfile.h. The output is indented by
4ee9c684 141 INDENT spaces. */
142
143void
144print_generic_stmt_indented (FILE *file, tree t, int flags, int indent)
145{
146 int i;
147
148 maybe_init_pretty_print (file);
4ee9c684 149
150 for (i = 0; i < indent; i++)
151 pp_space (&buffer);
152 dump_generic_node (&buffer, t, indent, flags, true);
5f7f600e 153 pp_newline_and_flush (&buffer);
4ee9c684 154}
155
156/* Print a single expression T on file FILE. FLAGS specifies details to show
b9ed1410 157 in the dump. See TDF_* in dumpfile.h. */
4ee9c684 158
159void
160print_generic_expr (FILE *file, tree t, int flags)
161{
162 maybe_init_pretty_print (file);
4ee9c684 163 dump_generic_node (&buffer, t, 0, flags, false);
229c964b 164 pp_flush (&buffer);
4ee9c684 165}
166
167/* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
168 in FLAGS. */
169
170static void
171dump_decl_name (pretty_printer *buffer, tree node, int flags)
172{
8c1f2562 173 if (DECL_NAME (node))
174 {
175 if ((flags & TDF_ASMNAME) && DECL_ASSEMBLER_NAME_SET_P (node))
176 pp_tree_identifier (buffer, DECL_ASSEMBLER_NAME (node));
177 else
178 pp_tree_identifier (buffer, DECL_NAME (node));
179 }
180 if ((flags & TDF_UID) || DECL_NAME (node) == NULL_TREE)
4ee9c684 181 {
8c1f2562 182 if (TREE_CODE (node) == LABEL_DECL && LABEL_DECL_UID (node) != -1)
00753696 183 pp_printf (buffer, "L.%d", (int) LABEL_DECL_UID (node));
688ff29b 184 else if (TREE_CODE (node) == DEBUG_EXPR_DECL)
00753696 185 {
186 if (flags & TDF_NOUID)
187 pp_string (buffer, "D#xxxx");
188 else
189 pp_printf (buffer, "D#%i", DEBUG_TEMP_UID (node));
190 }
4d735392 191 else
e67e5e1f 192 {
8c1f2562 193 char c = TREE_CODE (node) == CONST_DECL ? 'C' : 'D';
00753696 194 if (flags & TDF_NOUID)
195 pp_printf (buffer, "%c.xxxx", c);
196 else
197 pp_printf (buffer, "%c.%u", c, DECL_UID (node));
e67e5e1f 198 }
4ee9c684 199 }
1a981e1a 200 if ((flags & TDF_ALIAS) && DECL_PT_UID (node) != DECL_UID (node))
201 {
202 if (flags & TDF_NOUID)
203 pp_printf (buffer, "ptD.xxxx");
204 else
205 pp_printf (buffer, "ptD.%u", DECL_PT_UID (node));
206 }
4ee9c684 207}
208
a1080ab2 209/* Like the above, but used for pretty printing function calls. */
210
211static void
8c1f2562 212dump_function_name (pretty_printer *buffer, tree node, int flags)
a1080ab2 213{
8c1f2562 214 if (TREE_CODE (node) == NOP_EXPR)
215 node = TREE_OPERAND (node, 0);
216 if (DECL_NAME (node) && (flags & TDF_ASMNAME) == 0)
217 pp_string (buffer, lang_hooks.decl_printable_name (node, 1));
a1080ab2 218 else
8c1f2562 219 dump_decl_name (buffer, node, flags);
a1080ab2 220}
221
d700b485 222/* Dump a function declaration. NODE is the FUNCTION_TYPE. BUFFER, SPC and
223 FLAGS are as in dump_generic_node. */
224
225static void
226dump_function_declaration (pretty_printer *buffer, tree node,
227 int spc, int flags)
228{
229 bool wrote_arg = false;
230 tree arg;
231
232 pp_space (buffer);
233 pp_character (buffer, '(');
234
8eb81823 235 /* Print the argument types. */
d700b485 236 arg = TYPE_ARG_TYPES (node);
8eb81823 237 while (arg && arg != void_list_node && arg != error_mark_node)
d700b485 238 {
8eb81823 239 if (wrote_arg)
d700b485 240 {
241 pp_character (buffer, ',');
242 pp_space (buffer);
243 }
8eb81823 244 wrote_arg = true;
245 dump_generic_node (buffer, TREE_VALUE (arg), spc, flags, false);
246 arg = TREE_CHAIN (arg);
d700b485 247 }
248
8eb81823 249 /* Drop the trailing void_type_node if we had any previous argument. */
250 if (arg == void_list_node && !wrote_arg)
d700b485 251 pp_string (buffer, "void");
8eb81823 252 /* Properly dump vararg function types. */
253 else if (!arg && wrote_arg)
254 pp_string (buffer, ", ...");
255 /* Avoid printing any arg for unprototyped functions. */
d700b485 256
257 pp_character (buffer, ')');
258}
259
9b1a6180 260/* Dump the domain associated with an array. */
261
262static void
263dump_array_domain (pretty_printer *buffer, tree domain, int spc, int flags)
264{
265 pp_character (buffer, '[');
266 if (domain)
267 {
268 tree min = TYPE_MIN_VALUE (domain);
269 tree max = TYPE_MAX_VALUE (domain);
270
271 if (min && max
272 && integer_zerop (min)
273 && host_integerp (max, 0))
274 pp_wide_integer (buffer, TREE_INT_CST_LOW (max) + 1);
275 else
276 {
277 if (min)
278 dump_generic_node (buffer, min, spc, flags, false);
279 pp_character (buffer, ':');
280 if (max)
281 dump_generic_node (buffer, max, spc, flags, false);
282 }
283 }
284 else
285 pp_string (buffer, "<unknown>");
286 pp_character (buffer, ']');
287}
288
55d6e7cd 289
290/* Dump OpenMP clause CLAUSE. BUFFER, CLAUSE, SPC and FLAGS are as in
291 dump_generic_node. */
1e8e9920 292
293static void
55d6e7cd 294dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)
1e8e9920 295{
296 const char *name;
297
55d6e7cd 298 switch (OMP_CLAUSE_CODE (clause))
1e8e9920 299 {
55d6e7cd 300 case OMP_CLAUSE_PRIVATE:
301 name = "private";
302 goto print_remap;
303 case OMP_CLAUSE_SHARED:
304 name = "shared";
305 goto print_remap;
306 case OMP_CLAUSE_FIRSTPRIVATE:
307 name = "firstprivate";
308 goto print_remap;
309 case OMP_CLAUSE_LASTPRIVATE:
310 name = "lastprivate";
311 goto print_remap;
312 case OMP_CLAUSE_COPYIN:
313 name = "copyin";
314 goto print_remap;
315 case OMP_CLAUSE_COPYPRIVATE:
316 name = "copyprivate";
317 goto print_remap;
318 print_remap:
319 pp_string (buffer, name);
320 pp_character (buffer, '(');
321 dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
322 spc, flags, false);
323 pp_character (buffer, ')');
324 break;
1e8e9920 325
55d6e7cd 326 case OMP_CLAUSE_REDUCTION:
327 pp_string (buffer, "reduction(");
ad4a85ad 328 pp_string (buffer, op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause)));
55d6e7cd 329 pp_character (buffer, ':');
330 dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
331 spc, flags, false);
332 pp_character (buffer, ')');
333 break;
1e8e9920 334
55d6e7cd 335 case OMP_CLAUSE_IF:
336 pp_string (buffer, "if(");
337 dump_generic_node (buffer, OMP_CLAUSE_IF_EXPR (clause),
338 spc, flags, false);
339 pp_character (buffer, ')');
340 break;
1e8e9920 341
55d6e7cd 342 case OMP_CLAUSE_NUM_THREADS:
343 pp_string (buffer, "num_threads(");
344 dump_generic_node (buffer, OMP_CLAUSE_NUM_THREADS_EXPR (clause),
345 spc, flags, false);
346 pp_character (buffer, ')');
347 break;
1e8e9920 348
55d6e7cd 349 case OMP_CLAUSE_NOWAIT:
350 pp_string (buffer, "nowait");
351 break;
352 case OMP_CLAUSE_ORDERED:
353 pp_string (buffer, "ordered");
354 break;
1e8e9920 355
55d6e7cd 356 case OMP_CLAUSE_DEFAULT:
357 pp_string (buffer, "default(");
358 switch (OMP_CLAUSE_DEFAULT_KIND (clause))
359 {
fd6481cf 360 case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
361 break;
362 case OMP_CLAUSE_DEFAULT_SHARED:
363 pp_string (buffer, "shared");
364 break;
365 case OMP_CLAUSE_DEFAULT_NONE:
366 pp_string (buffer, "none");
367 break;
368 case OMP_CLAUSE_DEFAULT_PRIVATE:
369 pp_string (buffer, "private");
370 break;
371 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:
372 pp_string (buffer, "firstprivate");
373 break;
374 default:
375 gcc_unreachable ();
55d6e7cd 376 }
377 pp_character (buffer, ')');
378 break;
1e8e9920 379
55d6e7cd 380 case OMP_CLAUSE_SCHEDULE:
381 pp_string (buffer, "schedule(");
382 switch (OMP_CLAUSE_SCHEDULE_KIND (clause))
383 {
384 case OMP_CLAUSE_SCHEDULE_STATIC:
385 pp_string (buffer, "static");
386 break;
387 case OMP_CLAUSE_SCHEDULE_DYNAMIC:
388 pp_string (buffer, "dynamic");
389 break;
390 case OMP_CLAUSE_SCHEDULE_GUIDED:
391 pp_string (buffer, "guided");
392 break;
393 case OMP_CLAUSE_SCHEDULE_RUNTIME:
394 pp_string (buffer, "runtime");
395 break;
fd6481cf 396 case OMP_CLAUSE_SCHEDULE_AUTO:
397 pp_string (buffer, "auto");
398 break;
55d6e7cd 399 default:
400 gcc_unreachable ();
1e8e9920 401 }
55d6e7cd 402 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))
403 {
404 pp_character (buffer, ',');
405 dump_generic_node (buffer,
406 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause),
407 spc, flags, false);
408 }
409 pp_character (buffer, ')');
410 break;
411
fd6481cf 412 case OMP_CLAUSE_UNTIED:
413 pp_string (buffer, "untied");
414 break;
415
416 case OMP_CLAUSE_COLLAPSE:
417 pp_string (buffer, "collapse(");
418 dump_generic_node (buffer,
419 OMP_CLAUSE_COLLAPSE_EXPR (clause),
420 spc, flags, false);
421 pp_character (buffer, ')');
422 break;
423
2169f33b 424 case OMP_CLAUSE_FINAL:
425 pp_string (buffer, "final(");
426 dump_generic_node (buffer, OMP_CLAUSE_FINAL_EXPR (clause),
427 spc, flags, false);
428 pp_character (buffer, ')');
429 break;
430
431 case OMP_CLAUSE_MERGEABLE:
432 pp_string (buffer, "mergeable");
433 break;
434
55d6e7cd 435 default:
436 /* Should never happen. */
437 dump_generic_node (buffer, clause, spc, flags, false);
438 break;
439 }
440}
441
442
443/* Dump the list of OpenMP clauses. BUFFER, SPC and FLAGS are as in
444 dump_generic_node. */
445
75a70cf9 446void
55d6e7cd 447dump_omp_clauses (pretty_printer *buffer, tree clause, int spc, int flags)
448{
449 if (clause == NULL)
450 return;
1e8e9920 451
55d6e7cd 452 pp_space (buffer);
453 while (1)
454 {
455 dump_omp_clause (buffer, clause, spc, flags);
1e8e9920 456 clause = OMP_CLAUSE_CHAIN (clause);
457 if (clause == NULL)
458 return;
459 pp_space (buffer);
460 }
461}
462
55d6e7cd 463
7aa082e5 464/* Dump location LOC to BUFFER. */
465
466static void
467dump_location (pretty_printer *buffer, location_t loc)
468{
469 expanded_location xloc = expand_location (loc);
470
471 pp_character (buffer, '[');
472 if (xloc.file)
473 {
474 pp_string (buffer, xloc.file);
475 pp_string (buffer, " : ");
476 }
477 pp_decimal_int (buffer, xloc.line);
478 pp_string (buffer, "] ");
479}
480
481
482/* Dump lexical block BLOCK. BUFFER, SPC and FLAGS are as in
483 dump_generic_node. */
484
485static void
486dump_block_node (pretty_printer *buffer, tree block, int spc, int flags)
487{
488 tree t;
489
490 pp_printf (buffer, "BLOCK #%d ", BLOCK_NUMBER (block));
491
492 if (flags & TDF_ADDRESS)
493 pp_printf (buffer, "[%p] ", (void *) block);
494
495 if (BLOCK_ABSTRACT (block))
496 pp_string (buffer, "[abstract] ");
497
498 if (TREE_ASM_WRITTEN (block))
499 pp_string (buffer, "[written] ");
500
501 if (flags & TDF_SLIM)
502 return;
503
504 if (BLOCK_SOURCE_LOCATION (block))
505 dump_location (buffer, BLOCK_SOURCE_LOCATION (block));
506
507 newline_and_indent (buffer, spc + 2);
508
509 if (BLOCK_SUPERCONTEXT (block))
510 {
511 pp_string (buffer, "SUPERCONTEXT: ");
512 dump_generic_node (buffer, BLOCK_SUPERCONTEXT (block), 0,
513 flags | TDF_SLIM, false);
514 newline_and_indent (buffer, spc + 2);
515 }
516
517 if (BLOCK_SUBBLOCKS (block))
518 {
519 pp_string (buffer, "SUBBLOCKS: ");
520 for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t))
521 {
522 dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false);
523 pp_string (buffer, " ");
524 }
525 newline_and_indent (buffer, spc + 2);
526 }
527
528 if (BLOCK_CHAIN (block))
529 {
530 pp_string (buffer, "SIBLINGS: ");
531 for (t = BLOCK_CHAIN (block); t; t = BLOCK_CHAIN (t))
532 {
533 dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false);
534 pp_string (buffer, " ");
535 }
536 newline_and_indent (buffer, spc + 2);
537 }
538
539 if (BLOCK_VARS (block))
540 {
541 pp_string (buffer, "VARS: ");
542 for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t))
543 {
544 dump_generic_node (buffer, t, 0, flags, false);
545 pp_string (buffer, " ");
546 }
547 newline_and_indent (buffer, spc + 2);
548 }
549
f1f41a6c 550 if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block)) > 0)
7aa082e5 551 {
552 unsigned i;
f1f41a6c 553 vec<tree, va_gc> *nlv = BLOCK_NONLOCALIZED_VARS (block);
7aa082e5 554
555 pp_string (buffer, "NONLOCALIZED_VARS: ");
f1f41a6c 556 FOR_EACH_VEC_ELT (*nlv, i, t)
7aa082e5 557 {
558 dump_generic_node (buffer, t, 0, flags, false);
559 pp_string (buffer, " ");
560 }
561 newline_and_indent (buffer, spc + 2);
562 }
563
564 if (BLOCK_ABSTRACT_ORIGIN (block))
565 {
566 pp_string (buffer, "ABSTRACT_ORIGIN: ");
567 dump_generic_node (buffer, BLOCK_ABSTRACT_ORIGIN (block), 0,
568 flags | TDF_SLIM, false);
569 newline_and_indent (buffer, spc + 2);
570 }
571
572 if (BLOCK_FRAGMENT_ORIGIN (block))
573 {
574 pp_string (buffer, "FRAGMENT_ORIGIN: ");
575 dump_generic_node (buffer, BLOCK_FRAGMENT_ORIGIN (block), 0,
576 flags | TDF_SLIM, false);
577 newline_and_indent (buffer, spc + 2);
578 }
579
580 if (BLOCK_FRAGMENT_CHAIN (block))
581 {
582 pp_string (buffer, "FRAGMENT_CHAIN: ");
583 for (t = BLOCK_FRAGMENT_CHAIN (block); t; t = BLOCK_FRAGMENT_CHAIN (t))
584 {
585 dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false);
586 pp_string (buffer, " ");
587 }
588 newline_and_indent (buffer, spc + 2);
589 }
590}
591
592
46412a37 593/* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of
594 indent. FLAGS specifies details to show in the dump (see TDF_* in
b9ed1410 595 dumpfile.h). If IS_STMT is true, the object printed is considered
46412a37 596 to be a statement and it is terminated by ';' if appropriate. */
4ee9c684 597
598int
599dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
600 bool is_stmt)
601{
602 tree type;
603 tree op0, op1;
d700b485 604 const char *str;
4ee9c684 605 bool is_expr;
79a78f7f 606 enum tree_code code;
4ee9c684 607
608 if (node == NULL_TREE)
609 return spc;
610
75a70cf9 611 is_expr = EXPR_P (node);
4ee9c684 612
22aa74c4 613 if (is_stmt && (flags & TDF_STMTADDR))
f3a60048 614 pp_printf (buffer, "<&%p> ", (void *)node);
22aa74c4 615
1e8e9920 616 if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node))
7aa082e5 617 dump_location (buffer, EXPR_LOCATION (node));
4ee9c684 618
79a78f7f 619 code = TREE_CODE (node);
620 switch (code)
4ee9c684 621 {
622 case ERROR_MARK:
623 pp_string (buffer, "<<< error >>>");
624 break;
625
626 case IDENTIFIER_NODE:
627 pp_tree_identifier (buffer, node);
628 break;
629
630 case TREE_LIST:
631 while (node && node != error_mark_node)
632 {
633 if (TREE_PURPOSE (node))
634 {
635 dump_generic_node (buffer, TREE_PURPOSE (node), spc, flags, false);
636 pp_space (buffer);
637 }
638 dump_generic_node (buffer, TREE_VALUE (node), spc, flags, false);
639 node = TREE_CHAIN (node);
640 if (node && TREE_CODE (node) == TREE_LIST)
641 {
642 pp_character (buffer, ',');
643 pp_space (buffer);
644 }
645 }
646 break;
647
dce3d064 648 case TREE_BINFO:
4ee9c684 649 dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false);
c6934f8a 650 break;
dce3d064 651
652 case TREE_VEC:
653 {
654 size_t i;
655 if (TREE_VEC_LENGTH (node) > 0)
656 {
657 size_t len = TREE_VEC_LENGTH (node);
658 for (i = 0; i < len - 1; i++)
48e1416a 659 {
dce3d064 660 dump_generic_node (buffer, TREE_VEC_ELT (node, i), spc, flags,
661 false);
662 pp_character (buffer, ',');
663 pp_space (buffer);
664 }
48e1416a 665 dump_generic_node (buffer, TREE_VEC_ELT (node, len - 1), spc,
dce3d064 666 flags, false);
667 }
668 }
4ee9c684 669 break;
670
4ee9c684 671 case VOID_TYPE:
672 case INTEGER_TYPE:
673 case REAL_TYPE:
06f0b99c 674 case FIXED_POINT_TYPE:
4ee9c684 675 case COMPLEX_TYPE:
676 case VECTOR_TYPE:
677 case ENUMERAL_TYPE:
678 case BOOLEAN_TYPE:
4ee9c684 679 {
680 unsigned int quals = TYPE_QUALS (node);
f4e36c33 681 enum tree_code_class tclass;
4ee9c684 682
683 if (quals & TYPE_QUAL_CONST)
684 pp_string (buffer, "const ");
685 else if (quals & TYPE_QUAL_VOLATILE)
686 pp_string (buffer, "volatile ");
687 else if (quals & TYPE_QUAL_RESTRICT)
688 pp_string (buffer, "restrict ");
689
bd1a81f7 690 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
691 {
692 pp_string (buffer, "<address-space-");
693 pp_decimal_int (buffer, TYPE_ADDR_SPACE (node));
694 pp_string (buffer, "> ");
695 }
696
f4e36c33 697 tclass = TREE_CODE_CLASS (TREE_CODE (node));
4ee9c684 698
f4e36c33 699 if (tclass == tcc_declaration)
4ee9c684 700 {
701 if (DECL_NAME (node))
702 dump_decl_name (buffer, node, flags);
703 else
704 pp_string (buffer, "<unnamed type decl>");
705 }
f4e36c33 706 else if (tclass == tcc_type)
4ee9c684 707 {
708 if (TYPE_NAME (node))
709 {
710 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
711 pp_tree_identifier (buffer, TYPE_NAME (node));
712 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
713 && DECL_NAME (TYPE_NAME (node)))
714 dump_decl_name (buffer, TYPE_NAME (node), flags);
715 else
5d8f2392 716 pp_string (buffer, "<unnamed type>");
717 }
718 else if (TREE_CODE (node) == VECTOR_TYPE)
719 {
d2d3b1ae 720 pp_string (buffer, "vector");
721 pp_character (buffer, '(');
722 pp_wide_integer (buffer, TYPE_VECTOR_SUBPARTS (node));
723 pp_string (buffer, ") ");
c6934f8a 724 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
4ee9c684 725 }
e4e0b898 726 else if (TREE_CODE (node) == INTEGER_TYPE)
727 {
0177b1e3 728 if (TYPE_PRECISION (node) == CHAR_TYPE_SIZE)
729 pp_string (buffer, (TYPE_UNSIGNED (node)
730 ? "unsigned char"
731 : "signed char"));
732 else if (TYPE_PRECISION (node) == SHORT_TYPE_SIZE)
733 pp_string (buffer, (TYPE_UNSIGNED (node)
734 ? "unsigned short"
735 : "signed short"));
736 else if (TYPE_PRECISION (node) == INT_TYPE_SIZE)
737 pp_string (buffer, (TYPE_UNSIGNED (node)
738 ? "unsigned int"
739 : "signed int"));
740 else if (TYPE_PRECISION (node) == LONG_TYPE_SIZE)
741 pp_string (buffer, (TYPE_UNSIGNED (node)
742 ? "unsigned long"
743 : "signed long"));
744 else if (TYPE_PRECISION (node) == LONG_LONG_TYPE_SIZE)
745 pp_string (buffer, (TYPE_UNSIGNED (node)
746 ? "unsigned long long"
747 : "signed long long"));
748 else if (TYPE_PRECISION (node) >= CHAR_TYPE_SIZE
69435ea2 749 && exact_log2 (TYPE_PRECISION (node)) != -1)
0177b1e3 750 {
751 pp_string (buffer, (TYPE_UNSIGNED (node) ? "uint" : "int"));
752 pp_decimal_int (buffer, TYPE_PRECISION (node));
753 pp_string (buffer, "_t");
754 }
755 else
756 {
757 pp_string (buffer, (TYPE_UNSIGNED (node)
758 ? "<unnamed-unsigned:"
759 : "<unnamed-signed:"));
760 pp_decimal_int (buffer, TYPE_PRECISION (node));
761 pp_string (buffer, ">");
762 }
e4e0b898 763 }
c6934f8a 764 else if (TREE_CODE (node) == COMPLEX_TYPE)
765 {
766 pp_string (buffer, "__complex__ ");
767 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
768 }
769 else if (TREE_CODE (node) == REAL_TYPE)
770 {
771 pp_string (buffer, "<float:");
772 pp_decimal_int (buffer, TYPE_PRECISION (node));
773 pp_string (buffer, ">");
774 }
775 else if (TREE_CODE (node) == FIXED_POINT_TYPE)
776 {
777 pp_string (buffer, "<fixed-point-");
778 pp_string (buffer, TYPE_SATURATING (node) ? "sat:" : "nonsat:");
779 pp_decimal_int (buffer, TYPE_PRECISION (node));
780 pp_string (buffer, ">");
781 }
d91b94e0 782 else if (TREE_CODE (node) == VOID_TYPE)
783 pp_string (buffer, "void");
4ee9c684 784 else
785 pp_string (buffer, "<unnamed type>");
786 }
787 break;
788 }
789
790 case POINTER_TYPE:
791 case REFERENCE_TYPE:
792 str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&");
793
c6934f8a 794 if (TREE_TYPE (node) == NULL)
795 {
796 pp_string (buffer, str);
797 pp_string (buffer, "<null type>");
798 }
799 else if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)
4ee9c684 800 {
801 tree fnode = TREE_TYPE (node);
d700b485 802
4ee9c684 803 dump_generic_node (buffer, TREE_TYPE (fnode), spc, flags, false);
804 pp_space (buffer);
805 pp_character (buffer, '(');
806 pp_string (buffer, str);
807 if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
808 dump_decl_name (buffer, TYPE_NAME (node), flags);
12e18540 809 else if (flags & TDF_NOUID)
810 pp_printf (buffer, "<Txxxx>");
4ee9c684 811 else
812 pp_printf (buffer, "<T%x>", TYPE_UID (node));
813
814 pp_character (buffer, ')');
d700b485 815 dump_function_declaration (buffer, fnode, spc, flags);
4ee9c684 816 }
817 else
818 {
819 unsigned int quals = TYPE_QUALS (node);
820
821 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
822 pp_space (buffer);
823 pp_string (buffer, str);
824
825 if (quals & TYPE_QUAL_CONST)
826 pp_string (buffer, " const");
d3828421 827 if (quals & TYPE_QUAL_VOLATILE)
828 pp_string (buffer, " volatile");
829 if (quals & TYPE_QUAL_RESTRICT)
4ee9c684 830 pp_string (buffer, " restrict");
90cea464 831
bd1a81f7 832 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
833 {
834 pp_string (buffer, " <address-space-");
835 pp_decimal_int (buffer, TYPE_ADDR_SPACE (node));
836 pp_string (buffer, ">");
837 }
838
90cea464 839 if (TYPE_REF_CAN_ALIAS_ALL (node))
840 pp_string (buffer, " {ref-all}");
4ee9c684 841 }
842 break;
843
844 case OFFSET_TYPE:
845 NIY;
846 break;
847
182cf5a9 848 case MEM_REF:
849 {
850 if (integer_zerop (TREE_OPERAND (node, 1))
d6f21aeb 851 /* Dump the types of INTEGER_CSTs explicitly, for we can't
852 infer them and MEM_ATTR caching will share MEM_REFs
853 with differently-typed op0s. */
854 && TREE_CODE (TREE_OPERAND (node, 0)) != INTEGER_CST
ff2d70df 855 /* Released SSA_NAMES have no TREE_TYPE. */
856 && TREE_TYPE (TREE_OPERAND (node, 0)) != NULL_TREE
182cf5a9 857 /* Same pointer types, but ignoring POINTER_TYPE vs.
858 REFERENCE_TYPE. */
859 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 0)))
860 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1))))
861 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 0)))
862 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 1))))
863 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 0)))
864 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 1))))
182cf5a9 865 /* Same value types ignoring qualifiers. */
866 && (TYPE_MAIN_VARIANT (TREE_TYPE (node))
867 == TYPE_MAIN_VARIANT
868 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1))))))
869 {
870 if (TREE_CODE (TREE_OPERAND (node, 0)) != ADDR_EXPR)
871 {
872 pp_string (buffer, "*");
873 dump_generic_node (buffer, TREE_OPERAND (node, 0),
874 spc, flags, false);
875 }
876 else
877 dump_generic_node (buffer,
878 TREE_OPERAND (TREE_OPERAND (node, 0), 0),
879 spc, flags, false);
880 }
881 else
882 {
87b8feeb 883 tree ptype;
884
182cf5a9 885 pp_string (buffer, "MEM[");
886 pp_string (buffer, "(");
87b8feeb 887 ptype = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node, 1)));
888 dump_generic_node (buffer, ptype,
5db1bdc2 889 spc, flags | TDF_SLIM, false);
182cf5a9 890 pp_string (buffer, ")");
891 dump_generic_node (buffer, TREE_OPERAND (node, 0),
892 spc, flags, false);
893 if (!integer_zerop (TREE_OPERAND (node, 1)))
894 {
895 pp_string (buffer, " + ");
896 dump_generic_node (buffer, TREE_OPERAND (node, 1),
897 spc, flags, false);
898 }
899 pp_string (buffer, "]");
900 }
901 break;
902 }
903
aed164c3 904 case TARGET_MEM_REF:
905 {
906 const char *sep = "";
907 tree tmp;
908
909 pp_string (buffer, "MEM[");
910
28daba6f 911 if (TREE_CODE (TMR_BASE (node)) == ADDR_EXPR)
aed164c3 912 {
913 pp_string (buffer, sep);
914 sep = ", ";
915 pp_string (buffer, "symbol: ");
28daba6f 916 dump_generic_node (buffer, TREE_OPERAND (TMR_BASE (node), 0),
e077c79b 917 spc, flags, false);
aed164c3 918 }
28daba6f 919 else
920 {
921 pp_string (buffer, sep);
922 sep = ", ";
923 pp_string (buffer, "base: ");
924 dump_generic_node (buffer, TMR_BASE (node), spc, flags, false);
925 }
926 tmp = TMR_INDEX2 (node);
aed164c3 927 if (tmp)
928 {
929 pp_string (buffer, sep);
930 sep = ", ";
931 pp_string (buffer, "base: ");
932 dump_generic_node (buffer, tmp, spc, flags, false);
933 }
934 tmp = TMR_INDEX (node);
935 if (tmp)
936 {
937 pp_string (buffer, sep);
938 sep = ", ";
939 pp_string (buffer, "index: ");
940 dump_generic_node (buffer, tmp, spc, flags, false);
941 }
942 tmp = TMR_STEP (node);
943 if (tmp)
944 {
945 pp_string (buffer, sep);
946 sep = ", ";
947 pp_string (buffer, "step: ");
948 dump_generic_node (buffer, tmp, spc, flags, false);
949 }
950 tmp = TMR_OFFSET (node);
951 if (tmp)
952 {
953 pp_string (buffer, sep);
954 sep = ", ";
955 pp_string (buffer, "offset: ");
956 dump_generic_node (buffer, tmp, spc, flags, false);
957 }
958 pp_string (buffer, "]");
aed164c3 959 }
960 break;
961
4ee9c684 962 case ARRAY_TYPE:
963 {
964 tree tmp;
965
a0cac6f5 966 /* Print the innermost component type. */
967 for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE;
968 tmp = TREE_TYPE (tmp))
969 ;
970 dump_generic_node (buffer, tmp, spc, flags, false);
4ee9c684 971
972 /* Print the dimensions. */
9b1a6180 973 for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp))
974 dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
4ee9c684 975 break;
976 }
977
4ee9c684 978 case RECORD_TYPE:
979 case UNION_TYPE:
6374121b 980 case QUAL_UNION_TYPE:
d3828421 981 {
982 unsigned int quals = TYPE_QUALS (node);
983
984 if (quals & TYPE_QUAL_CONST)
985 pp_string (buffer, "const ");
986 if (quals & TYPE_QUAL_VOLATILE)
987 pp_string (buffer, "volatile ");
988
989 /* Print the name of the structure. */
990 if (TREE_CODE (node) == RECORD_TYPE)
991 pp_string (buffer, "struct ");
992 else if (TREE_CODE (node) == UNION_TYPE)
993 pp_string (buffer, "union ");
994
995 if (TYPE_NAME (node))
996 dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false);
c6934f8a 997 else if (!(flags & TDF_SLIM))
998 /* FIXME: If we eliminate the 'else' above and attempt
999 to show the fields for named types, we may get stuck
1000 following a cycle of pointers to structs. The alleged
1001 self-reference check in print_struct_decl will not detect
1002 cycles involving more than one pointer or struct type. */
d3828421 1003 print_struct_decl (buffer, node, spc, flags);
1004 break;
1005 }
4ee9c684 1006
4ee9c684 1007 case LANG_TYPE:
1008 NIY;
1009 break;
1010
1011 case INTEGER_CST:
1012 if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE)
1013 {
1014 /* In the case of a pointer, one may want to divide by the
1015 size of the pointed-to type. Unfortunately, this not
1016 straightforward. The C front-end maps expressions
1017
1018 (int *) 5
1019 int *p; (p + 5)
1020
1021 in such a way that the two INTEGER_CST nodes for "5" have
1022 different values but identical types. In the latter
1023 case, the 5 is multiplied by sizeof (int) in c-common.c
1024 (pointer_int_sum) to convert it to a byte address, and
1025 yet the type of the node is left unchanged. Argh. What
1026 is consistent though is that the number value corresponds
1027 to bytes (UNITS) offset.
1028
1029 NB: Neither of the following divisors can be trivially
1030 used to recover the original literal:
1031
1032 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
1033 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
1034 pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
1035 pp_string (buffer, "B"); /* pseudo-unit */
1036 }
d066d69a 1037 else if (host_integerp (node, 0))
1038 pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
1039 else if (host_integerp (node, 1))
1040 pp_unsigned_wide_integer (buffer, TREE_INT_CST_LOW (node));
1041 else
4ee9c684 1042 {
1043 tree val = node;
167a3fa5 1044 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (val);
1045 HOST_WIDE_INT high = TREE_INT_CST_HIGH (val);
4ee9c684 1046
1047 if (tree_int_cst_sgn (val) < 0)
1048 {
1049 pp_character (buffer, '-');
167a3fa5 1050 high = ~high + !low;
1051 low = -low;
4ee9c684 1052 }
1053 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
1054 systems? */
167a3fa5 1055 sprintf (pp_buffer (buffer)->digit_buffer,
7df7561b 1056 HOST_WIDE_INT_PRINT_DOUBLE_HEX,
1057 (unsigned HOST_WIDE_INT) high, low);
167a3fa5 1058 pp_string (buffer, pp_buffer (buffer)->digit_buffer);
4ee9c684 1059 }
4ee9c684 1060 break;
1061
1062 case REAL_CST:
1063 /* Code copied from print_node. */
1064 {
1065 REAL_VALUE_TYPE d;
1066 if (TREE_OVERFLOW (node))
1067 pp_string (buffer, " overflow");
1068
1069#if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
1070 d = TREE_REAL_CST (node);
1071 if (REAL_VALUE_ISINF (d))
3cfd6525 1072 pp_string (buffer, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
4ee9c684 1073 else if (REAL_VALUE_ISNAN (d))
1074 pp_string (buffer, " Nan");
1075 else
1076 {
1077 char string[100];
1078 real_to_decimal (string, &d, sizeof (string), 0, 1);
1079 pp_string (buffer, string);
1080 }
1081#else
1082 {
1083 HOST_WIDE_INT i;
1084 unsigned char *p = (unsigned char *) &TREE_REAL_CST (node);
1085 pp_string (buffer, "0x");
1086 for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
1087 output_formatted_integer (buffer, "%02x", *p++);
1088 }
1089#endif
1090 break;
1091 }
1092
06f0b99c 1093 case FIXED_CST:
1094 {
1095 char string[100];
1096 fixed_to_decimal (string, TREE_FIXED_CST_PTR (node), sizeof (string));
1097 pp_string (buffer, string);
1098 break;
1099 }
1100
4ee9c684 1101 case COMPLEX_CST:
1102 pp_string (buffer, "__complex__ (");
1103 dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false);
1104 pp_string (buffer, ", ");
1105 dump_generic_node (buffer, TREE_IMAGPART (node), spc, flags, false);
1106 pp_string (buffer, ")");
1107 break;
1108
1109 case STRING_CST:
1110 pp_string (buffer, "\"");
1111 pretty_print_string (buffer, TREE_STRING_POINTER (node));
1112 pp_string (buffer, "\"");
1113 break;
1114
1115 case VECTOR_CST:
1116 {
fadf62f4 1117 unsigned i;
4ee9c684 1118 pp_string (buffer, "{ ");
fadf62f4 1119 for (i = 0; i < VECTOR_CST_NELTS (node); ++i)
4ee9c684 1120 {
fadf62f4 1121 if (i != 0)
4ee9c684 1122 pp_string (buffer, ", ");
fadf62f4 1123 dump_generic_node (buffer, VECTOR_CST_ELT (node, i),
1124 spc, flags, false);
4ee9c684 1125 }
1126 pp_string (buffer, " }");
1127 }
1128 break;
1129
1130 case FUNCTION_TYPE:
c6934f8a 1131 case METHOD_TYPE:
1132 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1133 pp_space (buffer);
1134 if (TREE_CODE (node) == METHOD_TYPE)
1135 {
1136 if (TYPE_METHOD_BASETYPE (node))
1137 dump_decl_name (buffer, TYPE_NAME (TYPE_METHOD_BASETYPE (node)),
1138 flags);
1139 else
1140 pp_string (buffer, "<null method basetype>");
1141 pp_string (buffer, "::");
1142 }
1143 if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
1144 dump_decl_name (buffer, TYPE_NAME (node), flags);
12e18540 1145 else if (flags & TDF_NOUID)
1146 pp_printf (buffer, "<Txxxx>");
c6934f8a 1147 else
1148 pp_printf (buffer, "<T%x>", TYPE_UID (node));
1149 dump_function_declaration (buffer, node, spc, flags);
4ee9c684 1150 break;
1151
1152 case FUNCTION_DECL:
1153 case CONST_DECL:
1154 dump_decl_name (buffer, node, flags);
1155 break;
1156
1157 case LABEL_DECL:
1158 if (DECL_NAME (node))
1159 dump_decl_name (buffer, node, flags);
1160 else if (LABEL_DECL_UID (node) != -1)
00753696 1161 pp_printf (buffer, "<L%d>", (int) LABEL_DECL_UID (node));
4ee9c684 1162 else
00753696 1163 {
1164 if (flags & TDF_NOUID)
1165 pp_string (buffer, "<D.xxxx>");
1166 else
1167 pp_printf (buffer, "<D.%u>", DECL_UID (node));
1168 }
4ee9c684 1169 break;
1170
1171 case TYPE_DECL:
7bd3dcc4 1172 if (DECL_IS_BUILTIN (node))
4ee9c684 1173 {
1174 /* Don't print the declaration of built-in types. */
1175 break;
1176 }
1177 if (DECL_NAME (node))
d700b485 1178 dump_decl_name (buffer, node, flags);
5db1bdc2 1179 else if (TYPE_NAME (TREE_TYPE (node)) != node)
4ee9c684 1180 {
efa75d92 1181 if ((TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
1182 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
1183 && TYPE_METHODS (TREE_TYPE (node)))
4ee9c684 1184 {
1185 /* The type is a c++ class: all structures have at least
0bed3869 1186 4 methods. */
4ee9c684 1187 pp_string (buffer, "class ");
1188 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1189 }
1190 else
1191 {
d700b485 1192 pp_string (buffer,
1193 (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE
1194 ? "union" : "struct "));
4ee9c684 1195 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
4ee9c684 1196 }
1197 }
5db1bdc2 1198 else
1199 pp_string (buffer, "<anon>");
4ee9c684 1200 break;
1201
1202 case VAR_DECL:
1203 case PARM_DECL:
1204 case FIELD_DECL:
688ff29b 1205 case DEBUG_EXPR_DECL:
4ee9c684 1206 case NAMESPACE_DECL:
1207 dump_decl_name (buffer, node, flags);
1208 break;
1209
1210 case RESULT_DECL:
1211 pp_string (buffer, "<retval>");
1212 break;
1213
1214 case COMPONENT_REF:
1215 op0 = TREE_OPERAND (node, 0);
1216 str = ".";
182cf5a9 1217 if (op0
1218 && (TREE_CODE (op0) == INDIRECT_REF
1219 || (TREE_CODE (op0) == MEM_REF
1220 && TREE_CODE (TREE_OPERAND (op0, 0)) != ADDR_EXPR
1221 && integer_zerop (TREE_OPERAND (op0, 1))
d6f21aeb 1222 /* Dump the types of INTEGER_CSTs explicitly, for we
1223 can't infer them and MEM_ATTR caching will share
1224 MEM_REFs with differently-typed op0s. */
1225 && TREE_CODE (TREE_OPERAND (op0, 0)) != INTEGER_CST
ff2d70df 1226 /* Released SSA_NAMES have no TREE_TYPE. */
1227 && TREE_TYPE (TREE_OPERAND (op0, 0)) != NULL_TREE
182cf5a9 1228 /* Same pointer types, but ignoring POINTER_TYPE vs.
1229 REFERENCE_TYPE. */
1230 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 0)))
1231 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1))))
1232 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 0)))
1233 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 1))))
1234 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 0)))
1235 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 1))))
182cf5a9 1236 /* Same value types ignoring qualifiers. */
1237 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0))
1238 == TYPE_MAIN_VARIANT
1239 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1))))))))
4ee9c684 1240 {
1241 op0 = TREE_OPERAND (op0, 0);
1242 str = "->";
1243 }
1244 if (op_prio (op0) < op_prio (node))
1245 pp_character (buffer, '(');
1246 dump_generic_node (buffer, op0, spc, flags, false);
1247 if (op_prio (op0) < op_prio (node))
1248 pp_character (buffer, ')');
1249 pp_string (buffer, str);
1250 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
f6c33c78 1251 op0 = component_ref_field_offset (node);
1252 if (op0 && TREE_CODE (op0) != INTEGER_CST)
6374121b 1253 {
f6c33c78 1254 pp_string (buffer, "{off: ");
e3349ccb 1255 dump_generic_node (buffer, op0, spc, flags, false);
1256 pp_character (buffer, '}');
6374121b 1257 }
4ee9c684 1258 break;
1259
1260 case BIT_FIELD_REF:
1261 pp_string (buffer, "BIT_FIELD_REF <");
1262 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1263 pp_string (buffer, ", ");
1264 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1265 pp_string (buffer, ", ");
1266 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1267 pp_string (buffer, ">");
1268 break;
1269
4ee9c684 1270 case ARRAY_REF:
6374121b 1271 case ARRAY_RANGE_REF:
4ee9c684 1272 op0 = TREE_OPERAND (node, 0);
1273 if (op_prio (op0) < op_prio (node))
1274 pp_character (buffer, '(');
1275 dump_generic_node (buffer, op0, spc, flags, false);
1276 if (op_prio (op0) < op_prio (node))
1277 pp_character (buffer, ')');
1278 pp_character (buffer, '[');
1279 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
6374121b 1280 if (TREE_CODE (node) == ARRAY_RANGE_REF)
1281 pp_string (buffer, " ...");
4ee9c684 1282 pp_character (buffer, ']');
4ee9c684 1283
1267d2b7 1284 op0 = array_ref_low_bound (node);
1285 op1 = array_ref_element_size (node);
1286
1287 if (!integer_zerop (op0)
a128a28f 1288 || TREE_OPERAND (node, 2)
1289 || TREE_OPERAND (node, 3))
6374121b 1290 {
1291 pp_string (buffer, "{lb: ");
1267d2b7 1292 dump_generic_node (buffer, op0, spc, flags, false);
6374121b 1293 pp_string (buffer, " sz: ");
1267d2b7 1294 dump_generic_node (buffer, op1, spc, flags, false);
6374121b 1295 pp_character (buffer, '}');
1296 }
4ee9c684 1297 break;
1298
1299 case CONSTRUCTOR:
1300 {
c75b4594 1301 unsigned HOST_WIDE_INT ix;
1302 tree field, val;
fe1fdd37 1303 bool is_struct_init = false;
1304 bool is_array_init = false;
1305 double_int curidx = double_int_zero;
4ee9c684 1306 pp_character (buffer, '{');
3c25489e 1307 if (TREE_CLOBBER_P (node))
1308 pp_string (buffer, "CLOBBER");
1309 else if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
1310 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
fe1fdd37 1311 is_struct_init = true;
1312 else if (TREE_CODE (TREE_TYPE (node)) == ARRAY_TYPE
1313 && TYPE_DOMAIN (TREE_TYPE (node))
1314 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node)))
1315 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node))))
1316 == INTEGER_CST)
1317 {
1318 tree minv = TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node)));
1319 is_array_init = true;
1320 curidx = tree_to_double_int (minv);
1321 }
c75b4594 1322 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)
4ee9c684 1323 {
fe1fdd37 1324 if (field)
4ee9c684 1325 {
fe1fdd37 1326 if (is_struct_init)
1327 {
1328 pp_character (buffer, '.');
1329 dump_generic_node (buffer, field, spc, flags, false);
1330 pp_character (buffer, '=');
1331 }
1332 else if (is_array_init
1333 && (TREE_CODE (field) != INTEGER_CST
cf8f0e63 1334 || tree_to_double_int (field) != curidx))
fe1fdd37 1335 {
1336 pp_character (buffer, '[');
1337 if (TREE_CODE (field) == RANGE_EXPR)
1338 {
1339 dump_generic_node (buffer, TREE_OPERAND (field, 0), spc,
1340 flags, false);
1341 pp_string (buffer, " ... ");
1342 dump_generic_node (buffer, TREE_OPERAND (field, 1), spc,
1343 flags, false);
1344 if (TREE_CODE (TREE_OPERAND (field, 1)) == INTEGER_CST)
1345 curidx = tree_to_double_int (TREE_OPERAND (field, 1));
1346 }
1347 else
1348 dump_generic_node (buffer, field, spc, flags, false);
1349 if (TREE_CODE (field) == INTEGER_CST)
1350 curidx = tree_to_double_int (field);
1351 pp_string (buffer, "]=");
1352 }
4ee9c684 1353 }
fe1fdd37 1354 if (is_array_init)
cf8f0e63 1355 curidx += double_int_one;
4ee9c684 1356 if (val && TREE_CODE (val) == ADDR_EXPR)
1357 if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
1358 val = TREE_OPERAND (val, 0);
1359 if (val && TREE_CODE (val) == FUNCTION_DECL)
4ee9c684 1360 dump_decl_name (buffer, val, flags);
4ee9c684 1361 else
c75b4594 1362 dump_generic_node (buffer, val, spc, flags, false);
f1f41a6c 1363 if (ix != vec_safe_length (CONSTRUCTOR_ELTS (node)) - 1)
4ee9c684 1364 {
1365 pp_character (buffer, ',');
1366 pp_space (buffer);
1367 }
1368 }
1369 pp_character (buffer, '}');
1370 }
1371 break;
1372
1373 case COMPOUND_EXPR:
1374 {
1375 tree *tp;
1376 if (flags & TDF_SLIM)
1377 {
1378 pp_string (buffer, "<COMPOUND_EXPR>");
1379 break;
1380 }
1381
1382 dump_generic_node (buffer, TREE_OPERAND (node, 0),
1e8e9920 1383 spc, flags, !(flags & TDF_SLIM));
1384 if (flags & TDF_SLIM)
4ee9c684 1385 newline_and_indent (buffer, spc);
1386 else
1387 {
1388 pp_character (buffer, ',');
1389 pp_space (buffer);
1390 }
1391
1392 for (tp = &TREE_OPERAND (node, 1);
1393 TREE_CODE (*tp) == COMPOUND_EXPR;
1394 tp = &TREE_OPERAND (*tp, 1))
1395 {
1396 dump_generic_node (buffer, TREE_OPERAND (*tp, 0),
1e8e9920 1397 spc, flags, !(flags & TDF_SLIM));
1398 if (flags & TDF_SLIM)
4ee9c684 1399 newline_and_indent (buffer, spc);
1400 else
1401 {
1402 pp_character (buffer, ',');
1403 pp_space (buffer);
1404 }
1405 }
1406
1e8e9920 1407 dump_generic_node (buffer, *tp, spc, flags, !(flags & TDF_SLIM));
4ee9c684 1408 }
1409 break;
1410
1411 case STATEMENT_LIST:
1412 {
1413 tree_stmt_iterator si;
1414 bool first = true;
b27ac6b5 1415
1e8e9920 1416 if (flags & TDF_SLIM)
4ee9c684 1417 {
1418 pp_string (buffer, "<STATEMENT_LIST>");
1419 break;
1420 }
1421
1422 for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))
1423 {
1424 if (!first)
1425 newline_and_indent (buffer, spc);
1426 else
1427 first = false;
1428 dump_generic_node (buffer, tsi_stmt (si), spc, flags, true);
1429 }
1430 }
1431 break;
1432
1433 case MODIFY_EXPR:
1434 case INIT_EXPR:
75a70cf9 1435 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags,
35cc02b5 1436 false);
4ee9c684 1437 pp_space (buffer);
1438 pp_character (buffer, '=');
1439 pp_space (buffer);
75a70cf9 1440 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags,
35cc02b5 1441 false);
4ee9c684 1442 break;
1443
1444 case TARGET_EXPR:
2363ef00 1445 pp_string (buffer, "TARGET_EXPR <");
1446 dump_generic_node (buffer, TARGET_EXPR_SLOT (node), spc, flags, false);
1447 pp_character (buffer, ',');
1448 pp_space (buffer);
4ee9c684 1449 dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false);
2363ef00 1450 pp_character (buffer, '>');
4ee9c684 1451 break;
1452
d700b485 1453 case DECL_EXPR:
1454 print_declaration (buffer, DECL_EXPR_DECL (node), spc, flags);
1455 is_stmt = false;
1456 break;
1457
4ee9c684 1458 case COND_EXPR:
0375a275 1459 if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node)
4ee9c684 1460 {
1461 pp_string (buffer, "if (");
1462 dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false);
1463 pp_character (buffer, ')');
1464 /* The lowered cond_exprs should always be printed in full. */
1465 if (COND_EXPR_THEN (node)
49377e21 1466 && (IS_EMPTY_STMT (COND_EXPR_THEN (node))
1467 || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)
4ee9c684 1468 && COND_EXPR_ELSE (node)
49377e21 1469 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node))
1470 || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
4ee9c684 1471 {
1472 pp_space (buffer);
24f116a8 1473 dump_generic_node (buffer, COND_EXPR_THEN (node),
1474 0, flags, true);
1475 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
1476 {
1477 pp_string (buffer, " else ");
1478 dump_generic_node (buffer, COND_EXPR_ELSE (node),
1479 0, flags, true);
1480 }
4ee9c684 1481 }
1482 else if (!(flags & TDF_SLIM))
1483 {
1484 /* Output COND_EXPR_THEN. */
1485 if (COND_EXPR_THEN (node))
1486 {
1487 newline_and_indent (buffer, spc+2);
1488 pp_character (buffer, '{');
1489 newline_and_indent (buffer, spc+4);
1490 dump_generic_node (buffer, COND_EXPR_THEN (node), spc+4,
1491 flags, true);
1492 newline_and_indent (buffer, spc+2);
1493 pp_character (buffer, '}');
1494 }
1495
1496 /* Output COND_EXPR_ELSE. */
24f116a8 1497 if (COND_EXPR_ELSE (node)
1498 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
4ee9c684 1499 {
1500 newline_and_indent (buffer, spc);
1501 pp_string (buffer, "else");
1502 newline_and_indent (buffer, spc+2);
1503 pp_character (buffer, '{');
1504 newline_and_indent (buffer, spc+4);
1505 dump_generic_node (buffer, COND_EXPR_ELSE (node), spc+4,
1506 flags, true);
1507 newline_and_indent (buffer, spc+2);
1508 pp_character (buffer, '}');
1509 }
1510 }
1511 is_expr = false;
1512 }
1513 else
1514 {
1515 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1516 pp_space (buffer);
1517 pp_character (buffer, '?');
1518 pp_space (buffer);
1519 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1520 pp_space (buffer);
1521 pp_character (buffer, ':');
1522 pp_space (buffer);
1523 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1524 }
1525 break;
1526
1527 case BIND_EXPR:
1528 pp_character (buffer, '{');
1529 if (!(flags & TDF_SLIM))
1530 {
1531 if (BIND_EXPR_VARS (node))
1532 {
1533 pp_newline (buffer);
1534
1767a056 1535 for (op0 = BIND_EXPR_VARS (node); op0; op0 = DECL_CHAIN (op0))
4ee9c684 1536 {
1537 print_declaration (buffer, op0, spc+2, flags);
1538 pp_newline (buffer);
1539 }
1540 }
1541
1542 newline_and_indent (buffer, spc+2);
1543 dump_generic_node (buffer, BIND_EXPR_BODY (node), spc+2, flags, true);
1544 newline_and_indent (buffer, spc);
1545 pp_character (buffer, '}');
1546 }
1547 is_expr = false;
1548 break;
1549
1550 case CALL_EXPR:
8c1f2562 1551 print_call_name (buffer, CALL_EXPR_FN (node), flags);
4ee9c684 1552
1553 /* Print parameters. */
1554 pp_space (buffer);
1555 pp_character (buffer, '(');
c2f47e15 1556 {
1557 tree arg;
1558 call_expr_arg_iterator iter;
1559 FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
1560 {
1561 dump_generic_node (buffer, arg, spc, flags, false);
1562 if (more_call_expr_args_p (&iter))
1563 {
1564 pp_character (buffer, ',');
1565 pp_space (buffer);
1566 }
1567 }
1568 }
48dc2227 1569 if (CALL_EXPR_VA_ARG_PACK (node))
1570 {
1571 if (call_expr_nargs (node) > 0)
1572 {
1573 pp_character (buffer, ',');
1574 pp_space (buffer);
1575 }
1576 pp_string (buffer, "__builtin_va_arg_pack ()");
1577 }
4ee9c684 1578 pp_character (buffer, ')');
1579
c2f47e15 1580 op1 = CALL_EXPR_STATIC_CHAIN (node);
4ee9c684 1581 if (op1)
1582 {
1583 pp_string (buffer, " [static-chain: ");
1584 dump_generic_node (buffer, op1, spc, flags, false);
1585 pp_character (buffer, ']');
1586 }
1587
ea523851 1588 if (CALL_EXPR_RETURN_SLOT_OPT (node))
1589 pp_string (buffer, " [return slot optimization]");
4ee9c684 1590 if (CALL_EXPR_TAILCALL (node))
1591 pp_string (buffer, " [tail call]");
1592 break;
1593
1594 case WITH_CLEANUP_EXPR:
1595 NIY;
1596 break;
1597
1598 case CLEANUP_POINT_EXPR:
1599 pp_string (buffer, "<<cleanup_point ");
1600 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1601 pp_string (buffer, ">>");
1602 break;
1603
1604 case PLACEHOLDER_EXPR:
d700b485 1605 pp_string (buffer, "<PLACEHOLDER_EXPR ");
1606 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1607 pp_character (buffer, '>');
4ee9c684 1608 break;
1609
1610 /* Binary arithmetic and logic expressions. */
4a61a337 1611 case WIDEN_SUM_EXPR:
1612 case WIDEN_MULT_EXPR:
4ee9c684 1613 case MULT_EXPR:
96504875 1614 case MULT_HIGHPART_EXPR:
4ee9c684 1615 case PLUS_EXPR:
0de36bdb 1616 case POINTER_PLUS_EXPR:
4ee9c684 1617 case MINUS_EXPR:
1618 case TRUNC_DIV_EXPR:
1619 case CEIL_DIV_EXPR:
1620 case FLOOR_DIV_EXPR:
1621 case ROUND_DIV_EXPR:
1622 case TRUNC_MOD_EXPR:
1623 case CEIL_MOD_EXPR:
1624 case FLOOR_MOD_EXPR:
1625 case ROUND_MOD_EXPR:
1626 case RDIV_EXPR:
1627 case EXACT_DIV_EXPR:
1628 case LSHIFT_EXPR:
1629 case RSHIFT_EXPR:
1630 case LROTATE_EXPR:
1631 case RROTATE_EXPR:
925c62d4 1632 case VEC_LSHIFT_EXPR:
1633 case VEC_RSHIFT_EXPR:
6083c152 1634 case WIDEN_LSHIFT_EXPR:
4ee9c684 1635 case BIT_IOR_EXPR:
1636 case BIT_XOR_EXPR:
1637 case BIT_AND_EXPR:
1638 case TRUTH_ANDIF_EXPR:
1639 case TRUTH_ORIF_EXPR:
1640 case TRUTH_AND_EXPR:
1641 case TRUTH_OR_EXPR:
1642 case TRUTH_XOR_EXPR:
1643 case LT_EXPR:
1644 case LE_EXPR:
1645 case GT_EXPR:
1646 case GE_EXPR:
1647 case EQ_EXPR:
1648 case NE_EXPR:
1649 case UNLT_EXPR:
1650 case UNLE_EXPR:
1651 case UNGT_EXPR:
1652 case UNGE_EXPR:
1653 case UNEQ_EXPR:
318a728f 1654 case LTGT_EXPR:
1655 case ORDERED_EXPR:
1656 case UNORDERED_EXPR:
4ee9c684 1657 {
1658 const char *op = op_symbol (node);
1659 op0 = TREE_OPERAND (node, 0);
1660 op1 = TREE_OPERAND (node, 1);
1661
1662 /* When the operands are expressions with less priority,
1663 keep semantics of the tree representation. */
3814cd68 1664 if (op_prio (op0) <= op_prio (node))
4ee9c684 1665 {
1666 pp_character (buffer, '(');
1667 dump_generic_node (buffer, op0, spc, flags, false);
1668 pp_character (buffer, ')');
1669 }
1670 else
1671 dump_generic_node (buffer, op0, spc, flags, false);
1672
1673 pp_space (buffer);
1674 pp_string (buffer, op);
1675 pp_space (buffer);
1676
1677 /* When the operands are expressions with less priority,
1678 keep semantics of the tree representation. */
3814cd68 1679 if (op_prio (op1) <= op_prio (node))
4ee9c684 1680 {
1681 pp_character (buffer, '(');
1682 dump_generic_node (buffer, op1, spc, flags, false);
1683 pp_character (buffer, ')');
1684 }
1685 else
1686 dump_generic_node (buffer, op1, spc, flags, false);
1687 }
1688 break;
1689
1690 /* Unary arithmetic and logic expressions. */
1691 case NEGATE_EXPR:
1692 case BIT_NOT_EXPR:
1693 case TRUTH_NOT_EXPR:
1694 case ADDR_EXPR:
4ee9c684 1695 case PREDECREMENT_EXPR:
1696 case PREINCREMENT_EXPR:
1697 case INDIRECT_REF:
1698 if (TREE_CODE (node) == ADDR_EXPR
1699 && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
1700 || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
1701 ; /* Do not output '&' for strings and function pointers. */
1702 else
1703 pp_string (buffer, op_symbol (node));
1704
1705 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1706 {
1707 pp_character (buffer, '(');
1708 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1709 pp_character (buffer, ')');
1710 }
1711 else
1712 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1713 break;
1714
1715 case POSTDECREMENT_EXPR:
1716 case POSTINCREMENT_EXPR:
1717 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1718 {
1719 pp_character (buffer, '(');
1720 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1721 pp_character (buffer, ')');
1722 }
1723 else
1724 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1725 pp_string (buffer, op_symbol (node));
1726 break;
1727
1728 case MIN_EXPR:
1729 pp_string (buffer, "MIN_EXPR <");
1730 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1731 pp_string (buffer, ", ");
1732 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1733 pp_character (buffer, '>');
1734 break;
1735
1736 case MAX_EXPR:
1737 pp_string (buffer, "MAX_EXPR <");
1738 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1739 pp_string (buffer, ", ");
1740 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1741 pp_character (buffer, '>');
1742 break;
1743
1744 case ABS_EXPR:
1745 pp_string (buffer, "ABS_EXPR <");
1746 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1747 pp_character (buffer, '>');
1748 break;
1749
4ee9c684 1750 case RANGE_EXPR:
1751 NIY;
1752 break;
1753
bd1a81f7 1754 case ADDR_SPACE_CONVERT_EXPR:
06f0b99c 1755 case FIXED_CONVERT_EXPR:
4ee9c684 1756 case FIX_TRUNC_EXPR:
4ee9c684 1757 case FLOAT_EXPR:
72dd6141 1758 CASE_CONVERT:
4ee9c684 1759 type = TREE_TYPE (node);
1760 op0 = TREE_OPERAND (node, 0);
1761 if (type != TREE_TYPE (op0))
1762 {
1763 pp_character (buffer, '(');
1764 dump_generic_node (buffer, type, spc, flags, false);
153536df 1765 pp_string (buffer, ") ");
4ee9c684 1766 }
1767 if (op_prio (op0) < op_prio (node))
1768 pp_character (buffer, '(');
1769 dump_generic_node (buffer, op0, spc, flags, false);
1770 if (op_prio (op0) < op_prio (node))
1771 pp_character (buffer, ')');
1772 break;
1773
1774 case VIEW_CONVERT_EXPR:
1775 pp_string (buffer, "VIEW_CONVERT_EXPR<");
1776 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1777 pp_string (buffer, ">(");
1778 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1779 pp_character (buffer, ')');
1780 break;
1781
751ff693 1782 case PAREN_EXPR:
1783 pp_string (buffer, "((");
1784 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1785 pp_string (buffer, "))");
1786 break;
1787
4ee9c684 1788 case NON_LVALUE_EXPR:
1789 pp_string (buffer, "NON_LVALUE_EXPR <");
1790 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1791 pp_character (buffer, '>');
1792 break;
1793
1794 case SAVE_EXPR:
1795 pp_string (buffer, "SAVE_EXPR <");
1796 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1797 pp_character (buffer, '>');
1798 break;
1799
4ee9c684 1800 case COMPLEX_EXPR:
1801 pp_string (buffer, "COMPLEX_EXPR <");
1802 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1803 pp_string (buffer, ", ");
1804 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1805 pp_string (buffer, ">");
1806 break;
1807
1808 case CONJ_EXPR:
1809 pp_string (buffer, "CONJ_EXPR <");
1810 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1811 pp_string (buffer, ">");
1812 break;
1813
1814 case REALPART_EXPR:
1815 pp_string (buffer, "REALPART_EXPR <");
1816 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1817 pp_string (buffer, ">");
1818 break;
1819
1820 case IMAGPART_EXPR:
1821 pp_string (buffer, "IMAGPART_EXPR <");
1822 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1823 pp_string (buffer, ">");
1824 break;
1825
1826 case VA_ARG_EXPR:
1827 pp_string (buffer, "VA_ARG_EXPR <");
1828 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1829 pp_string (buffer, ">");
1830 break;
1831
1832 case TRY_FINALLY_EXPR:
1833 case TRY_CATCH_EXPR:
1834 pp_string (buffer, "try");
1835 newline_and_indent (buffer, spc+2);
1836 pp_string (buffer, "{");
1837 newline_and_indent (buffer, spc+4);
1838 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc+4, flags, true);
1839 newline_and_indent (buffer, spc+2);
1840 pp_string (buffer, "}");
1841 newline_and_indent (buffer, spc);
1842 pp_string (buffer,
1843 (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");
1844 newline_and_indent (buffer, spc+2);
1845 pp_string (buffer, "{");
1846 newline_and_indent (buffer, spc+4);
1847 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc+4, flags, true);
1848 newline_and_indent (buffer, spc+2);
1849 pp_string (buffer, "}");
1850 is_expr = false;
1851 break;
1852
1853 case CATCH_EXPR:
1854 pp_string (buffer, "catch (");
1855 dump_generic_node (buffer, CATCH_TYPES (node), spc+2, flags, false);
1856 pp_string (buffer, ")");
1857 newline_and_indent (buffer, spc+2);
1858 pp_string (buffer, "{");
1859 newline_and_indent (buffer, spc+4);
1860 dump_generic_node (buffer, CATCH_BODY (node), spc+4, flags, true);
1861 newline_and_indent (buffer, spc+2);
1862 pp_string (buffer, "}");
1863 is_expr = false;
1864 break;
1865
1866 case EH_FILTER_EXPR:
1867 pp_string (buffer, "<<<eh_filter (");
1868 dump_generic_node (buffer, EH_FILTER_TYPES (node), spc+2, flags, false);
1869 pp_string (buffer, ")>>>");
1870 newline_and_indent (buffer, spc+2);
1871 pp_string (buffer, "{");
1872 newline_and_indent (buffer, spc+4);
1873 dump_generic_node (buffer, EH_FILTER_FAILURE (node), spc+4, flags, true);
1874 newline_and_indent (buffer, spc+2);
1875 pp_string (buffer, "}");
1876 is_expr = false;
1877 break;
1878
4ee9c684 1879 case LABEL_EXPR:
1880 op0 = TREE_OPERAND (node, 0);
1881 /* If this is for break or continue, don't bother printing it. */
1882 if (DECL_NAME (op0))
1883 {
1884 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1885 if (strcmp (name, "break") == 0
1886 || strcmp (name, "continue") == 0)
1887 break;
1888 }
1889 dump_generic_node (buffer, op0, spc, flags, false);
1890 pp_character (buffer, ':');
1891 if (DECL_NONLOCAL (op0))
1892 pp_string (buffer, " [non-local]");
1893 break;
1894
4ee9c684 1895 case LOOP_EXPR:
1896 pp_string (buffer, "while (1)");
1897 if (!(flags & TDF_SLIM))
1898 {
1899 newline_and_indent (buffer, spc+2);
1900 pp_character (buffer, '{');
1901 newline_and_indent (buffer, spc+4);
1902 dump_generic_node (buffer, LOOP_EXPR_BODY (node), spc+4, flags, true);
1903 newline_and_indent (buffer, spc+2);
1904 pp_character (buffer, '}');
1905 }
1906 is_expr = false;
1907 break;
1908
4a1849e3 1909 case PREDICT_EXPR:
1910 pp_string (buffer, "// predicted ");
1911 if (PREDICT_EXPR_OUTCOME (node))
1912 pp_string (buffer, "likely by ");
1913 else
1914 pp_string (buffer, "unlikely by ");
1915 pp_string (buffer, predictor_name (PREDICT_EXPR_PREDICTOR (node)));
1916 pp_string (buffer, " predictor.");
1917 break;
1918
4ee9c684 1919 case RETURN_EXPR:
1920 pp_string (buffer, "return");
1921 op0 = TREE_OPERAND (node, 0);
1922 if (op0)
1923 {
1924 pp_space (buffer);
75a70cf9 1925 if (TREE_CODE (op0) == MODIFY_EXPR)
1926 dump_generic_node (buffer, TREE_OPERAND (op0, 1),
35cc02b5 1927 spc, flags, false);
4ee9c684 1928 else
1929 dump_generic_node (buffer, op0, spc, flags, false);
1930 }
1931 break;
1932
1933 case EXIT_EXPR:
1934 pp_string (buffer, "if (");
1935 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1936 pp_string (buffer, ") break");
1937 break;
1938
1939 case SWITCH_EXPR:
1940 pp_string (buffer, "switch (");
1941 dump_generic_node (buffer, SWITCH_COND (node), spc, flags, false);
1942 pp_character (buffer, ')');
1943 if (!(flags & TDF_SLIM))
1944 {
1945 newline_and_indent (buffer, spc+2);
1946 pp_character (buffer, '{');
1947 if (SWITCH_BODY (node))
1948 {
1949 newline_and_indent (buffer, spc+4);
1e8e9920 1950 dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags,
1951 true);
4ee9c684 1952 }
1953 else
1954 {
1955 tree vec = SWITCH_LABELS (node);
1956 size_t i, n = TREE_VEC_LENGTH (vec);
1957 for (i = 0; i < n; ++i)
1958 {
1959 tree elt = TREE_VEC_ELT (vec, i);
1960 newline_and_indent (buffer, spc+4);
1e8e9920 1961 if (elt)
1962 {
1963 dump_generic_node (buffer, elt, spc+4, flags, false);
1964 pp_string (buffer, " goto ");
1965 dump_generic_node (buffer, CASE_LABEL (elt), spc+4,
1966 flags, true);
1967 pp_semicolon (buffer);
1968 }
1969 else
1970 pp_string (buffer, "case ???: goto ???;");
4ee9c684 1971 }
1972 }
1973 newline_and_indent (buffer, spc+2);
1974 pp_character (buffer, '}');
1975 }
1976 is_expr = false;
1977 break;
1978
1979 case GOTO_EXPR:
1980 op0 = GOTO_DESTINATION (node);
ce45a448 1981 if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
4ee9c684 1982 {
1983 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1984 if (strcmp (name, "break") == 0
1985 || strcmp (name, "continue") == 0)
1986 {
1987 pp_string (buffer, name);
1988 break;
1989 }
1990 }
1991 pp_string (buffer, "goto ");
1992 dump_generic_node (buffer, op0, spc, flags, false);
1993 break;
1994
4ee9c684 1995 case ASM_EXPR:
1996 pp_string (buffer, "__asm__");
1997 if (ASM_VOLATILE_P (node))
1998 pp_string (buffer, " __volatile__");
1999 pp_character (buffer, '(');
2000 dump_generic_node (buffer, ASM_STRING (node), spc, flags, false);
2001 pp_character (buffer, ':');
2002 dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false);
2003 pp_character (buffer, ':');
2004 dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false);
2005 if (ASM_CLOBBERS (node))
2006 {
2007 pp_character (buffer, ':');
2008 dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false);
2009 }
2010 pp_string (buffer, ")");
2011 break;
2012
2013 case CASE_LABEL_EXPR:
2014 if (CASE_LOW (node) && CASE_HIGH (node))
2015 {
2016 pp_string (buffer, "case ");
2017 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
2018 pp_string (buffer, " ... ");
2019 dump_generic_node (buffer, CASE_HIGH (node), spc, flags, false);
2020 }
2021 else if (CASE_LOW (node))
2022 {
2023 pp_string (buffer, "case ");
2024 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
2025 }
2026 else
75a70cf9 2027 pp_string (buffer, "default");
4ee9c684 2028 pp_character (buffer, ':');
2029 break;
2030
215e2f1d 2031 case OBJ_TYPE_REF:
2032 pp_string (buffer, "OBJ_TYPE_REF(");
2033 dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
2034 pp_character (buffer, ';');
2035 dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
2036 pp_character (buffer, '-');
4ee9c684 2037 pp_character (buffer, '>');
215e2f1d 2038 dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
2039 pp_character (buffer, ')');
4ee9c684 2040 break;
2041
4ee9c684 2042 case SSA_NAME:
ec11736b 2043 if (SSA_NAME_IDENTIFIER (node))
2044 dump_generic_node (buffer, SSA_NAME_IDENTIFIER (node),
2045 spc, flags, false);
4ee9c684 2046 pp_string (buffer, "_");
2047 pp_decimal_int (buffer, SSA_NAME_VERSION (node));
2b6719e9 2048 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
2049 pp_string (buffer, "(ab)");
4fb5e5ca 2050 else if (SSA_NAME_IS_DEFAULT_DEF (node))
2051 pp_string (buffer, "(D)");
4ee9c684 2052 break;
2053
80f06481 2054 case WITH_SIZE_EXPR:
2055 pp_string (buffer, "WITH_SIZE_EXPR <");
2056 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2057 pp_string (buffer, ", ");
2058 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2059 pp_string (buffer, ">");
2060 break;
2061
88dbf20f 2062 case ASSERT_EXPR:
2063 pp_string (buffer, "ASSERT_EXPR <");
2064 dump_generic_node (buffer, ASSERT_EXPR_VAR (node), spc, flags, false);
2065 pp_string (buffer, ", ");
2066 dump_generic_node (buffer, ASSERT_EXPR_COND (node), spc, flags, false);
2067 pp_string (buffer, ">");
2068 break;
2069
101d9422 2070 case SCEV_KNOWN:
2071 pp_string (buffer, "scev_known");
2072 break;
2073
2074 case SCEV_NOT_KNOWN:
2075 pp_string (buffer, "scev_not_known");
2076 break;
2077
2078 case POLYNOMIAL_CHREC:
2079 pp_string (buffer, "{");
2080 dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false);
2081 pp_string (buffer, ", +, ");
2082 dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false);
2083 pp_string (buffer, "}_");
2084 dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false);
2085 is_stmt = false;
2086 break;
2087
b056d812 2088 case REALIGN_LOAD_EXPR:
2089 pp_string (buffer, "REALIGN_LOAD <");
2090 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2091 pp_string (buffer, ", ");
2092 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2093 pp_string (buffer, ", ");
2094 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
2095 pp_string (buffer, ">");
2096 break;
48e1416a 2097
5c4f2f32 2098 case VEC_COND_EXPR:
2099 pp_string (buffer, " VEC_COND_EXPR < ");
2100 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
6cf89e04 2101 pp_string (buffer, " , ");
2102 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2103 pp_string (buffer, " , ");
2104 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
2105 pp_string (buffer, " > ");
2106 break;
2107
f4803722 2108 case VEC_PERM_EXPR:
2109 pp_string (buffer, " VEC_PERM_EXPR < ");
6cf89e04 2110 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
5c4f2f32 2111 pp_string (buffer, " , ");
2112 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2113 pp_string (buffer, " , ");
2114 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
2115 pp_string (buffer, " > ");
2116 break;
2117
4a61a337 2118 case DOT_PROD_EXPR:
2119 pp_string (buffer, " DOT_PROD_EXPR < ");
2120 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
c6c91d61 2121 pp_string (buffer, ", ");
4a61a337 2122 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
c6c91d61 2123 pp_string (buffer, ", ");
4a61a337 2124 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
2125 pp_string (buffer, " > ");
2126 break;
2127
00f4f705 2128 case WIDEN_MULT_PLUS_EXPR:
2129 pp_string (buffer, " WIDEN_MULT_PLUS_EXPR < ");
2130 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2131 pp_string (buffer, ", ");
2132 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2133 pp_string (buffer, ", ");
2134 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
2135 pp_string (buffer, " > ");
2136 break;
2137
2138 case WIDEN_MULT_MINUS_EXPR:
2139 pp_string (buffer, " WIDEN_MULT_MINUS_EXPR < ");
2140 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2141 pp_string (buffer, ", ");
2142 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2143 pp_string (buffer, ", ");
2144 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
2145 pp_string (buffer, " > ");
2146 break;
2147
156f51b9 2148 case FMA_EXPR:
2149 pp_string (buffer, " FMA_EXPR < ");
2150 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2151 pp_string (buffer, ", ");
2152 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2153 pp_string (buffer, ", ");
2154 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
2155 pp_string (buffer, " > ");
2156 break;
2157
1e8e9920 2158 case OMP_PARALLEL:
2159 pp_string (buffer, "#pragma omp parallel");
2160 dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags);
2161
2162 dump_omp_body:
2163 if (!(flags & TDF_SLIM) && OMP_BODY (node))
2164 {
2165 newline_and_indent (buffer, spc + 2);
2166 pp_character (buffer, '{');
2167 newline_and_indent (buffer, spc + 4);
2168 dump_generic_node (buffer, OMP_BODY (node), spc + 4, flags, false);
2169 newline_and_indent (buffer, spc + 2);
2170 pp_character (buffer, '}');
2171 }
2172 is_expr = false;
2173 break;
2174
fd6481cf 2175 case OMP_TASK:
2176 pp_string (buffer, "#pragma omp task");
2177 dump_omp_clauses (buffer, OMP_TASK_CLAUSES (node), spc, flags);
fd6481cf 2178 goto dump_omp_body;
2179
1e8e9920 2180 case OMP_FOR:
2181 pp_string (buffer, "#pragma omp for");
2182 dump_omp_clauses (buffer, OMP_FOR_CLAUSES (node), spc, flags);
2183
2184 if (!(flags & TDF_SLIM))
2185 {
fd6481cf 2186 int i;
2187
1e8e9920 2188 if (OMP_FOR_PRE_BODY (node))
2189 {
2190 newline_and_indent (buffer, spc + 2);
2191 pp_character (buffer, '{');
2192 spc += 4;
2193 newline_and_indent (buffer, spc);
2194 dump_generic_node (buffer, OMP_FOR_PRE_BODY (node),
2195 spc, flags, false);
2196 }
fd6481cf 2197 spc -= 2;
2198 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (node)); i++)
2199 {
2200 spc += 2;
2201 newline_and_indent (buffer, spc);
2202 pp_string (buffer, "for (");
2203 dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_INIT (node), i),
2204 spc, flags, false);
2205 pp_string (buffer, "; ");
2206 dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_COND (node), i),
2207 spc, flags, false);
2208 pp_string (buffer, "; ");
2209 dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_INCR (node), i),
2210 spc, flags, false);
2211 pp_string (buffer, ")");
2212 }
1e8e9920 2213 if (OMP_FOR_BODY (node))
2214 {
2215 newline_and_indent (buffer, spc + 2);
2216 pp_character (buffer, '{');
2217 newline_and_indent (buffer, spc + 4);
2218 dump_generic_node (buffer, OMP_FOR_BODY (node), spc + 4, flags,
2219 false);
2220 newline_and_indent (buffer, spc + 2);
2221 pp_character (buffer, '}');
2222 }
fd6481cf 2223 spc -= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node)) - 2;
1e8e9920 2224 if (OMP_FOR_PRE_BODY (node))
2225 {
2226 spc -= 4;
2227 newline_and_indent (buffer, spc + 2);
2228 pp_character (buffer, '}');
2229 }
2230 }
2231 is_expr = false;
2232 break;
2233
2234 case OMP_SECTIONS:
2235 pp_string (buffer, "#pragma omp sections");
2236 dump_omp_clauses (buffer, OMP_SECTIONS_CLAUSES (node), spc, flags);
2237 goto dump_omp_body;
2238
2239 case OMP_SECTION:
2240 pp_string (buffer, "#pragma omp section");
2241 goto dump_omp_body;
48e1416a 2242
1e8e9920 2243 case OMP_MASTER:
2244 pp_string (buffer, "#pragma omp master");
2245 goto dump_omp_body;
2246
2247 case OMP_ORDERED:
2248 pp_string (buffer, "#pragma omp ordered");
2249 goto dump_omp_body;
2250
2251 case OMP_CRITICAL:
2252 pp_string (buffer, "#pragma omp critical");
2253 if (OMP_CRITICAL_NAME (node))
2254 {
2255 pp_space (buffer);
2256 pp_character (buffer, '(');
2257 dump_generic_node (buffer, OMP_CRITICAL_NAME (node), spc,
2258 flags, false);
2259 pp_character (buffer, ')');
2260 }
2261 goto dump_omp_body;
2262
2263 case OMP_ATOMIC:
2264 pp_string (buffer, "#pragma omp atomic");
2265 newline_and_indent (buffer, spc + 2);
2266 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2267 pp_space (buffer);
2268 pp_character (buffer, '=');
2269 pp_space (buffer);
2270 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2271 break;
2272
2169f33b 2273 case OMP_ATOMIC_READ:
2274 pp_string (buffer, "#pragma omp atomic read");
2275 newline_and_indent (buffer, spc + 2);
2276 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2277 pp_space (buffer);
2278 break;
2279
2280 case OMP_ATOMIC_CAPTURE_OLD:
2281 case OMP_ATOMIC_CAPTURE_NEW:
2282 pp_string (buffer, "#pragma omp atomic capture");
2283 newline_and_indent (buffer, spc + 2);
2284 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2285 pp_space (buffer);
2286 pp_character (buffer, '=');
2287 pp_space (buffer);
2288 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2289 break;
2290
1e8e9920 2291 case OMP_SINGLE:
2292 pp_string (buffer, "#pragma omp single");
2293 dump_omp_clauses (buffer, OMP_SINGLE_CLAUSES (node), spc, flags);
2294 goto dump_omp_body;
2295
55d6e7cd 2296 case OMP_CLAUSE:
2297 dump_omp_clause (buffer, node, spc, flags);
2298 is_expr = false;
2299 break;
2300
4c0315d0 2301 case TRANSACTION_EXPR:
2302 if (TRANSACTION_EXPR_OUTER (node))
2303 pp_string (buffer, "__transaction_atomic [[outer]]");
2304 else if (TRANSACTION_EXPR_RELAXED (node))
2305 pp_string (buffer, "__transaction_relaxed");
2306 else
2307 pp_string (buffer, "__transaction_atomic");
2308 if (!(flags & TDF_SLIM) && TRANSACTION_EXPR_BODY (node))
2309 {
2310 newline_and_indent (buffer, spc);
2311 pp_character (buffer, '{');
2312 newline_and_indent (buffer, spc + 2);
2313 dump_generic_node (buffer, TRANSACTION_EXPR_BODY (node),
2314 spc + 2, flags, false);
2315 newline_and_indent (buffer, spc);
2316 pp_character (buffer, '}');
2317 }
2318 is_expr = false;
2319 break;
2320
ea8f3370 2321 case REDUC_MAX_EXPR:
2322 pp_string (buffer, " REDUC_MAX_EXPR < ");
2323 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2324 pp_string (buffer, " > ");
2325 break;
2326
2327 case REDUC_MIN_EXPR:
2328 pp_string (buffer, " REDUC_MIN_EXPR < ");
2329 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2330 pp_string (buffer, " > ");
2331 break;
2332
2333 case REDUC_PLUS_EXPR:
2334 pp_string (buffer, " REDUC_PLUS_EXPR < ");
2335 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2336 pp_string (buffer, " > ");
2337 break;
2338
c6c91d61 2339 case VEC_WIDEN_MULT_HI_EXPR:
c6c91d61 2340 case VEC_WIDEN_MULT_LO_EXPR:
79a78f7f 2341 case VEC_WIDEN_MULT_EVEN_EXPR:
2342 case VEC_WIDEN_MULT_ODD_EXPR:
6083c152 2343 case VEC_WIDEN_LSHIFT_HI_EXPR:
6083c152 2344 case VEC_WIDEN_LSHIFT_LO_EXPR:
79a78f7f 2345 pp_character (buffer, ' ');
2346 for (str = tree_code_name [code]; *str; str++)
2347 pp_character (buffer, TOUPPER (*str));
2348 pp_string (buffer, " < ");
6083c152 2349 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2350 pp_string (buffer, ", ");
2351 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2352 pp_string (buffer, " > ");
2353 break;
2354
c6c91d61 2355 case VEC_UNPACK_HI_EXPR:
2356 pp_string (buffer, " VEC_UNPACK_HI_EXPR < ");
2357 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2358 pp_string (buffer, " > ");
2359 break;
2360
2361 case VEC_UNPACK_LO_EXPR:
2362 pp_string (buffer, " VEC_UNPACK_LO_EXPR < ");
2363 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2364 pp_string (buffer, " > ");
2365 break;
2366
8aa4e142 2367 case VEC_UNPACK_FLOAT_HI_EXPR:
2368 pp_string (buffer, " VEC_UNPACK_FLOAT_HI_EXPR < ");
2369 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2370 pp_string (buffer, " > ");
2371 break;
2372
2373 case VEC_UNPACK_FLOAT_LO_EXPR:
2374 pp_string (buffer, " VEC_UNPACK_FLOAT_LO_EXPR < ");
2375 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2376 pp_string (buffer, " > ");
2377 break;
2378
bb8107e7 2379 case VEC_PACK_TRUNC_EXPR:
2380 pp_string (buffer, " VEC_PACK_TRUNC_EXPR < ");
c6c91d61 2381 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2382 pp_string (buffer, ", ");
2383 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2384 pp_string (buffer, " > ");
2385 break;
8aa4e142 2386
c6c91d61 2387 case VEC_PACK_SAT_EXPR:
2388 pp_string (buffer, " VEC_PACK_SAT_EXPR < ");
2389 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2390 pp_string (buffer, ", ");
2391 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2392 pp_string (buffer, " > ");
2393 break;
8aa4e142 2394
2395 case VEC_PACK_FIX_TRUNC_EXPR:
2396 pp_string (buffer, " VEC_PACK_FIX_TRUNC_EXPR < ");
2397 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2398 pp_string (buffer, ", ");
2399 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2400 pp_string (buffer, " > ");
2401 break;
2402
1e8e9920 2403 case BLOCK:
7aa082e5 2404 dump_block_node (buffer, node, spc, flags);
2405 break;
1e8e9920 2406
4ee9c684 2407 default:
2408 NIY;
2409 }
2410
2411 if (is_stmt && is_expr)
2412 pp_semicolon (buffer);
b4c01899 2413
4ee9c684 2414 return spc;
2415}
2416
2417/* Print the declaration of a variable. */
2418
75a70cf9 2419void
4ee9c684 2420print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
2421{
4ee9c684 2422 INDENT (spc);
2423
d700b485 2424 if (TREE_CODE (t) == TYPE_DECL)
2425 pp_string (buffer, "typedef ");
2426
5ded8c6f 2427 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t))
4ee9c684 2428 pp_string (buffer, "register ");
2429
2430 if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
2431 pp_string (buffer, "extern ");
2432 else if (TREE_STATIC (t))
2433 pp_string (buffer, "static ");
2434
2435 /* Print the type and name. */
12e18540 2436 if (TREE_TYPE (t) && TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
4ee9c684 2437 {
2438 tree tmp;
2439
2440 /* Print array's type. */
2441 tmp = TREE_TYPE (t);
2442 while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
2443 tmp = TREE_TYPE (tmp);
2444 dump_generic_node (buffer, TREE_TYPE (tmp), spc, flags, false);
2445
2446 /* Print variable's name. */
2447 pp_space (buffer);
2448 dump_generic_node (buffer, t, spc, flags, false);
2449
2450 /* Print the dimensions. */
2451 tmp = TREE_TYPE (t);
2452 while (TREE_CODE (tmp) == ARRAY_TYPE)
2453 {
9b1a6180 2454 dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
4ee9c684 2455 tmp = TREE_TYPE (tmp);
2456 }
2457 }
d700b485 2458 else if (TREE_CODE (t) == FUNCTION_DECL)
2459 {
2460 dump_generic_node (buffer, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
2461 pp_space (buffer);
2462 dump_decl_name (buffer, t, flags);
2463 dump_function_declaration (buffer, TREE_TYPE (t), spc, flags);
2464 }
4ee9c684 2465 else
2466 {
2467 /* Print type declaration. */
2468 dump_generic_node (buffer, TREE_TYPE (t), spc, flags, false);
2469
2470 /* Print variable's name. */
2471 pp_space (buffer);
2472 dump_generic_node (buffer, t, spc, flags, false);
2473 }
2474
fbc51f36 2475 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
2476 {
2477 pp_string (buffer, " __asm__ ");
2478 pp_character (buffer, '(');
2479 dump_generic_node (buffer, DECL_ASSEMBLER_NAME (t), spc, flags, false);
2480 pp_character (buffer, ')');
2481 }
2482
f0b5f617 2483 /* The initial value of a function serves to determine whether the function
4ee9c684 2484 is declared or defined. So the following does not apply to function
2485 nodes. */
2486 if (TREE_CODE (t) != FUNCTION_DECL)
2487 {
2488 /* Print the initial value. */
2489 if (DECL_INITIAL (t))
2490 {
2491 pp_space (buffer);
2492 pp_character (buffer, '=');
2493 pp_space (buffer);
2494 dump_generic_node (buffer, DECL_INITIAL (t), spc, flags, false);
2495 }
2496 }
2497
1e8e9920 2498 if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t))
2499 {
2500 pp_string (buffer, " [value-expr: ");
2501 dump_generic_node (buffer, DECL_VALUE_EXPR (t), spc, flags, false);
2502 pp_character (buffer, ']');
2503 }
2504
4ee9c684 2505 pp_character (buffer, ';');
2506}
2507
2508
2509/* Prints a structure: name, fields, and methods.
2510 FIXME: Still incomplete. */
2511
2512static void
b4b34335 2513print_struct_decl (pretty_printer *buffer, const_tree node, int spc, int flags)
4ee9c684 2514{
2515 /* Print the name of the structure. */
2516 if (TYPE_NAME (node))
2517 {
2518 INDENT (spc);
2519 if (TREE_CODE (node) == RECORD_TYPE)
2520 pp_string (buffer, "struct ");
6374121b 2521 else if ((TREE_CODE (node) == UNION_TYPE
2522 || TREE_CODE (node) == QUAL_UNION_TYPE))
4ee9c684 2523 pp_string (buffer, "union ");
6374121b 2524
4ee9c684 2525 dump_generic_node (buffer, TYPE_NAME (node), spc, 0, false);
2526 }
2527
2528 /* Print the contents of the structure. */
2529 pp_newline (buffer);
2530 INDENT (spc);
2531 pp_character (buffer, '{');
2532 pp_newline (buffer);
2533
2534 /* Print the fields of the structure. */
2535 {
2536 tree tmp;
2537 tmp = TYPE_FIELDS (node);
2538 while (tmp)
2539 {
2540 /* Avoid to print recursively the structure. */
2541 /* FIXME : Not implemented correctly...,
2542 what about the case when we have a cycle in the contain graph? ...
2543 Maybe this could be solved by looking at the scope in which the
2544 structure was declared. */
2545 if (TREE_TYPE (tmp) != node
c6934f8a 2546 && (TREE_CODE (TREE_TYPE (tmp)) != POINTER_TYPE
2547 || TREE_TYPE (TREE_TYPE (tmp)) != node))
4ee9c684 2548 {
2549 print_declaration (buffer, tmp, spc+2, flags);
2550 pp_newline (buffer);
2551 }
1767a056 2552 tmp = DECL_CHAIN (tmp);
4ee9c684 2553 }
2554 }
2555 INDENT (spc);
2556 pp_character (buffer, '}');
2557}
2558
e70f5f27 2559/* Return the priority of the operator CODE.
4ee9c684 2560
2561 From lowest to highest precedence with either left-to-right (L-R)
2562 or right-to-left (R-L) associativity]:
2563
2564 1 [L-R] ,
2565 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
2566 3 [R-L] ?:
2567 4 [L-R] ||
2568 5 [L-R] &&
2569 6 [L-R] |
2570 7 [L-R] ^
2571 8 [L-R] &
2572 9 [L-R] == !=
2573 10 [L-R] < <= > >=
2574 11 [L-R] << >>
2575 12 [L-R] + -
2576 13 [L-R] * / %
2577 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
2578 15 [L-R] fn() [] -> .
2579
2580 unary +, - and * have higher precedence than the corresponding binary
2581 operators. */
2582
e70f5f27 2583int
2584op_code_prio (enum tree_code code)
4ee9c684 2585{
e70f5f27 2586 switch (code)
4ee9c684 2587 {
2588 case TREE_LIST:
2589 case COMPOUND_EXPR:
2590 case BIND_EXPR:
2591 return 1;
2592
2593 case MODIFY_EXPR:
2594 case INIT_EXPR:
2595 return 2;
2596
2597 case COND_EXPR:
2598 return 3;
2599
2600 case TRUTH_OR_EXPR:
2601 case TRUTH_ORIF_EXPR:
2602 return 4;
2603
2604 case TRUTH_AND_EXPR:
2605 case TRUTH_ANDIF_EXPR:
2606 return 5;
2607
2608 case BIT_IOR_EXPR:
2609 return 6;
2610
2611 case BIT_XOR_EXPR:
2612 case TRUTH_XOR_EXPR:
2613 return 7;
2614
2615 case BIT_AND_EXPR:
2616 return 8;
2617
2618 case EQ_EXPR:
2619 case NE_EXPR:
2620 return 9;
2621
318a728f 2622 case UNLT_EXPR:
2623 case UNLE_EXPR:
2624 case UNGT_EXPR:
2625 case UNGE_EXPR:
2626 case UNEQ_EXPR:
2627 case LTGT_EXPR:
2628 case ORDERED_EXPR:
2629 case UNORDERED_EXPR:
4ee9c684 2630 case LT_EXPR:
2631 case LE_EXPR:
2632 case GT_EXPR:
2633 case GE_EXPR:
2634 return 10;
2635
2636 case LSHIFT_EXPR:
2637 case RSHIFT_EXPR:
2638 case LROTATE_EXPR:
2639 case RROTATE_EXPR:
6083c152 2640 case VEC_WIDEN_LSHIFT_HI_EXPR:
2641 case VEC_WIDEN_LSHIFT_LO_EXPR:
2642 case WIDEN_LSHIFT_EXPR:
4ee9c684 2643 return 11;
2644
4a61a337 2645 case WIDEN_SUM_EXPR:
4ee9c684 2646 case PLUS_EXPR:
0de36bdb 2647 case POINTER_PLUS_EXPR:
4ee9c684 2648 case MINUS_EXPR:
2649 return 12;
2650
c6c91d61 2651 case VEC_WIDEN_MULT_HI_EXPR:
2652 case VEC_WIDEN_MULT_LO_EXPR:
4a61a337 2653 case WIDEN_MULT_EXPR:
2654 case DOT_PROD_EXPR:
00f4f705 2655 case WIDEN_MULT_PLUS_EXPR:
2656 case WIDEN_MULT_MINUS_EXPR:
4ee9c684 2657 case MULT_EXPR:
96504875 2658 case MULT_HIGHPART_EXPR:
4ee9c684 2659 case TRUNC_DIV_EXPR:
2660 case CEIL_DIV_EXPR:
2661 case FLOOR_DIV_EXPR:
2662 case ROUND_DIV_EXPR:
2663 case RDIV_EXPR:
2664 case EXACT_DIV_EXPR:
2665 case TRUNC_MOD_EXPR:
2666 case CEIL_MOD_EXPR:
2667 case FLOOR_MOD_EXPR:
2668 case ROUND_MOD_EXPR:
156f51b9 2669 case FMA_EXPR:
4ee9c684 2670 return 13;
2671
2672 case TRUTH_NOT_EXPR:
2673 case BIT_NOT_EXPR:
2674 case POSTINCREMENT_EXPR:
2675 case POSTDECREMENT_EXPR:
2676 case PREINCREMENT_EXPR:
2677 case PREDECREMENT_EXPR:
2678 case NEGATE_EXPR:
2679 case INDIRECT_REF:
2680 case ADDR_EXPR:
2681 case FLOAT_EXPR:
72dd6141 2682 CASE_CONVERT:
4ee9c684 2683 case FIX_TRUNC_EXPR:
4ee9c684 2684 case TARGET_EXPR:
2685 return 14;
2686
2687 case CALL_EXPR:
2688 case ARRAY_REF:
6374121b 2689 case ARRAY_RANGE_REF:
4ee9c684 2690 case COMPONENT_REF:
2691 return 15;
2692
2693 /* Special expressions. */
2694 case MIN_EXPR:
2695 case MAX_EXPR:
2696 case ABS_EXPR:
2697 case REALPART_EXPR:
2698 case IMAGPART_EXPR:
ea8f3370 2699 case REDUC_MAX_EXPR:
2700 case REDUC_MIN_EXPR:
2701 case REDUC_PLUS_EXPR:
925c62d4 2702 case VEC_LSHIFT_EXPR:
2703 case VEC_RSHIFT_EXPR:
c6c91d61 2704 case VEC_UNPACK_HI_EXPR:
2705 case VEC_UNPACK_LO_EXPR:
8aa4e142 2706 case VEC_UNPACK_FLOAT_HI_EXPR:
2707 case VEC_UNPACK_FLOAT_LO_EXPR:
bb8107e7 2708 case VEC_PACK_TRUNC_EXPR:
c6c91d61 2709 case VEC_PACK_SAT_EXPR:
4ee9c684 2710 return 16;
2711
4ee9c684 2712 default:
2713 /* Return an arbitrarily high precedence to avoid surrounding single
2714 VAR_DECLs in ()s. */
2715 return 9999;
2716 }
2717}
2718
e70f5f27 2719/* Return the priority of the operator OP. */
2720
2721int
2722op_prio (const_tree op)
2723{
2724 enum tree_code code;
2725
2726 if (op == NULL)
2727 return 9999;
2728
2729 code = TREE_CODE (op);
2730 if (code == SAVE_EXPR || code == NON_LVALUE_EXPR)
2731 return op_prio (TREE_OPERAND (op, 0));
2732
2733 return op_code_prio (code);
2734}
4ee9c684 2735
ad4a85ad 2736/* Return the symbol associated with operator CODE. */
4ee9c684 2737
ad4a85ad 2738const char *
2739op_symbol_code (enum tree_code code)
4ee9c684 2740{
1e8e9920 2741 switch (code)
4ee9c684 2742 {
2743 case MODIFY_EXPR:
2744 return "=";
2745
2746 case TRUTH_OR_EXPR:
2747 case TRUTH_ORIF_EXPR:
2748 return "||";
2749
2750 case TRUTH_AND_EXPR:
2751 case TRUTH_ANDIF_EXPR:
2752 return "&&";
2753
2754 case BIT_IOR_EXPR:
2755 return "|";
2756
2757 case TRUTH_XOR_EXPR:
2758 case BIT_XOR_EXPR:
2759 return "^";
2760
2761 case ADDR_EXPR:
2762 case BIT_AND_EXPR:
2763 return "&";
2764
318a728f 2765 case ORDERED_EXPR:
2766 return "ord";
2767 case UNORDERED_EXPR:
2768 return "unord";
2769
4ee9c684 2770 case EQ_EXPR:
4ee9c684 2771 return "==";
318a728f 2772 case UNEQ_EXPR:
2773 return "u==";
4ee9c684 2774
2775 case NE_EXPR:
2776 return "!=";
2777
2778 case LT_EXPR:
4ee9c684 2779 return "<";
318a728f 2780 case UNLT_EXPR:
2781 return "u<";
4ee9c684 2782
2783 case LE_EXPR:
4ee9c684 2784 return "<=";
318a728f 2785 case UNLE_EXPR:
2786 return "u<=";
4ee9c684 2787
2788 case GT_EXPR:
4ee9c684 2789 return ">";
318a728f 2790 case UNGT_EXPR:
2791 return "u>";
4ee9c684 2792
2793 case GE_EXPR:
4ee9c684 2794 return ">=";
318a728f 2795 case UNGE_EXPR:
2796 return "u>=";
2797
2798 case LTGT_EXPR:
2799 return "<>";
4ee9c684 2800
2801 case LSHIFT_EXPR:
2802 return "<<";
2803
2804 case RSHIFT_EXPR:
2805 return ">>";
2806
01329d30 2807 case LROTATE_EXPR:
2808 return "r<<";
2809
2810 case RROTATE_EXPR:
2811 return "r>>";
2812
925c62d4 2813 case VEC_LSHIFT_EXPR:
2814 return "v<<";
2815
2816 case VEC_RSHIFT_EXPR:
2817 return "v>>";
0de36bdb 2818
6083c152 2819 case WIDEN_LSHIFT_EXPR:
2820 return "w<<";
2821
0de36bdb 2822 case POINTER_PLUS_EXPR:
2823 return "+";
48e1416a 2824
4ee9c684 2825 case PLUS_EXPR:
2826 return "+";
2827
ea8f3370 2828 case REDUC_PLUS_EXPR:
2829 return "r+";
2830
4a61a337 2831 case WIDEN_SUM_EXPR:
2832 return "w+";
2833
2834 case WIDEN_MULT_EXPR:
2835 return "w*";
2836
96504875 2837 case MULT_HIGHPART_EXPR:
2838 return "h*";
2839
4ee9c684 2840 case NEGATE_EXPR:
2841 case MINUS_EXPR:
2842 return "-";
2843
2844 case BIT_NOT_EXPR:
2845 return "~";
2846
2847 case TRUTH_NOT_EXPR:
2848 return "!";
2849
2850 case MULT_EXPR:
2851 case INDIRECT_REF:
2852 return "*";
2853
2854 case TRUNC_DIV_EXPR:
153536df 2855 case RDIV_EXPR:
2856 return "/";
2857
4ee9c684 2858 case CEIL_DIV_EXPR:
153536df 2859 return "/[cl]";
2860
4ee9c684 2861 case FLOOR_DIV_EXPR:
153536df 2862 return "/[fl]";
2863
4ee9c684 2864 case ROUND_DIV_EXPR:
153536df 2865 return "/[rd]";
2866
4ee9c684 2867 case EXACT_DIV_EXPR:
153536df 2868 return "/[ex]";
4ee9c684 2869
2870 case TRUNC_MOD_EXPR:
153536df 2871 return "%";
2872
4ee9c684 2873 case CEIL_MOD_EXPR:
153536df 2874 return "%[cl]";
2875
4ee9c684 2876 case FLOOR_MOD_EXPR:
153536df 2877 return "%[fl]";
2878
4ee9c684 2879 case ROUND_MOD_EXPR:
153536df 2880 return "%[rd]";
4ee9c684 2881
2882 case PREDECREMENT_EXPR:
2883 return " --";
2884
2885 case PREINCREMENT_EXPR:
2886 return " ++";
2887
2888 case POSTDECREMENT_EXPR:
2889 return "-- ";
2890
2891 case POSTINCREMENT_EXPR:
2892 return "++ ";
2893
1e8e9920 2894 case MAX_EXPR:
2895 return "max";
2896
2897 case MIN_EXPR:
2898 return "min";
2899
4ee9c684 2900 default:
2901 return "<<< ??? >>>";
2902 }
2903}
2904
ad4a85ad 2905/* Return the symbol associated with operator OP. */
2906
1e8e9920 2907static const char *
b4b34335 2908op_symbol (const_tree op)
1e8e9920 2909{
ad4a85ad 2910 return op_symbol_code (TREE_CODE (op));
1e8e9920 2911}
2912
4437c3fe 2913/* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
2914 the gimple_call_fn of a GIMPLE_CALL. */
4ee9c684 2915
4437c3fe 2916void
8c1f2562 2917print_call_name (pretty_printer *buffer, tree node, int flags)
4ee9c684 2918{
4437c3fe 2919 tree op0 = node;
4ee9c684 2920
2921 if (TREE_CODE (op0) == NON_LVALUE_EXPR)
2922 op0 = TREE_OPERAND (op0, 0);
2923
4437c3fe 2924 again:
4ee9c684 2925 switch (TREE_CODE (op0))
2926 {
2927 case VAR_DECL:
2928 case PARM_DECL:
4437c3fe 2929 case FUNCTION_DECL:
8c1f2562 2930 dump_function_name (buffer, op0, flags);
4ee9c684 2931 break;
2932
2933 case ADDR_EXPR:
2934 case INDIRECT_REF:
2935 case NOP_EXPR:
4437c3fe 2936 op0 = TREE_OPERAND (op0, 0);
2937 goto again;
4ee9c684 2938
2939 case COND_EXPR:
2940 pp_string (buffer, "(");
8c1f2562 2941 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, flags, false);
4ee9c684 2942 pp_string (buffer, ") ? ");
8c1f2562 2943 dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, flags, false);
4ee9c684 2944 pp_string (buffer, " : ");
8c1f2562 2945 dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, flags, false);
4ee9c684 2946 break;
2947
4ee9c684 2948 case ARRAY_REF:
2949 if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
8c1f2562 2950 dump_function_name (buffer, TREE_OPERAND (op0, 0), flags);
4ee9c684 2951 else
8c1f2562 2952 dump_generic_node (buffer, op0, 0, flags, false);
4ee9c684 2953 break;
2954
182cf5a9 2955 case MEM_REF:
2956 if (integer_zerop (TREE_OPERAND (op0, 1)))
2957 {
2958 op0 = TREE_OPERAND (op0, 0);
2959 goto again;
2960 }
2961 /* Fallthru. */
2692ac97 2962 case COMPONENT_REF:
4ee9c684 2963 case SSA_NAME:
215e2f1d 2964 case OBJ_TYPE_REF:
8c1f2562 2965 dump_generic_node (buffer, op0, 0, flags, false);
4ee9c684 2966 break;
2967
2968 default:
2969 NIY;
2970 }
2971}
2972
2973/* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
2974
2975static void
2976pretty_print_string (pretty_printer *buffer, const char *str)
2977{
2978 if (str == NULL)
2979 return;
2980
2981 while (*str)
2982 {
2983 switch (str[0])
2984 {
2985 case '\b':
2986 pp_string (buffer, "\\b");
2987 break;
2988
2989 case '\f':
2990 pp_string (buffer, "\\f");
2991 break;
2992
2993 case '\n':
2994 pp_string (buffer, "\\n");
2995 break;
2996
2997 case '\r':
2998 pp_string (buffer, "\\r");
2999 break;
3000
3001 case '\t':
3002 pp_string (buffer, "\\t");
3003 break;
3004
3005 case '\v':
3006 pp_string (buffer, "\\v");
3007 break;
3008
3009 case '\\':
3010 pp_string (buffer, "\\\\");
3011 break;
3012
3013 case '\"':
3014 pp_string (buffer, "\\\"");
3015 break;
3016
3017 case '\'':
3018 pp_string (buffer, "\\'");
3019 break;
3020
32a9fcf7 3021 /* No need to handle \0; the loop terminates on \0. */
4ee9c684 3022
3023 case '\1':
3024 pp_string (buffer, "\\1");
3025 break;
3026
3027 case '\2':
3028 pp_string (buffer, "\\2");
3029 break;
3030
3031 case '\3':
3032 pp_string (buffer, "\\3");
3033 break;
3034
3035 case '\4':
3036 pp_string (buffer, "\\4");
3037 break;
3038
3039 case '\5':
3040 pp_string (buffer, "\\5");
3041 break;
3042
3043 case '\6':
3044 pp_string (buffer, "\\6");
3045 break;
3046
3047 case '\7':
3048 pp_string (buffer, "\\7");
3049 break;
3050
3051 default:
3052 pp_character (buffer, str[0]);
3053 break;
3054 }
3055 str++;
3056 }
3057}
3058
3059static void
3060maybe_init_pretty_print (FILE *file)
3061{
3062 if (!initialized)
3063 {
3064 pp_construct (&buffer, /* prefix */NULL, /* line-width */0);
3065 pp_needs_newline (&buffer) = true;
a608187f 3066 pp_translate_identifiers (&buffer) = false;
4ee9c684 3067 initialized = 1;
3068 }
3069
3070 buffer.buffer->stream = file;
3071}
3072
3073static void
3074newline_and_indent (pretty_printer *buffer, int spc)
3075{
3076 pp_newline (buffer);
3077 INDENT (spc);
3078}
ce084dfc 3079
3080/* Handle a %K format for TEXT. Separate from default_tree_printer so
3081 it can also be used in front ends.
3082 %K: a statement, from which EXPR_LOCATION and TREE_BLOCK will be recorded.
3083*/
3084
3085void
3086percent_K_format (text_info *text)
3087{
3088 tree t = va_arg (*text->args_ptr, tree), block;
3089 gcc_assert (text->locus != NULL);
3090 *text->locus = EXPR_LOCATION (t);
3091 gcc_assert (pp_ti_abstract_origin (text) != NULL);
3092 block = TREE_BLOCK (t);
3093 *pp_ti_abstract_origin (text) = NULL;
3094 while (block
3095 && TREE_CODE (block) == BLOCK
3096 && BLOCK_ABSTRACT_ORIGIN (block))
3097 {
3098 tree ao = BLOCK_ABSTRACT_ORIGIN (block);
3099
3100 while (TREE_CODE (ao) == BLOCK
3101 && BLOCK_ABSTRACT_ORIGIN (ao)
3102 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
3103 ao = BLOCK_ABSTRACT_ORIGIN (ao);
3104
3105 if (TREE_CODE (ao) == FUNCTION_DECL)
3106 {
3107 *pp_ti_abstract_origin (text) = block;
3108 break;
3109 }
3110 block = BLOCK_SUPERCONTEXT (block);
3111 }
3112}
3113
3114/* Print the identifier ID to PRETTY-PRINTER. */
3115
3116void
3117pp_base_tree_identifier (pretty_printer *pp, tree id)
3118{
3119 if (pp_translate_identifiers (pp))
3120 {
3121 const char *text = identifier_to_locale (IDENTIFIER_POINTER (id));
3122 pp_append_text (pp, text, text + strlen (text));
3123 }
3124 else
3125 pp_append_text (pp, IDENTIFIER_POINTER (id),
3126 IDENTIFIER_POINTER (id) + IDENTIFIER_LENGTH (id));
3127}
7009b7bd 3128
3129/* A helper function that is used to dump function information before the
3130 function dump. */
3131
3132void
55b028fe 3133dump_function_header (FILE *dump_file, tree fdecl, int flags)
7009b7bd 3134{
3135 const char *dname, *aname;
3136 struct cgraph_node *node = cgraph_get_node (fdecl);
3137 struct function *fun = DECL_STRUCT_FUNCTION (fdecl);
3138
3139 dname = lang_hooks.decl_printable_name (fdecl, 2);
3140
3141 if (DECL_ASSEMBLER_NAME_SET_P (fdecl))
3142 aname = (IDENTIFIER_POINTER
3143 (DECL_ASSEMBLER_NAME (fdecl)));
3144 else
3145 aname = "<unset-asm-name>";
3146
55b028fe 3147 fprintf (dump_file, "\n;; Function %s (%s, funcdef_no=%d",
3148 dname, aname, fun->funcdef_no);
3149 if (!(flags & TDF_NOUID))
3150 fprintf (dump_file, ", decl_uid=%d", DECL_UID (fdecl));
7009b7bd 3151 if (node)
3152 {
55b028fe 3153 fprintf (dump_file, ", cgraph_uid=%d)%s\n\n", node->uid,
7009b7bd 3154 node->frequency == NODE_FREQUENCY_HOT
3155 ? " (hot)"
3156 : node->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED
3157 ? " (unlikely executed)"
3158 : node->frequency == NODE_FREQUENCY_EXECUTED_ONCE
3159 ? " (executed once)"
3160 : "");
3161 }
3162 else
55b028fe 3163 fprintf (dump_file, ")\n\n");
7009b7bd 3164}
Mirror of https://gcc.gnu.org/git/gcc.git