OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [gimple-pretty-print.c] - Blame information for rev 721

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.