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