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