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