?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Daily bump.
[official-gcc.git] / gcc / tree-pretty-print.c
blob63ec823c0bad8d0d2e3f6ed3426656174c1084a9
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 ABSU_EXPR:
2466 pp_string (pp, "ABSU_EXPR <");
2467 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2468 pp_greater (pp);
2469 break;
2470
2471 case RANGE_EXPR:
2472 NIY;
2473 break;
2474
2475 case ADDR_SPACE_CONVERT_EXPR:
2476 case FIXED_CONVERT_EXPR:
2477 case FIX_TRUNC_EXPR:
2478 case FLOAT_EXPR:
2479 CASE_CONVERT:
2480 type = TREE_TYPE (node);
2481 op0 = TREE_OPERAND (node, 0);
2482 if (type != TREE_TYPE (op0))
2483 {
2484 pp_left_paren (pp);
2485 dump_generic_node (pp, type, spc, flags, false);
2486 pp_string (pp, ") ");
2487 }
2488 if (op_prio (op0) < op_prio (node))
2489 pp_left_paren (pp);
2490 dump_generic_node (pp, op0, spc, flags, false);
2491 if (op_prio (op0) < op_prio (node))
2492 pp_right_paren (pp);
2493 break;
2494
2495 case VIEW_CONVERT_EXPR:
2496 pp_string (pp, "VIEW_CONVERT_EXPR<");
2497 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2498 pp_string (pp, ">(");
2499 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2500 pp_right_paren (pp);
2501 break;
2502
2503 case PAREN_EXPR:
2504 pp_string (pp, "((");
2505 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2506 pp_string (pp, "))");
2507 break;
2508
2509 case NON_LVALUE_EXPR:
2510 pp_string (pp, "NON_LVALUE_EXPR <");
2511 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2512 pp_greater (pp);
2513 break;
2514
2515 case SAVE_EXPR:
2516 pp_string (pp, "SAVE_EXPR <");
2517 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2518 pp_greater (pp);
2519 break;
2520
2521 case COMPLEX_EXPR:
2522 pp_string (pp, "COMPLEX_EXPR <");
2523 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2524 pp_string (pp, ", ");
2525 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2526 pp_greater (pp);
2527 break;
2528
2529 case CONJ_EXPR:
2530 pp_string (pp, "CONJ_EXPR <");
2531 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2532 pp_greater (pp);
2533 break;
2534
2535 case REALPART_EXPR:
2536 if (flags & TDF_GIMPLE)
2537 {
2538 pp_string (pp, "__real ");
2539 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2540 }
2541 else
2542 {
2543 pp_string (pp, "REALPART_EXPR <");
2544 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2545 pp_greater (pp);
2546 }
2547 break;
2548
2549 case IMAGPART_EXPR:
2550 if (flags & TDF_GIMPLE)
2551 {
2552 pp_string (pp, "__imag ");
2553 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2554 }
2555 else
2556 {
2557 pp_string (pp, "IMAGPART_EXPR <");
2558 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2559 pp_greater (pp);
2560 }
2561 break;
2562
2563 case VA_ARG_EXPR:
2564 pp_string (pp, "VA_ARG_EXPR <");
2565 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2566 pp_greater (pp);
2567 break;
2568
2569 case TRY_FINALLY_EXPR:
2570 case TRY_CATCH_EXPR:
2571 pp_string (pp, "try");
2572 newline_and_indent (pp, spc+2);
2573 pp_left_brace (pp);
2574 newline_and_indent (pp, spc+4);
2575 dump_generic_node (pp, TREE_OPERAND (node, 0), spc+4, flags, true);
2576 newline_and_indent (pp, spc+2);
2577 pp_right_brace (pp);
2578 newline_and_indent (pp, spc);
2579 pp_string (pp,
2580 (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");
2581 newline_and_indent (pp, spc+2);
2582 pp_left_brace (pp);
2583 newline_and_indent (pp, spc+4);
2584 dump_generic_node (pp, TREE_OPERAND (node, 1), spc+4, flags, true);
2585 newline_and_indent (pp, spc+2);
2586 pp_right_brace (pp);
2587 is_expr = false;
2588 break;
2589
2590 case CATCH_EXPR:
2591 pp_string (pp, "catch (");
2592 dump_generic_node (pp, CATCH_TYPES (node), spc+2, flags, false);
2593 pp_right_paren (pp);
2594 newline_and_indent (pp, spc+2);
2595 pp_left_brace (pp);
2596 newline_and_indent (pp, spc+4);
2597 dump_generic_node (pp, CATCH_BODY (node), spc+4, flags, true);
2598 newline_and_indent (pp, spc+2);
2599 pp_right_brace (pp);
2600 is_expr = false;
2601 break;
2602
2603 case EH_FILTER_EXPR:
2604 pp_string (pp, "<<<eh_filter (");
2605 dump_generic_node (pp, EH_FILTER_TYPES (node), spc+2, flags, false);
2606 pp_string (pp, ")>>>");
2607 newline_and_indent (pp, spc+2);
2608 pp_left_brace (pp);
2609 newline_and_indent (pp, spc+4);
2610 dump_generic_node (pp, EH_FILTER_FAILURE (node), spc+4, flags, true);
2611 newline_and_indent (pp, spc+2);
2612 pp_right_brace (pp);
2613 is_expr = false;
2614 break;
2615
2616 case LABEL_EXPR:
2617 op0 = TREE_OPERAND (node, 0);
2618 /* If this is for break or continue, don't bother printing it. */
2619 if (DECL_NAME (op0))
2620 {
2621 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
2622 if (strcmp (name, "break") == 0
2623 || strcmp (name, "continue") == 0)
2624 break;
2625 }
2626 dump_generic_node (pp, op0, spc, flags, false);
2627 pp_colon (pp);
2628 if (DECL_NONLOCAL (op0))
2629 pp_string (pp, " [non-local]");
2630 break;
2631
2632 case LOOP_EXPR:
2633 pp_string (pp, "while (1)");
2634 if (!(flags & TDF_SLIM))
2635 {
2636 newline_and_indent (pp, spc+2);
2637 pp_left_brace (pp);
2638 newline_and_indent (pp, spc+4);
2639 dump_generic_node (pp, LOOP_EXPR_BODY (node), spc+4, flags, true);
2640 newline_and_indent (pp, spc+2);
2641 pp_right_brace (pp);
2642 }
2643 is_expr = false;
2644 break;
2645
2646 case PREDICT_EXPR:
2647 pp_string (pp, "// predicted ");
2648 if (PREDICT_EXPR_OUTCOME (node))
2649 pp_string (pp, "likely by ");
2650 else
2651 pp_string (pp, "unlikely by ");
2652 pp_string (pp, predictor_name (PREDICT_EXPR_PREDICTOR (node)));
2653 pp_string (pp, " predictor.");
2654 break;
2655
2656 case ANNOTATE_EXPR:
2657 pp_string (pp, "ANNOTATE_EXPR <");
2658 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2659 switch ((enum annot_expr_kind) TREE_INT_CST_LOW (TREE_OPERAND (node, 1)))
2660 {
2661 case annot_expr_ivdep_kind:
2662 pp_string (pp, ", ivdep");
2663 break;
2664 case annot_expr_unroll_kind:
2665 pp_printf (pp, ", unroll %d",
2666 (int) TREE_INT_CST_LOW (TREE_OPERAND (node, 2)));
2667 break;
2668 case annot_expr_no_vector_kind:
2669 pp_string (pp, ", no-vector");
2670 break;
2671 case annot_expr_vector_kind:
2672 pp_string (pp, ", vector");
2673 break;
2674 case annot_expr_parallel_kind:
2675 pp_string (pp, ", parallel");
2676 break;
2677 default:
2678 gcc_unreachable ();
2679 }
2680 pp_greater (pp);
2681 break;
2682
2683 case RETURN_EXPR:
2684 pp_string (pp, "return");
2685 op0 = TREE_OPERAND (node, 0);
2686 if (op0)
2687 {
2688 pp_space (pp);
2689 if (TREE_CODE (op0) == MODIFY_EXPR)
2690 dump_generic_node (pp, TREE_OPERAND (op0, 1),
2691 spc, flags, false);
2692 else
2693 dump_generic_node (pp, op0, spc, flags, false);
2694 }
2695 break;
2696
2697 case EXIT_EXPR:
2698 pp_string (pp, "if (");
2699 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2700 pp_string (pp, ") break");
2701 break;
2702
2703 case SWITCH_EXPR:
2704 pp_string (pp, "switch (");
2705 dump_generic_node (pp, SWITCH_COND (node), spc, flags, false);
2706 pp_right_paren (pp);
2707 if (!(flags & TDF_SLIM))
2708 {
2709 newline_and_indent (pp, spc+2);
2710 pp_left_brace (pp);
2711 if (SWITCH_BODY (node))
2712 {
2713 newline_and_indent (pp, spc+4);
2714 dump_generic_node (pp, SWITCH_BODY (node), spc+4, flags,
2715 true);
2716 }
2717 newline_and_indent (pp, spc+2);
2718 pp_right_brace (pp);
2719 }
2720 is_expr = false;
2721 break;
2722
2723 case GOTO_EXPR:
2724 op0 = GOTO_DESTINATION (node);
2725 if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
2726 {
2727 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
2728 if (strcmp (name, "break") == 0
2729 || strcmp (name, "continue") == 0)
2730 {
2731 pp_string (pp, name);
2732 break;
2733 }
2734 }
2735 pp_string (pp, "goto ");
2736 dump_generic_node (pp, op0, spc, flags, false);
2737 break;
2738
2739 case ASM_EXPR:
2740 pp_string (pp, "__asm__");
2741 if (ASM_VOLATILE_P (node))
2742 pp_string (pp, " __volatile__");
2743 pp_left_paren (pp);
2744 dump_generic_node (pp, ASM_STRING (node), spc, flags, false);
2745 pp_colon (pp);
2746 dump_generic_node (pp, ASM_OUTPUTS (node), spc, flags, false);
2747 pp_colon (pp);
2748 dump_generic_node (pp, ASM_INPUTS (node), spc, flags, false);
2749 if (ASM_CLOBBERS (node))
2750 {
2751 pp_colon (pp);
2752 dump_generic_node (pp, ASM_CLOBBERS (node), spc, flags, false);
2753 }
2754 pp_right_paren (pp);
2755 break;
2756
2757 case CASE_LABEL_EXPR:
2758 if (CASE_LOW (node) && CASE_HIGH (node))
2759 {
2760 pp_string (pp, "case ");
2761 dump_generic_node (pp, CASE_LOW (node), spc, flags, false);
2762 pp_string (pp, " ... ");
2763 dump_generic_node (pp, CASE_HIGH (node), spc, flags, false);
2764 }
2765 else if (CASE_LOW (node))
2766 {
2767 pp_string (pp, "case ");
2768 dump_generic_node (pp, CASE_LOW (node), spc, flags, false);
2769 }
2770 else
2771 pp_string (pp, "default");
2772 pp_colon (pp);
2773 break;
2774
2775 case OBJ_TYPE_REF:
2776 pp_string (pp, "OBJ_TYPE_REF(");
2777 dump_generic_node (pp, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
2778 pp_semicolon (pp);
2779 /* We omit the class type for -fcompare-debug because we may
2780 drop TYPE_BINFO early depending on debug info, and then
2781 virtual_method_call_p would return false, whereas when
2782 TYPE_BINFO is preserved it may still return true and then
2783 we'd print the class type. Compare tree and rtl dumps for
2784 libstdc++-prettyprinters/shared_ptr.cc with and without -g,
2785 for example, at occurrences of OBJ_TYPE_REF. */
2786 if (!(flags & (TDF_SLIM | TDF_COMPARE_DEBUG))
2787 && virtual_method_call_p (node))
2788 {
2789 pp_string (pp, "(");
2790 dump_generic_node (pp, obj_type_ref_class (node), spc, flags, false);
2791 pp_string (pp, ")");
2792 }
2793 dump_generic_node (pp, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
2794 pp_arrow (pp);
2795 dump_generic_node (pp, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
2796 pp_right_paren (pp);
2797 break;
2798
2799 case SSA_NAME:
2800 if (SSA_NAME_IDENTIFIER (node))
2801 {
2802 if ((flags & TDF_NOUID)
2803 && SSA_NAME_VAR (node)
2804 && DECL_NAMELESS (SSA_NAME_VAR (node)))
2805 dump_fancy_name (pp, SSA_NAME_IDENTIFIER (node));
2806 else if (! (flags & TDF_GIMPLE)
2807 || SSA_NAME_VAR (node))
2808 dump_generic_node (pp, SSA_NAME_IDENTIFIER (node),
2809 spc, flags, false);
2810 }
2811 pp_underscore (pp);
2812 pp_decimal_int (pp, SSA_NAME_VERSION (node));
2813 if (SSA_NAME_IS_DEFAULT_DEF (node))
2814 pp_string (pp, "(D)");
2815 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
2816 pp_string (pp, "(ab)");
2817 break;
2818
2819 case WITH_SIZE_EXPR:
2820 pp_string (pp, "WITH_SIZE_EXPR <");
2821 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2822 pp_string (pp, ", ");
2823 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2824 pp_greater (pp);
2825 break;
2826
2827 case ASSERT_EXPR:
2828 pp_string (pp, "ASSERT_EXPR <");
2829 dump_generic_node (pp, ASSERT_EXPR_VAR (node), spc, flags, false);
2830 pp_string (pp, ", ");
2831 dump_generic_node (pp, ASSERT_EXPR_COND (node), spc, flags, false);
2832 pp_greater (pp);
2833 break;
2834
2835 case SCEV_KNOWN:
2836 pp_string (pp, "scev_known");
2837 break;
2838
2839 case SCEV_NOT_KNOWN:
2840 pp_string (pp, "scev_not_known");
2841 break;
2842
2843 case POLYNOMIAL_CHREC:
2844 pp_left_brace (pp);
2845 dump_generic_node (pp, CHREC_LEFT (node), spc, flags, false);
2846 pp_string (pp, ", +, ");
2847 dump_generic_node (pp, CHREC_RIGHT (node), spc, flags, false);
2848 pp_printf (pp, "}_%u", CHREC_VARIABLE (node));
2849 is_stmt = false;
2850 break;
2851
2852 case REALIGN_LOAD_EXPR:
2853 pp_string (pp, "REALIGN_LOAD <");
2854 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2855 pp_string (pp, ", ");
2856 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2857 pp_string (pp, ", ");
2858 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2859 pp_greater (pp);
2860 break;
2861
2862 case VEC_COND_EXPR:
2863 pp_string (pp, " VEC_COND_EXPR < ");
2864 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2865 pp_string (pp, " , ");
2866 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2867 pp_string (pp, " , ");
2868 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2869 pp_string (pp, " > ");
2870 break;
2871
2872 case VEC_PERM_EXPR:
2873 pp_string (pp, " VEC_PERM_EXPR < ");
2874 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2875 pp_string (pp, " , ");
2876 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2877 pp_string (pp, " , ");
2878 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2879 pp_string (pp, " > ");
2880 break;
2881
2882 case DOT_PROD_EXPR:
2883 pp_string (pp, " DOT_PROD_EXPR < ");
2884 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2885 pp_string (pp, ", ");
2886 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2887 pp_string (pp, ", ");
2888 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2889 pp_string (pp, " > ");
2890 break;
2891
2892 case WIDEN_MULT_PLUS_EXPR:
2893 pp_string (pp, " WIDEN_MULT_PLUS_EXPR < ");
2894 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2895 pp_string (pp, ", ");
2896 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2897 pp_string (pp, ", ");
2898 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2899 pp_string (pp, " > ");
2900 break;
2901
2902 case WIDEN_MULT_MINUS_EXPR:
2903 pp_string (pp, " WIDEN_MULT_MINUS_EXPR < ");
2904 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2905 pp_string (pp, ", ");
2906 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2907 pp_string (pp, ", ");
2908 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2909 pp_string (pp, " > ");
2910 break;
2911
2912 case OACC_PARALLEL:
2913 pp_string (pp, "#pragma acc parallel");
2914 goto dump_omp_clauses_body;
2915
2916 case OACC_KERNELS:
2917 pp_string (pp, "#pragma acc kernels");
2918 goto dump_omp_clauses_body;
2919
2920 case OACC_DATA:
2921 pp_string (pp, "#pragma acc data");
2922 dump_omp_clauses (pp, OACC_DATA_CLAUSES (node), spc, flags);
2923 goto dump_omp_body;
2924
2925 case OACC_HOST_DATA:
2926 pp_string (pp, "#pragma acc host_data");
2927 dump_omp_clauses (pp, OACC_HOST_DATA_CLAUSES (node), spc, flags);
2928 goto dump_omp_body;
2929
2930 case OACC_DECLARE:
2931 pp_string (pp, "#pragma acc declare");
2932 dump_omp_clauses (pp, OACC_DECLARE_CLAUSES (node), spc, flags);
2933 break;
2934
2935 case OACC_UPDATE:
2936 pp_string (pp, "#pragma acc update");
2937 dump_omp_clauses (pp, OACC_UPDATE_CLAUSES (node), spc, flags);
2938 break;
2939
2940 case OACC_ENTER_DATA:
2941 pp_string (pp, "#pragma acc enter data");
2942 dump_omp_clauses (pp, OACC_ENTER_DATA_CLAUSES (node), spc, flags);
2943 break;
2944
2945 case OACC_EXIT_DATA:
2946 pp_string (pp, "#pragma acc exit data");
2947 dump_omp_clauses (pp, OACC_EXIT_DATA_CLAUSES (node), spc, flags);
2948 break;
2949
2950 case OACC_CACHE:
2951 pp_string (pp, "#pragma acc cache");
2952 dump_omp_clauses (pp, OACC_CACHE_CLAUSES (node), spc, flags);
2953 break;
2954
2955 case OMP_PARALLEL:
2956 pp_string (pp, "#pragma omp parallel");
2957 dump_omp_clauses (pp, OMP_PARALLEL_CLAUSES (node), spc, flags);
2958 goto dump_omp_body;
2959
2960 dump_omp_clauses_body:
2961 dump_omp_clauses (pp, OMP_CLAUSES (node), spc, flags);
2962 goto dump_omp_body;
2963
2964 dump_omp_body:
2965 if (!(flags & TDF_SLIM) && OMP_BODY (node))
2966 {
2967 newline_and_indent (pp, spc + 2);
2968 pp_left_brace (pp);
2969 newline_and_indent (pp, spc + 4);
2970 dump_generic_node (pp, OMP_BODY (node), spc + 4, flags, false);
2971 newline_and_indent (pp, spc + 2);
2972 pp_right_brace (pp);
2973 }
2974 is_expr = false;
2975 break;
2976
2977 case OMP_TASK:
2978 pp_string (pp, "#pragma omp task");
2979 dump_omp_clauses (pp, OMP_TASK_CLAUSES (node), spc, flags);
2980 goto dump_omp_body;
2981
2982 case OMP_FOR:
2983 pp_string (pp, "#pragma omp for");
2984 goto dump_omp_loop;
2985
2986 case OMP_SIMD:
2987 pp_string (pp, "#pragma omp simd");
2988 goto dump_omp_loop;
2989
2990 case OMP_DISTRIBUTE:
2991 pp_string (pp, "#pragma omp distribute");
2992 goto dump_omp_loop;
2993
2994 case OMP_TASKLOOP:
2995 pp_string (pp, "#pragma omp taskloop");
2996 goto dump_omp_loop;
2997
2998 case OACC_LOOP:
2999 pp_string (pp, "#pragma acc loop");
3000 goto dump_omp_loop;
3001
3002 case OMP_TEAMS:
3003 pp_string (pp, "#pragma omp teams");
3004 dump_omp_clauses (pp, OMP_TEAMS_CLAUSES (node), spc, flags);
3005 goto dump_omp_body;
3006
3007 case OMP_TARGET_DATA:
3008 pp_string (pp, "#pragma omp target data");
3009 dump_omp_clauses (pp, OMP_TARGET_DATA_CLAUSES (node), spc, flags);
3010 goto dump_omp_body;
3011
3012 case OMP_TARGET_ENTER_DATA:
3013 pp_string (pp, "#pragma omp target enter data");
3014 dump_omp_clauses (pp, OMP_TARGET_ENTER_DATA_CLAUSES (node), spc, flags);
3015 is_expr = false;
3016 break;
3017
3018 case OMP_TARGET_EXIT_DATA:
3019 pp_string (pp, "#pragma omp target exit data");
3020 dump_omp_clauses (pp, OMP_TARGET_EXIT_DATA_CLAUSES (node), spc, flags);
3021 is_expr = false;
3022 break;
3023
3024 case OMP_TARGET:
3025 pp_string (pp, "#pragma omp target");
3026 dump_omp_clauses (pp, OMP_TARGET_CLAUSES (node), spc, flags);
3027 goto dump_omp_body;
3028
3029 case OMP_TARGET_UPDATE:
3030 pp_string (pp, "#pragma omp target update");
3031 dump_omp_clauses (pp, OMP_TARGET_UPDATE_CLAUSES (node), spc, flags);
3032 is_expr = false;
3033 break;
3034
3035 dump_omp_loop:
3036 dump_omp_clauses (pp, OMP_FOR_CLAUSES (node), spc, flags);
3037 if (!(flags & TDF_SLIM))
3038 {
3039 int i;
3040
3041 if (OMP_FOR_PRE_BODY (node))
3042 {
3043 newline_and_indent (pp, spc + 2);
3044 pp_left_brace (pp);
3045 spc += 4;
3046 newline_and_indent (pp, spc);
3047 dump_generic_node (pp, OMP_FOR_PRE_BODY (node),
3048 spc, flags, false);
3049 }
3050 if (OMP_FOR_INIT (node))
3051 {
3052 spc -= 2;
3053 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (node)); i++)
3054 {
3055 spc += 2;
3056 newline_and_indent (pp, spc);
3057 pp_string (pp, "for (");
3058 dump_generic_node (pp,
3059 TREE_VEC_ELT (OMP_FOR_INIT (node), i),
3060 spc, flags, false);
3061 pp_string (pp, "; ");
3062 dump_generic_node (pp,
3063 TREE_VEC_ELT (OMP_FOR_COND (node), i),
3064 spc, flags, false);
3065 pp_string (pp, "; ");
3066 dump_generic_node (pp,
3067 TREE_VEC_ELT (OMP_FOR_INCR (node), i),
3068 spc, flags, false);
3069 pp_right_paren (pp);
3070 }
3071 }
3072 if (OMP_FOR_BODY (node))
3073 {
3074 newline_and_indent (pp, spc + 2);
3075 pp_left_brace (pp);
3076 newline_and_indent (pp, spc + 4);
3077 dump_generic_node (pp, OMP_FOR_BODY (node), spc + 4, flags,
3078 false);
3079 newline_and_indent (pp, spc + 2);
3080 pp_right_brace (pp);
3081 }
3082 if (OMP_FOR_INIT (node))
3083 spc -= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node)) - 2;
3084 if (OMP_FOR_PRE_BODY (node))
3085 {
3086 spc -= 4;
3087 newline_and_indent (pp, spc + 2);
3088 pp_right_brace (pp);
3089 }
3090 }
3091 is_expr = false;
3092 break;
3093
3094 case OMP_SECTIONS:
3095 pp_string (pp, "#pragma omp sections");
3096 dump_omp_clauses (pp, OMP_SECTIONS_CLAUSES (node), spc, flags);
3097 goto dump_omp_body;
3098
3099 case OMP_SECTION:
3100 pp_string (pp, "#pragma omp section");
3101 goto dump_omp_body;
3102
3103 case OMP_MASTER:
3104 pp_string (pp, "#pragma omp master");
3105 goto dump_omp_body;
3106
3107 case OMP_TASKGROUP:
3108 pp_string (pp, "#pragma omp taskgroup");
3109 goto dump_omp_body;
3110
3111 case OMP_ORDERED:
3112 pp_string (pp, "#pragma omp ordered");
3113 dump_omp_clauses (pp, OMP_ORDERED_CLAUSES (node), spc, flags);
3114 goto dump_omp_body;
3115
3116 case OMP_CRITICAL:
3117 pp_string (pp, "#pragma omp critical");
3118 if (OMP_CRITICAL_NAME (node))
3119 {
3120 pp_space (pp);
3121 pp_left_paren (pp);
3122 dump_generic_node (pp, OMP_CRITICAL_NAME (node), spc,
3123 flags, false);
3124 pp_right_paren (pp);
3125 }
3126 dump_omp_clauses (pp, OMP_CRITICAL_CLAUSES (node), spc, flags);
3127 goto dump_omp_body;
3128
3129 case OMP_ATOMIC:
3130 pp_string (pp, "#pragma omp atomic");
3131 if (OMP_ATOMIC_SEQ_CST (node))
3132 pp_string (pp, " seq_cst");
3133 newline_and_indent (pp, spc + 2);
3134 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3135 pp_space (pp);
3136 pp_equal (pp);
3137 pp_space (pp);
3138 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3139 break;
3140
3141 case OMP_ATOMIC_READ:
3142 pp_string (pp, "#pragma omp atomic read");
3143 if (OMP_ATOMIC_SEQ_CST (node))
3144 pp_string (pp, " seq_cst");
3145 newline_and_indent (pp, spc + 2);
3146 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3147 pp_space (pp);
3148 break;
3149
3150 case OMP_ATOMIC_CAPTURE_OLD:
3151 case OMP_ATOMIC_CAPTURE_NEW:
3152 pp_string (pp, "#pragma omp atomic capture");
3153 if (OMP_ATOMIC_SEQ_CST (node))
3154 pp_string (pp, " seq_cst");
3155 newline_and_indent (pp, spc + 2);
3156 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3157 pp_space (pp);
3158 pp_equal (pp);
3159 pp_space (pp);
3160 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3161 break;
3162
3163 case OMP_SINGLE:
3164 pp_string (pp, "#pragma omp single");
3165 dump_omp_clauses (pp, OMP_SINGLE_CLAUSES (node), spc, flags);
3166 goto dump_omp_body;
3167
3168 case OMP_CLAUSE:
3169 dump_omp_clause (pp, node, spc, flags);
3170 is_expr = false;
3171 break;
3172
3173 case TRANSACTION_EXPR:
3174 if (TRANSACTION_EXPR_OUTER (node))
3175 pp_string (pp, "__transaction_atomic [[outer]]");
3176 else if (TRANSACTION_EXPR_RELAXED (node))
3177 pp_string (pp, "__transaction_relaxed");
3178 else
3179 pp_string (pp, "__transaction_atomic");
3180 if (!(flags & TDF_SLIM) && TRANSACTION_EXPR_BODY (node))
3181 {
3182 newline_and_indent (pp, spc);
3183 pp_left_brace (pp);
3184 newline_and_indent (pp, spc + 2);
3185 dump_generic_node (pp, TRANSACTION_EXPR_BODY (node),
3186 spc + 2, flags, false);
3187 newline_and_indent (pp, spc);
3188 pp_right_brace (pp);
3189 }
3190 is_expr = false;
3191 break;
3192
3193 case VEC_SERIES_EXPR:
3194 case VEC_WIDEN_MULT_HI_EXPR:
3195 case VEC_WIDEN_MULT_LO_EXPR:
3196 case VEC_WIDEN_MULT_EVEN_EXPR:
3197 case VEC_WIDEN_MULT_ODD_EXPR:
3198 case VEC_WIDEN_LSHIFT_HI_EXPR:
3199 case VEC_WIDEN_LSHIFT_LO_EXPR:
3200 pp_space (pp);
3201 for (str = get_tree_code_name (code); *str; str++)
3202 pp_character (pp, TOUPPER (*str));
3203 pp_string (pp, " < ");
3204 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3205 pp_string (pp, ", ");
3206 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3207 pp_string (pp, " > ");
3208 break;
3209
3210 case VEC_DUPLICATE_EXPR:
3211 pp_space (pp);
3212 for (str = get_tree_code_name (code); *str; str++)
3213 pp_character (pp, TOUPPER (*str));
3214 pp_string (pp, " < ");
3215 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3216 pp_string (pp, " > ");
3217 break;
3218
3219 case VEC_UNPACK_HI_EXPR:
3220 pp_string (pp, " VEC_UNPACK_HI_EXPR < ");
3221 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3222 pp_string (pp, " > ");
3223 break;
3224
3225 case VEC_UNPACK_LO_EXPR:
3226 pp_string (pp, " VEC_UNPACK_LO_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_HI_EXPR:
3232 pp_string (pp, " VEC_UNPACK_FLOAT_HI_EXPR < ");
3233 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3234 pp_string (pp, " > ");
3235 break;
3236
3237 case VEC_UNPACK_FLOAT_LO_EXPR:
3238 pp_string (pp, " VEC_UNPACK_FLOAT_LO_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_HI_EXPR:
3244 pp_string (pp, " VEC_UNPACK_FIX_TRUNC_HI_EXPR < ");
3245 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3246 pp_string (pp, " > ");
3247 break;
3248
3249 case VEC_UNPACK_FIX_TRUNC_LO_EXPR:
3250 pp_string (pp, " VEC_UNPACK_FIX_TRUNC_LO_EXPR < ");
3251 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3252 pp_string (pp, " > ");
3253 break;
3254
3255 case VEC_PACK_TRUNC_EXPR:
3256 pp_string (pp, " VEC_PACK_TRUNC_EXPR < ");
3257 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3258 pp_string (pp, ", ");
3259 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3260 pp_string (pp, " > ");
3261 break;
3262
3263 case VEC_PACK_SAT_EXPR:
3264 pp_string (pp, " VEC_PACK_SAT_EXPR < ");
3265 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3266 pp_string (pp, ", ");
3267 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3268 pp_string (pp, " > ");
3269 break;
3270
3271 case VEC_PACK_FIX_TRUNC_EXPR:
3272 pp_string (pp, " VEC_PACK_FIX_TRUNC_EXPR < ");
3273 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3274 pp_string (pp, ", ");
3275 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3276 pp_string (pp, " > ");
3277 break;
3278
3279 case VEC_PACK_FLOAT_EXPR:
3280 pp_string (pp, " VEC_PACK_FLOAT_EXPR < ");
3281 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3282 pp_string (pp, ", ");
3283 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3284 pp_string (pp, " > ");
3285 break;
3286
3287 case BLOCK:
3288 dump_block_node (pp, node, spc, flags);
3289 break;
3290
3291 case DEBUG_BEGIN_STMT:
3292 pp_string (pp, "# DEBUG BEGIN STMT");
3293 break;
3294
3295 default:
3296 NIY;
3297 }
3298
3299 if (is_stmt && is_expr)
3300 pp_semicolon (pp);
3301
3302 return spc;
3303 }
3304
3305 /* Print the declaration of a variable. */
3306
3307 void
3308 print_declaration (pretty_printer *pp, tree t, int spc, dump_flags_t flags)
3309 {
3310 INDENT (spc);
3311
3312 if (TREE_CODE(t) == NAMELIST_DECL)
3313 {
3314 pp_string(pp, "namelist ");
3315 dump_decl_name (pp, t, flags);
3316 pp_semicolon (pp);
3317 return;
3318 }
3319
3320 if (TREE_CODE (t) == TYPE_DECL)
3321 pp_string (pp, "typedef ");
3322
3323 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t))
3324 pp_string (pp, "register ");
3325
3326 if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
3327 pp_string (pp, "extern ");
3328 else if (TREE_STATIC (t))
3329 pp_string (pp, "static ");
3330
3331 /* Print the type and name. */
3332 if (TREE_TYPE (t) && TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
3333 {
3334 tree tmp;
3335
3336 /* Print array's type. */
3337 tmp = TREE_TYPE (t);
3338 while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
3339 tmp = TREE_TYPE (tmp);
3340 dump_generic_node (pp, TREE_TYPE (tmp), spc, flags, false);
3341
3342 /* Print variable's name. */
3343 pp_space (pp);
3344 dump_generic_node (pp, t, spc, flags, false);
3345
3346 /* Print the dimensions. */
3347 tmp = TREE_TYPE (t);
3348 while (TREE_CODE (tmp) == ARRAY_TYPE)
3349 {
3350 dump_array_domain (pp, TYPE_DOMAIN (tmp), spc, flags);
3351 tmp = TREE_TYPE (tmp);
3352 }
3353 }
3354 else if (TREE_CODE (t) == FUNCTION_DECL)
3355 {
3356 dump_generic_node (pp, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
3357 pp_space (pp);
3358 dump_decl_name (pp, t, flags);
3359 dump_function_declaration (pp, TREE_TYPE (t), spc, flags);
3360 }
3361 else
3362 {
3363 /* Print type declaration. */
3364 dump_generic_node (pp, TREE_TYPE (t), spc, flags, false);
3365
3366 /* Print variable's name. */
3367 pp_space (pp);
3368 dump_generic_node (pp, t, spc, flags, false);
3369 }
3370
3371 if (VAR_P (t) && DECL_HARD_REGISTER (t))
3372 {
3373 pp_string (pp, " __asm__ ");
3374 pp_left_paren (pp);
3375 dump_generic_node (pp, DECL_ASSEMBLER_NAME (t), spc, flags, false);
3376 pp_right_paren (pp);
3377 }
3378
3379 /* The initial value of a function serves to determine whether the function
3380 is declared or defined. So the following does not apply to function
3381 nodes. */
3382 if (TREE_CODE (t) != FUNCTION_DECL)
3383 {
3384 /* Print the initial value. */
3385 if (DECL_INITIAL (t))
3386 {
3387 pp_space (pp);
3388 pp_equal (pp);
3389 pp_space (pp);
3390 if (!(flags & TDF_SLIM))
3391 dump_generic_node (pp, DECL_INITIAL (t), spc, flags, false);
3392 else
3393 pp_string (pp, "<<< omitted >>>");
3394 }
3395 }
3396
3397 if (VAR_P (t) && DECL_HAS_VALUE_EXPR_P (t))
3398 {
3399 pp_string (pp, " [value-expr: ");
3400 dump_generic_node (pp, DECL_VALUE_EXPR (t), spc, flags, false);
3401 pp_right_bracket (pp);
3402 }
3403
3404 pp_semicolon (pp);
3405 }
3406
3407
3408 /* Prints a structure: name, fields, and methods.
3409 FIXME: Still incomplete. */
3410
3411 static void
3412 print_struct_decl (pretty_printer *pp, const_tree node, int spc,
3413 dump_flags_t flags)
3414 {
3415 /* Print the name of the structure. */
3416 if (TYPE_NAME (node))
3417 {
3418 INDENT (spc);
3419 if (TREE_CODE (node) == RECORD_TYPE)
3420 pp_string (pp, "struct ");
3421 else if ((TREE_CODE (node) == UNION_TYPE
3422 || TREE_CODE (node) == QUAL_UNION_TYPE))
3423 pp_string (pp, "union ");
3424
3425 dump_generic_node (pp, TYPE_NAME (node), spc, TDF_NONE, false);
3426 }
3427
3428 /* Print the contents of the structure. */
3429 pp_newline (pp);
3430 INDENT (spc);
3431 pp_left_brace (pp);
3432 pp_newline (pp);
3433
3434 /* Print the fields of the structure. */
3435 {
3436 tree tmp;
3437 tmp = TYPE_FIELDS (node);
3438 while (tmp)
3439 {
3440 /* Avoid to print recursively the structure. */
3441 /* FIXME : Not implemented correctly...,
3442 what about the case when we have a cycle in the contain graph? ...
3443 Maybe this could be solved by looking at the scope in which the
3444 structure was declared. */
3445 if (TREE_TYPE (tmp) != node
3446 && (TREE_CODE (TREE_TYPE (tmp)) != POINTER_TYPE
3447 || TREE_TYPE (TREE_TYPE (tmp)) != node))
3448 {
3449 print_declaration (pp, tmp, spc+2, flags);
3450 pp_newline (pp);
3451 }
3452 tmp = DECL_CHAIN (tmp);
3453 }
3454 }
3455 INDENT (spc);
3456 pp_right_brace (pp);
3457 }
3458
3459 /* Return the priority of the operator CODE.
3460
3461 From lowest to highest precedence with either left-to-right (L-R)
3462 or right-to-left (R-L) associativity]:
3463
3464 1 [L-R] ,
3465 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
3466 3 [R-L] ?:
3467 4 [L-R] ||
3468 5 [L-R] &&
3469 6 [L-R] |
3470 7 [L-R] ^
3471 8 [L-R] &
3472 9 [L-R] == !=
3473 10 [L-R] < <= > >=
3474 11 [L-R] << >>
3475 12 [L-R] + -
3476 13 [L-R] * / %
3477 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
3478 15 [L-R] fn() [] -> .
3479
3480 unary +, - and * have higher precedence than the corresponding binary
3481 operators. */
3482
3483 int
3484 op_code_prio (enum tree_code code)
3485 {
3486 switch (code)
3487 {
3488 case TREE_LIST:
3489 case COMPOUND_EXPR:
3490 case BIND_EXPR:
3491 return 1;
3492
3493 case MODIFY_EXPR:
3494 case INIT_EXPR:
3495 return 2;
3496
3497 case COND_EXPR:
3498 return 3;
3499
3500 case TRUTH_OR_EXPR:
3501 case TRUTH_ORIF_EXPR:
3502 return 4;
3503
3504 case TRUTH_AND_EXPR:
3505 case TRUTH_ANDIF_EXPR:
3506 return 5;
3507
3508 case BIT_IOR_EXPR:
3509 return 6;
3510
3511 case BIT_XOR_EXPR:
3512 case TRUTH_XOR_EXPR:
3513 return 7;
3514
3515 case BIT_AND_EXPR:
3516 return 8;
3517
3518 case EQ_EXPR:
3519 case NE_EXPR:
3520 return 9;
3521
3522 case UNLT_EXPR:
3523 case UNLE_EXPR:
3524 case UNGT_EXPR:
3525 case UNGE_EXPR:
3526 case UNEQ_EXPR:
3527 case LTGT_EXPR:
3528 case ORDERED_EXPR:
3529 case UNORDERED_EXPR:
3530 case LT_EXPR:
3531 case LE_EXPR:
3532 case GT_EXPR:
3533 case GE_EXPR:
3534 return 10;
3535
3536 case LSHIFT_EXPR:
3537 case RSHIFT_EXPR:
3538 case LROTATE_EXPR:
3539 case RROTATE_EXPR:
3540 case VEC_WIDEN_LSHIFT_HI_EXPR:
3541 case VEC_WIDEN_LSHIFT_LO_EXPR:
3542 case WIDEN_LSHIFT_EXPR:
3543 return 11;
3544
3545 case WIDEN_SUM_EXPR:
3546 case PLUS_EXPR:
3547 case POINTER_PLUS_EXPR:
3548 case POINTER_DIFF_EXPR:
3549 case MINUS_EXPR:
3550 return 12;
3551
3552 case VEC_WIDEN_MULT_HI_EXPR:
3553 case VEC_WIDEN_MULT_LO_EXPR:
3554 case WIDEN_MULT_EXPR:
3555 case DOT_PROD_EXPR:
3556 case WIDEN_MULT_PLUS_EXPR:
3557 case WIDEN_MULT_MINUS_EXPR:
3558 case MULT_EXPR:
3559 case MULT_HIGHPART_EXPR:
3560 case TRUNC_DIV_EXPR:
3561 case CEIL_DIV_EXPR:
3562 case FLOOR_DIV_EXPR:
3563 case ROUND_DIV_EXPR:
3564 case RDIV_EXPR:
3565 case EXACT_DIV_EXPR:
3566 case TRUNC_MOD_EXPR:
3567 case CEIL_MOD_EXPR:
3568 case FLOOR_MOD_EXPR:
3569 case ROUND_MOD_EXPR:
3570 return 13;
3571
3572 case TRUTH_NOT_EXPR:
3573 case BIT_NOT_EXPR:
3574 case POSTINCREMENT_EXPR:
3575 case POSTDECREMENT_EXPR:
3576 case PREINCREMENT_EXPR:
3577 case PREDECREMENT_EXPR:
3578 case NEGATE_EXPR:
3579 case INDIRECT_REF:
3580 case ADDR_EXPR:
3581 case FLOAT_EXPR:
3582 CASE_CONVERT:
3583 case FIX_TRUNC_EXPR:
3584 case TARGET_EXPR:
3585 return 14;
3586
3587 case CALL_EXPR:
3588 case ARRAY_REF:
3589 case ARRAY_RANGE_REF:
3590 case COMPONENT_REF:
3591 return 15;
3592
3593 /* Special expressions. */
3594 case MIN_EXPR:
3595 case MAX_EXPR:
3596 case ABS_EXPR:
3597 case REALPART_EXPR:
3598 case IMAGPART_EXPR:
3599 case VEC_UNPACK_HI_EXPR:
3600 case VEC_UNPACK_LO_EXPR:
3601 case VEC_UNPACK_FLOAT_HI_EXPR:
3602 case VEC_UNPACK_FLOAT_LO_EXPR:
3603 case VEC_UNPACK_FIX_TRUNC_HI_EXPR:
3604 case VEC_UNPACK_FIX_TRUNC_LO_EXPR:
3605 case VEC_PACK_TRUNC_EXPR:
3606 case VEC_PACK_SAT_EXPR:
3607 return 16;
3608
3609 default:
3610 /* Return an arbitrarily high precedence to avoid surrounding single
3611 VAR_DECLs in ()s. */
3612 return 9999;
3613 }
3614 }
3615
3616 /* Return the priority of the operator OP. */
3617
3618 int
3619 op_prio (const_tree op)
3620 {
3621 enum tree_code code;
3622
3623 if (op == NULL)
3624 return 9999;
3625
3626 code = TREE_CODE (op);
3627 if (code == SAVE_EXPR || code == NON_LVALUE_EXPR)
3628 return op_prio (TREE_OPERAND (op, 0));
3629
3630 return op_code_prio (code);
3631 }
3632
3633 /* Return the symbol associated with operator CODE. */
3634
3635 const char *
3636 op_symbol_code (enum tree_code code)
3637 {
3638 switch (code)
3639 {
3640 case MODIFY_EXPR:
3641 return "=";
3642
3643 case TRUTH_OR_EXPR:
3644 case TRUTH_ORIF_EXPR:
3645 return "||";
3646
3647 case TRUTH_AND_EXPR:
3648 case TRUTH_ANDIF_EXPR:
3649 return "&&";
3650
3651 case BIT_IOR_EXPR:
3652 return "|";
3653
3654 case TRUTH_XOR_EXPR:
3655 case BIT_XOR_EXPR:
3656 return "^";
3657
3658 case ADDR_EXPR:
3659 case BIT_AND_EXPR:
3660 return "&";
3661
3662 case ORDERED_EXPR:
3663 return "ord";
3664 case UNORDERED_EXPR:
3665 return "unord";
3666
3667 case EQ_EXPR:
3668 return "==";
3669 case UNEQ_EXPR:
3670 return "u==";
3671
3672 case NE_EXPR:
3673 return "!=";
3674
3675 case LT_EXPR:
3676 return "<";
3677 case UNLT_EXPR:
3678 return "u<";
3679
3680 case LE_EXPR:
3681 return "<=";
3682 case UNLE_EXPR:
3683 return "u<=";
3684
3685 case GT_EXPR:
3686 return ">";
3687 case UNGT_EXPR:
3688 return "u>";
3689
3690 case GE_EXPR:
3691 return ">=";
3692 case UNGE_EXPR:
3693 return "u>=";
3694
3695 case LTGT_EXPR:
3696 return "<>";
3697
3698 case LSHIFT_EXPR:
3699 return "<<";
3700
3701 case RSHIFT_EXPR:
3702 return ">>";
3703
3704 case LROTATE_EXPR:
3705 return "r<<";
3706
3707 case RROTATE_EXPR:
3708 return "r>>";
3709
3710 case WIDEN_LSHIFT_EXPR:
3711 return "w<<";
3712
3713 case POINTER_PLUS_EXPR:
3714 return "+";
3715
3716 case PLUS_EXPR:
3717 return "+";
3718
3719 case WIDEN_SUM_EXPR:
3720 return "w+";
3721
3722 case WIDEN_MULT_EXPR:
3723 return "w*";
3724
3725 case MULT_HIGHPART_EXPR:
3726 return "h*";
3727
3728 case NEGATE_EXPR:
3729 case MINUS_EXPR:
3730 case POINTER_DIFF_EXPR:
3731 return "-";
3732
3733 case BIT_NOT_EXPR:
3734 return "~";
3735
3736 case TRUTH_NOT_EXPR:
3737 return "!";
3738
3739 case MULT_EXPR:
3740 case INDIRECT_REF:
3741 return "*";
3742
3743 case TRUNC_DIV_EXPR:
3744 case RDIV_EXPR:
3745 return "/";
3746
3747 case CEIL_DIV_EXPR:
3748 return "/[cl]";
3749
3750 case FLOOR_DIV_EXPR:
3751 return "/[fl]";
3752
3753 case ROUND_DIV_EXPR:
3754 return "/[rd]";
3755
3756 case EXACT_DIV_EXPR:
3757 return "/[ex]";
3758
3759 case TRUNC_MOD_EXPR:
3760 return "%";
3761
3762 case CEIL_MOD_EXPR:
3763 return "%[cl]";
3764
3765 case FLOOR_MOD_EXPR:
3766 return "%[fl]";
3767
3768 case ROUND_MOD_EXPR:
3769 return "%[rd]";
3770
3771 case PREDECREMENT_EXPR:
3772 return " --";
3773
3774 case PREINCREMENT_EXPR:
3775 return " ++";
3776
3777 case POSTDECREMENT_EXPR:
3778 return "-- ";
3779
3780 case POSTINCREMENT_EXPR:
3781 return "++ ";
3782
3783 case MAX_EXPR:
3784 return "max";
3785
3786 case MIN_EXPR:
3787 return "min";
3788
3789 default:
3790 return "<<< ??? >>>";
3791 }
3792 }
3793
3794 /* Return the symbol associated with operator OP. */
3795
3796 static const char *
3797 op_symbol (const_tree op)
3798 {
3799 return op_symbol_code (TREE_CODE (op));
3800 }
3801
3802 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
3803 the gimple_call_fn of a GIMPLE_CALL. */
3804
3805 void
3806 print_call_name (pretty_printer *pp, tree node, dump_flags_t flags)
3807 {
3808 tree op0 = node;
3809
3810 if (TREE_CODE (op0) == NON_LVALUE_EXPR)
3811 op0 = TREE_OPERAND (op0, 0);
3812
3813 again:
3814 switch (TREE_CODE (op0))
3815 {
3816 case VAR_DECL:
3817 case PARM_DECL:
3818 case FUNCTION_DECL:
3819 dump_function_name (pp, op0, flags);
3820 break;
3821
3822 case ADDR_EXPR:
3823 case INDIRECT_REF:
3824 CASE_CONVERT:
3825 op0 = TREE_OPERAND (op0, 0);
3826 goto again;
3827
3828 case COND_EXPR:
3829 pp_left_paren (pp);
3830 dump_generic_node (pp, TREE_OPERAND (op0, 0), 0, flags, false);
3831 pp_string (pp, ") ? ");
3832 dump_generic_node (pp, TREE_OPERAND (op0, 1), 0, flags, false);
3833 pp_string (pp, " : ");
3834 dump_generic_node (pp, TREE_OPERAND (op0, 2), 0, flags, false);
3835 break;
3836
3837 case ARRAY_REF:
3838 if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
3839 dump_function_name (pp, TREE_OPERAND (op0, 0), flags);
3840 else
3841 dump_generic_node (pp, op0, 0, flags, false);
3842 break;
3843
3844 case MEM_REF:
3845 if (integer_zerop (TREE_OPERAND (op0, 1)))
3846 {
3847 op0 = TREE_OPERAND (op0, 0);
3848 goto again;
3849 }
3850 /* Fallthru. */
3851 case COMPONENT_REF:
3852 case SSA_NAME:
3853 case OBJ_TYPE_REF:
3854 dump_generic_node (pp, op0, 0, flags, false);
3855 break;
3856
3857 default:
3858 NIY;
3859 }
3860 }
3861
3862 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
3863
3864 static void
3865 pretty_print_string (pretty_printer *pp, const char *str)
3866 {
3867 if (str == NULL)
3868 return;
3869
3870 while (*str)
3871 {
3872 switch (str[0])
3873 {
3874 case '\b':
3875 pp_string (pp, "\\b");
3876 break;
3877
3878 case '\f':
3879 pp_string (pp, "\\f");
3880 break;
3881
3882 case '\n':
3883 pp_string (pp, "\\n");
3884 break;
3885
3886 case '\r':
3887 pp_string (pp, "\\r");
3888 break;
3889
3890 case '\t':
3891 pp_string (pp, "\\t");
3892 break;
3893
3894 case '\v':
3895 pp_string (pp, "\\v");
3896 break;
3897
3898 case '\\':
3899 pp_string (pp, "\\\\");
3900 break;
3901
3902 case '\"':
3903 pp_string (pp, "\\\"");
3904 break;
3905
3906 case '\'':
3907 pp_string (pp, "\\'");
3908 break;
3909
3910 /* No need to handle \0; the loop terminates on \0. */
3911
3912 case '\1':
3913 pp_string (pp, "\\1");
3914 break;
3915
3916 case '\2':
3917 pp_string (pp, "\\2");
3918 break;
3919
3920 case '\3':
3921 pp_string (pp, "\\3");
3922 break;
3923
3924 case '\4':
3925 pp_string (pp, "\\4");
3926 break;
3927
3928 case '\5':
3929 pp_string (pp, "\\5");
3930 break;
3931
3932 case '\6':
3933 pp_string (pp, "\\6");
3934 break;
3935
3936 case '\7':
3937 pp_string (pp, "\\7");
3938 break;
3939
3940 default:
3941 if (!ISPRINT (str[0]))
3942 {
3943 char buf[5];
3944 sprintf (buf, "\\x%x", (unsigned char)str[0]);
3945 pp_string (pp, buf);
3946 }
3947 else
3948 pp_character (pp, str[0]);
3949 break;
3950 }
3951 str++;
3952 }
3953 }
3954
3955 static void
3956 maybe_init_pretty_print (FILE *file)
3957 {
3958 if (!tree_pp)
3959 {
3960 tree_pp = new pretty_printer ();
3961 pp_needs_newline (tree_pp) = true;
3962 pp_translate_identifiers (tree_pp) = false;
3963 }
3964
3965 tree_pp->buffer->stream = file;
3966 }
3967
3968 static void
3969 newline_and_indent (pretty_printer *pp, int spc)
3970 {
3971 pp_newline (pp);
3972 INDENT (spc);
3973 }
3974
3975 /* Handle the %K format for TEXT. Separate from default_tree_printer
3976 so it can also be used in front ends.
3977 Argument is a statement from which EXPR_LOCATION and TREE_BLOCK will
3978 be recorded. */
3979
3980 void
3981 percent_K_format (text_info *text, tree t)
3982 {
3983 text->set_location (0, EXPR_LOCATION (t), true);
3984 gcc_assert (pp_ti_abstract_origin (text) != NULL);
3985 tree block = TREE_BLOCK (t);
3986 *pp_ti_abstract_origin (text) = NULL;
3987
3988 if (in_lto_p)
3989 {
3990 /* ??? LTO drops all BLOCK_ABSTRACT_ORIGINs apart from those
3991 representing the outermost block of an inlined function.
3992 So walk the BLOCK tree until we hit such a scope. */
3993 while (block
3994 && TREE_CODE (block) == BLOCK)
3995 {
3996 if (inlined_function_outer_scope_p (block))
3997 {
3998 *pp_ti_abstract_origin (text) = block;
3999 break;
4000 }
4001 block = BLOCK_SUPERCONTEXT (block);
4002 }
4003 return;
4004 }
4005
4006 while (block
4007 && TREE_CODE (block) == BLOCK
4008 && BLOCK_ABSTRACT_ORIGIN (block))
4009 {
4010 tree ao = BLOCK_ABSTRACT_ORIGIN (block);
4011
4012 while (TREE_CODE (ao) == BLOCK
4013 && BLOCK_ABSTRACT_ORIGIN (ao)
4014 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
4015 ao = BLOCK_ABSTRACT_ORIGIN (ao);
4016
4017 if (TREE_CODE (ao) == FUNCTION_DECL)
4018 {
4019 *pp_ti_abstract_origin (text) = block;
4020 break;
4021 }
4022 block = BLOCK_SUPERCONTEXT (block);
4023 }
4024 }
4025
4026 /* Print the identifier ID to PRETTY-PRINTER. */
4027
4028 void
4029 pp_tree_identifier (pretty_printer *pp, tree id)
4030 {
4031 if (pp_translate_identifiers (pp))
4032 {
4033 const char *text = identifier_to_locale (IDENTIFIER_POINTER (id));
4034 pp_append_text (pp, text, text + strlen (text));
4035 }
4036 else
4037 pp_append_text (pp, IDENTIFIER_POINTER (id),
4038 IDENTIFIER_POINTER (id) + IDENTIFIER_LENGTH (id));
4039 }
4040
4041 /* A helper function that is used to dump function information before the
4042 function dump. */
4043
4044 void
4045 dump_function_header (FILE *dump_file, tree fdecl, dump_flags_t flags)
4046 {
4047 const char *dname, *aname;
4048 struct cgraph_node *node = cgraph_node::get (fdecl);
4049 struct function *fun = DECL_STRUCT_FUNCTION (fdecl);
4050
4051 dname = lang_hooks.decl_printable_name (fdecl, 1);
4052
4053 if (DECL_ASSEMBLER_NAME_SET_P (fdecl))
4054 aname = (IDENTIFIER_POINTER
4055 (DECL_ASSEMBLER_NAME (fdecl)));
4056 else
4057 aname = "<unset-asm-name>";
4058
4059 fprintf (dump_file, "\n;; Function %s (%s, funcdef_no=%d",
4060 dname, aname, fun->funcdef_no);
4061 if (!(flags & TDF_NOUID))
4062 fprintf (dump_file, ", decl_uid=%d", DECL_UID (fdecl));
4063 if (node)
4064 {
4065 fprintf (dump_file, ", cgraph_uid=%d", node->get_uid ());
4066 fprintf (dump_file, ", symbol_order=%d)%s\n\n", node->order,
4067 node->frequency == NODE_FREQUENCY_HOT
4068 ? " (hot)"
4069 : node->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED
4070 ? " (unlikely executed)"
4071 : node->frequency == NODE_FREQUENCY_EXECUTED_ONCE
4072 ? " (executed once)"
4073 : "");
4074 }
4075 else
4076 fprintf (dump_file, ")\n\n");
4077 }
4078
4079 /* Dump double_int D to pretty_printer PP. UNS is true
4080 if D is unsigned and false otherwise. */
4081 void
4082 pp_double_int (pretty_printer *pp, double_int d, bool uns)
4083 {
4084 if (d.fits_shwi ())
4085 pp_wide_integer (pp, d.low);
4086 else if (d.fits_uhwi ())
4087 pp_unsigned_wide_integer (pp, d.low);
4088 else
4089 {
4090 unsigned HOST_WIDE_INT low = d.low;
4091 HOST_WIDE_INT high = d.high;
4092 if (!uns && d.is_negative ())
4093 {
4094 pp_minus (pp);
4095 high = ~high + !low;
4096 low = -low;
4097 }
4098 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
4099 systems? */
4100 sprintf (pp_buffer (pp)->digit_buffer,
4101 HOST_WIDE_INT_PRINT_DOUBLE_HEX,
4102 (unsigned HOST_WIDE_INT) high, low);
4103 pp_string (pp, pp_buffer (pp)->digit_buffer);
4104 }
4105 }
Mirror of the offical gcc git repository hosted at gcc.gnu.org