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