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