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