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