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