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