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