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