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