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