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