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