Line data Source code
1 : /* Pretty formatting of GIMPLE statements and expressions.
2 : Copyright (C) 2001-2026 Free Software Foundation, Inc.
3 : Contributed by Aldy Hernandez <aldyh@redhat.com> and
4 : Diego Novillo <dnovillo@google.com>
5 :
6 : This file is part of GCC.
7 :
8 : GCC is free software; you can redistribute it and/or modify it under
9 : the terms of the GNU General Public License as published by the Free
10 : Software Foundation; either version 3, or (at your option) any later
11 : version.
12 :
13 : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 : WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 : FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 : for more details.
17 :
18 : You should have received a copy of the GNU General Public License
19 : along with GCC; see the file COPYING3. If not see
20 : <http://www.gnu.org/licenses/>. */
21 :
22 : #include "config.h"
23 : #include "system.h"
24 : #include "coretypes.h"
25 : #include "dumpfile.h"
26 : #include "backend.h"
27 : #include "tree.h"
28 : #include "gimple.h"
29 : #include "gimple-predict.h"
30 : #include "ssa.h"
31 : #include "cgraph.h"
32 : #include "gimple-pretty-print.h"
33 : #include "value-range-pretty-print.h"
34 : #include "internal-fn.h"
35 : #include "tree-eh.h"
36 : #include "gimple-iterator.h"
37 : #include "tree-cfg.h"
38 : #include "dumpfile.h" /* for dump_flags */
39 : #include "value-prof.h"
40 : #include "trans-mem.h"
41 : #include "cfganal.h"
42 : #include "stringpool.h"
43 : #include "attribs.h"
44 : #include "asan.h"
45 : #include "cfgloop.h"
46 : #include "gimple-range.h"
47 : #include "cfghooks.h"
48 : #include "json.h"
49 : #include "custom-sarif-properties/cfg.h"
50 :
51 : /* Disable warnings about quoting issues in the pp_xxx calls below
52 : that (intentionally) don't follow GCC diagnostic conventions. */
53 : #if __GNUC__ >= 10
54 : # pragma GCC diagnostic push
55 : # pragma GCC diagnostic ignored "-Wformat-diag"
56 : #endif
57 :
58 : #define INDENT(SPACE) \
59 : do { int i; for (i = 0; i < SPACE; i++) pp_space (pp); } while (0)
60 :
61 : #define GIMPLE_NIY do_niy (pp,gs)
62 :
63 : /* Try to print on PP a default message for the unrecognized
64 : gimple statement GS. */
65 :
66 : static void
67 0 : do_niy (pretty_printer *pp, const gimple *gs)
68 : {
69 0 : pp_printf (pp, "<<< Unknown GIMPLE statement: %s >>>\n",
70 0 : gimple_code_name[(int) gimple_code (gs)]);
71 0 : }
72 :
73 :
74 : /* Emit a newline and SPC indentation spaces to PP. */
75 :
76 : static void
77 277145 : newline_and_indent (pretty_printer *pp, int spc)
78 : {
79 277145 : pp_newline (pp);
80 1675626 : INDENT (spc);
81 277145 : }
82 :
83 :
84 : /* Print the GIMPLE statement GS on stderr. */
85 :
86 : DEBUG_FUNCTION void
87 1 : debug_gimple_stmt (gimple *gs)
88 : {
89 1 : print_gimple_stmt (stderr, gs, 0, TDF_VOPS|TDF_MEMSYMS);
90 1 : }
91 :
92 :
93 : /* Return formatted string of a VALUE probability
94 : (biased by REG_BR_PROB_BASE). Returned string is allocated
95 : by xstrdup_for_dump. */
96 :
97 : static const char *
98 249296 : dump_profile (profile_count &count)
99 : {
100 249296 : char *buf = NULL;
101 249296 : if (!count.initialized_p ())
102 : return "";
103 226080 : if (count.ipa_p ())
104 12714 : buf = xasprintf ("[count: %" PRId64 "]",
105 : count.to_gcov_type ());
106 213366 : else if (count.initialized_p ())
107 213366 : buf = xasprintf ("[local count: %" PRId64 "]",
108 : count.to_gcov_type ());
109 :
110 226080 : const char *ret = xstrdup_for_dump (buf);
111 226080 : free (buf);
112 :
113 226080 : return ret;
114 : }
115 :
116 : /* Return formatted string of a VALUE probability
117 : (biased by REG_BR_PROB_BASE). Returned string is allocated
118 : by xstrdup_for_dump. */
119 :
120 : static const char *
121 255217 : dump_probability (profile_probability probability)
122 : {
123 255217 : float minimum = 0.01f;
124 255217 : float fvalue = -1;
125 :
126 255217 : if (probability.initialized_p ())
127 : {
128 240927 : fvalue = probability.to_reg_br_prob_base () * 100.0f / REG_BR_PROB_BASE;
129 240927 : if (fvalue < minimum && probability.to_reg_br_prob_base ())
130 : fvalue = minimum;
131 : }
132 :
133 255217 : char *buf;
134 255217 : if (probability.initialized_p ())
135 240927 : buf = xasprintf ("[%.2f%%]", fvalue);
136 : else
137 14290 : buf = xasprintf ("[INV]");
138 :
139 255217 : const char *ret = xstrdup_for_dump (buf);
140 255217 : free (buf);
141 :
142 255217 : return ret;
143 : }
144 :
145 : /* Dump E probability to PP. */
146 :
147 : static void
148 255217 : dump_edge_probability (pretty_printer *pp, edge e)
149 : {
150 255217 : pp_scalar (pp, " %s", dump_probability (e->probability));
151 255217 : }
152 :
153 : /* Print GIMPLE statement G to FILE using SPC indentation spaces and
154 : FLAGS as in pp_gimple_stmt_1. */
155 :
156 : void
157 1032379 : print_gimple_stmt (FILE *file, gimple *g, int spc, dump_flags_t flags)
158 : {
159 1032379 : pretty_printer pp;
160 1032379 : pp_needs_newline (&pp) = true;
161 1032379 : pp.set_output_stream (file);
162 1032379 : pp_gimple_stmt_1 (&pp, g, spc, flags);
163 1032379 : pp_newline_and_flush (&pp);
164 1032379 : }
165 :
166 : DEBUG_FUNCTION void
167 0 : debug (gimple &ref)
168 : {
169 0 : print_gimple_stmt (stderr, &ref, 0, TDF_NONE);
170 0 : }
171 :
172 : DEBUG_FUNCTION void
173 0 : debug (gimple *ptr)
174 : {
175 0 : if (ptr)
176 0 : debug (*ptr);
177 : else
178 0 : fprintf (stderr, "<nil>\n");
179 0 : }
180 :
181 :
182 : /* Print GIMPLE statement G to FILE using SPC indentation spaces and
183 : FLAGS as in pp_gimple_stmt_1. Print only the right-hand side
184 : of the statement. */
185 :
186 : void
187 241577 : print_gimple_expr (FILE *file, gimple *g, int spc, dump_flags_t flags)
188 : {
189 241577 : flags |= TDF_RHS_ONLY;
190 241577 : pretty_printer pp;
191 241577 : pp_needs_newline (&pp) = true;
192 241577 : pp.set_output_stream (file);
193 241577 : pp_gimple_stmt_1 (&pp, g, spc, flags);
194 241577 : pp_flush (&pp);
195 241577 : }
196 :
197 :
198 : /* Print the GIMPLE sequence SEQ on PP using SPC indentation
199 : spaces and FLAGS as in pp_gimple_stmt_1.
200 : The caller is responsible for calling pp_flush on PP to finalize
201 : the pretty printer. */
202 :
203 : static void
204 38731 : dump_gimple_seq (pretty_printer *pp, gimple_seq seq, int spc,
205 : dump_flags_t flags)
206 : {
207 38731 : gimple_stmt_iterator i;
208 :
209 175710 : for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
210 : {
211 : gimple *gs = gsi_stmt (i);
212 1397339 : INDENT (spc);
213 136979 : pp_gimple_stmt_1 (pp, gs, spc, flags);
214 235877 : if (!gsi_one_before_end_p (i))
215 98898 : pp_newline (pp);
216 : }
217 38731 : }
218 :
219 :
220 : /* Print GIMPLE sequence SEQ to FILE using SPC indentation spaces and
221 : FLAGS as in pp_gimple_stmt_1. */
222 :
223 : void
224 5235 : print_gimple_seq (FILE *file, gimple_seq seq, int spc, dump_flags_t flags)
225 : {
226 5235 : pretty_printer pp;
227 5235 : pp_needs_newline (&pp) = true;
228 5235 : pp.set_output_stream (file);
229 5235 : dump_gimple_seq (&pp, seq, spc, flags);
230 5235 : pp_newline_and_flush (&pp);
231 5235 : }
232 :
233 :
234 : /* Print the GIMPLE sequence SEQ on stderr. */
235 :
236 : DEBUG_FUNCTION void
237 0 : debug_gimple_seq (gimple_seq seq)
238 : {
239 0 : print_gimple_seq (stderr, seq, 0, TDF_VOPS|TDF_MEMSYMS);
240 0 : }
241 :
242 :
243 : /* A simple helper to pretty-print some of the gimple tuples in the printf
244 : style. The format modifiers are preceded by '%' and are:
245 : 'G' - outputs a string corresponding to the code of the given gimple,
246 : 'S' - outputs a gimple_seq with indent of spc + 2,
247 : 'T' - outputs the tree t,
248 : 'd' - outputs an int as a decimal,
249 : 's' - outputs a string,
250 : 'n' - outputs a newline,
251 : 'x' - outputs an int as hexadecimal,
252 : '+' - increases indent by 2 then outputs a newline,
253 : '-' - decreases indent by 2 then outputs a newline. */
254 :
255 : static void
256 44496 : dump_gimple_fmt (pretty_printer *pp, int spc, dump_flags_t flags,
257 : const char *fmt, ...)
258 : {
259 44496 : va_list args;
260 44496 : const char *c;
261 44496 : const char *tmp;
262 :
263 44496 : va_start (args, fmt);
264 700216 : for (c = fmt; *c; c++)
265 : {
266 655720 : if (*c == '%')
267 : {
268 56228 : gimple_seq seq;
269 56228 : tree t;
270 56228 : gimple *g;
271 56228 : switch (*++c)
272 : {
273 2569 : case 'G':
274 2569 : g = va_arg (args, gimple *);
275 2569 : tmp = gimple_code_name[gimple_code (g)];
276 2569 : pp_string (pp, tmp);
277 2569 : break;
278 :
279 12 : case 'S':
280 12 : seq = va_arg (args, gimple_seq);
281 12 : pp_newline (pp);
282 12 : dump_gimple_seq (pp, seq, spc + 2, flags);
283 12 : newline_and_indent (pp, spc);
284 12 : break;
285 :
286 50174 : case 'T':
287 50174 : t = va_arg (args, tree);
288 50174 : if (t == NULL_TREE)
289 6116 : pp_string (pp, "NULL");
290 : else
291 44058 : dump_generic_node (pp, t, spc, flags, false);
292 : break;
293 :
294 1707 : case 'd':
295 1707 : pp_decimal_int (pp, va_arg (args, int));
296 1707 : break;
297 :
298 1718 : case 's':
299 1718 : pp_string (pp, va_arg (args, char *));
300 1718 : break;
301 :
302 8 : case 'n':
303 8 : newline_and_indent (pp, spc);
304 8 : break;
305 :
306 0 : case 'x':
307 0 : pp_scalar (pp, "%x", va_arg (args, int));
308 0 : break;
309 :
310 28 : case '+':
311 28 : spc += 2;
312 28 : newline_and_indent (pp, spc);
313 28 : break;
314 :
315 12 : case '-':
316 12 : spc -= 2;
317 12 : newline_and_indent (pp, spc);
318 12 : break;
319 :
320 0 : default:
321 0 : gcc_unreachable ();
322 : }
323 : }
324 : else
325 599492 : pp_character (pp, *c);
326 : }
327 44496 : va_end (args);
328 44496 : }
329 :
330 :
331 : /* Helper for dump_gimple_assign. Print the unary RHS of the
332 : assignment GS. PP, SPC and FLAGS are as in pp_gimple_stmt_1. */
333 :
334 : static void
335 2664277 : dump_unary_rhs (pretty_printer *pp, const gassign *gs, int spc,
336 : dump_flags_t flags)
337 : {
338 2664277 : enum tree_code rhs_code = gimple_assign_rhs_code (gs);
339 2664277 : tree lhs = gimple_assign_lhs (gs);
340 2664277 : tree rhs = gimple_assign_rhs1 (gs);
341 :
342 2664277 : switch (rhs_code)
343 : {
344 33716 : case VIEW_CONVERT_EXPR:
345 33716 : dump_generic_node (pp, rhs, spc, flags, false);
346 33716 : break;
347 :
348 524849 : case FIXED_CONVERT_EXPR:
349 524849 : case ADDR_SPACE_CONVERT_EXPR:
350 524849 : case FIX_TRUNC_EXPR:
351 524849 : case FLOAT_EXPR:
352 524849 : CASE_CONVERT:
353 524849 : pp_left_paren (pp);
354 524849 : dump_generic_node (pp, TREE_TYPE (lhs), spc, flags, false);
355 524849 : pp_string (pp, ") ");
356 524849 : if (op_prio (rhs) < op_code_prio (rhs_code))
357 : {
358 0 : pp_left_paren (pp);
359 0 : dump_generic_node (pp, rhs, spc, flags, false);
360 0 : pp_right_paren (pp);
361 : }
362 : else
363 524849 : dump_generic_node (pp, rhs, spc, flags, false);
364 : break;
365 :
366 3141 : case PAREN_EXPR:
367 3141 : pp_string (pp, "((");
368 3141 : dump_generic_node (pp, rhs, spc, flags, false);
369 3141 : pp_string (pp, "))");
370 3141 : break;
371 :
372 6624 : case ABS_EXPR:
373 6624 : case ABSU_EXPR:
374 6624 : if (flags & TDF_GIMPLE)
375 : {
376 3 : pp_string (pp,
377 : rhs_code == ABS_EXPR ? "__ABS " : "__ABSU ");
378 2 : dump_generic_node (pp, rhs, spc, flags, false);
379 : }
380 : else
381 : {
382 7969 : pp_string (pp,
383 : rhs_code == ABS_EXPR ? "ABS_EXPR <" : "ABSU_EXPR <");
384 6622 : dump_generic_node (pp, rhs, spc, flags, false);
385 6622 : pp_greater (pp);
386 : }
387 : break;
388 :
389 2095947 : default:
390 2095947 : if (TREE_CODE_CLASS (rhs_code) == tcc_declaration
391 2069243 : || TREE_CODE_CLASS (rhs_code) == tcc_constant
392 1959851 : || TREE_CODE_CLASS (rhs_code) == tcc_reference
393 803551 : || rhs_code == SSA_NAME
394 803551 : || rhs_code == ADDR_EXPR
395 : || rhs_code == CONSTRUCTOR)
396 : {
397 2061174 : dump_generic_node (pp, rhs, spc, flags, false);
398 2061174 : break;
399 : }
400 : else if (rhs_code == BIT_NOT_EXPR)
401 7794 : pp_complement (pp);
402 : else if (rhs_code == TRUTH_NOT_EXPR)
403 0 : pp_exclamation (pp);
404 : else if (rhs_code == NEGATE_EXPR)
405 6605 : pp_minus (pp);
406 : else
407 : {
408 20374 : pp_left_bracket (pp);
409 20374 : pp_string (pp, get_tree_code_name (rhs_code));
410 20374 : pp_string (pp, "] ");
411 : }
412 :
413 34773 : if (op_prio (rhs) < op_code_prio (rhs_code))
414 : {
415 0 : pp_left_paren (pp);
416 0 : dump_generic_node (pp, rhs, spc, flags, false);
417 0 : pp_right_paren (pp);
418 : }
419 : else
420 34773 : dump_generic_node (pp, rhs, spc, flags, false);
421 : break;
422 : }
423 2664277 : }
424 :
425 :
426 : /* Helper for dump_gimple_assign. Print the binary RHS of the
427 : assignment GS. PP, SPC and FLAGS are as in pp_gimple_stmt_1. */
428 :
429 : static void
430 1852580 : dump_binary_rhs (pretty_printer *pp, const gassign *gs, int spc,
431 : dump_flags_t flags)
432 : {
433 1852580 : const char *p;
434 1852580 : enum tree_code code = gimple_assign_rhs_code (gs);
435 1852580 : switch (code)
436 : {
437 13235 : case MIN_EXPR:
438 13235 : case MAX_EXPR:
439 13235 : if (flags & TDF_GIMPLE)
440 : {
441 0 : pp_string (pp, code == MIN_EXPR ? "__MIN (" : "__MAX (");
442 0 : dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags,
443 : false);
444 0 : pp_string (pp, ", ");
445 0 : dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags,
446 : false);
447 0 : pp_string (pp, ")");
448 0 : break;
449 : }
450 : else
451 : {
452 25334 : gcc_fallthrough ();
453 : }
454 25334 : case COMPLEX_EXPR:
455 25334 : case VEC_WIDEN_MULT_HI_EXPR:
456 25334 : case VEC_WIDEN_MULT_LO_EXPR:
457 25334 : case VEC_WIDEN_MULT_EVEN_EXPR:
458 25334 : case VEC_WIDEN_MULT_ODD_EXPR:
459 25334 : case VEC_PACK_TRUNC_EXPR:
460 25334 : case VEC_PACK_SAT_EXPR:
461 25334 : case VEC_PACK_FIX_TRUNC_EXPR:
462 25334 : case VEC_PACK_FLOAT_EXPR:
463 25334 : case VEC_WIDEN_LSHIFT_HI_EXPR:
464 25334 : case VEC_WIDEN_LSHIFT_LO_EXPR:
465 25334 : case VEC_SERIES_EXPR:
466 358343 : for (p = get_tree_code_name (code); *p; p++)
467 333009 : pp_character (pp, TOUPPER (*p));
468 25334 : pp_string (pp, " <");
469 25334 : dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false);
470 25334 : pp_string (pp, ", ");
471 50668 : dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false);
472 25334 : pp_greater (pp);
473 25334 : break;
474 :
475 1827246 : default:
476 1827246 : if (op_prio (gimple_assign_rhs1 (gs)) <= op_code_prio (code))
477 : {
478 0 : pp_left_paren (pp);
479 0 : dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags,
480 : false);
481 0 : pp_right_paren (pp);
482 : }
483 : else
484 1827246 : dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false);
485 1827246 : pp_space (pp);
486 1827246 : pp_string (pp, op_symbol_code (gimple_assign_rhs_code (gs), flags));
487 1827246 : pp_space (pp);
488 3654492 : if (op_prio (gimple_assign_rhs2 (gs)) <= op_code_prio (code))
489 : {
490 0 : pp_left_paren (pp);
491 0 : dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags,
492 : false);
493 0 : pp_right_paren (pp);
494 : }
495 : else
496 3654492 : dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false);
497 : }
498 1852580 : }
499 :
500 : /* Helper for dump_gimple_assign. Print the ternary RHS of the
501 : assignment GS. PP, SPC and FLAGS are as in pp_gimple_stmt_1. */
502 :
503 : static void
504 125083 : dump_ternary_rhs (pretty_printer *pp, const gassign *gs, int spc,
505 : dump_flags_t flags)
506 : {
507 125083 : const char *p;
508 125083 : enum tree_code code = gimple_assign_rhs_code (gs);
509 125083 : switch (code)
510 : {
511 0 : case WIDEN_MULT_PLUS_EXPR:
512 0 : case WIDEN_MULT_MINUS_EXPR:
513 0 : for (p = get_tree_code_name (code); *p; p++)
514 0 : pp_character (pp, TOUPPER (*p));
515 0 : pp_string (pp, " <");
516 0 : dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false);
517 0 : pp_string (pp, ", ");
518 0 : dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false);
519 0 : pp_string (pp, ", ");
520 0 : dump_generic_node (pp, gimple_assign_rhs3 (gs), spc, flags, false);
521 0 : pp_greater (pp);
522 0 : break;
523 :
524 3281 : case DOT_PROD_EXPR:
525 3281 : pp_string (pp, "DOT_PROD_EXPR <");
526 3281 : dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false);
527 3281 : pp_string (pp, ", ");
528 6562 : dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false);
529 3281 : pp_string (pp, ", ");
530 6562 : dump_generic_node (pp, gimple_assign_rhs3 (gs), spc, flags, false);
531 3281 : pp_greater (pp);
532 3281 : break;
533 :
534 1261 : case SAD_EXPR:
535 1261 : pp_string (pp, "SAD_EXPR <");
536 1261 : dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false);
537 1261 : pp_string (pp, ", ");
538 2522 : dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false);
539 1261 : pp_string (pp, ", ");
540 2522 : dump_generic_node (pp, gimple_assign_rhs3 (gs), spc, flags, false);
541 1261 : pp_greater (pp);
542 1261 : break;
543 :
544 49714 : case VEC_PERM_EXPR:
545 49714 : if (flags & TDF_GIMPLE)
546 0 : pp_string (pp, "__VEC_PERM (");
547 : else
548 49714 : pp_string (pp, "VEC_PERM_EXPR <");
549 49714 : dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false);
550 49714 : pp_string (pp, ", ");
551 99428 : dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false);
552 49714 : pp_string (pp, ", ");
553 99428 : dump_generic_node (pp, gimple_assign_rhs3 (gs), spc, flags, false);
554 49714 : if (flags & TDF_GIMPLE)
555 0 : pp_right_paren (pp);
556 : else
557 49714 : pp_greater (pp);
558 : break;
559 :
560 0 : case REALIGN_LOAD_EXPR:
561 0 : pp_string (pp, "REALIGN_LOAD <");
562 0 : dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false);
563 0 : pp_string (pp, ", ");
564 0 : dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false);
565 0 : pp_string (pp, ", ");
566 0 : dump_generic_node (pp, gimple_assign_rhs3 (gs), spc, flags, false);
567 0 : pp_greater (pp);
568 0 : break;
569 :
570 61330 : case COND_EXPR:
571 61330 : dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false);
572 61330 : pp_string (pp, " ? ");
573 122660 : dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false);
574 61330 : pp_string (pp, " : ");
575 61330 : dump_generic_node (pp, gimple_assign_rhs3 (gs), spc, flags, false);
576 61330 : break;
577 :
578 8855 : case VEC_COND_EXPR:
579 8855 : pp_string (pp, "VEC_COND_EXPR <");
580 8855 : dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false);
581 8855 : pp_string (pp, ", ");
582 17710 : dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false);
583 8855 : pp_string (pp, ", ");
584 17710 : dump_generic_node (pp, gimple_assign_rhs3 (gs), spc, flags, false);
585 8855 : pp_greater (pp);
586 8855 : break;
587 :
588 642 : case BIT_INSERT_EXPR:
589 642 : if (flags & TDF_GIMPLE)
590 : {
591 0 : pp_string (pp, "__BIT_INSERT (");
592 0 : dump_generic_node (pp, gimple_assign_rhs1 (gs), spc,
593 : flags | TDF_SLIM, false);
594 0 : pp_string (pp, ", ");
595 0 : dump_generic_node (pp, gimple_assign_rhs2 (gs), spc,
596 : flags | TDF_SLIM, false);
597 0 : pp_string (pp, ", ");
598 0 : dump_generic_node (pp, gimple_assign_rhs3 (gs), spc,
599 : flags | TDF_SLIM, false);
600 0 : pp_right_paren (pp);
601 : }
602 : else
603 : {
604 642 : pp_string (pp, "BIT_INSERT_EXPR <");
605 642 : dump_generic_node (pp, gimple_assign_rhs1 (gs),
606 : spc, flags, false);
607 642 : pp_string (pp, ", ");
608 1284 : dump_generic_node (pp, gimple_assign_rhs2 (gs),
609 : spc, flags, false);
610 642 : pp_string (pp, ", ");
611 1284 : dump_generic_node (pp, gimple_assign_rhs3 (gs),
612 : spc, flags, false);
613 1284 : if (INTEGRAL_TYPE_P (TREE_TYPE (gimple_assign_rhs2 (gs))))
614 : {
615 588 : pp_string (pp, " (");
616 1176 : pp_decimal_int (pp, TYPE_PRECISION
617 : (TREE_TYPE (gimple_assign_rhs2 (gs))));
618 588 : pp_string (pp, " bits)");
619 : }
620 642 : pp_greater (pp);
621 : }
622 : break;
623 :
624 0 : default:
625 0 : gcc_unreachable ();
626 : }
627 125083 : }
628 :
629 :
630 : /* Dump the gimple assignment GS. PP, SPC and FLAGS are as in
631 : pp_gimple_stmt_1. */
632 :
633 : static void
634 4643491 : dump_gimple_assign (pretty_printer *pp, const gassign *gs, int spc,
635 : dump_flags_t flags)
636 : {
637 4643491 : if (flags & TDF_RAW)
638 : {
639 1551 : tree arg1 = NULL;
640 1551 : tree arg2 = NULL;
641 1551 : tree arg3 = NULL;
642 1551 : switch (gimple_num_ops (gs))
643 : {
644 67 : case 4:
645 67 : arg3 = gimple_assign_rhs3 (gs);
646 : /* FALLTHRU */
647 842 : case 3:
648 842 : arg2 = gimple_assign_rhs2 (gs);
649 : /* FALLTHRU */
650 1551 : case 2:
651 1551 : arg1 = gimple_assign_rhs1 (gs);
652 1551 : break;
653 0 : default:
654 0 : gcc_unreachable ();
655 : }
656 :
657 2045 : dump_gimple_fmt (pp, spc, flags, "%G <%s, %T, %T, %T, %T>", gs,
658 : get_tree_code_name (gimple_assign_rhs_code (gs)),
659 : gimple_assign_lhs (gs), arg1, arg2, arg3);
660 : }
661 : else
662 : {
663 4641940 : if (!(flags & TDF_RHS_ONLY))
664 : {
665 3870127 : dump_generic_node (pp, gimple_assign_lhs (gs), spc, flags, false);
666 3870127 : pp_space (pp);
667 3870127 : pp_equal (pp);
668 :
669 3870127 : if (gimple_assign_nontemporal_move_p (gs))
670 51 : pp_string (pp, "{nt}");
671 :
672 7740254 : if (gimple_has_volatile_ops (gs))
673 23143 : pp_string (pp, "{v}");
674 :
675 3870127 : pp_space (pp);
676 : }
677 :
678 4641940 : if (gimple_num_ops (gs) == 2)
679 2664324 : dump_unary_rhs (pp, gs, spc,
680 2664277 : ((flags & TDF_GIMPLE)
681 47 : && gimple_assign_rhs_class (gs) != GIMPLE_SINGLE_RHS)
682 2 : ? (flags | TDF_GIMPLE_VAL) : flags);
683 1977663 : else if (gimple_num_ops (gs) == 3)
684 1852581 : dump_binary_rhs (pp, gs, spc,
685 1852580 : (flags & TDF_GIMPLE)
686 1 : ? (flags | TDF_GIMPLE_VAL) : flags);
687 125083 : else if (gimple_num_ops (gs) == 4)
688 125083 : dump_ternary_rhs (pp, gs, spc,
689 125083 : (flags & TDF_GIMPLE)
690 0 : ? (flags | TDF_GIMPLE_VAL) : flags);
691 : else
692 0 : gcc_unreachable ();
693 4641940 : if (!(flags & TDF_RHS_ONLY))
694 3870127 : pp_semicolon (pp);
695 : }
696 4643491 : }
697 :
698 :
699 : /* Dump the return statement GS. PP, SPC and FLAGS are as in
700 : pp_gimple_stmt_1. */
701 :
702 : static void
703 55977 : dump_gimple_return (pretty_printer *pp, const greturn *gs, int spc,
704 : dump_flags_t flags)
705 : {
706 55977 : tree t;
707 :
708 55977 : t = gimple_return_retval (gs);
709 55977 : if (flags & TDF_RAW)
710 469 : dump_gimple_fmt (pp, spc, flags, "%G <%T>", gs, t);
711 : else
712 : {
713 55508 : pp_string (pp, "return");
714 55508 : if (t)
715 : {
716 35287 : pp_space (pp);
717 35287 : dump_generic_node (pp, t, spc, flags, false);
718 : }
719 55508 : pp_semicolon (pp);
720 : }
721 55977 : }
722 :
723 :
724 : /* Dump the call arguments for a gimple call. PP, FLAGS are as in
725 : dump_gimple_call. */
726 :
727 : static void
728 173732 : dump_gimple_call_args (pretty_printer *pp, const gcall *gs,
729 : dump_flags_t flags)
730 : {
731 173732 : size_t i = 0;
732 :
733 : /* Pretty print first arg to certain internal fns. */
734 173732 : if (gimple_call_internal_p (gs))
735 : {
736 56674 : const char *const *enums = NULL;
737 56674 : unsigned limit = 0;
738 :
739 56674 : switch (gimple_call_internal_fn (gs))
740 : {
741 : case IFN_UNIQUE:
742 : #define DEF(X) #X
743 : static const char *const unique_args[] = {IFN_UNIQUE_CODES};
744 : #undef DEF
745 : enums = unique_args;
746 :
747 : limit = ARRAY_SIZE (unique_args);
748 : break;
749 :
750 452 : case IFN_GOACC_LOOP:
751 : #define DEF(X) #X
752 452 : static const char *const loop_args[] = {IFN_GOACC_LOOP_CODES};
753 : #undef DEF
754 452 : enums = loop_args;
755 452 : limit = ARRAY_SIZE (loop_args);
756 452 : break;
757 :
758 24 : case IFN_GOACC_REDUCTION:
759 : #define DEF(X) #X
760 24 : static const char *const reduction_args[]
761 : = {IFN_GOACC_REDUCTION_CODES};
762 : #undef DEF
763 24 : enums = reduction_args;
764 24 : limit = ARRAY_SIZE (reduction_args);
765 24 : break;
766 :
767 192 : case IFN_HWASAN_MARK:
768 192 : case IFN_ASAN_MARK:
769 : #define DEF(X) #X
770 192 : static const char *const asan_mark_args[] = {IFN_ASAN_MARK_FLAGS};
771 : #undef DEF
772 192 : enums = asan_mark_args;
773 192 : limit = ARRAY_SIZE (asan_mark_args);
774 192 : break;
775 :
776 : default:
777 : break;
778 : }
779 668 : if (limit)
780 : {
781 2300 : tree arg0 = gimple_call_arg (gs, 0);
782 2300 : HOST_WIDE_INT v;
783 :
784 2300 : if (TREE_CODE (arg0) == INTEGER_CST
785 2300 : && tree_fits_shwi_p (arg0)
786 4600 : && (v = tree_to_shwi (arg0)) >= 0 && v < limit)
787 : {
788 2300 : i++;
789 2300 : pp_string (pp, enums[v]);
790 : }
791 : }
792 : }
793 :
794 528487 : for (; i < gimple_call_num_args (gs); i++)
795 : {
796 354755 : if (i)
797 220879 : pp_string (pp, ", ");
798 354755 : dump_generic_node (pp, gimple_call_arg (gs, i), 0, flags, false);
799 : }
800 :
801 173732 : if (gimple_call_va_arg_pack_p (gs))
802 : {
803 0 : if (i)
804 0 : pp_string (pp, ", ");
805 :
806 0 : pp_string (pp, "__builtin_va_arg_pack ()");
807 : }
808 173732 : }
809 :
810 : /* Dump the points-to solution *PT to PP. */
811 :
812 : static void
813 2523 : pp_points_to_solution (pretty_printer *pp, const pt_solution *pt)
814 : {
815 2523 : if (pt->anything)
816 : {
817 208 : pp_string (pp, "anything ");
818 208 : return;
819 : }
820 2315 : if (pt->nonlocal)
821 1206 : pp_string (pp, "nonlocal ");
822 2315 : if (pt->escaped)
823 682 : pp_string (pp, "escaped ");
824 2315 : if (pt->ipa_escaped)
825 92 : pp_string (pp, "unit-escaped ");
826 2315 : if (pt->null)
827 1615 : pp_string (pp, "null ");
828 2315 : if (pt->const_pool)
829 37 : pp_string (pp, "const-pool ");
830 2315 : if (pt->vars
831 2315 : && !bitmap_empty_p (pt->vars))
832 : {
833 1368 : bitmap_iterator bi;
834 1368 : unsigned i;
835 1368 : pp_string (pp, "{ ");
836 3403 : EXECUTE_IF_SET_IN_BITMAP (pt->vars, 0, i, bi)
837 : {
838 2035 : pp_string (pp, "D.");
839 2035 : pp_decimal_int (pp, i);
840 2035 : pp_space (pp);
841 : }
842 1368 : pp_right_brace (pp);
843 1368 : if (pt->vars_contains_nonlocal
844 131 : || pt->vars_contains_escaped
845 42 : || pt->vars_contains_escaped_heap
846 36 : || pt->vars_contains_restrict
847 36 : || pt->vars_contains_interposable)
848 : {
849 1332 : const char *comma = "";
850 1332 : pp_string (pp, " (");
851 1332 : if (pt->vars_contains_nonlocal)
852 : {
853 1237 : pp_string (pp, "nonlocal");
854 1237 : comma = ", ";
855 : }
856 1332 : if (pt->vars_contains_escaped)
857 : {
858 572 : pp_string (pp, comma);
859 572 : pp_string (pp, "escaped");
860 572 : comma = ", ";
861 : }
862 1332 : if (pt->vars_contains_escaped_heap)
863 : {
864 326 : pp_string (pp, comma);
865 326 : pp_string (pp, "escaped heap");
866 326 : comma = ", ";
867 : }
868 1332 : if (pt->vars_contains_restrict)
869 : {
870 197 : pp_string (pp, comma);
871 197 : pp_string (pp, "restrict");
872 197 : comma = ", ";
873 : }
874 1332 : if (pt->vars_contains_interposable)
875 : {
876 13 : pp_string (pp, comma);
877 13 : pp_string (pp, "interposable");
878 : }
879 1332 : pp_string (pp, ")");
880 : }
881 :
882 : }
883 : }
884 :
885 : /* Dump the call statement GS. PP, SPC and FLAGS are as in
886 : pp_gimple_stmt_1. */
887 :
888 : static void
889 173773 : dump_gimple_call (pretty_printer *pp, const gcall *gs, int spc,
890 : dump_flags_t flags)
891 : {
892 173773 : tree lhs = gimple_call_lhs (gs);
893 173773 : tree fn = gimple_call_fn (gs);
894 :
895 173773 : if (flags & TDF_ALIAS)
896 : {
897 523 : const pt_solution *pt;
898 523 : pt = gimple_call_use_set (gs);
899 523 : if (!pt_solution_empty_p (pt))
900 : {
901 418 : pp_string (pp, "# USE = ");
902 418 : pp_points_to_solution (pp, pt);
903 418 : newline_and_indent (pp, spc);
904 : }
905 523 : pt = gimple_call_clobber_set (gs);
906 523 : if (!pt_solution_empty_p (pt))
907 : {
908 354 : pp_string (pp, "# CLB = ");
909 354 : pp_points_to_solution (pp, pt);
910 354 : newline_and_indent (pp, spc);
911 : }
912 : }
913 :
914 173773 : if (flags & TDF_RAW)
915 : {
916 257 : if (gimple_call_internal_p (gs))
917 18 : dump_gimple_fmt (pp, spc, flags, "%G <.%s, %T", gs,
918 : internal_fn_name (gimple_call_internal_fn (gs)), lhs);
919 : else
920 239 : dump_gimple_fmt (pp, spc, flags, "%G <%T, %T", gs, fn, lhs);
921 257 : if (gimple_call_num_args (gs) > 0)
922 : {
923 216 : pp_string (pp, ", ");
924 216 : dump_gimple_call_args (pp, gs, flags);
925 : }
926 257 : pp_greater (pp);
927 : }
928 : else
929 : {
930 173516 : if (lhs && !(flags & TDF_RHS_ONLY))
931 : {
932 70518 : dump_generic_node (pp, lhs, spc, flags, false);
933 70518 : pp_string (pp, " =");
934 :
935 141036 : if (gimple_has_volatile_ops (gs))
936 0 : pp_string (pp, "{v}");
937 :
938 70518 : pp_space (pp);
939 : }
940 173516 : if (gimple_call_internal_p (gs))
941 : {
942 56656 : pp_dot (pp);
943 56656 : pp_string (pp, internal_fn_name (gimple_call_internal_fn (gs)));
944 : }
945 : else
946 116860 : print_call_name (pp, fn, flags);
947 173516 : pp_string (pp, " (");
948 173516 : dump_gimple_call_args (pp, gs, flags);
949 173516 : pp_right_paren (pp);
950 173516 : if (!(flags & TDF_RHS_ONLY))
951 161481 : pp_semicolon (pp);
952 : }
953 :
954 173773 : if (gimple_call_chain (gs))
955 : {
956 34 : pp_string (pp, " [static-chain: ");
957 34 : dump_generic_node (pp, gimple_call_chain (gs), spc, flags, false);
958 34 : pp_right_bracket (pp);
959 : }
960 :
961 173773 : if (gimple_call_return_slot_opt_p (gs))
962 116 : pp_string (pp, " [return slot optimization]");
963 173773 : if (gimple_call_tail_p (gs))
964 3084 : pp_string (pp, " [tail call]");
965 173773 : if (gimple_call_must_tail_p (gs))
966 167 : pp_string (pp, " [must tail call]");
967 :
968 173773 : if (fn == NULL)
969 : return;
970 :
971 : /* Dump the arguments of _ITM_beginTransaction sanely. */
972 117099 : if (TREE_CODE (fn) == ADDR_EXPR)
973 112549 : fn = TREE_OPERAND (fn, 0);
974 214209 : if (TREE_CODE (fn) == FUNCTION_DECL && decl_is_tm_clone (fn))
975 29 : pp_string (pp, " [tm-clone]");
976 117099 : if (TREE_CODE (fn) == FUNCTION_DECL
977 112549 : && fndecl_built_in_p (fn, BUILT_IN_TM_START)
978 117239 : && gimple_call_num_args (gs) > 0)
979 : {
980 140 : tree t = gimple_call_arg (gs, 0);
981 140 : unsigned HOST_WIDE_INT props;
982 140 : gcc_assert (TREE_CODE (t) == INTEGER_CST);
983 :
984 140 : pp_string (pp, " [ ");
985 :
986 : /* Get the transaction code properties. */
987 140 : props = TREE_INT_CST_LOW (t);
988 :
989 140 : if (props & PR_INSTRUMENTEDCODE)
990 136 : pp_string (pp, "instrumentedCode ");
991 140 : if (props & PR_UNINSTRUMENTEDCODE)
992 140 : pp_string (pp, "uninstrumentedCode ");
993 140 : if (props & PR_HASNOXMMUPDATE)
994 0 : pp_string (pp, "hasNoXMMUpdate ");
995 140 : if (props & PR_HASNOABORT)
996 128 : pp_string (pp, "hasNoAbort ");
997 140 : if (props & PR_HASNOIRREVOCABLE)
998 129 : pp_string (pp, "hasNoIrrevocable ");
999 140 : if (props & PR_DOESGOIRREVOCABLE)
1000 4 : pp_string (pp, "doesGoIrrevocable ");
1001 140 : if (props & PR_HASNOSIMPLEREADS)
1002 0 : pp_string (pp, "hasNoSimpleReads ");
1003 140 : if (props & PR_AWBARRIERSOMITTED)
1004 0 : pp_string (pp, "awBarriersOmitted ");
1005 140 : if (props & PR_RARBARRIERSOMITTED)
1006 0 : pp_string (pp, "RaRBarriersOmitted ");
1007 140 : if (props & PR_UNDOLOGCODE)
1008 0 : pp_string (pp, "undoLogCode ");
1009 140 : if (props & PR_PREFERUNINSTRUMENTED)
1010 0 : pp_string (pp, "preferUninstrumented ");
1011 140 : if (props & PR_EXCEPTIONBLOCK)
1012 0 : pp_string (pp, "exceptionBlock ");
1013 140 : if (props & PR_HASELSE)
1014 0 : pp_string (pp, "hasElse ");
1015 140 : if (props & PR_READONLY)
1016 71 : pp_string (pp, "readOnly ");
1017 :
1018 140 : pp_right_bracket (pp);
1019 : }
1020 : }
1021 :
1022 :
1023 : /* Dump the switch statement GS. PP, SPC and FLAGS are as in
1024 : pp_gimple_stmt_1. */
1025 :
1026 : static void
1027 1465 : dump_gimple_switch (pretty_printer *pp, const gswitch *gs, int spc,
1028 : dump_flags_t flags)
1029 : {
1030 1465 : unsigned int i;
1031 :
1032 1465 : GIMPLE_CHECK (gs, GIMPLE_SWITCH);
1033 1465 : if (flags & TDF_RAW)
1034 0 : dump_gimple_fmt (pp, spc, flags, "%G <%T, ", gs,
1035 : gimple_switch_index (gs));
1036 : else
1037 : {
1038 1465 : pp_string (pp, "switch (");
1039 1465 : dump_generic_node (pp, gimple_switch_index (gs), spc, flags, true);
1040 1465 : if (flags & TDF_GIMPLE)
1041 0 : pp_string (pp, ") {");
1042 : else
1043 1465 : pp_string (pp, ") <");
1044 : }
1045 :
1046 10072 : for (i = 0; i < gimple_switch_num_labels (gs); i++)
1047 : {
1048 8607 : tree case_label = gimple_switch_label (gs, i);
1049 8607 : gcc_checking_assert (case_label != NULL_TREE);
1050 8607 : dump_generic_node (pp, case_label, spc, flags, false);
1051 8607 : pp_space (pp);
1052 8607 : tree label = CASE_LABEL (case_label);
1053 8607 : dump_generic_node (pp, label, spc, flags, false);
1054 :
1055 8607 : if (cfun && cfun->cfg)
1056 : {
1057 7572 : basic_block dest = label_to_block (cfun, label);
1058 7572 : if (dest)
1059 : {
1060 7560 : edge label_edge = find_edge (gimple_bb (gs), dest);
1061 7560 : if (label_edge && !(flags & TDF_GIMPLE))
1062 7560 : dump_edge_probability (pp, label_edge);
1063 : }
1064 : }
1065 :
1066 8607 : if (i < gimple_switch_num_labels (gs) - 1)
1067 : {
1068 7142 : if (flags & TDF_GIMPLE)
1069 0 : pp_string (pp, "; ");
1070 : else
1071 7142 : pp_string (pp, ", ");
1072 : }
1073 : }
1074 1465 : if (flags & TDF_GIMPLE)
1075 0 : pp_string (pp, "; }");
1076 : else
1077 1465 : pp_greater (pp);
1078 1465 : }
1079 :
1080 :
1081 : /* Dump the gimple conditional GS. PP, SPC and FLAGS are as in
1082 : pp_gimple_stmt_1. */
1083 :
1084 : static void
1085 191226 : dump_gimple_cond (pretty_printer *pp, const gcond *gs, int spc,
1086 : dump_flags_t flags)
1087 : {
1088 191226 : if (flags & TDF_RAW)
1089 145 : dump_gimple_fmt (pp, spc, flags, "%G <%s, %T, %T, %T, %T>", gs,
1090 : get_tree_code_name (gimple_cond_code (gs)),
1091 : gimple_cond_lhs (gs), gimple_cond_rhs (gs),
1092 : gimple_cond_true_label (gs), gimple_cond_false_label (gs));
1093 : else
1094 : {
1095 191081 : if (!(flags & TDF_RHS_ONLY))
1096 189138 : pp_string (pp, "if (");
1097 382162 : dump_generic_node (pp, gimple_cond_lhs (gs), spc,
1098 191081 : flags | ((flags & TDF_GIMPLE) ? TDF_GIMPLE_VAL : TDF_NONE),
1099 : false);
1100 191081 : pp_space (pp);
1101 191081 : pp_string (pp, op_symbol_code (gimple_cond_code (gs), flags));
1102 191081 : pp_space (pp);
1103 191081 : dump_generic_node (pp, gimple_cond_rhs (gs), spc,
1104 191081 : flags | ((flags & TDF_GIMPLE) ? TDF_GIMPLE_VAL : TDF_NONE),
1105 : false);
1106 191081 : if (!(flags & TDF_RHS_ONLY))
1107 : {
1108 189138 : edge_iterator ei;
1109 189138 : edge e, true_edge = NULL, false_edge = NULL;
1110 189138 : basic_block bb = gimple_bb (gs);
1111 :
1112 189138 : if (bb)
1113 : {
1114 536876 : FOR_EACH_EDGE (e, ei, bb->succs)
1115 : {
1116 357823 : if (e->flags & EDGE_TRUE_VALUE)
1117 : true_edge = e;
1118 178903 : else if (e->flags & EDGE_FALSE_VALUE)
1119 178903 : false_edge = e;
1120 : }
1121 : }
1122 :
1123 189138 : bool has_edge_info = true_edge != NULL && false_edge != NULL;
1124 :
1125 189138 : pp_right_paren (pp);
1126 :
1127 189138 : if (gimple_cond_true_label (gs))
1128 : {
1129 6487 : pp_string (pp, " goto ");
1130 6487 : dump_generic_node (pp, gimple_cond_true_label (gs),
1131 : spc, flags, false);
1132 6487 : if (has_edge_info && !(flags & TDF_GIMPLE))
1133 0 : dump_edge_probability (pp, true_edge);
1134 6487 : pp_semicolon (pp);
1135 : }
1136 189138 : if (gimple_cond_false_label (gs))
1137 : {
1138 6487 : pp_string (pp, " else goto ");
1139 6487 : dump_generic_node (pp, gimple_cond_false_label (gs),
1140 : spc, flags, false);
1141 6487 : if (has_edge_info && !(flags & TDF_GIMPLE))
1142 0 : dump_edge_probability (pp, false_edge);
1143 :
1144 6487 : pp_semicolon (pp);
1145 : }
1146 : }
1147 : }
1148 191226 : }
1149 :
1150 :
1151 : /* Dump a GIMPLE_LABEL tuple on the pretty_printer PP, SPC
1152 : spaces of indent. FLAGS specifies details to show in the dump (see
1153 : TDF_* in dumpfils.h). */
1154 :
1155 : static void
1156 36677 : dump_gimple_label (pretty_printer *pp, const glabel *gs, int spc,
1157 : dump_flags_t flags)
1158 : {
1159 36677 : tree label = gimple_label_label (gs);
1160 36677 : if (flags & TDF_RAW)
1161 47 : dump_gimple_fmt (pp, spc, flags, "%G <%T>", gs, label);
1162 : else
1163 : {
1164 36630 : dump_generic_node (pp, label, spc, flags, false);
1165 36630 : pp_colon (pp);
1166 : }
1167 36677 : if (flags & TDF_GIMPLE)
1168 : return;
1169 36639 : if (DECL_NONLOCAL (label))
1170 3 : pp_string (pp, " [non-local]");
1171 36906 : if ((flags & TDF_EH) && EH_LANDING_PAD_NR (label))
1172 25 : pp_printf (pp, " [LP %d]", EH_LANDING_PAD_NR (label));
1173 : }
1174 :
1175 : /* Dump a GIMPLE_GOTO tuple on the pretty_printer PP, SPC
1176 : spaces of indent. FLAGS specifies details to show in the dump (see
1177 : TDF_* in dumpfile.h). */
1178 :
1179 : static void
1180 4278 : dump_gimple_goto (pretty_printer *pp, const ggoto *gs, int spc,
1181 : dump_flags_t flags)
1182 : {
1183 4278 : tree label = gimple_goto_dest (gs);
1184 4278 : if (flags & TDF_RAW)
1185 4 : dump_gimple_fmt (pp, spc, flags, "%G <%T>", gs, label);
1186 : else
1187 4274 : dump_gimple_fmt (pp, spc, flags, "goto %T;", label);
1188 4278 : }
1189 :
1190 :
1191 : /* Dump a GIMPLE_BIND tuple on the pretty_printer PP, SPC
1192 : spaces of indent. FLAGS specifies details to show in the dump (see
1193 : TDF_* in dumpfile.h). */
1194 :
1195 : static void
1196 17822 : dump_gimple_bind (pretty_printer *pp, const gbind *gs, int spc,
1197 : dump_flags_t flags)
1198 : {
1199 17822 : if (flags & TDF_RAW)
1200 7 : dump_gimple_fmt (pp, spc, flags, "%G <", gs);
1201 : else
1202 17815 : pp_left_brace (pp);
1203 17822 : if (!(flags & TDF_SLIM))
1204 : {
1205 17818 : tree var;
1206 :
1207 43506 : for (var = gimple_bind_vars (gs); var; var = DECL_CHAIN (var))
1208 : {
1209 25688 : newline_and_indent (pp, 2);
1210 25688 : print_declaration (pp, var, spc, flags);
1211 : }
1212 17818 : if (gimple_bind_vars (gs))
1213 9991 : pp_newline (pp);
1214 : }
1215 17822 : pp_newline (pp);
1216 17822 : dump_gimple_seq (pp, gimple_bind_body (gs), spc + 2, flags);
1217 17822 : newline_and_indent (pp, spc);
1218 17822 : if (flags & TDF_RAW)
1219 7 : pp_greater (pp);
1220 : else
1221 17815 : pp_right_brace (pp);
1222 17822 : }
1223 :
1224 :
1225 : /* Dump a GIMPLE_TRY tuple on the pretty_printer PP, SPC spaces of
1226 : indent. FLAGS specifies details to show in the dump (see TDF_* in
1227 : dumpfile.h). */
1228 :
1229 : static void
1230 4059 : dump_gimple_try (pretty_printer *pp, const gtry *gs, int spc,
1231 : dump_flags_t flags)
1232 : {
1233 4059 : if (flags & TDF_RAW)
1234 : {
1235 0 : const char *type;
1236 0 : if (gimple_try_kind (gs) == GIMPLE_TRY_CATCH)
1237 : type = "GIMPLE_TRY_CATCH";
1238 0 : else if (gimple_try_kind (gs) == GIMPLE_TRY_FINALLY)
1239 : type = "GIMPLE_TRY_FINALLY";
1240 : else
1241 0 : type = "UNKNOWN GIMPLE_TRY";
1242 0 : dump_gimple_fmt (pp, spc, flags,
1243 : "%G <%s,%+EVAL <%S>%nCLEANUP <%S>%->", gs, type,
1244 : gimple_try_eval (gs), gimple_try_cleanup (gs));
1245 : }
1246 : else
1247 : {
1248 4059 : pp_string (pp, "try");
1249 4059 : newline_and_indent (pp, spc + 2);
1250 4059 : pp_left_brace (pp);
1251 4059 : pp_newline (pp);
1252 :
1253 4059 : dump_gimple_seq (pp, gimple_try_eval (gs), spc + 4, flags);
1254 4059 : newline_and_indent (pp, spc + 2);
1255 4059 : pp_right_brace (pp);
1256 :
1257 4059 : gimple_seq seq = gimple_try_cleanup (gs);
1258 :
1259 4059 : if (gimple_try_kind (gs) == GIMPLE_TRY_CATCH)
1260 : {
1261 958 : newline_and_indent (pp, spc);
1262 958 : pp_string (pp, "catch");
1263 958 : newline_and_indent (pp, spc + 2);
1264 958 : pp_left_brace (pp);
1265 : }
1266 3101 : else if (gimple_try_kind (gs) == GIMPLE_TRY_FINALLY)
1267 : {
1268 3101 : newline_and_indent (pp, spc);
1269 3101 : pp_string (pp, "finally");
1270 3101 : newline_and_indent (pp, spc + 2);
1271 3101 : pp_left_brace (pp);
1272 :
1273 3101 : if (seq && is_a <geh_else *> (gimple_seq_first_stmt (seq))
1274 3215 : && gimple_seq_nondebug_singleton_p (seq))
1275 : {
1276 114 : geh_else *stmt = as_a <geh_else *> (gimple_seq_first_stmt (seq));
1277 114 : seq = gimple_eh_else_n_body (stmt);
1278 114 : pp_newline (pp);
1279 114 : dump_gimple_seq (pp, seq, spc + 4, flags);
1280 114 : newline_and_indent (pp, spc + 2);
1281 114 : pp_right_brace (pp);
1282 114 : seq = gimple_eh_else_e_body (stmt);
1283 114 : newline_and_indent (pp, spc);
1284 114 : pp_string (pp, "else");
1285 114 : newline_and_indent (pp, spc + 2);
1286 114 : pp_left_brace (pp);
1287 : }
1288 : }
1289 : else
1290 0 : pp_string (pp, " <UNKNOWN GIMPLE_TRY> {");
1291 :
1292 4059 : pp_newline (pp);
1293 4059 : dump_gimple_seq (pp, seq, spc + 4, flags);
1294 4059 : newline_and_indent (pp, spc + 2);
1295 4059 : pp_right_brace (pp);
1296 : }
1297 4059 : }
1298 :
1299 :
1300 : /* Dump a GIMPLE_CATCH tuple on the pretty_printer PP, SPC spaces of
1301 : indent. FLAGS specifies details to show in the dump (see TDF_* in
1302 : dumpfile.h). */
1303 :
1304 : static void
1305 0 : dump_gimple_catch (pretty_printer *pp, const gcatch *gs, int spc,
1306 : dump_flags_t flags)
1307 : {
1308 0 : if (flags & TDF_RAW)
1309 0 : dump_gimple_fmt (pp, spc, flags, "%G <%T, %+CATCH <%S>%->", gs,
1310 : gimple_catch_types (gs), gimple_catch_handler (gs));
1311 : else
1312 0 : dump_gimple_fmt (pp, spc, flags, "catch (%T)%+{%S}",
1313 : gimple_catch_types (gs), gimple_catch_handler (gs));
1314 0 : }
1315 :
1316 :
1317 : /* Dump a GIMPLE_EH_FILTER tuple on the pretty_printer PP, SPC spaces of
1318 : indent. FLAGS specifies details to show in the dump (see TDF_* in
1319 : dumpfile.h). */
1320 :
1321 : static void
1322 12 : dump_gimple_eh_filter (pretty_printer *pp, const geh_filter *gs, int spc,
1323 : dump_flags_t flags)
1324 : {
1325 12 : if (flags & TDF_RAW)
1326 0 : dump_gimple_fmt (pp, spc, flags, "%G <%T, %+FAILURE <%S>%->", gs,
1327 : gimple_eh_filter_types (gs),
1328 : gimple_eh_filter_failure (gs));
1329 : else
1330 12 : dump_gimple_fmt (pp, spc, flags, "<<<eh_filter (%T)>>>%+{%+%S%-}",
1331 : gimple_eh_filter_types (gs),
1332 : gimple_eh_filter_failure (gs));
1333 12 : }
1334 :
1335 :
1336 : /* Dump a GIMPLE_EH_MUST_NOT_THROW tuple. */
1337 :
1338 : static void
1339 808 : dump_gimple_eh_must_not_throw (pretty_printer *pp,
1340 : const geh_mnt *gs, int spc, dump_flags_t flags)
1341 : {
1342 808 : if (flags & TDF_RAW)
1343 0 : dump_gimple_fmt (pp, spc, flags, "%G <%T>", gs,
1344 : gimple_eh_must_not_throw_fndecl (gs));
1345 : else
1346 808 : dump_gimple_fmt (pp, spc, flags, "<<<eh_must_not_throw (%T)>>>",
1347 : gimple_eh_must_not_throw_fndecl (gs));
1348 808 : }
1349 :
1350 :
1351 : /* Dump a GIMPLE_EH_ELSE tuple on the pretty_printer PP, SPC spaces of
1352 : indent. FLAGS specifies details to show in the dump (see TDF_* in
1353 : dumpfile.h). */
1354 :
1355 : static void
1356 0 : dump_gimple_eh_else (pretty_printer *pp, const geh_else *gs, int spc,
1357 : dump_flags_t flags)
1358 : {
1359 0 : if (flags & TDF_RAW)
1360 0 : dump_gimple_fmt (pp, spc, flags,
1361 : "%G <%+N_BODY <%S>%nE_BODY <%S>%->", gs,
1362 : gimple_eh_else_n_body (gs), gimple_eh_else_e_body (gs));
1363 : else
1364 0 : dump_gimple_fmt (pp, spc, flags,
1365 : "<<<if_normal_exit>>>%+{%S}%-<<<else_eh_exit>>>%+{%S}",
1366 : gimple_eh_else_n_body (gs), gimple_eh_else_e_body (gs));
1367 0 : }
1368 :
1369 :
1370 : /* Dump a GIMPLE_RESX tuple on the pretty_printer PP, SPC spaces of
1371 : indent. FLAGS specifies details to show in the dump (see TDF_* in
1372 : dumpfile.h). */
1373 :
1374 : static void
1375 1677 : dump_gimple_resx (pretty_printer *pp, const gresx *gs, int spc,
1376 : dump_flags_t flags)
1377 : {
1378 1677 : if (flags & TDF_RAW)
1379 0 : dump_gimple_fmt (pp, spc, flags, "%G <%d>", gs,
1380 : gimple_resx_region (gs));
1381 : else
1382 1677 : dump_gimple_fmt (pp, spc, flags, "resx %d", gimple_resx_region (gs));
1383 1677 : }
1384 :
1385 : /* Dump a GIMPLE_EH_DISPATCH tuple on the pretty_printer PP. */
1386 :
1387 : static void
1388 30 : dump_gimple_eh_dispatch (pretty_printer *pp, const geh_dispatch *gs,
1389 : int spc, dump_flags_t flags)
1390 : {
1391 30 : if (flags & TDF_RAW)
1392 0 : dump_gimple_fmt (pp, spc, flags, "%G <%d>", gs,
1393 : gimple_eh_dispatch_region (gs));
1394 : else
1395 30 : dump_gimple_fmt (pp, spc, flags, "eh_dispatch %d",
1396 : gimple_eh_dispatch_region (gs));
1397 30 : }
1398 :
1399 : /* Dump a GIMPLE_DEBUG tuple on the pretty_printer PP, SPC spaces
1400 : of indent. FLAGS specifies details to show in the dump (see TDF_*
1401 : in dumpfile.h). */
1402 :
1403 : static void
1404 35126 : dump_gimple_debug (pretty_printer *pp, const gdebug *gs, int spc,
1405 : dump_flags_t flags)
1406 : {
1407 35126 : switch (gs->subcode)
1408 : {
1409 18466 : case GIMPLE_DEBUG_BIND:
1410 18466 : if (flags & TDF_RAW)
1411 0 : dump_gimple_fmt (pp, spc, flags, "%G BIND <%T, %T>", gs,
1412 : gimple_debug_bind_get_var (gs),
1413 : gimple_debug_bind_get_value (gs));
1414 : else
1415 18466 : dump_gimple_fmt (pp, spc, flags, "# DEBUG %T => %T",
1416 : gimple_debug_bind_get_var (gs),
1417 : gimple_debug_bind_get_value (gs));
1418 : break;
1419 :
1420 6 : case GIMPLE_DEBUG_SOURCE_BIND:
1421 6 : if (flags & TDF_RAW)
1422 0 : dump_gimple_fmt (pp, spc, flags, "%G SRCBIND <%T, %T>", gs,
1423 : gimple_debug_source_bind_get_var (gs),
1424 : gimple_debug_source_bind_get_value (gs));
1425 : else
1426 6 : dump_gimple_fmt (pp, spc, flags, "# DEBUG %T s=> %T",
1427 : gimple_debug_source_bind_get_var (gs),
1428 : gimple_debug_source_bind_get_value (gs));
1429 : break;
1430 :
1431 16403 : case GIMPLE_DEBUG_BEGIN_STMT:
1432 16403 : if (flags & TDF_RAW)
1433 0 : dump_gimple_fmt (pp, spc, flags, "%G BEGIN_STMT", gs);
1434 : else
1435 16403 : dump_gimple_fmt (pp, spc, flags, "# DEBUG BEGIN_STMT");
1436 : break;
1437 :
1438 251 : case GIMPLE_DEBUG_INLINE_ENTRY:
1439 251 : if (flags & TDF_RAW)
1440 0 : dump_gimple_fmt (pp, spc, flags, "%G INLINE_ENTRY %T", gs,
1441 0 : gimple_block (gs)
1442 0 : ? block_ultimate_origin (gimple_block (gs))
1443 : : NULL_TREE);
1444 : else
1445 502 : dump_gimple_fmt (pp, spc, flags, "# DEBUG INLINE_ENTRY %T",
1446 251 : gimple_block (gs)
1447 251 : ? block_ultimate_origin (gimple_block (gs))
1448 : : NULL_TREE);
1449 : break;
1450 :
1451 0 : default:
1452 0 : gcc_unreachable ();
1453 : }
1454 35126 : }
1455 :
1456 : /* Dump a GIMPLE_OMP_FOR tuple on the pretty_printer PP. */
1457 : static void
1458 3343 : dump_gimple_omp_for (pretty_printer *pp, const gomp_for *gs, int spc,
1459 : dump_flags_t flags)
1460 : {
1461 3343 : size_t i;
1462 :
1463 3343 : if (flags & TDF_RAW)
1464 : {
1465 0 : const char *kind;
1466 0 : switch (gimple_omp_for_kind (gs))
1467 : {
1468 : case GF_OMP_FOR_KIND_FOR:
1469 : kind = "";
1470 : break;
1471 0 : case GF_OMP_FOR_KIND_DISTRIBUTE:
1472 0 : kind = " distribute";
1473 0 : break;
1474 0 : case GF_OMP_FOR_KIND_TASKLOOP:
1475 0 : kind = " taskloop";
1476 0 : break;
1477 0 : case GF_OMP_FOR_KIND_OACC_LOOP:
1478 0 : kind = " oacc_loop";
1479 0 : break;
1480 0 : case GF_OMP_FOR_KIND_SIMD:
1481 0 : kind = " simd";
1482 0 : break;
1483 0 : default:
1484 0 : gcc_unreachable ();
1485 : }
1486 0 : dump_gimple_fmt (pp, spc, flags, "%G%s <%+BODY <%S>%nCLAUSES <", gs,
1487 : kind, gimple_omp_body (gs));
1488 0 : dump_omp_clauses (pp, gimple_omp_for_clauses (gs), spc, flags);
1489 0 : dump_gimple_fmt (pp, spc, flags, " >,");
1490 0 : for (i = 0; i < gimple_omp_for_collapse (gs); i++)
1491 0 : dump_gimple_fmt (pp, spc, flags,
1492 : "%+%T, %T, %T, %s, %T,%n",
1493 : gimple_omp_for_index (gs, i),
1494 : gimple_omp_for_initial (gs, i),
1495 : gimple_omp_for_final (gs, i),
1496 : get_tree_code_name (gimple_omp_for_cond (gs, i)),
1497 : gimple_omp_for_incr (gs, i));
1498 0 : dump_gimple_fmt (pp, spc, flags, "PRE_BODY <%S>%->",
1499 : gimple_omp_for_pre_body (gs));
1500 : }
1501 : else
1502 : {
1503 3343 : switch (gimple_omp_for_kind (gs))
1504 : {
1505 801 : case GF_OMP_FOR_KIND_FOR:
1506 801 : pp_string (pp, "#pragma omp for");
1507 801 : break;
1508 456 : case GF_OMP_FOR_KIND_DISTRIBUTE:
1509 456 : pp_string (pp, "#pragma omp distribute");
1510 456 : break;
1511 480 : case GF_OMP_FOR_KIND_TASKLOOP:
1512 480 : pp_string (pp, "#pragma omp taskloop");
1513 480 : break;
1514 744 : case GF_OMP_FOR_KIND_OACC_LOOP:
1515 744 : pp_string (pp, "#pragma acc loop");
1516 744 : break;
1517 862 : case GF_OMP_FOR_KIND_SIMD:
1518 862 : pp_string (pp, "#pragma omp simd");
1519 862 : break;
1520 0 : default:
1521 0 : gcc_unreachable ();
1522 : }
1523 3343 : dump_omp_clauses (pp, gimple_omp_for_clauses (gs), spc, flags);
1524 6979 : for (i = 0; i < gimple_omp_for_collapse (gs); i++)
1525 : {
1526 3636 : if (i)
1527 293 : spc += 2;
1528 3636 : newline_and_indent (pp, spc);
1529 3636 : pp_string (pp, "for (");
1530 3636 : dump_generic_node (pp, gimple_omp_for_index (gs, i), spc,
1531 : flags, false);
1532 3636 : pp_string (pp, " = ");
1533 3636 : tree init = gimple_omp_for_initial (gs, i);
1534 3636 : if (TREE_CODE (init) != TREE_VEC)
1535 3636 : dump_generic_node (pp, init, spc, flags, false);
1536 : else
1537 0 : dump_omp_loop_non_rect_expr (pp, init, spc, flags);
1538 3636 : pp_string (pp, "; ");
1539 :
1540 3636 : dump_generic_node (pp, gimple_omp_for_index (gs, i), spc,
1541 : flags, false);
1542 3636 : pp_space (pp);
1543 3636 : switch (gimple_omp_for_cond (gs, i))
1544 : {
1545 2995 : case LT_EXPR:
1546 2995 : pp_less (pp);
1547 2995 : break;
1548 8 : case GT_EXPR:
1549 8 : pp_greater (pp);
1550 8 : break;
1551 633 : case LE_EXPR:
1552 633 : pp_less_equal (pp);
1553 633 : break;
1554 0 : case GE_EXPR:
1555 0 : pp_greater_equal (pp);
1556 0 : break;
1557 0 : case NE_EXPR:
1558 0 : pp_string (pp, "!=");
1559 0 : break;
1560 0 : default:
1561 0 : gcc_unreachable ();
1562 : }
1563 3636 : pp_space (pp);
1564 3636 : tree cond = gimple_omp_for_final (gs, i);
1565 3636 : if (TREE_CODE (cond) != TREE_VEC)
1566 3636 : dump_generic_node (pp, cond, spc, flags, false);
1567 : else
1568 0 : dump_omp_loop_non_rect_expr (pp, cond, spc, flags);
1569 3636 : pp_string (pp, "; ");
1570 :
1571 3636 : dump_generic_node (pp, gimple_omp_for_index (gs, i), spc,
1572 : flags, false);
1573 3636 : pp_string (pp, " = ");
1574 3636 : dump_generic_node (pp, gimple_omp_for_incr (gs, i), spc,
1575 : flags, false);
1576 3636 : pp_right_paren (pp);
1577 : }
1578 :
1579 3343 : if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1580 : {
1581 2910 : newline_and_indent (pp, spc + 2);
1582 2910 : pp_left_brace (pp);
1583 2910 : pp_newline (pp);
1584 2910 : dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags);
1585 2910 : newline_and_indent (pp, spc + 2);
1586 2910 : pp_right_brace (pp);
1587 : }
1588 : }
1589 3343 : }
1590 :
1591 : /* Dump a GIMPLE_OMP_CONTINUE tuple on the pretty_printer PP. */
1592 :
1593 : static void
1594 292 : dump_gimple_omp_continue (pretty_printer *pp, const gomp_continue *gs,
1595 : int spc, dump_flags_t flags)
1596 : {
1597 292 : if (flags & TDF_RAW)
1598 : {
1599 0 : dump_gimple_fmt (pp, spc, flags, "%G <%T, %T>", gs,
1600 : gimple_omp_continue_control_def (gs),
1601 : gimple_omp_continue_control_use (gs));
1602 : }
1603 : else
1604 : {
1605 292 : pp_string (pp, "#pragma omp continue (");
1606 292 : dump_generic_node (pp, gimple_omp_continue_control_def (gs),
1607 : spc, flags, false);
1608 292 : pp_comma (pp);
1609 292 : pp_space (pp);
1610 292 : dump_generic_node (pp, gimple_omp_continue_control_use (gs),
1611 : spc, flags, false);
1612 292 : pp_right_paren (pp);
1613 : }
1614 292 : }
1615 :
1616 : /* Dump a GIMPLE_OMP_SINGLE tuple on the pretty_printer PP. */
1617 :
1618 : static void
1619 29 : dump_gimple_omp_single (pretty_printer *pp, const gomp_single *gs,
1620 : int spc, dump_flags_t flags)
1621 : {
1622 29 : if (flags & TDF_RAW)
1623 : {
1624 0 : dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
1625 : gimple_omp_body (gs));
1626 0 : dump_omp_clauses (pp, gimple_omp_single_clauses (gs), spc, flags);
1627 0 : dump_gimple_fmt (pp, spc, flags, " >");
1628 : }
1629 : else
1630 : {
1631 29 : pp_string (pp, "#pragma omp single");
1632 29 : dump_omp_clauses (pp, gimple_omp_single_clauses (gs), spc, flags);
1633 29 : if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1634 : {
1635 25 : newline_and_indent (pp, spc + 2);
1636 25 : pp_left_brace (pp);
1637 25 : pp_newline (pp);
1638 25 : dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags);
1639 25 : newline_and_indent (pp, spc + 2);
1640 25 : pp_right_brace (pp);
1641 : }
1642 : }
1643 29 : }
1644 :
1645 : /* Dump a GIMPLE_OMP_TASKGROUP tuple on the pretty_printer PP. */
1646 :
1647 : static void
1648 0 : dump_gimple_omp_taskgroup (pretty_printer *pp, const gimple *gs,
1649 : int spc, dump_flags_t flags)
1650 : {
1651 0 : if (flags & TDF_RAW)
1652 : {
1653 0 : dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
1654 : gimple_omp_body (gs));
1655 0 : dump_omp_clauses (pp, gimple_omp_taskgroup_clauses (gs), spc, flags);
1656 0 : dump_gimple_fmt (pp, spc, flags, " >");
1657 : }
1658 : else
1659 : {
1660 0 : pp_string (pp, "#pragma omp taskgroup");
1661 0 : dump_omp_clauses (pp, gimple_omp_taskgroup_clauses (gs), spc, flags);
1662 0 : if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1663 : {
1664 0 : newline_and_indent (pp, spc + 2);
1665 0 : pp_left_brace (pp);
1666 0 : pp_newline (pp);
1667 0 : dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags);
1668 0 : newline_and_indent (pp, spc + 2);
1669 0 : pp_right_brace (pp);
1670 : }
1671 : }
1672 0 : }
1673 :
1674 : /* Dump a GIMPLE_OMP_MASKED tuple on the pretty_printer PP. */
1675 :
1676 : static void
1677 6 : dump_gimple_omp_masked (pretty_printer *pp, const gimple *gs,
1678 : int spc, dump_flags_t flags)
1679 : {
1680 6 : if (flags & TDF_RAW)
1681 : {
1682 0 : dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
1683 : gimple_omp_body (gs));
1684 0 : dump_omp_clauses (pp, gimple_omp_masked_clauses (gs), spc, flags);
1685 0 : dump_gimple_fmt (pp, spc, flags, " >");
1686 : }
1687 : else
1688 : {
1689 6 : pp_string (pp, "#pragma omp masked");
1690 6 : dump_omp_clauses (pp, gimple_omp_masked_clauses (gs), spc, flags);
1691 6 : if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1692 : {
1693 6 : newline_and_indent (pp, spc + 2);
1694 6 : pp_left_brace (pp);
1695 6 : pp_newline (pp);
1696 6 : dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags);
1697 6 : newline_and_indent (pp, spc + 2);
1698 6 : pp_right_brace (pp);
1699 : }
1700 : }
1701 6 : }
1702 :
1703 : /* Dump a GIMPLE_OMP_SCOPE tuple on the pretty_printer PP. */
1704 :
1705 : static void
1706 0 : dump_gimple_omp_scope (pretty_printer *pp, const gimple *gs,
1707 : int spc, dump_flags_t flags)
1708 : {
1709 0 : if (flags & TDF_RAW)
1710 : {
1711 0 : dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
1712 : gimple_omp_body (gs));
1713 0 : dump_omp_clauses (pp, gimple_omp_scope_clauses (gs), spc, flags);
1714 0 : dump_gimple_fmt (pp, spc, flags, " >");
1715 : }
1716 : else
1717 : {
1718 0 : pp_string (pp, "#pragma omp scope");
1719 0 : dump_omp_clauses (pp, gimple_omp_scope_clauses (gs), spc, flags);
1720 0 : if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1721 : {
1722 0 : newline_and_indent (pp, spc + 2);
1723 0 : pp_left_brace (pp);
1724 0 : pp_newline (pp);
1725 0 : dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags);
1726 0 : newline_and_indent (pp, spc + 2);
1727 0 : pp_right_brace (pp);
1728 : }
1729 : }
1730 0 : }
1731 :
1732 : /* Dump a GIMPLE_OMP_DISPATCH tuple on the pretty_printer BUFFER. */
1733 :
1734 : static void
1735 401 : dump_gimple_omp_dispatch (pretty_printer *buffer, const gimple *gs, int spc,
1736 : dump_flags_t flags)
1737 : {
1738 401 : if (flags & TDF_RAW)
1739 : {
1740 0 : dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
1741 : gimple_omp_body (gs));
1742 0 : dump_omp_clauses (buffer, gimple_omp_dispatch_clauses (gs), spc, flags);
1743 0 : dump_gimple_fmt (buffer, spc, flags, " >");
1744 : }
1745 : else
1746 : {
1747 401 : pp_string (buffer, "#pragma omp dispatch");
1748 401 : dump_omp_clauses (buffer, gimple_omp_dispatch_clauses (gs), spc, flags);
1749 401 : if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1750 : {
1751 401 : newline_and_indent (buffer, spc + 2);
1752 401 : pp_left_brace (buffer);
1753 401 : pp_newline (buffer);
1754 401 : dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
1755 401 : newline_and_indent (buffer, spc + 2);
1756 401 : pp_right_brace (buffer);
1757 : }
1758 : }
1759 401 : }
1760 :
1761 : /* Dump a GIMPLE_OMP_INTEROP tuple on the pretty_printer BUFFER. */
1762 :
1763 : static void
1764 0 : dump_gimple_omp_interop (pretty_printer *buffer, const gimple *gs, int spc,
1765 : dump_flags_t flags)
1766 : {
1767 0 : if (flags & TDF_RAW)
1768 : {
1769 0 : dump_gimple_fmt (buffer, spc, flags, "%G <CLAUSES <", gs);
1770 0 : dump_omp_clauses (buffer, gimple_omp_interop_clauses (gs), spc, flags);
1771 0 : dump_gimple_fmt (buffer, spc, flags, " >");
1772 : }
1773 : else
1774 : {
1775 0 : pp_string (buffer, "#pragma omp interop");
1776 0 : dump_omp_clauses (buffer, gimple_omp_interop_clauses (gs), spc, flags);
1777 : }
1778 0 : }
1779 :
1780 : /* Dump a GIMPLE_OMP_TARGET tuple on the pretty_printer PP. */
1781 :
1782 : static void
1783 2358 : dump_gimple_omp_target (pretty_printer *pp, const gomp_target *gs,
1784 : int spc, dump_flags_t flags)
1785 : {
1786 2358 : const char *kind;
1787 2358 : switch (gimple_omp_target_kind (gs))
1788 : {
1789 : case GF_OMP_TARGET_KIND_REGION:
1790 : kind = "";
1791 : break;
1792 49 : case GF_OMP_TARGET_KIND_DATA:
1793 49 : kind = " data";
1794 49 : break;
1795 35 : case GF_OMP_TARGET_KIND_UPDATE:
1796 35 : kind = " update";
1797 35 : break;
1798 89 : case GF_OMP_TARGET_KIND_ENTER_DATA:
1799 89 : kind = " enter data";
1800 89 : break;
1801 57 : case GF_OMP_TARGET_KIND_EXIT_DATA:
1802 57 : kind = " exit data";
1803 57 : break;
1804 175 : case GF_OMP_TARGET_KIND_OACC_KERNELS:
1805 175 : kind = " oacc_kernels";
1806 175 : break;
1807 403 : case GF_OMP_TARGET_KIND_OACC_PARALLEL:
1808 403 : kind = " oacc_parallel";
1809 403 : break;
1810 234 : case GF_OMP_TARGET_KIND_OACC_SERIAL:
1811 234 : kind = " oacc_serial";
1812 234 : break;
1813 88 : case GF_OMP_TARGET_KIND_OACC_DATA:
1814 88 : kind = " oacc_data";
1815 88 : break;
1816 48 : case GF_OMP_TARGET_KIND_OACC_UPDATE:
1817 48 : kind = " oacc_update";
1818 48 : break;
1819 37 : case GF_OMP_TARGET_KIND_OACC_ENTER_DATA:
1820 37 : kind = " oacc_enter_data";
1821 37 : break;
1822 51 : case GF_OMP_TARGET_KIND_OACC_EXIT_DATA:
1823 51 : kind = " oacc_exit_data";
1824 51 : break;
1825 16 : case GF_OMP_TARGET_KIND_OACC_DECLARE:
1826 16 : kind = " oacc_declare";
1827 16 : break;
1828 35 : case GF_OMP_TARGET_KIND_OACC_HOST_DATA:
1829 35 : kind = " oacc_host_data";
1830 35 : break;
1831 5 : case GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_PARALLELIZED:
1832 5 : kind = " oacc_parallel_kernels_parallelized";
1833 5 : break;
1834 18 : case GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_GANG_SINGLE:
1835 18 : kind = " oacc_parallel_kernels_gang_single";
1836 18 : break;
1837 19 : case GF_OMP_TARGET_KIND_OACC_DATA_KERNELS:
1838 19 : kind = " oacc_data_kernels";
1839 19 : break;
1840 0 : default:
1841 0 : gcc_unreachable ();
1842 : }
1843 2358 : if (gimple_omp_target_iterator_loops (gs))
1844 : {
1845 42 : pp_string (pp, "// Expanded iterator loops for #pragma omp target\n");
1846 42 : dump_gimple_seq (pp, gimple_omp_target_iterator_loops (gs), spc, flags);
1847 42 : pp_newline (pp);
1848 : }
1849 2358 : if (flags & TDF_RAW)
1850 : {
1851 0 : dump_gimple_fmt (pp, spc, flags, "%G%s <%+BODY <%S>%nCLAUSES <", gs,
1852 : kind, gimple_omp_body (gs));
1853 0 : dump_omp_clauses (pp, gimple_omp_target_clauses (gs), spc, flags);
1854 0 : dump_gimple_fmt (pp, spc, flags, " >, %T, %T%n>",
1855 : gimple_omp_target_child_fn (gs),
1856 : gimple_omp_target_data_arg (gs));
1857 : }
1858 : else
1859 : {
1860 2358 : pp_string (pp, "#pragma omp target");
1861 2358 : pp_string (pp, kind);
1862 2358 : dump_omp_clauses (pp, gimple_omp_target_clauses (gs), spc, flags);
1863 2358 : if (gimple_omp_target_child_fn (gs))
1864 : {
1865 172 : pp_string (pp, " [child fn: ");
1866 172 : dump_generic_node (pp, gimple_omp_target_child_fn (gs),
1867 : spc, flags, false);
1868 172 : pp_string (pp, " (");
1869 172 : if (gimple_omp_target_data_arg (gs))
1870 148 : dump_generic_node (pp, gimple_omp_target_data_arg (gs),
1871 : spc, flags, false);
1872 : else
1873 24 : pp_string (pp, "???");
1874 172 : pp_string (pp, ")]");
1875 : }
1876 2358 : gimple_seq body = gimple_omp_body (gs);
1877 2358 : if (body && gimple_code (gimple_seq_first_stmt (body)) != GIMPLE_BIND)
1878 : {
1879 361 : newline_and_indent (pp, spc + 2);
1880 361 : pp_left_brace (pp);
1881 361 : pp_newline (pp);
1882 361 : dump_gimple_seq (pp, body, spc + 4, flags);
1883 361 : newline_and_indent (pp, spc + 2);
1884 361 : pp_right_brace (pp);
1885 : }
1886 1997 : else if (body)
1887 : {
1888 1664 : pp_newline (pp);
1889 1664 : dump_gimple_seq (pp, body, spc + 2, flags);
1890 : }
1891 : }
1892 2358 : }
1893 :
1894 : /* Dump a GIMPLE_OMP_TEAMS tuple on the pretty_printer PP. */
1895 :
1896 : static void
1897 505 : dump_gimple_omp_teams (pretty_printer *pp, const gomp_teams *gs, int spc,
1898 : dump_flags_t flags)
1899 : {
1900 505 : if (flags & TDF_RAW)
1901 : {
1902 0 : dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
1903 : gimple_omp_body (gs));
1904 0 : dump_omp_clauses (pp, gimple_omp_teams_clauses (gs), spc, flags);
1905 0 : dump_gimple_fmt (pp, spc, flags, " >");
1906 : }
1907 : else
1908 : {
1909 505 : pp_string (pp, "#pragma omp teams");
1910 505 : dump_omp_clauses (pp, gimple_omp_teams_clauses (gs), spc, flags);
1911 505 : if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1912 : {
1913 499 : newline_and_indent (pp, spc + 2);
1914 499 : pp_character (pp, '{');
1915 499 : pp_newline (pp);
1916 499 : dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags);
1917 499 : newline_and_indent (pp, spc + 2);
1918 499 : pp_character (pp, '}');
1919 : }
1920 : }
1921 505 : }
1922 :
1923 : /* Dump a GIMPLE_OMP_SECTIONS tuple on the pretty_printer PP. */
1924 :
1925 : static void
1926 35 : dump_gimple_omp_sections (pretty_printer *pp, const gomp_sections *gs,
1927 : int spc, dump_flags_t flags)
1928 : {
1929 35 : if (flags & TDF_RAW)
1930 : {
1931 0 : dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
1932 : gimple_omp_body (gs));
1933 0 : dump_omp_clauses (pp, gimple_omp_sections_clauses (gs), spc, flags);
1934 0 : dump_gimple_fmt (pp, spc, flags, " >");
1935 : }
1936 : else
1937 : {
1938 35 : pp_string (pp, "#pragma omp sections");
1939 35 : if (gimple_omp_sections_control (gs))
1940 : {
1941 7 : pp_string (pp, " <");
1942 7 : dump_generic_node (pp, gimple_omp_sections_control (gs), spc,
1943 : flags, false);
1944 7 : pp_greater (pp);
1945 : }
1946 35 : dump_omp_clauses (pp, gimple_omp_sections_clauses (gs), spc, flags);
1947 35 : if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1948 : {
1949 28 : newline_and_indent (pp, spc + 2);
1950 28 : pp_left_brace (pp);
1951 28 : pp_newline (pp);
1952 28 : dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags);
1953 28 : newline_and_indent (pp, spc + 2);
1954 28 : pp_right_brace (pp);
1955 : }
1956 : }
1957 35 : }
1958 :
1959 : /* Dump a GIMPLE_OMP_{MASTER,ORDERED,SECTION,STRUCTURED_BLOCK} tuple on the
1960 : pretty_printer PP. */
1961 :
1962 : static void
1963 270 : dump_gimple_omp_block (pretty_printer *pp, const gimple *gs, int spc,
1964 : dump_flags_t flags)
1965 : {
1966 270 : if (flags & TDF_RAW)
1967 0 : dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S> >", gs,
1968 : gimple_omp_body (gs));
1969 : else
1970 : {
1971 270 : switch (gimple_code (gs))
1972 : {
1973 203 : case GIMPLE_OMP_MASTER:
1974 203 : pp_string (pp, "#pragma omp master");
1975 203 : break;
1976 67 : case GIMPLE_OMP_SECTION:
1977 67 : pp_string (pp, "#pragma omp section");
1978 67 : break;
1979 0 : case GIMPLE_OMP_STRUCTURED_BLOCK:
1980 0 : pp_string (pp, "#pragma omp __structured_block");
1981 0 : break;
1982 0 : default:
1983 0 : gcc_unreachable ();
1984 : }
1985 270 : if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1986 : {
1987 253 : newline_and_indent (pp, spc + 2);
1988 253 : pp_left_brace (pp);
1989 253 : pp_newline (pp);
1990 253 : dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags);
1991 253 : newline_and_indent (pp, spc + 2);
1992 253 : pp_right_brace (pp);
1993 : }
1994 : }
1995 270 : }
1996 :
1997 : /* Dump a GIMPLE_OMP_CRITICAL tuple on the pretty_printer PP. */
1998 :
1999 : static void
2000 16 : dump_gimple_omp_critical (pretty_printer *pp, const gomp_critical *gs,
2001 : int spc, dump_flags_t flags)
2002 : {
2003 16 : if (flags & TDF_RAW)
2004 0 : dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S> >", gs,
2005 : gimple_omp_body (gs));
2006 : else
2007 : {
2008 16 : pp_string (pp, "#pragma omp critical");
2009 16 : if (gimple_omp_critical_name (gs))
2010 : {
2011 6 : pp_string (pp, " (");
2012 6 : dump_generic_node (pp, gimple_omp_critical_name (gs), spc,
2013 : flags, false);
2014 6 : pp_right_paren (pp);
2015 : }
2016 16 : dump_omp_clauses (pp, gimple_omp_critical_clauses (gs), spc, flags);
2017 16 : if (!gimple_seq_empty_p (gimple_omp_body (gs)))
2018 : {
2019 0 : newline_and_indent (pp, spc + 2);
2020 0 : pp_left_brace (pp);
2021 0 : pp_newline (pp);
2022 0 : dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags);
2023 0 : newline_and_indent (pp, spc + 2);
2024 0 : pp_right_brace (pp);
2025 : }
2026 : }
2027 16 : }
2028 :
2029 : /* Dump a GIMPLE_OMP_ORDERED tuple on the pretty_printer PP. */
2030 :
2031 : static void
2032 37 : dump_gimple_omp_ordered (pretty_printer *pp, const gomp_ordered *gs,
2033 : int spc, dump_flags_t flags)
2034 : {
2035 37 : if (flags & TDF_RAW)
2036 0 : dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S> >", gs,
2037 : gimple_omp_body (gs));
2038 : else
2039 : {
2040 37 : pp_string (pp, "#pragma omp ordered");
2041 37 : dump_omp_clauses (pp, gimple_omp_ordered_clauses (gs), spc, flags);
2042 37 : if (!gimple_seq_empty_p (gimple_omp_body (gs)))
2043 : {
2044 13 : newline_and_indent (pp, spc + 2);
2045 13 : pp_left_brace (pp);
2046 13 : pp_newline (pp);
2047 13 : dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags);
2048 13 : newline_and_indent (pp, spc + 2);
2049 13 : pp_right_brace (pp);
2050 : }
2051 : }
2052 37 : }
2053 :
2054 : /* Dump a GIMPLE_OMP_SCAN tuple on the pretty_printer PP. */
2055 :
2056 : static void
2057 0 : dump_gimple_omp_scan (pretty_printer *pp, const gomp_scan *gs,
2058 : int spc, dump_flags_t flags)
2059 : {
2060 0 : if (flags & TDF_RAW)
2061 0 : dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S> >", gs,
2062 : gimple_omp_body (gs));
2063 : else
2064 : {
2065 0 : if (gimple_omp_scan_clauses (gs))
2066 : {
2067 0 : pp_string (pp, "#pragma omp scan");
2068 0 : dump_omp_clauses (pp, gimple_omp_scan_clauses (gs), spc, flags);
2069 : }
2070 0 : if (!gimple_seq_empty_p (gimple_omp_body (gs)))
2071 : {
2072 0 : newline_and_indent (pp, spc + 2);
2073 0 : pp_left_brace (pp);
2074 0 : pp_newline (pp);
2075 0 : dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags);
2076 0 : newline_and_indent (pp, spc + 2);
2077 0 : pp_right_brace (pp);
2078 : }
2079 : }
2080 0 : }
2081 :
2082 : /* Dump a GIMPLE_OMP_RETURN tuple on the pretty_printer PP. */
2083 :
2084 : static void
2085 653 : dump_gimple_omp_return (pretty_printer *pp, const gimple *gs, int spc,
2086 : dump_flags_t flags)
2087 : {
2088 653 : if (flags & TDF_RAW)
2089 : {
2090 0 : dump_gimple_fmt (pp, spc, flags, "%G <nowait=%d", gs,
2091 0 : (int) gimple_omp_return_nowait_p (gs));
2092 0 : if (gimple_omp_return_lhs (gs))
2093 0 : dump_gimple_fmt (pp, spc, flags, ", lhs=%T>",
2094 : gimple_omp_return_lhs (gs));
2095 : else
2096 0 : dump_gimple_fmt (pp, spc, flags, ">");
2097 : }
2098 : else
2099 : {
2100 653 : pp_string (pp, "#pragma omp return");
2101 653 : if (gimple_omp_return_nowait_p (gs))
2102 294 : pp_string (pp, "(nowait)");
2103 653 : if (gimple_omp_return_lhs (gs))
2104 : {
2105 0 : pp_string (pp, " (set ");
2106 0 : dump_generic_node (pp, gimple_omp_return_lhs (gs),
2107 : spc, flags, false);
2108 0 : pp_character (pp, ')');
2109 : }
2110 : }
2111 653 : }
2112 :
2113 : /* Dump a GIMPLE_ASSUME tuple on the pretty_printer PP. */
2114 :
2115 : static void
2116 0 : dump_gimple_assume (pretty_printer *pp, const gimple *gs,
2117 : int spc, dump_flags_t flags)
2118 : {
2119 0 : if (flags & TDF_RAW)
2120 0 : dump_gimple_fmt (pp, spc, flags,
2121 : "%G [GUARD=%T] <%+BODY <%S> >",
2122 : gs, gimple_assume_guard (gs),
2123 : gimple_assume_body (gs));
2124 : else
2125 : {
2126 0 : pp_string (pp, "[[assume (");
2127 0 : dump_generic_node (pp, gimple_assume_guard (gs), spc, flags, false);
2128 0 : pp_string (pp, ")]]");
2129 0 : newline_and_indent (pp, spc + 2);
2130 0 : pp_left_brace (pp);
2131 0 : pp_newline (pp);
2132 0 : dump_gimple_seq (pp, gimple_assume_body (gs), spc + 4, flags);
2133 0 : newline_and_indent (pp, spc + 2);
2134 0 : pp_right_brace (pp);
2135 : }
2136 0 : }
2137 :
2138 : /* Dump a GIMPLE_TRANSACTION tuple on the pretty_printer PP. */
2139 :
2140 : static void
2141 77 : dump_gimple_transaction (pretty_printer *pp, const gtransaction *gs,
2142 : int spc, dump_flags_t flags)
2143 : {
2144 77 : unsigned subcode = gimple_transaction_subcode (gs);
2145 :
2146 77 : if (flags & TDF_RAW)
2147 : {
2148 0 : dump_gimple_fmt (pp, spc, flags,
2149 : "%G [SUBCODE=%x,NORM=%T,UNINST=%T,OVER=%T] "
2150 : "<%+BODY <%S> >",
2151 : gs, subcode, gimple_transaction_label_norm (gs),
2152 : gimple_transaction_label_uninst (gs),
2153 : gimple_transaction_label_over (gs),
2154 : gimple_transaction_body (gs));
2155 : }
2156 : else
2157 : {
2158 77 : if (subcode & GTMA_IS_OUTER)
2159 0 : pp_string (pp, "__transaction_atomic [[outer]]");
2160 77 : else if (subcode & GTMA_IS_RELAXED)
2161 8 : pp_string (pp, "__transaction_relaxed");
2162 : else
2163 69 : pp_string (pp, "__transaction_atomic");
2164 77 : subcode &= ~GTMA_DECLARATION_MASK;
2165 :
2166 77 : if (gimple_transaction_body (gs))
2167 : {
2168 0 : newline_and_indent (pp, spc + 2);
2169 0 : pp_left_brace (pp);
2170 0 : pp_newline (pp);
2171 0 : dump_gimple_seq (pp, gimple_transaction_body (gs),
2172 : spc + 4, flags);
2173 0 : newline_and_indent (pp, spc + 2);
2174 0 : pp_right_brace (pp);
2175 : }
2176 : else
2177 : {
2178 77 : pp_string (pp, " //");
2179 77 : if (gimple_transaction_label_norm (gs))
2180 : {
2181 77 : pp_string (pp, " NORM=");
2182 77 : dump_generic_node (pp, gimple_transaction_label_norm (gs),
2183 : spc, flags, false);
2184 : }
2185 77 : if (gimple_transaction_label_uninst (gs))
2186 : {
2187 77 : pp_string (pp, " UNINST=");
2188 77 : dump_generic_node (pp, gimple_transaction_label_uninst (gs),
2189 : spc, flags, false);
2190 : }
2191 77 : if (gimple_transaction_label_over (gs))
2192 : {
2193 77 : pp_string (pp, " OVER=");
2194 77 : dump_generic_node (pp, gimple_transaction_label_over (gs),
2195 : spc, flags, false);
2196 : }
2197 77 : if (subcode)
2198 : {
2199 77 : pp_string (pp, " SUBCODE=[ ");
2200 77 : if (subcode & GTMA_HAVE_ABORT)
2201 : {
2202 1 : pp_string (pp, "GTMA_HAVE_ABORT ");
2203 1 : subcode &= ~GTMA_HAVE_ABORT;
2204 : }
2205 77 : if (subcode & GTMA_HAVE_LOAD)
2206 : {
2207 77 : pp_string (pp, "GTMA_HAVE_LOAD ");
2208 77 : subcode &= ~GTMA_HAVE_LOAD;
2209 : }
2210 77 : if (subcode & GTMA_HAVE_STORE)
2211 : {
2212 40 : pp_string (pp, "GTMA_HAVE_STORE ");
2213 40 : subcode &= ~GTMA_HAVE_STORE;
2214 : }
2215 77 : if (subcode & GTMA_MAY_ENTER_IRREVOCABLE)
2216 : {
2217 8 : pp_string (pp, "GTMA_MAY_ENTER_IRREVOCABLE ");
2218 8 : subcode &= ~GTMA_MAY_ENTER_IRREVOCABLE;
2219 : }
2220 77 : if (subcode & GTMA_DOES_GO_IRREVOCABLE)
2221 : {
2222 7 : pp_string (pp, "GTMA_DOES_GO_IRREVOCABLE ");
2223 7 : subcode &= ~GTMA_DOES_GO_IRREVOCABLE;
2224 : }
2225 77 : if (subcode & GTMA_HAS_NO_INSTRUMENTATION)
2226 : {
2227 7 : pp_string (pp, "GTMA_HAS_NO_INSTRUMENTATION ");
2228 7 : subcode &= ~GTMA_HAS_NO_INSTRUMENTATION;
2229 : }
2230 77 : if (subcode)
2231 0 : pp_printf (pp, "0x%x ", subcode);
2232 77 : pp_right_bracket (pp);
2233 : }
2234 : }
2235 : }
2236 77 : }
2237 :
2238 : /* Dump a GIMPLE_ASM tuple on the pretty_printer PP, SPC spaces of
2239 : indent. FLAGS specifies details to show in the dump (see TDF_* in
2240 : dumpfile.h). */
2241 :
2242 : static void
2243 10591 : dump_gimple_asm (pretty_printer *pp, const gasm *gs, int spc,
2244 : dump_flags_t flags)
2245 : {
2246 10591 : unsigned int i, n, f, fields;
2247 :
2248 10591 : if (flags & TDF_RAW)
2249 : {
2250 4 : dump_gimple_fmt (pp, spc, flags, "%G <%+STRING <%n%s%n>", gs,
2251 : gimple_asm_string (gs));
2252 :
2253 4 : n = gimple_asm_noutputs (gs);
2254 4 : if (n)
2255 : {
2256 0 : newline_and_indent (pp, spc + 2);
2257 0 : pp_string (pp, "OUTPUT: ");
2258 0 : for (i = 0; i < n; i++)
2259 : {
2260 0 : dump_generic_node (pp, gimple_asm_output_op (gs, i),
2261 : spc, flags, false);
2262 0 : if (i < n - 1)
2263 0 : pp_string (pp, ", ");
2264 : }
2265 : }
2266 :
2267 4 : n = gimple_asm_ninputs (gs);
2268 4 : if (n)
2269 : {
2270 4 : newline_and_indent (pp, spc + 2);
2271 4 : pp_string (pp, "INPUT: ");
2272 12 : for (i = 0; i < n; i++)
2273 : {
2274 4 : dump_generic_node (pp, gimple_asm_input_op (gs, i),
2275 : spc, flags, false);
2276 4 : if (i < n - 1)
2277 0 : pp_string (pp, ", ");
2278 : }
2279 : }
2280 :
2281 4 : n = gimple_asm_nclobbers (gs);
2282 4 : if (n)
2283 : {
2284 4 : newline_and_indent (pp, spc + 2);
2285 4 : pp_string (pp, "CLOBBER: ");
2286 12 : for (i = 0; i < n; i++)
2287 : {
2288 4 : dump_generic_node (pp, gimple_asm_clobber_op (gs, i),
2289 : spc, flags, false);
2290 4 : if (i < n - 1)
2291 0 : pp_string (pp, ", ");
2292 : }
2293 : }
2294 :
2295 4 : n = gimple_asm_nlabels (gs);
2296 4 : if (n)
2297 : {
2298 0 : newline_and_indent (pp, spc + 2);
2299 0 : pp_string (pp, "LABEL: ");
2300 0 : for (i = 0; i < n; i++)
2301 : {
2302 0 : dump_generic_node (pp, gimple_asm_label_op (gs, i),
2303 : spc, flags, false);
2304 0 : if (i < n - 1)
2305 0 : pp_string (pp, ", ");
2306 : }
2307 : }
2308 :
2309 4 : newline_and_indent (pp, spc);
2310 4 : pp_greater (pp);
2311 : }
2312 : else
2313 : {
2314 10587 : pp_string (pp, "__asm__");
2315 10587 : if (gimple_asm_volatile_p (gs))
2316 5352 : pp_string (pp, " __volatile__");
2317 10587 : if (gimple_asm_inline_p (gs))
2318 0 : pp_string (pp, " __inline__");
2319 10587 : if (gimple_asm_nlabels (gs))
2320 1 : pp_string (pp, " goto");
2321 10587 : pp_string (pp, "(\"");
2322 10587 : pp_string (pp, gimple_asm_string (gs));
2323 10587 : pp_string (pp, "\"");
2324 :
2325 10587 : if (gimple_asm_nlabels (gs))
2326 : fields = 4;
2327 10586 : else if (gimple_asm_nclobbers (gs))
2328 : fields = 3;
2329 8593 : else if (gimple_asm_ninputs (gs))
2330 : fields = 2;
2331 1127 : else if (gimple_asm_noutputs (gs))
2332 : fields = 1;
2333 : else
2334 1116 : fields = 0;
2335 :
2336 31513 : for (f = 0; f < fields; ++f)
2337 : {
2338 20926 : pp_string (pp, " : ");
2339 :
2340 20926 : switch (f)
2341 : {
2342 9471 : case 0:
2343 9471 : n = gimple_asm_noutputs (gs);
2344 22263 : for (i = 0; i < n; i++)
2345 : {
2346 12792 : dump_generic_node (pp, gimple_asm_output_op (gs, i),
2347 : spc, flags, false);
2348 12792 : if (i < n - 1)
2349 5396 : pp_string (pp, ", ");
2350 : }
2351 : break;
2352 :
2353 9460 : case 1:
2354 9460 : n = gimple_asm_ninputs (gs);
2355 17907 : for (i = 0; i < n; i++)
2356 : {
2357 8447 : dump_generic_node (pp, gimple_asm_input_op (gs, i),
2358 : spc, flags, false);
2359 8447 : if (i < n - 1)
2360 936 : pp_string (pp, ", ");
2361 : }
2362 : break;
2363 :
2364 1994 : case 2:
2365 1994 : n = gimple_asm_nclobbers (gs);
2366 3987 : for (i = 0; i < n; i++)
2367 : {
2368 1993 : dump_generic_node (pp, gimple_asm_clobber_op (gs, i),
2369 : spc, flags, false);
2370 1993 : if (i < n - 1)
2371 0 : pp_string (pp, ", ");
2372 : }
2373 : break;
2374 :
2375 1 : case 3:
2376 1 : n = gimple_asm_nlabels (gs);
2377 2 : for (i = 0; i < n; i++)
2378 : {
2379 1 : dump_generic_node (pp, gimple_asm_label_op (gs, i),
2380 : spc, flags, false);
2381 1 : if (i < n - 1)
2382 0 : pp_string (pp, ", ");
2383 : }
2384 : break;
2385 :
2386 : default:
2387 : gcc_unreachable ();
2388 : }
2389 : }
2390 :
2391 10587 : pp_string (pp, ");");
2392 : }
2393 10591 : }
2394 :
2395 : /* Dump ptr_info and range_info for NODE on pretty_printer PP with
2396 : SPC spaces of indent. */
2397 :
2398 : static void
2399 19109 : dump_ssaname_info (pretty_printer *pp, tree node, int spc)
2400 : {
2401 19109 : if (TREE_CODE (node) != SSA_NAME)
2402 : return;
2403 :
2404 33555 : if (POINTER_TYPE_P (TREE_TYPE (node))
2405 17886 : && SSA_NAME_PTR_INFO (node))
2406 : {
2407 1751 : unsigned int align, misalign;
2408 1751 : struct ptr_info_def *pi = SSA_NAME_PTR_INFO (node);
2409 1751 : pp_string (pp, "# PT = ");
2410 1751 : pp_points_to_solution (pp, &pi->pt);
2411 1751 : newline_and_indent (pp, spc);
2412 1751 : if (get_ptr_info_alignment (pi, &align, &misalign))
2413 : {
2414 99 : pp_printf (pp, "# ALIGN = %u, MISALIGN = %u", align, misalign);
2415 99 : newline_and_indent (pp, spc);
2416 : }
2417 : }
2418 :
2419 33555 : if (!POINTER_TYPE_P (TREE_TYPE (node))
2420 33256 : && SSA_NAME_RANGE_INFO (node))
2421 : {
2422 3095 : value_range r (TREE_TYPE (node));
2423 3095 : get_global_range_query ()->range_of_expr (r, node);
2424 3095 : pp_string (pp, "# RANGE ");
2425 3095 : pp_vrange (pp, &r);
2426 3095 : newline_and_indent (pp, spc);
2427 3095 : }
2428 : }
2429 :
2430 : /* As dump_ssaname_info, but dump to FILE. */
2431 :
2432 : void
2433 566 : dump_ssaname_info_to_file (FILE *file, tree node, int spc)
2434 : {
2435 566 : pretty_printer pp;
2436 566 : pp_needs_newline (&pp) = true;
2437 566 : pp.set_output_stream (file);
2438 566 : dump_ssaname_info (&pp, node, spc);
2439 566 : pp_flush (&pp);
2440 566 : }
2441 :
2442 : /* Dump a PHI node PHI. PP, SPC and FLAGS are as in pp_gimple_stmt_1.
2443 : The caller is responsible for calling pp_flush on PP to finalize
2444 : pretty printer. If COMMENT is true, print this after #. */
2445 :
2446 : static void
2447 685059 : dump_gimple_phi (pretty_printer *pp, const gphi *phi, int spc, bool comment,
2448 : dump_flags_t flags)
2449 : {
2450 685059 : size_t i;
2451 685059 : tree lhs = gimple_phi_result (phi);
2452 :
2453 685059 : if (flags & TDF_ALIAS)
2454 3870 : dump_ssaname_info (pp, lhs, spc);
2455 :
2456 685059 : if (comment)
2457 166568 : pp_string (pp, "# ");
2458 :
2459 685059 : if (flags & TDF_RAW)
2460 85 : dump_gimple_fmt (pp, spc, flags, "%G <%T, ", phi,
2461 : gimple_phi_result (phi));
2462 : else
2463 : {
2464 684974 : dump_generic_node (pp, lhs, spc, flags, false);
2465 684974 : if (flags & TDF_GIMPLE)
2466 0 : pp_string (pp, " = __PHI (");
2467 : else
2468 684974 : pp_string (pp, " = PHI <");
2469 : }
2470 2019798 : for (i = 0; i < gimple_phi_num_args (phi); i++)
2471 : {
2472 1334743 : if ((flags & TDF_LINENO) && gimple_phi_arg_has_location (phi, i))
2473 0 : dump_location (pp, gimple_phi_arg_location (phi, i), flags);
2474 1334739 : basic_block src = gimple_phi_arg_edge (phi, i)->src;
2475 1334739 : if (flags & TDF_GIMPLE)
2476 : {
2477 0 : pp_string (pp, "__BB");
2478 0 : pp_decimal_int (pp, src->index);
2479 0 : pp_string (pp, ": ");
2480 : }
2481 1334739 : dump_generic_node (pp, gimple_phi_arg_def (phi, i), spc, flags,
2482 : false);
2483 1334739 : if (! (flags & TDF_GIMPLE))
2484 : {
2485 1334739 : pp_left_paren (pp);
2486 1334739 : pp_decimal_int (pp, src->index);
2487 1334739 : pp_right_paren (pp);
2488 : }
2489 1334739 : if (i < gimple_phi_num_args (phi) - 1)
2490 653069 : pp_string (pp, ", ");
2491 : }
2492 685059 : if (flags & TDF_GIMPLE)
2493 0 : pp_string (pp, ");");
2494 : else
2495 685059 : pp_greater (pp);
2496 685059 : }
2497 :
2498 :
2499 : /* Dump a GIMPLE_OMP_PARALLEL tuple on the pretty_printer PP, SPC spaces
2500 : of indent. FLAGS specifies details to show in the dump (see TDF_* in
2501 : dumpfile.h). */
2502 :
2503 : static void
2504 968 : dump_gimple_omp_parallel (pretty_printer *pp, const gomp_parallel *gs,
2505 : int spc, dump_flags_t flags)
2506 : {
2507 968 : if (flags & TDF_RAW)
2508 : {
2509 0 : dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
2510 : gimple_omp_body (gs));
2511 0 : dump_omp_clauses (pp, gimple_omp_parallel_clauses (gs), spc, flags);
2512 0 : dump_gimple_fmt (pp, spc, flags, " >, %T, %T%n>",
2513 : gimple_omp_parallel_child_fn (gs),
2514 : gimple_omp_parallel_data_arg (gs));
2515 : }
2516 : else
2517 : {
2518 968 : gimple_seq body;
2519 968 : pp_string (pp, "#pragma omp parallel");
2520 968 : dump_omp_clauses (pp, gimple_omp_parallel_clauses (gs), spc, flags);
2521 968 : if (gimple_omp_parallel_child_fn (gs))
2522 : {
2523 140 : pp_string (pp, " [child fn: ");
2524 140 : dump_generic_node (pp, gimple_omp_parallel_child_fn (gs),
2525 : spc, flags, false);
2526 140 : pp_string (pp, " (");
2527 140 : if (gimple_omp_parallel_data_arg (gs))
2528 102 : dump_generic_node (pp, gimple_omp_parallel_data_arg (gs),
2529 : spc, flags, false);
2530 : else
2531 38 : pp_string (pp, "???");
2532 140 : pp_string (pp, ")]");
2533 : }
2534 968 : body = gimple_omp_body (gs);
2535 968 : if (body && gimple_code (gimple_seq_first_stmt (body)) != GIMPLE_BIND)
2536 : {
2537 55 : newline_and_indent (pp, spc + 2);
2538 55 : pp_left_brace (pp);
2539 55 : pp_newline (pp);
2540 55 : dump_gimple_seq (pp, body, spc + 4, flags);
2541 55 : newline_and_indent (pp, spc + 2);
2542 55 : pp_right_brace (pp);
2543 : }
2544 913 : else if (body)
2545 : {
2546 836 : pp_newline (pp);
2547 836 : dump_gimple_seq (pp, body, spc + 2, flags);
2548 : }
2549 : }
2550 968 : }
2551 :
2552 :
2553 : /* Dump a GIMPLE_OMP_TASK tuple on the pretty_printer PP, SPC spaces
2554 : of indent. FLAGS specifies details to show in the dump (see TDF_* in
2555 : dumpfile.h). */
2556 :
2557 : static void
2558 339 : dump_gimple_omp_task (pretty_printer *pp, const gomp_task *gs, int spc,
2559 : dump_flags_t flags)
2560 : {
2561 339 : if (flags & TDF_RAW)
2562 : {
2563 0 : dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
2564 : gimple_omp_body (gs));
2565 0 : dump_omp_clauses (pp, gimple_omp_task_clauses (gs), spc, flags);
2566 0 : dump_gimple_fmt (pp, spc, flags, " >, %T, %T, %T, %T, %T%n>",
2567 : gimple_omp_task_child_fn (gs),
2568 : gimple_omp_task_data_arg (gs),
2569 : gimple_omp_task_copy_fn (gs),
2570 : gimple_omp_task_arg_size (gs),
2571 : gimple_omp_task_arg_size (gs));
2572 : }
2573 : else
2574 : {
2575 339 : gimple_seq body;
2576 339 : if (gimple_omp_task_taskloop_p (gs))
2577 240 : pp_string (pp, "#pragma omp taskloop");
2578 99 : else if (gimple_omp_task_taskwait_p (gs))
2579 2 : pp_string (pp, "#pragma omp taskwait");
2580 : else
2581 97 : pp_string (pp, "#pragma omp task");
2582 339 : dump_omp_clauses (pp, gimple_omp_task_clauses (gs), spc, flags);
2583 339 : if (gimple_omp_task_child_fn (gs))
2584 : {
2585 4 : pp_string (pp, " [child fn: ");
2586 4 : dump_generic_node (pp, gimple_omp_task_child_fn (gs),
2587 : spc, flags, false);
2588 4 : pp_string (pp, " (");
2589 4 : if (gimple_omp_task_data_arg (gs))
2590 4 : dump_generic_node (pp, gimple_omp_task_data_arg (gs),
2591 : spc, flags, false);
2592 : else
2593 0 : pp_string (pp, "???");
2594 4 : pp_string (pp, ")]");
2595 : }
2596 339 : body = gimple_omp_body (gs);
2597 339 : if (body && gimple_code (gimple_seq_first_stmt (body)) != GIMPLE_BIND)
2598 : {
2599 4 : newline_and_indent (pp, spc + 2);
2600 4 : pp_left_brace (pp);
2601 4 : pp_newline (pp);
2602 4 : dump_gimple_seq (pp, body, spc + 4, flags);
2603 4 : newline_and_indent (pp, spc + 2);
2604 4 : pp_right_brace (pp);
2605 : }
2606 335 : else if (body)
2607 : {
2608 333 : pp_newline (pp);
2609 333 : dump_gimple_seq (pp, body, spc + 2, flags);
2610 : }
2611 : }
2612 339 : }
2613 :
2614 :
2615 : /* Dump a GIMPLE_OMP_ATOMIC_LOAD tuple on the pretty_printer PP, SPC
2616 : spaces of indent. FLAGS specifies details to show in the dump (see TDF_*
2617 : in dumpfile.h). */
2618 :
2619 : static void
2620 526 : dump_gimple_omp_atomic_load (pretty_printer *pp, const gomp_atomic_load *gs,
2621 : int spc, dump_flags_t flags)
2622 : {
2623 526 : if (flags & TDF_RAW)
2624 : {
2625 0 : dump_gimple_fmt (pp, spc, flags, "%G <%T, %T>", gs,
2626 : gimple_omp_atomic_load_lhs (gs),
2627 : gimple_omp_atomic_load_rhs (gs));
2628 : }
2629 : else
2630 : {
2631 526 : pp_string (pp, "#pragma omp atomic_load");
2632 526 : dump_omp_atomic_memory_order (pp,
2633 : gimple_omp_atomic_memory_order (gs));
2634 526 : if (gimple_omp_atomic_need_value_p (gs))
2635 0 : pp_string (pp, " [needed]");
2636 526 : if (gimple_omp_atomic_weak_p (gs))
2637 0 : pp_string (pp, " [weak]");
2638 526 : newline_and_indent (pp, spc + 2);
2639 526 : dump_generic_node (pp, gimple_omp_atomic_load_lhs (gs),
2640 : spc, flags, false);
2641 526 : pp_space (pp);
2642 526 : pp_equal (pp);
2643 526 : pp_space (pp);
2644 526 : pp_star (pp);
2645 526 : dump_generic_node (pp, gimple_omp_atomic_load_rhs (gs),
2646 : spc, flags, false);
2647 : }
2648 526 : }
2649 :
2650 : /* Dump a GIMPLE_OMP_ATOMIC_STORE tuple on the pretty_printer PP, SPC
2651 : spaces of indent. FLAGS specifies details to show in the dump (see TDF_*
2652 : in dumpfile.h). */
2653 :
2654 : static void
2655 526 : dump_gimple_omp_atomic_store (pretty_printer *pp,
2656 : const gomp_atomic_store *gs, int spc,
2657 : dump_flags_t flags)
2658 : {
2659 526 : if (flags & TDF_RAW)
2660 : {
2661 0 : dump_gimple_fmt (pp, spc, flags, "%G <%T>", gs,
2662 : gimple_omp_atomic_store_val (gs));
2663 : }
2664 : else
2665 : {
2666 526 : pp_string (pp, "#pragma omp atomic_store");
2667 526 : dump_omp_atomic_memory_order (pp,
2668 : gimple_omp_atomic_memory_order (gs));
2669 526 : pp_space (pp);
2670 526 : if (gimple_omp_atomic_need_value_p (gs))
2671 0 : pp_string (pp, "[needed] ");
2672 526 : if (gimple_omp_atomic_weak_p (gs))
2673 0 : pp_string (pp, "[weak] ");
2674 526 : pp_left_paren (pp);
2675 526 : dump_generic_node (pp, gimple_omp_atomic_store_val (gs),
2676 : spc, flags, false);
2677 526 : pp_right_paren (pp);
2678 : }
2679 526 : }
2680 :
2681 :
2682 : /* Dump all the memory operands for statement GS. PP, SPC and
2683 : FLAGS are as in pp_gimple_stmt_1. */
2684 :
2685 : static void
2686 22570 : dump_gimple_mem_ops (pretty_printer *pp, const gimple *gs, int spc,
2687 : dump_flags_t flags)
2688 : {
2689 22570 : tree vdef = gimple_vdef (gs);
2690 22570 : tree vuse = gimple_vuse (gs);
2691 :
2692 22570 : if (vdef != NULL_TREE)
2693 : {
2694 2998 : pp_string (pp, "# ");
2695 2998 : dump_generic_node (pp, vdef, spc + 2, flags, false);
2696 2998 : pp_string (pp, " = VDEF <");
2697 2998 : dump_generic_node (pp, vuse, spc + 2, flags, false);
2698 2998 : pp_greater (pp);
2699 2998 : newline_and_indent (pp, spc);
2700 : }
2701 19572 : else if (vuse != NULL_TREE)
2702 : {
2703 4309 : pp_string (pp, "# VUSE <");
2704 4309 : dump_generic_node (pp, vuse, spc + 2, flags, false);
2705 4309 : pp_greater (pp);
2706 4309 : newline_and_indent (pp, spc);
2707 : }
2708 22570 : }
2709 :
2710 :
2711 : /* Print the gimple statement GS on the pretty printer PP, SPC
2712 : spaces of indent. FLAGS specifies details to show in the dump (see
2713 : TDF_* in dumpfile.h). The caller is responsible for calling
2714 : pp_flush on PP to finalize the pretty printer. */
2715 :
2716 : void
2717 5707533 : pp_gimple_stmt_1 (pretty_printer *pp, const gimple *gs, int spc,
2718 : dump_flags_t flags)
2719 : {
2720 5707533 : if (!gs)
2721 : return;
2722 :
2723 5707417 : if (flags & TDF_STMTADDR)
2724 129 : pp_printf (pp, "<&%p> ", (const void *) gs);
2725 :
2726 5707417 : if ((flags & TDF_LINENO) && gimple_has_location (gs))
2727 1395 : dump_location (pp, gimple_location (gs), flags);
2728 :
2729 5707417 : if (flags & TDF_EH)
2730 : {
2731 18144 : int lp_nr = lookup_stmt_eh_lp (gs);
2732 18144 : if (lp_nr > 0)
2733 27 : pp_printf (pp, "[LP %d] ", lp_nr);
2734 18117 : else if (lp_nr < 0)
2735 12 : pp_printf (pp, "[MNT %d] ", -lp_nr);
2736 : }
2737 :
2738 5707417 : if ((flags & (TDF_VOPS|TDF_MEMSYMS))
2739 5707417 : && gimple_has_mem_ops (gs))
2740 22570 : dump_gimple_mem_ops (pp, gs, spc, flags);
2741 :
2742 5789134 : if (gimple_has_lhs (gs)
2743 4817264 : && (flags & TDF_ALIAS))
2744 14673 : dump_ssaname_info (pp, gimple_get_lhs (gs), spc);
2745 :
2746 5707417 : switch (gimple_code (gs))
2747 : {
2748 10591 : case GIMPLE_ASM:
2749 10591 : dump_gimple_asm (pp, as_a <const gasm *> (gs), spc, flags);
2750 10591 : break;
2751 :
2752 4643491 : case GIMPLE_ASSIGN:
2753 4643491 : dump_gimple_assign (pp, as_a <const gassign *> (gs), spc, flags);
2754 4643491 : break;
2755 :
2756 17822 : case GIMPLE_BIND:
2757 17822 : dump_gimple_bind (pp, as_a <const gbind *> (gs), spc, flags);
2758 17822 : break;
2759 :
2760 173773 : case GIMPLE_CALL:
2761 173773 : dump_gimple_call (pp, as_a <const gcall *> (gs), spc, flags);
2762 173773 : break;
2763 :
2764 191226 : case GIMPLE_COND:
2765 191226 : dump_gimple_cond (pp, as_a <const gcond *> (gs), spc, flags);
2766 191226 : break;
2767 :
2768 36677 : case GIMPLE_LABEL:
2769 36677 : dump_gimple_label (pp, as_a <const glabel *> (gs), spc, flags);
2770 36677 : break;
2771 :
2772 4278 : case GIMPLE_GOTO:
2773 4278 : dump_gimple_goto (pp, as_a <const ggoto *> (gs), spc, flags);
2774 4278 : break;
2775 :
2776 297 : case GIMPLE_NOP:
2777 297 : pp_string (pp, "GIMPLE_NOP");
2778 297 : break;
2779 :
2780 55977 : case GIMPLE_RETURN:
2781 55977 : dump_gimple_return (pp, as_a <const greturn *> (gs), spc, flags);
2782 55977 : break;
2783 :
2784 1465 : case GIMPLE_SWITCH:
2785 1465 : dump_gimple_switch (pp, as_a <const gswitch *> (gs), spc, flags);
2786 1465 : break;
2787 :
2788 4059 : case GIMPLE_TRY:
2789 4059 : dump_gimple_try (pp, as_a <const gtry *> (gs), spc, flags);
2790 4059 : break;
2791 :
2792 518491 : case GIMPLE_PHI:
2793 518491 : dump_gimple_phi (pp, as_a <const gphi *> (gs), spc, false, flags);
2794 518491 : break;
2795 :
2796 968 : case GIMPLE_OMP_PARALLEL:
2797 968 : dump_gimple_omp_parallel (pp, as_a <const gomp_parallel *> (gs), spc,
2798 : flags);
2799 968 : break;
2800 :
2801 339 : case GIMPLE_OMP_TASK:
2802 339 : dump_gimple_omp_task (pp, as_a <const gomp_task *> (gs), spc, flags);
2803 339 : break;
2804 :
2805 526 : case GIMPLE_OMP_ATOMIC_LOAD:
2806 526 : dump_gimple_omp_atomic_load (pp, as_a <const gomp_atomic_load *> (gs),
2807 : spc, flags);
2808 526 : break;
2809 :
2810 526 : case GIMPLE_OMP_ATOMIC_STORE:
2811 526 : dump_gimple_omp_atomic_store (pp,
2812 : as_a <const gomp_atomic_store *> (gs),
2813 : spc, flags);
2814 526 : break;
2815 :
2816 3343 : case GIMPLE_OMP_FOR:
2817 3343 : dump_gimple_omp_for (pp, as_a <const gomp_for *> (gs), spc, flags);
2818 3343 : break;
2819 :
2820 292 : case GIMPLE_OMP_CONTINUE:
2821 292 : dump_gimple_omp_continue (pp, as_a <const gomp_continue *> (gs), spc,
2822 : flags);
2823 292 : break;
2824 :
2825 29 : case GIMPLE_OMP_SINGLE:
2826 29 : dump_gimple_omp_single (pp, as_a <const gomp_single *> (gs), spc,
2827 : flags);
2828 29 : break;
2829 :
2830 2358 : case GIMPLE_OMP_TARGET:
2831 2358 : dump_gimple_omp_target (pp, as_a <const gomp_target *> (gs), spc,
2832 : flags);
2833 2358 : break;
2834 :
2835 505 : case GIMPLE_OMP_TEAMS:
2836 505 : dump_gimple_omp_teams (pp, as_a <const gomp_teams *> (gs), spc,
2837 : flags);
2838 505 : break;
2839 :
2840 653 : case GIMPLE_OMP_RETURN:
2841 653 : dump_gimple_omp_return (pp, gs, spc, flags);
2842 653 : break;
2843 :
2844 35 : case GIMPLE_OMP_SECTIONS:
2845 35 : dump_gimple_omp_sections (pp, as_a <const gomp_sections *> (gs),
2846 : spc, flags);
2847 35 : break;
2848 :
2849 7 : case GIMPLE_OMP_SECTIONS_SWITCH:
2850 7 : pp_string (pp, "GIMPLE_SECTIONS_SWITCH");
2851 7 : break;
2852 :
2853 0 : case GIMPLE_OMP_TASKGROUP:
2854 0 : dump_gimple_omp_taskgroup (pp, gs, spc, flags);
2855 0 : break;
2856 :
2857 6 : case GIMPLE_OMP_MASKED:
2858 6 : dump_gimple_omp_masked (pp, gs, spc, flags);
2859 6 : break;
2860 :
2861 0 : case GIMPLE_OMP_SCOPE:
2862 0 : dump_gimple_omp_scope (pp, gs, spc, flags);
2863 0 : break;
2864 :
2865 401 : case GIMPLE_OMP_DISPATCH:
2866 401 : dump_gimple_omp_dispatch(pp, gs, spc, flags);
2867 401 : break;
2868 :
2869 0 : case GIMPLE_OMP_INTEROP:
2870 0 : dump_gimple_omp_interop (pp, gs, spc, flags);
2871 0 : break;
2872 :
2873 270 : case GIMPLE_OMP_MASTER:
2874 270 : case GIMPLE_OMP_SECTION:
2875 270 : case GIMPLE_OMP_STRUCTURED_BLOCK:
2876 270 : dump_gimple_omp_block (pp, gs, spc, flags);
2877 270 : break;
2878 :
2879 37 : case GIMPLE_OMP_ORDERED:
2880 37 : dump_gimple_omp_ordered (pp, as_a <const gomp_ordered *> (gs), spc,
2881 : flags);
2882 37 : break;
2883 :
2884 0 : case GIMPLE_OMP_SCAN:
2885 0 : dump_gimple_omp_scan (pp, as_a <const gomp_scan *> (gs), spc,
2886 : flags);
2887 0 : break;
2888 :
2889 16 : case GIMPLE_OMP_CRITICAL:
2890 16 : dump_gimple_omp_critical (pp, as_a <const gomp_critical *> (gs), spc,
2891 : flags);
2892 16 : break;
2893 :
2894 0 : case GIMPLE_CATCH:
2895 0 : dump_gimple_catch (pp, as_a <const gcatch *> (gs), spc, flags);
2896 0 : break;
2897 :
2898 12 : case GIMPLE_EH_FILTER:
2899 12 : dump_gimple_eh_filter (pp, as_a <const geh_filter *> (gs), spc,
2900 : flags);
2901 12 : break;
2902 :
2903 808 : case GIMPLE_EH_MUST_NOT_THROW:
2904 808 : dump_gimple_eh_must_not_throw (pp,
2905 : as_a <const geh_mnt *> (gs),
2906 : spc, flags);
2907 808 : break;
2908 :
2909 0 : case GIMPLE_EH_ELSE:
2910 0 : dump_gimple_eh_else (pp, as_a <const geh_else *> (gs), spc, flags);
2911 0 : break;
2912 :
2913 1677 : case GIMPLE_RESX:
2914 1677 : dump_gimple_resx (pp, as_a <const gresx *> (gs), spc, flags);
2915 1677 : break;
2916 :
2917 30 : case GIMPLE_EH_DISPATCH:
2918 30 : dump_gimple_eh_dispatch (pp, as_a <const geh_dispatch *> (gs), spc,
2919 : flags);
2920 30 : break;
2921 :
2922 35126 : case GIMPLE_DEBUG:
2923 35126 : dump_gimple_debug (pp, as_a <const gdebug *> (gs), spc, flags);
2924 35126 : break;
2925 :
2926 1229 : case GIMPLE_PREDICT:
2927 1229 : pp_string (pp, "// predicted ");
2928 1229 : if (gimple_predict_outcome (gs))
2929 48 : pp_string (pp, "likely by ");
2930 : else
2931 1181 : pp_string (pp, "unlikely by ");
2932 1229 : pp_string (pp, predictor_name (gimple_predict_predictor (gs)));
2933 1229 : pp_string (pp, " predictor.");
2934 1229 : break;
2935 :
2936 0 : case GIMPLE_ASSUME:
2937 0 : dump_gimple_assume (pp, gs, spc, flags);
2938 0 : break;
2939 :
2940 77 : case GIMPLE_TRANSACTION:
2941 77 : dump_gimple_transaction (pp, as_a <const gtransaction *> (gs), spc,
2942 : flags);
2943 77 : break;
2944 :
2945 0 : default:
2946 0 : GIMPLE_NIY;
2947 : }
2948 : }
2949 :
2950 :
2951 : /* Dumps header of basic block BB to OUTF indented by INDENT
2952 : spaces and details described by flags. */
2953 :
2954 : static void
2955 296200 : dump_gimple_bb_header (FILE *outf, basic_block bb, int indent,
2956 : dump_flags_t flags)
2957 : {
2958 296200 : if (flags & TDF_BLOCKS)
2959 : {
2960 46831 : if (flags & TDF_LINENO)
2961 : {
2962 0 : gimple_stmt_iterator gsi;
2963 :
2964 0 : fputs (";; ", outf);
2965 :
2966 0 : for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
2967 0 : if (!is_gimple_debug (gsi_stmt (gsi))
2968 0 : && get_lineno (gsi_stmt (gsi)) != UNKNOWN_LOCATION)
2969 : {
2970 0 : fprintf (outf, "%*sstarting at line %d",
2971 0 : indent, "", get_lineno (gsi_stmt (gsi)));
2972 0 : break;
2973 : }
2974 0 : fputc ('\n', outf);
2975 : }
2976 : }
2977 : else
2978 : {
2979 249369 : if (flags & TDF_GIMPLE)
2980 : {
2981 73 : fprintf (outf, "%*s__BB(%d", indent, "", bb->index);
2982 73 : if (bb->loop_father->header == bb)
2983 0 : fprintf (outf, ",loop_header(%d)", bb->loop_father->num);
2984 73 : if (bb->count.initialized_p ())
2985 0 : fprintf (outf, ",%s(%" PRIu64 ")",
2986 : profile_quality_as_string (bb->count.quality ()),
2987 : bb->count.value ());
2988 73 : fprintf (outf, "):\n");
2989 : }
2990 : else
2991 249296 : fprintf (outf, "%*s<bb %d> %s:\n",
2992 249296 : indent, "", bb->index, dump_profile (bb->count));
2993 : }
2994 296200 : }
2995 :
2996 :
2997 : /* Dumps end of basic block BB to PP indented by INDENT
2998 : spaces. */
2999 :
3000 : static void
3001 0 : dump_gimple_bb_footer (FILE *outf ATTRIBUTE_UNUSED,
3002 : basic_block bb ATTRIBUTE_UNUSED,
3003 : int indent ATTRIBUTE_UNUSED,
3004 : dump_flags_t flags ATTRIBUTE_UNUSED)
3005 : {
3006 : /* There is currently no GIMPLE-specific basic block info to dump. */
3007 0 : return;
3008 : }
3009 :
3010 :
3011 : /* Dump PHI nodes of basic block BB to PP with details described
3012 : by FLAGS and indented by INDENT spaces. */
3013 :
3014 : static void
3015 296200 : dump_phi_nodes (pretty_printer *pp, basic_block bb, int indent,
3016 : dump_flags_t flags)
3017 : {
3018 296200 : gphi_iterator i;
3019 :
3020 531060 : for (i = gsi_start_phis (bb); !gsi_end_p (i); gsi_next (&i))
3021 : {
3022 234860 : gphi *phi = i.phi ();
3023 469720 : if (!virtual_operand_p (gimple_phi_result (phi)) || (flags & TDF_VOPS))
3024 : {
3025 494832 : INDENT (indent);
3026 166568 : dump_gimple_phi (pp, phi, indent,
3027 166568 : (flags & TDF_GIMPLE) ? false : true, flags);
3028 166568 : pp_newline (pp);
3029 : }
3030 : }
3031 296200 : }
3032 :
3033 :
3034 : /* Dump jump to basic block BB that is represented implicitly in the cfg
3035 : to PP. */
3036 :
3037 : static void
3038 247692 : pp_cfg_jump (pretty_printer *pp, edge e, dump_flags_t flags)
3039 : {
3040 247692 : if (flags & TDF_GIMPLE)
3041 : {
3042 35 : pp_string (pp, "goto __BB");
3043 35 : pp_decimal_int (pp, e->dest->index);
3044 35 : if (e->probability.initialized_p ())
3045 : {
3046 0 : pp_string (pp, "(");
3047 0 : pp_string (pp,
3048 : profile_quality_as_string (e->probability.quality ()));
3049 0 : pp_string (pp, "(");
3050 0 : pp_decimal_int (pp, e->probability.value ());
3051 0 : pp_string (pp, "))");
3052 : }
3053 35 : pp_semicolon (pp);
3054 : }
3055 : else
3056 : {
3057 247657 : pp_string (pp, "goto <bb ");
3058 247657 : pp_decimal_int (pp, e->dest->index);
3059 247657 : pp_greater (pp);
3060 247657 : pp_semicolon (pp);
3061 :
3062 247657 : dump_edge_probability (pp, e);
3063 : }
3064 247692 : }
3065 :
3066 :
3067 : /* Dump edges represented implicitly in basic block BB to PP, indented
3068 : by INDENT spaces, with details given by FLAGS. */
3069 :
3070 : static void
3071 296344 : dump_implicit_edges (pretty_printer *pp, basic_block bb, int indent,
3072 : dump_flags_t flags)
3073 : {
3074 296344 : edge e;
3075 :
3076 592688 : if (safe_is_a <gcond *> (*gsi_last_bb (bb)))
3077 : {
3078 93426 : edge true_edge, false_edge;
3079 :
3080 : /* When we are emitting the code or changing CFG, it is possible that
3081 : the edges are not yet created. When we are using debug_bb in such
3082 : a situation, we do not want it to crash. */
3083 186701 : if (EDGE_COUNT (bb->succs) != 2)
3084 : return;
3085 93275 : extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
3086 :
3087 557540 : INDENT (indent + 2);
3088 93275 : pp_cfg_jump (pp, true_edge, flags);
3089 93275 : newline_and_indent (pp, indent);
3090 93275 : pp_string (pp, "else");
3091 93275 : newline_and_indent (pp, indent + 2);
3092 93275 : pp_cfg_jump (pp, false_edge, flags);
3093 93275 : pp_newline (pp);
3094 93275 : return;
3095 : }
3096 :
3097 : /* If there is a fallthru edge, we may need to add an artificial
3098 : goto to the dump. */
3099 202918 : e = find_fallthru_edge (bb->succs);
3100 :
3101 202918 : if (e && (e->dest != bb->next_bb || (flags & TDF_GIMPLE)))
3102 : {
3103 166420 : INDENT (indent);
3104 :
3105 61022 : if ((flags & TDF_LINENO)
3106 61022 : && e->goto_locus != UNKNOWN_LOCATION)
3107 0 : dump_location (pp, e->goto_locus, flags);
3108 :
3109 61022 : pp_cfg_jump (pp, e, flags);
3110 61022 : pp_newline (pp);
3111 : }
3112 : }
3113 :
3114 :
3115 : /* Dumps basic block BB to PP with details described by FLAGS and
3116 : indented by INDENT spaces. */
3117 :
3118 : static void
3119 296200 : gimple_dump_bb_buff (pretty_printer *pp, basic_block bb, int indent,
3120 : dump_flags_t flags)
3121 : {
3122 296200 : gimple_stmt_iterator gsi;
3123 296200 : gimple *stmt;
3124 296200 : int label_indent = indent - 2;
3125 :
3126 296200 : if (label_indent < 0)
3127 : label_indent = 0;
3128 :
3129 296200 : dump_phi_nodes (pp, bb, indent, flags);
3130 :
3131 1727337 : for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
3132 : {
3133 1134937 : int curr_indent;
3134 :
3135 1134937 : stmt = gsi_stmt (gsi);
3136 :
3137 1134937 : curr_indent = gimple_code (stmt) == GIMPLE_LABEL ? label_indent : indent;
3138 :
3139 3352253 : INDENT (curr_indent);
3140 1134937 : pp_gimple_stmt_1 (pp, stmt, curr_indent, flags);
3141 1134937 : pp_newline_and_flush (pp);
3142 1134937 : gcc_checking_assert (DECL_STRUCT_FUNCTION (current_function_decl));
3143 1134937 : dump_histograms_for_stmt (DECL_STRUCT_FUNCTION (current_function_decl),
3144 1134937 : pp_buffer (pp)->m_stream, stmt);
3145 : }
3146 :
3147 296200 : dump_implicit_edges (pp, bb, indent, flags);
3148 296200 : pp_flush (pp);
3149 296200 : }
3150 :
3151 :
3152 : /* Dumps basic block BB to FILE with details described by FLAGS and
3153 : indented by INDENT spaces. */
3154 :
3155 : void
3156 296200 : gimple_dump_bb (FILE *file, basic_block bb, int indent, dump_flags_t flags)
3157 : {
3158 296200 : dump_gimple_bb_header (file, bb, indent, flags);
3159 296200 : if (bb->index >= NUM_FIXED_BLOCKS)
3160 : {
3161 296200 : pretty_printer pp;
3162 296200 : pp_needs_newline (&pp) = true;
3163 296200 : pp.set_output_stream (file);
3164 296200 : gimple_dump_bb_buff (&pp, bb, indent, flags);
3165 296200 : }
3166 296200 : dump_gimple_bb_footer (file, bb, indent, flags);
3167 296200 : }
3168 :
3169 : /* Dumps basic block BB to pretty-printer PP with default dump flags and
3170 : no indentation, for use as a label of a DOT graph record-node.
3171 : ??? Should just use gimple_dump_bb_buff here, except that value profiling
3172 : histogram dumping doesn't know about pretty-printers. */
3173 :
3174 : void
3175 144 : gimple_dump_bb_for_graph (pretty_printer *pp, basic_block bb)
3176 : {
3177 144 : pp_printf (pp, "<bb %d>:\n", bb->index);
3178 144 : pp_write_text_as_dot_label_to_stream (pp, /*for_record=*/true);
3179 :
3180 158 : for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
3181 14 : gsi_next (&gsi))
3182 : {
3183 14 : gphi *phi = gsi.phi ();
3184 14 : if (!virtual_operand_p (gimple_phi_result (phi))
3185 14 : || (dump_flags & TDF_VOPS))
3186 : {
3187 6 : pp_bar (pp);
3188 6 : pp_write_text_to_stream (pp);
3189 6 : pp_string (pp, "# ");
3190 6 : pp_gimple_stmt_1 (pp, phi, 0, dump_flags);
3191 6 : pp_newline (pp);
3192 6 : pp_write_text_as_dot_label_to_stream (pp, /*for_record=*/true);
3193 : }
3194 : }
3195 :
3196 487 : for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);
3197 199 : gsi_next (&gsi))
3198 : {
3199 199 : gimple *stmt = gsi_stmt (gsi);
3200 199 : pp_bar (pp);
3201 199 : pp_write_text_to_stream (pp);
3202 199 : pp_gimple_stmt_1 (pp, stmt, 0, dump_flags);
3203 199 : pp_newline (pp);
3204 199 : pp_write_text_as_dot_label_to_stream (pp, /*for_record=*/true);
3205 : }
3206 144 : dump_implicit_edges (pp, bb, 0, dump_flags);
3207 144 : pp_write_text_as_dot_label_to_stream (pp, /*for_record=*/true);
3208 144 : }
3209 :
3210 : void
3211 240 : gimple_dump_bb_as_sarif_properties (diagnostics::sarif_builder *,
3212 : json::object &output_bag,
3213 : basic_block bb)
3214 : {
3215 240 : namespace bb_properties = custom_sarif_properties::cfg::basic_block;
3216 240 : output_bag.set_integer (bb_properties::index, bb->index);
3217 :
3218 240 : auto phi_arr = std::make_unique<json::array> ();
3219 274 : for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
3220 34 : gsi_next (&gsi))
3221 : {
3222 34 : gphi *phi = gsi.phi ();
3223 34 : if (!virtual_operand_p (gimple_phi_result (phi))
3224 34 : || (dump_flags & TDF_VOPS))
3225 : {
3226 34 : pretty_printer pp;
3227 34 : pp_gimple_stmt_1 (&pp, phi, 0, dump_flags);
3228 34 : phi_arr->append_string (pp_formatted_text (&pp));
3229 34 : }
3230 : }
3231 240 : output_bag.set_array_of_string (bb_properties::gimple::phis,
3232 : std::move (phi_arr));
3233 :
3234 240 : auto stmt_arr = std::make_unique<json::array> ();
3235 760 : for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);
3236 280 : gsi_next (&gsi))
3237 : {
3238 280 : gimple *stmt = gsi_stmt (gsi);
3239 280 : pretty_printer the_pp;
3240 280 : pretty_printer *pp = &the_pp;
3241 280 : pp_gimple_stmt_1 (pp, stmt, 0, dump_flags);
3242 280 : pp_newline (pp);
3243 280 : if (gsi_one_before_end_p (gsi))
3244 : {
3245 : /* Compare with gcond part of dump_implicit_edges. */
3246 160 : if (safe_is_a <gcond *> (stmt)
3247 160 : && (EDGE_COUNT (bb->succs) == 2))
3248 : {
3249 40 : const int indent = 0;
3250 40 : edge true_edge, false_edge;
3251 :
3252 40 : extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
3253 160 : INDENT (indent + 2);
3254 40 : pp_cfg_jump (pp, true_edge, dump_flags);
3255 40 : newline_and_indent (pp, indent);
3256 40 : pp_string (pp, "else");
3257 40 : newline_and_indent (pp, indent + 2);
3258 40 : pp_cfg_jump (pp, false_edge, dump_flags);
3259 40 : pp_newline (pp);
3260 : }
3261 : }
3262 280 : stmt_arr->append_string (pp_formatted_text (pp));
3263 280 : }
3264 :
3265 : /* Compare with dump_implicit_edges. */
3266 240 : {
3267 : /* If there is a fallthru edge, we may need to add an artificial
3268 : goto to the dump. */
3269 240 : edge e = find_fallthru_edge (bb->succs);
3270 :
3271 240 : if (e && (e->dest != bb->next_bb || (dump_flags & TDF_GIMPLE)))
3272 : {
3273 40 : pretty_printer the_pp;
3274 40 : pretty_printer *pp = &the_pp;
3275 40 : INDENT (0);
3276 :
3277 40 : if ((dump_flags & TDF_LINENO)
3278 40 : && e->goto_locus != UNKNOWN_LOCATION)
3279 0 : dump_location (pp, e->goto_locus, dump_flags);
3280 :
3281 40 : pp_cfg_jump (pp, e, dump_flags);
3282 40 : pp_newline (pp);
3283 40 : stmt_arr->append_string (pp_formatted_text (pp));
3284 40 : }
3285 : }
3286 :
3287 240 : output_bag.set_array_of_string (bb_properties::gimple::stmts,
3288 : std::move (stmt_arr));
3289 240 : }
3290 :
3291 : #if __GNUC__ >= 10
3292 : # pragma GCC diagnostic pop
3293 : #endif
|
