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