?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2018-05-28 Richard Biener <rguenther@suse.de>
[official-gcc.git] / gcc / tree-pretty-print.c
blob5a8c8eb79460785bb679aaa3cb634a6d6f2bce2d
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 POINTER_BOUNDS_TYPE:
1289 case INTEGER_TYPE:
1290 case REAL_TYPE:
1291 case FIXED_POINT_TYPE:
1292 case COMPLEX_TYPE:
1293 case VECTOR_TYPE:
1294 case ENUMERAL_TYPE:
1295 case BOOLEAN_TYPE:
1296 {
1297 unsigned int quals = TYPE_QUALS (node);
1298 enum tree_code_class tclass;
1299
1300 if (quals & TYPE_QUAL_ATOMIC)
1301 pp_string (pp, "atomic ");
1302 if (quals & TYPE_QUAL_CONST)
1303 pp_string (pp, "const ");
1304 else if (quals & TYPE_QUAL_VOLATILE)
1305 pp_string (pp, "volatile ");
1306 else if (quals & TYPE_QUAL_RESTRICT)
1307 pp_string (pp, "restrict ");
1308
1309 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
1310 {
1311 pp_string (pp, "<address-space-");
1312 pp_decimal_int (pp, TYPE_ADDR_SPACE (node));
1313 pp_string (pp, "> ");
1314 }
1315
1316 tclass = TREE_CODE_CLASS (TREE_CODE (node));
1317
1318 if (tclass == tcc_declaration)
1319 {
1320 if (DECL_NAME (node))
1321 dump_decl_name (pp, node, flags);
1322 else
1323 pp_string (pp, "<unnamed type decl>");
1324 }
1325 else if (tclass == tcc_type)
1326 {
1327 if (TYPE_NAME (node))
1328 {
1329 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
1330 pp_tree_identifier (pp, TYPE_NAME (node));
1331 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
1332 && DECL_NAME (TYPE_NAME (node)))
1333 dump_decl_name (pp, TYPE_NAME (node), flags);
1334 else
1335 pp_string (pp, "<unnamed type>");
1336 }
1337 else if (TREE_CODE (node) == VECTOR_TYPE)
1338 {
1339 pp_string (pp, "vector");
1340 pp_left_paren (pp);
1341 pp_wide_integer (pp, TYPE_VECTOR_SUBPARTS (node));
1342 pp_string (pp, ") ");
1343 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
1344 }
1345 else if (TREE_CODE (node) == INTEGER_TYPE)
1346 {
1347 if (TYPE_PRECISION (node) == CHAR_TYPE_SIZE)
1348 pp_string (pp, (TYPE_UNSIGNED (node)
1349 ? "unsigned char"
1350 : "signed char"));
1351 else if (TYPE_PRECISION (node) == SHORT_TYPE_SIZE)
1352 pp_string (pp, (TYPE_UNSIGNED (node)
1353 ? "unsigned short"
1354 : "signed short"));
1355 else if (TYPE_PRECISION (node) == INT_TYPE_SIZE)
1356 pp_string (pp, (TYPE_UNSIGNED (node)
1357 ? "unsigned int"
1358 : "signed int"));
1359 else if (TYPE_PRECISION (node) == LONG_TYPE_SIZE)
1360 pp_string (pp, (TYPE_UNSIGNED (node)
1361 ? "unsigned long"
1362 : "signed long"));
1363 else if (TYPE_PRECISION (node) == LONG_LONG_TYPE_SIZE)
1364 pp_string (pp, (TYPE_UNSIGNED (node)
1365 ? "unsigned long long"
1366 : "signed long long"));
1367 else if (TYPE_PRECISION (node) >= CHAR_TYPE_SIZE
1368 && pow2p_hwi (TYPE_PRECISION (node)))
1369 {
1370 pp_string (pp, (TYPE_UNSIGNED (node) ? "uint" : "int"));
1371 pp_decimal_int (pp, TYPE_PRECISION (node));
1372 pp_string (pp, "_t");
1373 }
1374 else
1375 {
1376 pp_string (pp, (TYPE_UNSIGNED (node)
1377 ? "<unnamed-unsigned:"
1378 : "<unnamed-signed:"));
1379 pp_decimal_int (pp, TYPE_PRECISION (node));
1380 pp_greater (pp);
1381 }
1382 }
1383 else if (TREE_CODE (node) == COMPLEX_TYPE)
1384 {
1385 pp_string (pp, "__complex__ ");
1386 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
1387 }
1388 else if (TREE_CODE (node) == REAL_TYPE)
1389 {
1390 pp_string (pp, "<float:");
1391 pp_decimal_int (pp, TYPE_PRECISION (node));
1392 pp_greater (pp);
1393 }
1394 else if (TREE_CODE (node) == FIXED_POINT_TYPE)
1395 {
1396 pp_string (pp, "<fixed-point-");
1397 pp_string (pp, TYPE_SATURATING (node) ? "sat:" : "nonsat:");
1398 pp_decimal_int (pp, TYPE_PRECISION (node));
1399 pp_greater (pp);
1400 }
1401 else if (TREE_CODE (node) == VOID_TYPE)
1402 pp_string (pp, "void");
1403 else
1404 pp_string (pp, "<unnamed type>");
1405 }
1406 break;
1407 }
1408
1409 case POINTER_TYPE:
1410 case REFERENCE_TYPE:
1411 str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&");
1412
1413 if (TREE_TYPE (node) == NULL)
1414 {
1415 pp_string (pp, str);
1416 pp_string (pp, "<null type>");
1417 }
1418 else if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)
1419 {
1420 tree fnode = TREE_TYPE (node);
1421
1422 dump_generic_node (pp, TREE_TYPE (fnode), spc, flags, false);
1423 pp_space (pp);
1424 pp_left_paren (pp);
1425 pp_string (pp, str);
1426 if (TYPE_IDENTIFIER (node))
1427 dump_generic_node (pp, TYPE_NAME (node), spc, flags, false);
1428 else if (flags & TDF_NOUID)
1429 pp_printf (pp, "<Txxxx>");
1430 else
1431 pp_printf (pp, "<T%x>", TYPE_UID (node));
1432
1433 pp_right_paren (pp);
1434 dump_function_declaration (pp, fnode, spc, flags);
1435 }
1436 else
1437 {
1438 unsigned int quals = TYPE_QUALS (node);
1439
1440 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
1441 pp_space (pp);
1442 pp_string (pp, str);
1443
1444 if (quals & TYPE_QUAL_CONST)
1445 pp_string (pp, " const");
1446 if (quals & TYPE_QUAL_VOLATILE)
1447 pp_string (pp, " volatile");
1448 if (quals & TYPE_QUAL_RESTRICT)
1449 pp_string (pp, " restrict");
1450
1451 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
1452 {
1453 pp_string (pp, " <address-space-");
1454 pp_decimal_int (pp, TYPE_ADDR_SPACE (node));
1455 pp_greater (pp);
1456 }
1457
1458 if (TYPE_REF_CAN_ALIAS_ALL (node))
1459 pp_string (pp, " {ref-all}");
1460 }
1461 break;
1462
1463 case OFFSET_TYPE:
1464 NIY;
1465 break;
1466
1467 case MEM_REF:
1468 {
1469 if (flags & TDF_GIMPLE)
1470 {
1471 pp_string (pp, "__MEM <");
1472 dump_generic_node (pp, TREE_TYPE (node),
1473 spc, flags | TDF_SLIM, false);
1474 if (TYPE_ALIGN (TREE_TYPE (node))
1475 != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node))))
1476 {
1477 pp_string (pp, ", ");
1478 pp_decimal_int (pp, TYPE_ALIGN (TREE_TYPE (node)));
1479 }
1480 pp_greater (pp);
1481 pp_string (pp, " (");
1482 if (TREE_TYPE (TREE_OPERAND (node, 0))
1483 != TREE_TYPE (TREE_OPERAND (node, 1)))
1484 {
1485 pp_left_paren (pp);
1486 dump_generic_node (pp, TREE_TYPE (TREE_OPERAND (node, 1)),
1487 spc, flags | TDF_SLIM, false);
1488 pp_right_paren (pp);
1489 }
1490 dump_generic_node (pp, TREE_OPERAND (node, 0),
1491 spc, flags | TDF_SLIM, false);
1492 if (! integer_zerop (TREE_OPERAND (node, 1)))
1493 {
1494 pp_string (pp, " + ");
1495 dump_generic_node (pp, TREE_OPERAND (node, 1),
1496 spc, flags | TDF_SLIM, false);
1497 }
1498 pp_right_paren (pp);
1499 }
1500 else if (integer_zerop (TREE_OPERAND (node, 1))
1501 /* Dump the types of INTEGER_CSTs explicitly, for we can't
1502 infer them and MEM_ATTR caching will share MEM_REFs
1503 with differently-typed op0s. */
1504 && TREE_CODE (TREE_OPERAND (node, 0)) != INTEGER_CST
1505 /* Released SSA_NAMES have no TREE_TYPE. */
1506 && TREE_TYPE (TREE_OPERAND (node, 0)) != NULL_TREE
1507 /* Same pointer types, but ignoring POINTER_TYPE vs.
1508 REFERENCE_TYPE. */
1509 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 0)))
1510 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1))))
1511 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 0)))
1512 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 1))))
1513 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 0)))
1514 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 1))))
1515 /* Same value types ignoring qualifiers. */
1516 && (TYPE_MAIN_VARIANT (TREE_TYPE (node))
1517 == TYPE_MAIN_VARIANT
1518 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1)))))
1519 && (!(flags & TDF_ALIAS)
1520 || MR_DEPENDENCE_CLIQUE (node) == 0))
1521 {
1522 if (TREE_CODE (TREE_OPERAND (node, 0)) != ADDR_EXPR)
1523 {
1524 pp_star (pp);
1525 dump_generic_node (pp, TREE_OPERAND (node, 0),
1526 spc, flags, false);
1527 }
1528 else
1529 dump_generic_node (pp,
1530 TREE_OPERAND (TREE_OPERAND (node, 0), 0),
1531 spc, flags, false);
1532 }
1533 else
1534 {
1535 tree ptype;
1536
1537 pp_string (pp, "MEM[");
1538 pp_left_paren (pp);
1539 ptype = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node, 1)));
1540 dump_generic_node (pp, ptype,
1541 spc, flags | TDF_SLIM, false);
1542 pp_right_paren (pp);
1543 dump_generic_node (pp, TREE_OPERAND (node, 0),
1544 spc, flags, false);
1545 if (!integer_zerop (TREE_OPERAND (node, 1)))
1546 {
1547 pp_string (pp, " + ");
1548 dump_generic_node (pp, TREE_OPERAND (node, 1),
1549 spc, flags, false);
1550 }
1551 if ((flags & TDF_ALIAS)
1552 && MR_DEPENDENCE_CLIQUE (node) != 0)
1553 {
1554 pp_string (pp, " clique ");
1555 pp_unsigned_wide_integer (pp, MR_DEPENDENCE_CLIQUE (node));
1556 pp_string (pp, " base ");
1557 pp_unsigned_wide_integer (pp, MR_DEPENDENCE_BASE (node));
1558 }
1559 pp_right_bracket (pp);
1560 }
1561 break;
1562 }
1563
1564 case TARGET_MEM_REF:
1565 {
1566 const char *sep = "";
1567 tree tmp;
1568
1569 pp_string (pp, "MEM[");
1570
1571 if (TREE_CODE (TMR_BASE (node)) == ADDR_EXPR)
1572 {
1573 pp_string (pp, sep);
1574 sep = ", ";
1575 pp_string (pp, "symbol: ");
1576 dump_generic_node (pp, TREE_OPERAND (TMR_BASE (node), 0),
1577 spc, flags, false);
1578 }
1579 else
1580 {
1581 pp_string (pp, sep);
1582 sep = ", ";
1583 pp_string (pp, "base: ");
1584 dump_generic_node (pp, TMR_BASE (node), spc, flags, false);
1585 }
1586 tmp = TMR_INDEX2 (node);
1587 if (tmp)
1588 {
1589 pp_string (pp, sep);
1590 sep = ", ";
1591 pp_string (pp, "base: ");
1592 dump_generic_node (pp, tmp, spc, flags, false);
1593 }
1594 tmp = TMR_INDEX (node);
1595 if (tmp)
1596 {
1597 pp_string (pp, sep);
1598 sep = ", ";
1599 pp_string (pp, "index: ");
1600 dump_generic_node (pp, tmp, spc, flags, false);
1601 }
1602 tmp = TMR_STEP (node);
1603 if (tmp)
1604 {
1605 pp_string (pp, sep);
1606 sep = ", ";
1607 pp_string (pp, "step: ");
1608 dump_generic_node (pp, tmp, spc, flags, false);
1609 }
1610 tmp = TMR_OFFSET (node);
1611 if (tmp)
1612 {
1613 pp_string (pp, sep);
1614 sep = ", ";
1615 pp_string (pp, "offset: ");
1616 dump_generic_node (pp, tmp, spc, flags, false);
1617 }
1618 pp_right_bracket (pp);
1619 }
1620 break;
1621
1622 case ARRAY_TYPE:
1623 {
1624 tree tmp;
1625
1626 /* Print the innermost component type. */
1627 for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE;
1628 tmp = TREE_TYPE (tmp))
1629 ;
1630 dump_generic_node (pp, tmp, spc, flags, false);
1631
1632 /* Print the dimensions. */
1633 for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp))
1634 dump_array_domain (pp, TYPE_DOMAIN (tmp), spc, flags);
1635 break;
1636 }
1637
1638 case RECORD_TYPE:
1639 case UNION_TYPE:
1640 case QUAL_UNION_TYPE:
1641 {
1642 unsigned int quals = TYPE_QUALS (node);
1643
1644 if (quals & TYPE_QUAL_ATOMIC)
1645 pp_string (pp, "atomic ");
1646 if (quals & TYPE_QUAL_CONST)
1647 pp_string (pp, "const ");
1648 if (quals & TYPE_QUAL_VOLATILE)
1649 pp_string (pp, "volatile ");
1650
1651 /* Print the name of the structure. */
1652 if (TREE_CODE (node) == RECORD_TYPE)
1653 pp_string (pp, "struct ");
1654 else if (TREE_CODE (node) == UNION_TYPE)
1655 pp_string (pp, "union ");
1656
1657 if (TYPE_NAME (node))
1658 dump_generic_node (pp, TYPE_NAME (node), spc, flags, false);
1659 else if (!(flags & TDF_SLIM))
1660 /* FIXME: If we eliminate the 'else' above and attempt
1661 to show the fields for named types, we may get stuck
1662 following a cycle of pointers to structs. The alleged
1663 self-reference check in print_struct_decl will not detect
1664 cycles involving more than one pointer or struct type. */
1665 print_struct_decl (pp, node, spc, flags);
1666 break;
1667 }
1668
1669 case LANG_TYPE:
1670 NIY;
1671 break;
1672
1673 case INTEGER_CST:
1674 if (flags & TDF_GIMPLE
1675 && (POINTER_TYPE_P (TREE_TYPE (node))
1676 || (TYPE_PRECISION (TREE_TYPE (node))
1677 < TYPE_PRECISION (integer_type_node))
1678 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node))) == -1))
1679 {
1680 pp_string (pp, "_Literal (");
1681 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
1682 pp_string (pp, ") ");
1683 }
1684 if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE
1685 && ! (flags & TDF_GIMPLE))
1686 {
1687 /* In the case of a pointer, one may want to divide by the
1688 size of the pointed-to type. Unfortunately, this not
1689 straightforward. The C front-end maps expressions
1690
1691 (int *) 5
1692 int *p; (p + 5)
1693
1694 in such a way that the two INTEGER_CST nodes for "5" have
1695 different values but identical types. In the latter
1696 case, the 5 is multiplied by sizeof (int) in c-common.c
1697 (pointer_int_sum) to convert it to a byte address, and
1698 yet the type of the node is left unchanged. Argh. What
1699 is consistent though is that the number value corresponds
1700 to bytes (UNITS) offset.
1701
1702 NB: Neither of the following divisors can be trivially
1703 used to recover the original literal:
1704
1705 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
1706 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
1707 pp_wide_integer (pp, TREE_INT_CST_LOW (node));
1708 pp_string (pp, "B"); /* pseudo-unit */
1709 }
1710 else if (tree_fits_shwi_p (node))
1711 pp_wide_integer (pp, tree_to_shwi (node));
1712 else if (tree_fits_uhwi_p (node))
1713 pp_unsigned_wide_integer (pp, tree_to_uhwi (node));
1714 else
1715 {
1716 wide_int val = wi::to_wide (node);
1717
1718 if (wi::neg_p (val, TYPE_SIGN (TREE_TYPE (node))))
1719 {
1720 pp_minus (pp);
1721 val = -val;
1722 }
1723 print_hex (val, pp_buffer (pp)->digit_buffer);
1724 pp_string (pp, pp_buffer (pp)->digit_buffer);
1725 }
1726 if ((flags & TDF_GIMPLE)
1727 && ! (POINTER_TYPE_P (TREE_TYPE (node))
1728 || (TYPE_PRECISION (TREE_TYPE (node))
1729 < TYPE_PRECISION (integer_type_node))
1730 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node))) == -1))
1731 {
1732 if (TYPE_UNSIGNED (TREE_TYPE (node)))
1733 pp_character (pp, 'u');
1734 if (TYPE_PRECISION (TREE_TYPE (node))
1735 == TYPE_PRECISION (unsigned_type_node))
1736 ;
1737 else if (TYPE_PRECISION (TREE_TYPE (node))
1738 == TYPE_PRECISION (long_unsigned_type_node))
1739 pp_character (pp, 'l');
1740 else if (TYPE_PRECISION (TREE_TYPE (node))
1741 == TYPE_PRECISION (long_long_unsigned_type_node))
1742 pp_string (pp, "ll");
1743 }
1744 if (TREE_OVERFLOW (node))
1745 pp_string (pp, "(OVF)");
1746 break;
1747
1748 case POLY_INT_CST:
1749 pp_string (pp, "POLY_INT_CST [");
1750 dump_generic_node (pp, POLY_INT_CST_COEFF (node, 0), spc, flags, false);
1751 for (unsigned int i = 1; i < NUM_POLY_INT_COEFFS; ++i)
1752 {
1753 pp_string (pp, ", ");
1754 dump_generic_node (pp, POLY_INT_CST_COEFF (node, i),
1755 spc, flags, false);
1756 }
1757 pp_string (pp, "]");
1758 break;
1759
1760 case REAL_CST:
1761 /* Code copied from print_node. */
1762 {
1763 REAL_VALUE_TYPE d;
1764 if (TREE_OVERFLOW (node))
1765 pp_string (pp, " overflow");
1766
1767 d = TREE_REAL_CST (node);
1768 if (REAL_VALUE_ISINF (d))
1769 pp_string (pp, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
1770 else if (REAL_VALUE_ISNAN (d))
1771 pp_string (pp, " Nan");
1772 else
1773 {
1774 char string[100];
1775 real_to_decimal (string, &d, sizeof (string), 0, 1);
1776 pp_string (pp, string);
1777 }
1778 break;
1779 }
1780
1781 case FIXED_CST:
1782 {
1783 char string[100];
1784 fixed_to_decimal (string, TREE_FIXED_CST_PTR (node), sizeof (string));
1785 pp_string (pp, string);
1786 break;
1787 }
1788
1789 case COMPLEX_CST:
1790 pp_string (pp, "__complex__ (");
1791 dump_generic_node (pp, TREE_REALPART (node), spc, flags, false);
1792 pp_string (pp, ", ");
1793 dump_generic_node (pp, TREE_IMAGPART (node), spc, flags, false);
1794 pp_right_paren (pp);
1795 break;
1796
1797 case STRING_CST:
1798 pp_string (pp, "\"");
1799 pretty_print_string (pp, TREE_STRING_POINTER (node));
1800 pp_string (pp, "\"");
1801 break;
1802
1803 case VECTOR_CST:
1804 {
1805 unsigned i;
1806 pp_string (pp, "{ ");
1807 unsigned HOST_WIDE_INT nunits;
1808 if (!VECTOR_CST_NELTS (node).is_constant (&nunits))
1809 nunits = vector_cst_encoded_nelts (node);
1810 for (i = 0; i < nunits; ++i)
1811 {
1812 if (i != 0)
1813 pp_string (pp, ", ");
1814 dump_generic_node (pp, VECTOR_CST_ELT (node, i),
1815 spc, flags, false);
1816 }
1817 if (!VECTOR_CST_NELTS (node).is_constant ())
1818 pp_string (pp, ", ...");
1819 pp_string (pp, " }");
1820 }
1821 break;
1822
1823 case FUNCTION_TYPE:
1824 case METHOD_TYPE:
1825 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
1826 pp_space (pp);
1827 if (TREE_CODE (node) == METHOD_TYPE)
1828 {
1829 if (TYPE_METHOD_BASETYPE (node))
1830 dump_generic_node (pp, TYPE_NAME (TYPE_METHOD_BASETYPE (node)),
1831 spc, flags, false);
1832 else
1833 pp_string (pp, "<null method basetype>");
1834 pp_colon_colon (pp);
1835 }
1836 if (TYPE_IDENTIFIER (node))
1837 dump_generic_node (pp, TYPE_NAME (node), spc, flags, false);
1838 else if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
1839 dump_decl_name (pp, TYPE_NAME (node), flags);
1840 else if (flags & TDF_NOUID)
1841 pp_printf (pp, "<Txxxx>");
1842 else
1843 pp_printf (pp, "<T%x>", TYPE_UID (node));
1844 dump_function_declaration (pp, node, spc, flags);
1845 break;
1846
1847 case FUNCTION_DECL:
1848 case CONST_DECL:
1849 dump_decl_name (pp, node, flags);
1850 break;
1851
1852 case LABEL_DECL:
1853 if (DECL_NAME (node))
1854 dump_decl_name (pp, node, flags);
1855 else if (LABEL_DECL_UID (node) != -1)
1856 {
1857 if (flags & TDF_GIMPLE)
1858 pp_printf (pp, "L%d", (int) LABEL_DECL_UID (node));
1859 else
1860 pp_printf (pp, "<L%d>", (int) LABEL_DECL_UID (node));
1861 }
1862 else
1863 {
1864 if (flags & TDF_NOUID)
1865 pp_string (pp, "<D.xxxx>");
1866 else
1867 {
1868 if (flags & TDF_GIMPLE)
1869 pp_printf (pp, "<D%u>", DECL_UID (node));
1870 else
1871 pp_printf (pp, "<D.%u>", DECL_UID (node));
1872 }
1873 }
1874 break;
1875
1876 case TYPE_DECL:
1877 if (DECL_IS_BUILTIN (node))
1878 {
1879 /* Don't print the declaration of built-in types. */
1880 break;
1881 }
1882 if (DECL_NAME (node))
1883 dump_decl_name (pp, node, flags);
1884 else if (TYPE_NAME (TREE_TYPE (node)) != node)
1885 {
1886 pp_string (pp, (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE
1887 ? "union" : "struct "));
1888 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
1889 }
1890 else
1891 pp_string (pp, "<anon>");
1892 break;
1893
1894 case VAR_DECL:
1895 case PARM_DECL:
1896 case FIELD_DECL:
1897 case DEBUG_EXPR_DECL:
1898 case NAMESPACE_DECL:
1899 case NAMELIST_DECL:
1900 dump_decl_name (pp, node, flags);
1901 break;
1902
1903 case RESULT_DECL:
1904 pp_string (pp, "<retval>");
1905 break;
1906
1907 case COMPONENT_REF:
1908 op0 = TREE_OPERAND (node, 0);
1909 str = ".";
1910 if (op0
1911 && (TREE_CODE (op0) == INDIRECT_REF
1912 || (TREE_CODE (op0) == MEM_REF
1913 && TREE_CODE (TREE_OPERAND (op0, 0)) != ADDR_EXPR
1914 && integer_zerop (TREE_OPERAND (op0, 1))
1915 /* Dump the types of INTEGER_CSTs explicitly, for we
1916 can't infer them and MEM_ATTR caching will share
1917 MEM_REFs with differently-typed op0s. */
1918 && TREE_CODE (TREE_OPERAND (op0, 0)) != INTEGER_CST
1919 /* Released SSA_NAMES have no TREE_TYPE. */
1920 && TREE_TYPE (TREE_OPERAND (op0, 0)) != NULL_TREE
1921 /* Same pointer types, but ignoring POINTER_TYPE vs.
1922 REFERENCE_TYPE. */
1923 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 0)))
1924 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1))))
1925 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 0)))
1926 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 1))))
1927 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 0)))
1928 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 1))))
1929 /* Same value types ignoring qualifiers. */
1930 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0))
1931 == TYPE_MAIN_VARIANT
1932 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1)))))
1933 && MR_DEPENDENCE_CLIQUE (op0) == 0)))
1934 {
1935 op0 = TREE_OPERAND (op0, 0);
1936 str = "->";
1937 }
1938 if (op_prio (op0) < op_prio (node))
1939 pp_left_paren (pp);
1940 dump_generic_node (pp, op0, spc, flags, false);
1941 if (op_prio (op0) < op_prio (node))
1942 pp_right_paren (pp);
1943 pp_string (pp, str);
1944 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
1945 op0 = component_ref_field_offset (node);
1946 if (op0 && TREE_CODE (op0) != INTEGER_CST)
1947 {
1948 pp_string (pp, "{off: ");
1949 dump_generic_node (pp, op0, spc, flags, false);
1950 pp_right_brace (pp);
1951 }
1952 break;
1953
1954 case BIT_FIELD_REF:
1955 pp_string (pp, "BIT_FIELD_REF <");
1956 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
1957 pp_string (pp, ", ");
1958 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
1959 pp_string (pp, ", ");
1960 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
1961 pp_greater (pp);
1962 break;
1963
1964 case BIT_INSERT_EXPR:
1965 pp_string (pp, "BIT_INSERT_EXPR <");
1966 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
1967 pp_string (pp, ", ");
1968 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
1969 pp_string (pp, ", ");
1970 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
1971 pp_string (pp, " (");
1972 if (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (node, 1))))
1973 pp_decimal_int (pp,
1974 TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (node, 1))));
1975 else
1976 dump_generic_node (pp, TYPE_SIZE (TREE_TYPE (TREE_OPERAND (node, 1))),
1977 spc, flags, false);
1978 pp_string (pp, " bits)>");
1979 break;
1980
1981 case ARRAY_REF:
1982 case ARRAY_RANGE_REF:
1983 op0 = TREE_OPERAND (node, 0);
1984 if (op_prio (op0) < op_prio (node))
1985 pp_left_paren (pp);
1986 dump_generic_node (pp, op0, spc, flags, false);
1987 if (op_prio (op0) < op_prio (node))
1988 pp_right_paren (pp);
1989 pp_left_bracket (pp);
1990 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
1991 if (TREE_CODE (node) == ARRAY_RANGE_REF)
1992 pp_string (pp, " ...");
1993 pp_right_bracket (pp);
1994
1995 op0 = array_ref_low_bound (node);
1996 op1 = array_ref_element_size (node);
1997
1998 if (!integer_zerop (op0)
1999 || TREE_OPERAND (node, 2)
2000 || TREE_OPERAND (node, 3))
2001 {
2002 pp_string (pp, "{lb: ");
2003 dump_generic_node (pp, op0, spc, flags, false);
2004 pp_string (pp, " sz: ");
2005 dump_generic_node (pp, op1, spc, flags, false);
2006 pp_right_brace (pp);
2007 }
2008 break;
2009
2010 case CONSTRUCTOR:
2011 {
2012 unsigned HOST_WIDE_INT ix;
2013 tree field, val;
2014 bool is_struct_init = false;
2015 bool is_array_init = false;
2016 widest_int curidx;
2017 pp_left_brace (pp);
2018 if (TREE_CLOBBER_P (node))
2019 pp_string (pp, "CLOBBER");
2020 else if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
2021 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
2022 is_struct_init = true;
2023 else if (TREE_CODE (TREE_TYPE (node)) == ARRAY_TYPE
2024 && TYPE_DOMAIN (TREE_TYPE (node))
2025 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node)))
2026 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node))))
2027 == INTEGER_CST)
2028 {
2029 tree minv = TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node)));
2030 is_array_init = true;
2031 curidx = wi::to_widest (minv);
2032 }
2033 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)
2034 {
2035 if (field)
2036 {
2037 if (is_struct_init)
2038 {
2039 pp_dot (pp);
2040 dump_generic_node (pp, field, spc, flags, false);
2041 pp_equal (pp);
2042 }
2043 else if (is_array_init
2044 && (TREE_CODE (field) != INTEGER_CST
2045 || curidx != wi::to_widest (field)))
2046 {
2047 pp_left_bracket (pp);
2048 if (TREE_CODE (field) == RANGE_EXPR)
2049 {
2050 dump_generic_node (pp, TREE_OPERAND (field, 0), spc,
2051 flags, false);
2052 pp_string (pp, " ... ");
2053 dump_generic_node (pp, TREE_OPERAND (field, 1), spc,
2054 flags, false);
2055 if (TREE_CODE (TREE_OPERAND (field, 1)) == INTEGER_CST)
2056 curidx = wi::to_widest (TREE_OPERAND (field, 1));
2057 }
2058 else
2059 dump_generic_node (pp, field, spc, flags, false);
2060 if (TREE_CODE (field) == INTEGER_CST)
2061 curidx = wi::to_widest (field);
2062 pp_string (pp, "]=");
2063 }
2064 }
2065 if (is_array_init)
2066 curidx += 1;
2067 if (val && TREE_CODE (val) == ADDR_EXPR)
2068 if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
2069 val = TREE_OPERAND (val, 0);
2070 if (val && TREE_CODE (val) == FUNCTION_DECL)
2071 dump_decl_name (pp, val, flags);
2072 else
2073 dump_generic_node (pp, val, spc, flags, false);
2074 if (ix != CONSTRUCTOR_NELTS (node) - 1)
2075 {
2076 pp_comma (pp);
2077 pp_space (pp);
2078 }
2079 }
2080 pp_right_brace (pp);
2081 }
2082 break;
2083
2084 case COMPOUND_EXPR:
2085 {
2086 tree *tp;
2087 if (flags & TDF_SLIM)
2088 {
2089 pp_string (pp, "<COMPOUND_EXPR>");
2090 break;
2091 }
2092
2093 dump_generic_node (pp, TREE_OPERAND (node, 0),
2094 spc, flags, !(flags & TDF_SLIM));
2095 if (flags & TDF_SLIM)
2096 newline_and_indent (pp, spc);
2097 else
2098 {
2099 pp_comma (pp);
2100 pp_space (pp);
2101 }
2102
2103 for (tp = &TREE_OPERAND (node, 1);
2104 TREE_CODE (*tp) == COMPOUND_EXPR;
2105 tp = &TREE_OPERAND (*tp, 1))
2106 {
2107 dump_generic_node (pp, TREE_OPERAND (*tp, 0),
2108 spc, flags, !(flags & TDF_SLIM));
2109 if (flags & TDF_SLIM)
2110 newline_and_indent (pp, spc);
2111 else
2112 {
2113 pp_comma (pp);
2114 pp_space (pp);
2115 }
2116 }
2117
2118 dump_generic_node (pp, *tp, spc, flags, !(flags & TDF_SLIM));
2119 }
2120 break;
2121
2122 case STATEMENT_LIST:
2123 {
2124 tree_stmt_iterator si;
2125 bool first = true;
2126
2127 if (flags & TDF_SLIM)
2128 {
2129 pp_string (pp, "<STATEMENT_LIST>");
2130 break;
2131 }
2132
2133 for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))
2134 {
2135 if (!first)
2136 newline_and_indent (pp, spc);
2137 else
2138 first = false;
2139 dump_generic_node (pp, tsi_stmt (si), spc, flags, true);
2140 }
2141 }
2142 break;
2143
2144 case MODIFY_EXPR:
2145 case INIT_EXPR:
2146 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags,
2147 false);
2148 pp_space (pp);
2149 pp_equal (pp);
2150 pp_space (pp);
2151 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags,
2152 false);
2153 break;
2154
2155 case TARGET_EXPR:
2156 pp_string (pp, "TARGET_EXPR <");
2157 dump_generic_node (pp, TARGET_EXPR_SLOT (node), spc, flags, false);
2158 pp_comma (pp);
2159 pp_space (pp);
2160 dump_generic_node (pp, TARGET_EXPR_INITIAL (node), spc, flags, false);
2161 pp_greater (pp);
2162 break;
2163
2164 case DECL_EXPR:
2165 print_declaration (pp, DECL_EXPR_DECL (node), spc, flags);
2166 is_stmt = false;
2167 break;
2168
2169 case COND_EXPR:
2170 if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node)
2171 {
2172 pp_string (pp, "if (");
2173 dump_generic_node (pp, COND_EXPR_COND (node), spc, flags, false);
2174 pp_right_paren (pp);
2175 /* The lowered cond_exprs should always be printed in full. */
2176 if (COND_EXPR_THEN (node)
2177 && (IS_EMPTY_STMT (COND_EXPR_THEN (node))
2178 || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)
2179 && COND_EXPR_ELSE (node)
2180 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node))
2181 || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
2182 {
2183 pp_space (pp);
2184 dump_generic_node (pp, COND_EXPR_THEN (node),
2185 0, flags, true);
2186 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
2187 {
2188 pp_string (pp, " else ");
2189 dump_generic_node (pp, COND_EXPR_ELSE (node),
2190 0, flags, true);
2191 }
2192 }
2193 else if (!(flags & TDF_SLIM))
2194 {
2195 /* Output COND_EXPR_THEN. */
2196 if (COND_EXPR_THEN (node))
2197 {
2198 newline_and_indent (pp, spc+2);
2199 pp_left_brace (pp);
2200 newline_and_indent (pp, spc+4);
2201 dump_generic_node (pp, COND_EXPR_THEN (node), spc+4,
2202 flags, true);
2203 newline_and_indent (pp, spc+2);
2204 pp_right_brace (pp);
2205 }
2206
2207 /* Output COND_EXPR_ELSE. */
2208 if (COND_EXPR_ELSE (node)
2209 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
2210 {
2211 newline_and_indent (pp, spc);
2212 pp_string (pp, "else");
2213 newline_and_indent (pp, spc+2);
2214 pp_left_brace (pp);
2215 newline_and_indent (pp, spc+4);
2216 dump_generic_node (pp, COND_EXPR_ELSE (node), spc+4,
2217 flags, true);
2218 newline_and_indent (pp, spc+2);
2219 pp_right_brace (pp);
2220 }
2221 }
2222 is_expr = false;
2223 }
2224 else
2225 {
2226 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2227 pp_space (pp);
2228 pp_question (pp);
2229 pp_space (pp);
2230 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2231 pp_space (pp);
2232 pp_colon (pp);
2233 pp_space (pp);
2234 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2235 }
2236 break;
2237
2238 case BIND_EXPR:
2239 pp_left_brace (pp);
2240 if (!(flags & TDF_SLIM))
2241 {
2242 if (BIND_EXPR_VARS (node))
2243 {
2244 pp_newline (pp);
2245
2246 for (op0 = BIND_EXPR_VARS (node); op0; op0 = DECL_CHAIN (op0))
2247 {
2248 print_declaration (pp, op0, spc+2, flags);
2249 pp_newline (pp);
2250 }
2251 }
2252
2253 newline_and_indent (pp, spc+2);
2254 dump_generic_node (pp, BIND_EXPR_BODY (node), spc+2, flags, true);
2255 newline_and_indent (pp, spc);
2256 pp_right_brace (pp);
2257 }
2258 is_expr = false;
2259 break;
2260
2261 case CALL_EXPR:
2262 if (CALL_EXPR_FN (node) != NULL_TREE)
2263 print_call_name (pp, CALL_EXPR_FN (node), flags);
2264 else
2265 {
2266 pp_dot (pp);
2267 pp_string (pp, internal_fn_name (CALL_EXPR_IFN (node)));
2268 }
2269
2270 /* Print parameters. */
2271 pp_space (pp);
2272 pp_left_paren (pp);
2273 {
2274 tree arg;
2275 call_expr_arg_iterator iter;
2276 FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
2277 {
2278 dump_generic_node (pp, arg, spc, flags, false);
2279 if (more_call_expr_args_p (&iter))
2280 {
2281 pp_comma (pp);
2282 pp_space (pp);
2283 }
2284 }
2285 }
2286 if (CALL_EXPR_VA_ARG_PACK (node))
2287 {
2288 if (call_expr_nargs (node) > 0)
2289 {
2290 pp_comma (pp);
2291 pp_space (pp);
2292 }
2293 pp_string (pp, "__builtin_va_arg_pack ()");
2294 }
2295 pp_right_paren (pp);
2296
2297 op1 = CALL_EXPR_STATIC_CHAIN (node);
2298 if (op1)
2299 {
2300 pp_string (pp, " [static-chain: ");
2301 dump_generic_node (pp, op1, spc, flags, false);
2302 pp_right_bracket (pp);
2303 }
2304
2305 if (CALL_EXPR_RETURN_SLOT_OPT (node))
2306 pp_string (pp, " [return slot optimization]");
2307 if (CALL_EXPR_TAILCALL (node))
2308 pp_string (pp, " [tail call]");
2309 break;
2310
2311 case WITH_CLEANUP_EXPR:
2312 NIY;
2313 break;
2314
2315 case CLEANUP_POINT_EXPR:
2316 pp_string (pp, "<<cleanup_point ");
2317 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2318 pp_string (pp, ">>");
2319 break;
2320
2321 case PLACEHOLDER_EXPR:
2322 pp_string (pp, "<PLACEHOLDER_EXPR ");
2323 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2324 pp_greater (pp);
2325 break;
2326
2327 /* Binary arithmetic and logic expressions. */
2328 case WIDEN_SUM_EXPR:
2329 case WIDEN_MULT_EXPR:
2330 case MULT_EXPR:
2331 case MULT_HIGHPART_EXPR:
2332 case PLUS_EXPR:
2333 case POINTER_PLUS_EXPR:
2334 case POINTER_DIFF_EXPR:
2335 case MINUS_EXPR:
2336 case TRUNC_DIV_EXPR:
2337 case CEIL_DIV_EXPR:
2338 case FLOOR_DIV_EXPR:
2339 case ROUND_DIV_EXPR:
2340 case TRUNC_MOD_EXPR:
2341 case CEIL_MOD_EXPR:
2342 case FLOOR_MOD_EXPR:
2343 case ROUND_MOD_EXPR:
2344 case RDIV_EXPR:
2345 case EXACT_DIV_EXPR:
2346 case LSHIFT_EXPR:
2347 case RSHIFT_EXPR:
2348 case LROTATE_EXPR:
2349 case RROTATE_EXPR:
2350 case WIDEN_LSHIFT_EXPR:
2351 case BIT_IOR_EXPR:
2352 case BIT_XOR_EXPR:
2353 case BIT_AND_EXPR:
2354 case TRUTH_ANDIF_EXPR:
2355 case TRUTH_ORIF_EXPR:
2356 case TRUTH_AND_EXPR:
2357 case TRUTH_OR_EXPR:
2358 case TRUTH_XOR_EXPR:
2359 case LT_EXPR:
2360 case LE_EXPR:
2361 case GT_EXPR:
2362 case GE_EXPR:
2363 case EQ_EXPR:
2364 case NE_EXPR:
2365 case UNLT_EXPR:
2366 case UNLE_EXPR:
2367 case UNGT_EXPR:
2368 case UNGE_EXPR:
2369 case UNEQ_EXPR:
2370 case LTGT_EXPR:
2371 case ORDERED_EXPR:
2372 case UNORDERED_EXPR:
2373 {
2374 const char *op = op_symbol (node);
2375 op0 = TREE_OPERAND (node, 0);
2376 op1 = TREE_OPERAND (node, 1);
2377
2378 /* When the operands are expressions with less priority,
2379 keep semantics of the tree representation. */
2380 if (op_prio (op0) <= op_prio (node))
2381 {
2382 pp_left_paren (pp);
2383 dump_generic_node (pp, op0, spc, flags, false);
2384 pp_right_paren (pp);
2385 }
2386 else
2387 dump_generic_node (pp, op0, spc, flags, false);
2388
2389 pp_space (pp);
2390 pp_string (pp, op);
2391 pp_space (pp);
2392
2393 /* When the operands are expressions with less priority,
2394 keep semantics of the tree representation. */
2395 if (op_prio (op1) <= op_prio (node))
2396 {
2397 pp_left_paren (pp);
2398 dump_generic_node (pp, op1, spc, flags, false);
2399 pp_right_paren (pp);
2400 }
2401 else
2402 dump_generic_node (pp, op1, spc, flags, false);
2403 }
2404 break;
2405
2406 /* Unary arithmetic and logic expressions. */
2407 case NEGATE_EXPR:
2408 case BIT_NOT_EXPR:
2409 case TRUTH_NOT_EXPR:
2410 case ADDR_EXPR:
2411 case PREDECREMENT_EXPR:
2412 case PREINCREMENT_EXPR:
2413 case INDIRECT_REF:
2414 if (TREE_CODE (node) == ADDR_EXPR
2415 && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
2416 || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
2417 ; /* Do not output '&' for strings and function pointers. */
2418 else
2419 pp_string (pp, op_symbol (node));
2420
2421 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
2422 {
2423 pp_left_paren (pp);
2424 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2425 pp_right_paren (pp);
2426 }
2427 else
2428 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2429 break;
2430
2431 case POSTDECREMENT_EXPR:
2432 case POSTINCREMENT_EXPR:
2433 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
2434 {
2435 pp_left_paren (pp);
2436 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2437 pp_right_paren (pp);
2438 }
2439 else
2440 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2441 pp_string (pp, op_symbol (node));
2442 break;
2443
2444 case MIN_EXPR:
2445 pp_string (pp, "MIN_EXPR <");
2446 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2447 pp_string (pp, ", ");
2448 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2449 pp_greater (pp);
2450 break;
2451
2452 case MAX_EXPR:
2453 pp_string (pp, "MAX_EXPR <");
2454 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2455 pp_string (pp, ", ");
2456 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2457 pp_greater (pp);
2458 break;
2459
2460 case ABS_EXPR:
2461 pp_string (pp, "ABS_EXPR <");
2462 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2463 pp_greater (pp);
2464 break;
2465
2466 case RANGE_EXPR:
2467 NIY;
2468 break;
2469
2470 case ADDR_SPACE_CONVERT_EXPR:
2471 case FIXED_CONVERT_EXPR:
2472 case FIX_TRUNC_EXPR:
2473 case FLOAT_EXPR:
2474 CASE_CONVERT:
2475 type = TREE_TYPE (node);
2476 op0 = TREE_OPERAND (node, 0);
2477 if (type != TREE_TYPE (op0))
2478 {
2479 pp_left_paren (pp);
2480 dump_generic_node (pp, type, spc, flags, false);
2481 pp_string (pp, ") ");
2482 }
2483 if (op_prio (op0) < op_prio (node))
2484 pp_left_paren (pp);
2485 dump_generic_node (pp, op0, spc, flags, false);
2486 if (op_prio (op0) < op_prio (node))
2487 pp_right_paren (pp);
2488 break;
2489
2490 case VIEW_CONVERT_EXPR:
2491 pp_string (pp, "VIEW_CONVERT_EXPR<");
2492 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2493 pp_string (pp, ">(");
2494 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2495 pp_right_paren (pp);
2496 break;
2497
2498 case PAREN_EXPR:
2499 pp_string (pp, "((");
2500 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2501 pp_string (pp, "))");
2502 break;
2503
2504 case NON_LVALUE_EXPR:
2505 pp_string (pp, "NON_LVALUE_EXPR <");
2506 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2507 pp_greater (pp);
2508 break;
2509
2510 case SAVE_EXPR:
2511 pp_string (pp, "SAVE_EXPR <");
2512 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2513 pp_greater (pp);
2514 break;
2515
2516 case COMPLEX_EXPR:
2517 pp_string (pp, "COMPLEX_EXPR <");
2518 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2519 pp_string (pp, ", ");
2520 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2521 pp_greater (pp);
2522 break;
2523
2524 case CONJ_EXPR:
2525 pp_string (pp, "CONJ_EXPR <");
2526 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2527 pp_greater (pp);
2528 break;
2529
2530 case REALPART_EXPR:
2531 if (flags & TDF_GIMPLE)
2532 {
2533 pp_string (pp, "__real ");
2534 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2535 }
2536 else
2537 {
2538 pp_string (pp, "REALPART_EXPR <");
2539 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2540 pp_greater (pp);
2541 }
2542 break;
2543
2544 case IMAGPART_EXPR:
2545 if (flags & TDF_GIMPLE)
2546 {
2547 pp_string (pp, "__imag ");
2548 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2549 }
2550 else
2551 {
2552 pp_string (pp, "IMAGPART_EXPR <");
2553 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2554 pp_greater (pp);
2555 }
2556 break;
2557
2558 case VA_ARG_EXPR:
2559 pp_string (pp, "VA_ARG_EXPR <");
2560 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2561 pp_greater (pp);
2562 break;
2563
2564 case TRY_FINALLY_EXPR:
2565 case TRY_CATCH_EXPR:
2566 pp_string (pp, "try");
2567 newline_and_indent (pp, spc+2);
2568 pp_left_brace (pp);
2569 newline_and_indent (pp, spc+4);
2570 dump_generic_node (pp, TREE_OPERAND (node, 0), spc+4, flags, true);
2571 newline_and_indent (pp, spc+2);
2572 pp_right_brace (pp);
2573 newline_and_indent (pp, spc);
2574 pp_string (pp,
2575 (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");
2576 newline_and_indent (pp, spc+2);
2577 pp_left_brace (pp);
2578 newline_and_indent (pp, spc+4);
2579 dump_generic_node (pp, TREE_OPERAND (node, 1), spc+4, flags, true);
2580 newline_and_indent (pp, spc+2);
2581 pp_right_brace (pp);
2582 is_expr = false;
2583 break;
2584
2585 case CATCH_EXPR:
2586 pp_string (pp, "catch (");
2587 dump_generic_node (pp, CATCH_TYPES (node), spc+2, flags, false);
2588 pp_right_paren (pp);
2589 newline_and_indent (pp, spc+2);
2590 pp_left_brace (pp);
2591 newline_and_indent (pp, spc+4);
2592 dump_generic_node (pp, CATCH_BODY (node), spc+4, flags, true);
2593 newline_and_indent (pp, spc+2);
2594 pp_right_brace (pp);
2595 is_expr = false;
2596 break;
2597
2598 case EH_FILTER_EXPR:
2599 pp_string (pp, "<<<eh_filter (");
2600 dump_generic_node (pp, EH_FILTER_TYPES (node), spc+2, flags, false);
2601 pp_string (pp, ")>>>");
2602 newline_and_indent (pp, spc+2);
2603 pp_left_brace (pp);
2604 newline_and_indent (pp, spc+4);
2605 dump_generic_node (pp, EH_FILTER_FAILURE (node), spc+4, flags, true);
2606 newline_and_indent (pp, spc+2);
2607 pp_right_brace (pp);
2608 is_expr = false;
2609 break;
2610
2611 case LABEL_EXPR:
2612 op0 = TREE_OPERAND (node, 0);
2613 /* If this is for break or continue, don't bother printing it. */
2614 if (DECL_NAME (op0))
2615 {
2616 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
2617 if (strcmp (name, "break") == 0
2618 || strcmp (name, "continue") == 0)
2619 break;
2620 }
2621 dump_generic_node (pp, op0, spc, flags, false);
2622 pp_colon (pp);
2623 if (DECL_NONLOCAL (op0))
2624 pp_string (pp, " [non-local]");
2625 break;
2626
2627 case LOOP_EXPR:
2628 pp_string (pp, "while (1)");
2629 if (!(flags & TDF_SLIM))
2630 {
2631 newline_and_indent (pp, spc+2);
2632 pp_left_brace (pp);
2633 newline_and_indent (pp, spc+4);
2634 dump_generic_node (pp, LOOP_EXPR_BODY (node), spc+4, flags, true);
2635 newline_and_indent (pp, spc+2);
2636 pp_right_brace (pp);
2637 }
2638 is_expr = false;
2639 break;
2640
2641 case PREDICT_EXPR:
2642 pp_string (pp, "// predicted ");
2643 if (PREDICT_EXPR_OUTCOME (node))
2644 pp_string (pp, "likely by ");
2645 else
2646 pp_string (pp, "unlikely by ");
2647 pp_string (pp, predictor_name (PREDICT_EXPR_PREDICTOR (node)));
2648 pp_string (pp, " predictor.");
2649 break;
2650
2651 case ANNOTATE_EXPR:
2652 pp_string (pp, "ANNOTATE_EXPR <");
2653 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2654 switch ((enum annot_expr_kind) TREE_INT_CST_LOW (TREE_OPERAND (node, 1)))
2655 {
2656 case annot_expr_ivdep_kind:
2657 pp_string (pp, ", ivdep");
2658 break;
2659 case annot_expr_unroll_kind:
2660 pp_printf (pp, ", unroll %d",
2661 (int) TREE_INT_CST_LOW (TREE_OPERAND (node, 2)));
2662 break;
2663 case annot_expr_no_vector_kind:
2664 pp_string (pp, ", no-vector");
2665 break;
2666 case annot_expr_vector_kind:
2667 pp_string (pp, ", vector");
2668 break;
2669 case annot_expr_parallel_kind:
2670 pp_string (pp, ", parallel");
2671 break;
2672 default:
2673 gcc_unreachable ();
2674 }
2675 pp_greater (pp);
2676 break;
2677
2678 case RETURN_EXPR:
2679 pp_string (pp, "return");
2680 op0 = TREE_OPERAND (node, 0);
2681 if (op0)
2682 {
2683 pp_space (pp);
2684 if (TREE_CODE (op0) == MODIFY_EXPR)
2685 dump_generic_node (pp, TREE_OPERAND (op0, 1),
2686 spc, flags, false);
2687 else
2688 dump_generic_node (pp, op0, spc, flags, false);
2689 }
2690 break;
2691
2692 case EXIT_EXPR:
2693 pp_string (pp, "if (");
2694 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2695 pp_string (pp, ") break");
2696 break;
2697
2698 case SWITCH_EXPR:
2699 pp_string (pp, "switch (");
2700 dump_generic_node (pp, SWITCH_COND (node), spc, flags, false);
2701 pp_right_paren (pp);
2702 if (!(flags & TDF_SLIM))
2703 {
2704 newline_and_indent (pp, spc+2);
2705 pp_left_brace (pp);
2706 if (SWITCH_BODY (node))
2707 {
2708 newline_and_indent (pp, spc+4);
2709 dump_generic_node (pp, SWITCH_BODY (node), spc+4, flags,
2710 true);
2711 }
2712 newline_and_indent (pp, spc+2);
2713 pp_right_brace (pp);
2714 }
2715 is_expr = false;
2716 break;
2717
2718 case GOTO_EXPR:
2719 op0 = GOTO_DESTINATION (node);
2720 if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
2721 {
2722 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
2723 if (strcmp (name, "break") == 0
2724 || strcmp (name, "continue") == 0)
2725 {
2726 pp_string (pp, name);
2727 break;
2728 }
2729 }
2730 pp_string (pp, "goto ");
2731 dump_generic_node (pp, op0, spc, flags, false);
2732 break;
2733
2734 case ASM_EXPR:
2735 pp_string (pp, "__asm__");
2736 if (ASM_VOLATILE_P (node))
2737 pp_string (pp, " __volatile__");
2738 pp_left_paren (pp);
2739 dump_generic_node (pp, ASM_STRING (node), spc, flags, false);
2740 pp_colon (pp);
2741 dump_generic_node (pp, ASM_OUTPUTS (node), spc, flags, false);
2742 pp_colon (pp);
2743 dump_generic_node (pp, ASM_INPUTS (node), spc, flags, false);
2744 if (ASM_CLOBBERS (node))
2745 {
2746 pp_colon (pp);
2747 dump_generic_node (pp, ASM_CLOBBERS (node), spc, flags, false);
2748 }
2749 pp_right_paren (pp);
2750 break;
2751
2752 case CASE_LABEL_EXPR:
2753 if (CASE_LOW (node) && CASE_HIGH (node))
2754 {
2755 pp_string (pp, "case ");
2756 dump_generic_node (pp, CASE_LOW (node), spc, flags, false);
2757 pp_string (pp, " ... ");
2758 dump_generic_node (pp, CASE_HIGH (node), spc, flags, false);
2759 }
2760 else if (CASE_LOW (node))
2761 {
2762 pp_string (pp, "case ");
2763 dump_generic_node (pp, CASE_LOW (node), spc, flags, false);
2764 }
2765 else
2766 pp_string (pp, "default");
2767 pp_colon (pp);
2768 break;
2769
2770 case OBJ_TYPE_REF:
2771 pp_string (pp, "OBJ_TYPE_REF(");
2772 dump_generic_node (pp, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
2773 pp_semicolon (pp);
2774 /* We omit the class type for -fcompare-debug because we may
2775 drop TYPE_BINFO early depending on debug info, and then
2776 virtual_method_call_p would return false, whereas when
2777 TYPE_BINFO is preserved it may still return true and then
2778 we'd print the class type. Compare tree and rtl dumps for
2779 libstdc++-prettyprinters/shared_ptr.cc with and without -g,
2780 for example, at occurrences of OBJ_TYPE_REF. */
2781 if (!(flags & (TDF_SLIM | TDF_COMPARE_DEBUG))
2782 && virtual_method_call_p (node))
2783 {
2784 pp_string (pp, "(");
2785 dump_generic_node (pp, obj_type_ref_class (node), spc, flags, false);
2786 pp_string (pp, ")");
2787 }
2788 dump_generic_node (pp, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
2789 pp_arrow (pp);
2790 dump_generic_node (pp, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
2791 pp_right_paren (pp);
2792 break;
2793
2794 case SSA_NAME:
2795 if (SSA_NAME_IDENTIFIER (node))
2796 {
2797 if ((flags & TDF_NOUID)
2798 && SSA_NAME_VAR (node)
2799 && DECL_NAMELESS (SSA_NAME_VAR (node)))
2800 dump_fancy_name (pp, SSA_NAME_IDENTIFIER (node));
2801 else if (! (flags & TDF_GIMPLE)
2802 || SSA_NAME_VAR (node))
2803 dump_generic_node (pp, SSA_NAME_IDENTIFIER (node),
2804 spc, flags, false);
2805 }
2806 pp_underscore (pp);
2807 pp_decimal_int (pp, SSA_NAME_VERSION (node));
2808 if (SSA_NAME_IS_DEFAULT_DEF (node))
2809 pp_string (pp, "(D)");
2810 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
2811 pp_string (pp, "(ab)");
2812 break;
2813
2814 case WITH_SIZE_EXPR:
2815 pp_string (pp, "WITH_SIZE_EXPR <");
2816 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2817 pp_string (pp, ", ");
2818 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2819 pp_greater (pp);
2820 break;
2821
2822 case ASSERT_EXPR:
2823 pp_string (pp, "ASSERT_EXPR <");
2824 dump_generic_node (pp, ASSERT_EXPR_VAR (node), spc, flags, false);
2825 pp_string (pp, ", ");
2826 dump_generic_node (pp, ASSERT_EXPR_COND (node), spc, flags, false);
2827 pp_greater (pp);
2828 break;
2829
2830 case SCEV_KNOWN:
2831 pp_string (pp, "scev_known");
2832 break;
2833
2834 case SCEV_NOT_KNOWN:
2835 pp_string (pp, "scev_not_known");
2836 break;
2837
2838 case POLYNOMIAL_CHREC:
2839 pp_left_brace (pp);
2840 dump_generic_node (pp, CHREC_LEFT (node), spc, flags, false);
2841 pp_string (pp, ", +, ");
2842 dump_generic_node (pp, CHREC_RIGHT (node), spc, flags, false);
2843 pp_printf (pp, "}_%u", CHREC_VARIABLE (node));
2844 is_stmt = false;
2845 break;
2846
2847 case REALIGN_LOAD_EXPR:
2848 pp_string (pp, "REALIGN_LOAD <");
2849 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2850 pp_string (pp, ", ");
2851 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2852 pp_string (pp, ", ");
2853 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2854 pp_greater (pp);
2855 break;
2856
2857 case VEC_COND_EXPR:
2858 pp_string (pp, " VEC_COND_EXPR < ");
2859 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2860 pp_string (pp, " , ");
2861 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2862 pp_string (pp, " , ");
2863 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2864 pp_string (pp, " > ");
2865 break;
2866
2867 case VEC_PERM_EXPR:
2868 pp_string (pp, " VEC_PERM_EXPR < ");
2869 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2870 pp_string (pp, " , ");
2871 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2872 pp_string (pp, " , ");
2873 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2874 pp_string (pp, " > ");
2875 break;
2876
2877 case DOT_PROD_EXPR:
2878 pp_string (pp, " DOT_PROD_EXPR < ");
2879 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2880 pp_string (pp, ", ");
2881 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2882 pp_string (pp, ", ");
2883 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2884 pp_string (pp, " > ");
2885 break;
2886
2887 case WIDEN_MULT_PLUS_EXPR:
2888 pp_string (pp, " WIDEN_MULT_PLUS_EXPR < ");
2889 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2890 pp_string (pp, ", ");
2891 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2892 pp_string (pp, ", ");
2893 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2894 pp_string (pp, " > ");
2895 break;
2896
2897 case WIDEN_MULT_MINUS_EXPR:
2898 pp_string (pp, " WIDEN_MULT_MINUS_EXPR < ");
2899 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2900 pp_string (pp, ", ");
2901 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2902 pp_string (pp, ", ");
2903 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2904 pp_string (pp, " > ");
2905 break;
2906
2907 case OACC_PARALLEL:
2908 pp_string (pp, "#pragma acc parallel");
2909 goto dump_omp_clauses_body;
2910
2911 case OACC_KERNELS:
2912 pp_string (pp, "#pragma acc kernels");
2913 goto dump_omp_clauses_body;
2914
2915 case OACC_DATA:
2916 pp_string (pp, "#pragma acc data");
2917 dump_omp_clauses (pp, OACC_DATA_CLAUSES (node), spc, flags);
2918 goto dump_omp_body;
2919
2920 case OACC_HOST_DATA:
2921 pp_string (pp, "#pragma acc host_data");
2922 dump_omp_clauses (pp, OACC_HOST_DATA_CLAUSES (node), spc, flags);
2923 goto dump_omp_body;
2924
2925 case OACC_DECLARE:
2926 pp_string (pp, "#pragma acc declare");
2927 dump_omp_clauses (pp, OACC_DECLARE_CLAUSES (node), spc, flags);
2928 break;
2929
2930 case OACC_UPDATE:
2931 pp_string (pp, "#pragma acc update");
2932 dump_omp_clauses (pp, OACC_UPDATE_CLAUSES (node), spc, flags);
2933 break;
2934
2935 case OACC_ENTER_DATA:
2936 pp_string (pp, "#pragma acc enter data");
2937 dump_omp_clauses (pp, OACC_ENTER_DATA_CLAUSES (node), spc, flags);
2938 break;
2939
2940 case OACC_EXIT_DATA:
2941 pp_string (pp, "#pragma acc exit data");
2942 dump_omp_clauses (pp, OACC_EXIT_DATA_CLAUSES (node), spc, flags);
2943 break;
2944
2945 case OACC_CACHE:
2946 pp_string (pp, "#pragma acc cache");
2947 dump_omp_clauses (pp, OACC_CACHE_CLAUSES (node), spc, flags);
2948 break;
2949
2950 case OMP_PARALLEL:
2951 pp_string (pp, "#pragma omp parallel");
2952 dump_omp_clauses (pp, OMP_PARALLEL_CLAUSES (node), spc, flags);
2953 goto dump_omp_body;
2954
2955 dump_omp_clauses_body:
2956 dump_omp_clauses (pp, OMP_CLAUSES (node), spc, flags);
2957 goto dump_omp_body;
2958
2959 dump_omp_body:
2960 if (!(flags & TDF_SLIM) && OMP_BODY (node))
2961 {
2962 newline_and_indent (pp, spc + 2);
2963 pp_left_brace (pp);
2964 newline_and_indent (pp, spc + 4);
2965 dump_generic_node (pp, OMP_BODY (node), spc + 4, flags, false);
2966 newline_and_indent (pp, spc + 2);
2967 pp_right_brace (pp);
2968 }
2969 is_expr = false;
2970 break;
2971
2972 case OMP_TASK:
2973 pp_string (pp, "#pragma omp task");
2974 dump_omp_clauses (pp, OMP_TASK_CLAUSES (node), spc, flags);
2975 goto dump_omp_body;
2976
2977 case OMP_FOR:
2978 pp_string (pp, "#pragma omp for");
2979 goto dump_omp_loop;
2980
2981 case OMP_SIMD:
2982 pp_string (pp, "#pragma omp simd");
2983 goto dump_omp_loop;
2984
2985 case OMP_DISTRIBUTE:
2986 pp_string (pp, "#pragma omp distribute");
2987 goto dump_omp_loop;
2988
2989 case OMP_TASKLOOP:
2990 pp_string (pp, "#pragma omp taskloop");
2991 goto dump_omp_loop;
2992
2993 case OACC_LOOP:
2994 pp_string (pp, "#pragma acc loop");
2995 goto dump_omp_loop;
2996
2997 case OMP_TEAMS:
2998 pp_string (pp, "#pragma omp teams");
2999 dump_omp_clauses (pp, OMP_TEAMS_CLAUSES (node), spc, flags);
3000 goto dump_omp_body;
3001
3002 case OMP_TARGET_DATA:
3003 pp_string (pp, "#pragma omp target data");
3004 dump_omp_clauses (pp, OMP_TARGET_DATA_CLAUSES (node), spc, flags);
3005 goto dump_omp_body;
3006
3007 case OMP_TARGET_ENTER_DATA:
3008 pp_string (pp, "#pragma omp target enter data");
3009 dump_omp_clauses (pp, OMP_TARGET_ENTER_DATA_CLAUSES (node), spc, flags);
3010 is_expr = false;
3011 break;
3012
3013 case OMP_TARGET_EXIT_DATA:
3014 pp_string (pp, "#pragma omp target exit data");
3015 dump_omp_clauses (pp, OMP_TARGET_EXIT_DATA_CLAUSES (node), spc, flags);
3016 is_expr = false;
3017 break;
3018
3019 case OMP_TARGET:
3020 pp_string (pp, "#pragma omp target");
3021 dump_omp_clauses (pp, OMP_TARGET_CLAUSES (node), spc, flags);
3022 goto dump_omp_body;
3023
3024 case OMP_TARGET_UPDATE:
3025 pp_string (pp, "#pragma omp target update");
3026 dump_omp_clauses (pp, OMP_TARGET_UPDATE_CLAUSES (node), spc, flags);
3027 is_expr = false;
3028 break;
3029
3030 dump_omp_loop:
3031 dump_omp_clauses (pp, OMP_FOR_CLAUSES (node), spc, flags);
3032 if (!(flags & TDF_SLIM))
3033 {
3034 int i;
3035
3036 if (OMP_FOR_PRE_BODY (node))
3037 {
3038 newline_and_indent (pp, spc + 2);
3039 pp_left_brace (pp);
3040 spc += 4;
3041 newline_and_indent (pp, spc);
3042 dump_generic_node (pp, OMP_FOR_PRE_BODY (node),
3043 spc, flags, false);
3044 }
3045 if (OMP_FOR_INIT (node))
3046 {
3047 spc -= 2;
3048 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (node)); i++)
3049 {
3050 spc += 2;
3051 newline_and_indent (pp, spc);
3052 pp_string (pp, "for (");
3053 dump_generic_node (pp,
3054 TREE_VEC_ELT (OMP_FOR_INIT (node), i),
3055 spc, flags, false);
3056 pp_string (pp, "; ");
3057 dump_generic_node (pp,
3058 TREE_VEC_ELT (OMP_FOR_COND (node), i),
3059 spc, flags, false);
3060 pp_string (pp, "; ");
3061 dump_generic_node (pp,
3062 TREE_VEC_ELT (OMP_FOR_INCR (node), i),
3063 spc, flags, false);
3064 pp_right_paren (pp);
3065 }
3066 }
3067 if (OMP_FOR_BODY (node))
3068 {
3069 newline_and_indent (pp, spc + 2);
3070 pp_left_brace (pp);
3071 newline_and_indent (pp, spc + 4);
3072 dump_generic_node (pp, OMP_FOR_BODY (node), spc + 4, flags,
3073 false);
3074 newline_and_indent (pp, spc + 2);
3075 pp_right_brace (pp);
3076 }
3077 if (OMP_FOR_INIT (node))
3078 spc -= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node)) - 2;
3079 if (OMP_FOR_PRE_BODY (node))
3080 {
3081 spc -= 4;
3082 newline_and_indent (pp, spc + 2);
3083 pp_right_brace (pp);
3084 }
3085 }
3086 is_expr = false;
3087 break;
3088
3089 case OMP_SECTIONS:
3090 pp_string (pp, "#pragma omp sections");
3091 dump_omp_clauses (pp, OMP_SECTIONS_CLAUSES (node), spc, flags);
3092 goto dump_omp_body;
3093
3094 case OMP_SECTION:
3095 pp_string (pp, "#pragma omp section");
3096 goto dump_omp_body;
3097
3098 case OMP_MASTER:
3099 pp_string (pp, "#pragma omp master");
3100 goto dump_omp_body;
3101
3102 case OMP_TASKGROUP:
3103 pp_string (pp, "#pragma omp taskgroup");
3104 goto dump_omp_body;
3105
3106 case OMP_ORDERED:
3107 pp_string (pp, "#pragma omp ordered");
3108 dump_omp_clauses (pp, OMP_ORDERED_CLAUSES (node), spc, flags);
3109 goto dump_omp_body;
3110
3111 case OMP_CRITICAL:
3112 pp_string (pp, "#pragma omp critical");
3113 if (OMP_CRITICAL_NAME (node))
3114 {
3115 pp_space (pp);
3116 pp_left_paren (pp);
3117 dump_generic_node (pp, OMP_CRITICAL_NAME (node), spc,
3118 flags, false);
3119 pp_right_paren (pp);
3120 }
3121 dump_omp_clauses (pp, OMP_CRITICAL_CLAUSES (node), spc, flags);
3122 goto dump_omp_body;
3123
3124 case OMP_ATOMIC:
3125 pp_string (pp, "#pragma omp atomic");
3126 if (OMP_ATOMIC_SEQ_CST (node))
3127 pp_string (pp, " seq_cst");
3128 newline_and_indent (pp, spc + 2);
3129 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3130 pp_space (pp);
3131 pp_equal (pp);
3132 pp_space (pp);
3133 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3134 break;
3135
3136 case OMP_ATOMIC_READ:
3137 pp_string (pp, "#pragma omp atomic read");
3138 if (OMP_ATOMIC_SEQ_CST (node))
3139 pp_string (pp, " seq_cst");
3140 newline_and_indent (pp, spc + 2);
3141 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3142 pp_space (pp);
3143 break;
3144
3145 case OMP_ATOMIC_CAPTURE_OLD:
3146 case OMP_ATOMIC_CAPTURE_NEW:
3147 pp_string (pp, "#pragma omp atomic capture");
3148 if (OMP_ATOMIC_SEQ_CST (node))
3149 pp_string (pp, " seq_cst");
3150 newline_and_indent (pp, spc + 2);
3151 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3152 pp_space (pp);
3153 pp_equal (pp);
3154 pp_space (pp);
3155 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3156 break;
3157
3158 case OMP_SINGLE:
3159 pp_string (pp, "#pragma omp single");
3160 dump_omp_clauses (pp, OMP_SINGLE_CLAUSES (node), spc, flags);
3161 goto dump_omp_body;
3162
3163 case OMP_CLAUSE:
3164 dump_omp_clause (pp, node, spc, flags);
3165 is_expr = false;
3166 break;
3167
3168 case TRANSACTION_EXPR:
3169 if (TRANSACTION_EXPR_OUTER (node))
3170 pp_string (pp, "__transaction_atomic [[outer]]");
3171 else if (TRANSACTION_EXPR_RELAXED (node))
3172 pp_string (pp, "__transaction_relaxed");
3173 else
3174 pp_string (pp, "__transaction_atomic");
3175 if (!(flags & TDF_SLIM) && TRANSACTION_EXPR_BODY (node))
3176 {
3177 newline_and_indent (pp, spc);
3178 pp_left_brace (pp);
3179 newline_and_indent (pp, spc + 2);
3180 dump_generic_node (pp, TRANSACTION_EXPR_BODY (node),
3181 spc + 2, flags, false);
3182 newline_and_indent (pp, spc);
3183 pp_right_brace (pp);
3184 }
3185 is_expr = false;
3186 break;
3187
3188 case VEC_SERIES_EXPR:
3189 case VEC_WIDEN_MULT_HI_EXPR:
3190 case VEC_WIDEN_MULT_LO_EXPR:
3191 case VEC_WIDEN_MULT_EVEN_EXPR:
3192 case VEC_WIDEN_MULT_ODD_EXPR:
3193 case VEC_WIDEN_LSHIFT_HI_EXPR:
3194 case VEC_WIDEN_LSHIFT_LO_EXPR:
3195 pp_space (pp);
3196 for (str = get_tree_code_name (code); *str; str++)
3197 pp_character (pp, TOUPPER (*str));
3198 pp_string (pp, " < ");
3199 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3200 pp_string (pp, ", ");
3201 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3202 pp_string (pp, " > ");
3203 break;
3204
3205 case VEC_DUPLICATE_EXPR:
3206 pp_space (pp);
3207 for (str = get_tree_code_name (code); *str; str++)
3208 pp_character (pp, TOUPPER (*str));
3209 pp_string (pp, " < ");
3210 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3211 pp_string (pp, " > ");
3212 break;
3213
3214 case VEC_UNPACK_HI_EXPR:
3215 pp_string (pp, " VEC_UNPACK_HI_EXPR < ");
3216 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3217 pp_string (pp, " > ");
3218 break;
3219
3220 case VEC_UNPACK_LO_EXPR:
3221 pp_string (pp, " VEC_UNPACK_LO_EXPR < ");
3222 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3223 pp_string (pp, " > ");
3224 break;
3225
3226 case VEC_UNPACK_FLOAT_HI_EXPR:
3227 pp_string (pp, " VEC_UNPACK_FLOAT_HI_EXPR < ");
3228 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3229 pp_string (pp, " > ");
3230 break;
3231
3232 case VEC_UNPACK_FLOAT_LO_EXPR:
3233 pp_string (pp, " VEC_UNPACK_FLOAT_LO_EXPR < ");
3234 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3235 pp_string (pp, " > ");
3236 break;
3237
3238 case VEC_PACK_TRUNC_EXPR:
3239 pp_string (pp, " VEC_PACK_TRUNC_EXPR < ");
3240 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3241 pp_string (pp, ", ");
3242 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3243 pp_string (pp, " > ");
3244 break;
3245
3246 case VEC_PACK_SAT_EXPR:
3247 pp_string (pp, " VEC_PACK_SAT_EXPR < ");
3248 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3249 pp_string (pp, ", ");
3250 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3251 pp_string (pp, " > ");
3252 break;
3253
3254 case VEC_PACK_FIX_TRUNC_EXPR:
3255 pp_string (pp, " VEC_PACK_FIX_TRUNC_EXPR < ");
3256 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3257 pp_string (pp, ", ");
3258 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3259 pp_string (pp, " > ");
3260 break;
3261
3262 case BLOCK:
3263 dump_block_node (pp, node, spc, flags);
3264 break;
3265
3266 case DEBUG_BEGIN_STMT:
3267 pp_string (pp, "# DEBUG BEGIN STMT");
3268 break;
3269
3270 default:
3271 NIY;
3272 }
3273
3274 if (is_stmt && is_expr)
3275 pp_semicolon (pp);
3276
3277 return spc;
3278 }
3279
3280 /* Print the declaration of a variable. */
3281
3282 void
3283 print_declaration (pretty_printer *pp, tree t, int spc, dump_flags_t flags)
3284 {
3285 INDENT (spc);
3286
3287 if (TREE_CODE(t) == NAMELIST_DECL)
3288 {
3289 pp_string(pp, "namelist ");
3290 dump_decl_name (pp, t, flags);
3291 pp_semicolon (pp);
3292 return;
3293 }
3294
3295 if (TREE_CODE (t) == TYPE_DECL)
3296 pp_string (pp, "typedef ");
3297
3298 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t))
3299 pp_string (pp, "register ");
3300
3301 if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
3302 pp_string (pp, "extern ");
3303 else if (TREE_STATIC (t))
3304 pp_string (pp, "static ");
3305
3306 /* Print the type and name. */
3307 if (TREE_TYPE (t) && TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
3308 {
3309 tree tmp;
3310
3311 /* Print array's type. */
3312 tmp = TREE_TYPE (t);
3313 while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
3314 tmp = TREE_TYPE (tmp);
3315 dump_generic_node (pp, TREE_TYPE (tmp), spc, flags, false);
3316
3317 /* Print variable's name. */
3318 pp_space (pp);
3319 dump_generic_node (pp, t, spc, flags, false);
3320
3321 /* Print the dimensions. */
3322 tmp = TREE_TYPE (t);
3323 while (TREE_CODE (tmp) == ARRAY_TYPE)
3324 {
3325 dump_array_domain (pp, TYPE_DOMAIN (tmp), spc, flags);
3326 tmp = TREE_TYPE (tmp);
3327 }
3328 }
3329 else if (TREE_CODE (t) == FUNCTION_DECL)
3330 {
3331 dump_generic_node (pp, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
3332 pp_space (pp);
3333 dump_decl_name (pp, t, flags);
3334 dump_function_declaration (pp, TREE_TYPE (t), spc, flags);
3335 }
3336 else
3337 {
3338 /* Print type declaration. */
3339 dump_generic_node (pp, TREE_TYPE (t), spc, flags, false);
3340
3341 /* Print variable's name. */
3342 pp_space (pp);
3343 dump_generic_node (pp, t, spc, flags, false);
3344 }
3345
3346 if (VAR_P (t) && DECL_HARD_REGISTER (t))
3347 {
3348 pp_string (pp, " __asm__ ");
3349 pp_left_paren (pp);
3350 dump_generic_node (pp, DECL_ASSEMBLER_NAME (t), spc, flags, false);
3351 pp_right_paren (pp);
3352 }
3353
3354 /* The initial value of a function serves to determine whether the function
3355 is declared or defined. So the following does not apply to function
3356 nodes. */
3357 if (TREE_CODE (t) != FUNCTION_DECL)
3358 {
3359 /* Print the initial value. */
3360 if (DECL_INITIAL (t))
3361 {
3362 pp_space (pp);
3363 pp_equal (pp);
3364 pp_space (pp);
3365 if (!(flags & TDF_SLIM))
3366 dump_generic_node (pp, DECL_INITIAL (t), spc, flags, false);
3367 else
3368 pp_string (pp, "<<< omitted >>>");
3369 }
3370 }
3371
3372 if (VAR_P (t) && DECL_HAS_VALUE_EXPR_P (t))
3373 {
3374 pp_string (pp, " [value-expr: ");
3375 dump_generic_node (pp, DECL_VALUE_EXPR (t), spc, flags, false);
3376 pp_right_bracket (pp);
3377 }
3378
3379 pp_semicolon (pp);
3380 }
3381
3382
3383 /* Prints a structure: name, fields, and methods.
3384 FIXME: Still incomplete. */
3385
3386 static void
3387 print_struct_decl (pretty_printer *pp, const_tree node, int spc,
3388 dump_flags_t flags)
3389 {
3390 /* Print the name of the structure. */
3391 if (TYPE_NAME (node))
3392 {
3393 INDENT (spc);
3394 if (TREE_CODE (node) == RECORD_TYPE)
3395 pp_string (pp, "struct ");
3396 else if ((TREE_CODE (node) == UNION_TYPE
3397 || TREE_CODE (node) == QUAL_UNION_TYPE))
3398 pp_string (pp, "union ");
3399
3400 dump_generic_node (pp, TYPE_NAME (node), spc, 0, false);
3401 }
3402
3403 /* Print the contents of the structure. */
3404 pp_newline (pp);
3405 INDENT (spc);
3406 pp_left_brace (pp);
3407 pp_newline (pp);
3408
3409 /* Print the fields of the structure. */
3410 {
3411 tree tmp;
3412 tmp = TYPE_FIELDS (node);
3413 while (tmp)
3414 {
3415 /* Avoid to print recursively the structure. */
3416 /* FIXME : Not implemented correctly...,
3417 what about the case when we have a cycle in the contain graph? ...
3418 Maybe this could be solved by looking at the scope in which the
3419 structure was declared. */
3420 if (TREE_TYPE (tmp) != node
3421 && (TREE_CODE (TREE_TYPE (tmp)) != POINTER_TYPE
3422 || TREE_TYPE (TREE_TYPE (tmp)) != node))
3423 {
3424 print_declaration (pp, tmp, spc+2, flags);
3425 pp_newline (pp);
3426 }
3427 tmp = DECL_CHAIN (tmp);
3428 }
3429 }
3430 INDENT (spc);
3431 pp_right_brace (pp);
3432 }
3433
3434 /* Return the priority of the operator CODE.
3435
3436 From lowest to highest precedence with either left-to-right (L-R)
3437 or right-to-left (R-L) associativity]:
3438
3439 1 [L-R] ,
3440 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
3441 3 [R-L] ?:
3442 4 [L-R] ||
3443 5 [L-R] &&
3444 6 [L-R] |
3445 7 [L-R] ^
3446 8 [L-R] &
3447 9 [L-R] == !=
3448 10 [L-R] < <= > >=
3449 11 [L-R] << >>
3450 12 [L-R] + -
3451 13 [L-R] * / %
3452 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
3453 15 [L-R] fn() [] -> .
3454
3455 unary +, - and * have higher precedence than the corresponding binary
3456 operators. */
3457
3458 int
3459 op_code_prio (enum tree_code code)
3460 {
3461 switch (code)
3462 {
3463 case TREE_LIST:
3464 case COMPOUND_EXPR:
3465 case BIND_EXPR:
3466 return 1;
3467
3468 case MODIFY_EXPR:
3469 case INIT_EXPR:
3470 return 2;
3471
3472 case COND_EXPR:
3473 return 3;
3474
3475 case TRUTH_OR_EXPR:
3476 case TRUTH_ORIF_EXPR:
3477 return 4;
3478
3479 case TRUTH_AND_EXPR:
3480 case TRUTH_ANDIF_EXPR:
3481 return 5;
3482
3483 case BIT_IOR_EXPR:
3484 return 6;
3485
3486 case BIT_XOR_EXPR:
3487 case TRUTH_XOR_EXPR:
3488 return 7;
3489
3490 case BIT_AND_EXPR:
3491 return 8;
3492
3493 case EQ_EXPR:
3494 case NE_EXPR:
3495 return 9;
3496
3497 case UNLT_EXPR:
3498 case UNLE_EXPR:
3499 case UNGT_EXPR:
3500 case UNGE_EXPR:
3501 case UNEQ_EXPR:
3502 case LTGT_EXPR:
3503 case ORDERED_EXPR:
3504 case UNORDERED_EXPR:
3505 case LT_EXPR:
3506 case LE_EXPR:
3507 case GT_EXPR:
3508 case GE_EXPR:
3509 return 10;
3510
3511 case LSHIFT_EXPR:
3512 case RSHIFT_EXPR:
3513 case LROTATE_EXPR:
3514 case RROTATE_EXPR:
3515 case VEC_WIDEN_LSHIFT_HI_EXPR:
3516 case VEC_WIDEN_LSHIFT_LO_EXPR:
3517 case WIDEN_LSHIFT_EXPR:
3518 return 11;
3519
3520 case WIDEN_SUM_EXPR:
3521 case PLUS_EXPR:
3522 case POINTER_PLUS_EXPR:
3523 case POINTER_DIFF_EXPR:
3524 case MINUS_EXPR:
3525 return 12;
3526
3527 case VEC_WIDEN_MULT_HI_EXPR:
3528 case VEC_WIDEN_MULT_LO_EXPR:
3529 case WIDEN_MULT_EXPR:
3530 case DOT_PROD_EXPR:
3531 case WIDEN_MULT_PLUS_EXPR:
3532 case WIDEN_MULT_MINUS_EXPR:
3533 case MULT_EXPR:
3534 case MULT_HIGHPART_EXPR:
3535 case TRUNC_DIV_EXPR:
3536 case CEIL_DIV_EXPR:
3537 case FLOOR_DIV_EXPR:
3538 case ROUND_DIV_EXPR:
3539 case RDIV_EXPR:
3540 case EXACT_DIV_EXPR:
3541 case TRUNC_MOD_EXPR:
3542 case CEIL_MOD_EXPR:
3543 case FLOOR_MOD_EXPR:
3544 case ROUND_MOD_EXPR:
3545 return 13;
3546
3547 case TRUTH_NOT_EXPR:
3548 case BIT_NOT_EXPR:
3549 case POSTINCREMENT_EXPR:
3550 case POSTDECREMENT_EXPR:
3551 case PREINCREMENT_EXPR:
3552 case PREDECREMENT_EXPR:
3553 case NEGATE_EXPR:
3554 case INDIRECT_REF:
3555 case ADDR_EXPR:
3556 case FLOAT_EXPR:
3557 CASE_CONVERT:
3558 case FIX_TRUNC_EXPR:
3559 case TARGET_EXPR:
3560 return 14;
3561
3562 case CALL_EXPR:
3563 case ARRAY_REF:
3564 case ARRAY_RANGE_REF:
3565 case COMPONENT_REF:
3566 return 15;
3567
3568 /* Special expressions. */
3569 case MIN_EXPR:
3570 case MAX_EXPR:
3571 case ABS_EXPR:
3572 case REALPART_EXPR:
3573 case IMAGPART_EXPR:
3574 case VEC_UNPACK_HI_EXPR:
3575 case VEC_UNPACK_LO_EXPR:
3576 case VEC_UNPACK_FLOAT_HI_EXPR:
3577 case VEC_UNPACK_FLOAT_LO_EXPR:
3578 case VEC_PACK_TRUNC_EXPR:
3579 case VEC_PACK_SAT_EXPR:
3580 return 16;
3581
3582 default:
3583 /* Return an arbitrarily high precedence to avoid surrounding single
3584 VAR_DECLs in ()s. */
3585 return 9999;
3586 }
3587 }
3588
3589 /* Return the priority of the operator OP. */
3590
3591 int
3592 op_prio (const_tree op)
3593 {
3594 enum tree_code code;
3595
3596 if (op == NULL)
3597 return 9999;
3598
3599 code = TREE_CODE (op);
3600 if (code == SAVE_EXPR || code == NON_LVALUE_EXPR)
3601 return op_prio (TREE_OPERAND (op, 0));
3602
3603 return op_code_prio (code);
3604 }
3605
3606 /* Return the symbol associated with operator CODE. */
3607
3608 const char *
3609 op_symbol_code (enum tree_code code)
3610 {
3611 switch (code)
3612 {
3613 case MODIFY_EXPR:
3614 return "=";
3615
3616 case TRUTH_OR_EXPR:
3617 case TRUTH_ORIF_EXPR:
3618 return "||";
3619
3620 case TRUTH_AND_EXPR:
3621 case TRUTH_ANDIF_EXPR:
3622 return "&&";
3623
3624 case BIT_IOR_EXPR:
3625 return "|";
3626
3627 case TRUTH_XOR_EXPR:
3628 case BIT_XOR_EXPR:
3629 return "^";
3630
3631 case ADDR_EXPR:
3632 case BIT_AND_EXPR:
3633 return "&";
3634
3635 case ORDERED_EXPR:
3636 return "ord";
3637 case UNORDERED_EXPR:
3638 return "unord";
3639
3640 case EQ_EXPR:
3641 return "==";
3642 case UNEQ_EXPR:
3643 return "u==";
3644
3645 case NE_EXPR:
3646 return "!=";
3647
3648 case LT_EXPR:
3649 return "<";
3650 case UNLT_EXPR:
3651 return "u<";
3652
3653 case LE_EXPR:
3654 return "<=";
3655 case UNLE_EXPR:
3656 return "u<=";
3657
3658 case GT_EXPR:
3659 return ">";
3660 case UNGT_EXPR:
3661 return "u>";
3662
3663 case GE_EXPR:
3664 return ">=";
3665 case UNGE_EXPR:
3666 return "u>=";
3667
3668 case LTGT_EXPR:
3669 return "<>";
3670
3671 case LSHIFT_EXPR:
3672 return "<<";
3673
3674 case RSHIFT_EXPR:
3675 return ">>";
3676
3677 case LROTATE_EXPR:
3678 return "r<<";
3679
3680 case RROTATE_EXPR:
3681 return "r>>";
3682
3683 case WIDEN_LSHIFT_EXPR:
3684 return "w<<";
3685
3686 case POINTER_PLUS_EXPR:
3687 return "+";
3688
3689 case PLUS_EXPR:
3690 return "+";
3691
3692 case WIDEN_SUM_EXPR:
3693 return "w+";
3694
3695 case WIDEN_MULT_EXPR:
3696 return "w*";
3697
3698 case MULT_HIGHPART_EXPR:
3699 return "h*";
3700
3701 case NEGATE_EXPR:
3702 case MINUS_EXPR:
3703 case POINTER_DIFF_EXPR:
3704 return "-";
3705
3706 case BIT_NOT_EXPR:
3707 return "~";
3708
3709 case TRUTH_NOT_EXPR:
3710 return "!";
3711
3712 case MULT_EXPR:
3713 case INDIRECT_REF:
3714 return "*";
3715
3716 case TRUNC_DIV_EXPR:
3717 case RDIV_EXPR:
3718 return "/";
3719
3720 case CEIL_DIV_EXPR:
3721 return "/[cl]";
3722
3723 case FLOOR_DIV_EXPR:
3724 return "/[fl]";
3725
3726 case ROUND_DIV_EXPR:
3727 return "/[rd]";
3728
3729 case EXACT_DIV_EXPR:
3730 return "/[ex]";
3731
3732 case TRUNC_MOD_EXPR:
3733 return "%";
3734
3735 case CEIL_MOD_EXPR:
3736 return "%[cl]";
3737
3738 case FLOOR_MOD_EXPR:
3739 return "%[fl]";
3740
3741 case ROUND_MOD_EXPR:
3742 return "%[rd]";
3743
3744 case PREDECREMENT_EXPR:
3745 return " --";
3746
3747 case PREINCREMENT_EXPR:
3748 return " ++";
3749
3750 case POSTDECREMENT_EXPR:
3751 return "-- ";
3752
3753 case POSTINCREMENT_EXPR:
3754 return "++ ";
3755
3756 case MAX_EXPR:
3757 return "max";
3758
3759 case MIN_EXPR:
3760 return "min";
3761
3762 default:
3763 return "<<< ??? >>>";
3764 }
3765 }
3766
3767 /* Return the symbol associated with operator OP. */
3768
3769 static const char *
3770 op_symbol (const_tree op)
3771 {
3772 return op_symbol_code (TREE_CODE (op));
3773 }
3774
3775 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
3776 the gimple_call_fn of a GIMPLE_CALL. */
3777
3778 void
3779 print_call_name (pretty_printer *pp, tree node, dump_flags_t flags)
3780 {
3781 tree op0 = node;
3782
3783 if (TREE_CODE (op0) == NON_LVALUE_EXPR)
3784 op0 = TREE_OPERAND (op0, 0);
3785
3786 again:
3787 switch (TREE_CODE (op0))
3788 {
3789 case VAR_DECL:
3790 case PARM_DECL:
3791 case FUNCTION_DECL:
3792 dump_function_name (pp, op0, flags);
3793 break;
3794
3795 case ADDR_EXPR:
3796 case INDIRECT_REF:
3797 CASE_CONVERT:
3798 op0 = TREE_OPERAND (op0, 0);
3799 goto again;
3800
3801 case COND_EXPR:
3802 pp_left_paren (pp);
3803 dump_generic_node (pp, TREE_OPERAND (op0, 0), 0, flags, false);
3804 pp_string (pp, ") ? ");
3805 dump_generic_node (pp, TREE_OPERAND (op0, 1), 0, flags, false);
3806 pp_string (pp, " : ");
3807 dump_generic_node (pp, TREE_OPERAND (op0, 2), 0, flags, false);
3808 break;
3809
3810 case ARRAY_REF:
3811 if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
3812 dump_function_name (pp, TREE_OPERAND (op0, 0), flags);
3813 else
3814 dump_generic_node (pp, op0, 0, flags, false);
3815 break;
3816
3817 case MEM_REF:
3818 if (integer_zerop (TREE_OPERAND (op0, 1)))
3819 {
3820 op0 = TREE_OPERAND (op0, 0);
3821 goto again;
3822 }
3823 /* Fallthru. */
3824 case COMPONENT_REF:
3825 case SSA_NAME:
3826 case OBJ_TYPE_REF:
3827 dump_generic_node (pp, op0, 0, flags, false);
3828 break;
3829
3830 default:
3831 NIY;
3832 }
3833 }
3834
3835 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
3836
3837 static void
3838 pretty_print_string (pretty_printer *pp, const char *str)
3839 {
3840 if (str == NULL)
3841 return;
3842
3843 while (*str)
3844 {
3845 switch (str[0])
3846 {
3847 case '\b':
3848 pp_string (pp, "\\b");
3849 break;
3850
3851 case '\f':
3852 pp_string (pp, "\\f");
3853 break;
3854
3855 case '\n':
3856 pp_string (pp, "\\n");
3857 break;
3858
3859 case '\r':
3860 pp_string (pp, "\\r");
3861 break;
3862
3863 case '\t':
3864 pp_string (pp, "\\t");
3865 break;
3866
3867 case '\v':
3868 pp_string (pp, "\\v");
3869 break;
3870
3871 case '\\':
3872 pp_string (pp, "\\\\");
3873 break;
3874
3875 case '\"':
3876 pp_string (pp, "\\\"");
3877 break;
3878
3879 case '\'':
3880 pp_string (pp, "\\'");
3881 break;
3882
3883 /* No need to handle \0; the loop terminates on \0. */
3884
3885 case '\1':
3886 pp_string (pp, "\\1");
3887 break;
3888
3889 case '\2':
3890 pp_string (pp, "\\2");
3891 break;
3892
3893 case '\3':
3894 pp_string (pp, "\\3");
3895 break;
3896
3897 case '\4':
3898 pp_string (pp, "\\4");
3899 break;
3900
3901 case '\5':
3902 pp_string (pp, "\\5");
3903 break;
3904
3905 case '\6':
3906 pp_string (pp, "\\6");
3907 break;
3908
3909 case '\7':
3910 pp_string (pp, "\\7");
3911 break;
3912
3913 default:
3914 if (!ISPRINT (str[0]))
3915 {
3916 char buf[5];
3917 sprintf (buf, "\\x%x", (unsigned char)str[0]);
3918 pp_string (pp, buf);
3919 }
3920 else
3921 pp_character (pp, str[0]);
3922 break;
3923 }
3924 str++;
3925 }
3926 }
3927
3928 static void
3929 maybe_init_pretty_print (FILE *file)
3930 {
3931 if (!tree_pp)
3932 {
3933 tree_pp = new pretty_printer ();
3934 pp_needs_newline (tree_pp) = true;
3935 pp_translate_identifiers (tree_pp) = false;
3936 }
3937
3938 tree_pp->buffer->stream = file;
3939 }
3940
3941 static void
3942 newline_and_indent (pretty_printer *pp, int spc)
3943 {
3944 pp_newline (pp);
3945 INDENT (spc);
3946 }
3947
3948 /* Handle the %K format for TEXT. Separate from default_tree_printer
3949 so it can also be used in front ends.
3950 Argument is a statement from which EXPR_LOCATION and TREE_BLOCK will
3951 be recorded. */
3952
3953 void
3954 percent_K_format (text_info *text, tree t)
3955 {
3956 text->set_location (0, EXPR_LOCATION (t), true);
3957 gcc_assert (pp_ti_abstract_origin (text) != NULL);
3958 tree block = TREE_BLOCK (t);
3959 *pp_ti_abstract_origin (text) = NULL;
3960
3961 if (in_lto_p)
3962 {
3963 /* ??? LTO drops all BLOCK_ABSTRACT_ORIGINs apart from those
3964 representing the outermost block of an inlined function.
3965 So walk the BLOCK tree until we hit such a scope. */
3966 while (block
3967 && TREE_CODE (block) == BLOCK)
3968 {
3969 if (inlined_function_outer_scope_p (block))
3970 {
3971 *pp_ti_abstract_origin (text) = block;
3972 break;
3973 }
3974 block = BLOCK_SUPERCONTEXT (block);
3975 }
3976 return;
3977 }
3978
3979 while (block
3980 && TREE_CODE (block) == BLOCK
3981 && BLOCK_ABSTRACT_ORIGIN (block))
3982 {
3983 tree ao = BLOCK_ABSTRACT_ORIGIN (block);
3984
3985 while (TREE_CODE (ao) == BLOCK
3986 && BLOCK_ABSTRACT_ORIGIN (ao)
3987 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
3988 ao = BLOCK_ABSTRACT_ORIGIN (ao);
3989
3990 if (TREE_CODE (ao) == FUNCTION_DECL)
3991 {
3992 *pp_ti_abstract_origin (text) = block;
3993 break;
3994 }
3995 block = BLOCK_SUPERCONTEXT (block);
3996 }
3997 }
3998
3999 /* Print the identifier ID to PRETTY-PRINTER. */
4000
4001 void
4002 pp_tree_identifier (pretty_printer *pp, tree id)
4003 {
4004 if (pp_translate_identifiers (pp))
4005 {
4006 const char *text = identifier_to_locale (IDENTIFIER_POINTER (id));
4007 pp_append_text (pp, text, text + strlen (text));
4008 }
4009 else
4010 pp_append_text (pp, IDENTIFIER_POINTER (id),
4011 IDENTIFIER_POINTER (id) + IDENTIFIER_LENGTH (id));
4012 }
4013
4014 /* A helper function that is used to dump function information before the
4015 function dump. */
4016
4017 void
4018 dump_function_header (FILE *dump_file, tree fdecl, dump_flags_t flags)
4019 {
4020 const char *dname, *aname;
4021 struct cgraph_node *node = cgraph_node::get (fdecl);
4022 struct function *fun = DECL_STRUCT_FUNCTION (fdecl);
4023
4024 dname = lang_hooks.decl_printable_name (fdecl, 1);
4025
4026 if (DECL_ASSEMBLER_NAME_SET_P (fdecl))
4027 aname = (IDENTIFIER_POINTER
4028 (DECL_ASSEMBLER_NAME (fdecl)));
4029 else
4030 aname = "<unset-asm-name>";
4031
4032 fprintf (dump_file, "\n;; Function %s (%s, funcdef_no=%d",
4033 dname, aname, fun->funcdef_no);
4034 if (!(flags & TDF_NOUID))
4035 fprintf (dump_file, ", decl_uid=%d", DECL_UID (fdecl));
4036 if (node)
4037 {
4038 fprintf (dump_file, ", cgraph_uid=%d", node->uid);
4039 fprintf (dump_file, ", symbol_order=%d)%s\n\n", node->order,
4040 node->frequency == NODE_FREQUENCY_HOT
4041 ? " (hot)"
4042 : node->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED
4043 ? " (unlikely executed)"
4044 : node->frequency == NODE_FREQUENCY_EXECUTED_ONCE
4045 ? " (executed once)"
4046 : "");
4047 }
4048 else
4049 fprintf (dump_file, ")\n\n");
4050 }
4051
4052 /* Dump double_int D to pretty_printer PP. UNS is true
4053 if D is unsigned and false otherwise. */
4054 void
4055 pp_double_int (pretty_printer *pp, double_int d, bool uns)
4056 {
4057 if (d.fits_shwi ())
4058 pp_wide_integer (pp, d.low);
4059 else if (d.fits_uhwi ())
4060 pp_unsigned_wide_integer (pp, d.low);
4061 else
4062 {
4063 unsigned HOST_WIDE_INT low = d.low;
4064 HOST_WIDE_INT high = d.high;
4065 if (!uns && d.is_negative ())
4066 {
4067 pp_minus (pp);
4068 high = ~high + !low;
4069 low = -low;
4070 }
4071 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
4072 systems? */
4073 sprintf (pp_buffer (pp)->digit_buffer,
4074 HOST_WIDE_INT_PRINT_DOUBLE_HEX,
4075 (unsigned HOST_WIDE_INT) high, low);
4076 pp_string (pp, pp_buffer (pp)->digit_buffer);
4077 }
4078 }
Mirror of the offical gcc git repository hosted at gcc.gnu.org