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