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