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