?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
poly_int: two-operation SLP
[official-gcc.git] / gcc / tree-pretty-print.c
blobae0107e78e3b7cdd9cbfdab2da96e32cfffccc30
1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001-2017 Free Software Foundation, Inc.
3 Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
20
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "backend.h"
25 #include "rtl.h"
26 #include "tree.h"
27 #include "predict.h"
28 #include "cgraph.h"
29 #include "tree-pretty-print.h"
30 #include "stor-layout.h"
31 #include "langhooks.h"
32 #include "tree-iterator.h"
33 #include "dumpfile.h"
34 #include "internal-fn.h"
35 #include "gomp-constants.h"
36 #include "gimple.h"
37
38 /* Local functions, macros and variables. */
39 static const char *op_symbol (const_tree);
40 static void pretty_print_string (pretty_printer *, const char*);
41 static void newline_and_indent (pretty_printer *, int);
42 static void maybe_init_pretty_print (FILE *);
43 static void print_struct_decl (pretty_printer *, const_tree, int, dump_flags_t);
44 static void do_niy (pretty_printer *, const_tree, dump_flags_t);
45
46 #define INDENT(SPACE) do { \
47 int i; for (i = 0; i<SPACE; i++) pp_space (pp); } while (0)
48
49 #define NIY do_niy (pp, node, flags)
50
51 static pretty_printer *tree_pp;
52
53 /* Try to print something for an unknown tree code. */
54
55 static void
56 do_niy (pretty_printer *pp, const_tree node, dump_flags_t flags)
57 {
58 int i, len;
59
60 pp_string (pp, "<<< Unknown tree: ");
61 pp_string (pp, get_tree_code_name (TREE_CODE (node)));
62
63 if (EXPR_P (node))
64 {
65 len = TREE_OPERAND_LENGTH (node);
66 for (i = 0; i < len; ++i)
67 {
68 newline_and_indent (pp, 2);
69 dump_generic_node (pp, TREE_OPERAND (node, i), 2, flags, false);
70 }
71 }
72
73 pp_string (pp, " >>>");
74 }
75
76 /* Debugging function to print out a generic expression. */
77
78 DEBUG_FUNCTION void
79 debug_generic_expr (tree t)
80 {
81 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS);
82 fprintf (stderr, "\n");
83 }
84
85 /* Debugging function to print out a generic statement. */
86
87 DEBUG_FUNCTION void
88 debug_generic_stmt (tree t)
89 {
90 print_generic_stmt (stderr, t, TDF_VOPS|TDF_MEMSYMS);
91 fprintf (stderr, "\n");
92 }
93
94 /* Debugging function to print out a chain of trees . */
95
96 DEBUG_FUNCTION void
97 debug_tree_chain (tree t)
98 {
99 hash_set<tree> seen;
100
101 while (t)
102 {
103 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);
104 fprintf (stderr, " ");
105 t = TREE_CHAIN (t);
106 if (seen.add (t))
107 {
108 fprintf (stderr, "... [cycled back to ");
109 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);
110 fprintf (stderr, "]");
111 break;
112 }
113 }
114 fprintf (stderr, "\n");
115 }
116
117 /* Prints declaration DECL to the FILE with details specified by FLAGS. */
118 void
119 print_generic_decl (FILE *file, tree decl, dump_flags_t flags)
120 {
121 maybe_init_pretty_print (file);
122 print_declaration (tree_pp, decl, 2, flags);
123 pp_write_text_to_stream (tree_pp);
124 }
125
126 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
127 to show in the dump. See TDF_* in dumpfile.h. */
128
129 void
130 print_generic_stmt (FILE *file, tree t, dump_flags_t flags)
131 {
132 maybe_init_pretty_print (file);
133 dump_generic_node (tree_pp, t, 0, flags, true);
134 pp_newline_and_flush (tree_pp);
135 }
136
137 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
138 to show in the dump. See TDF_* in dumpfile.h. The output is indented by
139 INDENT spaces. */
140
141 void
142 print_generic_stmt_indented (FILE *file, tree t, dump_flags_t flags, int indent)
143 {
144 int i;
145
146 maybe_init_pretty_print (file);
147
148 for (i = 0; i < indent; i++)
149 pp_space (tree_pp);
150 dump_generic_node (tree_pp, t, indent, flags, true);
151 pp_newline_and_flush (tree_pp);
152 }
153
154 /* Print a single expression T on file FILE. FLAGS specifies details to show
155 in the dump. See TDF_* in dumpfile.h. */
156
157 void
158 print_generic_expr (FILE *file, tree t, dump_flags_t flags)
159 {
160 maybe_init_pretty_print (file);
161 dump_generic_node (tree_pp, t, 0, flags, false);
162 pp_flush (tree_pp);
163 }
164
165 /* Dump NAME, an IDENTIFIER_POINTER, sanitized so that D<num> sequences
166 in it are replaced with Dxxxx, as long as they are at the start or
167 preceded by $ and at the end or followed by $. See make_fancy_name
168 in tree-sra.c. */
169
170 static void
171 dump_fancy_name (pretty_printer *pp, tree name)
172 {
173 int cnt = 0;
174 int length = IDENTIFIER_LENGTH (name);
175 const char *n = IDENTIFIER_POINTER (name);
176 do
177 {
178 n = strchr (n, 'D');
179 if (n == NULL)
180 break;
181 if (ISDIGIT (n[1])
182 && (n == IDENTIFIER_POINTER (name) || n[-1] == '$'))
183 {
184 int l = 2;
185 while (ISDIGIT (n[l]))
186 l++;
187 if (n[l] == '\0' || n[l] == '$')
188 {
189 cnt++;
190 length += 5 - l;
191 }
192 n += l;
193 }
194 else
195 n++;
196 }
197 while (1);
198 if (cnt == 0)
199 {
200 pp_tree_identifier (pp, name);
201 return;
202 }
203
204 char *str = XNEWVEC (char, length + 1);
205 char *p = str;
206 const char *q;
207 q = n = IDENTIFIER_POINTER (name);
208 do
209 {
210 q = strchr (q, 'D');
211 if (q == NULL)
212 break;
213 if (ISDIGIT (q[1])
214 && (q == IDENTIFIER_POINTER (name) || q[-1] == '$'))
215 {
216 int l = 2;
217 while (ISDIGIT (q[l]))
218 l++;
219 if (q[l] == '\0' || q[l] == '$')
220 {
221 memcpy (p, n, q - n);
222 memcpy (p + (q - n), "Dxxxx", 5);
223 p += (q - n) + 5;
224 n = q + l;
225 }
226 q += l;
227 }
228 else
229 q++;
230 }
231 while (1);
232 memcpy (p, n, IDENTIFIER_LENGTH (name) - (n - IDENTIFIER_POINTER (name)));
233 str[length] = '\0';
234 if (pp_translate_identifiers (pp))
235 {
236 const char *text = identifier_to_locale (str);
237 pp_append_text (pp, text, text + strlen (text));
238 }
239 else
240 pp_append_text (pp, str, str + length);
241 XDELETEVEC (str);
242 }
243
244 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
245 in FLAGS. */
246
247 static void
248 dump_decl_name (pretty_printer *pp, tree node, dump_flags_t flags)
249 {
250 if (DECL_NAME (node))
251 {
252 if ((flags & TDF_ASMNAME)
253 && HAS_DECL_ASSEMBLER_NAME_P (node)
254 && DECL_ASSEMBLER_NAME_SET_P (node))
255 pp_tree_identifier (pp, DECL_ASSEMBLER_NAME_RAW (node));
256 /* For DECL_NAMELESS names look for embedded uids in the
257 names and sanitize them for TDF_NOUID. */
258 else if ((flags & TDF_NOUID) && DECL_NAMELESS (node))
259 dump_fancy_name (pp, DECL_NAME (node));
260 else
261 pp_tree_identifier (pp, DECL_NAME (node));
262 }
263 char uid_sep = (flags & TDF_GIMPLE) ? '_' : '.';
264 if ((flags & TDF_UID) || DECL_NAME (node) == NULL_TREE)
265 {
266 if (TREE_CODE (node) == LABEL_DECL && LABEL_DECL_UID (node) != -1)
267 pp_printf (pp, "L%c%d", uid_sep, (int) LABEL_DECL_UID (node));
268 else if (TREE_CODE (node) == DEBUG_EXPR_DECL)
269 {
270 if (flags & TDF_NOUID)
271 pp_string (pp, "D#xxxx");
272 else
273 pp_printf (pp, "D#%i", DEBUG_TEMP_UID (node));
274 }
275 else
276 {
277 char c = TREE_CODE (node) == CONST_DECL ? 'C' : 'D';
278 if (flags & TDF_NOUID)
279 pp_printf (pp, "%c.xxxx", c);
280 else
281 pp_printf (pp, "%c%c%u", c, uid_sep, DECL_UID (node));
282 }
283 }
284 if ((flags & TDF_ALIAS) && DECL_PT_UID (node) != DECL_UID (node))
285 {
286 if (flags & TDF_NOUID)
287 pp_printf (pp, "ptD.xxxx");
288 else
289 pp_printf (pp, "ptD.%u", DECL_PT_UID (node));
290 }
291 }
292
293 /* Like the above, but used for pretty printing function calls. */
294
295 static void
296 dump_function_name (pretty_printer *pp, tree node, dump_flags_t flags)
297 {
298 if (CONVERT_EXPR_P (node))
299 node = TREE_OPERAND (node, 0);
300 if (DECL_NAME (node) && (flags & TDF_ASMNAME) == 0)
301 pp_string (pp, lang_hooks.decl_printable_name (node, 1));
302 else
303 dump_decl_name (pp, node, flags);
304 }
305
306 /* Dump a function declaration. NODE is the FUNCTION_TYPE. PP, SPC and
307 FLAGS are as in dump_generic_node. */
308
309 static void
310 dump_function_declaration (pretty_printer *pp, tree node,
311 int spc, dump_flags_t flags)
312 {
313 bool wrote_arg = false;
314 tree arg;
315
316 pp_space (pp);
317 pp_left_paren (pp);
318
319 /* Print the argument types. */
320 arg = TYPE_ARG_TYPES (node);
321 while (arg && arg != void_list_node && arg != error_mark_node)
322 {
323 if (wrote_arg)
324 {
325 pp_comma (pp);
326 pp_space (pp);
327 }
328 wrote_arg = true;
329 dump_generic_node (pp, TREE_VALUE (arg), spc, flags, false);
330 arg = TREE_CHAIN (arg);
331 }
332
333 /* Drop the trailing void_type_node if we had any previous argument. */
334 if (arg == void_list_node && !wrote_arg)
335 pp_string (pp, "void");
336 /* Properly dump vararg function types. */
337 else if (!arg && wrote_arg)
338 pp_string (pp, ", ...");
339 /* Avoid printing any arg for unprototyped functions. */
340
341 pp_right_paren (pp);
342 }
343
344 /* Dump the domain associated with an array. */
345
346 static void
347 dump_array_domain (pretty_printer *pp, tree domain, int spc, dump_flags_t flags)
348 {
349 pp_left_bracket (pp);
350 if (domain)
351 {
352 tree min = TYPE_MIN_VALUE (domain);
353 tree max = TYPE_MAX_VALUE (domain);
354
355 if (min && max
356 && integer_zerop (min)
357 && tree_fits_shwi_p (max))
358 pp_wide_integer (pp, tree_to_shwi (max) + 1);
359 else
360 {
361 if (min)
362 dump_generic_node (pp, min, spc, flags, false);
363 pp_colon (pp);
364 if (max)
365 dump_generic_node (pp, max, spc, flags, false);
366 }
367 }
368 else
369 pp_string (pp, "<unknown>");
370 pp_right_bracket (pp);
371 }
372
373
374 /* Dump OpenMP clause CLAUSE. PP, CLAUSE, SPC and FLAGS are as in
375 dump_generic_node. */
376
377 static void
378 dump_omp_clause (pretty_printer *pp, tree clause, int spc, dump_flags_t flags)
379 {
380 const char *name;
381
382 switch (OMP_CLAUSE_CODE (clause))
383 {
384 case OMP_CLAUSE_PRIVATE:
385 name = "private";
386 goto print_remap;
387 case OMP_CLAUSE_SHARED:
388 name = "shared";
389 goto print_remap;
390 case OMP_CLAUSE_FIRSTPRIVATE:
391 name = "firstprivate";
392 goto print_remap;
393 case OMP_CLAUSE_LASTPRIVATE:
394 name = "lastprivate";
395 goto print_remap;
396 case OMP_CLAUSE_COPYIN:
397 name = "copyin";
398 goto print_remap;
399 case OMP_CLAUSE_COPYPRIVATE:
400 name = "copyprivate";
401 goto print_remap;
402 case OMP_CLAUSE_UNIFORM:
403 name = "uniform";
404 goto print_remap;
405 case OMP_CLAUSE_USE_DEVICE_PTR:
406 name = "use_device_ptr";
407 goto print_remap;
408 case OMP_CLAUSE_IS_DEVICE_PTR:
409 name = "is_device_ptr";
410 goto print_remap;
411 case OMP_CLAUSE__LOOPTEMP_:
412 name = "_looptemp_";
413 goto print_remap;
414 case OMP_CLAUSE_TO_DECLARE:
415 name = "to";
416 goto print_remap;
417 case OMP_CLAUSE_LINK:
418 name = "link";
419 goto print_remap;
420 print_remap:
421 pp_string (pp, name);
422 pp_left_paren (pp);
423 dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
424 spc, flags, false);
425 pp_right_paren (pp);
426 break;
427
428 case OMP_CLAUSE_REDUCTION:
429 pp_string (pp, "reduction(");
430 if (OMP_CLAUSE_REDUCTION_CODE (clause) != ERROR_MARK)
431 {
432 pp_string (pp,
433 op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause)));
434 pp_colon (pp);
435 }
436 dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
437 spc, flags, false);
438 pp_right_paren (pp);
439 break;
440
441 case OMP_CLAUSE_IF:
442 pp_string (pp, "if(");
443 switch (OMP_CLAUSE_IF_MODIFIER (clause))
444 {
445 case ERROR_MARK: break;
446 case OMP_PARALLEL: pp_string (pp, "parallel:"); break;
447 case OMP_TASK: pp_string (pp, "task:"); break;
448 case OMP_TASKLOOP: pp_string (pp, "taskloop:"); break;
449 case OMP_TARGET_DATA: pp_string (pp, "target data:"); break;
450 case OMP_TARGET: pp_string (pp, "target:"); break;
451 case OMP_TARGET_UPDATE: pp_string (pp, "target update:"); break;
452 case OMP_TARGET_ENTER_DATA:
453 pp_string (pp, "target enter data:"); break;
454 case OMP_TARGET_EXIT_DATA: pp_string (pp, "target exit data:"); break;
455 default: gcc_unreachable ();
456 }
457 dump_generic_node (pp, OMP_CLAUSE_IF_EXPR (clause),
458 spc, flags, false);
459 pp_right_paren (pp);
460 break;
461
462 case OMP_CLAUSE_NUM_THREADS:
463 pp_string (pp, "num_threads(");
464 dump_generic_node (pp, OMP_CLAUSE_NUM_THREADS_EXPR (clause),
465 spc, flags, false);
466 pp_right_paren (pp);
467 break;
468
469 case OMP_CLAUSE_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_NAME (node) && DECL_NAME (TYPE_NAME (node)))
1416 dump_decl_name (pp, TYPE_NAME (node), flags);
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 for (i = 0; i < VECTOR_CST_NELTS (node); ++i)
1797 {
1798 if (i != 0)
1799 pp_string (pp, ", ");
1800 dump_generic_node (pp, VECTOR_CST_ELT (node, i),
1801 spc, flags, false);
1802 }
1803 pp_string (pp, " }");
1804 }
1805 break;
1806
1807 case FUNCTION_TYPE:
1808 case METHOD_TYPE:
1809 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
1810 pp_space (pp);
1811 if (TREE_CODE (node) == METHOD_TYPE)
1812 {
1813 if (TYPE_METHOD_BASETYPE (node))
1814 dump_decl_name (pp, TYPE_NAME (TYPE_METHOD_BASETYPE (node)),
1815 flags);
1816 else
1817 pp_string (pp, "<null method basetype>");
1818 pp_colon_colon (pp);
1819 }
1820 if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
1821 dump_decl_name (pp, TYPE_NAME (node), flags);
1822 else if (flags & TDF_NOUID)
1823 pp_printf (pp, "<Txxxx>");
1824 else
1825 pp_printf (pp, "<T%x>", TYPE_UID (node));
1826 dump_function_declaration (pp, node, spc, flags);
1827 break;
1828
1829 case FUNCTION_DECL:
1830 case CONST_DECL:
1831 dump_decl_name (pp, node, flags);
1832 break;
1833
1834 case LABEL_DECL:
1835 if (DECL_NAME (node))
1836 dump_decl_name (pp, node, flags);
1837 else if (LABEL_DECL_UID (node) != -1)
1838 {
1839 if (flags & TDF_GIMPLE)
1840 pp_printf (pp, "L%d", (int) LABEL_DECL_UID (node));
1841 else
1842 pp_printf (pp, "<L%d>", (int) LABEL_DECL_UID (node));
1843 }
1844 else
1845 {
1846 if (flags & TDF_NOUID)
1847 pp_string (pp, "<D.xxxx>");
1848 else
1849 {
1850 if (flags & TDF_GIMPLE)
1851 pp_printf (pp, "<D%u>", DECL_UID (node));
1852 else
1853 pp_printf (pp, "<D.%u>", DECL_UID (node));
1854 }
1855 }
1856 break;
1857
1858 case TYPE_DECL:
1859 if (DECL_IS_BUILTIN (node))
1860 {
1861 /* Don't print the declaration of built-in types. */
1862 break;
1863 }
1864 if (DECL_NAME (node))
1865 dump_decl_name (pp, node, flags);
1866 else if (TYPE_NAME (TREE_TYPE (node)) != node)
1867 {
1868 pp_string (pp, (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE
1869 ? "union" : "struct "));
1870 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
1871 }
1872 else
1873 pp_string (pp, "<anon>");
1874 break;
1875
1876 case VAR_DECL:
1877 case PARM_DECL:
1878 case FIELD_DECL:
1879 case DEBUG_EXPR_DECL:
1880 case NAMESPACE_DECL:
1881 case NAMELIST_DECL:
1882 dump_decl_name (pp, node, flags);
1883 break;
1884
1885 case RESULT_DECL:
1886 pp_string (pp, "<retval>");
1887 break;
1888
1889 case COMPONENT_REF:
1890 op0 = TREE_OPERAND (node, 0);
1891 str = ".";
1892 if (op0
1893 && (TREE_CODE (op0) == INDIRECT_REF
1894 || (TREE_CODE (op0) == MEM_REF
1895 && TREE_CODE (TREE_OPERAND (op0, 0)) != ADDR_EXPR
1896 && integer_zerop (TREE_OPERAND (op0, 1))
1897 /* Dump the types of INTEGER_CSTs explicitly, for we
1898 can't infer them and MEM_ATTR caching will share
1899 MEM_REFs with differently-typed op0s. */
1900 && TREE_CODE (TREE_OPERAND (op0, 0)) != INTEGER_CST
1901 /* Released SSA_NAMES have no TREE_TYPE. */
1902 && TREE_TYPE (TREE_OPERAND (op0, 0)) != NULL_TREE
1903 /* Same pointer types, but ignoring POINTER_TYPE vs.
1904 REFERENCE_TYPE. */
1905 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 0)))
1906 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1))))
1907 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 0)))
1908 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 1))))
1909 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 0)))
1910 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 1))))
1911 /* Same value types ignoring qualifiers. */
1912 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0))
1913 == TYPE_MAIN_VARIANT
1914 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1)))))
1915 && MR_DEPENDENCE_CLIQUE (op0) == 0)))
1916 {
1917 op0 = TREE_OPERAND (op0, 0);
1918 str = "->";
1919 }
1920 if (op_prio (op0) < op_prio (node))
1921 pp_left_paren (pp);
1922 dump_generic_node (pp, op0, spc, flags, false);
1923 if (op_prio (op0) < op_prio (node))
1924 pp_right_paren (pp);
1925 pp_string (pp, str);
1926 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
1927 op0 = component_ref_field_offset (node);
1928 if (op0 && TREE_CODE (op0) != INTEGER_CST)
1929 {
1930 pp_string (pp, "{off: ");
1931 dump_generic_node (pp, op0, spc, flags, false);
1932 pp_right_brace (pp);
1933 }
1934 break;
1935
1936 case BIT_FIELD_REF:
1937 pp_string (pp, "BIT_FIELD_REF <");
1938 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
1939 pp_string (pp, ", ");
1940 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
1941 pp_string (pp, ", ");
1942 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
1943 pp_greater (pp);
1944 break;
1945
1946 case BIT_INSERT_EXPR:
1947 pp_string (pp, "BIT_INSERT_EXPR <");
1948 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
1949 pp_string (pp, ", ");
1950 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
1951 pp_string (pp, ", ");
1952 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
1953 pp_string (pp, " (");
1954 if (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (node, 1))))
1955 pp_decimal_int (pp,
1956 TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (node, 1))));
1957 else
1958 dump_generic_node (pp, TYPE_SIZE (TREE_TYPE (TREE_OPERAND (node, 1))),
1959 spc, flags, false);
1960 pp_string (pp, " bits)>");
1961 break;
1962
1963 case ARRAY_REF:
1964 case ARRAY_RANGE_REF:
1965 op0 = TREE_OPERAND (node, 0);
1966 if (op_prio (op0) < op_prio (node))
1967 pp_left_paren (pp);
1968 dump_generic_node (pp, op0, spc, flags, false);
1969 if (op_prio (op0) < op_prio (node))
1970 pp_right_paren (pp);
1971 pp_left_bracket (pp);
1972 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
1973 if (TREE_CODE (node) == ARRAY_RANGE_REF)
1974 pp_string (pp, " ...");
1975 pp_right_bracket (pp);
1976
1977 op0 = array_ref_low_bound (node);
1978 op1 = array_ref_element_size (node);
1979
1980 if (!integer_zerop (op0)
1981 || TREE_OPERAND (node, 2)
1982 || TREE_OPERAND (node, 3))
1983 {
1984 pp_string (pp, "{lb: ");
1985 dump_generic_node (pp, op0, spc, flags, false);
1986 pp_string (pp, " sz: ");
1987 dump_generic_node (pp, op1, spc, flags, false);
1988 pp_right_brace (pp);
1989 }
1990 break;
1991
1992 case CONSTRUCTOR:
1993 {
1994 unsigned HOST_WIDE_INT ix;
1995 tree field, val;
1996 bool is_struct_init = false;
1997 bool is_array_init = false;
1998 widest_int curidx;
1999 pp_left_brace (pp);
2000 if (TREE_CLOBBER_P (node))
2001 pp_string (pp, "CLOBBER");
2002 else if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
2003 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
2004 is_struct_init = true;
2005 else if (TREE_CODE (TREE_TYPE (node)) == ARRAY_TYPE
2006 && TYPE_DOMAIN (TREE_TYPE (node))
2007 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node)))
2008 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node))))
2009 == INTEGER_CST)
2010 {
2011 tree minv = TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node)));
2012 is_array_init = true;
2013 curidx = wi::to_widest (minv);
2014 }
2015 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)
2016 {
2017 if (field)
2018 {
2019 if (is_struct_init)
2020 {
2021 pp_dot (pp);
2022 dump_generic_node (pp, field, spc, flags, false);
2023 pp_equal (pp);
2024 }
2025 else if (is_array_init
2026 && (TREE_CODE (field) != INTEGER_CST
2027 || curidx != wi::to_widest (field)))
2028 {
2029 pp_left_bracket (pp);
2030 if (TREE_CODE (field) == RANGE_EXPR)
2031 {
2032 dump_generic_node (pp, TREE_OPERAND (field, 0), spc,
2033 flags, false);
2034 pp_string (pp, " ... ");
2035 dump_generic_node (pp, TREE_OPERAND (field, 1), spc,
2036 flags, false);
2037 if (TREE_CODE (TREE_OPERAND (field, 1)) == INTEGER_CST)
2038 curidx = wi::to_widest (TREE_OPERAND (field, 1));
2039 }
2040 else
2041 dump_generic_node (pp, field, spc, flags, false);
2042 if (TREE_CODE (field) == INTEGER_CST)
2043 curidx = wi::to_widest (field);
2044 pp_string (pp, "]=");
2045 }
2046 }
2047 if (is_array_init)
2048 curidx += 1;
2049 if (val && TREE_CODE (val) == ADDR_EXPR)
2050 if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
2051 val = TREE_OPERAND (val, 0);
2052 if (val && TREE_CODE (val) == FUNCTION_DECL)
2053 dump_decl_name (pp, val, flags);
2054 else
2055 dump_generic_node (pp, val, spc, flags, false);
2056 if (ix != CONSTRUCTOR_NELTS (node) - 1)
2057 {
2058 pp_comma (pp);
2059 pp_space (pp);
2060 }
2061 }
2062 pp_right_brace (pp);
2063 }
2064 break;
2065
2066 case COMPOUND_EXPR:
2067 {
2068 tree *tp;
2069 if (flags & TDF_SLIM)
2070 {
2071 pp_string (pp, "<COMPOUND_EXPR>");
2072 break;
2073 }
2074
2075 dump_generic_node (pp, TREE_OPERAND (node, 0),
2076 spc, flags, !(flags & TDF_SLIM));
2077 if (flags & TDF_SLIM)
2078 newline_and_indent (pp, spc);
2079 else
2080 {
2081 pp_comma (pp);
2082 pp_space (pp);
2083 }
2084
2085 for (tp = &TREE_OPERAND (node, 1);
2086 TREE_CODE (*tp) == COMPOUND_EXPR;
2087 tp = &TREE_OPERAND (*tp, 1))
2088 {
2089 dump_generic_node (pp, TREE_OPERAND (*tp, 0),
2090 spc, flags, !(flags & TDF_SLIM));
2091 if (flags & TDF_SLIM)
2092 newline_and_indent (pp, spc);
2093 else
2094 {
2095 pp_comma (pp);
2096 pp_space (pp);
2097 }
2098 }
2099
2100 dump_generic_node (pp, *tp, spc, flags, !(flags & TDF_SLIM));
2101 }
2102 break;
2103
2104 case STATEMENT_LIST:
2105 {
2106 tree_stmt_iterator si;
2107 bool first = true;
2108
2109 if (flags & TDF_SLIM)
2110 {
2111 pp_string (pp, "<STATEMENT_LIST>");
2112 break;
2113 }
2114
2115 for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))
2116 {
2117 if (!first)
2118 newline_and_indent (pp, spc);
2119 else
2120 first = false;
2121 dump_generic_node (pp, tsi_stmt (si), spc, flags, true);
2122 }
2123 }
2124 break;
2125
2126 case MODIFY_EXPR:
2127 case INIT_EXPR:
2128 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags,
2129 false);
2130 pp_space (pp);
2131 pp_equal (pp);
2132 pp_space (pp);
2133 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags,
2134 false);
2135 break;
2136
2137 case TARGET_EXPR:
2138 pp_string (pp, "TARGET_EXPR <");
2139 dump_generic_node (pp, TARGET_EXPR_SLOT (node), spc, flags, false);
2140 pp_comma (pp);
2141 pp_space (pp);
2142 dump_generic_node (pp, TARGET_EXPR_INITIAL (node), spc, flags, false);
2143 pp_greater (pp);
2144 break;
2145
2146 case DECL_EXPR:
2147 print_declaration (pp, DECL_EXPR_DECL (node), spc, flags);
2148 is_stmt = false;
2149 break;
2150
2151 case COND_EXPR:
2152 if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node)
2153 {
2154 pp_string (pp, "if (");
2155 dump_generic_node (pp, COND_EXPR_COND (node), spc, flags, false);
2156 pp_right_paren (pp);
2157 /* The lowered cond_exprs should always be printed in full. */
2158 if (COND_EXPR_THEN (node)
2159 && (IS_EMPTY_STMT (COND_EXPR_THEN (node))
2160 || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)
2161 && COND_EXPR_ELSE (node)
2162 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node))
2163 || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
2164 {
2165 pp_space (pp);
2166 dump_generic_node (pp, COND_EXPR_THEN (node),
2167 0, flags, true);
2168 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
2169 {
2170 pp_string (pp, " else ");
2171 dump_generic_node (pp, COND_EXPR_ELSE (node),
2172 0, flags, true);
2173 }
2174 }
2175 else if (!(flags & TDF_SLIM))
2176 {
2177 /* Output COND_EXPR_THEN. */
2178 if (COND_EXPR_THEN (node))
2179 {
2180 newline_and_indent (pp, spc+2);
2181 pp_left_brace (pp);
2182 newline_and_indent (pp, spc+4);
2183 dump_generic_node (pp, COND_EXPR_THEN (node), spc+4,
2184 flags, true);
2185 newline_and_indent (pp, spc+2);
2186 pp_right_brace (pp);
2187 }
2188
2189 /* Output COND_EXPR_ELSE. */
2190 if (COND_EXPR_ELSE (node)
2191 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
2192 {
2193 newline_and_indent (pp, spc);
2194 pp_string (pp, "else");
2195 newline_and_indent (pp, spc+2);
2196 pp_left_brace (pp);
2197 newline_and_indent (pp, spc+4);
2198 dump_generic_node (pp, COND_EXPR_ELSE (node), spc+4,
2199 flags, true);
2200 newline_and_indent (pp, spc+2);
2201 pp_right_brace (pp);
2202 }
2203 }
2204 is_expr = false;
2205 }
2206 else
2207 {
2208 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2209 pp_space (pp);
2210 pp_question (pp);
2211 pp_space (pp);
2212 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2213 pp_space (pp);
2214 pp_colon (pp);
2215 pp_space (pp);
2216 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2217 }
2218 break;
2219
2220 case BIND_EXPR:
2221 pp_left_brace (pp);
2222 if (!(flags & TDF_SLIM))
2223 {
2224 if (BIND_EXPR_VARS (node))
2225 {
2226 pp_newline (pp);
2227
2228 for (op0 = BIND_EXPR_VARS (node); op0; op0 = DECL_CHAIN (op0))
2229 {
2230 print_declaration (pp, op0, spc+2, flags);
2231 pp_newline (pp);
2232 }
2233 }
2234
2235 newline_and_indent (pp, spc+2);
2236 dump_generic_node (pp, BIND_EXPR_BODY (node), spc+2, flags, true);
2237 newline_and_indent (pp, spc);
2238 pp_right_brace (pp);
2239 }
2240 is_expr = false;
2241 break;
2242
2243 case CALL_EXPR:
2244 if (CALL_EXPR_FN (node) != NULL_TREE)
2245 print_call_name (pp, CALL_EXPR_FN (node), flags);
2246 else
2247 pp_string (pp, internal_fn_name (CALL_EXPR_IFN (node)));
2248
2249 /* Print parameters. */
2250 pp_space (pp);
2251 pp_left_paren (pp);
2252 {
2253 tree arg;
2254 call_expr_arg_iterator iter;
2255 FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
2256 {
2257 dump_generic_node (pp, arg, spc, flags, false);
2258 if (more_call_expr_args_p (&iter))
2259 {
2260 pp_comma (pp);
2261 pp_space (pp);
2262 }
2263 }
2264 }
2265 if (CALL_EXPR_VA_ARG_PACK (node))
2266 {
2267 if (call_expr_nargs (node) > 0)
2268 {
2269 pp_comma (pp);
2270 pp_space (pp);
2271 }
2272 pp_string (pp, "__builtin_va_arg_pack ()");
2273 }
2274 pp_right_paren (pp);
2275
2276 op1 = CALL_EXPR_STATIC_CHAIN (node);
2277 if (op1)
2278 {
2279 pp_string (pp, " [static-chain: ");
2280 dump_generic_node (pp, op1, spc, flags, false);
2281 pp_right_bracket (pp);
2282 }
2283
2284 if (CALL_EXPR_RETURN_SLOT_OPT (node))
2285 pp_string (pp, " [return slot optimization]");
2286 if (CALL_EXPR_TAILCALL (node))
2287 pp_string (pp, " [tail call]");
2288 break;
2289
2290 case WITH_CLEANUP_EXPR:
2291 NIY;
2292 break;
2293
2294 case CLEANUP_POINT_EXPR:
2295 pp_string (pp, "<<cleanup_point ");
2296 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2297 pp_string (pp, ">>");
2298 break;
2299
2300 case PLACEHOLDER_EXPR:
2301 pp_string (pp, "<PLACEHOLDER_EXPR ");
2302 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2303 pp_greater (pp);
2304 break;
2305
2306 /* Binary arithmetic and logic expressions. */
2307 case WIDEN_SUM_EXPR:
2308 case WIDEN_MULT_EXPR:
2309 case MULT_EXPR:
2310 case MULT_HIGHPART_EXPR:
2311 case PLUS_EXPR:
2312 case POINTER_PLUS_EXPR:
2313 case POINTER_DIFF_EXPR:
2314 case MINUS_EXPR:
2315 case TRUNC_DIV_EXPR:
2316 case CEIL_DIV_EXPR:
2317 case FLOOR_DIV_EXPR:
2318 case ROUND_DIV_EXPR:
2319 case TRUNC_MOD_EXPR:
2320 case CEIL_MOD_EXPR:
2321 case FLOOR_MOD_EXPR:
2322 case ROUND_MOD_EXPR:
2323 case RDIV_EXPR:
2324 case EXACT_DIV_EXPR:
2325 case LSHIFT_EXPR:
2326 case RSHIFT_EXPR:
2327 case LROTATE_EXPR:
2328 case RROTATE_EXPR:
2329 case WIDEN_LSHIFT_EXPR:
2330 case BIT_IOR_EXPR:
2331 case BIT_XOR_EXPR:
2332 case BIT_AND_EXPR:
2333 case TRUTH_ANDIF_EXPR:
2334 case TRUTH_ORIF_EXPR:
2335 case TRUTH_AND_EXPR:
2336 case TRUTH_OR_EXPR:
2337 case TRUTH_XOR_EXPR:
2338 case LT_EXPR:
2339 case LE_EXPR:
2340 case GT_EXPR:
2341 case GE_EXPR:
2342 case EQ_EXPR:
2343 case NE_EXPR:
2344 case UNLT_EXPR:
2345 case UNLE_EXPR:
2346 case UNGT_EXPR:
2347 case UNGE_EXPR:
2348 case UNEQ_EXPR:
2349 case LTGT_EXPR:
2350 case ORDERED_EXPR:
2351 case UNORDERED_EXPR:
2352 {
2353 const char *op = op_symbol (node);
2354 op0 = TREE_OPERAND (node, 0);
2355 op1 = TREE_OPERAND (node, 1);
2356
2357 /* When the operands are expressions with less priority,
2358 keep semantics of the tree representation. */
2359 if (op_prio (op0) <= op_prio (node))
2360 {
2361 pp_left_paren (pp);
2362 dump_generic_node (pp, op0, spc, flags, false);
2363 pp_right_paren (pp);
2364 }
2365 else
2366 dump_generic_node (pp, op0, spc, flags, false);
2367
2368 pp_space (pp);
2369 pp_string (pp, op);
2370 pp_space (pp);
2371
2372 /* When the operands are expressions with less priority,
2373 keep semantics of the tree representation. */
2374 if (op_prio (op1) <= op_prio (node))
2375 {
2376 pp_left_paren (pp);
2377 dump_generic_node (pp, op1, spc, flags, false);
2378 pp_right_paren (pp);
2379 }
2380 else
2381 dump_generic_node (pp, op1, spc, flags, false);
2382 }
2383 break;
2384
2385 /* Unary arithmetic and logic expressions. */
2386 case NEGATE_EXPR:
2387 case BIT_NOT_EXPR:
2388 case TRUTH_NOT_EXPR:
2389 case ADDR_EXPR:
2390 case PREDECREMENT_EXPR:
2391 case PREINCREMENT_EXPR:
2392 case INDIRECT_REF:
2393 if (TREE_CODE (node) == ADDR_EXPR
2394 && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
2395 || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
2396 ; /* Do not output '&' for strings and function pointers. */
2397 else
2398 pp_string (pp, op_symbol (node));
2399
2400 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
2401 {
2402 pp_left_paren (pp);
2403 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2404 pp_right_paren (pp);
2405 }
2406 else
2407 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2408 break;
2409
2410 case POSTDECREMENT_EXPR:
2411 case POSTINCREMENT_EXPR:
2412 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
2413 {
2414 pp_left_paren (pp);
2415 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2416 pp_right_paren (pp);
2417 }
2418 else
2419 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2420 pp_string (pp, op_symbol (node));
2421 break;
2422
2423 case MIN_EXPR:
2424 pp_string (pp, "MIN_EXPR <");
2425 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2426 pp_string (pp, ", ");
2427 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2428 pp_greater (pp);
2429 break;
2430
2431 case MAX_EXPR:
2432 pp_string (pp, "MAX_EXPR <");
2433 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2434 pp_string (pp, ", ");
2435 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2436 pp_greater (pp);
2437 break;
2438
2439 case ABS_EXPR:
2440 pp_string (pp, "ABS_EXPR <");
2441 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2442 pp_greater (pp);
2443 break;
2444
2445 case RANGE_EXPR:
2446 NIY;
2447 break;
2448
2449 case ADDR_SPACE_CONVERT_EXPR:
2450 case FIXED_CONVERT_EXPR:
2451 case FIX_TRUNC_EXPR:
2452 case FLOAT_EXPR:
2453 CASE_CONVERT:
2454 type = TREE_TYPE (node);
2455 op0 = TREE_OPERAND (node, 0);
2456 if (type != TREE_TYPE (op0))
2457 {
2458 pp_left_paren (pp);
2459 dump_generic_node (pp, type, spc, flags, false);
2460 pp_string (pp, ") ");
2461 }
2462 if (op_prio (op0) < op_prio (node))
2463 pp_left_paren (pp);
2464 dump_generic_node (pp, op0, spc, flags, false);
2465 if (op_prio (op0) < op_prio (node))
2466 pp_right_paren (pp);
2467 break;
2468
2469 case VIEW_CONVERT_EXPR:
2470 pp_string (pp, "VIEW_CONVERT_EXPR<");
2471 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2472 pp_string (pp, ">(");
2473 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2474 pp_right_paren (pp);
2475 break;
2476
2477 case PAREN_EXPR:
2478 pp_string (pp, "((");
2479 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2480 pp_string (pp, "))");
2481 break;
2482
2483 case NON_LVALUE_EXPR:
2484 pp_string (pp, "NON_LVALUE_EXPR <");
2485 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2486 pp_greater (pp);
2487 break;
2488
2489 case SAVE_EXPR:
2490 pp_string (pp, "SAVE_EXPR <");
2491 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2492 pp_greater (pp);
2493 break;
2494
2495 case COMPLEX_EXPR:
2496 pp_string (pp, "COMPLEX_EXPR <");
2497 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2498 pp_string (pp, ", ");
2499 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2500 pp_greater (pp);
2501 break;
2502
2503 case CONJ_EXPR:
2504 pp_string (pp, "CONJ_EXPR <");
2505 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2506 pp_greater (pp);
2507 break;
2508
2509 case REALPART_EXPR:
2510 if (flags & TDF_GIMPLE)
2511 {
2512 pp_string (pp, "__real ");
2513 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2514 }
2515 else
2516 {
2517 pp_string (pp, "REALPART_EXPR <");
2518 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2519 pp_greater (pp);
2520 }
2521 break;
2522
2523 case IMAGPART_EXPR:
2524 if (flags & TDF_GIMPLE)
2525 {
2526 pp_string (pp, "__imag ");
2527 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2528 }
2529 else
2530 {
2531 pp_string (pp, "IMAGPART_EXPR <");
2532 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2533 pp_greater (pp);
2534 }
2535 break;
2536
2537 case VA_ARG_EXPR:
2538 pp_string (pp, "VA_ARG_EXPR <");
2539 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2540 pp_greater (pp);
2541 break;
2542
2543 case TRY_FINALLY_EXPR:
2544 case TRY_CATCH_EXPR:
2545 pp_string (pp, "try");
2546 newline_and_indent (pp, spc+2);
2547 pp_left_brace (pp);
2548 newline_and_indent (pp, spc+4);
2549 dump_generic_node (pp, TREE_OPERAND (node, 0), spc+4, flags, true);
2550 newline_and_indent (pp, spc+2);
2551 pp_right_brace (pp);
2552 newline_and_indent (pp, spc);
2553 pp_string (pp,
2554 (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");
2555 newline_and_indent (pp, spc+2);
2556 pp_left_brace (pp);
2557 newline_and_indent (pp, spc+4);
2558 dump_generic_node (pp, TREE_OPERAND (node, 1), spc+4, flags, true);
2559 newline_and_indent (pp, spc+2);
2560 pp_right_brace (pp);
2561 is_expr = false;
2562 break;
2563
2564 case CATCH_EXPR:
2565 pp_string (pp, "catch (");
2566 dump_generic_node (pp, CATCH_TYPES (node), spc+2, flags, false);
2567 pp_right_paren (pp);
2568 newline_and_indent (pp, spc+2);
2569 pp_left_brace (pp);
2570 newline_and_indent (pp, spc+4);
2571 dump_generic_node (pp, CATCH_BODY (node), spc+4, flags, true);
2572 newline_and_indent (pp, spc+2);
2573 pp_right_brace (pp);
2574 is_expr = false;
2575 break;
2576
2577 case EH_FILTER_EXPR:
2578 pp_string (pp, "<<<eh_filter (");
2579 dump_generic_node (pp, EH_FILTER_TYPES (node), spc+2, flags, false);
2580 pp_string (pp, ")>>>");
2581 newline_and_indent (pp, spc+2);
2582 pp_left_brace (pp);
2583 newline_and_indent (pp, spc+4);
2584 dump_generic_node (pp, EH_FILTER_FAILURE (node), spc+4, flags, true);
2585 newline_and_indent (pp, spc+2);
2586 pp_right_brace (pp);
2587 is_expr = false;
2588 break;
2589
2590 case LABEL_EXPR:
2591 op0 = TREE_OPERAND (node, 0);
2592 /* If this is for break or continue, don't bother printing it. */
2593 if (DECL_NAME (op0))
2594 {
2595 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
2596 if (strcmp (name, "break") == 0
2597 || strcmp (name, "continue") == 0)
2598 break;
2599 }
2600 dump_generic_node (pp, op0, spc, flags, false);
2601 pp_colon (pp);
2602 if (DECL_NONLOCAL (op0))
2603 pp_string (pp, " [non-local]");
2604 break;
2605
2606 case LOOP_EXPR:
2607 pp_string (pp, "while (1)");
2608 if (!(flags & TDF_SLIM))
2609 {
2610 newline_and_indent (pp, spc+2);
2611 pp_left_brace (pp);
2612 newline_and_indent (pp, spc+4);
2613 dump_generic_node (pp, LOOP_EXPR_BODY (node), spc+4, flags, true);
2614 newline_and_indent (pp, spc+2);
2615 pp_right_brace (pp);
2616 }
2617 is_expr = false;
2618 break;
2619
2620 case PREDICT_EXPR:
2621 pp_string (pp, "// predicted ");
2622 if (PREDICT_EXPR_OUTCOME (node))
2623 pp_string (pp, "likely by ");
2624 else
2625 pp_string (pp, "unlikely by ");
2626 pp_string (pp, predictor_name (PREDICT_EXPR_PREDICTOR (node)));
2627 pp_string (pp, " predictor.");
2628 break;
2629
2630 case ANNOTATE_EXPR:
2631 pp_string (pp, "ANNOTATE_EXPR <");
2632 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2633 switch ((enum annot_expr_kind) TREE_INT_CST_LOW (TREE_OPERAND (node, 1)))
2634 {
2635 case annot_expr_ivdep_kind:
2636 pp_string (pp, ", ivdep");
2637 break;
2638 case annot_expr_unroll_kind:
2639 pp_printf (pp, ", unroll %d",
2640 (int) TREE_INT_CST_LOW (TREE_OPERAND (node, 2)));
2641 break;
2642 case annot_expr_no_vector_kind:
2643 pp_string (pp, ", no-vector");
2644 break;
2645 case annot_expr_vector_kind:
2646 pp_string (pp, ", vector");
2647 break;
2648 case annot_expr_parallel_kind:
2649 pp_string (pp, ", parallel");
2650 break;
2651 default:
2652 gcc_unreachable ();
2653 }
2654 pp_greater (pp);
2655 break;
2656
2657 case RETURN_EXPR:
2658 pp_string (pp, "return");
2659 op0 = TREE_OPERAND (node, 0);
2660 if (op0)
2661 {
2662 pp_space (pp);
2663 if (TREE_CODE (op0) == MODIFY_EXPR)
2664 dump_generic_node (pp, TREE_OPERAND (op0, 1),
2665 spc, flags, false);
2666 else
2667 dump_generic_node (pp, op0, spc, flags, false);
2668 }
2669 break;
2670
2671 case EXIT_EXPR:
2672 pp_string (pp, "if (");
2673 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2674 pp_string (pp, ") break");
2675 break;
2676
2677 case SWITCH_EXPR:
2678 pp_string (pp, "switch (");
2679 dump_generic_node (pp, SWITCH_COND (node), spc, flags, false);
2680 pp_right_paren (pp);
2681 if (!(flags & TDF_SLIM))
2682 {
2683 newline_and_indent (pp, spc+2);
2684 pp_left_brace (pp);
2685 if (SWITCH_BODY (node))
2686 {
2687 newline_and_indent (pp, spc+4);
2688 dump_generic_node (pp, SWITCH_BODY (node), spc+4, flags,
2689 true);
2690 }
2691 newline_and_indent (pp, spc+2);
2692 pp_right_brace (pp);
2693 }
2694 is_expr = false;
2695 break;
2696
2697 case GOTO_EXPR:
2698 op0 = GOTO_DESTINATION (node);
2699 if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
2700 {
2701 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
2702 if (strcmp (name, "break") == 0
2703 || strcmp (name, "continue") == 0)
2704 {
2705 pp_string (pp, name);
2706 break;
2707 }
2708 }
2709 pp_string (pp, "goto ");
2710 dump_generic_node (pp, op0, spc, flags, false);
2711 break;
2712
2713 case ASM_EXPR:
2714 pp_string (pp, "__asm__");
2715 if (ASM_VOLATILE_P (node))
2716 pp_string (pp, " __volatile__");
2717 pp_left_paren (pp);
2718 dump_generic_node (pp, ASM_STRING (node), spc, flags, false);
2719 pp_colon (pp);
2720 dump_generic_node (pp, ASM_OUTPUTS (node), spc, flags, false);
2721 pp_colon (pp);
2722 dump_generic_node (pp, ASM_INPUTS (node), spc, flags, false);
2723 if (ASM_CLOBBERS (node))
2724 {
2725 pp_colon (pp);
2726 dump_generic_node (pp, ASM_CLOBBERS (node), spc, flags, false);
2727 }
2728 pp_right_paren (pp);
2729 break;
2730
2731 case CASE_LABEL_EXPR:
2732 if (CASE_LOW (node) && CASE_HIGH (node))
2733 {
2734 pp_string (pp, "case ");
2735 dump_generic_node (pp, CASE_LOW (node), spc, flags, false);
2736 pp_string (pp, " ... ");
2737 dump_generic_node (pp, CASE_HIGH (node), spc, flags, false);
2738 }
2739 else if (CASE_LOW (node))
2740 {
2741 pp_string (pp, "case ");
2742 dump_generic_node (pp, CASE_LOW (node), spc, flags, false);
2743 }
2744 else
2745 pp_string (pp, "default");
2746 pp_colon (pp);
2747 break;
2748
2749 case OBJ_TYPE_REF:
2750 pp_string (pp, "OBJ_TYPE_REF(");
2751 dump_generic_node (pp, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
2752 pp_semicolon (pp);
2753 /* We omit the class type for -fcompare-debug because we may
2754 drop TYPE_BINFO early depending on debug info, and then
2755 virtual_method_call_p would return false, whereas when
2756 TYPE_BINFO is preserved it may still return true and then
2757 we'd print the class type. Compare tree and rtl dumps for
2758 libstdc++-prettyprinters/shared_ptr.cc with and without -g,
2759 for example, at occurrences of OBJ_TYPE_REF. */
2760 if (!(flags & (TDF_SLIM | TDF_COMPARE_DEBUG))
2761 && virtual_method_call_p (node))
2762 {
2763 pp_string (pp, "(");
2764 dump_generic_node (pp, obj_type_ref_class (node), spc, flags, false);
2765 pp_string (pp, ")");
2766 }
2767 dump_generic_node (pp, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
2768 pp_arrow (pp);
2769 dump_generic_node (pp, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
2770 pp_right_paren (pp);
2771 break;
2772
2773 case SSA_NAME:
2774 if (SSA_NAME_IDENTIFIER (node))
2775 {
2776 if ((flags & TDF_NOUID)
2777 && SSA_NAME_VAR (node)
2778 && DECL_NAMELESS (SSA_NAME_VAR (node)))
2779 dump_fancy_name (pp, SSA_NAME_IDENTIFIER (node));
2780 else if (! (flags & TDF_GIMPLE)
2781 || SSA_NAME_VAR (node))
2782 dump_generic_node (pp, SSA_NAME_IDENTIFIER (node),
2783 spc, flags, false);
2784 }
2785 pp_underscore (pp);
2786 pp_decimal_int (pp, SSA_NAME_VERSION (node));
2787 if (SSA_NAME_IS_DEFAULT_DEF (node))
2788 pp_string (pp, "(D)");
2789 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
2790 pp_string (pp, "(ab)");
2791 break;
2792
2793 case WITH_SIZE_EXPR:
2794 pp_string (pp, "WITH_SIZE_EXPR <");
2795 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2796 pp_string (pp, ", ");
2797 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2798 pp_greater (pp);
2799 break;
2800
2801 case ASSERT_EXPR:
2802 pp_string (pp, "ASSERT_EXPR <");
2803 dump_generic_node (pp, ASSERT_EXPR_VAR (node), spc, flags, false);
2804 pp_string (pp, ", ");
2805 dump_generic_node (pp, ASSERT_EXPR_COND (node), spc, flags, false);
2806 pp_greater (pp);
2807 break;
2808
2809 case SCEV_KNOWN:
2810 pp_string (pp, "scev_known");
2811 break;
2812
2813 case SCEV_NOT_KNOWN:
2814 pp_string (pp, "scev_not_known");
2815 break;
2816
2817 case POLYNOMIAL_CHREC:
2818 pp_left_brace (pp);
2819 dump_generic_node (pp, CHREC_LEFT (node), spc, flags, false);
2820 pp_string (pp, ", +, ");
2821 dump_generic_node (pp, CHREC_RIGHT (node), spc, flags, false);
2822 pp_printf (pp, "}_%u", CHREC_VARIABLE (node));
2823 is_stmt = false;
2824 break;
2825
2826 case REALIGN_LOAD_EXPR:
2827 pp_string (pp, "REALIGN_LOAD <");
2828 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2829 pp_string (pp, ", ");
2830 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2831 pp_string (pp, ", ");
2832 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2833 pp_greater (pp);
2834 break;
2835
2836 case VEC_COND_EXPR:
2837 pp_string (pp, " VEC_COND_EXPR < ");
2838 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2839 pp_string (pp, " , ");
2840 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2841 pp_string (pp, " , ");
2842 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2843 pp_string (pp, " > ");
2844 break;
2845
2846 case VEC_PERM_EXPR:
2847 pp_string (pp, " VEC_PERM_EXPR < ");
2848 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2849 pp_string (pp, " , ");
2850 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2851 pp_string (pp, " , ");
2852 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2853 pp_string (pp, " > ");
2854 break;
2855
2856 case DOT_PROD_EXPR:
2857 pp_string (pp, " DOT_PROD_EXPR < ");
2858 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2859 pp_string (pp, ", ");
2860 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2861 pp_string (pp, ", ");
2862 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2863 pp_string (pp, " > ");
2864 break;
2865
2866 case WIDEN_MULT_PLUS_EXPR:
2867 pp_string (pp, " WIDEN_MULT_PLUS_EXPR < ");
2868 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2869 pp_string (pp, ", ");
2870 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2871 pp_string (pp, ", ");
2872 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2873 pp_string (pp, " > ");
2874 break;
2875
2876 case WIDEN_MULT_MINUS_EXPR:
2877 pp_string (pp, " WIDEN_MULT_MINUS_EXPR < ");
2878 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2879 pp_string (pp, ", ");
2880 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2881 pp_string (pp, ", ");
2882 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2883 pp_string (pp, " > ");
2884 break;
2885
2886 case FMA_EXPR:
2887 pp_string (pp, " FMA_EXPR < ");
2888 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2889 pp_string (pp, ", ");
2890 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2891 pp_string (pp, ", ");
2892 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2893 pp_string (pp, " > ");
2894 break;
2895
2896 case OACC_PARALLEL:
2897 pp_string (pp, "#pragma acc parallel");
2898 goto dump_omp_clauses_body;
2899
2900 case OACC_KERNELS:
2901 pp_string (pp, "#pragma acc kernels");
2902 goto dump_omp_clauses_body;
2903
2904 case OACC_DATA:
2905 pp_string (pp, "#pragma acc data");
2906 dump_omp_clauses (pp, OACC_DATA_CLAUSES (node), spc, flags);
2907 goto dump_omp_body;
2908
2909 case OACC_HOST_DATA:
2910 pp_string (pp, "#pragma acc host_data");
2911 dump_omp_clauses (pp, OACC_HOST_DATA_CLAUSES (node), spc, flags);
2912 goto dump_omp_body;
2913
2914 case OACC_DECLARE:
2915 pp_string (pp, "#pragma acc declare");
2916 dump_omp_clauses (pp, OACC_DECLARE_CLAUSES (node), spc, flags);
2917 break;
2918
2919 case OACC_UPDATE:
2920 pp_string (pp, "#pragma acc update");
2921 dump_omp_clauses (pp, OACC_UPDATE_CLAUSES (node), spc, flags);
2922 break;
2923
2924 case OACC_ENTER_DATA:
2925 pp_string (pp, "#pragma acc enter data");
2926 dump_omp_clauses (pp, OACC_ENTER_DATA_CLAUSES (node), spc, flags);
2927 break;
2928
2929 case OACC_EXIT_DATA:
2930 pp_string (pp, "#pragma acc exit data");
2931 dump_omp_clauses (pp, OACC_EXIT_DATA_CLAUSES (node), spc, flags);
2932 break;
2933
2934 case OACC_CACHE:
2935 pp_string (pp, "#pragma acc cache");
2936 dump_omp_clauses (pp, OACC_CACHE_CLAUSES (node), spc, flags);
2937 break;
2938
2939 case OMP_PARALLEL:
2940 pp_string (pp, "#pragma omp parallel");
2941 dump_omp_clauses (pp, OMP_PARALLEL_CLAUSES (node), spc, flags);
2942 goto dump_omp_body;
2943
2944 dump_omp_clauses_body:
2945 dump_omp_clauses (pp, OMP_CLAUSES (node), spc, flags);
2946 goto dump_omp_body;
2947
2948 dump_omp_body:
2949 if (!(flags & TDF_SLIM) && OMP_BODY (node))
2950 {
2951 newline_and_indent (pp, spc + 2);
2952 pp_left_brace (pp);
2953 newline_and_indent (pp, spc + 4);
2954 dump_generic_node (pp, OMP_BODY (node), spc + 4, flags, false);
2955 newline_and_indent (pp, spc + 2);
2956 pp_right_brace (pp);
2957 }
2958 is_expr = false;
2959 break;
2960
2961 case OMP_TASK:
2962 pp_string (pp, "#pragma omp task");
2963 dump_omp_clauses (pp, OMP_TASK_CLAUSES (node), spc, flags);
2964 goto dump_omp_body;
2965
2966 case OMP_FOR:
2967 pp_string (pp, "#pragma omp for");
2968 goto dump_omp_loop;
2969
2970 case OMP_SIMD:
2971 pp_string (pp, "#pragma omp simd");
2972 goto dump_omp_loop;
2973
2974 case OMP_DISTRIBUTE:
2975 pp_string (pp, "#pragma omp distribute");
2976 goto dump_omp_loop;
2977
2978 case OMP_TASKLOOP:
2979 pp_string (pp, "#pragma omp taskloop");
2980 goto dump_omp_loop;
2981
2982 case OACC_LOOP:
2983 pp_string (pp, "#pragma acc loop");
2984 goto dump_omp_loop;
2985
2986 case OMP_TEAMS:
2987 pp_string (pp, "#pragma omp teams");
2988 dump_omp_clauses (pp, OMP_TEAMS_CLAUSES (node), spc, flags);
2989 goto dump_omp_body;
2990
2991 case OMP_TARGET_DATA:
2992 pp_string (pp, "#pragma omp target data");
2993 dump_omp_clauses (pp, OMP_TARGET_DATA_CLAUSES (node), spc, flags);
2994 goto dump_omp_body;
2995
2996 case OMP_TARGET_ENTER_DATA:
2997 pp_string (pp, "#pragma omp target enter data");
2998 dump_omp_clauses (pp, OMP_TARGET_ENTER_DATA_CLAUSES (node), spc, flags);
2999 is_expr = false;
3000 break;
3001
3002 case OMP_TARGET_EXIT_DATA:
3003 pp_string (pp, "#pragma omp target exit data");
3004 dump_omp_clauses (pp, OMP_TARGET_EXIT_DATA_CLAUSES (node), spc, flags);
3005 is_expr = false;
3006 break;
3007
3008 case OMP_TARGET:
3009 pp_string (pp, "#pragma omp target");
3010 dump_omp_clauses (pp, OMP_TARGET_CLAUSES (node), spc, flags);
3011 goto dump_omp_body;
3012
3013 case OMP_TARGET_UPDATE:
3014 pp_string (pp, "#pragma omp target update");
3015 dump_omp_clauses (pp, OMP_TARGET_UPDATE_CLAUSES (node), spc, flags);
3016 is_expr = false;
3017 break;
3018
3019 dump_omp_loop:
3020 dump_omp_clauses (pp, OMP_FOR_CLAUSES (node), spc, flags);
3021 if (!(flags & TDF_SLIM))
3022 {
3023 int i;
3024
3025 if (OMP_FOR_PRE_BODY (node))
3026 {
3027 newline_and_indent (pp, spc + 2);
3028 pp_left_brace (pp);
3029 spc += 4;
3030 newline_and_indent (pp, spc);
3031 dump_generic_node (pp, OMP_FOR_PRE_BODY (node),
3032 spc, flags, false);
3033 }
3034 if (OMP_FOR_INIT (node))
3035 {
3036 spc -= 2;
3037 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (node)); i++)
3038 {
3039 spc += 2;
3040 newline_and_indent (pp, spc);
3041 pp_string (pp, "for (");
3042 dump_generic_node (pp,
3043 TREE_VEC_ELT (OMP_FOR_INIT (node), i),
3044 spc, flags, false);
3045 pp_string (pp, "; ");
3046 dump_generic_node (pp,
3047 TREE_VEC_ELT (OMP_FOR_COND (node), i),
3048 spc, flags, false);
3049 pp_string (pp, "; ");
3050 dump_generic_node (pp,
3051 TREE_VEC_ELT (OMP_FOR_INCR (node), i),
3052 spc, flags, false);
3053 pp_right_paren (pp);
3054 }
3055 }
3056 if (OMP_FOR_BODY (node))
3057 {
3058 newline_and_indent (pp, spc + 2);
3059 pp_left_brace (pp);
3060 newline_and_indent (pp, spc + 4);
3061 dump_generic_node (pp, OMP_FOR_BODY (node), spc + 4, flags,
3062 false);
3063 newline_and_indent (pp, spc + 2);
3064 pp_right_brace (pp);
3065 }
3066 if (OMP_FOR_INIT (node))
3067 spc -= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node)) - 2;
3068 if (OMP_FOR_PRE_BODY (node))
3069 {
3070 spc -= 4;
3071 newline_and_indent (pp, spc + 2);
3072 pp_right_brace (pp);
3073 }
3074 }
3075 is_expr = false;
3076 break;
3077
3078 case OMP_SECTIONS:
3079 pp_string (pp, "#pragma omp sections");
3080 dump_omp_clauses (pp, OMP_SECTIONS_CLAUSES (node), spc, flags);
3081 goto dump_omp_body;
3082
3083 case OMP_SECTION:
3084 pp_string (pp, "#pragma omp section");
3085 goto dump_omp_body;
3086
3087 case OMP_MASTER:
3088 pp_string (pp, "#pragma omp master");
3089 goto dump_omp_body;
3090
3091 case OMP_TASKGROUP:
3092 pp_string (pp, "#pragma omp taskgroup");
3093 goto dump_omp_body;
3094
3095 case OMP_ORDERED:
3096 pp_string (pp, "#pragma omp ordered");
3097 dump_omp_clauses (pp, OMP_ORDERED_CLAUSES (node), spc, flags);
3098 goto dump_omp_body;
3099
3100 case OMP_CRITICAL:
3101 pp_string (pp, "#pragma omp critical");
3102 if (OMP_CRITICAL_NAME (node))
3103 {
3104 pp_space (pp);
3105 pp_left_paren (pp);
3106 dump_generic_node (pp, OMP_CRITICAL_NAME (node), spc,
3107 flags, false);
3108 pp_right_paren (pp);
3109 }
3110 dump_omp_clauses (pp, OMP_CRITICAL_CLAUSES (node), spc, flags);
3111 goto dump_omp_body;
3112
3113 case OMP_ATOMIC:
3114 pp_string (pp, "#pragma omp atomic");
3115 if (OMP_ATOMIC_SEQ_CST (node))
3116 pp_string (pp, " seq_cst");
3117 newline_and_indent (pp, spc + 2);
3118 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3119 pp_space (pp);
3120 pp_equal (pp);
3121 pp_space (pp);
3122 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3123 break;
3124
3125 case OMP_ATOMIC_READ:
3126 pp_string (pp, "#pragma omp atomic read");
3127 if (OMP_ATOMIC_SEQ_CST (node))
3128 pp_string (pp, " seq_cst");
3129 newline_and_indent (pp, spc + 2);
3130 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3131 pp_space (pp);
3132 break;
3133
3134 case OMP_ATOMIC_CAPTURE_OLD:
3135 case OMP_ATOMIC_CAPTURE_NEW:
3136 pp_string (pp, "#pragma omp atomic capture");
3137 if (OMP_ATOMIC_SEQ_CST (node))
3138 pp_string (pp, " seq_cst");
3139 newline_and_indent (pp, spc + 2);
3140 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3141 pp_space (pp);
3142 pp_equal (pp);
3143 pp_space (pp);
3144 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3145 break;
3146
3147 case OMP_SINGLE:
3148 pp_string (pp, "#pragma omp single");
3149 dump_omp_clauses (pp, OMP_SINGLE_CLAUSES (node), spc, flags);
3150 goto dump_omp_body;
3151
3152 case OMP_CLAUSE:
3153 dump_omp_clause (pp, node, spc, flags);
3154 is_expr = false;
3155 break;
3156
3157 case TRANSACTION_EXPR:
3158 if (TRANSACTION_EXPR_OUTER (node))
3159 pp_string (pp, "__transaction_atomic [[outer]]");
3160 else if (TRANSACTION_EXPR_RELAXED (node))
3161 pp_string (pp, "__transaction_relaxed");
3162 else
3163 pp_string (pp, "__transaction_atomic");
3164 if (!(flags & TDF_SLIM) && TRANSACTION_EXPR_BODY (node))
3165 {
3166 newline_and_indent (pp, spc);
3167 pp_left_brace (pp);
3168 newline_and_indent (pp, spc + 2);
3169 dump_generic_node (pp, TRANSACTION_EXPR_BODY (node),
3170 spc + 2, flags, false);
3171 newline_and_indent (pp, spc);
3172 pp_right_brace (pp);
3173 }
3174 is_expr = false;
3175 break;
3176
3177 case VEC_SERIES_EXPR:
3178 case VEC_WIDEN_MULT_HI_EXPR:
3179 case VEC_WIDEN_MULT_LO_EXPR:
3180 case VEC_WIDEN_MULT_EVEN_EXPR:
3181 case VEC_WIDEN_MULT_ODD_EXPR:
3182 case VEC_WIDEN_LSHIFT_HI_EXPR:
3183 case VEC_WIDEN_LSHIFT_LO_EXPR:
3184 pp_space (pp);
3185 for (str = get_tree_code_name (code); *str; str++)
3186 pp_character (pp, TOUPPER (*str));
3187 pp_string (pp, " < ");
3188 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3189 pp_string (pp, ", ");
3190 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3191 pp_string (pp, " > ");
3192 break;
3193
3194 case VEC_DUPLICATE_EXPR:
3195 pp_space (pp);
3196 for (str = get_tree_code_name (code); *str; str++)
3197 pp_character (pp, TOUPPER (*str));
3198 pp_string (pp, " < ");
3199 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3200 pp_string (pp, " > ");
3201 break;
3202
3203 case VEC_UNPACK_HI_EXPR:
3204 pp_string (pp, " VEC_UNPACK_HI_EXPR < ");
3205 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3206 pp_string (pp, " > ");
3207 break;
3208
3209 case VEC_UNPACK_LO_EXPR:
3210 pp_string (pp, " VEC_UNPACK_LO_EXPR < ");
3211 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3212 pp_string (pp, " > ");
3213 break;
3214
3215 case VEC_UNPACK_FLOAT_HI_EXPR:
3216 pp_string (pp, " VEC_UNPACK_FLOAT_HI_EXPR < ");
3217 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3218 pp_string (pp, " > ");
3219 break;
3220
3221 case VEC_UNPACK_FLOAT_LO_EXPR:
3222 pp_string (pp, " VEC_UNPACK_FLOAT_LO_EXPR < ");
3223 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3224 pp_string (pp, " > ");
3225 break;
3226
3227 case VEC_PACK_TRUNC_EXPR:
3228 pp_string (pp, " VEC_PACK_TRUNC_EXPR < ");
3229 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3230 pp_string (pp, ", ");
3231 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3232 pp_string (pp, " > ");
3233 break;
3234
3235 case VEC_PACK_SAT_EXPR:
3236 pp_string (pp, " VEC_PACK_SAT_EXPR < ");
3237 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3238 pp_string (pp, ", ");
3239 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3240 pp_string (pp, " > ");
3241 break;
3242
3243 case VEC_PACK_FIX_TRUNC_EXPR:
3244 pp_string (pp, " VEC_PACK_FIX_TRUNC_EXPR < ");
3245 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3246 pp_string (pp, ", ");
3247 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3248 pp_string (pp, " > ");
3249 break;
3250
3251 case BLOCK:
3252 dump_block_node (pp, node, spc, flags);
3253 break;
3254
3255 case DEBUG_BEGIN_STMT:
3256 pp_string (pp, "# DEBUG BEGIN STMT");
3257 break;
3258
3259 default:
3260 NIY;
3261 }
3262
3263 if (is_stmt && is_expr)
3264 pp_semicolon (pp);
3265
3266 return spc;
3267 }
3268
3269 /* Print the declaration of a variable. */
3270
3271 void
3272 print_declaration (pretty_printer *pp, tree t, int spc, dump_flags_t flags)
3273 {
3274 INDENT (spc);
3275
3276 if (TREE_CODE(t) == NAMELIST_DECL)
3277 {
3278 pp_string(pp, "namelist ");
3279 dump_decl_name (pp, t, flags);
3280 pp_semicolon (pp);
3281 return;
3282 }
3283
3284 if (TREE_CODE (t) == TYPE_DECL)
3285 pp_string (pp, "typedef ");
3286
3287 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t))
3288 pp_string (pp, "register ");
3289
3290 if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
3291 pp_string (pp, "extern ");
3292 else if (TREE_STATIC (t))
3293 pp_string (pp, "static ");
3294
3295 /* Print the type and name. */
3296 if (TREE_TYPE (t) && TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
3297 {
3298 tree tmp;
3299
3300 /* Print array's type. */
3301 tmp = TREE_TYPE (t);
3302 while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
3303 tmp = TREE_TYPE (tmp);
3304 dump_generic_node (pp, TREE_TYPE (tmp), spc, flags, false);
3305
3306 /* Print variable's name. */
3307 pp_space (pp);
3308 dump_generic_node (pp, t, spc, flags, false);
3309
3310 /* Print the dimensions. */
3311 tmp = TREE_TYPE (t);
3312 while (TREE_CODE (tmp) == ARRAY_TYPE)
3313 {
3314 dump_array_domain (pp, TYPE_DOMAIN (tmp), spc, flags);
3315 tmp = TREE_TYPE (tmp);
3316 }
3317 }
3318 else if (TREE_CODE (t) == FUNCTION_DECL)
3319 {
3320 dump_generic_node (pp, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
3321 pp_space (pp);
3322 dump_decl_name (pp, t, flags);
3323 dump_function_declaration (pp, TREE_TYPE (t), spc, flags);
3324 }
3325 else
3326 {
3327 /* Print type declaration. */
3328 dump_generic_node (pp, TREE_TYPE (t), spc, flags, false);
3329
3330 /* Print variable's name. */
3331 pp_space (pp);
3332 dump_generic_node (pp, t, spc, flags, false);
3333 }
3334
3335 if (VAR_P (t) && DECL_HARD_REGISTER (t))
3336 {
3337 pp_string (pp, " __asm__ ");
3338 pp_left_paren (pp);
3339 dump_generic_node (pp, DECL_ASSEMBLER_NAME (t), spc, flags, false);
3340 pp_right_paren (pp);
3341 }
3342
3343 /* The initial value of a function serves to determine whether the function
3344 is declared or defined. So the following does not apply to function
3345 nodes. */
3346 if (TREE_CODE (t) != FUNCTION_DECL)
3347 {
3348 /* Print the initial value. */
3349 if (DECL_INITIAL (t))
3350 {
3351 pp_space (pp);
3352 pp_equal (pp);
3353 pp_space (pp);
3354 if (!(flags & TDF_SLIM))
3355 dump_generic_node (pp, DECL_INITIAL (t), spc, flags, false);
3356 else
3357 pp_string (pp, "<<< omitted >>>");
3358 }
3359 }
3360
3361 if (VAR_P (t) && DECL_HAS_VALUE_EXPR_P (t))
3362 {
3363 pp_string (pp, " [value-expr: ");
3364 dump_generic_node (pp, DECL_VALUE_EXPR (t), spc, flags, false);
3365 pp_right_bracket (pp);
3366 }
3367
3368 pp_semicolon (pp);
3369 }
3370
3371
3372 /* Prints a structure: name, fields, and methods.
3373 FIXME: Still incomplete. */
3374
3375 static void
3376 print_struct_decl (pretty_printer *pp, const_tree node, int spc,
3377 dump_flags_t flags)
3378 {
3379 /* Print the name of the structure. */
3380 if (TYPE_NAME (node))
3381 {
3382 INDENT (spc);
3383 if (TREE_CODE (node) == RECORD_TYPE)
3384 pp_string (pp, "struct ");
3385 else if ((TREE_CODE (node) == UNION_TYPE
3386 || TREE_CODE (node) == QUAL_UNION_TYPE))
3387 pp_string (pp, "union ");
3388
3389 dump_generic_node (pp, TYPE_NAME (node), spc, 0, false);
3390 }
3391
3392 /* Print the contents of the structure. */
3393 pp_newline (pp);
3394 INDENT (spc);
3395 pp_left_brace (pp);
3396 pp_newline (pp);
3397
3398 /* Print the fields of the structure. */
3399 {
3400 tree tmp;
3401 tmp = TYPE_FIELDS (node);
3402 while (tmp)
3403 {
3404 /* Avoid to print recursively the structure. */
3405 /* FIXME : Not implemented correctly...,
3406 what about the case when we have a cycle in the contain graph? ...
3407 Maybe this could be solved by looking at the scope in which the
3408 structure was declared. */
3409 if (TREE_TYPE (tmp) != node
3410 && (TREE_CODE (TREE_TYPE (tmp)) != POINTER_TYPE
3411 || TREE_TYPE (TREE_TYPE (tmp)) != node))
3412 {
3413 print_declaration (pp, tmp, spc+2, flags);
3414 pp_newline (pp);
3415 }
3416 tmp = DECL_CHAIN (tmp);
3417 }
3418 }
3419 INDENT (spc);
3420 pp_right_brace (pp);
3421 }
3422
3423 /* Return the priority of the operator CODE.
3424
3425 From lowest to highest precedence with either left-to-right (L-R)
3426 or right-to-left (R-L) associativity]:
3427
3428 1 [L-R] ,
3429 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
3430 3 [R-L] ?:
3431 4 [L-R] ||
3432 5 [L-R] &&
3433 6 [L-R] |
3434 7 [L-R] ^
3435 8 [L-R] &
3436 9 [L-R] == !=
3437 10 [L-R] < <= > >=
3438 11 [L-R] << >>
3439 12 [L-R] + -
3440 13 [L-R] * / %
3441 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
3442 15 [L-R] fn() [] -> .
3443
3444 unary +, - and * have higher precedence than the corresponding binary
3445 operators. */
3446
3447 int
3448 op_code_prio (enum tree_code code)
3449 {
3450 switch (code)
3451 {
3452 case TREE_LIST:
3453 case COMPOUND_EXPR:
3454 case BIND_EXPR:
3455 return 1;
3456
3457 case MODIFY_EXPR:
3458 case INIT_EXPR:
3459 return 2;
3460
3461 case COND_EXPR:
3462 return 3;
3463
3464 case TRUTH_OR_EXPR:
3465 case TRUTH_ORIF_EXPR:
3466 return 4;
3467
3468 case TRUTH_AND_EXPR:
3469 case TRUTH_ANDIF_EXPR:
3470 return 5;
3471
3472 case BIT_IOR_EXPR:
3473 return 6;
3474
3475 case BIT_XOR_EXPR:
3476 case TRUTH_XOR_EXPR:
3477 return 7;
3478
3479 case BIT_AND_EXPR:
3480 return 8;
3481
3482 case EQ_EXPR:
3483 case NE_EXPR:
3484 return 9;
3485
3486 case UNLT_EXPR:
3487 case UNLE_EXPR:
3488 case UNGT_EXPR:
3489 case UNGE_EXPR:
3490 case UNEQ_EXPR:
3491 case LTGT_EXPR:
3492 case ORDERED_EXPR:
3493 case UNORDERED_EXPR:
3494 case LT_EXPR:
3495 case LE_EXPR:
3496 case GT_EXPR:
3497 case GE_EXPR:
3498 return 10;
3499
3500 case LSHIFT_EXPR:
3501 case RSHIFT_EXPR:
3502 case LROTATE_EXPR:
3503 case RROTATE_EXPR:
3504 case VEC_WIDEN_LSHIFT_HI_EXPR:
3505 case VEC_WIDEN_LSHIFT_LO_EXPR:
3506 case WIDEN_LSHIFT_EXPR:
3507 return 11;
3508
3509 case WIDEN_SUM_EXPR:
3510 case PLUS_EXPR:
3511 case POINTER_PLUS_EXPR:
3512 case POINTER_DIFF_EXPR:
3513 case MINUS_EXPR:
3514 return 12;
3515
3516 case VEC_WIDEN_MULT_HI_EXPR:
3517 case VEC_WIDEN_MULT_LO_EXPR:
3518 case WIDEN_MULT_EXPR:
3519 case DOT_PROD_EXPR:
3520 case WIDEN_MULT_PLUS_EXPR:
3521 case WIDEN_MULT_MINUS_EXPR:
3522 case MULT_EXPR:
3523 case MULT_HIGHPART_EXPR:
3524 case TRUNC_DIV_EXPR:
3525 case CEIL_DIV_EXPR:
3526 case FLOOR_DIV_EXPR:
3527 case ROUND_DIV_EXPR:
3528 case RDIV_EXPR:
3529 case EXACT_DIV_EXPR:
3530 case TRUNC_MOD_EXPR:
3531 case CEIL_MOD_EXPR:
3532 case FLOOR_MOD_EXPR:
3533 case ROUND_MOD_EXPR:
3534 case FMA_EXPR:
3535 return 13;
3536
3537 case TRUTH_NOT_EXPR:
3538 case BIT_NOT_EXPR:
3539 case POSTINCREMENT_EXPR:
3540 case POSTDECREMENT_EXPR:
3541 case PREINCREMENT_EXPR:
3542 case PREDECREMENT_EXPR:
3543 case NEGATE_EXPR:
3544 case INDIRECT_REF:
3545 case ADDR_EXPR:
3546 case FLOAT_EXPR:
3547 CASE_CONVERT:
3548 case FIX_TRUNC_EXPR:
3549 case TARGET_EXPR:
3550 return 14;
3551
3552 case CALL_EXPR:
3553 case ARRAY_REF:
3554 case ARRAY_RANGE_REF:
3555 case COMPONENT_REF:
3556 return 15;
3557
3558 /* Special expressions. */
3559 case MIN_EXPR:
3560 case MAX_EXPR:
3561 case ABS_EXPR:
3562 case REALPART_EXPR:
3563 case IMAGPART_EXPR:
3564 case VEC_UNPACK_HI_EXPR:
3565 case VEC_UNPACK_LO_EXPR:
3566 case VEC_UNPACK_FLOAT_HI_EXPR:
3567 case VEC_UNPACK_FLOAT_LO_EXPR:
3568 case VEC_PACK_TRUNC_EXPR:
3569 case VEC_PACK_SAT_EXPR:
3570 return 16;
3571
3572 default:
3573 /* Return an arbitrarily high precedence to avoid surrounding single
3574 VAR_DECLs in ()s. */
3575 return 9999;
3576 }
3577 }
3578
3579 /* Return the priority of the operator OP. */
3580
3581 int
3582 op_prio (const_tree op)
3583 {
3584 enum tree_code code;
3585
3586 if (op == NULL)
3587 return 9999;
3588
3589 code = TREE_CODE (op);
3590 if (code == SAVE_EXPR || code == NON_LVALUE_EXPR)
3591 return op_prio (TREE_OPERAND (op, 0));
3592
3593 return op_code_prio (code);
3594 }
3595
3596 /* Return the symbol associated with operator CODE. */
3597
3598 const char *
3599 op_symbol_code (enum tree_code code)
3600 {
3601 switch (code)
3602 {
3603 case MODIFY_EXPR:
3604 return "=";
3605
3606 case TRUTH_OR_EXPR:
3607 case TRUTH_ORIF_EXPR:
3608 return "||";
3609
3610 case TRUTH_AND_EXPR:
3611 case TRUTH_ANDIF_EXPR:
3612 return "&&";
3613
3614 case BIT_IOR_EXPR:
3615 return "|";
3616
3617 case TRUTH_XOR_EXPR:
3618 case BIT_XOR_EXPR:
3619 return "^";
3620
3621 case ADDR_EXPR:
3622 case BIT_AND_EXPR:
3623 return "&";
3624
3625 case ORDERED_EXPR:
3626 return "ord";
3627 case UNORDERED_EXPR:
3628 return "unord";
3629
3630 case EQ_EXPR:
3631 return "==";
3632 case UNEQ_EXPR:
3633 return "u==";
3634
3635 case NE_EXPR:
3636 return "!=";
3637
3638 case LT_EXPR:
3639 return "<";
3640 case UNLT_EXPR:
3641 return "u<";
3642
3643 case LE_EXPR:
3644 return "<=";
3645 case UNLE_EXPR:
3646 return "u<=";
3647
3648 case GT_EXPR:
3649 return ">";
3650 case UNGT_EXPR:
3651 return "u>";
3652
3653 case GE_EXPR:
3654 return ">=";
3655 case UNGE_EXPR:
3656 return "u>=";
3657
3658 case LTGT_EXPR:
3659 return "<>";
3660
3661 case LSHIFT_EXPR:
3662 return "<<";
3663
3664 case RSHIFT_EXPR:
3665 return ">>";
3666
3667 case LROTATE_EXPR:
3668 return "r<<";
3669
3670 case RROTATE_EXPR:
3671 return "r>>";
3672
3673 case WIDEN_LSHIFT_EXPR:
3674 return "w<<";
3675
3676 case POINTER_PLUS_EXPR:
3677 return "+";
3678
3679 case PLUS_EXPR:
3680 return "+";
3681
3682 case WIDEN_SUM_EXPR:
3683 return "w+";
3684
3685 case WIDEN_MULT_EXPR:
3686 return "w*";
3687
3688 case MULT_HIGHPART_EXPR:
3689 return "h*";
3690
3691 case NEGATE_EXPR:
3692 case MINUS_EXPR:
3693 case POINTER_DIFF_EXPR:
3694 return "-";
3695
3696 case BIT_NOT_EXPR:
3697 return "~";
3698
3699 case TRUTH_NOT_EXPR:
3700 return "!";
3701
3702 case MULT_EXPR:
3703 case INDIRECT_REF:
3704 return "*";
3705
3706 case TRUNC_DIV_EXPR:
3707 case RDIV_EXPR:
3708 return "/";
3709
3710 case CEIL_DIV_EXPR:
3711 return "/[cl]";
3712
3713 case FLOOR_DIV_EXPR:
3714 return "/[fl]";
3715
3716 case ROUND_DIV_EXPR:
3717 return "/[rd]";
3718
3719 case EXACT_DIV_EXPR:
3720 return "/[ex]";
3721
3722 case TRUNC_MOD_EXPR:
3723 return "%";
3724
3725 case CEIL_MOD_EXPR:
3726 return "%[cl]";
3727
3728 case FLOOR_MOD_EXPR:
3729 return "%[fl]";
3730
3731 case ROUND_MOD_EXPR:
3732 return "%[rd]";
3733
3734 case PREDECREMENT_EXPR:
3735 return " --";
3736
3737 case PREINCREMENT_EXPR:
3738 return " ++";
3739
3740 case POSTDECREMENT_EXPR:
3741 return "-- ";
3742
3743 case POSTINCREMENT_EXPR:
3744 return "++ ";
3745
3746 case MAX_EXPR:
3747 return "max";
3748
3749 case MIN_EXPR:
3750 return "min";
3751
3752 default:
3753 return "<<< ??? >>>";
3754 }
3755 }
3756
3757 /* Return the symbol associated with operator OP. */
3758
3759 static const char *
3760 op_symbol (const_tree op)
3761 {
3762 return op_symbol_code (TREE_CODE (op));
3763 }
3764
3765 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
3766 the gimple_call_fn of a GIMPLE_CALL. */
3767
3768 void
3769 print_call_name (pretty_printer *pp, tree node, dump_flags_t flags)
3770 {
3771 tree op0 = node;
3772
3773 if (TREE_CODE (op0) == NON_LVALUE_EXPR)
3774 op0 = TREE_OPERAND (op0, 0);
3775
3776 again:
3777 switch (TREE_CODE (op0))
3778 {
3779 case VAR_DECL:
3780 case PARM_DECL:
3781 case FUNCTION_DECL:
3782 dump_function_name (pp, op0, flags);
3783 break;
3784
3785 case ADDR_EXPR:
3786 case INDIRECT_REF:
3787 CASE_CONVERT:
3788 op0 = TREE_OPERAND (op0, 0);
3789 goto again;
3790
3791 case COND_EXPR:
3792 pp_left_paren (pp);
3793 dump_generic_node (pp, TREE_OPERAND (op0, 0), 0, flags, false);
3794 pp_string (pp, ") ? ");
3795 dump_generic_node (pp, TREE_OPERAND (op0, 1), 0, flags, false);
3796 pp_string (pp, " : ");
3797 dump_generic_node (pp, TREE_OPERAND (op0, 2), 0, flags, false);
3798 break;
3799
3800 case ARRAY_REF:
3801 if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
3802 dump_function_name (pp, TREE_OPERAND (op0, 0), flags);
3803 else
3804 dump_generic_node (pp, op0, 0, flags, false);
3805 break;
3806
3807 case MEM_REF:
3808 if (integer_zerop (TREE_OPERAND (op0, 1)))
3809 {
3810 op0 = TREE_OPERAND (op0, 0);
3811 goto again;
3812 }
3813 /* Fallthru. */
3814 case COMPONENT_REF:
3815 case SSA_NAME:
3816 case OBJ_TYPE_REF:
3817 dump_generic_node (pp, op0, 0, flags, false);
3818 break;
3819
3820 default:
3821 NIY;
3822 }
3823 }
3824
3825 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
3826
3827 static void
3828 pretty_print_string (pretty_printer *pp, const char *str)
3829 {
3830 if (str == NULL)
3831 return;
3832
3833 while (*str)
3834 {
3835 switch (str[0])
3836 {
3837 case '\b':
3838 pp_string (pp, "\\b");
3839 break;
3840
3841 case '\f':
3842 pp_string (pp, "\\f");
3843 break;
3844
3845 case '\n':
3846 pp_string (pp, "\\n");
3847 break;
3848
3849 case '\r':
3850 pp_string (pp, "\\r");
3851 break;
3852
3853 case '\t':
3854 pp_string (pp, "\\t");
3855 break;
3856
3857 case '\v':
3858 pp_string (pp, "\\v");
3859 break;
3860
3861 case '\\':
3862 pp_string (pp, "\\\\");
3863 break;
3864
3865 case '\"':
3866 pp_string (pp, "\\\"");
3867 break;
3868
3869 case '\'':
3870 pp_string (pp, "\\'");
3871 break;
3872
3873 /* No need to handle \0; the loop terminates on \0. */
3874
3875 case '\1':
3876 pp_string (pp, "\\1");
3877 break;
3878
3879 case '\2':
3880 pp_string (pp, "\\2");
3881 break;
3882
3883 case '\3':
3884 pp_string (pp, "\\3");
3885 break;
3886
3887 case '\4':
3888 pp_string (pp, "\\4");
3889 break;
3890
3891 case '\5':
3892 pp_string (pp, "\\5");
3893 break;
3894
3895 case '\6':
3896 pp_string (pp, "\\6");
3897 break;
3898
3899 case '\7':
3900 pp_string (pp, "\\7");
3901 break;
3902
3903 default:
3904 if (!ISPRINT (str[0]))
3905 {
3906 char buf[5];
3907 sprintf (buf, "\\x%x", (unsigned char)str[0]);
3908 pp_string (pp, buf);
3909 }
3910 else
3911 pp_character (pp, str[0]);
3912 break;
3913 }
3914 str++;
3915 }
3916 }
3917
3918 static void
3919 maybe_init_pretty_print (FILE *file)
3920 {
3921 if (!tree_pp)
3922 {
3923 tree_pp = new pretty_printer ();
3924 pp_needs_newline (tree_pp) = true;
3925 pp_translate_identifiers (tree_pp) = false;
3926 }
3927
3928 tree_pp->buffer->stream = file;
3929 }
3930
3931 static void
3932 newline_and_indent (pretty_printer *pp, int spc)
3933 {
3934 pp_newline (pp);
3935 INDENT (spc);
3936 }
3937
3938 /* Handle the %K format for TEXT. Separate from default_tree_printer
3939 so it can also be used in front ends.
3940 Argument is a statement from which EXPR_LOCATION and TREE_BLOCK will
3941 be recorded. */
3942
3943 void
3944 percent_K_format (text_info *text, tree t)
3945 {
3946 text->set_location (0, EXPR_LOCATION (t), true);
3947 gcc_assert (pp_ti_abstract_origin (text) != NULL);
3948 tree block = TREE_BLOCK (t);
3949 *pp_ti_abstract_origin (text) = NULL;
3950
3951 if (in_lto_p)
3952 {
3953 /* ??? LTO drops all BLOCK_ABSTRACT_ORIGINs apart from those
3954 representing the outermost block of an inlined function.
3955 So walk the BLOCK tree until we hit such a scope. */
3956 while (block
3957 && TREE_CODE (block) == BLOCK)
3958 {
3959 if (inlined_function_outer_scope_p (block))
3960 {
3961 *pp_ti_abstract_origin (text) = block;
3962 break;
3963 }
3964 block = BLOCK_SUPERCONTEXT (block);
3965 }
3966 return;
3967 }
3968
3969 while (block
3970 && TREE_CODE (block) == BLOCK
3971 && BLOCK_ABSTRACT_ORIGIN (block))
3972 {
3973 tree ao = BLOCK_ABSTRACT_ORIGIN (block);
3974
3975 while (TREE_CODE (ao) == BLOCK
3976 && BLOCK_ABSTRACT_ORIGIN (ao)
3977 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
3978 ao = BLOCK_ABSTRACT_ORIGIN (ao);
3979
3980 if (TREE_CODE (ao) == FUNCTION_DECL)
3981 {
3982 *pp_ti_abstract_origin (text) = block;
3983 break;
3984 }
3985 block = BLOCK_SUPERCONTEXT (block);
3986 }
3987 }
3988
3989 /* Print the identifier ID to PRETTY-PRINTER. */
3990
3991 void
3992 pp_tree_identifier (pretty_printer *pp, tree id)
3993 {
3994 if (pp_translate_identifiers (pp))
3995 {
3996 const char *text = identifier_to_locale (IDENTIFIER_POINTER (id));
3997 pp_append_text (pp, text, text + strlen (text));
3998 }
3999 else
4000 pp_append_text (pp, IDENTIFIER_POINTER (id),
4001 IDENTIFIER_POINTER (id) + IDENTIFIER_LENGTH (id));
4002 }
4003
4004 /* A helper function that is used to dump function information before the
4005 function dump. */
4006
4007 void
4008 dump_function_header (FILE *dump_file, tree fdecl, dump_flags_t flags)
4009 {
4010 const char *dname, *aname;
4011 struct cgraph_node *node = cgraph_node::get (fdecl);
4012 struct function *fun = DECL_STRUCT_FUNCTION (fdecl);
4013
4014 dname = lang_hooks.decl_printable_name (fdecl, 1);
4015
4016 if (DECL_ASSEMBLER_NAME_SET_P (fdecl))
4017 aname = (IDENTIFIER_POINTER
4018 (DECL_ASSEMBLER_NAME (fdecl)));
4019 else
4020 aname = "<unset-asm-name>";
4021
4022 fprintf (dump_file, "\n;; Function %s (%s, funcdef_no=%d",
4023 dname, aname, fun->funcdef_no);
4024 if (!(flags & TDF_NOUID))
4025 fprintf (dump_file, ", decl_uid=%d", DECL_UID (fdecl));
4026 if (node)
4027 {
4028 fprintf (dump_file, ", cgraph_uid=%d", node->uid);
4029 fprintf (dump_file, ", symbol_order=%d)%s\n\n", node->order,
4030 node->frequency == NODE_FREQUENCY_HOT
4031 ? " (hot)"
4032 : node->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED
4033 ? " (unlikely executed)"
4034 : node->frequency == NODE_FREQUENCY_EXECUTED_ONCE
4035 ? " (executed once)"
4036 : "");
4037 }
4038 else
4039 fprintf (dump_file, ")\n\n");
4040 }
4041
4042 /* Dump double_int D to pretty_printer PP. UNS is true
4043 if D is unsigned and false otherwise. */
4044 void
4045 pp_double_int (pretty_printer *pp, double_int d, bool uns)
4046 {
4047 if (d.fits_shwi ())
4048 pp_wide_integer (pp, d.low);
4049 else if (d.fits_uhwi ())
4050 pp_unsigned_wide_integer (pp, d.low);
4051 else
4052 {
4053 unsigned HOST_WIDE_INT low = d.low;
4054 HOST_WIDE_INT high = d.high;
4055 if (!uns && d.is_negative ())
4056 {
4057 pp_minus (pp);
4058 high = ~high + !low;
4059 low = -low;
4060 }
4061 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
4062 systems? */
4063 sprintf (pp_buffer (pp)->digit_buffer,
4064 HOST_WIDE_INT_PRINT_DOUBLE_HEX,
4065 (unsigned HOST_WIDE_INT) high, low);
4066 pp_string (pp, pp_buffer (pp)->digit_buffer);
4067 }
4068 }
Mirror of the offical gcc git repository hosted at gcc.gnu.org