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