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