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