]> git.ipfire.org Git - thirdparty/gcc.git/blame - gcc/gimple-pretty-print.c
projects / thirdparty / gcc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
re PR debug/47858 (IPA-SRA decreases quality of debug info)
[thirdparty/gcc.git] / gcc / gimple-pretty-print.c
CommitLineData
726a989a 1/* Pretty formatting of GIMPLE statements and expressions.
ddb555ed
JJ		 2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
3 2011 Free Software Foundation, Inc.
726a989a
RB		 4 Contributed by Aldy Hernandez <aldyh@redhat.com> and
5 Diego Novillo <dnovillo@google.com>
6
7This file is part of GCC.
8
9GCC is free software; you can redistribute it and/or modify it under
10the terms of the GNU General Public License as published by the Free
11Software Foundation; either version 3, or (at your option) any later
12version.
13
14GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15WARRANTY; without even the implied warranty of MERCHANTABILITY or
16FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17for more details.
18
19You should have received a copy of the GNU General Public License
20along with GCC; see the file COPYING3. If not see
21<http://www.gnu.org/licenses/>. */
22
23#include "config.h"
24#include "system.h"
25#include "coretypes.h"
26#include "tm.h"
27#include "tree.h"
28#include "diagnostic.h"
cf835838
JM		 29#include "tree-pretty-print.h"
30#include "gimple-pretty-print.h"
726a989a
RB		 31#include "hashtab.h"
32#include "tree-flow.h"
33#include "tree-pass.h"
34#include "gimple.h"
35#include "value-prof.h"
36
37#define INDENT(SPACE) \
38 do { int i; for (i = 0; i < SPACE; i++) pp_space (buffer); } while (0)
39
40static pretty_printer buffer;
41static bool initialized = false;
42
43#define GIMPLE_NIY do_niy (buffer,gs)
44
45/* Try to print on BUFFER a default message for the unrecognized
46 gimple statement GS. */
47
48static void
49do_niy (pretty_printer *buffer, gimple gs)
50{
51 pp_printf (buffer, "<<< Unknown GIMPLE statement: %s >>>\n",
52 gimple_code_name[(int) gimple_code (gs)]);
53}
54
55
56/* Initialize the pretty printer on FILE if needed. */
57
58static void
59maybe_init_pretty_print (FILE *file)
60{
61 if (!initialized)
62 {
63 pp_construct (&buffer, NULL, 0);
64 pp_needs_newline (&buffer) = true;
65 initialized = true;
66 }
67
68 buffer.buffer->stream = file;
69}
70
71
72/* Emit a newline and SPC indentantion spaces to BUFFER. */
73
74static void
75newline_and_indent (pretty_printer *buffer, int spc)
76{
77 pp_newline (buffer);
78 INDENT (spc);
79}
80
81
82/* Print the GIMPLE statement GS on stderr. */
83
24e47c76 84DEBUG_FUNCTION void
726a989a
RB		 85debug_gimple_stmt (gimple gs)
86{
87 print_gimple_stmt (stderr, gs, 0, TDF_VOPS|TDF_MEMSYMS);
88 fprintf (stderr, "\n");
89}
90
91
92/* Dump GIMPLE statement G to FILE using SPC indentantion spaces and
93 FLAGS as in dump_gimple_stmt. */
94
95void
96print_gimple_stmt (FILE *file, gimple g, int spc, int flags)
97{
98 maybe_init_pretty_print (file);
99 dump_gimple_stmt (&buffer, g, spc, flags);
100 pp_flush (&buffer);
101}
102
103
104/* Dump GIMPLE statement G to FILE using SPC indentantion spaces and
105 FLAGS as in dump_gimple_stmt. Print only the right-hand side
106 of the statement. */
107
108void
109print_gimple_expr (FILE *file, gimple g, int spc, int flags)
110{
111 flags |= TDF_RHS_ONLY;
112 maybe_init_pretty_print (file);
113 dump_gimple_stmt (&buffer, g, spc, flags);
114}
115
116
117/* Print the GIMPLE sequence SEQ on BUFFER using SPC indentantion
118 spaces and FLAGS as in dump_gimple_stmt. */
119
120static void
121dump_gimple_seq (pretty_printer *buffer, gimple_seq seq, int spc, int flags)
122{
123 gimple_stmt_iterator i;
124
125 for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
126 {
127 gimple gs = gsi_stmt (i);
128 INDENT (spc);
129 dump_gimple_stmt (buffer, gs, spc, flags);
130 if (!gsi_one_before_end_p (i))
131 pp_newline (buffer);
132 }
133}
134
135
136/* Dump GIMPLE sequence SEQ to FILE using SPC indentantion spaces and
137 FLAGS as in dump_gimple_stmt. */
138
139void
140print_gimple_seq (FILE *file, gimple_seq seq, int spc, int flags)
141{
142 maybe_init_pretty_print (file);
143 dump_gimple_seq (&buffer, seq, spc, flags);
144 pp_flush (&buffer);
145}
146
147
148/* Print the GIMPLE sequence SEQ on stderr. */
149
24e47c76 150DEBUG_FUNCTION void
726a989a
RB		 151debug_gimple_seq (gimple_seq seq)
152{
153 print_gimple_seq (stderr, seq, 0, TDF_VOPS|TDF_MEMSYMS);
154}
155
156
157/* A simple helper to pretty-print some of the gimple tuples in the printf
158 style. The format modifiers are preceeded by '%' and are:
159 'G' - outputs a string corresponding to the code of the given gimple,
160 'S' - outputs a gimple_seq with indent of spc + 2,
161 'T' - outputs the tree t,
162 'd' - outputs an int as a decimal,
163 's' - outputs a string,
164 'n' - outputs a newline,
165 '+' - increases indent by 2 then outputs a newline,
166 '-' - decreases indent by 2 then outputs a newline. */
167
168static void
169dump_gimple_fmt (pretty_printer *buffer, int spc, int flags,
170 const char *fmt, ...)
171{
172 va_list args;
173 const char *c;
174 const char *tmp;
175
176 va_start (args, fmt);
177 for (c = fmt; *c; c++)
178 {
179 if (*c == '%')
180 {
181 gimple_seq seq;
182 tree t;
183 gimple g;
184 switch (*++c)
185 {
186 case 'G':
187 g = va_arg (args, gimple);
188 tmp = gimple_code_name[gimple_code (g)];
189 pp_string (buffer, tmp);
190 break;
191
192 case 'S':
193 seq = va_arg (args, gimple_seq);
194 pp_newline (buffer);
195 dump_gimple_seq (buffer, seq, spc + 2, flags);
196 newline_and_indent (buffer, spc);
197 break;
198
199 case 'T':
200 t = va_arg (args, tree);
201 if (t == NULL_TREE)
202 pp_string (buffer, "NULL");
203 else
204 dump_generic_node (buffer, t, spc, flags, false);
205 break;
206
207 case 'd':
208 pp_decimal_int (buffer, va_arg (args, int));
209 break;
210
211 case 's':
212 pp_string (buffer, va_arg (args, char *));
213 break;
214
215 case 'n':
216 newline_and_indent (buffer, spc);
217 break;
218
219 case '+':
220 spc += 2;
221 newline_and_indent (buffer, spc);
222 break;
223
224 case '-':
225 spc -= 2;
226 newline_and_indent (buffer, spc);
227 break;
228
229 default:
230 gcc_unreachable ();
231 }
b8698a0f 232 }
726a989a
RB		 233 else
234 pp_character (buffer, *c);
235 }
236 va_end (args);
237}
238
239
240/* Helper for dump_gimple_assign. Print the unary RHS of the
241 assignment GS. BUFFER, SPC and FLAGS are as in dump_gimple_stmt. */
242
243static void
244dump_unary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
245{
246 enum tree_code rhs_code = gimple_assign_rhs_code (gs);
247 tree lhs = gimple_assign_lhs (gs);
248 tree rhs = gimple_assign_rhs1 (gs);
249
250 switch (rhs_code)
251 {
252 case VIEW_CONVERT_EXPR:
253 case ASSERT_EXPR:
254 dump_generic_node (buffer, rhs, spc, flags, false);
255 break;
256
257 case FIXED_CONVERT_EXPR:
09e881c9 258 case ADDR_SPACE_CONVERT_EXPR:
726a989a
RB		 259 case FIX_TRUNC_EXPR:
260 case FLOAT_EXPR:
261 CASE_CONVERT:
0cf0d02b 262 pp_character (buffer, '(');
726a989a
RB		 263 dump_generic_node (buffer, TREE_TYPE (lhs), spc, flags, false);
264 pp_string (buffer, ") ");
0cf0d02b
JJ		 265 if (op_prio (rhs) < op_code_prio (rhs_code))
266 {
267 pp_character (buffer, '(');
268 dump_generic_node (buffer, rhs, spc, flags, false);
269 pp_character (buffer, ')');
270 }
271 else
272 dump_generic_node (buffer, rhs, spc, flags, false);
726a989a 273 break;
b8698a0f 274
726a989a
RB		 275 case PAREN_EXPR:
276 pp_string (buffer, "((");
277 dump_generic_node (buffer, rhs, spc, flags, false);
278 pp_string (buffer, "))");
279 break;
b8698a0f 280
726a989a
RB		 281 case ABS_EXPR:
282 pp_string (buffer, "ABS_EXPR <");
283 dump_generic_node (buffer, rhs, spc, flags, false);
0cf0d02b 284 pp_character (buffer, '>');
726a989a
RB		 285 break;
286
287 default:
288 if (TREE_CODE_CLASS (rhs_code) == tcc_declaration
289 || TREE_CODE_CLASS (rhs_code) == tcc_constant
290 || TREE_CODE_CLASS (rhs_code) == tcc_reference
291 || rhs_code == SSA_NAME
292 || rhs_code == ADDR_EXPR
293 || rhs_code == CONSTRUCTOR)
0cf0d02b
JJ		 294 {
295 dump_generic_node (buffer, rhs, spc, flags, false);
296 break;
297 }
726a989a 298 else if (rhs_code == BIT_NOT_EXPR)
0cf0d02b 299 pp_character (buffer, '~');
726a989a 300 else if (rhs_code == TRUTH_NOT_EXPR)
0cf0d02b 301 pp_character (buffer, '!');
726a989a 302 else if (rhs_code == NEGATE_EXPR)
0cf0d02b 303 pp_character (buffer, '-');
726a989a
RB		 304 else
305 {
0cf0d02b 306 pp_character (buffer, '[');
726a989a
RB		 307 pp_string (buffer, tree_code_name [rhs_code]);
308 pp_string (buffer, "] ");
309 }
310
0cf0d02b
JJ		 311 if (op_prio (rhs) < op_code_prio (rhs_code))
312 {
313 pp_character (buffer, '(');
314 dump_generic_node (buffer, rhs, spc, flags, false);
315 pp_character (buffer, ')');
316 }
317 else
318 dump_generic_node (buffer, rhs, spc, flags, false);
726a989a
RB		 319 break;
320 }
321}
322
323
324/* Helper for dump_gimple_assign. Print the binary RHS of the
325 assignment GS. BUFFER, SPC and FLAGS are as in dump_gimple_stmt. */
326
327static void
328dump_binary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
329{
2603276e
JJ		 330 const char *p;
331 enum tree_code code = gimple_assign_rhs_code (gs);
332 switch (code)
726a989a
RB		 333 {
334 case COMPLEX_EXPR:
726a989a 335 case MIN_EXPR:
726a989a 336 case MAX_EXPR:
2603276e
JJ		 337 case VEC_WIDEN_MULT_HI_EXPR:
338 case VEC_WIDEN_MULT_LO_EXPR:
339 case VEC_PACK_TRUNC_EXPR:
340 case VEC_PACK_SAT_EXPR:
341 case VEC_PACK_FIX_TRUNC_EXPR:
342 case VEC_EXTRACT_EVEN_EXPR:
343 case VEC_EXTRACT_ODD_EXPR:
344 case VEC_INTERLEAVE_HIGH_EXPR:
345 case VEC_INTERLEAVE_LOW_EXPR:
346 for (p = tree_code_name [(int) code]; *p; p++)
347 pp_character (buffer, TOUPPER (*p));
348 pp_string (buffer, " <");
726a989a
RB		 349 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
350 pp_string (buffer, ", ");
351 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
2603276e 352 pp_character (buffer, '>');
726a989a
RB		 353 break;
354
355 default:
0cf0d02b
JJ		 356 if (op_prio (gimple_assign_rhs1 (gs)) <= op_code_prio (code))
357 {
358 pp_character (buffer, '(');
359 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags,
360 false);
361 pp_character (buffer, ')');
362 }
363 else
364 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
726a989a
RB		 365 pp_space (buffer);
366 pp_string (buffer, op_symbol_code (gimple_assign_rhs_code (gs)));
367 pp_space (buffer);
0cf0d02b
JJ		 368 if (op_prio (gimple_assign_rhs2 (gs)) <= op_code_prio (code))
369 {
370 pp_character (buffer, '(');
371 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags,
372 false);
373 pp_character (buffer, ')');
374 }
375 else
376 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
726a989a
RB		 377 }
378}
379
0354c0c7
BS		 380/* Helper for dump_gimple_assign. Print the ternary RHS of the
381 assignment GS. BUFFER, SPC and FLAGS are as in dump_gimple_stmt. */
382
383static void
384dump_ternary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
385{
386 const char *p;
387 enum tree_code code = gimple_assign_rhs_code (gs);
388 switch (code)
389 {
390 case WIDEN_MULT_PLUS_EXPR:
391 case WIDEN_MULT_MINUS_EXPR:
392 for (p = tree_code_name [(int) code]; *p; p++)
393 pp_character (buffer, TOUPPER (*p));
394 pp_string (buffer, " <");
395 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
396 pp_string (buffer, ", ");
397 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
398 pp_string (buffer, ", ");
399 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
400 pp_character (buffer, '>');
401 break;
402
16949072
RG		 403 case FMA_EXPR:
404 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
405 pp_string (buffer, " * ");
406 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
407 pp_string (buffer, " + ");
408 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
409 break;
410
f471fe72
RG		 411 case DOT_PROD_EXPR:
412 pp_string (buffer, "DOT_PROD_EXPR <");
413 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
414 pp_string (buffer, ", ");
415 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
416 pp_string (buffer, ", ");
417 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
418 pp_string (buffer, ">");
419 break;
420
421 case REALIGN_LOAD_EXPR:
422 pp_string (buffer, "REALIGN_LOAD <");
423 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
424 pp_string (buffer, ", ");
425 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
426 pp_string (buffer, ", ");
427 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
428 pp_string (buffer, ">");
429 break;
430
0354c0c7
BS		 431 default:
432 gcc_unreachable ();
433 }
434}
435
726a989a
RB		 436
437/* Dump the gimple assignment GS. BUFFER, SPC and FLAGS are as in
438 dump_gimple_stmt. */
439
440static void
441dump_gimple_assign (pretty_printer *buffer, gimple gs, int spc, int flags)
442{
443 if (flags & TDF_RAW)
444 {
445 tree last;
446 if (gimple_num_ops (gs) == 2)
447 last = NULL_TREE;
448 else if (gimple_num_ops (gs) == 3)
449 last = gimple_assign_rhs2 (gs);
450 else
451 gcc_unreachable ();
452
453 dump_gimple_fmt (buffer, spc, flags, "%G <%s, %T, %T, %T>", gs,
454 tree_code_name[gimple_assign_rhs_code (gs)],
455 gimple_assign_lhs (gs), gimple_assign_rhs1 (gs), last);
456 }
457 else
458 {
459 if (!(flags & TDF_RHS_ONLY))
460 {
461 dump_generic_node (buffer, gimple_assign_lhs (gs), spc, flags, false);
462 pp_space (buffer);
463 pp_character (buffer, '=');
464
465 if (gimple_assign_nontemporal_move_p (gs))
466 pp_string (buffer, "{nt}");
467
468 if (gimple_has_volatile_ops (gs))
469 pp_string (buffer, "{v}");
470
471 pp_space (buffer);
472 }
473
474 if (gimple_num_ops (gs) == 2)
475 dump_unary_rhs (buffer, gs, spc, flags);
476 else if (gimple_num_ops (gs) == 3)
477 dump_binary_rhs (buffer, gs, spc, flags);
0354c0c7
BS		 478 else if (gimple_num_ops (gs) == 4)
479 dump_ternary_rhs (buffer, gs, spc, flags);
726a989a
RB		 480 else
481 gcc_unreachable ();
482 if (!(flags & TDF_RHS_ONLY))
483 pp_semicolon(buffer);
484 }
485}
486
487
488/* Dump the return statement GS. BUFFER, SPC and FLAGS are as in
489 dump_gimple_stmt. */
490
491static void
492dump_gimple_return (pretty_printer *buffer, gimple gs, int spc, int flags)
493{
494 tree t;
495
496 t = gimple_return_retval (gs);
497 if (flags & TDF_RAW)
498 dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, t);
499 else
500 {
501 pp_string (buffer, "return");
502 if (t)
503 {
504 pp_space (buffer);
505 dump_generic_node (buffer, t, spc, flags, false);
506 }
507 pp_semicolon (buffer);
508 }
509}
510
511
512/* Dump the call arguments for a gimple call. BUFFER, FLAGS are as in
513 dump_gimple_call. */
514
515static void
516dump_gimple_call_args (pretty_printer *buffer, gimple gs, int flags)
517{
518 size_t i;
519
520 for (i = 0; i < gimple_call_num_args (gs); i++)
521 {
522 dump_generic_node (buffer, gimple_call_arg (gs, i), 0, flags, false);
523 if (i < gimple_call_num_args (gs) - 1)
524 pp_string (buffer, ", ");
525 }
526
527 if (gimple_call_va_arg_pack_p (gs))
528 {
529 if (gimple_call_num_args (gs) > 0)
530 {
531 pp_character (buffer, ',');
532 pp_space (buffer);
533 }
534
535 pp_string (buffer, "__builtin_va_arg_pack ()");
536 }
537}
538
25a6a873
RG		 539/* Dump the points-to solution *PT to BUFFER. */
540
541static void
542pp_points_to_solution (pretty_printer *buffer, struct pt_solution *pt)
543{
544 if (pt->anything)
545 {
546 pp_string (buffer, "anything ");
547 return;
548 }
549 if (pt->nonlocal)
550 pp_string (buffer, "nonlocal ");
551 if (pt->escaped)
552 pp_string (buffer, "escaped ");
553 if (pt->ipa_escaped)
554 pp_string (buffer, "unit-escaped ");
555 if (pt->null)
556 pp_string (buffer, "null ");
557 if (pt->vars
558 && !bitmap_empty_p (pt->vars))
559 {
560 bitmap_iterator bi;
561 unsigned i;
562 pp_string (buffer, "{ ");
563 EXECUTE_IF_SET_IN_BITMAP (pt->vars, 0, i, bi)
564 {
27c6b086 565 tree var = referenced_var_lookup (cfun, i);
25a6a873
RG		 566 if (var)
567 {
568 dump_generic_node (buffer, var, 0, dump_flags, false);
569 if (DECL_PT_UID (var) != DECL_UID (var))
570 {
571 pp_string (buffer, "ptD.");
572 pp_decimal_int (buffer, DECL_PT_UID (var));
573 }
574 }
575 else
576 {
577 pp_string (buffer, "D.");
578 pp_decimal_int (buffer, i);
579 }
580 pp_character (buffer, ' ');
581 }
582 pp_character (buffer, '}');
583 if (pt->vars_contains_global)
584 pp_string (buffer, " (glob)");
585 if (pt->vars_contains_restrict)
586 pp_string (buffer, " (restr)");
587 }
588}
726a989a
RB		 589
590/* Dump the call statement GS. BUFFER, SPC and FLAGS are as in
591 dump_gimple_stmt. */
592
593static void
594dump_gimple_call (pretty_printer *buffer, gimple gs, int spc, int flags)
595{
596 tree lhs = gimple_call_lhs (gs);
597
25a6a873
RG		 598 if (flags & TDF_ALIAS)
599 {
600 struct pt_solution *pt;
601 pt = gimple_call_use_set (gs);
602 if (!pt_solution_empty_p (pt))
603 {
604 pp_string (buffer, "# USE = ");
605 pp_points_to_solution (buffer, pt);
606 newline_and_indent (buffer, spc);
607 }
608 pt = gimple_call_clobber_set (gs);
609 if (!pt_solution_empty_p (pt))
610 {
611 pp_string (buffer, "# CLB = ");
612 pp_points_to_solution (buffer, pt);
613 newline_and_indent (buffer, spc);
614 }
615 }
616
726a989a
RB		 617 if (flags & TDF_RAW)
618 {
25583c4f
RS		 619 if (gimple_call_internal_p (gs))
620 dump_gimple_fmt (buffer, spc, flags, "%G <%s, %T", gs,
621 internal_fn_name (gimple_call_internal_fn (gs)), lhs);
622 else
623 dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T",
624 gs, gimple_call_fn (gs), lhs);
726a989a
RB		 625 if (gimple_call_num_args (gs) > 0)
626 {
627 pp_string (buffer, ", ");
628 dump_gimple_call_args (buffer, gs, flags);
629 }
0cf0d02b 630 pp_character (buffer, '>');
726a989a
RB		 631 }
632 else
633 {
634 if (lhs && !(flags & TDF_RHS_ONLY))
635 {
636 dump_generic_node (buffer, lhs, spc, flags, false);
637 pp_string (buffer, " =");
638
639 if (gimple_has_volatile_ops (gs))
640 pp_string (buffer, "{v}");
641
642 pp_space (buffer);
643 }
25583c4f
RS		 644 if (gimple_call_internal_p (gs))
645 pp_string (buffer, internal_fn_name (gimple_call_internal_fn (gs)));
646 else
647 print_call_name (buffer, gimple_call_fn (gs), flags);
726a989a
RB		 648 pp_string (buffer, " (");
649 dump_gimple_call_args (buffer, gs, flags);
0cf0d02b 650 pp_character (buffer, ')');
726a989a
RB		 651 if (!(flags & TDF_RHS_ONLY))
652 pp_semicolon (buffer);
653 }
654
655 if (gimple_call_chain (gs))
656 {
657 pp_string (buffer, " [static-chain: ");
658 dump_generic_node (buffer, gimple_call_chain (gs), spc, flags, false);
659 pp_character (buffer, ']');
660 }
661
662 if (gimple_call_return_slot_opt_p (gs))
663 pp_string (buffer, " [return slot optimization]");
664
665 if (gimple_call_tail_p (gs))
666 pp_string (buffer, " [tail call]");
667}
668
669
670/* Dump the switch statement GS. BUFFER, SPC and FLAGS are as in
671 dump_gimple_stmt. */
672
673static void
674dump_gimple_switch (pretty_printer *buffer, gimple gs, int spc, int flags)
675{
676 unsigned int i;
677
678 GIMPLE_CHECK (gs, GIMPLE_SWITCH);
679 if (flags & TDF_RAW)
680 dump_gimple_fmt (buffer, spc, flags, "%G <%T, ", gs,
681 gimple_switch_index (gs));
682 else
683 {
684 pp_string (buffer, "switch (");
685 dump_generic_node (buffer, gimple_switch_index (gs), spc, flags, true);
686 pp_string (buffer, ") <");
687 }
688
689 for (i = 0; i < gimple_switch_num_labels (gs); i++)
690 {
691 tree case_label = gimple_switch_label (gs, i);
692 if (case_label == NULL_TREE)
693 continue;
694
695 dump_generic_node (buffer, case_label, spc, flags, false);
0cf0d02b 696 pp_character (buffer, ' ');
726a989a
RB		 697 dump_generic_node (buffer, CASE_LABEL (case_label), spc, flags, false);
698 if (i < gimple_switch_num_labels (gs) - 1)
699 pp_string (buffer, ", ");
700 }
0cf0d02b 701 pp_character (buffer, '>');
726a989a
RB		 702}
703
704
705/* Dump the gimple conditional GS. BUFFER, SPC and FLAGS are as in
706 dump_gimple_stmt. */
707
708static void
709dump_gimple_cond (pretty_printer *buffer, gimple gs, int spc, int flags)
710{
711 if (flags & TDF_RAW)
712 dump_gimple_fmt (buffer, spc, flags, "%G <%s, %T, %T, %T, %T>", gs,
713 tree_code_name [gimple_cond_code (gs)],
714 gimple_cond_lhs (gs), gimple_cond_rhs (gs),
715 gimple_cond_true_label (gs), gimple_cond_false_label (gs));
716 else
717 {
718 if (!(flags & TDF_RHS_ONLY))
719 pp_string (buffer, "if (");
720 dump_generic_node (buffer, gimple_cond_lhs (gs), spc, flags, false);
721 pp_space (buffer);
722 pp_string (buffer, op_symbol_code (gimple_cond_code (gs)));
723 pp_space (buffer);
724 dump_generic_node (buffer, gimple_cond_rhs (gs), spc, flags, false);
725 if (!(flags & TDF_RHS_ONLY))
726 {
0cf0d02b 727 pp_character (buffer, ')');
726a989a
RB		 728
729 if (gimple_cond_true_label (gs))
730 {
731 pp_string (buffer, " goto ");
732 dump_generic_node (buffer, gimple_cond_true_label (gs),
733 spc, flags, false);
734 pp_semicolon (buffer);
735 }
736 if (gimple_cond_false_label (gs))
737 {
738 pp_string (buffer, " else goto ");
739 dump_generic_node (buffer, gimple_cond_false_label (gs),
740 spc, flags, false);
741 pp_semicolon (buffer);
742 }
743 }
744 }
745}
746
747
748/* Dump a GIMPLE_LABEL tuple on the pretty_printer BUFFER, SPC
749 spaces of indent. FLAGS specifies details to show in the dump (see
750 TDF_* in tree-pass.h). */
751
752static void
753dump_gimple_label (pretty_printer *buffer, gimple gs, int spc, int flags)
754{
755 tree label = gimple_label_label (gs);
756 if (flags & TDF_RAW)
757 dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, label);
758 else
759 {
760 dump_generic_node (buffer, label, spc, flags, false);
0cf0d02b 761 pp_character (buffer, ':');
726a989a
RB		 762 }
763 if (DECL_NONLOCAL (label))
764 pp_string (buffer, " [non-local]");
1d65f45c
RH		 765 if ((flags & TDF_EH) && EH_LANDING_PAD_NR (label))
766 pp_printf (buffer, " [LP %d]", EH_LANDING_PAD_NR (label));
726a989a
RB		 767}
768
769/* Dump a GIMPLE_GOTO tuple on the pretty_printer BUFFER, SPC
770 spaces of indent. FLAGS specifies details to show in the dump (see
771 TDF_* in tree-pass.h). */
772
773static void
774dump_gimple_goto (pretty_printer *buffer, gimple gs, int spc, int flags)
775{
776 tree label = gimple_goto_dest (gs);
777 if (flags & TDF_RAW)
778 dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, label);
779 else
780 dump_gimple_fmt (buffer, spc, flags, "goto %T;", label);
781}
782
783
784/* Dump a GIMPLE_BIND tuple on the pretty_printer BUFFER, SPC
785 spaces of indent. FLAGS specifies details to show in the dump (see
786 TDF_* in tree-pass.h). */
787
788static void
789dump_gimple_bind (pretty_printer *buffer, gimple gs, int spc, int flags)
790{
791 if (flags & TDF_RAW)
792 dump_gimple_fmt (buffer, spc, flags, "%G <", gs);
793 else
794 pp_character (buffer, '{');
795 if (!(flags & TDF_SLIM))
796 {
797 tree var;
798
910ad8de 799 for (var = gimple_bind_vars (gs); var; var = DECL_CHAIN (var))
726a989a
RB		 800 {
801 newline_and_indent (buffer, 2);
802 print_declaration (buffer, var, spc, flags);
803 }
804 if (gimple_bind_vars (gs))
805 pp_newline (buffer);
806 }
807 pp_newline (buffer);
808 dump_gimple_seq (buffer, gimple_bind_body (gs), spc + 2, flags);
809 newline_and_indent (buffer, spc);
810 if (flags & TDF_RAW)
811 pp_character (buffer, '>');
812 else
813 pp_character (buffer, '}');
814}
815
816
817/* Dump a GIMPLE_TRY tuple on the pretty_printer BUFFER, SPC spaces of
818 indent. FLAGS specifies details to show in the dump (see TDF_* in
819 tree-pass.h). */
820
821static void
822dump_gimple_try (pretty_printer *buffer, gimple gs, int spc, int flags)
823{
824 if (flags & TDF_RAW)
825 {
826 const char *type;
827 if (gimple_try_kind (gs) == GIMPLE_TRY_CATCH)
828 type = "GIMPLE_TRY_CATCH";
829 else if (gimple_try_kind (gs) == GIMPLE_TRY_FINALLY)
830 type = "GIMPLE_TRY_FINALLY";
831 else
832 type = "UNKNOWN GIMPLE_TRY";
833 dump_gimple_fmt (buffer, spc, flags,
834 "%G <%s,%+EVAL <%S>%nCLEANUP <%S>%->", gs, type,
835 gimple_try_eval (gs), gimple_try_cleanup (gs));
836 }
837 else
838 {
839 pp_string (buffer, "try");
840 newline_and_indent (buffer, spc + 2);
0cf0d02b 841 pp_character (buffer, '{');
726a989a
RB		 842 pp_newline (buffer);
843
844 dump_gimple_seq (buffer, gimple_try_eval (gs), spc + 4, flags);
845 newline_and_indent (buffer, spc + 2);
0cf0d02b 846 pp_character (buffer, '}');
726a989a
RB		 847
848 if (gimple_try_kind (gs) == GIMPLE_TRY_CATCH)
849 {
850 newline_and_indent (buffer, spc);
851 pp_string (buffer, "catch");
852 newline_and_indent (buffer, spc + 2);
0cf0d02b 853 pp_character (buffer, '{');
726a989a
RB		 854 }
855 else if (gimple_try_kind (gs) == GIMPLE_TRY_FINALLY)
856 {
857 newline_and_indent (buffer, spc);
858 pp_string (buffer, "finally");
859 newline_and_indent (buffer, spc + 2);
0cf0d02b 860 pp_character (buffer, '{');
726a989a
RB		 861 }
862 else
863 pp_string (buffer, " <UNKNOWN GIMPLE_TRY> {");
864
865 pp_newline (buffer);
866 dump_gimple_seq (buffer, gimple_try_cleanup (gs), spc + 4, flags);
867 newline_and_indent (buffer, spc + 2);
868 pp_character (buffer, '}');
869 }
870}
871
872
873/* Dump a GIMPLE_CATCH tuple on the pretty_printer BUFFER, SPC spaces of
874 indent. FLAGS specifies details to show in the dump (see TDF_* in
875 tree-pass.h). */
876
877static void
878dump_gimple_catch (pretty_printer *buffer, gimple gs, int spc, int flags)
879{
880 if (flags & TDF_RAW)
881 dump_gimple_fmt (buffer, spc, flags, "%G <%T, %+CATCH <%S>%->", gs,
882 gimple_catch_types (gs), gimple_catch_handler (gs));
883 else
884 dump_gimple_fmt (buffer, spc, flags, "catch (%T)%+{%S}",
885 gimple_catch_types (gs), gimple_catch_handler (gs));
886}
887
888
889/* Dump a GIMPLE_EH_FILTER tuple on the pretty_printer BUFFER, SPC spaces of
890 indent. FLAGS specifies details to show in the dump (see TDF_* in
891 tree-pass.h). */
892
893static void
894dump_gimple_eh_filter (pretty_printer *buffer, gimple gs, int spc, int flags)
895{
896 if (flags & TDF_RAW)
897 dump_gimple_fmt (buffer, spc, flags, "%G <%T, %+FAILURE <%S>%->", gs,
898 gimple_eh_filter_types (gs),
899 gimple_eh_filter_failure (gs));
900 else
901 dump_gimple_fmt (buffer, spc, flags, "<<<eh_filter (%T)>>>%+{%+%S%-}",
902 gimple_eh_filter_types (gs),
903 gimple_eh_filter_failure (gs));
904}
905
906
1d65f45c
RH		 907/* Dump a GIMPLE_EH_MUST_NOT_THROW tuple. */
908
909static void
910dump_gimple_eh_must_not_throw (pretty_printer *buffer, gimple gs,
911 int spc, int flags)
912{
913 if (flags & TDF_RAW)
914 dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs,
915 gimple_eh_must_not_throw_fndecl (gs));
916 else
917 dump_gimple_fmt (buffer, spc, flags, "<<<eh_must_not_throw (%T)>>>",
918 gimple_eh_must_not_throw_fndecl (gs));
919}
920
921
726a989a
RB		 922/* Dump a GIMPLE_RESX tuple on the pretty_printer BUFFER, SPC spaces of
923 indent. FLAGS specifies details to show in the dump (see TDF_* in
924 tree-pass.h). */
925
926static void
927dump_gimple_resx (pretty_printer *buffer, gimple gs, int spc, int flags)
928{
929 if (flags & TDF_RAW)
930 dump_gimple_fmt (buffer, spc, flags, "%G <%d>", gs,
1d65f45c 931 gimple_resx_region (gs));
726a989a
RB		 932 else
933 dump_gimple_fmt (buffer, spc, flags, "resx %d", gimple_resx_region (gs));
934}
935
1d65f45c
RH		 936/* Dump a GIMPLE_EH_DISPATCH tuple on the pretty_printer BUFFER. */
937
938static void
939dump_gimple_eh_dispatch (pretty_printer *buffer, gimple gs, int spc, int flags)
940{
941 if (flags & TDF_RAW)
942 dump_gimple_fmt (buffer, spc, flags, "%G <%d>", gs,
943 gimple_eh_dispatch_region (gs));
944 else
945 dump_gimple_fmt (buffer, spc, flags, "eh_dispatch %d",
946 gimple_eh_dispatch_region (gs));
947}
948
b5b8b0ac
AO		 949/* Dump a GIMPLE_DEBUG tuple on the pretty_printer BUFFER, SPC spaces
950 of indent. FLAGS specifies details to show in the dump (see TDF_*
951 in tree-pass.h). */
952
953static void
954dump_gimple_debug (pretty_printer *buffer, gimple gs, int spc, int flags)
955{
956 switch (gs->gsbase.subcode)
957 {
958 case GIMPLE_DEBUG_BIND:
959 if (flags & TDF_RAW)
960 dump_gimple_fmt (buffer, spc, flags, "%G BIND <%T, %T>", gs,
961 gimple_debug_bind_get_var (gs),
962 gimple_debug_bind_get_value (gs));
963 else
964 dump_gimple_fmt (buffer, spc, flags, "# DEBUG %T => %T",
965 gimple_debug_bind_get_var (gs),
966 gimple_debug_bind_get_value (gs));
967 break;
968
ddb555ed
JJ		 969 case GIMPLE_DEBUG_SOURCE_BIND:
970 if (flags & TDF_RAW)
971 dump_gimple_fmt (buffer, spc, flags, "%G SRCBIND <%T, %T>", gs,
972 gimple_debug_source_bind_get_var (gs),
973 gimple_debug_source_bind_get_value (gs));
974 else
975 dump_gimple_fmt (buffer, spc, flags, "# DEBUG %T s=> %T",
976 gimple_debug_source_bind_get_var (gs),
977 gimple_debug_source_bind_get_value (gs));
978 break;
979
b5b8b0ac
AO		 980 default:
981 gcc_unreachable ();
982 }
983}
984
726a989a
RB		 985/* Dump a GIMPLE_OMP_FOR tuple on the pretty_printer BUFFER. */
986static void
987dump_gimple_omp_for (pretty_printer *buffer, gimple gs, int spc, int flags)
988{
989 size_t i;
990
991 if (flags & TDF_RAW)
992 {
993 dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
994 gimple_omp_body (gs));
995 dump_omp_clauses (buffer, gimple_omp_for_clauses (gs), spc, flags);
996 dump_gimple_fmt (buffer, spc, flags, " >,");
997 for (i = 0; i < gimple_omp_for_collapse (gs); i++)
998 dump_gimple_fmt (buffer, spc, flags,
999 "%+%T, %T, %T, %s, %T,%n",
1000 gimple_omp_for_index (gs, i),
1001 gimple_omp_for_initial (gs, i),
1002 gimple_omp_for_final (gs, i),
1003 tree_code_name[gimple_omp_for_cond (gs, i)],
1004 gimple_omp_for_incr (gs, i));
1005 dump_gimple_fmt (buffer, spc, flags, "PRE_BODY <%S>%->",
1006 gimple_omp_for_pre_body (gs));
1007 }
1008 else
1009 {
1010 pp_string (buffer, "#pragma omp for");
1011 dump_omp_clauses (buffer, gimple_omp_for_clauses (gs), spc, flags);
1012 for (i = 0; i < gimple_omp_for_collapse (gs); i++)
1013 {
1014 if (i)
1015 spc += 2;
1016 newline_and_indent (buffer, spc);
1017 pp_string (buffer, "for (");
1018 dump_generic_node (buffer, gimple_omp_for_index (gs, i), spc,
1019 flags, false);
1020 pp_string (buffer, " = ");
1021 dump_generic_node (buffer, gimple_omp_for_initial (gs, i), spc,
1022 flags, false);
1023 pp_string (buffer, "; ");
1024
1025 dump_generic_node (buffer, gimple_omp_for_index (gs, i), spc,
1026 flags, false);
1027 pp_space (buffer);
1028 switch (gimple_omp_for_cond (gs, i))
1029 {
1030 case LT_EXPR:
1031 pp_character (buffer, '<');
1032 break;
1033 case GT_EXPR:
1034 pp_character (buffer, '>');
1035 break;
1036 case LE_EXPR:
1037 pp_string (buffer, "<=");
1038 break;
1039 case GE_EXPR:
1040 pp_string (buffer, ">=");
1041 break;
1042 default:
1043 gcc_unreachable ();
1044 }
1045 pp_space (buffer);
1046 dump_generic_node (buffer, gimple_omp_for_final (gs, i), spc,
1047 flags, false);
1048 pp_string (buffer, "; ");
1049
1050 dump_generic_node (buffer, gimple_omp_for_index (gs, i), spc,
1051 flags, false);
1052 pp_string (buffer, " = ");
1053 dump_generic_node (buffer, gimple_omp_for_incr (gs, i), spc,
1054 flags, false);
1055 pp_character (buffer, ')');
1056 }
1057
1058 if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1059 {
1060 newline_and_indent (buffer, spc + 2);
1061 pp_character (buffer, '{');
1062 pp_newline (buffer);
1063 dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
1064 newline_and_indent (buffer, spc + 2);
1065 pp_character (buffer, '}');
1066 }
1067 }
1068}
1069
1070/* Dump a GIMPLE_OMP_CONTINUE tuple on the pretty_printer BUFFER. */
1071
1072static void
1073dump_gimple_omp_continue (pretty_printer *buffer, gimple gs, int spc, int flags)
1074{
1075 if (flags & TDF_RAW)
1076 {
1077 dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T>", gs,
1078 gimple_omp_continue_control_def (gs),
1079 gimple_omp_continue_control_use (gs));
1080 }
1081 else
1082 {
1083 pp_string (buffer, "#pragma omp continue (");
1084 dump_generic_node (buffer, gimple_omp_continue_control_def (gs),
1085 spc, flags, false);
1086 pp_character (buffer, ',');
1087 pp_space (buffer);
1088 dump_generic_node (buffer, gimple_omp_continue_control_use (gs),
1089 spc, flags, false);
1090 pp_character (buffer, ')');
1091 }
1092}
1093
1094/* Dump a GIMPLE_OMP_SINGLE tuple on the pretty_printer BUFFER. */
1095
1096static void
1097dump_gimple_omp_single (pretty_printer *buffer, gimple gs, int spc, int flags)
1098{
1099 if (flags & TDF_RAW)
1100 {
1101 dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
1102 gimple_omp_body (gs));
1103 dump_omp_clauses (buffer, gimple_omp_single_clauses (gs), spc, flags);
1104 dump_gimple_fmt (buffer, spc, flags, " >");
1105 }
1106 else
1107 {
1108 pp_string (buffer, "#pragma omp single");
1109 dump_omp_clauses (buffer, gimple_omp_single_clauses (gs), spc, flags);
1110 if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1111 {
1112 newline_and_indent (buffer, spc + 2);
1113 pp_character (buffer, '{');
1114 pp_newline (buffer);
1115 dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
1116 newline_and_indent (buffer, spc + 2);
1117 pp_character (buffer, '}');
1118 }
1119 }
1120}
1121
1122/* Dump a GIMPLE_OMP_SECTIONS tuple on the pretty_printer BUFFER. */
1123
1124static void
1125dump_gimple_omp_sections (pretty_printer *buffer, gimple gs, int spc,
1126 int flags)
1127{
1128 if (flags & TDF_RAW)
1129 {
1130 dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
1131 gimple_omp_body (gs));
1132 dump_omp_clauses (buffer, gimple_omp_sections_clauses (gs), spc, flags);
1133 dump_gimple_fmt (buffer, spc, flags, " >");
1134 }
1135 else
1136 {
1137 pp_string (buffer, "#pragma omp sections");
1138 if (gimple_omp_sections_control (gs))
1139 {
1140 pp_string (buffer, " <");
1141 dump_generic_node (buffer, gimple_omp_sections_control (gs), spc,
1142 flags, false);
1143 pp_character (buffer, '>');
1144 }
1145 dump_omp_clauses (buffer, gimple_omp_sections_clauses (gs), spc, flags);
1146 if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1147 {
1148 newline_and_indent (buffer, spc + 2);
1149 pp_character (buffer, '{');
1150 pp_newline (buffer);
1151 dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
1152 newline_and_indent (buffer, spc + 2);
1153 pp_character (buffer, '}');
1154 }
1155 }
1156}
1157
1158/* Dump a GIMPLE_OMP_{MASTER,ORDERED,SECTION} tuple on the pretty_printer
1159 BUFFER. */
1160
1161static void
1162dump_gimple_omp_block (pretty_printer *buffer, gimple gs, int spc, int flags)
1163{
1164 if (flags & TDF_RAW)
1165 dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S> >", gs,
1166 gimple_omp_body (gs));
1167 else
1168 {
1169 switch (gimple_code (gs))
1170 {
1171 case GIMPLE_OMP_MASTER:
1172 pp_string (buffer, "#pragma omp master");
1173 break;
1174 case GIMPLE_OMP_ORDERED:
1175 pp_string (buffer, "#pragma omp ordered");
1176 break;
1177 case GIMPLE_OMP_SECTION:
1178 pp_string (buffer, "#pragma omp section");
1179 break;
1180 default:
1181 gcc_unreachable ();
1182 }
1183 if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1184 {
1185 newline_and_indent (buffer, spc + 2);
1186 pp_character (buffer, '{');
1187 pp_newline (buffer);
1188 dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
1189 newline_and_indent (buffer, spc + 2);
1190 pp_character (buffer, '}');
1191 }
1192 }
1193}
1194
1195/* Dump a GIMPLE_OMP_CRITICAL tuple on the pretty_printer BUFFER. */
1196
1197static void
1198dump_gimple_omp_critical (pretty_printer *buffer, gimple gs, int spc,
1199 int flags)
1200{
1201 if (flags & TDF_RAW)
1202 dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S> >", gs,
1203 gimple_omp_body (gs));
1204 else
1205 {
1206 pp_string (buffer, "#pragma omp critical");
1207 if (gimple_omp_critical_name (gs))
1208 {
1209 pp_string (buffer, " (");
1210 dump_generic_node (buffer, gimple_omp_critical_name (gs), spc,
1211 flags, false);
1212 pp_character (buffer, ')');
1213 }
1214 if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1215 {
1216 newline_and_indent (buffer, spc + 2);
1217 pp_character (buffer, '{');
1218 pp_newline (buffer);
1219 dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
1220 newline_and_indent (buffer, spc + 2);
1221 pp_character (buffer, '}');
1222 }
1223 }
1224}
1225
1226/* Dump a GIMPLE_OMP_RETURN tuple on the pretty_printer BUFFER. */
1227
1228static void
1229dump_gimple_omp_return (pretty_printer *buffer, gimple gs, int spc, int flags)
1230{
1231 if (flags & TDF_RAW)
1232 {
1233 dump_gimple_fmt (buffer, spc, flags, "%G <nowait=%d>", gs,
1234 (int) gimple_omp_return_nowait_p (gs));
1235 }
1236 else
1237 {
1238 pp_string (buffer, "#pragma omp return");
1239 if (gimple_omp_return_nowait_p (gs))
1240 pp_string (buffer, "(nowait)");
1241 }
1242}
1243
1244/* Dump a GIMPLE_ASM tuple on the pretty_printer BUFFER, SPC spaces of
1245 indent. FLAGS specifies details to show in the dump (see TDF_* in
1246 tree-pass.h). */
1247
1248static void
1249dump_gimple_asm (pretty_printer *buffer, gimple gs, int spc, int flags)
1250{
1c384bf1 1251 unsigned int i, n, f, fields;
726a989a
RB		 1252
1253 if (flags & TDF_RAW)
1c384bf1
RH		 1254 {
1255 dump_gimple_fmt (buffer, spc, flags, "%G <%+STRING <%n%s%n>", gs,
1256 gimple_asm_string (gs));
1257
1258 n = gimple_asm_noutputs (gs);
1259 if (n)
1260 {
1261 newline_and_indent (buffer, spc + 2);
1262 pp_string (buffer, "OUTPUT: ");
1263 for (i = 0; i < n; i++)
1264 {
1265 dump_generic_node (buffer, gimple_asm_output_op (gs, i),
1266 spc, flags, false);
1267 if (i < n - 1)
1268 pp_string (buffer, ", ");
1269 }
1270 }
1271
1272 n = gimple_asm_ninputs (gs);
1273 if (n)
1274 {
1275 newline_and_indent (buffer, spc + 2);
1276 pp_string (buffer, "INPUT: ");
1277 for (i = 0; i < n; i++)
1278 {
1279 dump_generic_node (buffer, gimple_asm_input_op (gs, i),
1280 spc, flags, false);
1281 if (i < n - 1)
1282 pp_string (buffer, ", ");
1283 }
1284 }
1285
1286 n = gimple_asm_nclobbers (gs);
1287 if (n)
1288 {
1289 newline_and_indent (buffer, spc + 2);
1290 pp_string (buffer, "CLOBBER: ");
1291 for (i = 0; i < n; i++)
1292 {
1293 dump_generic_node (buffer, gimple_asm_clobber_op (gs, i),
1294 spc, flags, false);
1295 if (i < n - 1)
1296 pp_string (buffer, ", ");
1297 }
1298 }
1299
1300 n = gimple_asm_nlabels (gs);
1301 if (n)
1302 {
1303 newline_and_indent (buffer, spc + 2);
1304 pp_string (buffer, "LABEL: ");
1305 for (i = 0; i < n; i++)
1306 {
1307 dump_generic_node (buffer, gimple_asm_label_op (gs, i),
1308 spc, flags, false);
1309 if (i < n - 1)
1310 pp_string (buffer, ", ");
1311 }
1312 }
1313
1314 newline_and_indent (buffer, spc);
1315 pp_character (buffer, '>');
1316 }
726a989a
RB		 1317 else
1318 {
1319 pp_string (buffer, "__asm__");
1320 if (gimple_asm_volatile_p (gs))
1321 pp_string (buffer, " __volatile__");
1c384bf1
RH		 1322 if (gimple_asm_nlabels (gs))
1323 pp_string (buffer, " goto");
726a989a
RB		 1324 pp_string (buffer, "(\"");
1325 pp_string (buffer, gimple_asm_string (gs));
1326 pp_string (buffer, "\"");
726a989a 1327
1c384bf1
RH		 1328 if (gimple_asm_nlabels (gs))
1329 fields = 4;
1330 else if (gimple_asm_nclobbers (gs))
1331 fields = 3;
1332 else if (gimple_asm_ninputs (gs))
1333 fields = 2;
1334 else if (gimple_asm_noutputs (gs))
1335 fields = 1;
1336 else
1337 fields = 0;
726a989a 1338
1c384bf1
RH		 1339 for (f = 0; f < fields; ++f)
1340 {
1341 pp_string (buffer, " : ");
726a989a 1342
1c384bf1
RH		 1343 switch (f)
1344 {
1345 case 0:
1346 n = gimple_asm_noutputs (gs);
1347 for (i = 0; i < n; i++)
1348 {
1349 dump_generic_node (buffer, gimple_asm_output_op (gs, i),
1350 spc, flags, false);
1351 if (i < n - 1)
1352 pp_string (buffer, ", ");
1353 }
1354 break;
726a989a 1355
1c384bf1
RH		 1356 case 1:
1357 n = gimple_asm_ninputs (gs);
1358 for (i = 0; i < n; i++)
1359 {
1360 dump_generic_node (buffer, gimple_asm_input_op (gs, i),
1361 spc, flags, false);
1362 if (i < n - 1)
1363 pp_string (buffer, ", ");
1364 }
1365 break;
726a989a 1366
1c384bf1
RH		 1367 case 2:
1368 n = gimple_asm_nclobbers (gs);
1369 for (i = 0; i < n; i++)
1370 {
1371 dump_generic_node (buffer, gimple_asm_clobber_op (gs, i),
1372 spc, flags, false);
1373 if (i < n - 1)
1374 pp_string (buffer, ", ");
1375 }
1376 break;
726a989a 1377
1c384bf1
RH		 1378 case 3:
1379 n = gimple_asm_nlabels (gs);
1380 for (i = 0; i < n; i++)
1381 {
1382 dump_generic_node (buffer, gimple_asm_label_op (gs, i),
1383 spc, flags, false);
1384 if (i < n - 1)
1385 pp_string (buffer, ", ");
1386 }
1387 break;
1388
1389 default:
1390 gcc_unreachable ();
1391 }
1392 }
1393
1394 pp_string (buffer, ");");
726a989a 1395 }
726a989a
RB		 1396}
1397
1398
726a989a
RB		 1399/* Dump a PHI node PHI. BUFFER, SPC and FLAGS are as in
1400 dump_gimple_stmt. */
1401
1402static void
1403dump_gimple_phi (pretty_printer *buffer, gimple phi, int spc, int flags)
1404{
1405 size_t i;
f0107145
RG		 1406 tree lhs = gimple_phi_result (phi);
1407
1408 if (flags & TDF_ALIAS
1409 && POINTER_TYPE_P (TREE_TYPE (lhs))
1410 && SSA_NAME_PTR_INFO (lhs))
1411 {
1be38ccb 1412 struct ptr_info_def *pi = SSA_NAME_PTR_INFO (lhs);
f0107145 1413 pp_string (buffer, "PT = ");
1be38ccb
RG		 1414 pp_points_to_solution (buffer, &pi->pt);
1415 newline_and_indent (buffer, spc);
1416 if (pi->align != 1)
1417 pp_printf (buffer, "# ALIGN = %u, MISALIGN = %u",
1418 pi->align, pi->misalign);
f0107145
RG		 1419 newline_and_indent (buffer, spc);
1420 pp_string (buffer, "# ");
1421 }
726a989a
RB		 1422
1423 if (flags & TDF_RAW)
1424 dump_gimple_fmt (buffer, spc, flags, "%G <%T, ", phi,
1425 gimple_phi_result (phi));
1426 else
1427 {
f0107145 1428 dump_generic_node (buffer, lhs, spc, flags, false);
726a989a
RB		 1429 pp_string (buffer, " = PHI <");
1430 }
1431 for (i = 0; i < gimple_phi_num_args (phi); i++)
1432 {
f5045c96
AM		 1433 if ((flags & TDF_LINENO) && gimple_phi_arg_has_location (phi, i))
1434 {
1435 expanded_location xloc;
1436
1437 xloc = expand_location (gimple_phi_arg_location (phi, i));
1438 pp_character (buffer, '[');
1439 if (xloc.file)
1440 {
1441 pp_string (buffer, xloc.file);
1442 pp_string (buffer, " : ");
1443 }
1444 pp_decimal_int (buffer, xloc.line);
1445 pp_string (buffer, ":");
1446 pp_decimal_int (buffer, xloc.column);
1447 pp_string (buffer, "] ");
1448 }
726a989a
RB		 1449 dump_generic_node (buffer, gimple_phi_arg_def (phi, i), spc, flags,
1450 false);
0cf0d02b 1451 pp_character (buffer, '(');
726a989a 1452 pp_decimal_int (buffer, gimple_phi_arg_edge (phi, i)->src->index);
0cf0d02b 1453 pp_character (buffer, ')');
726a989a
RB		 1454 if (i < gimple_phi_num_args (phi) - 1)
1455 pp_string (buffer, ", ");
1456 }
0cf0d02b 1457 pp_character (buffer, '>');
726a989a
RB		 1458}
1459
1460
1461/* Dump a GIMPLE_OMP_PARALLEL tuple on the pretty_printer BUFFER, SPC spaces
1462 of indent. FLAGS specifies details to show in the dump (see TDF_* in
1463 tree-pass.h). */
1464
1465static void
1466dump_gimple_omp_parallel (pretty_printer *buffer, gimple gs, int spc,
1467 int flags)
1468{
1469 if (flags & TDF_RAW)
1470 {
1471 dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
1472 gimple_omp_body (gs));
1473 dump_omp_clauses (buffer, gimple_omp_parallel_clauses (gs), spc, flags);
1474 dump_gimple_fmt (buffer, spc, flags, " >, %T, %T%n>",
1475 gimple_omp_parallel_child_fn (gs),
1476 gimple_omp_parallel_data_arg (gs));
1477 }
1478 else
1479 {
1480 gimple_seq body;
1481 pp_string (buffer, "#pragma omp parallel");
1482 dump_omp_clauses (buffer, gimple_omp_parallel_clauses (gs), spc, flags);
1483 if (gimple_omp_parallel_child_fn (gs))
1484 {
1485 pp_string (buffer, " [child fn: ");
1486 dump_generic_node (buffer, gimple_omp_parallel_child_fn (gs),
1487 spc, flags, false);
1488 pp_string (buffer, " (");
1489 if (gimple_omp_parallel_data_arg (gs))
1490 dump_generic_node (buffer, gimple_omp_parallel_data_arg (gs),
1491 spc, flags, false);
1492 else
1493 pp_string (buffer, "???");
1494 pp_string (buffer, ")]");
1495 }
1496 body = gimple_omp_body (gs);
1497 if (body && gimple_code (gimple_seq_first_stmt (body)) != GIMPLE_BIND)
1498 {
1499 newline_and_indent (buffer, spc + 2);
1500 pp_character (buffer, '{');
1501 pp_newline (buffer);
1502 dump_gimple_seq (buffer, body, spc + 4, flags);
1503 newline_and_indent (buffer, spc + 2);
1504 pp_character (buffer, '}');
1505 }
1506 else if (body)
1507 {
1508 pp_newline (buffer);
1509 dump_gimple_seq (buffer, body, spc + 2, flags);
1510 }
1511 }
1512}
1513
1514
1515/* Dump a GIMPLE_OMP_TASK tuple on the pretty_printer BUFFER, SPC spaces
1516 of indent. FLAGS specifies details to show in the dump (see TDF_* in
1517 tree-pass.h). */
1518
1519static void
1520dump_gimple_omp_task (pretty_printer *buffer, gimple gs, int spc,
1521 int flags)
1522{
1523 if (flags & TDF_RAW)
1524 {
1525 dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
1526 gimple_omp_body (gs));
1527 dump_omp_clauses (buffer, gimple_omp_task_clauses (gs), spc, flags);
1528 dump_gimple_fmt (buffer, spc, flags, " >, %T, %T, %T, %T, %T%n>",
1529 gimple_omp_task_child_fn (gs),
1530 gimple_omp_task_data_arg (gs),
1531 gimple_omp_task_copy_fn (gs),
1532 gimple_omp_task_arg_size (gs),
1533 gimple_omp_task_arg_size (gs));
1534 }
1535 else
1536 {
1537 gimple_seq body;
1538 pp_string (buffer, "#pragma omp task");
1539 dump_omp_clauses (buffer, gimple_omp_task_clauses (gs), spc, flags);
1540 if (gimple_omp_task_child_fn (gs))
1541 {
1542 pp_string (buffer, " [child fn: ");
1543 dump_generic_node (buffer, gimple_omp_task_child_fn (gs),
1544 spc, flags, false);
1545 pp_string (buffer, " (");
1546 if (gimple_omp_task_data_arg (gs))
1547 dump_generic_node (buffer, gimple_omp_task_data_arg (gs),
1548 spc, flags, false);
1549 else
1550 pp_string (buffer, "???");
1551 pp_string (buffer, ")]");
1552 }
1553 body = gimple_omp_body (gs);
1554 if (body && gimple_code (gimple_seq_first_stmt (body)) != GIMPLE_BIND)
1555 {
1556 newline_and_indent (buffer, spc + 2);
1557 pp_character (buffer, '{');
1558 pp_newline (buffer);
1559 dump_gimple_seq (buffer, body, spc + 4, flags);
1560 newline_and_indent (buffer, spc + 2);
1561 pp_character (buffer, '}');
1562 }
1563 else if (body)
1564 {
1565 pp_newline (buffer);
1566 dump_gimple_seq (buffer, body, spc + 2, flags);
1567 }
1568 }
1569}
1570
1571
1572/* Dump a GIMPLE_OMP_ATOMIC_LOAD tuple on the pretty_printer BUFFER, SPC
1573 spaces of indent. FLAGS specifies details to show in the dump (see TDF_*
1574 in tree-pass.h). */
1575
1576static void
1577dump_gimple_omp_atomic_load (pretty_printer *buffer, gimple gs, int spc,
1578 int flags)
1579{
1580 if (flags & TDF_RAW)
1581 {
1582 dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T>", gs,
1583 gimple_omp_atomic_load_lhs (gs),
1584 gimple_omp_atomic_load_rhs (gs));
1585 }
1586 else
1587 {
1588 pp_string (buffer, "#pragma omp atomic_load");
1589 newline_and_indent (buffer, spc + 2);
1590 dump_generic_node (buffer, gimple_omp_atomic_load_lhs (gs),
1591 spc, flags, false);
1592 pp_space (buffer);
1593 pp_character (buffer, '=');
1594 pp_space (buffer);
1595 pp_character (buffer, '*');
1596 dump_generic_node (buffer, gimple_omp_atomic_load_rhs (gs),
1597 spc, flags, false);
1598 }
1599}
1600
1601/* Dump a GIMPLE_OMP_ATOMIC_STORE tuple on the pretty_printer BUFFER, SPC
1602 spaces of indent. FLAGS specifies details to show in the dump (see TDF_*
1603 in tree-pass.h). */
1604
1605static void
1606dump_gimple_omp_atomic_store (pretty_printer *buffer, gimple gs, int spc,
1607 int flags)
1608{
1609 if (flags & TDF_RAW)
1610 {
1611 dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs,
1612 gimple_omp_atomic_store_val (gs));
1613 }
1614 else
1615 {
1616 pp_string (buffer, "#pragma omp atomic_store (");
1617 dump_generic_node (buffer, gimple_omp_atomic_store_val (gs),
1618 spc, flags, false);
1619 pp_character (buffer, ')');
1620 }
1621}
1622
726a989a
RB		 1623
1624/* Dump all the memory operands for statement GS. BUFFER, SPC and
1625 FLAGS are as in dump_gimple_stmt. */
1626
1627static void
1628dump_gimple_mem_ops (pretty_printer *buffer, gimple gs, int spc, int flags)
1629{
5006671f
RG		 1630 tree vdef = gimple_vdef (gs);
1631 tree vuse = gimple_vuse (gs);
726a989a
RB		 1632
1633 if (!ssa_operands_active () || !gimple_references_memory_p (gs))
1634 return;
1635
5006671f 1636 if (vdef != NULL_TREE)
726a989a 1637 {
5006671f
RG		 1638 pp_string (buffer, "# ");
1639 dump_generic_node (buffer, vdef, spc + 2, flags, false);
1640 pp_string (buffer, " = VDEF <");
1641 dump_generic_node (buffer, vuse, spc + 2, flags, false);
0cf0d02b 1642 pp_character (buffer, '>');
726a989a 1643 newline_and_indent (buffer, spc);
726a989a 1644 }
5006671f 1645 else if (vuse != NULL_TREE)
726a989a 1646 {
5006671f
RG		 1647 pp_string (buffer, "# VUSE <");
1648 dump_generic_node (buffer, vuse, spc + 2, flags, false);
0cf0d02b 1649 pp_character (buffer, '>');
726a989a 1650 newline_and_indent (buffer, spc);
726a989a
RB		 1651 }
1652}
1653
1654
1655/* Dump the gimple statement GS on the pretty printer BUFFER, SPC
1656 spaces of indent. FLAGS specifies details to show in the dump (see
1657 TDF_* in tree-pass.h). */
1658
1659void
1660dump_gimple_stmt (pretty_printer *buffer, gimple gs, int spc, int flags)
1661{
1662 if (!gs)
1663 return;
1664
1665 if (flags & TDF_STMTADDR)
1666 pp_printf (buffer, "<&%p> ", (void *) gs);
1667
1668 if ((flags & TDF_LINENO) && gimple_has_location (gs))
1669 {
1670 expanded_location xloc = expand_location (gimple_location (gs));
1671 pp_character (buffer, '[');
1672 if (xloc.file)
1673 {
1674 pp_string (buffer, xloc.file);
1675 pp_string (buffer, " : ");
1676 }
1677 pp_decimal_int (buffer, xloc.line);
c2255bc4
AH		 1678 pp_string (buffer, ":");
1679 pp_decimal_int (buffer, xloc.column);
726a989a
RB		 1680 pp_string (buffer, "] ");
1681 }
1682
cae63f88
DN		 1683 if (flags & TDF_EH)
1684 {
1d65f45c
RH		 1685 int lp_nr = lookup_stmt_eh_lp (gs);
1686 if (lp_nr > 0)
1687 pp_printf (buffer, "[LP %d] ", lp_nr);
1688 else if (lp_nr < 0)
1689 pp_printf (buffer, "[MNT %d] ", -lp_nr);
cae63f88
DN		 1690 }
1691
726a989a
RB		 1692 if ((flags & (TDF_VOPS|TDF_MEMSYMS))
1693 && gimple_has_mem_ops (gs))
1694 dump_gimple_mem_ops (buffer, gs, spc, flags);
1695
f0107145
RG		 1696 if ((flags & TDF_ALIAS)
1697 && gimple_has_lhs (gs))
1698 {
1699 tree lhs = gimple_get_lhs (gs);
1700 if (TREE_CODE (lhs) == SSA_NAME
1701 && POINTER_TYPE_P (TREE_TYPE (lhs))
1702 && SSA_NAME_PTR_INFO (lhs))
1703 {
1be38ccb 1704 struct ptr_info_def *pi = SSA_NAME_PTR_INFO (lhs);
f0107145 1705 pp_string (buffer, "# PT = ");
1be38ccb 1706 pp_points_to_solution (buffer, &pi->pt);
f0107145 1707 newline_and_indent (buffer, spc);
1be38ccb
RG		 1708 if (pi->align != 1)
1709 {
1710 pp_printf (buffer, "# ALIGN = %u, MISALIGN = %u",
1711 pi->align, pi->misalign);
1712 newline_and_indent (buffer, spc);
1713 }
f0107145
RG		 1714 }
1715 }
1716
726a989a
RB		 1717 switch (gimple_code (gs))
1718 {
1719 case GIMPLE_ASM:
1720 dump_gimple_asm (buffer, gs, spc, flags);
1721 break;
1722
1723 case GIMPLE_ASSIGN:
1724 dump_gimple_assign (buffer, gs, spc, flags);
1725 break;
1726
1727 case GIMPLE_BIND:
1728 dump_gimple_bind (buffer, gs, spc, flags);
1729 break;
1730
1731 case GIMPLE_CALL:
1732 dump_gimple_call (buffer, gs, spc, flags);
1733 break;
1734
1735 case GIMPLE_COND:
1736 dump_gimple_cond (buffer, gs, spc, flags);
1737 break;
1738
1739 case GIMPLE_LABEL:
1740 dump_gimple_label (buffer, gs, spc, flags);
1741 break;
1742
1743 case GIMPLE_GOTO:
1744 dump_gimple_goto (buffer, gs, spc, flags);
1745 break;
1746
1747 case GIMPLE_NOP:
1748 pp_string (buffer, "GIMPLE_NOP");
1749 break;
1750
1751 case GIMPLE_RETURN:
1752 dump_gimple_return (buffer, gs, spc, flags);
1753 break;
1754
1755 case GIMPLE_SWITCH:
1756 dump_gimple_switch (buffer, gs, spc, flags);
1757 break;
1758
1759 case GIMPLE_TRY:
1760 dump_gimple_try (buffer, gs, spc, flags);
1761 break;
1762
1763 case GIMPLE_PHI:
1764 dump_gimple_phi (buffer, gs, spc, flags);
1765 break;
1766
1767 case GIMPLE_OMP_PARALLEL:
1768 dump_gimple_omp_parallel (buffer, gs, spc, flags);
1769 break;
1770
1771 case GIMPLE_OMP_TASK:
1772 dump_gimple_omp_task (buffer, gs, spc, flags);
1773 break;
1774
1775 case GIMPLE_OMP_ATOMIC_LOAD:
1776 dump_gimple_omp_atomic_load (buffer, gs, spc, flags);
1777
1778 break;
1779
1780 case GIMPLE_OMP_ATOMIC_STORE:
1781 dump_gimple_omp_atomic_store (buffer, gs, spc, flags);
1782 break;
1783
1784 case GIMPLE_OMP_FOR:
1785 dump_gimple_omp_for (buffer, gs, spc, flags);
1786 break;
1787
1788 case GIMPLE_OMP_CONTINUE:
1789 dump_gimple_omp_continue (buffer, gs, spc, flags);
1790 break;
1791
1792 case GIMPLE_OMP_SINGLE:
1793 dump_gimple_omp_single (buffer, gs, spc, flags);
1794 break;
1795
1796 case GIMPLE_OMP_RETURN:
1797 dump_gimple_omp_return (buffer, gs, spc, flags);
1798 break;
1799
1800 case GIMPLE_OMP_SECTIONS:
1801 dump_gimple_omp_sections (buffer, gs, spc, flags);
1802 break;
1803
1804 case GIMPLE_OMP_SECTIONS_SWITCH:
1805 pp_string (buffer, "GIMPLE_SECTIONS_SWITCH");
1806 break;
1807
1808 case GIMPLE_OMP_MASTER:
1809 case GIMPLE_OMP_ORDERED:
1810 case GIMPLE_OMP_SECTION:
1811 dump_gimple_omp_block (buffer, gs, spc, flags);
1812 break;
1813
1814 case GIMPLE_OMP_CRITICAL:
1815 dump_gimple_omp_critical (buffer, gs, spc, flags);
1816 break;
1817
726a989a
RB		 1818 case GIMPLE_CATCH:
1819 dump_gimple_catch (buffer, gs, spc, flags);
1820 break;
1821
1822 case GIMPLE_EH_FILTER:
1823 dump_gimple_eh_filter (buffer, gs, spc, flags);
1824 break;
1825
1d65f45c
RH		 1826 case GIMPLE_EH_MUST_NOT_THROW:
1827 dump_gimple_eh_must_not_throw (buffer, gs, spc, flags);
1828 break;
1829
726a989a
RB		 1830 case GIMPLE_RESX:
1831 dump_gimple_resx (buffer, gs, spc, flags);
1832 break;
1833
1d65f45c
RH		 1834 case GIMPLE_EH_DISPATCH:
1835 dump_gimple_eh_dispatch (buffer, gs, spc, flags);
1836 break;
1837
b5b8b0ac
AO		 1838 case GIMPLE_DEBUG:
1839 dump_gimple_debug (buffer, gs, spc, flags);
1840 break;
1841
726a989a
RB		 1842 case GIMPLE_PREDICT:
1843 pp_string (buffer, "// predicted ");
1844 if (gimple_predict_outcome (gs))
1845 pp_string (buffer, "likely by ");
1846 else
1847 pp_string (buffer, "unlikely by ");
1848 pp_string (buffer, predictor_name (gimple_predict_predictor (gs)));
1849 pp_string (buffer, " predictor.");
1850 break;
1851
1852 default:
1853 GIMPLE_NIY;
1854 }
1855
1856 /* If we're building a diagnostic, the formatted text will be
1857 written into BUFFER's stream by the caller; otherwise, write it
1858 now. */
1859 if (!(flags & TDF_DIAGNOSTIC))
1860 pp_write_text_to_stream (buffer);
1861}
1862
1863
1864/* Dumps header of basic block BB to buffer BUFFER indented by INDENT
1865 spaces and details described by flags. */
1866
1867static void
1868dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags)
1869{
1870 edge e;
1871 gimple stmt;
1872 edge_iterator ei;
1873
1874 if (flags & TDF_BLOCKS)
1875 {
1876 INDENT (indent);
1877 pp_string (buffer, "# BLOCK ");
1878 pp_decimal_int (buffer, bb->index);
1879 if (bb->frequency)
1880 {
1881 pp_string (buffer, " freq:");
1882 pp_decimal_int (buffer, bb->frequency);
1883 }
1884 if (bb->count)
1885 {
1886 pp_string (buffer, " count:");
1887 pp_widest_integer (buffer, bb->count);
1888 }
1889
1890 if (flags & TDF_LINENO)
1891 {
1892 gimple_stmt_iterator gsi;
1893
1894 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
b5b8b0ac
AO		 1895 if (!is_gimple_debug (gsi_stmt (gsi))
1896 && get_lineno (gsi_stmt (gsi)) != UNKNOWN_LOCATION)
726a989a
RB		 1897 {
1898 pp_string (buffer, ", starting at line ");
1899 pp_decimal_int (buffer, get_lineno (gsi_stmt (gsi)));
1900 break;
1901 }
6c52e687
CC		 1902
1903 if (bb->discriminator)
1904 {
1905 pp_string (buffer, ", discriminator ");
1906 pp_decimal_int (buffer, bb->discriminator);
1907 }
726a989a
RB		 1908 }
1909 newline_and_indent (buffer, indent);
1910
1911 pp_string (buffer, "# PRED:");
1912 pp_write_text_to_stream (buffer);
1913 FOR_EACH_EDGE (e, ei, bb->preds)
1914 if (flags & TDF_SLIM)
1915 {
0cf0d02b 1916 pp_character (buffer, ' ');
726a989a
RB		 1917 if (e->src == ENTRY_BLOCK_PTR)
1918 pp_string (buffer, "ENTRY");
1919 else
1920 pp_decimal_int (buffer, e->src->index);
1921 }
1922 else
1923 dump_edge_info (buffer->buffer->stream, e, 0);
1924 pp_newline (buffer);
1925 }
1926 else
1927 {
1928 stmt = first_stmt (bb);
1929 if (!stmt || gimple_code (stmt) != GIMPLE_LABEL)
1930 {
1931 INDENT (indent - 2);
1932 pp_string (buffer, "<bb ");
1933 pp_decimal_int (buffer, bb->index);
1934 pp_string (buffer, ">:");
1935 pp_newline (buffer);
1936 }
1937 }
1938 pp_write_text_to_stream (buffer);
858de5cc
BS		 1939 if (cfun)
1940 check_bb_profile (bb, buffer->buffer->stream);
726a989a
RB		 1941}
1942
1943
1944/* Dumps end of basic block BB to buffer BUFFER indented by INDENT
1945 spaces. */
1946
1947static void
1948dump_bb_end (pretty_printer *buffer, basic_block bb, int indent, int flags)
1949{
1950 edge e;
1951 edge_iterator ei;
1952
1953 INDENT (indent);
1954 pp_string (buffer, "# SUCC:");
1955 pp_write_text_to_stream (buffer);
1956 FOR_EACH_EDGE (e, ei, bb->succs)
1957 if (flags & TDF_SLIM)
1958 {
0cf0d02b 1959 pp_character (buffer, ' ');
726a989a
RB		 1960 if (e->dest == EXIT_BLOCK_PTR)
1961 pp_string (buffer, "EXIT");
1962 else
1963 pp_decimal_int (buffer, e->dest->index);
1964 }
1965 else
1966 dump_edge_info (buffer->buffer->stream, e, 1);
1967 pp_newline (buffer);
1968}
1969
1970
1971/* Dump PHI nodes of basic block BB to BUFFER with details described
1972 by FLAGS and indented by INDENT spaces. */
1973
1974static void
1975dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags)
1976{
1977 gimple_stmt_iterator i;
1978
1979 for (i = gsi_start_phis (bb); !gsi_end_p (i); gsi_next (&i))
1980 {
1981 gimple phi = gsi_stmt (i);
1982 if (is_gimple_reg (gimple_phi_result (phi)) || (flags & TDF_VOPS))
1983 {
1984 INDENT (indent);
1985 pp_string (buffer, "# ");
1986 dump_gimple_phi (buffer, phi, indent, flags);
1987 pp_newline (buffer);
1988 }
1989 }
1990}
1991
1992
1993/* Dump jump to basic block BB that is represented implicitly in the cfg
1994 to BUFFER. */
1995
1996static void
1997pp_cfg_jump (pretty_printer *buffer, basic_block bb)
1998{
1999 gimple stmt;
2000
2001 stmt = first_stmt (bb);
2002
2003 pp_string (buffer, "goto <bb ");
2004 pp_decimal_int (buffer, bb->index);
0cf0d02b 2005 pp_character (buffer, '>');
726a989a
RB		 2006 if (stmt && gimple_code (stmt) == GIMPLE_LABEL)
2007 {
2008 pp_string (buffer, " (");
2009 dump_generic_node (buffer, gimple_label_label (stmt), 0, 0, false);
0cf0d02b 2010 pp_character (buffer, ')');
726a989a
RB		 2011 pp_semicolon (buffer);
2012 }
2013 else
2014 pp_semicolon (buffer);
2015}
2016
2017
2018/* Dump edges represented implicitly in basic block BB to BUFFER, indented
2019 by INDENT spaces, with details given by FLAGS. */
2020
2021static void
2022dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,
2023 int flags)
2024{
2025 edge e;
726a989a
RB		 2026 gimple stmt;
2027
2028 stmt = last_stmt (bb);
2029
2030 if (stmt && gimple_code (stmt) == GIMPLE_COND)
2031 {
2032 edge true_edge, false_edge;
2033
2034 /* When we are emitting the code or changing CFG, it is possible that
2035 the edges are not yet created. When we are using debug_bb in such
2036 a situation, we do not want it to crash. */
2037 if (EDGE_COUNT (bb->succs) != 2)
2038 return;
2039 extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
2040
2041 INDENT (indent + 2);
2042 pp_cfg_jump (buffer, true_edge->dest);
2043 newline_and_indent (buffer, indent);
2044 pp_string (buffer, "else");
2045 newline_and_indent (buffer, indent + 2);
2046 pp_cfg_jump (buffer, false_edge->dest);
2047 pp_newline (buffer);
2048 return;
2049 }
2050
2051 /* If there is a fallthru edge, we may need to add an artificial
2052 goto to the dump. */
0fd4b31d 2053 e = find_fallthru_edge (bb->succs);
726a989a
RB		 2054
2055 if (e && e->dest != bb->next_bb)
2056 {
2057 INDENT (indent);
2058
2059 if ((flags & TDF_LINENO)
2060 && e->goto_locus != UNKNOWN_LOCATION
2061 )
2062 {
2063 expanded_location goto_xloc;
2064 goto_xloc = expand_location (e->goto_locus);
2065 pp_character (buffer, '[');
2066 if (goto_xloc.file)
2067 {
2068 pp_string (buffer, goto_xloc.file);
2069 pp_string (buffer, " : ");
2070 }
2071 pp_decimal_int (buffer, goto_xloc.line);
c2255bc4
AH		 2072 pp_string (buffer, " : ");
2073 pp_decimal_int (buffer, goto_xloc.column);
726a989a
RB		 2074 pp_string (buffer, "] ");
2075 }
2076
2077 pp_cfg_jump (buffer, e->dest);
2078 pp_newline (buffer);
2079 }
2080}
2081
2082
2083/* Dumps basic block BB to buffer BUFFER with details described by FLAGS and
2084 indented by INDENT spaces. */
2085
2086static void
2087gimple_dump_bb_buff (pretty_printer *buffer, basic_block bb, int indent,
2088 int flags)
2089{
2090 gimple_stmt_iterator gsi;
2091 gimple stmt;
2092 int label_indent = indent - 2;
2093
2094 if (label_indent < 0)
2095 label_indent = 0;
2096
2097 dump_bb_header (buffer, bb, indent, flags);
2098 dump_phi_nodes (buffer, bb, indent, flags);
2099
2100 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
2101 {
2102 int curr_indent;
2103
2104 stmt = gsi_stmt (gsi);
2105
2106 curr_indent = gimple_code (stmt) == GIMPLE_LABEL ? label_indent : indent;
2107
2108 INDENT (curr_indent);
2109 dump_gimple_stmt (buffer, stmt, curr_indent, flags);
2110 pp_newline (buffer);
2111 dump_histograms_for_stmt (cfun, buffer->buffer->stream, stmt);
2112 }
2113
2114 dump_implicit_edges (buffer, bb, indent, flags);
2115
2116 if (flags & TDF_BLOCKS)
2117 dump_bb_end (buffer, bb, indent, flags);
2118}
2119
2120
2121/* Dumps basic block BB to FILE with details described by FLAGS and
2122 indented by INDENT spaces. */
2123
2124void
2125gimple_dump_bb (basic_block bb, FILE *file, int indent, int flags)
2126{
2127 maybe_init_pretty_print (file);
2128 gimple_dump_bb_buff (&buffer, bb, indent, flags);
2129 pp_flush (&buffer);
2130}
Mirror of https://gcc.gnu.org/git/gcc.git