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