1 /* Pretty formatting of GIMPLE statements and expressions.
2 Copyright (C) 2001-2014 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 "tm.h"
26 #include "tree.h"
27 #include "stringpool.h"
28 #include "diagnostic.h"
29 #include "gimple-pretty-print.h"
30 #include "hashtab.h"
31 #include "bitmap.h"
32 #include "basic-block.h"
33 #include "tree-ssa-alias.h"
34 #include "internal-fn.h"
35 #include "tree-eh.h"
36 #include "gimple-expr.h"
37 #include "is-a.h"
38 #include "gimple.h"
39 #include "gimple-iterator.h"
40 #include "gimple-ssa.h"
41 #include "cgraph.h"
42 #include "tree-cfg.h"
43 #include "tree-ssanames.h"
44 #include "dumpfile.h" /* for dump_flags */
45 #include "value-prof.h"
46 #include "trans-mem.h"
47
48 #define INDENT(SPACE) \
49 do { int i; for (i = 0; i < SPACE; i++) pp_space (buffer); } while (0)
50
51 #define GIMPLE_NIY do_niy (buffer,gs)
52
53 /* Try to print on BUFFER a default message for the unrecognized
54 gimple statement GS. */
55
56 static void
do_niy(pretty_printer * buffer,gimple gs)57 do_niy (pretty_printer *buffer, gimple gs)
58 {
59 pp_printf (buffer, "<<< Unknown GIMPLE statement: %s >>>\n",
60 gimple_code_name[(int) gimple_code (gs)]);
61 }
62
63
64 /* Emit a newline and SPC indentation spaces to BUFFER. */
65
66 static void
newline_and_indent(pretty_printer * buffer,int spc)67 newline_and_indent (pretty_printer *buffer, int spc)
68 {
69 pp_newline (buffer);
70 INDENT (spc);
71 }
72
73
74 /* Print the GIMPLE statement GS on stderr. */
75
76 DEBUG_FUNCTION void
debug_gimple_stmt(gimple gs)77 debug_gimple_stmt (gimple gs)
78 {
79 print_gimple_stmt (stderr, gs, 0, TDF_VOPS|TDF_MEMSYMS);
80 }
81
82
83 /* Print GIMPLE statement G to FILE using SPC indentation spaces and
84 FLAGS as in pp_gimple_stmt_1. */
85
86 void
print_gimple_stmt(FILE * file,gimple g,int spc,int flags)87 print_gimple_stmt (FILE *file, gimple g, int spc, int flags)
88 {
89 pretty_printer buffer;
90 pp_needs_newline (&buffer) = true;
91 buffer.buffer->stream = file;
92 pp_gimple_stmt_1 (&buffer, g, spc, flags);
93 pp_newline_and_flush (&buffer);
94 }
95
96 DEBUG_FUNCTION void
debug(gimple_statement_base & ref)97 debug (gimple_statement_base &ref)
98 {
99 print_gimple_stmt (stderr, &ref, 0, 0);
100 }
101
102 DEBUG_FUNCTION void
debug(gimple_statement_base * ptr)103 debug (gimple_statement_base *ptr)
104 {
105 if (ptr)
106 debug (*ptr);
107 else
108 fprintf (stderr, "<nil>\n");
109 }
110
111
112 /* Print GIMPLE statement G to FILE using SPC indentation spaces and
113 FLAGS as in pp_gimple_stmt_1. Print only the right-hand side
114 of the statement. */
115
116 void
print_gimple_expr(FILE * file,gimple g,int spc,int flags)117 print_gimple_expr (FILE *file, gimple g, int spc, int flags)
118 {
119 flags |= TDF_RHS_ONLY;
120 pretty_printer buffer;
121 pp_needs_newline (&buffer) = true;
122 buffer.buffer->stream = file;
123 pp_gimple_stmt_1 (&buffer, g, spc, flags);
124 pp_flush (&buffer);
125 }
126
127
128 /* Print the GIMPLE sequence SEQ on BUFFER using SPC indentation
129 spaces and FLAGS as in pp_gimple_stmt_1.
130 The caller is responsible for calling pp_flush on BUFFER to finalize
131 the pretty printer. */
132
133 static void
dump_gimple_seq(pretty_printer * buffer,gimple_seq seq,int spc,int flags)134 dump_gimple_seq (pretty_printer *buffer, gimple_seq seq, int spc, int flags)
135 {
136 gimple_stmt_iterator i;
137
138 for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
139 {
140 gimple gs = gsi_stmt (i);
141 INDENT (spc);
142 pp_gimple_stmt_1 (buffer, gs, spc, flags);
143 if (!gsi_one_before_end_p (i))
144 pp_newline (buffer);
145 }
146 }
147
148
149 /* Print GIMPLE sequence SEQ to FILE using SPC indentation spaces and
150 FLAGS as in pp_gimple_stmt_1. */
151
152 void
print_gimple_seq(FILE * file,gimple_seq seq,int spc,int flags)153 print_gimple_seq (FILE *file, gimple_seq seq, int spc, int flags)
154 {
155 pretty_printer buffer;
156 pp_needs_newline (&buffer) = true;
157 buffer.buffer->stream = file;
158 dump_gimple_seq (&buffer, seq, spc, flags);
159 pp_newline_and_flush (&buffer);
160 }
161
162
163 /* Print the GIMPLE sequence SEQ on stderr. */
164
165 DEBUG_FUNCTION void
debug_gimple_seq(gimple_seq seq)166 debug_gimple_seq (gimple_seq seq)
167 {
168 print_gimple_seq (stderr, seq, 0, TDF_VOPS|TDF_MEMSYMS);
169 }
170
171
172 /* A simple helper to pretty-print some of the gimple tuples in the printf
173 style. The format modifiers are preceded by '%' and are:
174 'G' - outputs a string corresponding to the code of the given gimple,
175 'S' - outputs a gimple_seq with indent of spc + 2,
176 'T' - outputs the tree t,
177 'd' - outputs an int as a decimal,
178 's' - outputs a string,
179 'n' - outputs a newline,
180 'x' - outputs an int as hexadecimal,
181 '+' - increases indent by 2 then outputs a newline,
182 '-' - decreases indent by 2 then outputs a newline. */
183
184 static void
dump_gimple_fmt(pretty_printer * buffer,int spc,int flags,const char * fmt,...)185 dump_gimple_fmt (pretty_printer *buffer, int spc, int flags,
186 const char *fmt, ...)
187 {
188 va_list args;
189 const char *c;
190 const char *tmp;
191
192 va_start (args, fmt);
193 for (c = fmt; *c; c++)
194 {
195 if (*c == '%')
196 {
197 gimple_seq seq;
198 tree t;
199 gimple g;
200 switch (*++c)
201 {
202 case 'G':
203 g = va_arg (args, gimple);
204 tmp = gimple_code_name[gimple_code (g)];
205 pp_string (buffer, tmp);
206 break;
207
208 case 'S':
209 seq = va_arg (args, gimple_seq);
210 pp_newline (buffer);
211 dump_gimple_seq (buffer, seq, spc + 2, flags);
212 newline_and_indent (buffer, spc);
213 break;
214
215 case 'T':
216 t = va_arg (args, tree);
217 if (t == NULL_TREE)
218 pp_string (buffer, "NULL");
219 else
220 dump_generic_node (buffer, t, spc, flags, false);
221 break;
222
223 case 'd':
224 pp_decimal_int (buffer, va_arg (args, int));
225 break;
226
227 case 's':
228 pp_string (buffer, va_arg (args, char *));
229 break;
230
231 case 'n':
232 newline_and_indent (buffer, spc);
233 break;
234
235 case 'x':
236 pp_scalar (buffer, "%x", va_arg (args, int));
237 break;
238
239 case '+':
240 spc += 2;
241 newline_and_indent (buffer, spc);
242 break;
243
244 case '-':
245 spc -= 2;
246 newline_and_indent (buffer, spc);
247 break;
248
249 default:
250 gcc_unreachable ();
251 }
252 }
253 else
254 pp_character (buffer, *c);
255 }
256 va_end (args);
257 }
258
259
260 /* Helper for dump_gimple_assign. Print the unary RHS of the
261 assignment GS. BUFFER, SPC and FLAGS are as in pp_gimple_stmt_1. */
262
263 static void
dump_unary_rhs(pretty_printer * buffer,gimple gs,int spc,int flags)264 dump_unary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
265 {
266 enum tree_code rhs_code = gimple_assign_rhs_code (gs);
267 tree lhs = gimple_assign_lhs (gs);
268 tree rhs = gimple_assign_rhs1 (gs);
269
270 switch (rhs_code)
271 {
272 case VIEW_CONVERT_EXPR:
273 case ASSERT_EXPR:
274 dump_generic_node (buffer, rhs, spc, flags, false);
275 break;
276
277 case FIXED_CONVERT_EXPR:
278 case ADDR_SPACE_CONVERT_EXPR:
279 case FIX_TRUNC_EXPR:
280 case FLOAT_EXPR:
281 CASE_CONVERT:
282 pp_left_paren (buffer);
283 dump_generic_node (buffer, TREE_TYPE (lhs), spc, flags, false);
284 pp_string (buffer, ") ");
285 if (op_prio (rhs) < op_code_prio (rhs_code))
286 {
287 pp_left_paren (buffer);
288 dump_generic_node (buffer, rhs, spc, flags, false);
289 pp_right_paren (buffer);
290 }
291 else
292 dump_generic_node (buffer, rhs, spc, flags, false);
293 break;
294
295 case PAREN_EXPR:
296 pp_string (buffer, "((");
297 dump_generic_node (buffer, rhs, spc, flags, false);
298 pp_string (buffer, "))");
299 break;
300
301 case ABS_EXPR:
302 pp_string (buffer, "ABS_EXPR <");
303 dump_generic_node (buffer, rhs, spc, flags, false);
304 pp_greater (buffer);
305 break;
306
307 default:
308 if (TREE_CODE_CLASS (rhs_code) == tcc_declaration
309 || TREE_CODE_CLASS (rhs_code) == tcc_constant
310 || TREE_CODE_CLASS (rhs_code) == tcc_reference
311 || rhs_code == SSA_NAME
312 || rhs_code == ADDR_EXPR
313 || rhs_code == CONSTRUCTOR)
314 {
315 dump_generic_node (buffer, rhs, spc, flags, false);
316 break;
317 }
318 else if (rhs_code == BIT_NOT_EXPR)
319 pp_complement (buffer);
320 else if (rhs_code == TRUTH_NOT_EXPR)
321 pp_exclamation (buffer);
322 else if (rhs_code == NEGATE_EXPR)
323 pp_minus (buffer);
324 else
325 {
326 pp_left_bracket (buffer);
327 pp_string (buffer, get_tree_code_name (rhs_code));
328 pp_string (buffer, "] ");
329 }
330
331 if (op_prio (rhs) < op_code_prio (rhs_code))
332 {
333 pp_left_paren (buffer);
334 dump_generic_node (buffer, rhs, spc, flags, false);
335 pp_right_paren (buffer);
336 }
337 else
338 dump_generic_node (buffer, rhs, spc, flags, false);
339 break;
340 }
341 }
342
343
344 /* Helper for dump_gimple_assign. Print the binary RHS of the
345 assignment GS. BUFFER, SPC and FLAGS are as in pp_gimple_stmt_1. */
346
347 static void
dump_binary_rhs(pretty_printer * buffer,gimple gs,int spc,int flags)348 dump_binary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
349 {
350 const char *p;
351 enum tree_code code = gimple_assign_rhs_code (gs);
352 switch (code)
353 {
354 case COMPLEX_EXPR:
355 case MIN_EXPR:
356 case MAX_EXPR:
357 case VEC_WIDEN_MULT_HI_EXPR:
358 case VEC_WIDEN_MULT_LO_EXPR:
359 case VEC_WIDEN_MULT_EVEN_EXPR:
360 case VEC_WIDEN_MULT_ODD_EXPR:
361 case VEC_PACK_TRUNC_EXPR:
362 case VEC_PACK_SAT_EXPR:
363 case VEC_PACK_FIX_TRUNC_EXPR:
364 case VEC_WIDEN_LSHIFT_HI_EXPR:
365 case VEC_WIDEN_LSHIFT_LO_EXPR:
366 for (p = get_tree_code_name (code); *p; p++)
367 pp_character (buffer, TOUPPER (*p));
368 pp_string (buffer, " <");
369 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
370 pp_string (buffer, ", ");
371 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
372 pp_greater (buffer);
373 break;
374
375 default:
376 if (op_prio (gimple_assign_rhs1 (gs)) <= op_code_prio (code))
377 {
378 pp_left_paren (buffer);
379 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags,
380 false);
381 pp_right_paren (buffer);
382 }
383 else
384 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
385 pp_space (buffer);
386 pp_string (buffer, op_symbol_code (gimple_assign_rhs_code (gs)));
387 pp_space (buffer);
388 if (op_prio (gimple_assign_rhs2 (gs)) <= op_code_prio (code))
389 {
390 pp_left_paren (buffer);
391 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags,
392 false);
393 pp_right_paren (buffer);
394 }
395 else
396 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
397 }
398 }
399
400 /* Helper for dump_gimple_assign. Print the ternary RHS of the
401 assignment GS. BUFFER, SPC and FLAGS are as in pp_gimple_stmt_1. */
402
403 static void
dump_ternary_rhs(pretty_printer * buffer,gimple gs,int spc,int flags)404 dump_ternary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
405 {
406 const char *p;
407 enum tree_code code = gimple_assign_rhs_code (gs);
408 switch (code)
409 {
410 case WIDEN_MULT_PLUS_EXPR:
411 case WIDEN_MULT_MINUS_EXPR:
412 for (p = get_tree_code_name (code); *p; p++)
413 pp_character (buffer, TOUPPER (*p));
414 pp_string (buffer, " <");
415 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
416 pp_string (buffer, ", ");
417 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
418 pp_string (buffer, ", ");
419 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
420 pp_greater (buffer);
421 break;
422
423 case FMA_EXPR:
424 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
425 pp_string (buffer, " * ");
426 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
427 pp_string (buffer, " + ");
428 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
429 break;
430
431 case DOT_PROD_EXPR:
432 pp_string (buffer, "DOT_PROD_EXPR <");
433 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
434 pp_string (buffer, ", ");
435 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
436 pp_string (buffer, ", ");
437 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
438 pp_greater (buffer);
439 break;
440
441 case VEC_PERM_EXPR:
442 pp_string (buffer, "VEC_PERM_EXPR <");
443 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
444 pp_string (buffer, ", ");
445 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
446 pp_string (buffer, ", ");
447 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
448 pp_greater (buffer);
449 break;
450
451 case REALIGN_LOAD_EXPR:
452 pp_string (buffer, "REALIGN_LOAD <");
453 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
454 pp_string (buffer, ", ");
455 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
456 pp_string (buffer, ", ");
457 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
458 pp_greater (buffer);
459 break;
460
461 case COND_EXPR:
462 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
463 pp_string (buffer, " ? ");
464 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
465 pp_string (buffer, " : ");
466 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
467 break;
468
469 case VEC_COND_EXPR:
470 pp_string (buffer, "VEC_COND_EXPR <");
471 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
472 pp_string (buffer, ", ");
473 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
474 pp_string (buffer, ", ");
475 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
476 pp_greater (buffer);
477 break;
478
479 default:
480 gcc_unreachable ();
481 }
482 }
483
484
485 /* Dump the gimple assignment GS. BUFFER, SPC and FLAGS are as in
486 pp_gimple_stmt_1. */
487
488 static void
dump_gimple_assign(pretty_printer * buffer,gimple gs,int spc,int flags)489 dump_gimple_assign (pretty_printer *buffer, gimple gs, int spc, int flags)
490 {
491 if (flags & TDF_RAW)
492 {
493 tree arg1 = NULL;
494 tree arg2 = NULL;
495 tree arg3 = NULL;
496 switch (gimple_num_ops (gs))
497 {
498 case 4:
499 arg3 = gimple_assign_rhs3 (gs);
500 case 3:
501 arg2 = gimple_assign_rhs2 (gs);
502 case 2:
503 arg1 = gimple_assign_rhs1 (gs);
504 break;
505 default:
506 gcc_unreachable ();
507 }
508
509 dump_gimple_fmt (buffer, spc, flags, "%G <%s, %T, %T, %T, %T>", gs,
510 get_tree_code_name (gimple_assign_rhs_code (gs)),
511 gimple_assign_lhs (gs), arg1, arg2, arg3);
512 }
513 else
514 {
515 if (!(flags & TDF_RHS_ONLY))
516 {
517 dump_generic_node (buffer, gimple_assign_lhs (gs), spc, flags, false);
518 pp_space (buffer);
519 pp_equal (buffer);
520
521 if (gimple_assign_nontemporal_move_p (gs))
522 pp_string (buffer, "{nt}");
523
524 if (gimple_has_volatile_ops (gs))
525 pp_string (buffer, "{v}");
526
527 pp_space (buffer);
528 }
529
530 if (gimple_num_ops (gs) == 2)
531 dump_unary_rhs (buffer, gs, spc, flags);
532 else if (gimple_num_ops (gs) == 3)
533 dump_binary_rhs (buffer, gs, spc, flags);
534 else if (gimple_num_ops (gs) == 4)
535 dump_ternary_rhs (buffer, gs, spc, flags);
536 else
537 gcc_unreachable ();
538 if (!(flags & TDF_RHS_ONLY))
539 pp_semicolon (buffer);
540 }
541 }
542
543
544 /* Dump the return statement GS. BUFFER, SPC and FLAGS are as in
545 pp_gimple_stmt_1. */
546
547 static void
dump_gimple_return(pretty_printer * buffer,gimple gs,int spc,int flags)548 dump_gimple_return (pretty_printer *buffer, gimple gs, int spc, int flags)
549 {
550 tree t;
551
552 t = gimple_return_retval (gs);
553 if (flags & TDF_RAW)
554 dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, t);
555 else
556 {
557 pp_string (buffer, "return");
558 if (t)
559 {
560 pp_space (buffer);
561 dump_generic_node (buffer, t, spc, flags, false);
562 }
563 pp_semicolon (buffer);
564 }
565 }
566
567
568 /* Dump the call arguments for a gimple call. BUFFER, FLAGS are as in
569 dump_gimple_call. */
570
571 static void
dump_gimple_call_args(pretty_printer * buffer,gimple gs,int flags)572 dump_gimple_call_args (pretty_printer *buffer, gimple gs, int flags)
573 {
574 size_t i;
575
576 for (i = 0; i < gimple_call_num_args (gs); i++)
577 {
578 dump_generic_node (buffer, gimple_call_arg (gs, i), 0, flags, false);
579 if (i < gimple_call_num_args (gs) - 1)
580 pp_string (buffer, ", ");
581 }
582
583 if (gimple_call_va_arg_pack_p (gs))
584 {
585 if (gimple_call_num_args (gs) > 0)
586 {
587 pp_comma (buffer);
588 pp_space (buffer);
589 }
590
591 pp_string (buffer, "__builtin_va_arg_pack ()");
592 }
593 }
594
595 /* Dump the points-to solution *PT to BUFFER. */
596
597 static void
pp_points_to_solution(pretty_printer * buffer,struct pt_solution * pt)598 pp_points_to_solution (pretty_printer *buffer, struct pt_solution *pt)
599 {
600 if (pt->anything)
601 {
602 pp_string (buffer, "anything ");
603 return;
604 }
605 if (pt->nonlocal)
606 pp_string (buffer, "nonlocal ");
607 if (pt->escaped)
608 pp_string (buffer, "escaped ");
609 if (pt->ipa_escaped)
610 pp_string (buffer, "unit-escaped ");
611 if (pt->null)
612 pp_string (buffer, "null ");
613 if (pt->vars
614 && !bitmap_empty_p (pt->vars))
615 {
616 bitmap_iterator bi;
617 unsigned i;
618 pp_string (buffer, "{ ");
619 EXECUTE_IF_SET_IN_BITMAP (pt->vars, 0, i, bi)
620 {
621 pp_string (buffer, "D.");
622 pp_decimal_int (buffer, i);
623 pp_space (buffer);
624 }
625 pp_right_brace (buffer);
626 if (pt->vars_contains_nonlocal
627 && pt->vars_contains_escaped_heap)
628 pp_string (buffer, " (nonlocal, escaped heap)");
629 else if (pt->vars_contains_nonlocal
630 && pt->vars_contains_escaped)
631 pp_string (buffer, " (nonlocal, escaped)");
632 else if (pt->vars_contains_nonlocal)
633 pp_string (buffer, " (nonlocal)");
634 else if (pt->vars_contains_escaped_heap)
635 pp_string (buffer, " (escaped heap)");
636 else if (pt->vars_contains_escaped)
637 pp_string (buffer, " (escaped)");
638 }
639 }
640
641 /* Dump the call statement GS. BUFFER, SPC and FLAGS are as in
642 pp_gimple_stmt_1. */
643
644 static void
dump_gimple_call(pretty_printer * buffer,gimple gs,int spc,int flags)645 dump_gimple_call (pretty_printer *buffer, gimple gs, int spc, int flags)
646 {
647 tree lhs = gimple_call_lhs (gs);
648 tree fn = gimple_call_fn (gs);
649
650 if (flags & TDF_ALIAS)
651 {
652 struct pt_solution *pt;
653 pt = gimple_call_use_set (gs);
654 if (!pt_solution_empty_p (pt))
655 {
656 pp_string (buffer, "# USE = ");
657 pp_points_to_solution (buffer, pt);
658 newline_and_indent (buffer, spc);
659 }
660 pt = gimple_call_clobber_set (gs);
661 if (!pt_solution_empty_p (pt))
662 {
663 pp_string (buffer, "# CLB = ");
664 pp_points_to_solution (buffer, pt);
665 newline_and_indent (buffer, spc);
666 }
667 }
668
669 if (flags & TDF_RAW)
670 {
671 if (gimple_call_internal_p (gs))
672 dump_gimple_fmt (buffer, spc, flags, "%G <%s, %T", gs,
673 internal_fn_name (gimple_call_internal_fn (gs)), lhs);
674 else
675 dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T", gs, fn, lhs);
676 if (gimple_call_num_args (gs) > 0)
677 {
678 pp_string (buffer, ", ");
679 dump_gimple_call_args (buffer, gs, flags);
680 }
681 pp_greater (buffer);
682 }
683 else
684 {
685 if (lhs && !(flags & TDF_RHS_ONLY))
686 {
687 dump_generic_node (buffer, lhs, spc, flags, false);
688 pp_string (buffer, " =");
689
690 if (gimple_has_volatile_ops (gs))
691 pp_string (buffer, "{v}");
692
693 pp_space (buffer);
694 }
695 if (gimple_call_internal_p (gs))
696 pp_string (buffer, internal_fn_name (gimple_call_internal_fn (gs)));
697 else
698 print_call_name (buffer, fn, flags);
699 pp_string (buffer, " (");
700 dump_gimple_call_args (buffer, gs, flags);
701 pp_right_paren (buffer);
702 if (!(flags & TDF_RHS_ONLY))
703 pp_semicolon (buffer);
704 }
705
706 if (gimple_call_chain (gs))
707 {
708 pp_string (buffer, " [static-chain: ");
709 dump_generic_node (buffer, gimple_call_chain (gs), spc, flags, false);
710 pp_right_bracket (buffer);
711 }
712
713 if (gimple_call_return_slot_opt_p (gs))
714 pp_string (buffer, " [return slot optimization]");
715 if (gimple_call_tail_p (gs))
716 pp_string (buffer, " [tail call]");
717
718 if (fn == NULL)
719 return;
720
721 /* Dump the arguments of _ITM_beginTransaction sanely. */
722 if (TREE_CODE (fn) == ADDR_EXPR)
723 fn = TREE_OPERAND (fn, 0);
724 if (TREE_CODE (fn) == FUNCTION_DECL && decl_is_tm_clone (fn))
725 pp_string (buffer, " [tm-clone]");
726 if (TREE_CODE (fn) == FUNCTION_DECL
727 && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL
728 && DECL_FUNCTION_CODE (fn) == BUILT_IN_TM_START
729 && gimple_call_num_args (gs) > 0)
730 {
731 tree t = gimple_call_arg (gs, 0);
732 unsigned HOST_WIDE_INT props;
733 gcc_assert (TREE_CODE (t) == INTEGER_CST);
734
735 pp_string (buffer, " [ ");
736
737 /* Get the transaction code properties. */
738 props = TREE_INT_CST_LOW (t);
739
740 if (props & PR_INSTRUMENTEDCODE)
741 pp_string (buffer, "instrumentedCode ");
742 if (props & PR_UNINSTRUMENTEDCODE)
743 pp_string (buffer, "uninstrumentedCode ");
744 if (props & PR_HASNOXMMUPDATE)
745 pp_string (buffer, "hasNoXMMUpdate ");
746 if (props & PR_HASNOABORT)
747 pp_string (buffer, "hasNoAbort ");
748 if (props & PR_HASNOIRREVOCABLE)
749 pp_string (buffer, "hasNoIrrevocable ");
750 if (props & PR_DOESGOIRREVOCABLE)
751 pp_string (buffer, "doesGoIrrevocable ");
752 if (props & PR_HASNOSIMPLEREADS)
753 pp_string (buffer, "hasNoSimpleReads ");
754 if (props & PR_AWBARRIERSOMITTED)
755 pp_string (buffer, "awBarriersOmitted ");
756 if (props & PR_RARBARRIERSOMITTED)
757 pp_string (buffer, "RaRBarriersOmitted ");
758 if (props & PR_UNDOLOGCODE)
759 pp_string (buffer, "undoLogCode ");
760 if (props & PR_PREFERUNINSTRUMENTED)
761 pp_string (buffer, "preferUninstrumented ");
762 if (props & PR_EXCEPTIONBLOCK)
763 pp_string (buffer, "exceptionBlock ");
764 if (props & PR_HASELSE)
765 pp_string (buffer, "hasElse ");
766 if (props & PR_READONLY)
767 pp_string (buffer, "readOnly ");
768
769 pp_right_bracket (buffer);
770 }
771 }
772
773
774 /* Dump the switch statement GS. BUFFER, SPC and FLAGS are as in
775 pp_gimple_stmt_1. */
776
777 static void
dump_gimple_switch(pretty_printer * buffer,gimple gs,int spc,int flags)778 dump_gimple_switch (pretty_printer *buffer, gimple gs, int spc, int flags)
779 {
780 unsigned int i;
781
782 GIMPLE_CHECK (gs, GIMPLE_SWITCH);
783 if (flags & TDF_RAW)
784 dump_gimple_fmt (buffer, spc, flags, "%G <%T, ", gs,
785 gimple_switch_index (gs));
786 else
787 {
788 pp_string (buffer, "switch (");
789 dump_generic_node (buffer, gimple_switch_index (gs), spc, flags, true);
790 pp_string (buffer, ") <");
791 }
792
793 for (i = 0; i < gimple_switch_num_labels (gs); i++)
794 {
795 tree case_label = gimple_switch_label (gs, i);
796 gcc_checking_assert (case_label != NULL_TREE);
797 dump_generic_node (buffer, case_label, spc, flags, false);
798 pp_space (buffer);
799 dump_generic_node (buffer, CASE_LABEL (case_label), spc, flags, false);
800 if (i < gimple_switch_num_labels (gs) - 1)
801 pp_string (buffer, ", ");
802 }
803 pp_greater (buffer);
804 }
805
806
807 /* Dump the gimple conditional GS. BUFFER, SPC and FLAGS are as in
808 pp_gimple_stmt_1. */
809
810 static void
dump_gimple_cond(pretty_printer * buffer,gimple gs,int spc,int flags)811 dump_gimple_cond (pretty_printer *buffer, gimple gs, int spc, int flags)
812 {
813 if (flags & TDF_RAW)
814 dump_gimple_fmt (buffer, spc, flags, "%G <%s, %T, %T, %T, %T>", gs,
815 get_tree_code_name (gimple_cond_code (gs)),
816 gimple_cond_lhs (gs), gimple_cond_rhs (gs),
817 gimple_cond_true_label (gs), gimple_cond_false_label (gs));
818 else
819 {
820 if (!(flags & TDF_RHS_ONLY))
821 pp_string (buffer, "if (");
822 dump_generic_node (buffer, gimple_cond_lhs (gs), spc, flags, false);
823 pp_space (buffer);
824 pp_string (buffer, op_symbol_code (gimple_cond_code (gs)));
825 pp_space (buffer);
826 dump_generic_node (buffer, gimple_cond_rhs (gs), spc, flags, false);
827 if (!(flags & TDF_RHS_ONLY))
828 {
829 pp_right_paren (buffer);
830
831 if (gimple_cond_true_label (gs))
832 {
833 pp_string (buffer, " goto ");
834 dump_generic_node (buffer, gimple_cond_true_label (gs),
835 spc, flags, false);
836 pp_semicolon (buffer);
837 }
838 if (gimple_cond_false_label (gs))
839 {
840 pp_string (buffer, " else goto ");
841 dump_generic_node (buffer, gimple_cond_false_label (gs),
842 spc, flags, false);
843 pp_semicolon (buffer);
844 }
845 }
846 }
847 }
848
849
850 /* Dump a GIMPLE_LABEL tuple on the pretty_printer BUFFER, SPC
851 spaces of indent. FLAGS specifies details to show in the dump (see
852 TDF_* in dumpfils.h). */
853
854 static void
dump_gimple_label(pretty_printer * buffer,gimple gs,int spc,int flags)855 dump_gimple_label (pretty_printer *buffer, gimple gs, int spc, int flags)
856 {
857 tree label = gimple_label_label (gs);
858 if (flags & TDF_RAW)
859 dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, label);
860 else
861 {
862 dump_generic_node (buffer, label, spc, flags, false);
863 pp_colon (buffer);
864 }
865 if (DECL_NONLOCAL (label))
866 pp_string (buffer, " [non-local]");
867 if ((flags & TDF_EH) && EH_LANDING_PAD_NR (label))
868 pp_printf (buffer, " [LP %d]", EH_LANDING_PAD_NR (label));
869 }
870
871 /* Dump a GIMPLE_GOTO tuple on the pretty_printer BUFFER, SPC
872 spaces of indent. FLAGS specifies details to show in the dump (see
873 TDF_* in dumpfile.h). */
874
875 static void
dump_gimple_goto(pretty_printer * buffer,gimple gs,int spc,int flags)876 dump_gimple_goto (pretty_printer *buffer, gimple gs, int spc, int flags)
877 {
878 tree label = gimple_goto_dest (gs);
879 if (flags & TDF_RAW)
880 dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, label);
881 else
882 dump_gimple_fmt (buffer, spc, flags, "goto %T;", label);
883 }
884
885
886 /* Dump a GIMPLE_BIND tuple on the pretty_printer BUFFER, SPC
887 spaces of indent. FLAGS specifies details to show in the dump (see
888 TDF_* in dumpfile.h). */
889
890 static void
dump_gimple_bind(pretty_printer * buffer,gimple gs,int spc,int flags)891 dump_gimple_bind (pretty_printer *buffer, gimple gs, int spc, int flags)
892 {
893 if (flags & TDF_RAW)
894 dump_gimple_fmt (buffer, spc, flags, "%G <", gs);
895 else
896 pp_left_brace (buffer);
897 if (!(flags & TDF_SLIM))
898 {
899 tree var;
900
901 for (var = gimple_bind_vars (gs); var; var = DECL_CHAIN (var))
902 {
903 newline_and_indent (buffer, 2);
904 print_declaration (buffer, var, spc, flags);
905 }
906 if (gimple_bind_vars (gs))
907 pp_newline (buffer);
908 }
909 pp_newline (buffer);
910 dump_gimple_seq (buffer, gimple_bind_body (gs), spc + 2, flags);
911 newline_and_indent (buffer, spc);
912 if (flags & TDF_RAW)
913 pp_greater (buffer);
914 else
915 pp_right_brace (buffer);
916 }
917
918
919 /* Dump a GIMPLE_TRY tuple on the pretty_printer BUFFER, SPC spaces of
920 indent. FLAGS specifies details to show in the dump (see TDF_* in
921 dumpfile.h). */
922
923 static void
dump_gimple_try(pretty_printer * buffer,gimple gs,int spc,int flags)924 dump_gimple_try (pretty_printer *buffer, gimple gs, int spc, int flags)
925 {
926 if (flags & TDF_RAW)
927 {
928 const char *type;
929 if (gimple_try_kind (gs) == GIMPLE_TRY_CATCH)
930 type = "GIMPLE_TRY_CATCH";
931 else if (gimple_try_kind (gs) == GIMPLE_TRY_FINALLY)
932 type = "GIMPLE_TRY_FINALLY";
933 else
934 type = "UNKNOWN GIMPLE_TRY";
935 dump_gimple_fmt (buffer, spc, flags,
936 "%G <%s,%+EVAL <%S>%nCLEANUP <%S>%->", gs, type,
937 gimple_try_eval (gs), gimple_try_cleanup (gs));
938 }
939 else
940 {
941 pp_string (buffer, "try");
942 newline_and_indent (buffer, spc + 2);
943 pp_left_brace (buffer);
944 pp_newline (buffer);
945
946 dump_gimple_seq (buffer, gimple_try_eval (gs), spc + 4, flags);
947 newline_and_indent (buffer, spc + 2);
948 pp_right_brace (buffer);
949
950 if (gimple_try_kind (gs) == GIMPLE_TRY_CATCH)
951 {
952 newline_and_indent (buffer, spc);
953 pp_string (buffer, "catch");
954 newline_and_indent (buffer, spc + 2);
955 pp_left_brace (buffer);
956 }
957 else if (gimple_try_kind (gs) == GIMPLE_TRY_FINALLY)
958 {
959 newline_and_indent (buffer, spc);
960 pp_string (buffer, "finally");
961 newline_and_indent (buffer, spc + 2);
962 pp_left_brace (buffer);
963 }
964 else
965 pp_string (buffer, " <UNKNOWN GIMPLE_TRY> {");
966
967 pp_newline (buffer);
968 dump_gimple_seq (buffer, gimple_try_cleanup (gs), spc + 4, flags);
969 newline_and_indent (buffer, spc + 2);
970 pp_right_brace (buffer);
971 }
972 }
973
974
975 /* Dump a GIMPLE_CATCH tuple on the pretty_printer BUFFER, SPC spaces of
976 indent. FLAGS specifies details to show in the dump (see TDF_* in
977 dumpfile.h). */
978
979 static void
dump_gimple_catch(pretty_printer * buffer,gimple gs,int spc,int flags)980 dump_gimple_catch (pretty_printer *buffer, gimple gs, int spc, int flags)
981 {
982 if (flags & TDF_RAW)
983 dump_gimple_fmt (buffer, spc, flags, "%G <%T, %+CATCH <%S>%->", gs,
984 gimple_catch_types (gs), gimple_catch_handler (gs));
985 else
986 dump_gimple_fmt (buffer, spc, flags, "catch (%T)%+{%S}",
987 gimple_catch_types (gs), gimple_catch_handler (gs));
988 }
989
990
991 /* Dump a GIMPLE_EH_FILTER tuple on the pretty_printer BUFFER, SPC spaces of
992 indent. FLAGS specifies details to show in the dump (see TDF_* in
993 dumpfile.h). */
994
995 static void
dump_gimple_eh_filter(pretty_printer * buffer,gimple gs,int spc,int flags)996 dump_gimple_eh_filter (pretty_printer *buffer, gimple gs, int spc, int flags)
997 {
998 if (flags & TDF_RAW)
999 dump_gimple_fmt (buffer, spc, flags, "%G <%T, %+FAILURE <%S>%->", gs,
1000 gimple_eh_filter_types (gs),
1001 gimple_eh_filter_failure (gs));
1002 else
1003 dump_gimple_fmt (buffer, spc, flags, "<<<eh_filter (%T)>>>%+{%+%S%-}",
1004 gimple_eh_filter_types (gs),
1005 gimple_eh_filter_failure (gs));
1006 }
1007
1008
1009 /* Dump a GIMPLE_EH_MUST_NOT_THROW tuple. */
1010
1011 static void
dump_gimple_eh_must_not_throw(pretty_printer * buffer,gimple gs,int spc,int flags)1012 dump_gimple_eh_must_not_throw (pretty_printer *buffer, gimple gs,
1013 int spc, int flags)
1014 {
1015 if (flags & TDF_RAW)
1016 dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs,
1017 gimple_eh_must_not_throw_fndecl (gs));
1018 else
1019 dump_gimple_fmt (buffer, spc, flags, "<<<eh_must_not_throw (%T)>>>",
1020 gimple_eh_must_not_throw_fndecl (gs));
1021 }
1022
1023
1024 /* Dump a GIMPLE_EH_ELSE tuple on the pretty_printer BUFFER, SPC spaces of
1025 indent. FLAGS specifies details to show in the dump (see TDF_* in
1026 dumpfile.h). */
1027
1028 static void
dump_gimple_eh_else(pretty_printer * buffer,gimple gs,int spc,int flags)1029 dump_gimple_eh_else (pretty_printer *buffer, gimple gs, int spc, int flags)
1030 {
1031 if (flags & TDF_RAW)
1032 dump_gimple_fmt (buffer, spc, flags,
1033 "%G <%+N_BODY <%S>%nE_BODY <%S>%->", gs,
1034 gimple_eh_else_n_body (gs), gimple_eh_else_e_body (gs));
1035 else
1036 dump_gimple_fmt (buffer, spc, flags,
1037 "<<<if_normal_exit>>>%+{%S}%-<<<else_eh_exit>>>%+{%S}",
1038 gimple_eh_else_n_body (gs), gimple_eh_else_e_body (gs));
1039 }
1040
1041
1042 /* Dump a GIMPLE_RESX tuple on the pretty_printer BUFFER, SPC spaces of
1043 indent. FLAGS specifies details to show in the dump (see TDF_* in
1044 dumpfile.h). */
1045
1046 static void
dump_gimple_resx(pretty_printer * buffer,gimple gs,int spc,int flags)1047 dump_gimple_resx (pretty_printer *buffer, gimple gs, int spc, int flags)
1048 {
1049 if (flags & TDF_RAW)
1050 dump_gimple_fmt (buffer, spc, flags, "%G <%d>", gs,
1051 gimple_resx_region (gs));
1052 else
1053 dump_gimple_fmt (buffer, spc, flags, "resx %d", gimple_resx_region (gs));
1054 }
1055
1056 /* Dump a GIMPLE_EH_DISPATCH tuple on the pretty_printer BUFFER. */
1057
1058 static void
dump_gimple_eh_dispatch(pretty_printer * buffer,gimple gs,int spc,int flags)1059 dump_gimple_eh_dispatch (pretty_printer *buffer, gimple gs, int spc, int flags)
1060 {
1061 if (flags & TDF_RAW)
1062 dump_gimple_fmt (buffer, spc, flags, "%G <%d>", gs,
1063 gimple_eh_dispatch_region (gs));
1064 else
1065 dump_gimple_fmt (buffer, spc, flags, "eh_dispatch %d",
1066 gimple_eh_dispatch_region (gs));
1067 }
1068
1069 /* Dump a GIMPLE_DEBUG tuple on the pretty_printer BUFFER, SPC spaces
1070 of indent. FLAGS specifies details to show in the dump (see TDF_*
1071 in dumpfile.h). */
1072
1073 static void
dump_gimple_debug(pretty_printer * buffer,gimple gs,int spc,int flags)1074 dump_gimple_debug (pretty_printer *buffer, gimple gs, int spc, int flags)
1075 {
1076 switch (gs->subcode)
1077 {
1078 case GIMPLE_DEBUG_BIND:
1079 if (flags & TDF_RAW)
1080 dump_gimple_fmt (buffer, spc, flags, "%G BIND <%T, %T>", gs,
1081 gimple_debug_bind_get_var (gs),
1082 gimple_debug_bind_get_value (gs));
1083 else
1084 dump_gimple_fmt (buffer, spc, flags, "# DEBUG %T => %T",
1085 gimple_debug_bind_get_var (gs),
1086 gimple_debug_bind_get_value (gs));
1087 break;
1088
1089 case GIMPLE_DEBUG_SOURCE_BIND:
1090 if (flags & TDF_RAW)
1091 dump_gimple_fmt (buffer, spc, flags, "%G SRCBIND <%T, %T>", gs,
1092 gimple_debug_source_bind_get_var (gs),
1093 gimple_debug_source_bind_get_value (gs));
1094 else
1095 dump_gimple_fmt (buffer, spc, flags, "# DEBUG %T s=> %T",
1096 gimple_debug_source_bind_get_var (gs),
1097 gimple_debug_source_bind_get_value (gs));
1098 break;
1099
1100 default:
1101 gcc_unreachable ();
1102 }
1103 }
1104
1105 /* Dump a GIMPLE_OMP_FOR tuple on the pretty_printer BUFFER. */
1106 static void
dump_gimple_omp_for(pretty_printer * buffer,gimple gs,int spc,int flags)1107 dump_gimple_omp_for (pretty_printer *buffer, gimple gs, int spc, int flags)
1108 {
1109 size_t i;
1110
1111 if (flags & TDF_RAW)
1112 {
1113 const char *kind;
1114 switch (gimple_omp_for_kind (gs))
1115 {
1116 case GF_OMP_FOR_KIND_FOR:
1117 kind = "";
1118 break;
1119 case GF_OMP_FOR_KIND_SIMD:
1120 kind = " simd";
1121 break;
1122 case GF_OMP_FOR_KIND_CILKSIMD:
1123 kind = " cilksimd";
1124 break;
1125 case GF_OMP_FOR_KIND_DISTRIBUTE:
1126 kind = " distribute";
1127 break;
1128 default:
1129 gcc_unreachable ();
1130 }
1131 dump_gimple_fmt (buffer, spc, flags, "%G%s <%+BODY <%S>%nCLAUSES <", gs,
1132 kind, gimple_omp_body (gs));
1133 dump_omp_clauses (buffer, gimple_omp_for_clauses (gs), spc, flags);
1134 dump_gimple_fmt (buffer, spc, flags, " >,");
1135 for (i = 0; i < gimple_omp_for_collapse (gs); i++)
1136 dump_gimple_fmt (buffer, spc, flags,
1137 "%+%T, %T, %T, %s, %T,%n",
1138 gimple_omp_for_index (gs, i),
1139 gimple_omp_for_initial (gs, i),
1140 gimple_omp_for_final (gs, i),
1141 get_tree_code_name (gimple_omp_for_cond (gs, i)),
1142 gimple_omp_for_incr (gs, i));
1143 dump_gimple_fmt (buffer, spc, flags, "PRE_BODY <%S>%->",
1144 gimple_omp_for_pre_body (gs));
1145 }
1146 else
1147 {
1148 switch (gimple_omp_for_kind (gs))
1149 {
1150 case GF_OMP_FOR_KIND_FOR:
1151 pp_string (buffer, "#pragma omp for");
1152 break;
1153 case GF_OMP_FOR_KIND_SIMD:
1154 pp_string (buffer, "#pragma omp simd");
1155 break;
1156 case GF_OMP_FOR_KIND_CILKSIMD:
1157 pp_string (buffer, "#pragma simd");
1158 break;
1159 case GF_OMP_FOR_KIND_DISTRIBUTE:
1160 pp_string (buffer, "#pragma omp distribute");
1161 break;
1162 default:
1163 gcc_unreachable ();
1164 }
1165 dump_omp_clauses (buffer, gimple_omp_for_clauses (gs), spc, flags);
1166 for (i = 0; i < gimple_omp_for_collapse (gs); i++)
1167 {
1168 if (i)
1169 spc += 2;
1170 newline_and_indent (buffer, spc);
1171 pp_string (buffer, "for (");
1172 dump_generic_node (buffer, gimple_omp_for_index (gs, i), spc,
1173 flags, false);
1174 pp_string (buffer, " = ");
1175 dump_generic_node (buffer, gimple_omp_for_initial (gs, i), spc,
1176 flags, false);
1177 pp_string (buffer, "; ");
1178
1179 dump_generic_node (buffer, gimple_omp_for_index (gs, i), spc,
1180 flags, false);
1181 pp_space (buffer);
1182 switch (gimple_omp_for_cond (gs, i))
1183 {
1184 case LT_EXPR:
1185 pp_less (buffer);
1186 break;
1187 case GT_EXPR:
1188 pp_greater (buffer);
1189 break;
1190 case LE_EXPR:
1191 pp_less_equal (buffer);
1192 break;
1193 case GE_EXPR:
1194 pp_greater_equal (buffer);
1195 break;
1196 default:
1197 gcc_unreachable ();
1198 }
1199 pp_space (buffer);
1200 dump_generic_node (buffer, gimple_omp_for_final (gs, i), spc,
1201 flags, false);
1202 pp_string (buffer, "; ");
1203
1204 dump_generic_node (buffer, gimple_omp_for_index (gs, i), spc,
1205 flags, false);
1206 pp_string (buffer, " = ");
1207 dump_generic_node (buffer, gimple_omp_for_incr (gs, i), spc,
1208 flags, false);
1209 pp_right_paren (buffer);
1210 }
1211
1212 if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1213 {
1214 newline_and_indent (buffer, spc + 2);
1215 pp_left_brace (buffer);
1216 pp_newline (buffer);
1217 dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
1218 newline_and_indent (buffer, spc + 2);
1219 pp_right_brace (buffer);
1220 }
1221 }
1222 }
1223
1224 /* Dump a GIMPLE_OMP_CONTINUE tuple on the pretty_printer BUFFER. */
1225
1226 static void
dump_gimple_omp_continue(pretty_printer * buffer,gimple gs,int spc,int flags)1227 dump_gimple_omp_continue (pretty_printer *buffer, gimple gs, int spc, int flags)
1228 {
1229 if (flags & TDF_RAW)
1230 {
1231 dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T>", gs,
1232 gimple_omp_continue_control_def (gs),
1233 gimple_omp_continue_control_use (gs));
1234 }
1235 else
1236 {
1237 pp_string (buffer, "#pragma omp continue (");
1238 dump_generic_node (buffer, gimple_omp_continue_control_def (gs),
1239 spc, flags, false);
1240 pp_comma (buffer);
1241 pp_space (buffer);
1242 dump_generic_node (buffer, gimple_omp_continue_control_use (gs),
1243 spc, flags, false);
1244 pp_right_paren (buffer);
1245 }
1246 }
1247
1248 /* Dump a GIMPLE_OMP_SINGLE tuple on the pretty_printer BUFFER. */
1249
1250 static void
dump_gimple_omp_single(pretty_printer * buffer,gimple gs,int spc,int flags)1251 dump_gimple_omp_single (pretty_printer *buffer, gimple gs, int spc, int flags)
1252 {
1253 if (flags & TDF_RAW)
1254 {
1255 dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
1256 gimple_omp_body (gs));
1257 dump_omp_clauses (buffer, gimple_omp_single_clauses (gs), spc, flags);
1258 dump_gimple_fmt (buffer, spc, flags, " >");
1259 }
1260 else
1261 {
1262 pp_string (buffer, "#pragma omp single");
1263 dump_omp_clauses (buffer, gimple_omp_single_clauses (gs), spc, flags);
1264 if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1265 {
1266 newline_and_indent (buffer, spc + 2);
1267 pp_left_brace (buffer);
1268 pp_newline (buffer);
1269 dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
1270 newline_and_indent (buffer, spc + 2);
1271 pp_right_brace (buffer);
1272 }
1273 }
1274 }
1275
1276 /* Dump a GIMPLE_OMP_TARGET tuple on the pretty_printer BUFFER. */
1277
1278 static void
dump_gimple_omp_target(pretty_printer * buffer,gimple gs,int spc,int flags)1279 dump_gimple_omp_target (pretty_printer *buffer, gimple gs, int spc, int flags)
1280 {
1281 const char *kind;
1282 switch (gimple_omp_target_kind (gs))
1283 {
1284 case GF_OMP_TARGET_KIND_REGION:
1285 kind = "";
1286 break;
1287 case GF_OMP_TARGET_KIND_DATA:
1288 kind = " data";
1289 break;
1290 case GF_OMP_TARGET_KIND_UPDATE:
1291 kind = " update";
1292 break;
1293 default:
1294 gcc_unreachable ();
1295 }
1296 if (flags & TDF_RAW)
1297 {
1298 dump_gimple_fmt (buffer, spc, flags, "%G%s <%+BODY <%S>%nCLAUSES <", gs,
1299 kind, gimple_omp_body (gs));
1300 dump_omp_clauses (buffer, gimple_omp_target_clauses (gs), spc, flags);
1301 dump_gimple_fmt (buffer, spc, flags, " >");
1302 }
1303 else
1304 {
1305 pp_string (buffer, "#pragma omp target");
1306 pp_string (buffer, kind);
1307 dump_omp_clauses (buffer, gimple_omp_target_clauses (gs), spc, flags);
1308 if (gimple_omp_target_child_fn (gs))
1309 {
1310 pp_string (buffer, " [child fn: ");
1311 dump_generic_node (buffer, gimple_omp_target_child_fn (gs),
1312 spc, flags, false);
1313 pp_right_bracket (buffer);
1314 }
1315 if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1316 {
1317 newline_and_indent (buffer, spc + 2);
1318 pp_character (buffer, '{');
1319 pp_newline (buffer);
1320 dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
1321 newline_and_indent (buffer, spc + 2);
1322 pp_character (buffer, '}');
1323 }
1324 }
1325 }
1326
1327 /* Dump a GIMPLE_OMP_TEAMS tuple on the pretty_printer BUFFER. */
1328
1329 static void
dump_gimple_omp_teams(pretty_printer * buffer,gimple gs,int spc,int flags)1330 dump_gimple_omp_teams (pretty_printer *buffer, gimple gs, int spc, int flags)
1331 {
1332 if (flags & TDF_RAW)
1333 {
1334 dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
1335 gimple_omp_body (gs));
1336 dump_omp_clauses (buffer, gimple_omp_teams_clauses (gs), spc, flags);
1337 dump_gimple_fmt (buffer, spc, flags, " >");
1338 }
1339 else
1340 {
1341 pp_string (buffer, "#pragma omp teams");
1342 dump_omp_clauses (buffer, gimple_omp_teams_clauses (gs), spc, flags);
1343 if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1344 {
1345 newline_and_indent (buffer, spc + 2);
1346 pp_character (buffer, '{');
1347 pp_newline (buffer);
1348 dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
1349 newline_and_indent (buffer, spc + 2);
1350 pp_character (buffer, '}');
1351 }
1352 }
1353 }
1354
1355 /* Dump a GIMPLE_OMP_SECTIONS tuple on the pretty_printer BUFFER. */
1356
1357 static void
dump_gimple_omp_sections(pretty_printer * buffer,gimple gs,int spc,int flags)1358 dump_gimple_omp_sections (pretty_printer *buffer, gimple gs, int spc,
1359 int flags)
1360 {
1361 if (flags & TDF_RAW)
1362 {
1363 dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
1364 gimple_omp_body (gs));
1365 dump_omp_clauses (buffer, gimple_omp_sections_clauses (gs), spc, flags);
1366 dump_gimple_fmt (buffer, spc, flags, " >");
1367 }
1368 else
1369 {
1370 pp_string (buffer, "#pragma omp sections");
1371 if (gimple_omp_sections_control (gs))
1372 {
1373 pp_string (buffer, " <");
1374 dump_generic_node (buffer, gimple_omp_sections_control (gs), spc,
1375 flags, false);
1376 pp_greater (buffer);
1377 }
1378 dump_omp_clauses (buffer, gimple_omp_sections_clauses (gs), spc, flags);
1379 if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1380 {
1381 newline_and_indent (buffer, spc + 2);
1382 pp_left_brace (buffer);
1383 pp_newline (buffer);
1384 dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
1385 newline_and_indent (buffer, spc + 2);
1386 pp_right_brace (buffer);
1387 }
1388 }
1389 }
1390
1391 /* Dump a GIMPLE_OMP_{MASTER,TASKGROUP,ORDERED,SECTION} tuple on the
1392 pretty_printer BUFFER. */
1393
1394 static void
dump_gimple_omp_block(pretty_printer * buffer,gimple gs,int spc,int flags)1395 dump_gimple_omp_block (pretty_printer *buffer, gimple gs, int spc, int flags)
1396 {
1397 if (flags & TDF_RAW)
1398 dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S> >", gs,
1399 gimple_omp_body (gs));
1400 else
1401 {
1402 switch (gimple_code (gs))
1403 {
1404 case GIMPLE_OMP_MASTER:
1405 pp_string (buffer, "#pragma omp master");
1406 break;
1407 case GIMPLE_OMP_TASKGROUP:
1408 pp_string (buffer, "#pragma omp taskgroup");
1409 break;
1410 case GIMPLE_OMP_ORDERED:
1411 pp_string (buffer, "#pragma omp ordered");
1412 break;
1413 case GIMPLE_OMP_SECTION:
1414 pp_string (buffer, "#pragma omp section");
1415 break;
1416 default:
1417 gcc_unreachable ();
1418 }
1419 if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1420 {
1421 newline_and_indent (buffer, spc + 2);
1422 pp_left_brace (buffer);
1423 pp_newline (buffer);
1424 dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
1425 newline_and_indent (buffer, spc + 2);
1426 pp_right_brace (buffer);
1427 }
1428 }
1429 }
1430
1431 /* Dump a GIMPLE_OMP_CRITICAL tuple on the pretty_printer BUFFER. */
1432
1433 static void
dump_gimple_omp_critical(pretty_printer * buffer,gimple gs,int spc,int flags)1434 dump_gimple_omp_critical (pretty_printer *buffer, gimple gs, int spc,
1435 int flags)
1436 {
1437 if (flags & TDF_RAW)
1438 dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S> >", gs,
1439 gimple_omp_body (gs));
1440 else
1441 {
1442 pp_string (buffer, "#pragma omp critical");
1443 if (gimple_omp_critical_name (gs))
1444 {
1445 pp_string (buffer, " (");
1446 dump_generic_node (buffer, gimple_omp_critical_name (gs), spc,
1447 flags, false);
1448 pp_right_paren (buffer);
1449 }
1450 if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1451 {
1452 newline_and_indent (buffer, spc + 2);
1453 pp_left_brace (buffer);
1454 pp_newline (buffer);
1455 dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
1456 newline_and_indent (buffer, spc + 2);
1457 pp_right_brace (buffer);
1458 }
1459 }
1460 }
1461
1462 /* Dump a GIMPLE_OMP_RETURN tuple on the pretty_printer BUFFER. */
1463
1464 static void
dump_gimple_omp_return(pretty_printer * buffer,gimple gs,int spc,int flags)1465 dump_gimple_omp_return (pretty_printer *buffer, gimple gs, int spc, int flags)
1466 {
1467 if (flags & TDF_RAW)
1468 {
1469 dump_gimple_fmt (buffer, spc, flags, "%G <nowait=%d", gs,
1470 (int) gimple_omp_return_nowait_p (gs));
1471 if (gimple_omp_return_lhs (gs))
1472 dump_gimple_fmt (buffer, spc, flags, ", lhs=%T>",
1473 gimple_omp_return_lhs (gs));
1474 else
1475 dump_gimple_fmt (buffer, spc, flags, ">");
1476 }
1477 else
1478 {
1479 pp_string (buffer, "#pragma omp return");
1480 if (gimple_omp_return_nowait_p (gs))
1481 pp_string (buffer, "(nowait)");
1482 if (gimple_omp_return_lhs (gs))
1483 {
1484 pp_string (buffer, " (set ");
1485 dump_generic_node (buffer, gimple_omp_return_lhs (gs),
1486 spc, flags, false);
1487 pp_character (buffer, ')');
1488 }
1489 }
1490 }
1491
1492 /* Dump a GIMPLE_TRANSACTION tuple on the pretty_printer BUFFER. */
1493
1494 static void
dump_gimple_transaction(pretty_printer * buffer,gimple gs,int spc,int flags)1495 dump_gimple_transaction (pretty_printer *buffer, gimple gs, int spc, int flags)
1496 {
1497 unsigned subcode = gimple_transaction_subcode (gs);
1498
1499 if (flags & TDF_RAW)
1500 {
1501 dump_gimple_fmt (buffer, spc, flags,
1502 "%G [SUBCODE=%x,LABEL=%T] <%+BODY <%S> >",
1503 gs, subcode, gimple_transaction_label (gs),
1504 gimple_transaction_body (gs));
1505 }
1506 else
1507 {
1508 if (subcode & GTMA_IS_OUTER)
1509 pp_string (buffer, "__transaction_atomic [[outer]]");
1510 else if (subcode & GTMA_IS_RELAXED)
1511 pp_string (buffer, "__transaction_relaxed");
1512 else
1513 pp_string (buffer, "__transaction_atomic");
1514 subcode &= ~GTMA_DECLARATION_MASK;
1515
1516 if (subcode || gimple_transaction_label (gs))
1517 {
1518 pp_string (buffer, " //");
1519 if (gimple_transaction_label (gs))
1520 {
1521 pp_string (buffer, " LABEL=");
1522 dump_generic_node (buffer, gimple_transaction_label (gs),
1523 spc, flags, false);
1524 }
1525 if (subcode)
1526 {
1527 pp_string (buffer, " SUBCODE=[ ");
1528 if (subcode & GTMA_HAVE_ABORT)
1529 {
1530 pp_string (buffer, "GTMA_HAVE_ABORT ");
1531 subcode &= ~GTMA_HAVE_ABORT;
1532 }
1533 if (subcode & GTMA_HAVE_LOAD)
1534 {
1535 pp_string (buffer, "GTMA_HAVE_LOAD ");
1536 subcode &= ~GTMA_HAVE_LOAD;
1537 }
1538 if (subcode & GTMA_HAVE_STORE)
1539 {
1540 pp_string (buffer, "GTMA_HAVE_STORE ");
1541 subcode &= ~GTMA_HAVE_STORE;
1542 }
1543 if (subcode & GTMA_MAY_ENTER_IRREVOCABLE)
1544 {
1545 pp_string (buffer, "GTMA_MAY_ENTER_IRREVOCABLE ");
1546 subcode &= ~GTMA_MAY_ENTER_IRREVOCABLE;
1547 }
1548 if (subcode & GTMA_DOES_GO_IRREVOCABLE)
1549 {
1550 pp_string (buffer, "GTMA_DOES_GO_IRREVOCABLE ");
1551 subcode &= ~GTMA_DOES_GO_IRREVOCABLE;
1552 }
1553 if (subcode & GTMA_HAS_NO_INSTRUMENTATION)
1554 {
1555 pp_string (buffer, "GTMA_HAS_NO_INSTRUMENTATION ");
1556 subcode &= ~GTMA_HAS_NO_INSTRUMENTATION;
1557 }
1558 if (subcode)
1559 pp_printf (buffer, "0x%x ", subcode);
1560 pp_right_bracket (buffer);
1561 }
1562 }
1563
1564 if (!gimple_seq_empty_p (gimple_transaction_body (gs)))
1565 {
1566 newline_and_indent (buffer, spc + 2);
1567 pp_left_brace (buffer);
1568 pp_newline (buffer);
1569 dump_gimple_seq (buffer, gimple_transaction_body (gs),
1570 spc + 4, flags);
1571 newline_and_indent (buffer, spc + 2);
1572 pp_right_brace (buffer);
1573 }
1574 }
1575 }
1576
1577 /* Dump a GIMPLE_ASM tuple on the pretty_printer BUFFER, SPC spaces of
1578 indent. FLAGS specifies details to show in the dump (see TDF_* in
1579 dumpfile.h). */
1580
1581 static void
dump_gimple_asm(pretty_printer * buffer,gimple gs,int spc,int flags)1582 dump_gimple_asm (pretty_printer *buffer, gimple gs, int spc, int flags)
1583 {
1584 unsigned int i, n, f, fields;
1585
1586 if (flags & TDF_RAW)
1587 {
1588 dump_gimple_fmt (buffer, spc, flags, "%G <%+STRING <%n%s%n>", gs,
1589 gimple_asm_string (gs));
1590
1591 n = gimple_asm_noutputs (gs);
1592 if (n)
1593 {
1594 newline_and_indent (buffer, spc + 2);
1595 pp_string (buffer, "OUTPUT: ");
1596 for (i = 0; i < n; i++)
1597 {
1598 dump_generic_node (buffer, gimple_asm_output_op (gs, i),
1599 spc, flags, false);
1600 if (i < n - 1)
1601 pp_string (buffer, ", ");
1602 }
1603 }
1604
1605 n = gimple_asm_ninputs (gs);
1606 if (n)
1607 {
1608 newline_and_indent (buffer, spc + 2);
1609 pp_string (buffer, "INPUT: ");
1610 for (i = 0; i < n; i++)
1611 {
1612 dump_generic_node (buffer, gimple_asm_input_op (gs, i),
1613 spc, flags, false);
1614 if (i < n - 1)
1615 pp_string (buffer, ", ");
1616 }
1617 }
1618
1619 n = gimple_asm_nclobbers (gs);
1620 if (n)
1621 {
1622 newline_and_indent (buffer, spc + 2);
1623 pp_string (buffer, "CLOBBER: ");
1624 for (i = 0; i < n; i++)
1625 {
1626 dump_generic_node (buffer, gimple_asm_clobber_op (gs, i),
1627 spc, flags, false);
1628 if (i < n - 1)
1629 pp_string (buffer, ", ");
1630 }
1631 }
1632
1633 n = gimple_asm_nlabels (gs);
1634 if (n)
1635 {
1636 newline_and_indent (buffer, spc + 2);
1637 pp_string (buffer, "LABEL: ");
1638 for (i = 0; i < n; i++)
1639 {
1640 dump_generic_node (buffer, gimple_asm_label_op (gs, i),
1641 spc, flags, false);
1642 if (i < n - 1)
1643 pp_string (buffer, ", ");
1644 }
1645 }
1646
1647 newline_and_indent (buffer, spc);
1648 pp_greater (buffer);
1649 }
1650 else
1651 {
1652 pp_string (buffer, "__asm__");
1653 if (gimple_asm_volatile_p (gs))
1654 pp_string (buffer, " __volatile__");
1655 if (gimple_asm_nlabels (gs))
1656 pp_string (buffer, " goto");
1657 pp_string (buffer, "(\"");
1658 pp_string (buffer, gimple_asm_string (gs));
1659 pp_string (buffer, "\"");
1660
1661 if (gimple_asm_nlabels (gs))
1662 fields = 4;
1663 else if (gimple_asm_nclobbers (gs))
1664 fields = 3;
1665 else if (gimple_asm_ninputs (gs))
1666 fields = 2;
1667 else if (gimple_asm_noutputs (gs))
1668 fields = 1;
1669 else
1670 fields = 0;
1671
1672 for (f = 0; f < fields; ++f)
1673 {
1674 pp_string (buffer, " : ");
1675
1676 switch (f)
1677 {
1678 case 0:
1679 n = gimple_asm_noutputs (gs);
1680 for (i = 0; i < n; i++)
1681 {
1682 dump_generic_node (buffer, gimple_asm_output_op (gs, i),
1683 spc, flags, false);
1684 if (i < n - 1)
1685 pp_string (buffer, ", ");
1686 }
1687 break;
1688
1689 case 1:
1690 n = gimple_asm_ninputs (gs);
1691 for (i = 0; i < n; i++)
1692 {
1693 dump_generic_node (buffer, gimple_asm_input_op (gs, i),
1694 spc, flags, false);
1695 if (i < n - 1)
1696 pp_string (buffer, ", ");
1697 }
1698 break;
1699
1700 case 2:
1701 n = gimple_asm_nclobbers (gs);
1702 for (i = 0; i < n; i++)
1703 {
1704 dump_generic_node (buffer, gimple_asm_clobber_op (gs, i),
1705 spc, flags, false);
1706 if (i < n - 1)
1707 pp_string (buffer, ", ");
1708 }
1709 break;
1710
1711 case 3:
1712 n = gimple_asm_nlabels (gs);
1713 for (i = 0; i < n; i++)
1714 {
1715 dump_generic_node (buffer, gimple_asm_label_op (gs, i),
1716 spc, flags, false);
1717 if (i < n - 1)
1718 pp_string (buffer, ", ");
1719 }
1720 break;
1721
1722 default:
1723 gcc_unreachable ();
1724 }
1725 }
1726
1727 pp_string (buffer, ");");
1728 }
1729 }
1730
1731 /* Dump ptr_info and range_info for NODE on pretty_printer BUFFER with
1732 SPC spaces of indent. */
1733
1734 static void
dump_ssaname_info(pretty_printer * buffer,tree node,int spc)1735 dump_ssaname_info (pretty_printer *buffer, tree node, int spc)
1736 {
1737 if (TREE_CODE (node) != SSA_NAME)
1738 return;
1739
1740 if (POINTER_TYPE_P (TREE_TYPE (node))
1741 && SSA_NAME_PTR_INFO (node))
1742 {
1743 unsigned int align, misalign;
1744 struct ptr_info_def *pi = SSA_NAME_PTR_INFO (node);
1745 pp_string (buffer, "# PT = ");
1746 pp_points_to_solution (buffer, &pi->pt);
1747 newline_and_indent (buffer, spc);
1748 if (get_ptr_info_alignment (pi, &align, &misalign))
1749 {
1750 pp_printf (buffer, "# ALIGN = %u, MISALIGN = %u", align, misalign);
1751 newline_and_indent (buffer, spc);
1752 }
1753 }
1754
1755 if (!POINTER_TYPE_P (TREE_TYPE (node))
1756 && SSA_NAME_RANGE_INFO (node))
1757 {
1758 double_int min, max, nonzero_bits;
1759 value_range_type range_type = get_range_info (node, &min, &max);
1760
1761 if (range_type == VR_VARYING)
1762 pp_printf (buffer, "# RANGE VR_VARYING");
1763 else if (range_type == VR_RANGE || range_type == VR_ANTI_RANGE)
1764 {
1765 pp_printf (buffer, "# RANGE ");
1766 pp_printf (buffer, "%s[", range_type == VR_RANGE ? "" : "~");
1767 pp_double_int (buffer, min, TYPE_UNSIGNED (TREE_TYPE (node)));
1768 pp_printf (buffer, ", ");
1769 pp_double_int (buffer, max, TYPE_UNSIGNED (TREE_TYPE (node)));
1770 pp_printf (buffer, "]");
1771 }
1772 nonzero_bits = get_nonzero_bits (node);
1773 if (nonzero_bits != double_int_minus_one
1774 && (nonzero_bits
1775 != double_int::mask (TYPE_PRECISION (TREE_TYPE (node)))))
1776 {
1777 pp_string (buffer, " NONZERO ");
1778 sprintf (pp_buffer (buffer)->digit_buffer,
1779 HOST_WIDE_INT_PRINT_DOUBLE_HEX,
1780 (unsigned HOST_WIDE_INT) nonzero_bits.high,
1781 nonzero_bits.low);
1782 pp_string (buffer, pp_buffer (buffer)->digit_buffer);
1783 }
1784 newline_and_indent (buffer, spc);
1785 }
1786 }
1787
1788
1789 /* Dump a PHI node PHI. BUFFER, SPC and FLAGS are as in pp_gimple_stmt_1.
1790 The caller is responsible for calling pp_flush on BUFFER to finalize
1791 pretty printer. If COMMENT is true, print this after #. */
1792
1793 static void
dump_gimple_phi(pretty_printer * buffer,gimple phi,int spc,bool comment,int flags)1794 dump_gimple_phi (pretty_printer *buffer, gimple phi, int spc, bool comment,
1795 int flags)
1796 {
1797 size_t i;
1798 tree lhs = gimple_phi_result (phi);
1799
1800 if (flags & TDF_ALIAS)
1801 dump_ssaname_info (buffer, lhs, spc);
1802
1803 if (comment)
1804 pp_string (buffer, "# ");
1805
1806 if (flags & TDF_RAW)
1807 dump_gimple_fmt (buffer, spc, flags, "%G <%T, ", phi,
1808 gimple_phi_result (phi));
1809 else
1810 {
1811 dump_generic_node (buffer, lhs, spc, flags, false);
1812 pp_string (buffer, " = PHI <");
1813 }
1814 for (i = 0; i < gimple_phi_num_args (phi); i++)
1815 {
1816 if ((flags & TDF_LINENO) && gimple_phi_arg_has_location (phi, i))
1817 {
1818 expanded_location xloc;
1819
1820 xloc = expand_location (gimple_phi_arg_location (phi, i));
1821 pp_left_bracket (buffer);
1822 if (xloc.file)
1823 {
1824 pp_string (buffer, xloc.file);
1825 pp_string (buffer, " : ");
1826 }
1827 pp_decimal_int (buffer, xloc.line);
1828 pp_colon (buffer);
1829 pp_decimal_int (buffer, xloc.column);
1830 pp_string (buffer, "] ");
1831 }
1832 dump_generic_node (buffer, gimple_phi_arg_def (phi, i), spc, flags,
1833 false);
1834 pp_left_paren (buffer);
1835 pp_decimal_int (buffer, gimple_phi_arg_edge (phi, i)->src->index);
1836 pp_right_paren (buffer);
1837 if (i < gimple_phi_num_args (phi) - 1)
1838 pp_string (buffer, ", ");
1839 }
1840 pp_greater (buffer);
1841 }
1842
1843
1844 /* Dump a GIMPLE_OMP_PARALLEL tuple on the pretty_printer BUFFER, SPC spaces
1845 of indent. FLAGS specifies details to show in the dump (see TDF_* in
1846 dumpfile.h). */
1847
1848 static void
dump_gimple_omp_parallel(pretty_printer * buffer,gimple gs,int spc,int flags)1849 dump_gimple_omp_parallel (pretty_printer *buffer, gimple gs, int spc,
1850 int flags)
1851 {
1852 if (flags & TDF_RAW)
1853 {
1854 dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
1855 gimple_omp_body (gs));
1856 dump_omp_clauses (buffer, gimple_omp_parallel_clauses (gs), spc, flags);
1857 dump_gimple_fmt (buffer, spc, flags, " >, %T, %T%n>",
1858 gimple_omp_parallel_child_fn (gs),
1859 gimple_omp_parallel_data_arg (gs));
1860 }
1861 else
1862 {
1863 gimple_seq body;
1864 pp_string (buffer, "#pragma omp parallel");
1865 dump_omp_clauses (buffer, gimple_omp_parallel_clauses (gs), spc, flags);
1866 if (gimple_omp_parallel_child_fn (gs))
1867 {
1868 pp_string (buffer, " [child fn: ");
1869 dump_generic_node (buffer, gimple_omp_parallel_child_fn (gs),
1870 spc, flags, false);
1871 pp_string (buffer, " (");
1872 if (gimple_omp_parallel_data_arg (gs))
1873 dump_generic_node (buffer, gimple_omp_parallel_data_arg (gs),
1874 spc, flags, false);
1875 else
1876 pp_string (buffer, "???");
1877 pp_string (buffer, ")]");
1878 }
1879 body = gimple_omp_body (gs);
1880 if (body && gimple_code (gimple_seq_first_stmt (body)) != GIMPLE_BIND)
1881 {
1882 newline_and_indent (buffer, spc + 2);
1883 pp_left_brace (buffer);
1884 pp_newline (buffer);
1885 dump_gimple_seq (buffer, body, spc + 4, flags);
1886 newline_and_indent (buffer, spc + 2);
1887 pp_right_brace (buffer);
1888 }
1889 else if (body)
1890 {
1891 pp_newline (buffer);
1892 dump_gimple_seq (buffer, body, spc + 2, flags);
1893 }
1894 }
1895 }
1896
1897
1898 /* Dump a GIMPLE_OMP_TASK tuple on the pretty_printer BUFFER, SPC spaces
1899 of indent. FLAGS specifies details to show in the dump (see TDF_* in
1900 dumpfile.h). */
1901
1902 static void
dump_gimple_omp_task(pretty_printer * buffer,gimple gs,int spc,int flags)1903 dump_gimple_omp_task (pretty_printer *buffer, gimple gs, int spc,
1904 int flags)
1905 {
1906 if (flags & TDF_RAW)
1907 {
1908 dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
1909 gimple_omp_body (gs));
1910 dump_omp_clauses (buffer, gimple_omp_task_clauses (gs), spc, flags);
1911 dump_gimple_fmt (buffer, spc, flags, " >, %T, %T, %T, %T, %T%n>",
1912 gimple_omp_task_child_fn (gs),
1913 gimple_omp_task_data_arg (gs),
1914 gimple_omp_task_copy_fn (gs),
1915 gimple_omp_task_arg_size (gs),
1916 gimple_omp_task_arg_size (gs));
1917 }
1918 else
1919 {
1920 gimple_seq body;
1921 pp_string (buffer, "#pragma omp task");
1922 dump_omp_clauses (buffer, gimple_omp_task_clauses (gs), spc, flags);
1923 if (gimple_omp_task_child_fn (gs))
1924 {
1925 pp_string (buffer, " [child fn: ");
1926 dump_generic_node (buffer, gimple_omp_task_child_fn (gs),
1927 spc, flags, false);
1928 pp_string (buffer, " (");
1929 if (gimple_omp_task_data_arg (gs))
1930 dump_generic_node (buffer, gimple_omp_task_data_arg (gs),
1931 spc, flags, false);
1932 else
1933 pp_string (buffer, "???");
1934 pp_string (buffer, ")]");
1935 }
1936 body = gimple_omp_body (gs);
1937 if (body && gimple_code (gimple_seq_first_stmt (body)) != GIMPLE_BIND)
1938 {
1939 newline_and_indent (buffer, spc + 2);
1940 pp_left_brace (buffer);
1941 pp_newline (buffer);
1942 dump_gimple_seq (buffer, body, spc + 4, flags);
1943 newline_and_indent (buffer, spc + 2);
1944 pp_right_brace (buffer);
1945 }
1946 else if (body)
1947 {
1948 pp_newline (buffer);
1949 dump_gimple_seq (buffer, body, spc + 2, flags);
1950 }
1951 }
1952 }
1953
1954
1955 /* Dump a GIMPLE_OMP_ATOMIC_LOAD tuple on the pretty_printer BUFFER, SPC
1956 spaces of indent. FLAGS specifies details to show in the dump (see TDF_*
1957 in dumpfile.h). */
1958
1959 static void
dump_gimple_omp_atomic_load(pretty_printer * buffer,gimple gs,int spc,int flags)1960 dump_gimple_omp_atomic_load (pretty_printer *buffer, gimple gs, int spc,
1961 int flags)
1962 {
1963 if (flags & TDF_RAW)
1964 {
1965 dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T>", gs,
1966 gimple_omp_atomic_load_lhs (gs),
1967 gimple_omp_atomic_load_rhs (gs));
1968 }
1969 else
1970 {
1971 pp_string (buffer, "#pragma omp atomic_load");
1972 if (gimple_omp_atomic_seq_cst_p (gs))
1973 pp_string (buffer, " seq_cst");
1974 if (gimple_omp_atomic_need_value_p (gs))
1975 pp_string (buffer, " [needed]");
1976 newline_and_indent (buffer, spc + 2);
1977 dump_generic_node (buffer, gimple_omp_atomic_load_lhs (gs),
1978 spc, flags, false);
1979 pp_space (buffer);
1980 pp_equal (buffer);
1981 pp_space (buffer);
1982 pp_star (buffer);
1983 dump_generic_node (buffer, gimple_omp_atomic_load_rhs (gs),
1984 spc, flags, false);
1985 }
1986 }
1987
1988 /* Dump a GIMPLE_OMP_ATOMIC_STORE tuple on the pretty_printer BUFFER, SPC
1989 spaces of indent. FLAGS specifies details to show in the dump (see TDF_*
1990 in dumpfile.h). */
1991
1992 static void
dump_gimple_omp_atomic_store(pretty_printer * buffer,gimple gs,int spc,int flags)1993 dump_gimple_omp_atomic_store (pretty_printer *buffer, gimple gs, int spc,
1994 int flags)
1995 {
1996 if (flags & TDF_RAW)
1997 {
1998 dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs,
1999 gimple_omp_atomic_store_val (gs));
2000 }
2001 else
2002 {
2003 pp_string (buffer, "#pragma omp atomic_store ");
2004 if (gimple_omp_atomic_seq_cst_p (gs))
2005 pp_string (buffer, "seq_cst ");
2006 if (gimple_omp_atomic_need_value_p (gs))
2007 pp_string (buffer, "[needed] ");
2008 pp_left_paren (buffer);
2009 dump_generic_node (buffer, gimple_omp_atomic_store_val (gs),
2010 spc, flags, false);
2011 pp_right_paren (buffer);
2012 }
2013 }
2014
2015
2016 /* Dump all the memory operands for statement GS. BUFFER, SPC and
2017 FLAGS are as in pp_gimple_stmt_1. */
2018
2019 static void
dump_gimple_mem_ops(pretty_printer * buffer,gimple gs,int spc,int flags)2020 dump_gimple_mem_ops (pretty_printer *buffer, gimple gs, int spc, int flags)
2021 {
2022 tree vdef = gimple_vdef (gs);
2023 tree vuse = gimple_vuse (gs);
2024
2025 if (vdef != NULL_TREE)
2026 {
2027 pp_string (buffer, "# ");
2028 dump_generic_node (buffer, vdef, spc + 2, flags, false);
2029 pp_string (buffer, " = VDEF <");
2030 dump_generic_node (buffer, vuse, spc + 2, flags, false);
2031 pp_greater (buffer);
2032 newline_and_indent (buffer, spc);
2033 }
2034 else if (vuse != NULL_TREE)
2035 {
2036 pp_string (buffer, "# VUSE <");
2037 dump_generic_node (buffer, vuse, spc + 2, flags, false);
2038 pp_greater (buffer);
2039 newline_and_indent (buffer, spc);
2040 }
2041 }
2042
2043
2044 /* Print the gimple statement GS on the pretty printer BUFFER, SPC
2045 spaces of indent. FLAGS specifies details to show in the dump (see
2046 TDF_* in dumpfile.h). The caller is responsible for calling
2047 pp_flush on BUFFER to finalize the pretty printer. */
2048
2049 void
pp_gimple_stmt_1(pretty_printer * buffer,gimple gs,int spc,int flags)2050 pp_gimple_stmt_1 (pretty_printer *buffer, gimple gs, int spc, int flags)
2051 {
2052 if (!gs)
2053 return;
2054
2055 if (flags & TDF_STMTADDR)
2056 pp_printf (buffer, "<&%p> ", (void *) gs);
2057
2058 if ((flags & TDF_LINENO) && gimple_has_location (gs))
2059 {
2060 expanded_location xloc = expand_location (gimple_location (gs));
2061 pp_left_bracket (buffer);
2062 if (xloc.file)
2063 {
2064 pp_string (buffer, xloc.file);
2065 pp_string (buffer, " : ");
2066 }
2067 pp_decimal_int (buffer, xloc.line);
2068 pp_colon (buffer);
2069 pp_decimal_int (buffer, xloc.column);
2070 pp_string (buffer, "] ");
2071 }
2072
2073 if (flags & TDF_EH)
2074 {
2075 int lp_nr = lookup_stmt_eh_lp (gs);
2076 if (lp_nr > 0)
2077 pp_printf (buffer, "[LP %d] ", lp_nr);
2078 else if (lp_nr < 0)
2079 pp_printf (buffer, "[MNT %d] ", -lp_nr);
2080 }
2081
2082 if ((flags & (TDF_VOPS|TDF_MEMSYMS))
2083 && gimple_has_mem_ops (gs))
2084 dump_gimple_mem_ops (buffer, gs, spc, flags);
2085
2086 if (gimple_has_lhs (gs)
2087 && (flags & TDF_ALIAS))
2088 dump_ssaname_info (buffer, gimple_get_lhs (gs), spc);
2089
2090 switch (gimple_code (gs))
2091 {
2092 case GIMPLE_ASM:
2093 dump_gimple_asm (buffer, gs, spc, flags);
2094 break;
2095
2096 case GIMPLE_ASSIGN:
2097 dump_gimple_assign (buffer, gs, spc, flags);
2098 break;
2099
2100 case GIMPLE_BIND:
2101 dump_gimple_bind (buffer, gs, spc, flags);
2102 break;
2103
2104 case GIMPLE_CALL:
2105 dump_gimple_call (buffer, gs, spc, flags);
2106 break;
2107
2108 case GIMPLE_COND:
2109 dump_gimple_cond (buffer, gs, spc, flags);
2110 break;
2111
2112 case GIMPLE_LABEL:
2113 dump_gimple_label (buffer, gs, spc, flags);
2114 break;
2115
2116 case GIMPLE_GOTO:
2117 dump_gimple_goto (buffer, gs, spc, flags);
2118 break;
2119
2120 case GIMPLE_NOP:
2121 pp_string (buffer, "GIMPLE_NOP");
2122 break;
2123
2124 case GIMPLE_RETURN:
2125 dump_gimple_return (buffer, gs, spc, flags);
2126 break;
2127
2128 case GIMPLE_SWITCH:
2129 dump_gimple_switch (buffer, gs, spc, flags);
2130 break;
2131
2132 case GIMPLE_TRY:
2133 dump_gimple_try (buffer, gs, spc, flags);
2134 break;
2135
2136 case GIMPLE_PHI:
2137 dump_gimple_phi (buffer, gs, spc, false, flags);
2138 break;
2139
2140 case GIMPLE_OMP_PARALLEL:
2141 dump_gimple_omp_parallel (buffer, gs, spc, flags);
2142 break;
2143
2144 case GIMPLE_OMP_TASK:
2145 dump_gimple_omp_task (buffer, gs, spc, flags);
2146 break;
2147
2148 case GIMPLE_OMP_ATOMIC_LOAD:
2149 dump_gimple_omp_atomic_load (buffer, gs, spc, flags);
2150
2151 break;
2152
2153 case GIMPLE_OMP_ATOMIC_STORE:
2154 dump_gimple_omp_atomic_store (buffer, gs, spc, flags);
2155 break;
2156
2157 case GIMPLE_OMP_FOR:
2158 dump_gimple_omp_for (buffer, gs, spc, flags);
2159 break;
2160
2161 case GIMPLE_OMP_CONTINUE:
2162 dump_gimple_omp_continue (buffer, gs, spc, flags);
2163 break;
2164
2165 case GIMPLE_OMP_SINGLE:
2166 dump_gimple_omp_single (buffer, gs, spc, flags);
2167 break;
2168
2169 case GIMPLE_OMP_TARGET:
2170 dump_gimple_omp_target (buffer, gs, spc, flags);
2171 break;
2172
2173 case GIMPLE_OMP_TEAMS:
2174 dump_gimple_omp_teams (buffer, gs, spc, flags);
2175 break;
2176
2177 case GIMPLE_OMP_RETURN:
2178 dump_gimple_omp_return (buffer, gs, spc, flags);
2179 break;
2180
2181 case GIMPLE_OMP_SECTIONS:
2182 dump_gimple_omp_sections (buffer, gs, spc, flags);
2183 break;
2184
2185 case GIMPLE_OMP_SECTIONS_SWITCH:
2186 pp_string (buffer, "GIMPLE_SECTIONS_SWITCH");
2187 break;
2188
2189 case GIMPLE_OMP_MASTER:
2190 case GIMPLE_OMP_TASKGROUP:
2191 case GIMPLE_OMP_ORDERED:
2192 case GIMPLE_OMP_SECTION:
2193 dump_gimple_omp_block (buffer, gs, spc, flags);
2194 break;
2195
2196 case GIMPLE_OMP_CRITICAL:
2197 dump_gimple_omp_critical (buffer, gs, spc, flags);
2198 break;
2199
2200 case GIMPLE_CATCH:
2201 dump_gimple_catch (buffer, gs, spc, flags);
2202 break;
2203
2204 case GIMPLE_EH_FILTER:
2205 dump_gimple_eh_filter (buffer, gs, spc, flags);
2206 break;
2207
2208 case GIMPLE_EH_MUST_NOT_THROW:
2209 dump_gimple_eh_must_not_throw (buffer, gs, spc, flags);
2210 break;
2211
2212 case GIMPLE_EH_ELSE:
2213 dump_gimple_eh_else (buffer, gs, spc, flags);
2214 break;
2215
2216 case GIMPLE_RESX:
2217 dump_gimple_resx (buffer, gs, spc, flags);
2218 break;
2219
2220 case GIMPLE_EH_DISPATCH:
2221 dump_gimple_eh_dispatch (buffer, gs, spc, flags);
2222 break;
2223
2224 case GIMPLE_DEBUG:
2225 dump_gimple_debug (buffer, gs, spc, flags);
2226 break;
2227
2228 case GIMPLE_PREDICT:
2229 pp_string (buffer, "// predicted ");
2230 if (gimple_predict_outcome (gs))
2231 pp_string (buffer, "likely by ");
2232 else
2233 pp_string (buffer, "unlikely by ");
2234 pp_string (buffer, predictor_name (gimple_predict_predictor (gs)));
2235 pp_string (buffer, " predictor.");
2236 break;
2237
2238 case GIMPLE_TRANSACTION:
2239 dump_gimple_transaction (buffer, gs, spc, flags);
2240 break;
2241
2242 default:
2243 GIMPLE_NIY;
2244 }
2245 }
2246
2247
2248 /* Dumps header of basic block BB to OUTF indented by INDENT
2249 spaces and details described by flags. */
2250
2251 static void
dump_gimple_bb_header(FILE * outf,basic_block bb,int indent,int flags)2252 dump_gimple_bb_header (FILE *outf, basic_block bb, int indent, int flags)
2253 {
2254 if (flags & TDF_BLOCKS)
2255 {
2256 if (flags & TDF_LINENO)
2257 {
2258 gimple_stmt_iterator gsi;
2259
2260 if (flags & TDF_COMMENT)
2261 fputs (";; ", outf);
2262
2263 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
2264 if (!is_gimple_debug (gsi_stmt (gsi))
2265 && get_lineno (gsi_stmt (gsi)) != UNKNOWN_LOCATION)
2266 {
2267 fprintf (outf, "%*sstarting at line %d",
2268 indent, "", get_lineno (gsi_stmt (gsi)));
2269 break;
2270 }
2271 if (bb->discriminator)
2272 fprintf (outf, ", discriminator %i", bb->discriminator);
2273 fputc ('\n', outf);
2274 }
2275 }
2276 else
2277 {
2278 gimple stmt = first_stmt (bb);
2279 if (!stmt || gimple_code (stmt) != GIMPLE_LABEL)
2280 fprintf (outf, "%*s<bb %d>:\n", indent, "", bb->index);
2281 }
2282 }
2283
2284
2285 /* Dumps end of basic block BB to buffer BUFFER indented by INDENT
2286 spaces. */
2287
2288 static void
dump_gimple_bb_footer(FILE * outf ATTRIBUTE_UNUSED,basic_block bb ATTRIBUTE_UNUSED,int indent ATTRIBUTE_UNUSED,int flags ATTRIBUTE_UNUSED)2289 dump_gimple_bb_footer (FILE *outf ATTRIBUTE_UNUSED,
2290 basic_block bb ATTRIBUTE_UNUSED,
2291 int indent ATTRIBUTE_UNUSED,
2292 int flags ATTRIBUTE_UNUSED)
2293 {
2294 /* There is currently no GIMPLE-specific basic block info to dump. */
2295 return;
2296 }
2297
2298
2299 /* Dump PHI nodes of basic block BB to BUFFER with details described
2300 by FLAGS and indented by INDENT spaces. */
2301
2302 static void
dump_phi_nodes(pretty_printer * buffer,basic_block bb,int indent,int flags)2303 dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags)
2304 {
2305 gimple_stmt_iterator i;
2306
2307 for (i = gsi_start_phis (bb); !gsi_end_p (i); gsi_next (&i))
2308 {
2309 gimple phi = gsi_stmt (i);
2310 if (!virtual_operand_p (gimple_phi_result (phi)) || (flags & TDF_VOPS))
2311 {
2312 INDENT (indent);
2313 dump_gimple_phi (buffer, phi, indent, true, flags);
2314 pp_newline (buffer);
2315 }
2316 }
2317 }
2318
2319
2320 /* Dump jump to basic block BB that is represented implicitly in the cfg
2321 to BUFFER. */
2322
2323 static void
pp_cfg_jump(pretty_printer * buffer,basic_block bb)2324 pp_cfg_jump (pretty_printer *buffer, basic_block bb)
2325 {
2326 gimple stmt;
2327
2328 stmt = first_stmt (bb);
2329
2330 pp_string (buffer, "goto <bb ");
2331 pp_decimal_int (buffer, bb->index);
2332 pp_greater (buffer);
2333 if (stmt && gimple_code (stmt) == GIMPLE_LABEL)
2334 {
2335 pp_string (buffer, " (");
2336 dump_generic_node (buffer, gimple_label_label (stmt), 0, 0, false);
2337 pp_right_paren (buffer);
2338 pp_semicolon (buffer);
2339 }
2340 else
2341 pp_semicolon (buffer);
2342 }
2343
2344
2345 /* Dump edges represented implicitly in basic block BB to BUFFER, indented
2346 by INDENT spaces, with details given by FLAGS. */
2347
2348 static void
dump_implicit_edges(pretty_printer * buffer,basic_block bb,int indent,int flags)2349 dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,
2350 int flags)
2351 {
2352 edge e;
2353 gimple stmt;
2354
2355 stmt = last_stmt (bb);
2356
2357 if (stmt && gimple_code (stmt) == GIMPLE_COND)
2358 {
2359 edge true_edge, false_edge;
2360
2361 /* When we are emitting the code or changing CFG, it is possible that
2362 the edges are not yet created. When we are using debug_bb in such
2363 a situation, we do not want it to crash. */
2364 if (EDGE_COUNT (bb->succs) != 2)
2365 return;
2366 extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
2367
2368 INDENT (indent + 2);
2369 pp_cfg_jump (buffer, true_edge->dest);
2370 newline_and_indent (buffer, indent);
2371 pp_string (buffer, "else");
2372 newline_and_indent (buffer, indent + 2);
2373 pp_cfg_jump (buffer, false_edge->dest);
2374 pp_newline (buffer);
2375 return;
2376 }
2377
2378 /* If there is a fallthru edge, we may need to add an artificial
2379 goto to the dump. */
2380 e = find_fallthru_edge (bb->succs);
2381
2382 if (e && e->dest != bb->next_bb)
2383 {
2384 INDENT (indent);
2385
2386 if ((flags & TDF_LINENO)
2387 && e->goto_locus != UNKNOWN_LOCATION
2388 )
2389 {
2390 expanded_location goto_xloc;
2391 goto_xloc = expand_location (e->goto_locus);
2392 pp_left_bracket (buffer);
2393 if (goto_xloc.file)
2394 {
2395 pp_string (buffer, goto_xloc.file);
2396 pp_string (buffer, " : ");
2397 }
2398 pp_decimal_int (buffer, goto_xloc.line);
2399 pp_string (buffer, " : ");
2400 pp_decimal_int (buffer, goto_xloc.column);
2401 pp_string (buffer, "] ");
2402 }
2403
2404 pp_cfg_jump (buffer, e->dest);
2405 pp_newline (buffer);
2406 }
2407 }
2408
2409
2410 /* Dumps basic block BB to buffer BUFFER with details described by FLAGS and
2411 indented by INDENT spaces. */
2412
2413 static void
gimple_dump_bb_buff(pretty_printer * buffer,basic_block bb,int indent,int flags)2414 gimple_dump_bb_buff (pretty_printer *buffer, basic_block bb, int indent,
2415 int flags)
2416 {
2417 gimple_stmt_iterator gsi;
2418 gimple stmt;
2419 int label_indent = indent - 2;
2420
2421 if (label_indent < 0)
2422 label_indent = 0;
2423
2424 dump_phi_nodes (buffer, bb, indent, flags);
2425
2426 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
2427 {
2428 int curr_indent;
2429
2430 stmt = gsi_stmt (gsi);
2431
2432 curr_indent = gimple_code (stmt) == GIMPLE_LABEL ? label_indent : indent;
2433
2434 INDENT (curr_indent);
2435 pp_gimple_stmt_1 (buffer, stmt, curr_indent, flags);
2436 pp_newline_and_flush (buffer);
2437 gcc_checking_assert (DECL_STRUCT_FUNCTION (current_function_decl));
2438 dump_histograms_for_stmt (DECL_STRUCT_FUNCTION (current_function_decl),
2439 pp_buffer (buffer)->stream, stmt);
2440 }
2441
2442 dump_implicit_edges (buffer, bb, indent, flags);
2443 pp_flush (buffer);
2444 }
2445
2446
2447 /* Dumps basic block BB to FILE with details described by FLAGS and
2448 indented by INDENT spaces. */
2449
2450 void
gimple_dump_bb(FILE * file,basic_block bb,int indent,int flags)2451 gimple_dump_bb (FILE *file, basic_block bb, int indent, int flags)
2452 {
2453 dump_gimple_bb_header (file, bb, indent, flags);
2454 if (bb->index >= NUM_FIXED_BLOCKS)
2455 {
2456 pretty_printer buffer;
2457 pp_needs_newline (&buffer) = true;
2458 buffer.buffer->stream = file;
2459 gimple_dump_bb_buff (&buffer, bb, indent, flags);
2460 }
2461 dump_gimple_bb_footer (file, bb, indent, flags);
2462 }
2463
2464 /* Dumps basic block BB to pretty-printer PP with default dump flags and
2465 no indentation, for use as a label of a DOT graph record-node.
2466 ??? Should just use gimple_dump_bb_buff here, except that value profiling
2467 histogram dumping doesn't know about pretty-printers. */
2468
2469 void
gimple_dump_bb_for_graph(pretty_printer * pp,basic_block bb)2470 gimple_dump_bb_for_graph (pretty_printer *pp, basic_block bb)
2471 {
2472 gimple_stmt_iterator gsi;
2473
2474 pp_printf (pp, "<bb %d>:\n", bb->index);
2475 pp_write_text_as_dot_label_to_stream (pp, /*for_record=*/true);
2476
2477 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
2478 {
2479 gimple phi = gsi_stmt (gsi);
2480 if (!virtual_operand_p (gimple_phi_result (phi))
2481 || (dump_flags & TDF_VOPS))
2482 {
2483 pp_bar (pp);
2484 pp_write_text_to_stream (pp);
2485 pp_string (pp, "# ");
2486 pp_gimple_stmt_1 (pp, phi, 0, dump_flags);
2487 pp_newline (pp);
2488 pp_write_text_as_dot_label_to_stream (pp, /*for_record=*/true);
2489 }
2490 }
2491
2492 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
2493 {
2494 gimple stmt = gsi_stmt (gsi);
2495 pp_bar (pp);
2496 pp_write_text_to_stream (pp);
2497 pp_gimple_stmt_1 (pp, stmt, 0, dump_flags);
2498 pp_newline (pp);
2499 pp_write_text_as_dot_label_to_stream (pp, /*for_record=*/true);
2500 }
2501 dump_implicit_edges (pp, bb, 0, dump_flags);
2502 pp_write_text_as_dot_label_to_stream (pp, /*for_record=*/true);
2503 }
2504
2505