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