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