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