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