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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [tree-cfg.c] - Blame information for rev 684

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 684 jeremybenn
/* Control flow functions for trees.
2
   Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
3
   2010, 2011, 2012  Free Software Foundation, Inc.
4
   Contributed by Diego Novillo <dnovillo@redhat.com>
5
 
6
This file is part of GCC.
7
 
8
GCC is free software; you can redistribute it and/or modify
9
it under the terms of the GNU General Public License as published by
10
the Free Software Foundation; either version 3, or (at your option)
11
any later version.
12
 
13
GCC is distributed in the hope that it will be useful,
14
but WITHOUT ANY WARRANTY; without even the implied warranty of
15
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
GNU General Public License for more details.
17
 
18
You should have received a copy of the GNU General Public License
19
along with GCC; see the file COPYING3.  If not see
20
<http://www.gnu.org/licenses/>.  */
21
 
22
#include "config.h"
23
#include "system.h"
24
#include "coretypes.h"
25
#include "tm.h"
26
#include "tree.h"
27
#include "tm_p.h"
28
#include "basic-block.h"
29
#include "output.h"
30
#include "flags.h"
31
#include "function.h"
32
#include "ggc.h"
33
#include "langhooks.h"
34
#include "tree-pretty-print.h"
35
#include "gimple-pretty-print.h"
36
#include "tree-flow.h"
37
#include "timevar.h"
38
#include "tree-dump.h"
39
#include "tree-pass.h"
40
#include "diagnostic-core.h"
41
#include "except.h"
42
#include "cfgloop.h"
43
#include "cfglayout.h"
44
#include "tree-ssa-propagate.h"
45
#include "value-prof.h"
46
#include "pointer-set.h"
47
#include "tree-inline.h"
48
 
49
/* This file contains functions for building the Control Flow Graph (CFG)
50
   for a function tree.  */
51
 
52
/* Local declarations.  */
53
 
54
/* Initial capacity for the basic block array.  */
55
static const int initial_cfg_capacity = 20;
56
 
57
/* This hash table allows us to efficiently lookup all CASE_LABEL_EXPRs
58
   which use a particular edge.  The CASE_LABEL_EXPRs are chained together
59
   via their TREE_CHAIN field, which we clear after we're done with the
60
   hash table to prevent problems with duplication of GIMPLE_SWITCHes.
61
 
62
   Access to this list of CASE_LABEL_EXPRs allows us to efficiently
63
   update the case vector in response to edge redirections.
64
 
65
   Right now this table is set up and torn down at key points in the
66
   compilation process.  It would be nice if we could make the table
67
   more persistent.  The key is getting notification of changes to
68
   the CFG (particularly edge removal, creation and redirection).  */
69
 
70
static struct pointer_map_t *edge_to_cases;
71
 
72
/* If we record edge_to_cases, this bitmap will hold indexes
73
   of basic blocks that end in a GIMPLE_SWITCH which we touched
74
   due to edge manipulations.  */
75
 
76
static bitmap touched_switch_bbs;
77
 
78
/* CFG statistics.  */
79
struct cfg_stats_d
80
{
81
  long num_merged_labels;
82
};
83
 
84
static struct cfg_stats_d cfg_stats;
85
 
86
/* Nonzero if we found a computed goto while building basic blocks.  */
87
static bool found_computed_goto;
88
 
89
/* Hash table to store last discriminator assigned for each locus.  */
90
struct locus_discrim_map
91
{
92
  location_t locus;
93
  int discriminator;
94
};
95
static htab_t discriminator_per_locus;
96
 
97
/* Basic blocks and flowgraphs.  */
98
static void make_blocks (gimple_seq);
99
static void factor_computed_gotos (void);
100
 
101
/* Edges.  */
102
static void make_edges (void);
103
static void make_cond_expr_edges (basic_block);
104
static void make_gimple_switch_edges (basic_block);
105
static void make_goto_expr_edges (basic_block);
106
static void make_gimple_asm_edges (basic_block);
107
static unsigned int locus_map_hash (const void *);
108
static int locus_map_eq (const void *, const void *);
109
static void assign_discriminator (location_t, basic_block);
110
static edge gimple_redirect_edge_and_branch (edge, basic_block);
111
static edge gimple_try_redirect_by_replacing_jump (edge, basic_block);
112
static unsigned int split_critical_edges (void);
113
 
114
/* Various helpers.  */
115
static inline bool stmt_starts_bb_p (gimple, gimple);
116
static int gimple_verify_flow_info (void);
117
static void gimple_make_forwarder_block (edge);
118
static void gimple_cfg2vcg (FILE *);
119
static gimple first_non_label_stmt (basic_block);
120
static bool verify_gimple_transaction (gimple);
121
 
122
/* Flowgraph optimization and cleanup.  */
123
static void gimple_merge_blocks (basic_block, basic_block);
124
static bool gimple_can_merge_blocks_p (basic_block, basic_block);
125
static void remove_bb (basic_block);
126
static edge find_taken_edge_computed_goto (basic_block, tree);
127
static edge find_taken_edge_cond_expr (basic_block, tree);
128
static edge find_taken_edge_switch_expr (basic_block, tree);
129
static tree find_case_label_for_value (gimple, tree);
130
static void group_case_labels_stmt (gimple);
131
 
132
void
133
init_empty_tree_cfg_for_function (struct function *fn)
134
{
135
  /* Initialize the basic block array.  */
136
  init_flow (fn);
137
  profile_status_for_function (fn) = PROFILE_ABSENT;
138
  n_basic_blocks_for_function (fn) = NUM_FIXED_BLOCKS;
139
  last_basic_block_for_function (fn) = NUM_FIXED_BLOCKS;
140
  basic_block_info_for_function (fn)
141
    = VEC_alloc (basic_block, gc, initial_cfg_capacity);
142
  VEC_safe_grow_cleared (basic_block, gc,
143
                         basic_block_info_for_function (fn),
144
                         initial_cfg_capacity);
145
 
146
  /* Build a mapping of labels to their associated blocks.  */
147
  label_to_block_map_for_function (fn)
148
    = VEC_alloc (basic_block, gc, initial_cfg_capacity);
149
  VEC_safe_grow_cleared (basic_block, gc,
150
                         label_to_block_map_for_function (fn),
151
                         initial_cfg_capacity);
152
 
153
  SET_BASIC_BLOCK_FOR_FUNCTION (fn, ENTRY_BLOCK,
154
                                ENTRY_BLOCK_PTR_FOR_FUNCTION (fn));
155
  SET_BASIC_BLOCK_FOR_FUNCTION (fn, EXIT_BLOCK,
156
                   EXIT_BLOCK_PTR_FOR_FUNCTION (fn));
157
 
158
  ENTRY_BLOCK_PTR_FOR_FUNCTION (fn)->next_bb
159
    = EXIT_BLOCK_PTR_FOR_FUNCTION (fn);
160
  EXIT_BLOCK_PTR_FOR_FUNCTION (fn)->prev_bb
161
    = ENTRY_BLOCK_PTR_FOR_FUNCTION (fn);
162
}
163
 
164
void
165
init_empty_tree_cfg (void)
166
{
167
  init_empty_tree_cfg_for_function (cfun);
168
}
169
 
170
/*---------------------------------------------------------------------------
171
                              Create basic blocks
172
---------------------------------------------------------------------------*/
173
 
174
/* Entry point to the CFG builder for trees.  SEQ is the sequence of
175
   statements to be added to the flowgraph.  */
176
 
177
static void
178
build_gimple_cfg (gimple_seq seq)
179
{
180
  /* Register specific gimple functions.  */
181
  gimple_register_cfg_hooks ();
182
 
183
  memset ((void *) &cfg_stats, 0, sizeof (cfg_stats));
184
 
185
  init_empty_tree_cfg ();
186
 
187
  found_computed_goto = 0;
188
  make_blocks (seq);
189
 
190
  /* Computed gotos are hell to deal with, especially if there are
191
     lots of them with a large number of destinations.  So we factor
192
     them to a common computed goto location before we build the
193
     edge list.  After we convert back to normal form, we will un-factor
194
     the computed gotos since factoring introduces an unwanted jump.  */
195
  if (found_computed_goto)
196
    factor_computed_gotos ();
197
 
198
  /* Make sure there is always at least one block, even if it's empty.  */
199
  if (n_basic_blocks == NUM_FIXED_BLOCKS)
200
    create_empty_bb (ENTRY_BLOCK_PTR);
201
 
202
  /* Adjust the size of the array.  */
203
  if (VEC_length (basic_block, basic_block_info) < (size_t) n_basic_blocks)
204
    VEC_safe_grow_cleared (basic_block, gc, basic_block_info, n_basic_blocks);
205
 
206
  /* To speed up statement iterator walks, we first purge dead labels.  */
207
  cleanup_dead_labels ();
208
 
209
  /* Group case nodes to reduce the number of edges.
210
     We do this after cleaning up dead labels because otherwise we miss
211
     a lot of obvious case merging opportunities.  */
212
  group_case_labels ();
213
 
214
  /* Create the edges of the flowgraph.  */
215
  discriminator_per_locus = htab_create (13, locus_map_hash, locus_map_eq,
216
                                         free);
217
  make_edges ();
218
  cleanup_dead_labels ();
219
  htab_delete (discriminator_per_locus);
220
 
221
  /* Debugging dumps.  */
222
 
223
  /* Write the flowgraph to a VCG file.  */
224
  {
225
    int local_dump_flags;
226
    FILE *vcg_file = dump_begin (TDI_vcg, &local_dump_flags);
227
    if (vcg_file)
228
      {
229
        gimple_cfg2vcg (vcg_file);
230
        dump_end (TDI_vcg, vcg_file);
231
      }
232
  }
233
}
234
 
235
static unsigned int
236
execute_build_cfg (void)
237
{
238
  gimple_seq body = gimple_body (current_function_decl);
239
 
240
  build_gimple_cfg (body);
241
  gimple_set_body (current_function_decl, NULL);
242
  if (dump_file && (dump_flags & TDF_DETAILS))
243
    {
244
      fprintf (dump_file, "Scope blocks:\n");
245
      dump_scope_blocks (dump_file, dump_flags);
246
    }
247
  return 0;
248
}
249
 
250
struct gimple_opt_pass pass_build_cfg =
251
{
252
 {
253
  GIMPLE_PASS,
254
  "cfg",                                /* name */
255
  NULL,                                 /* gate */
256
  execute_build_cfg,                    /* execute */
257
  NULL,                                 /* sub */
258
  NULL,                                 /* next */
259
  0,                                     /* static_pass_number */
260
  TV_TREE_CFG,                          /* tv_id */
261
  PROP_gimple_leh,                      /* properties_required */
262
  PROP_cfg,                             /* properties_provided */
263
  0,                                     /* properties_destroyed */
264
  0,                                     /* todo_flags_start */
265
  TODO_verify_stmts | TODO_cleanup_cfg  /* todo_flags_finish */
266
 }
267
};
268
 
269
 
270
/* Return true if T is a computed goto.  */
271
 
272
static bool
273
computed_goto_p (gimple t)
274
{
275
  return (gimple_code (t) == GIMPLE_GOTO
276
          && TREE_CODE (gimple_goto_dest (t)) != LABEL_DECL);
277
}
278
 
279
 
280
/* Search the CFG for any computed gotos.  If found, factor them to a
281
   common computed goto site.  Also record the location of that site so
282
   that we can un-factor the gotos after we have converted back to
283
   normal form.  */
284
 
285
static void
286
factor_computed_gotos (void)
287
{
288
  basic_block bb;
289
  tree factored_label_decl = NULL;
290
  tree var = NULL;
291
  gimple factored_computed_goto_label = NULL;
292
  gimple factored_computed_goto = NULL;
293
 
294
  /* We know there are one or more computed gotos in this function.
295
     Examine the last statement in each basic block to see if the block
296
     ends with a computed goto.  */
297
 
298
  FOR_EACH_BB (bb)
299
    {
300
      gimple_stmt_iterator gsi = gsi_last_bb (bb);
301
      gimple last;
302
 
303
      if (gsi_end_p (gsi))
304
        continue;
305
 
306
      last = gsi_stmt (gsi);
307
 
308
      /* Ignore the computed goto we create when we factor the original
309
         computed gotos.  */
310
      if (last == factored_computed_goto)
311
        continue;
312
 
313
      /* If the last statement is a computed goto, factor it.  */
314
      if (computed_goto_p (last))
315
        {
316
          gimple assignment;
317
 
318
          /* The first time we find a computed goto we need to create
319
             the factored goto block and the variable each original
320
             computed goto will use for their goto destination.  */
321
          if (!factored_computed_goto)
322
            {
323
              basic_block new_bb = create_empty_bb (bb);
324
              gimple_stmt_iterator new_gsi = gsi_start_bb (new_bb);
325
 
326
              /* Create the destination of the factored goto.  Each original
327
                 computed goto will put its desired destination into this
328
                 variable and jump to the label we create immediately
329
                 below.  */
330
              var = create_tmp_var (ptr_type_node, "gotovar");
331
 
332
              /* Build a label for the new block which will contain the
333
                 factored computed goto.  */
334
              factored_label_decl = create_artificial_label (UNKNOWN_LOCATION);
335
              factored_computed_goto_label
336
                = gimple_build_label (factored_label_decl);
337
              gsi_insert_after (&new_gsi, factored_computed_goto_label,
338
                                GSI_NEW_STMT);
339
 
340
              /* Build our new computed goto.  */
341
              factored_computed_goto = gimple_build_goto (var);
342
              gsi_insert_after (&new_gsi, factored_computed_goto, GSI_NEW_STMT);
343
            }
344
 
345
          /* Copy the original computed goto's destination into VAR.  */
346
          assignment = gimple_build_assign (var, gimple_goto_dest (last));
347
          gsi_insert_before (&gsi, assignment, GSI_SAME_STMT);
348
 
349
          /* And re-vector the computed goto to the new destination.  */
350
          gimple_goto_set_dest (last, factored_label_decl);
351
        }
352
    }
353
}
354
 
355
 
356
/* Build a flowgraph for the sequence of stmts SEQ.  */
357
 
358
static void
359
make_blocks (gimple_seq seq)
360
{
361
  gimple_stmt_iterator i = gsi_start (seq);
362
  gimple stmt = NULL;
363
  bool start_new_block = true;
364
  bool first_stmt_of_seq = true;
365
  basic_block bb = ENTRY_BLOCK_PTR;
366
 
367
  while (!gsi_end_p (i))
368
    {
369
      gimple prev_stmt;
370
 
371
      prev_stmt = stmt;
372
      stmt = gsi_stmt (i);
373
 
374
      /* If the statement starts a new basic block or if we have determined
375
         in a previous pass that we need to create a new block for STMT, do
376
         so now.  */
377
      if (start_new_block || stmt_starts_bb_p (stmt, prev_stmt))
378
        {
379
          if (!first_stmt_of_seq)
380
            seq = gsi_split_seq_before (&i);
381
          bb = create_basic_block (seq, NULL, bb);
382
          start_new_block = false;
383
        }
384
 
385
      /* Now add STMT to BB and create the subgraphs for special statement
386
         codes.  */
387
      gimple_set_bb (stmt, bb);
388
 
389
      if (computed_goto_p (stmt))
390
        found_computed_goto = true;
391
 
392
      /* If STMT is a basic block terminator, set START_NEW_BLOCK for the
393
         next iteration.  */
394
      if (stmt_ends_bb_p (stmt))
395
        {
396
          /* If the stmt can make abnormal goto use a new temporary
397
             for the assignment to the LHS.  This makes sure the old value
398
             of the LHS is available on the abnormal edge.  Otherwise
399
             we will end up with overlapping life-ranges for abnormal
400
             SSA names.  */
401
          if (gimple_has_lhs (stmt)
402
              && stmt_can_make_abnormal_goto (stmt)
403
              && is_gimple_reg_type (TREE_TYPE (gimple_get_lhs (stmt))))
404
            {
405
              tree lhs = gimple_get_lhs (stmt);
406
              tree tmp = create_tmp_var (TREE_TYPE (lhs), NULL);
407
              gimple s = gimple_build_assign (lhs, tmp);
408
              gimple_set_location (s, gimple_location (stmt));
409
              gimple_set_block (s, gimple_block (stmt));
410
              gimple_set_lhs (stmt, tmp);
411
              if (TREE_CODE (TREE_TYPE (tmp)) == COMPLEX_TYPE
412
                  || TREE_CODE (TREE_TYPE (tmp)) == VECTOR_TYPE)
413
                DECL_GIMPLE_REG_P (tmp) = 1;
414
              gsi_insert_after (&i, s, GSI_SAME_STMT);
415
            }
416
          start_new_block = true;
417
        }
418
 
419
      gsi_next (&i);
420
      first_stmt_of_seq = false;
421
    }
422
}
423
 
424
 
425
/* Create and return a new empty basic block after bb AFTER.  */
426
 
427
static basic_block
428
create_bb (void *h, void *e, basic_block after)
429
{
430
  basic_block bb;
431
 
432
  gcc_assert (!e);
433
 
434
  /* Create and initialize a new basic block.  Since alloc_block uses
435
     GC allocation that clears memory to allocate a basic block, we do
436
     not have to clear the newly allocated basic block here.  */
437
  bb = alloc_block ();
438
 
439
  bb->index = last_basic_block;
440
  bb->flags = BB_NEW;
441
  bb->il.gimple = ggc_alloc_cleared_gimple_bb_info ();
442
  set_bb_seq (bb, h ? (gimple_seq) h : gimple_seq_alloc ());
443
 
444
  /* Add the new block to the linked list of blocks.  */
445
  link_block (bb, after);
446
 
447
  /* Grow the basic block array if needed.  */
448
  if ((size_t) last_basic_block == VEC_length (basic_block, basic_block_info))
449
    {
450
      size_t new_size = last_basic_block + (last_basic_block + 3) / 4;
451
      VEC_safe_grow_cleared (basic_block, gc, basic_block_info, new_size);
452
    }
453
 
454
  /* Add the newly created block to the array.  */
455
  SET_BASIC_BLOCK (last_basic_block, bb);
456
 
457
  n_basic_blocks++;
458
  last_basic_block++;
459
 
460
  return bb;
461
}
462
 
463
 
464
/*---------------------------------------------------------------------------
465
                                 Edge creation
466
---------------------------------------------------------------------------*/
467
 
468
/* Fold COND_EXPR_COND of each COND_EXPR.  */
469
 
470
void
471
fold_cond_expr_cond (void)
472
{
473
  basic_block bb;
474
 
475
  FOR_EACH_BB (bb)
476
    {
477
      gimple stmt = last_stmt (bb);
478
 
479
      if (stmt && gimple_code (stmt) == GIMPLE_COND)
480
        {
481
          location_t loc = gimple_location (stmt);
482
          tree cond;
483
          bool zerop, onep;
484
 
485
          fold_defer_overflow_warnings ();
486
          cond = fold_binary_loc (loc, gimple_cond_code (stmt), boolean_type_node,
487
                              gimple_cond_lhs (stmt), gimple_cond_rhs (stmt));
488
          if (cond)
489
            {
490
              zerop = integer_zerop (cond);
491
              onep = integer_onep (cond);
492
            }
493
          else
494
            zerop = onep = false;
495
 
496
          fold_undefer_overflow_warnings (zerop || onep,
497
                                          stmt,
498
                                          WARN_STRICT_OVERFLOW_CONDITIONAL);
499
          if (zerop)
500
            gimple_cond_make_false (stmt);
501
          else if (onep)
502
            gimple_cond_make_true (stmt);
503
        }
504
    }
505
}
506
 
507
/* Join all the blocks in the flowgraph.  */
508
 
509
static void
510
make_edges (void)
511
{
512
  basic_block bb;
513
  struct omp_region *cur_region = NULL;
514
 
515
  /* Create an edge from entry to the first block with executable
516
     statements in it.  */
517
  make_edge (ENTRY_BLOCK_PTR, BASIC_BLOCK (NUM_FIXED_BLOCKS), EDGE_FALLTHRU);
518
 
519
  /* Traverse the basic block array placing edges.  */
520
  FOR_EACH_BB (bb)
521
    {
522
      gimple last = last_stmt (bb);
523
      bool fallthru;
524
 
525
      if (last)
526
        {
527
          enum gimple_code code = gimple_code (last);
528
          switch (code)
529
            {
530
            case GIMPLE_GOTO:
531
              make_goto_expr_edges (bb);
532
              fallthru = false;
533
              break;
534
            case GIMPLE_RETURN:
535
              make_edge (bb, EXIT_BLOCK_PTR, 0);
536
              fallthru = false;
537
              break;
538
            case GIMPLE_COND:
539
              make_cond_expr_edges (bb);
540
              fallthru = false;
541
              break;
542
            case GIMPLE_SWITCH:
543
              make_gimple_switch_edges (bb);
544
              fallthru = false;
545
              break;
546
            case GIMPLE_RESX:
547
              make_eh_edges (last);
548
              fallthru = false;
549
              break;
550
            case GIMPLE_EH_DISPATCH:
551
              fallthru = make_eh_dispatch_edges (last);
552
              break;
553
 
554
            case GIMPLE_CALL:
555
              /* If this function receives a nonlocal goto, then we need to
556
                 make edges from this call site to all the nonlocal goto
557
                 handlers.  */
558
              if (stmt_can_make_abnormal_goto (last))
559
                make_abnormal_goto_edges (bb, true);
560
 
561
              /* If this statement has reachable exception handlers, then
562
                 create abnormal edges to them.  */
563
              make_eh_edges (last);
564
 
565
              /* BUILTIN_RETURN is really a return statement.  */
566
              if (gimple_call_builtin_p (last, BUILT_IN_RETURN))
567
                make_edge (bb, EXIT_BLOCK_PTR, 0), fallthru = false;
568
              /* Some calls are known not to return.  */
569
              else
570
                fallthru = !(gimple_call_flags (last) & ECF_NORETURN);
571
              break;
572
 
573
            case GIMPLE_ASSIGN:
574
               /* A GIMPLE_ASSIGN may throw internally and thus be considered
575
                  control-altering. */
576
              if (is_ctrl_altering_stmt (last))
577
                make_eh_edges (last);
578
              fallthru = true;
579
              break;
580
 
581
            case GIMPLE_ASM:
582
              make_gimple_asm_edges (bb);
583
              fallthru = true;
584
              break;
585
 
586
            case GIMPLE_OMP_PARALLEL:
587
            case GIMPLE_OMP_TASK:
588
            case GIMPLE_OMP_FOR:
589
            case GIMPLE_OMP_SINGLE:
590
            case GIMPLE_OMP_MASTER:
591
            case GIMPLE_OMP_ORDERED:
592
            case GIMPLE_OMP_CRITICAL:
593
            case GIMPLE_OMP_SECTION:
594
              cur_region = new_omp_region (bb, code, cur_region);
595
              fallthru = true;
596
              break;
597
 
598
            case GIMPLE_OMP_SECTIONS:
599
              cur_region = new_omp_region (bb, code, cur_region);
600
              fallthru = true;
601
              break;
602
 
603
            case GIMPLE_OMP_SECTIONS_SWITCH:
604
              fallthru = false;
605
              break;
606
 
607
            case GIMPLE_OMP_ATOMIC_LOAD:
608
            case GIMPLE_OMP_ATOMIC_STORE:
609
               fallthru = true;
610
               break;
611
 
612
            case GIMPLE_OMP_RETURN:
613
              /* In the case of a GIMPLE_OMP_SECTION, the edge will go
614
                 somewhere other than the next block.  This will be
615
                 created later.  */
616
              cur_region->exit = bb;
617
              fallthru = cur_region->type != GIMPLE_OMP_SECTION;
618
              cur_region = cur_region->outer;
619
              break;
620
 
621
            case GIMPLE_OMP_CONTINUE:
622
              cur_region->cont = bb;
623
              switch (cur_region->type)
624
                {
625
                case GIMPLE_OMP_FOR:
626
                  /* Mark all GIMPLE_OMP_FOR and GIMPLE_OMP_CONTINUE
627
                     succs edges as abnormal to prevent splitting
628
                     them.  */
629
                  single_succ_edge (cur_region->entry)->flags |= EDGE_ABNORMAL;
630
                  /* Make the loopback edge.  */
631
                  make_edge (bb, single_succ (cur_region->entry),
632
                             EDGE_ABNORMAL);
633
 
634
                  /* Create an edge from GIMPLE_OMP_FOR to exit, which
635
                     corresponds to the case that the body of the loop
636
                     is not executed at all.  */
637
                  make_edge (cur_region->entry, bb->next_bb, EDGE_ABNORMAL);
638
                  make_edge (bb, bb->next_bb, EDGE_FALLTHRU | EDGE_ABNORMAL);
639
                  fallthru = false;
640
                  break;
641
 
642
                case GIMPLE_OMP_SECTIONS:
643
                  /* Wire up the edges into and out of the nested sections.  */
644
                  {
645
                    basic_block switch_bb = single_succ (cur_region->entry);
646
 
647
                    struct omp_region *i;
648
                    for (i = cur_region->inner; i ; i = i->next)
649
                      {
650
                        gcc_assert (i->type == GIMPLE_OMP_SECTION);
651
                        make_edge (switch_bb, i->entry, 0);
652
                        make_edge (i->exit, bb, EDGE_FALLTHRU);
653
                      }
654
 
655
                    /* Make the loopback edge to the block with
656
                       GIMPLE_OMP_SECTIONS_SWITCH.  */
657
                    make_edge (bb, switch_bb, 0);
658
 
659
                    /* Make the edge from the switch to exit.  */
660
                    make_edge (switch_bb, bb->next_bb, 0);
661
                    fallthru = false;
662
                  }
663
                  break;
664
 
665
                default:
666
                  gcc_unreachable ();
667
                }
668
              break;
669
 
670
            case GIMPLE_TRANSACTION:
671
              {
672
                tree abort_label = gimple_transaction_label (last);
673
                if (abort_label)
674
                  make_edge (bb, label_to_block (abort_label), 0);
675
                fallthru = true;
676
              }
677
              break;
678
 
679
            default:
680
              gcc_assert (!stmt_ends_bb_p (last));
681
              fallthru = true;
682
            }
683
        }
684
      else
685
        fallthru = true;
686
 
687
      if (fallthru)
688
        {
689
          make_edge (bb, bb->next_bb, EDGE_FALLTHRU);
690
          if (last)
691
            assign_discriminator (gimple_location (last), bb->next_bb);
692
        }
693
    }
694
 
695
  if (root_omp_region)
696
    free_omp_regions ();
697
 
698
  /* Fold COND_EXPR_COND of each COND_EXPR.  */
699
  fold_cond_expr_cond ();
700
}
701
 
702
/* Trivial hash function for a location_t.  ITEM is a pointer to
703
   a hash table entry that maps a location_t to a discriminator.  */
704
 
705
static unsigned int
706
locus_map_hash (const void *item)
707
{
708
  return ((const struct locus_discrim_map *) item)->locus;
709
}
710
 
711
/* Equality function for the locus-to-discriminator map.  VA and VB
712
   point to the two hash table entries to compare.  */
713
 
714
static int
715
locus_map_eq (const void *va, const void *vb)
716
{
717
  const struct locus_discrim_map *a = (const struct locus_discrim_map *) va;
718
  const struct locus_discrim_map *b = (const struct locus_discrim_map *) vb;
719
  return a->locus == b->locus;
720
}
721
 
722
/* Find the next available discriminator value for LOCUS.  The
723
   discriminator distinguishes among several basic blocks that
724
   share a common locus, allowing for more accurate sample-based
725
   profiling.  */
726
 
727
static int
728
next_discriminator_for_locus (location_t locus)
729
{
730
  struct locus_discrim_map item;
731
  struct locus_discrim_map **slot;
732
 
733
  item.locus = locus;
734
  item.discriminator = 0;
735
  slot = (struct locus_discrim_map **)
736
      htab_find_slot_with_hash (discriminator_per_locus, (void *) &item,
737
                                (hashval_t) locus, INSERT);
738
  gcc_assert (slot);
739
  if (*slot == HTAB_EMPTY_ENTRY)
740
    {
741
      *slot = XNEW (struct locus_discrim_map);
742
      gcc_assert (*slot);
743
      (*slot)->locus = locus;
744
      (*slot)->discriminator = 0;
745
    }
746
  (*slot)->discriminator++;
747
  return (*slot)->discriminator;
748
}
749
 
750
/* Return TRUE if LOCUS1 and LOCUS2 refer to the same source line.  */
751
 
752
static bool
753
same_line_p (location_t locus1, location_t locus2)
754
{
755
  expanded_location from, to;
756
 
757
  if (locus1 == locus2)
758
    return true;
759
 
760
  from = expand_location (locus1);
761
  to = expand_location (locus2);
762
 
763
  if (from.line != to.line)
764
    return false;
765
  if (from.file == to.file)
766
    return true;
767
  return (from.file != NULL
768
          && to.file != NULL
769
          && filename_cmp (from.file, to.file) == 0);
770
}
771
 
772
/* Assign a unique discriminator value to block BB if it begins at the same
773
   LOCUS as its predecessor block.  */
774
 
775
static void
776
assign_discriminator (location_t locus, basic_block bb)
777
{
778
  gimple first_in_to_bb, last_in_to_bb;
779
 
780
  if (locus == 0 || bb->discriminator != 0)
781
    return;
782
 
783
  first_in_to_bb = first_non_label_stmt (bb);
784
  last_in_to_bb = last_stmt (bb);
785
  if ((first_in_to_bb && same_line_p (locus, gimple_location (first_in_to_bb)))
786
      || (last_in_to_bb && same_line_p (locus, gimple_location (last_in_to_bb))))
787
    bb->discriminator = next_discriminator_for_locus (locus);
788
}
789
 
790
/* Create the edges for a GIMPLE_COND starting at block BB.  */
791
 
792
static void
793
make_cond_expr_edges (basic_block bb)
794
{
795
  gimple entry = last_stmt (bb);
796
  gimple then_stmt, else_stmt;
797
  basic_block then_bb, else_bb;
798
  tree then_label, else_label;
799
  edge e;
800
  location_t entry_locus;
801
 
802
  gcc_assert (entry);
803
  gcc_assert (gimple_code (entry) == GIMPLE_COND);
804
 
805
  entry_locus = gimple_location (entry);
806
 
807
  /* Entry basic blocks for each component.  */
808
  then_label = gimple_cond_true_label (entry);
809
  else_label = gimple_cond_false_label (entry);
810
  then_bb = label_to_block (then_label);
811
  else_bb = label_to_block (else_label);
812
  then_stmt = first_stmt (then_bb);
813
  else_stmt = first_stmt (else_bb);
814
 
815
  e = make_edge (bb, then_bb, EDGE_TRUE_VALUE);
816
  assign_discriminator (entry_locus, then_bb);
817
  e->goto_locus = gimple_location (then_stmt);
818
  if (e->goto_locus)
819
    e->goto_block = gimple_block (then_stmt);
820
  e = make_edge (bb, else_bb, EDGE_FALSE_VALUE);
821
  if (e)
822
    {
823
      assign_discriminator (entry_locus, else_bb);
824
      e->goto_locus = gimple_location (else_stmt);
825
      if (e->goto_locus)
826
        e->goto_block = gimple_block (else_stmt);
827
    }
828
 
829
  /* We do not need the labels anymore.  */
830
  gimple_cond_set_true_label (entry, NULL_TREE);
831
  gimple_cond_set_false_label (entry, NULL_TREE);
832
}
833
 
834
 
835
/* Called for each element in the hash table (P) as we delete the
836
   edge to cases hash table.
837
 
838
   Clear all the TREE_CHAINs to prevent problems with copying of
839
   SWITCH_EXPRs and structure sharing rules, then free the hash table
840
   element.  */
841
 
842
static bool
843
edge_to_cases_cleanup (const void *key ATTRIBUTE_UNUSED, void **value,
844
                       void *data ATTRIBUTE_UNUSED)
845
{
846
  tree t, next;
847
 
848
  for (t = (tree) *value; t; t = next)
849
    {
850
      next = CASE_CHAIN (t);
851
      CASE_CHAIN (t) = NULL;
852
    }
853
 
854
  *value = NULL;
855
  return true;
856
}
857
 
858
/* Start recording information mapping edges to case labels.  */
859
 
860
void
861
start_recording_case_labels (void)
862
{
863
  gcc_assert (edge_to_cases == NULL);
864
  edge_to_cases = pointer_map_create ();
865
  touched_switch_bbs = BITMAP_ALLOC (NULL);
866
}
867
 
868
/* Return nonzero if we are recording information for case labels.  */
869
 
870
static bool
871
recording_case_labels_p (void)
872
{
873
  return (edge_to_cases != NULL);
874
}
875
 
876
/* Stop recording information mapping edges to case labels and
877
   remove any information we have recorded.  */
878
void
879
end_recording_case_labels (void)
880
{
881
  bitmap_iterator bi;
882
  unsigned i;
883
  pointer_map_traverse (edge_to_cases, edge_to_cases_cleanup, NULL);
884
  pointer_map_destroy (edge_to_cases);
885
  edge_to_cases = NULL;
886
  EXECUTE_IF_SET_IN_BITMAP (touched_switch_bbs, 0, i, bi)
887
    {
888
      basic_block bb = BASIC_BLOCK (i);
889
      if (bb)
890
        {
891
          gimple stmt = last_stmt (bb);
892
          if (stmt && gimple_code (stmt) == GIMPLE_SWITCH)
893
            group_case_labels_stmt (stmt);
894
        }
895
    }
896
  BITMAP_FREE (touched_switch_bbs);
897
}
898
 
899
/* If we are inside a {start,end}_recording_cases block, then return
900
   a chain of CASE_LABEL_EXPRs from T which reference E.
901
 
902
   Otherwise return NULL.  */
903
 
904
static tree
905
get_cases_for_edge (edge e, gimple t)
906
{
907
  void **slot;
908
  size_t i, n;
909
 
910
  /* If we are not recording cases, then we do not have CASE_LABEL_EXPR
911
     chains available.  Return NULL so the caller can detect this case.  */
912
  if (!recording_case_labels_p ())
913
    return NULL;
914
 
915
  slot = pointer_map_contains (edge_to_cases, e);
916
  if (slot)
917
    return (tree) *slot;
918
 
919
  /* If we did not find E in the hash table, then this must be the first
920
     time we have been queried for information about E & T.  Add all the
921
     elements from T to the hash table then perform the query again.  */
922
 
923
  n = gimple_switch_num_labels (t);
924
  for (i = 0; i < n; i++)
925
    {
926
      tree elt = gimple_switch_label (t, i);
927
      tree lab = CASE_LABEL (elt);
928
      basic_block label_bb = label_to_block (lab);
929
      edge this_edge = find_edge (e->src, label_bb);
930
 
931
      /* Add it to the chain of CASE_LABEL_EXPRs referencing E, or create
932
         a new chain.  */
933
      slot = pointer_map_insert (edge_to_cases, this_edge);
934
      CASE_CHAIN (elt) = (tree) *slot;
935
      *slot = elt;
936
    }
937
 
938
  return (tree) *pointer_map_contains (edge_to_cases, e);
939
}
940
 
941
/* Create the edges for a GIMPLE_SWITCH starting at block BB.  */
942
 
943
static void
944
make_gimple_switch_edges (basic_block bb)
945
{
946
  gimple entry = last_stmt (bb);
947
  location_t entry_locus;
948
  size_t i, n;
949
 
950
  entry_locus = gimple_location (entry);
951
 
952
  n = gimple_switch_num_labels (entry);
953
 
954
  for (i = 0; i < n; ++i)
955
    {
956
      tree lab = CASE_LABEL (gimple_switch_label (entry, i));
957
      basic_block label_bb = label_to_block (lab);
958
      make_edge (bb, label_bb, 0);
959
      assign_discriminator (entry_locus, label_bb);
960
    }
961
}
962
 
963
 
964
/* Return the basic block holding label DEST.  */
965
 
966
basic_block
967
label_to_block_fn (struct function *ifun, tree dest)
968
{
969
  int uid = LABEL_DECL_UID (dest);
970
 
971
  /* We would die hard when faced by an undefined label.  Emit a label to
972
     the very first basic block.  This will hopefully make even the dataflow
973
     and undefined variable warnings quite right.  */
974
  if (seen_error () && uid < 0)
975
    {
976
      gimple_stmt_iterator gsi = gsi_start_bb (BASIC_BLOCK (NUM_FIXED_BLOCKS));
977
      gimple stmt;
978
 
979
      stmt = gimple_build_label (dest);
980
      gsi_insert_before (&gsi, stmt, GSI_NEW_STMT);
981
      uid = LABEL_DECL_UID (dest);
982
    }
983
  if (VEC_length (basic_block, ifun->cfg->x_label_to_block_map)
984
      <= (unsigned int) uid)
985
    return NULL;
986
  return VEC_index (basic_block, ifun->cfg->x_label_to_block_map, uid);
987
}
988
 
989
/* Create edges for an abnormal goto statement at block BB.  If FOR_CALL
990
   is true, the source statement is a CALL_EXPR instead of a GOTO_EXPR.  */
991
 
992
void
993
make_abnormal_goto_edges (basic_block bb, bool for_call)
994
{
995
  basic_block target_bb;
996
  gimple_stmt_iterator gsi;
997
 
998
  FOR_EACH_BB (target_bb)
999
    for (gsi = gsi_start_bb (target_bb); !gsi_end_p (gsi); gsi_next (&gsi))
1000
      {
1001
        gimple label_stmt = gsi_stmt (gsi);
1002
        tree target;
1003
 
1004
        if (gimple_code (label_stmt) != GIMPLE_LABEL)
1005
          break;
1006
 
1007
        target = gimple_label_label (label_stmt);
1008
 
1009
        /* Make an edge to every label block that has been marked as a
1010
           potential target for a computed goto or a non-local goto.  */
1011
        if ((FORCED_LABEL (target) && !for_call)
1012
            || (DECL_NONLOCAL (target) && for_call))
1013
          {
1014
            make_edge (bb, target_bb, EDGE_ABNORMAL);
1015
            break;
1016
          }
1017
      }
1018
}
1019
 
1020
/* Create edges for a goto statement at block BB.  */
1021
 
1022
static void
1023
make_goto_expr_edges (basic_block bb)
1024
{
1025
  gimple_stmt_iterator last = gsi_last_bb (bb);
1026
  gimple goto_t = gsi_stmt (last);
1027
 
1028
  /* A simple GOTO creates normal edges.  */
1029
  if (simple_goto_p (goto_t))
1030
    {
1031
      tree dest = gimple_goto_dest (goto_t);
1032
      basic_block label_bb = label_to_block (dest);
1033
      edge e = make_edge (bb, label_bb, EDGE_FALLTHRU);
1034
      e->goto_locus = gimple_location (goto_t);
1035
      assign_discriminator (e->goto_locus, label_bb);
1036
      if (e->goto_locus)
1037
        e->goto_block = gimple_block (goto_t);
1038
      gsi_remove (&last, true);
1039
      return;
1040
    }
1041
 
1042
  /* A computed GOTO creates abnormal edges.  */
1043
  make_abnormal_goto_edges (bb, false);
1044
}
1045
 
1046
/* Create edges for an asm statement with labels at block BB.  */
1047
 
1048
static void
1049
make_gimple_asm_edges (basic_block bb)
1050
{
1051
  gimple stmt = last_stmt (bb);
1052
  location_t stmt_loc = gimple_location (stmt);
1053
  int i, n = gimple_asm_nlabels (stmt);
1054
 
1055
  for (i = 0; i < n; ++i)
1056
    {
1057
      tree label = TREE_VALUE (gimple_asm_label_op (stmt, i));
1058
      basic_block label_bb = label_to_block (label);
1059
      make_edge (bb, label_bb, 0);
1060
      assign_discriminator (stmt_loc, label_bb);
1061
    }
1062
}
1063
 
1064
/*---------------------------------------------------------------------------
1065
                               Flowgraph analysis
1066
---------------------------------------------------------------------------*/
1067
 
1068
/* Cleanup useless labels in basic blocks.  This is something we wish
1069
   to do early because it allows us to group case labels before creating
1070
   the edges for the CFG, and it speeds up block statement iterators in
1071
   all passes later on.
1072
   We rerun this pass after CFG is created, to get rid of the labels that
1073
   are no longer referenced.  After then we do not run it any more, since
1074
   (almost) no new labels should be created.  */
1075
 
1076
/* A map from basic block index to the leading label of that block.  */
1077
static struct label_record
1078
{
1079
  /* The label.  */
1080
  tree label;
1081
 
1082
  /* True if the label is referenced from somewhere.  */
1083
  bool used;
1084
} *label_for_bb;
1085
 
1086
/* Given LABEL return the first label in the same basic block.  */
1087
 
1088
static tree
1089
main_block_label (tree label)
1090
{
1091
  basic_block bb = label_to_block (label);
1092
  tree main_label = label_for_bb[bb->index].label;
1093
 
1094
  /* label_to_block possibly inserted undefined label into the chain.  */
1095
  if (!main_label)
1096
    {
1097
      label_for_bb[bb->index].label = label;
1098
      main_label = label;
1099
    }
1100
 
1101
  label_for_bb[bb->index].used = true;
1102
  return main_label;
1103
}
1104
 
1105
/* Clean up redundant labels within the exception tree.  */
1106
 
1107
static void
1108
cleanup_dead_labels_eh (void)
1109
{
1110
  eh_landing_pad lp;
1111
  eh_region r;
1112
  tree lab;
1113
  int i;
1114
 
1115
  if (cfun->eh == NULL)
1116
    return;
1117
 
1118
  for (i = 1; VEC_iterate (eh_landing_pad, cfun->eh->lp_array, i, lp); ++i)
1119
    if (lp && lp->post_landing_pad)
1120
      {
1121
        lab = main_block_label (lp->post_landing_pad);
1122
        if (lab != lp->post_landing_pad)
1123
          {
1124
            EH_LANDING_PAD_NR (lp->post_landing_pad) = 0;
1125
            EH_LANDING_PAD_NR (lab) = lp->index;
1126
          }
1127
      }
1128
 
1129
  FOR_ALL_EH_REGION (r)
1130
    switch (r->type)
1131
      {
1132
      case ERT_CLEANUP:
1133
      case ERT_MUST_NOT_THROW:
1134
        break;
1135
 
1136
      case ERT_TRY:
1137
        {
1138
          eh_catch c;
1139
          for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
1140
            {
1141
              lab = c->label;
1142
              if (lab)
1143
                c->label = main_block_label (lab);
1144
            }
1145
        }
1146
        break;
1147
 
1148
      case ERT_ALLOWED_EXCEPTIONS:
1149
        lab = r->u.allowed.label;
1150
        if (lab)
1151
          r->u.allowed.label = main_block_label (lab);
1152
        break;
1153
      }
1154
}
1155
 
1156
 
1157
/* Cleanup redundant labels.  This is a three-step process:
1158
     1) Find the leading label for each block.
1159
     2) Redirect all references to labels to the leading labels.
1160
     3) Cleanup all useless labels.  */
1161
 
1162
void
1163
cleanup_dead_labels (void)
1164
{
1165
  basic_block bb;
1166
  label_for_bb = XCNEWVEC (struct label_record, last_basic_block);
1167
 
1168
  /* Find a suitable label for each block.  We use the first user-defined
1169
     label if there is one, or otherwise just the first label we see.  */
1170
  FOR_EACH_BB (bb)
1171
    {
1172
      gimple_stmt_iterator i;
1173
 
1174
      for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
1175
        {
1176
          tree label;
1177
          gimple stmt = gsi_stmt (i);
1178
 
1179
          if (gimple_code (stmt) != GIMPLE_LABEL)
1180
            break;
1181
 
1182
          label = gimple_label_label (stmt);
1183
 
1184
          /* If we have not yet seen a label for the current block,
1185
             remember this one and see if there are more labels.  */
1186
          if (!label_for_bb[bb->index].label)
1187
            {
1188
              label_for_bb[bb->index].label = label;
1189
              continue;
1190
            }
1191
 
1192
          /* If we did see a label for the current block already, but it
1193
             is an artificially created label, replace it if the current
1194
             label is a user defined label.  */
1195
          if (!DECL_ARTIFICIAL (label)
1196
              && DECL_ARTIFICIAL (label_for_bb[bb->index].label))
1197
            {
1198
              label_for_bb[bb->index].label = label;
1199
              break;
1200
            }
1201
        }
1202
    }
1203
 
1204
  /* Now redirect all jumps/branches to the selected label.
1205
     First do so for each block ending in a control statement.  */
1206
  FOR_EACH_BB (bb)
1207
    {
1208
      gimple stmt = last_stmt (bb);
1209
      tree label, new_label;
1210
 
1211
      if (!stmt)
1212
        continue;
1213
 
1214
      switch (gimple_code (stmt))
1215
        {
1216
        case GIMPLE_COND:
1217
          label = gimple_cond_true_label (stmt);
1218
          if (label)
1219
            {
1220
              new_label = main_block_label (label);
1221
              if (new_label != label)
1222
                gimple_cond_set_true_label (stmt, new_label);
1223
            }
1224
 
1225
          label = gimple_cond_false_label (stmt);
1226
          if (label)
1227
            {
1228
              new_label = main_block_label (label);
1229
              if (new_label != label)
1230
                gimple_cond_set_false_label (stmt, new_label);
1231
            }
1232
          break;
1233
 
1234
        case GIMPLE_SWITCH:
1235
          {
1236
            size_t i, n = gimple_switch_num_labels (stmt);
1237
 
1238
            /* Replace all destination labels.  */
1239
            for (i = 0; i < n; ++i)
1240
              {
1241
                tree case_label = gimple_switch_label (stmt, i);
1242
                label = CASE_LABEL (case_label);
1243
                new_label = main_block_label (label);
1244
                if (new_label != label)
1245
                  CASE_LABEL (case_label) = new_label;
1246
              }
1247
            break;
1248
          }
1249
 
1250
        case GIMPLE_ASM:
1251
          {
1252
            int i, n = gimple_asm_nlabels (stmt);
1253
 
1254
            for (i = 0; i < n; ++i)
1255
              {
1256
                tree cons = gimple_asm_label_op (stmt, i);
1257
                tree label = main_block_label (TREE_VALUE (cons));
1258
                TREE_VALUE (cons) = label;
1259
              }
1260
            break;
1261
          }
1262
 
1263
        /* We have to handle gotos until they're removed, and we don't
1264
           remove them until after we've created the CFG edges.  */
1265
        case GIMPLE_GOTO:
1266
          if (!computed_goto_p (stmt))
1267
            {
1268
              label = gimple_goto_dest (stmt);
1269
              new_label = main_block_label (label);
1270
              if (new_label != label)
1271
                gimple_goto_set_dest (stmt, new_label);
1272
            }
1273
          break;
1274
 
1275
        case GIMPLE_TRANSACTION:
1276
          {
1277
            tree label = gimple_transaction_label (stmt);
1278
            if (label)
1279
              {
1280
                tree new_label = main_block_label (label);
1281
                if (new_label != label)
1282
                  gimple_transaction_set_label (stmt, new_label);
1283
              }
1284
          }
1285
          break;
1286
 
1287
        default:
1288
          break;
1289
      }
1290
    }
1291
 
1292
  /* Do the same for the exception region tree labels.  */
1293
  cleanup_dead_labels_eh ();
1294
 
1295
  /* Finally, purge dead labels.  All user-defined labels and labels that
1296
     can be the target of non-local gotos and labels which have their
1297
     address taken are preserved.  */
1298
  FOR_EACH_BB (bb)
1299
    {
1300
      gimple_stmt_iterator i;
1301
      tree label_for_this_bb = label_for_bb[bb->index].label;
1302
 
1303
      if (!label_for_this_bb)
1304
        continue;
1305
 
1306
      /* If the main label of the block is unused, we may still remove it.  */
1307
      if (!label_for_bb[bb->index].used)
1308
        label_for_this_bb = NULL;
1309
 
1310
      for (i = gsi_start_bb (bb); !gsi_end_p (i); )
1311
        {
1312
          tree label;
1313
          gimple stmt = gsi_stmt (i);
1314
 
1315
          if (gimple_code (stmt) != GIMPLE_LABEL)
1316
            break;
1317
 
1318
          label = gimple_label_label (stmt);
1319
 
1320
          if (label == label_for_this_bb
1321
              || !DECL_ARTIFICIAL (label)
1322
              || DECL_NONLOCAL (label)
1323
              || FORCED_LABEL (label))
1324
            gsi_next (&i);
1325
          else
1326
            gsi_remove (&i, true);
1327
        }
1328
    }
1329
 
1330
  free (label_for_bb);
1331
}
1332
 
1333
/* Scan the sorted vector of cases in STMT (a GIMPLE_SWITCH) and combine
1334
   the ones jumping to the same label.
1335
   Eg. three separate entries 1: 2: 3: become one entry 1..3:  */
1336
 
1337
static void
1338
group_case_labels_stmt (gimple stmt)
1339
{
1340
  int old_size = gimple_switch_num_labels (stmt);
1341
  int i, j, new_size = old_size;
1342
  tree default_case = NULL_TREE;
1343
  tree default_label = NULL_TREE;
1344
  bool has_default;
1345
 
1346
  /* The default label is always the first case in a switch
1347
     statement after gimplification if it was not optimized
1348
     away */
1349
  if (!CASE_LOW (gimple_switch_default_label (stmt))
1350
      && !CASE_HIGH (gimple_switch_default_label (stmt)))
1351
    {
1352
      default_case = gimple_switch_default_label (stmt);
1353
      default_label = CASE_LABEL (default_case);
1354
      has_default = true;
1355
    }
1356
  else
1357
    has_default = false;
1358
 
1359
  /* Look for possible opportunities to merge cases.  */
1360
  if (has_default)
1361
    i = 1;
1362
  else
1363
    i = 0;
1364
  while (i < old_size)
1365
    {
1366
      tree base_case, base_label, base_high;
1367
      base_case = gimple_switch_label (stmt, i);
1368
 
1369
      gcc_assert (base_case);
1370
      base_label = CASE_LABEL (base_case);
1371
 
1372
      /* Discard cases that have the same destination as the
1373
         default case.  */
1374
      if (base_label == default_label)
1375
        {
1376
          gimple_switch_set_label (stmt, i, NULL_TREE);
1377
          i++;
1378
          new_size--;
1379
          continue;
1380
        }
1381
 
1382
      base_high = CASE_HIGH (base_case)
1383
          ? CASE_HIGH (base_case)
1384
          : CASE_LOW (base_case);
1385
      i++;
1386
 
1387
      /* Try to merge case labels.  Break out when we reach the end
1388
         of the label vector or when we cannot merge the next case
1389
         label with the current one.  */
1390
      while (i < old_size)
1391
        {
1392
          tree merge_case = gimple_switch_label (stmt, i);
1393
          tree merge_label = CASE_LABEL (merge_case);
1394
          double_int bhp1 = double_int_add (tree_to_double_int (base_high),
1395
                                            double_int_one);
1396
 
1397
          /* Merge the cases if they jump to the same place,
1398
             and their ranges are consecutive.  */
1399
          if (merge_label == base_label
1400
              && double_int_equal_p (tree_to_double_int (CASE_LOW (merge_case)),
1401
                                     bhp1))
1402
            {
1403
              base_high = CASE_HIGH (merge_case) ?
1404
                  CASE_HIGH (merge_case) : CASE_LOW (merge_case);
1405
              CASE_HIGH (base_case) = base_high;
1406
              gimple_switch_set_label (stmt, i, NULL_TREE);
1407
              new_size--;
1408
              i++;
1409
            }
1410
          else
1411
            break;
1412
        }
1413
    }
1414
 
1415
  /* Compress the case labels in the label vector, and adjust the
1416
     length of the vector.  */
1417
  for (i = 0, j = 0; i < new_size; i++)
1418
    {
1419
      while (! gimple_switch_label (stmt, j))
1420
        j++;
1421
      gimple_switch_set_label (stmt, i,
1422
                               gimple_switch_label (stmt, j++));
1423
    }
1424
 
1425
  gcc_assert (new_size <= old_size);
1426
  gimple_switch_set_num_labels (stmt, new_size);
1427
}
1428
 
1429
/* Look for blocks ending in a multiway branch (a GIMPLE_SWITCH),
1430
   and scan the sorted vector of cases.  Combine the ones jumping to the
1431
   same label.  */
1432
 
1433
void
1434
group_case_labels (void)
1435
{
1436
  basic_block bb;
1437
 
1438
  FOR_EACH_BB (bb)
1439
    {
1440
      gimple stmt = last_stmt (bb);
1441
      if (stmt && gimple_code (stmt) == GIMPLE_SWITCH)
1442
        group_case_labels_stmt (stmt);
1443
    }
1444
}
1445
 
1446
/* Checks whether we can merge block B into block A.  */
1447
 
1448
static bool
1449
gimple_can_merge_blocks_p (basic_block a, basic_block b)
1450
{
1451
  gimple stmt;
1452
  gimple_stmt_iterator gsi;
1453
  gimple_seq phis;
1454
 
1455
  if (!single_succ_p (a))
1456
    return false;
1457
 
1458
  if (single_succ_edge (a)->flags & (EDGE_ABNORMAL | EDGE_EH | EDGE_PRESERVE))
1459
    return false;
1460
 
1461
  if (single_succ (a) != b)
1462
    return false;
1463
 
1464
  if (!single_pred_p (b))
1465
    return false;
1466
 
1467
  if (b == EXIT_BLOCK_PTR)
1468
    return false;
1469
 
1470
  /* If A ends by a statement causing exceptions or something similar, we
1471
     cannot merge the blocks.  */
1472
  stmt = last_stmt (a);
1473
  if (stmt && stmt_ends_bb_p (stmt))
1474
    return false;
1475
 
1476
  /* Do not allow a block with only a non-local label to be merged.  */
1477
  if (stmt
1478
      && gimple_code (stmt) == GIMPLE_LABEL
1479
      && DECL_NONLOCAL (gimple_label_label (stmt)))
1480
    return false;
1481
 
1482
  /* Examine the labels at the beginning of B.  */
1483
  for (gsi = gsi_start_bb (b); !gsi_end_p (gsi); gsi_next (&gsi))
1484
    {
1485
      tree lab;
1486
      stmt = gsi_stmt (gsi);
1487
      if (gimple_code (stmt) != GIMPLE_LABEL)
1488
        break;
1489
      lab = gimple_label_label (stmt);
1490
 
1491
      /* Do not remove user forced labels or for -O0 any user labels.  */
1492
      if (!DECL_ARTIFICIAL (lab) && (!optimize || FORCED_LABEL (lab)))
1493
        return false;
1494
    }
1495
 
1496
  /* Protect the loop latches.  */
1497
  if (current_loops && b->loop_father->latch == b)
1498
    return false;
1499
 
1500
  /* It must be possible to eliminate all phi nodes in B.  If ssa form
1501
     is not up-to-date and a name-mapping is registered, we cannot eliminate
1502
     any phis.  Symbols marked for renaming are never a problem though.  */
1503
  phis = phi_nodes (b);
1504
  if (!gimple_seq_empty_p (phis)
1505
      && name_mappings_registered_p ())
1506
    return false;
1507
 
1508
  /* When not optimizing, don't merge if we'd lose goto_locus.  */
1509
  if (!optimize
1510
      && single_succ_edge (a)->goto_locus != UNKNOWN_LOCATION)
1511
    {
1512
      location_t goto_locus = single_succ_edge (a)->goto_locus;
1513
      gimple_stmt_iterator prev, next;
1514
      prev = gsi_last_nondebug_bb (a);
1515
      next = gsi_after_labels (b);
1516
      if (!gsi_end_p (next) && is_gimple_debug (gsi_stmt (next)))
1517
        gsi_next_nondebug (&next);
1518
      if ((gsi_end_p (prev)
1519
           || gimple_location (gsi_stmt (prev)) != goto_locus)
1520
          && (gsi_end_p (next)
1521
              || gimple_location (gsi_stmt (next)) != goto_locus))
1522
        return false;
1523
    }
1524
 
1525
  return true;
1526
}
1527
 
1528
/* Return true if the var whose chain of uses starts at PTR has no
1529
   nondebug uses.  */
1530
bool
1531
has_zero_uses_1 (const ssa_use_operand_t *head)
1532
{
1533
  const ssa_use_operand_t *ptr;
1534
 
1535
  for (ptr = head->next; ptr != head; ptr = ptr->next)
1536
    if (!is_gimple_debug (USE_STMT (ptr)))
1537
      return false;
1538
 
1539
  return true;
1540
}
1541
 
1542
/* Return true if the var whose chain of uses starts at PTR has a
1543
   single nondebug use.  Set USE_P and STMT to that single nondebug
1544
   use, if so, or to NULL otherwise.  */
1545
bool
1546
single_imm_use_1 (const ssa_use_operand_t *head,
1547
                  use_operand_p *use_p, gimple *stmt)
1548
{
1549
  ssa_use_operand_t *ptr, *single_use = 0;
1550
 
1551
  for (ptr = head->next; ptr != head; ptr = ptr->next)
1552
    if (!is_gimple_debug (USE_STMT (ptr)))
1553
      {
1554
        if (single_use)
1555
          {
1556
            single_use = NULL;
1557
            break;
1558
          }
1559
        single_use = ptr;
1560
      }
1561
 
1562
  if (use_p)
1563
    *use_p = single_use;
1564
 
1565
  if (stmt)
1566
    *stmt = single_use ? single_use->loc.stmt : NULL;
1567
 
1568
  return !!single_use;
1569
}
1570
 
1571
/* Replaces all uses of NAME by VAL.  */
1572
 
1573
void
1574
replace_uses_by (tree name, tree val)
1575
{
1576
  imm_use_iterator imm_iter;
1577
  use_operand_p use;
1578
  gimple stmt;
1579
  edge e;
1580
 
1581
  FOR_EACH_IMM_USE_STMT (stmt, imm_iter, name)
1582
    {
1583
      FOR_EACH_IMM_USE_ON_STMT (use, imm_iter)
1584
        {
1585
          replace_exp (use, val);
1586
 
1587
          if (gimple_code (stmt) == GIMPLE_PHI)
1588
            {
1589
              e = gimple_phi_arg_edge (stmt, PHI_ARG_INDEX_FROM_USE (use));
1590
              if (e->flags & EDGE_ABNORMAL)
1591
                {
1592
                  /* This can only occur for virtual operands, since
1593
                     for the real ones SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name))
1594
                     would prevent replacement.  */
1595
                  gcc_checking_assert (!is_gimple_reg (name));
1596
                  SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val) = 1;
1597
                }
1598
            }
1599
        }
1600
 
1601
      if (gimple_code (stmt) != GIMPLE_PHI)
1602
        {
1603
          gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
1604
          gimple orig_stmt = stmt;
1605
          size_t i;
1606
 
1607
          /* Mark the block if we changed the last stmt in it.  */
1608
          if (cfgcleanup_altered_bbs
1609
              && stmt_ends_bb_p (stmt))
1610
            bitmap_set_bit (cfgcleanup_altered_bbs, gimple_bb (stmt)->index);
1611
 
1612
          /* FIXME.  It shouldn't be required to keep TREE_CONSTANT
1613
             on ADDR_EXPRs up-to-date on GIMPLE.  Propagation will
1614
             only change sth from non-invariant to invariant, and only
1615
             when propagating constants.  */
1616
          if (is_gimple_min_invariant (val))
1617
            for (i = 0; i < gimple_num_ops (stmt); i++)
1618
              {
1619
                tree op = gimple_op (stmt, i);
1620
                /* Operands may be empty here.  For example, the labels
1621
                   of a GIMPLE_COND are nulled out following the creation
1622
                   of the corresponding CFG edges.  */
1623
                if (op && TREE_CODE (op) == ADDR_EXPR)
1624
                  recompute_tree_invariant_for_addr_expr (op);
1625
              }
1626
 
1627
          if (fold_stmt (&gsi))
1628
            stmt = gsi_stmt (gsi);
1629
 
1630
          if (maybe_clean_or_replace_eh_stmt (orig_stmt, stmt))
1631
            gimple_purge_dead_eh_edges (gimple_bb (stmt));
1632
 
1633
          update_stmt (stmt);
1634
        }
1635
    }
1636
 
1637
  gcc_checking_assert (has_zero_uses (name));
1638
 
1639
  /* Also update the trees stored in loop structures.  */
1640
  if (current_loops)
1641
    {
1642
      struct loop *loop;
1643
      loop_iterator li;
1644
 
1645
      FOR_EACH_LOOP (li, loop, 0)
1646
        {
1647
          substitute_in_loop_info (loop, name, val);
1648
        }
1649
    }
1650
}
1651
 
1652
/* Merge block B into block A.  */
1653
 
1654
static void
1655
gimple_merge_blocks (basic_block a, basic_block b)
1656
{
1657
  gimple_stmt_iterator last, gsi, psi;
1658
  gimple_seq phis = phi_nodes (b);
1659
 
1660
  if (dump_file)
1661
    fprintf (dump_file, "Merging blocks %d and %d\n", a->index, b->index);
1662
 
1663
  /* Remove all single-valued PHI nodes from block B of the form
1664
     V_i = PHI <V_j> by propagating V_j to all the uses of V_i.  */
1665
  gsi = gsi_last_bb (a);
1666
  for (psi = gsi_start (phis); !gsi_end_p (psi); )
1667
    {
1668
      gimple phi = gsi_stmt (psi);
1669
      tree def = gimple_phi_result (phi), use = gimple_phi_arg_def (phi, 0);
1670
      gimple copy;
1671
      bool may_replace_uses = !is_gimple_reg (def)
1672
                              || may_propagate_copy (def, use);
1673
 
1674
      /* In case we maintain loop closed ssa form, do not propagate arguments
1675
         of loop exit phi nodes.  */
1676
      if (current_loops
1677
          && loops_state_satisfies_p (LOOP_CLOSED_SSA)
1678
          && is_gimple_reg (def)
1679
          && TREE_CODE (use) == SSA_NAME
1680
          && a->loop_father != b->loop_father)
1681
        may_replace_uses = false;
1682
 
1683
      if (!may_replace_uses)
1684
        {
1685
          gcc_assert (is_gimple_reg (def));
1686
 
1687
          /* Note that just emitting the copies is fine -- there is no problem
1688
             with ordering of phi nodes.  This is because A is the single
1689
             predecessor of B, therefore results of the phi nodes cannot
1690
             appear as arguments of the phi nodes.  */
1691
          copy = gimple_build_assign (def, use);
1692
          gsi_insert_after (&gsi, copy, GSI_NEW_STMT);
1693
          remove_phi_node (&psi, false);
1694
        }
1695
      else
1696
        {
1697
          /* If we deal with a PHI for virtual operands, we can simply
1698
             propagate these without fussing with folding or updating
1699
             the stmt.  */
1700
          if (!is_gimple_reg (def))
1701
            {
1702
              imm_use_iterator iter;
1703
              use_operand_p use_p;
1704
              gimple stmt;
1705
 
1706
              FOR_EACH_IMM_USE_STMT (stmt, iter, def)
1707
                FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
1708
                  SET_USE (use_p, use);
1709
 
1710
              if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def))
1711
                SSA_NAME_OCCURS_IN_ABNORMAL_PHI (use) = 1;
1712
            }
1713
          else
1714
            replace_uses_by (def, use);
1715
 
1716
          remove_phi_node (&psi, true);
1717
        }
1718
    }
1719
 
1720
  /* Ensure that B follows A.  */
1721
  move_block_after (b, a);
1722
 
1723
  gcc_assert (single_succ_edge (a)->flags & EDGE_FALLTHRU);
1724
  gcc_assert (!last_stmt (a) || !stmt_ends_bb_p (last_stmt (a)));
1725
 
1726
  /* Remove labels from B and set gimple_bb to A for other statements.  */
1727
  for (gsi = gsi_start_bb (b); !gsi_end_p (gsi);)
1728
    {
1729
      gimple stmt = gsi_stmt (gsi);
1730
      if (gimple_code (stmt) == GIMPLE_LABEL)
1731
        {
1732
          tree label = gimple_label_label (stmt);
1733
          int lp_nr;
1734
 
1735
          gsi_remove (&gsi, false);
1736
 
1737
          /* Now that we can thread computed gotos, we might have
1738
             a situation where we have a forced label in block B
1739
             However, the label at the start of block B might still be
1740
             used in other ways (think about the runtime checking for
1741
             Fortran assigned gotos).  So we can not just delete the
1742
             label.  Instead we move the label to the start of block A.  */
1743
          if (FORCED_LABEL (label))
1744
            {
1745
              gimple_stmt_iterator dest_gsi = gsi_start_bb (a);
1746
              gsi_insert_before (&dest_gsi, stmt, GSI_NEW_STMT);
1747
            }
1748
          /* Other user labels keep around in a form of a debug stmt.  */
1749
          else if (!DECL_ARTIFICIAL (label) && MAY_HAVE_DEBUG_STMTS)
1750
            {
1751
              gimple dbg = gimple_build_debug_bind (label,
1752
                                                    integer_zero_node,
1753
                                                    stmt);
1754
              gimple_debug_bind_reset_value (dbg);
1755
              gsi_insert_before (&gsi, dbg, GSI_SAME_STMT);
1756
            }
1757
 
1758
          lp_nr = EH_LANDING_PAD_NR (label);
1759
          if (lp_nr)
1760
            {
1761
              eh_landing_pad lp = get_eh_landing_pad_from_number (lp_nr);
1762
              lp->post_landing_pad = NULL;
1763
            }
1764
        }
1765
      else
1766
        {
1767
          gimple_set_bb (stmt, a);
1768
          gsi_next (&gsi);
1769
        }
1770
    }
1771
 
1772
  /* Merge the sequences.  */
1773
  last = gsi_last_bb (a);
1774
  gsi_insert_seq_after (&last, bb_seq (b), GSI_NEW_STMT);
1775
  set_bb_seq (b, NULL);
1776
 
1777
  if (cfgcleanup_altered_bbs)
1778
    bitmap_set_bit (cfgcleanup_altered_bbs, a->index);
1779
}
1780
 
1781
 
1782
/* Return the one of two successors of BB that is not reachable by a
1783
   complex edge, if there is one.  Else, return BB.  We use
1784
   this in optimizations that use post-dominators for their heuristics,
1785
   to catch the cases in C++ where function calls are involved.  */
1786
 
1787
basic_block
1788
single_noncomplex_succ (basic_block bb)
1789
{
1790
  edge e0, e1;
1791
  if (EDGE_COUNT (bb->succs) != 2)
1792
    return bb;
1793
 
1794
  e0 = EDGE_SUCC (bb, 0);
1795
  e1 = EDGE_SUCC (bb, 1);
1796
  if (e0->flags & EDGE_COMPLEX)
1797
    return e1->dest;
1798
  if (e1->flags & EDGE_COMPLEX)
1799
    return e0->dest;
1800
 
1801
  return bb;
1802
}
1803
 
1804
/* T is CALL_EXPR.  Set current_function_calls_* flags.  */
1805
 
1806
void
1807
notice_special_calls (gimple call)
1808
{
1809
  int flags = gimple_call_flags (call);
1810
 
1811
  if (flags & ECF_MAY_BE_ALLOCA)
1812
    cfun->calls_alloca = true;
1813
  if (flags & ECF_RETURNS_TWICE)
1814
    cfun->calls_setjmp = true;
1815
}
1816
 
1817
 
1818
/* Clear flags set by notice_special_calls.  Used by dead code removal
1819
   to update the flags.  */
1820
 
1821
void
1822
clear_special_calls (void)
1823
{
1824
  cfun->calls_alloca = false;
1825
  cfun->calls_setjmp = false;
1826
}
1827
 
1828
/* Remove PHI nodes associated with basic block BB and all edges out of BB.  */
1829
 
1830
static void
1831
remove_phi_nodes_and_edges_for_unreachable_block (basic_block bb)
1832
{
1833
  /* Since this block is no longer reachable, we can just delete all
1834
     of its PHI nodes.  */
1835
  remove_phi_nodes (bb);
1836
 
1837
  /* Remove edges to BB's successors.  */
1838
  while (EDGE_COUNT (bb->succs) > 0)
1839
    remove_edge (EDGE_SUCC (bb, 0));
1840
}
1841
 
1842
 
1843
/* Remove statements of basic block BB.  */
1844
 
1845
static void
1846
remove_bb (basic_block bb)
1847
{
1848
  gimple_stmt_iterator i;
1849
 
1850
  if (dump_file)
1851
    {
1852
      fprintf (dump_file, "Removing basic block %d\n", bb->index);
1853
      if (dump_flags & TDF_DETAILS)
1854
        {
1855
          dump_bb (bb, dump_file, 0);
1856
          fprintf (dump_file, "\n");
1857
        }
1858
    }
1859
 
1860
  if (current_loops)
1861
    {
1862
      struct loop *loop = bb->loop_father;
1863
 
1864
      /* If a loop gets removed, clean up the information associated
1865
         with it.  */
1866
      if (loop->latch == bb
1867
          || loop->header == bb)
1868
        free_numbers_of_iterations_estimates_loop (loop);
1869
    }
1870
 
1871
  /* Remove all the instructions in the block.  */
1872
  if (bb_seq (bb) != NULL)
1873
    {
1874
      /* Walk backwards so as to get a chance to substitute all
1875
         released DEFs into debug stmts.  See
1876
         eliminate_unnecessary_stmts() in tree-ssa-dce.c for more
1877
         details.  */
1878
      for (i = gsi_last_bb (bb); !gsi_end_p (i);)
1879
        {
1880
          gimple stmt = gsi_stmt (i);
1881
          if (gimple_code (stmt) == GIMPLE_LABEL
1882
              && (FORCED_LABEL (gimple_label_label (stmt))
1883
                  || DECL_NONLOCAL (gimple_label_label (stmt))))
1884
            {
1885
              basic_block new_bb;
1886
              gimple_stmt_iterator new_gsi;
1887
 
1888
              /* A non-reachable non-local label may still be referenced.
1889
                 But it no longer needs to carry the extra semantics of
1890
                 non-locality.  */
1891
              if (DECL_NONLOCAL (gimple_label_label (stmt)))
1892
                {
1893
                  DECL_NONLOCAL (gimple_label_label (stmt)) = 0;
1894
                  FORCED_LABEL (gimple_label_label (stmt)) = 1;
1895
                }
1896
 
1897
              new_bb = bb->prev_bb;
1898
              new_gsi = gsi_start_bb (new_bb);
1899
              gsi_remove (&i, false);
1900
              gsi_insert_before (&new_gsi, stmt, GSI_NEW_STMT);
1901
            }
1902
          else
1903
            {
1904
              /* Release SSA definitions if we are in SSA.  Note that we
1905
                 may be called when not in SSA.  For example,
1906
                 final_cleanup calls this function via
1907
                 cleanup_tree_cfg.  */
1908
              if (gimple_in_ssa_p (cfun))
1909
                release_defs (stmt);
1910
 
1911
              gsi_remove (&i, true);
1912
            }
1913
 
1914
          if (gsi_end_p (i))
1915
            i = gsi_last_bb (bb);
1916
          else
1917
            gsi_prev (&i);
1918
        }
1919
    }
1920
 
1921
  remove_phi_nodes_and_edges_for_unreachable_block (bb);
1922
  bb->il.gimple = NULL;
1923
}
1924
 
1925
 
1926
/* Given a basic block BB ending with COND_EXPR or SWITCH_EXPR, and a
1927
   predicate VAL, return the edge that will be taken out of the block.
1928
   If VAL does not match a unique edge, NULL is returned.  */
1929
 
1930
edge
1931
find_taken_edge (basic_block bb, tree val)
1932
{
1933
  gimple stmt;
1934
 
1935
  stmt = last_stmt (bb);
1936
 
1937
  gcc_assert (stmt);
1938
  gcc_assert (is_ctrl_stmt (stmt));
1939
 
1940
  if (val == NULL)
1941
    return NULL;
1942
 
1943
  if (!is_gimple_min_invariant (val))
1944
    return NULL;
1945
 
1946
  if (gimple_code (stmt) == GIMPLE_COND)
1947
    return find_taken_edge_cond_expr (bb, val);
1948
 
1949
  if (gimple_code (stmt) == GIMPLE_SWITCH)
1950
    return find_taken_edge_switch_expr (bb, val);
1951
 
1952
  if (computed_goto_p (stmt))
1953
    {
1954
      /* Only optimize if the argument is a label, if the argument is
1955
         not a label then we can not construct a proper CFG.
1956
 
1957
         It may be the case that we only need to allow the LABEL_REF to
1958
         appear inside an ADDR_EXPR, but we also allow the LABEL_REF to
1959
         appear inside a LABEL_EXPR just to be safe.  */
1960
      if ((TREE_CODE (val) == ADDR_EXPR || TREE_CODE (val) == LABEL_EXPR)
1961
          && TREE_CODE (TREE_OPERAND (val, 0)) == LABEL_DECL)
1962
        return find_taken_edge_computed_goto (bb, TREE_OPERAND (val, 0));
1963
      return NULL;
1964
    }
1965
 
1966
  gcc_unreachable ();
1967
}
1968
 
1969
/* Given a constant value VAL and the entry block BB to a GOTO_EXPR
1970
   statement, determine which of the outgoing edges will be taken out of the
1971
   block.  Return NULL if either edge may be taken.  */
1972
 
1973
static edge
1974
find_taken_edge_computed_goto (basic_block bb, tree val)
1975
{
1976
  basic_block dest;
1977
  edge e = NULL;
1978
 
1979
  dest = label_to_block (val);
1980
  if (dest)
1981
    {
1982
      e = find_edge (bb, dest);
1983
      gcc_assert (e != NULL);
1984
    }
1985
 
1986
  return e;
1987
}
1988
 
1989
/* Given a constant value VAL and the entry block BB to a COND_EXPR
1990
   statement, determine which of the two edges will be taken out of the
1991
   block.  Return NULL if either edge may be taken.  */
1992
 
1993
static edge
1994
find_taken_edge_cond_expr (basic_block bb, tree val)
1995
{
1996
  edge true_edge, false_edge;
1997
 
1998
  extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
1999
 
2000
  gcc_assert (TREE_CODE (val) == INTEGER_CST);
2001
  return (integer_zerop (val) ? false_edge : true_edge);
2002
}
2003
 
2004
/* Given an INTEGER_CST VAL and the entry block BB to a SWITCH_EXPR
2005
   statement, determine which edge will be taken out of the block.  Return
2006
   NULL if any edge may be taken.  */
2007
 
2008
static edge
2009
find_taken_edge_switch_expr (basic_block bb, tree val)
2010
{
2011
  basic_block dest_bb;
2012
  edge e;
2013
  gimple switch_stmt;
2014
  tree taken_case;
2015
 
2016
  switch_stmt = last_stmt (bb);
2017
  taken_case = find_case_label_for_value (switch_stmt, val);
2018
  dest_bb = label_to_block (CASE_LABEL (taken_case));
2019
 
2020
  e = find_edge (bb, dest_bb);
2021
  gcc_assert (e);
2022
  return e;
2023
}
2024
 
2025
 
2026
/* Return the CASE_LABEL_EXPR that SWITCH_STMT will take for VAL.
2027
   We can make optimal use here of the fact that the case labels are
2028
   sorted: We can do a binary search for a case matching VAL.  */
2029
 
2030
static tree
2031
find_case_label_for_value (gimple switch_stmt, tree val)
2032
{
2033
  size_t low, high, n = gimple_switch_num_labels (switch_stmt);
2034
  tree default_case = gimple_switch_default_label (switch_stmt);
2035
 
2036
  for (low = 0, high = n; high - low > 1; )
2037
    {
2038
      size_t i = (high + low) / 2;
2039
      tree t = gimple_switch_label (switch_stmt, i);
2040
      int cmp;
2041
 
2042
      /* Cache the result of comparing CASE_LOW and val.  */
2043
      cmp = tree_int_cst_compare (CASE_LOW (t), val);
2044
 
2045
      if (cmp > 0)
2046
        high = i;
2047
      else
2048
        low = i;
2049
 
2050
      if (CASE_HIGH (t) == NULL)
2051
        {
2052
          /* A singe-valued case label.  */
2053
          if (cmp == 0)
2054
            return t;
2055
        }
2056
      else
2057
        {
2058
          /* A case range.  We can only handle integer ranges.  */
2059
          if (cmp <= 0 && tree_int_cst_compare (CASE_HIGH (t), val) >= 0)
2060
            return t;
2061
        }
2062
    }
2063
 
2064
  return default_case;
2065
}
2066
 
2067
 
2068
/* Dump a basic block on stderr.  */
2069
 
2070
void
2071
gimple_debug_bb (basic_block bb)
2072
{
2073
  gimple_dump_bb (bb, stderr, 0, TDF_VOPS|TDF_MEMSYMS);
2074
}
2075
 
2076
 
2077
/* Dump basic block with index N on stderr.  */
2078
 
2079
basic_block
2080
gimple_debug_bb_n (int n)
2081
{
2082
  gimple_debug_bb (BASIC_BLOCK (n));
2083
  return BASIC_BLOCK (n);
2084
}
2085
 
2086
 
2087
/* Dump the CFG on stderr.
2088
 
2089
   FLAGS are the same used by the tree dumping functions
2090
   (see TDF_* in tree-pass.h).  */
2091
 
2092
void
2093
gimple_debug_cfg (int flags)
2094
{
2095
  gimple_dump_cfg (stderr, flags);
2096
}
2097
 
2098
 
2099
/* Dump the program showing basic block boundaries on the given FILE.
2100
 
2101
   FLAGS are the same used by the tree dumping functions (see TDF_* in
2102
   tree.h).  */
2103
 
2104
void
2105
gimple_dump_cfg (FILE *file, int flags)
2106
{
2107
  if (flags & TDF_DETAILS)
2108
    {
2109
      dump_function_header (file, current_function_decl, flags);
2110
      fprintf (file, ";; \n%d basic blocks, %d edges, last basic block %d.\n\n",
2111
               n_basic_blocks, n_edges, last_basic_block);
2112
 
2113
      brief_dump_cfg (file);
2114
      fprintf (file, "\n");
2115
    }
2116
 
2117
  if (flags & TDF_STATS)
2118
    dump_cfg_stats (file);
2119
 
2120
  dump_function_to_file (current_function_decl, file, flags | TDF_BLOCKS);
2121
}
2122
 
2123
 
2124
/* Dump CFG statistics on FILE.  */
2125
 
2126
void
2127
dump_cfg_stats (FILE *file)
2128
{
2129
  static long max_num_merged_labels = 0;
2130
  unsigned long size, total = 0;
2131
  long num_edges;
2132
  basic_block bb;
2133
  const char * const fmt_str   = "%-30s%-13s%12s\n";
2134
  const char * const fmt_str_1 = "%-30s%13d%11lu%c\n";
2135
  const char * const fmt_str_2 = "%-30s%13ld%11lu%c\n";
2136
  const char * const fmt_str_3 = "%-43s%11lu%c\n";
2137
  const char *funcname
2138
    = lang_hooks.decl_printable_name (current_function_decl, 2);
2139
 
2140
 
2141
  fprintf (file, "\nCFG Statistics for %s\n\n", funcname);
2142
 
2143
  fprintf (file, "---------------------------------------------------------\n");
2144
  fprintf (file, fmt_str, "", "  Number of  ", "Memory");
2145
  fprintf (file, fmt_str, "", "  instances  ", "used ");
2146
  fprintf (file, "---------------------------------------------------------\n");
2147
 
2148
  size = n_basic_blocks * sizeof (struct basic_block_def);
2149
  total += size;
2150
  fprintf (file, fmt_str_1, "Basic blocks", n_basic_blocks,
2151
           SCALE (size), LABEL (size));
2152
 
2153
  num_edges = 0;
2154
  FOR_EACH_BB (bb)
2155
    num_edges += EDGE_COUNT (bb->succs);
2156
  size = num_edges * sizeof (struct edge_def);
2157
  total += size;
2158
  fprintf (file, fmt_str_2, "Edges", num_edges, SCALE (size), LABEL (size));
2159
 
2160
  fprintf (file, "---------------------------------------------------------\n");
2161
  fprintf (file, fmt_str_3, "Total memory used by CFG data", SCALE (total),
2162
           LABEL (total));
2163
  fprintf (file, "---------------------------------------------------------\n");
2164
  fprintf (file, "\n");
2165
 
2166
  if (cfg_stats.num_merged_labels > max_num_merged_labels)
2167
    max_num_merged_labels = cfg_stats.num_merged_labels;
2168
 
2169
  fprintf (file, "Coalesced label blocks: %ld (Max so far: %ld)\n",
2170
           cfg_stats.num_merged_labels, max_num_merged_labels);
2171
 
2172
  fprintf (file, "\n");
2173
}
2174
 
2175
 
2176
/* Dump CFG statistics on stderr.  Keep extern so that it's always
2177
   linked in the final executable.  */
2178
 
2179
DEBUG_FUNCTION void
2180
debug_cfg_stats (void)
2181
{
2182
  dump_cfg_stats (stderr);
2183
}
2184
 
2185
 
2186
/* Dump the flowgraph to a .vcg FILE.  */
2187
 
2188
static void
2189
gimple_cfg2vcg (FILE *file)
2190
{
2191
  edge e;
2192
  edge_iterator ei;
2193
  basic_block bb;
2194
  const char *funcname
2195
    = lang_hooks.decl_printable_name (current_function_decl, 2);
2196
 
2197
  /* Write the file header.  */
2198
  fprintf (file, "graph: { title: \"%s\"\n", funcname);
2199
  fprintf (file, "node: { title: \"ENTRY\" label: \"ENTRY\" }\n");
2200
  fprintf (file, "node: { title: \"EXIT\" label: \"EXIT\" }\n");
2201
 
2202
  /* Write blocks and edges.  */
2203
  FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
2204
    {
2205
      fprintf (file, "edge: { sourcename: \"ENTRY\" targetname: \"%d\"",
2206
               e->dest->index);
2207
 
2208
      if (e->flags & EDGE_FAKE)
2209
        fprintf (file, " linestyle: dotted priority: 10");
2210
      else
2211
        fprintf (file, " linestyle: solid priority: 100");
2212
 
2213
      fprintf (file, " }\n");
2214
    }
2215
  fputc ('\n', file);
2216
 
2217
  FOR_EACH_BB (bb)
2218
    {
2219
      enum gimple_code head_code, end_code;
2220
      const char *head_name, *end_name;
2221
      int head_line = 0;
2222
      int end_line = 0;
2223
      gimple first = first_stmt (bb);
2224
      gimple last = last_stmt (bb);
2225
 
2226
      if (first)
2227
        {
2228
          head_code = gimple_code (first);
2229
          head_name = gimple_code_name[head_code];
2230
          head_line = get_lineno (first);
2231
        }
2232
      else
2233
        head_name = "no-statement";
2234
 
2235
      if (last)
2236
        {
2237
          end_code = gimple_code (last);
2238
          end_name = gimple_code_name[end_code];
2239
          end_line = get_lineno (last);
2240
        }
2241
      else
2242
        end_name = "no-statement";
2243
 
2244
      fprintf (file, "node: { title: \"%d\" label: \"#%d\\n%s (%d)\\n%s (%d)\"}\n",
2245
               bb->index, bb->index, head_name, head_line, end_name,
2246
               end_line);
2247
 
2248
      FOR_EACH_EDGE (e, ei, bb->succs)
2249
        {
2250
          if (e->dest == EXIT_BLOCK_PTR)
2251
            fprintf (file, "edge: { sourcename: \"%d\" targetname: \"EXIT\"", bb->index);
2252
          else
2253
            fprintf (file, "edge: { sourcename: \"%d\" targetname: \"%d\"", bb->index, e->dest->index);
2254
 
2255
          if (e->flags & EDGE_FAKE)
2256
            fprintf (file, " priority: 10 linestyle: dotted");
2257
          else
2258
            fprintf (file, " priority: 100 linestyle: solid");
2259
 
2260
          fprintf (file, " }\n");
2261
        }
2262
 
2263
      if (bb->next_bb != EXIT_BLOCK_PTR)
2264
        fputc ('\n', file);
2265
    }
2266
 
2267
  fputs ("}\n\n", file);
2268
}
2269
 
2270
 
2271
 
2272
/*---------------------------------------------------------------------------
2273
                             Miscellaneous helpers
2274
---------------------------------------------------------------------------*/
2275
 
2276
/* Return true if T represents a stmt that always transfers control.  */
2277
 
2278
bool
2279
is_ctrl_stmt (gimple t)
2280
{
2281
  switch (gimple_code (t))
2282
    {
2283
    case GIMPLE_COND:
2284
    case GIMPLE_SWITCH:
2285
    case GIMPLE_GOTO:
2286
    case GIMPLE_RETURN:
2287
    case GIMPLE_RESX:
2288
      return true;
2289
    default:
2290
      return false;
2291
    }
2292
}
2293
 
2294
 
2295
/* Return true if T is a statement that may alter the flow of control
2296
   (e.g., a call to a non-returning function).  */
2297
 
2298
bool
2299
is_ctrl_altering_stmt (gimple t)
2300
{
2301
  gcc_assert (t);
2302
 
2303
  switch (gimple_code (t))
2304
    {
2305
    case GIMPLE_CALL:
2306
      {
2307
        int flags = gimple_call_flags (t);
2308
 
2309
        /* A non-pure/const call alters flow control if the current
2310
           function has nonlocal labels.  */
2311
        if (!(flags & (ECF_CONST | ECF_PURE | ECF_LEAF))
2312
            && cfun->has_nonlocal_label)
2313
          return true;
2314
 
2315
        /* A call also alters control flow if it does not return.  */
2316
        if (flags & ECF_NORETURN)
2317
          return true;
2318
 
2319
        /* TM ending statements have backedges out of the transaction.
2320
           Return true so we split the basic block containing them.
2321
           Note that the TM_BUILTIN test is merely an optimization.  */
2322
        if ((flags & ECF_TM_BUILTIN)
2323
            && is_tm_ending_fndecl (gimple_call_fndecl (t)))
2324
          return true;
2325
 
2326
        /* BUILT_IN_RETURN call is same as return statement.  */
2327
        if (gimple_call_builtin_p (t, BUILT_IN_RETURN))
2328
          return true;
2329
      }
2330
      break;
2331
 
2332
    case GIMPLE_EH_DISPATCH:
2333
      /* EH_DISPATCH branches to the individual catch handlers at
2334
         this level of a try or allowed-exceptions region.  It can
2335
         fallthru to the next statement as well.  */
2336
      return true;
2337
 
2338
    case GIMPLE_ASM:
2339
      if (gimple_asm_nlabels (t) > 0)
2340
        return true;
2341
      break;
2342
 
2343
    CASE_GIMPLE_OMP:
2344
      /* OpenMP directives alter control flow.  */
2345
      return true;
2346
 
2347
    case GIMPLE_TRANSACTION:
2348
      /* A transaction start alters control flow.  */
2349
      return true;
2350
 
2351
    default:
2352
      break;
2353
    }
2354
 
2355
  /* If a statement can throw, it alters control flow.  */
2356
  return stmt_can_throw_internal (t);
2357
}
2358
 
2359
 
2360
/* Return true if T is a simple local goto.  */
2361
 
2362
bool
2363
simple_goto_p (gimple t)
2364
{
2365
  return (gimple_code (t) == GIMPLE_GOTO
2366
          && TREE_CODE (gimple_goto_dest (t)) == LABEL_DECL);
2367
}
2368
 
2369
 
2370
/* Return true if T can make an abnormal transfer of control flow.
2371
   Transfers of control flow associated with EH are excluded.  */
2372
 
2373
bool
2374
stmt_can_make_abnormal_goto (gimple t)
2375
{
2376
  if (computed_goto_p (t))
2377
    return true;
2378
  if (is_gimple_call (t))
2379
    return (gimple_has_side_effects (t) && cfun->has_nonlocal_label
2380
            && !(gimple_call_flags (t) & ECF_LEAF));
2381
  return false;
2382
}
2383
 
2384
 
2385
/* Return true if STMT should start a new basic block.  PREV_STMT is
2386
   the statement preceding STMT.  It is used when STMT is a label or a
2387
   case label.  Labels should only start a new basic block if their
2388
   previous statement wasn't a label.  Otherwise, sequence of labels
2389
   would generate unnecessary basic blocks that only contain a single
2390
   label.  */
2391
 
2392
static inline bool
2393
stmt_starts_bb_p (gimple stmt, gimple prev_stmt)
2394
{
2395
  if (stmt == NULL)
2396
    return false;
2397
 
2398
  /* Labels start a new basic block only if the preceding statement
2399
     wasn't a label of the same type.  This prevents the creation of
2400
     consecutive blocks that have nothing but a single label.  */
2401
  if (gimple_code (stmt) == GIMPLE_LABEL)
2402
    {
2403
      /* Nonlocal and computed GOTO targets always start a new block.  */
2404
      if (DECL_NONLOCAL (gimple_label_label (stmt))
2405
          || FORCED_LABEL (gimple_label_label (stmt)))
2406
        return true;
2407
 
2408
      if (prev_stmt && gimple_code (prev_stmt) == GIMPLE_LABEL)
2409
        {
2410
          if (DECL_NONLOCAL (gimple_label_label (prev_stmt)))
2411
            return true;
2412
 
2413
          cfg_stats.num_merged_labels++;
2414
          return false;
2415
        }
2416
      else
2417
        return true;
2418
    }
2419
 
2420
  return false;
2421
}
2422
 
2423
 
2424
/* Return true if T should end a basic block.  */
2425
 
2426
bool
2427
stmt_ends_bb_p (gimple t)
2428
{
2429
  return is_ctrl_stmt (t) || is_ctrl_altering_stmt (t);
2430
}
2431
 
2432
/* Remove block annotations and other data structures.  */
2433
 
2434
void
2435
delete_tree_cfg_annotations (void)
2436
{
2437
  label_to_block_map = NULL;
2438
}
2439
 
2440
 
2441
/* Return the first statement in basic block BB.  */
2442
 
2443
gimple
2444
first_stmt (basic_block bb)
2445
{
2446
  gimple_stmt_iterator i = gsi_start_bb (bb);
2447
  gimple stmt = NULL;
2448
 
2449
  while (!gsi_end_p (i) && is_gimple_debug ((stmt = gsi_stmt (i))))
2450
    {
2451
      gsi_next (&i);
2452
      stmt = NULL;
2453
    }
2454
  return stmt;
2455
}
2456
 
2457
/* Return the first non-label statement in basic block BB.  */
2458
 
2459
static gimple
2460
first_non_label_stmt (basic_block bb)
2461
{
2462
  gimple_stmt_iterator i = gsi_start_bb (bb);
2463
  while (!gsi_end_p (i) && gimple_code (gsi_stmt (i)) == GIMPLE_LABEL)
2464
    gsi_next (&i);
2465
  return !gsi_end_p (i) ? gsi_stmt (i) : NULL;
2466
}
2467
 
2468
/* Return the last statement in basic block BB.  */
2469
 
2470
gimple
2471
last_stmt (basic_block bb)
2472
{
2473
  gimple_stmt_iterator i = gsi_last_bb (bb);
2474
  gimple stmt = NULL;
2475
 
2476
  while (!gsi_end_p (i) && is_gimple_debug ((stmt = gsi_stmt (i))))
2477
    {
2478
      gsi_prev (&i);
2479
      stmt = NULL;
2480
    }
2481
  return stmt;
2482
}
2483
 
2484
/* Return the last statement of an otherwise empty block.  Return NULL
2485
   if the block is totally empty, or if it contains more than one
2486
   statement.  */
2487
 
2488
gimple
2489
last_and_only_stmt (basic_block bb)
2490
{
2491
  gimple_stmt_iterator i = gsi_last_nondebug_bb (bb);
2492
  gimple last, prev;
2493
 
2494
  if (gsi_end_p (i))
2495
    return NULL;
2496
 
2497
  last = gsi_stmt (i);
2498
  gsi_prev_nondebug (&i);
2499
  if (gsi_end_p (i))
2500
    return last;
2501
 
2502
  /* Empty statements should no longer appear in the instruction stream.
2503
     Everything that might have appeared before should be deleted by
2504
     remove_useless_stmts, and the optimizers should just gsi_remove
2505
     instead of smashing with build_empty_stmt.
2506
 
2507
     Thus the only thing that should appear here in a block containing
2508
     one executable statement is a label.  */
2509
  prev = gsi_stmt (i);
2510
  if (gimple_code (prev) == GIMPLE_LABEL)
2511
    return last;
2512
  else
2513
    return NULL;
2514
}
2515
 
2516
/* Reinstall those PHI arguments queued in OLD_EDGE to NEW_EDGE.  */
2517
 
2518
static void
2519
reinstall_phi_args (edge new_edge, edge old_edge)
2520
{
2521
  edge_var_map_vector v;
2522
  edge_var_map *vm;
2523
  int i;
2524
  gimple_stmt_iterator phis;
2525
 
2526
  v = redirect_edge_var_map_vector (old_edge);
2527
  if (!v)
2528
    return;
2529
 
2530
  for (i = 0, phis = gsi_start_phis (new_edge->dest);
2531
       VEC_iterate (edge_var_map, v, i, vm) && !gsi_end_p (phis);
2532
       i++, gsi_next (&phis))
2533
    {
2534
      gimple phi = gsi_stmt (phis);
2535
      tree result = redirect_edge_var_map_result (vm);
2536
      tree arg = redirect_edge_var_map_def (vm);
2537
 
2538
      gcc_assert (result == gimple_phi_result (phi));
2539
 
2540
      add_phi_arg (phi, arg, new_edge, redirect_edge_var_map_location (vm));
2541
    }
2542
 
2543
  redirect_edge_var_map_clear (old_edge);
2544
}
2545
 
2546
/* Returns the basic block after which the new basic block created
2547
   by splitting edge EDGE_IN should be placed.  Tries to keep the new block
2548
   near its "logical" location.  This is of most help to humans looking
2549
   at debugging dumps.  */
2550
 
2551
static basic_block
2552
split_edge_bb_loc (edge edge_in)
2553
{
2554
  basic_block dest = edge_in->dest;
2555
  basic_block dest_prev = dest->prev_bb;
2556
 
2557
  if (dest_prev)
2558
    {
2559
      edge e = find_edge (dest_prev, dest);
2560
      if (e && !(e->flags & EDGE_COMPLEX))
2561
        return edge_in->src;
2562
    }
2563
  return dest_prev;
2564
}
2565
 
2566
/* Split a (typically critical) edge EDGE_IN.  Return the new block.
2567
   Abort on abnormal edges.  */
2568
 
2569
static basic_block
2570
gimple_split_edge (edge edge_in)
2571
{
2572
  basic_block new_bb, after_bb, dest;
2573
  edge new_edge, e;
2574
 
2575
  /* Abnormal edges cannot be split.  */
2576
  gcc_assert (!(edge_in->flags & EDGE_ABNORMAL));
2577
 
2578
  dest = edge_in->dest;
2579
 
2580
  after_bb = split_edge_bb_loc (edge_in);
2581
 
2582
  new_bb = create_empty_bb (after_bb);
2583
  new_bb->frequency = EDGE_FREQUENCY (edge_in);
2584
  new_bb->count = edge_in->count;
2585
  new_edge = make_edge (new_bb, dest, EDGE_FALLTHRU);
2586
  new_edge->probability = REG_BR_PROB_BASE;
2587
  new_edge->count = edge_in->count;
2588
 
2589
  e = redirect_edge_and_branch (edge_in, new_bb);
2590
  gcc_assert (e == edge_in);
2591
  reinstall_phi_args (new_edge, e);
2592
 
2593
  return new_bb;
2594
}
2595
 
2596
 
2597
/* Verify properties of the address expression T with base object BASE.  */
2598
 
2599
static tree
2600
verify_address (tree t, tree base)
2601
{
2602
  bool old_constant;
2603
  bool old_side_effects;
2604
  bool new_constant;
2605
  bool new_side_effects;
2606
 
2607
  old_constant = TREE_CONSTANT (t);
2608
  old_side_effects = TREE_SIDE_EFFECTS (t);
2609
 
2610
  recompute_tree_invariant_for_addr_expr (t);
2611
  new_side_effects = TREE_SIDE_EFFECTS (t);
2612
  new_constant = TREE_CONSTANT (t);
2613
 
2614
  if (old_constant != new_constant)
2615
    {
2616
      error ("constant not recomputed when ADDR_EXPR changed");
2617
      return t;
2618
    }
2619
  if (old_side_effects != new_side_effects)
2620
    {
2621
      error ("side effects not recomputed when ADDR_EXPR changed");
2622
      return t;
2623
    }
2624
 
2625
  if (!(TREE_CODE (base) == VAR_DECL
2626
        || TREE_CODE (base) == PARM_DECL
2627
        || TREE_CODE (base) == RESULT_DECL))
2628
    return NULL_TREE;
2629
 
2630
  if (DECL_GIMPLE_REG_P (base))
2631
    {
2632
      error ("DECL_GIMPLE_REG_P set on a variable with address taken");
2633
      return base;
2634
    }
2635
 
2636
  return NULL_TREE;
2637
}
2638
 
2639
/* Callback for walk_tree, check that all elements with address taken are
2640
   properly noticed as such.  The DATA is an int* that is 1 if TP was seen
2641
   inside a PHI node.  */
2642
 
2643
static tree
2644
verify_expr (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
2645
{
2646
  tree t = *tp, x;
2647
 
2648
  if (TYPE_P (t))
2649
    *walk_subtrees = 0;
2650
 
2651
  /* Check operand N for being valid GIMPLE and give error MSG if not.  */
2652
#define CHECK_OP(N, MSG) \
2653
  do { if (!is_gimple_val (TREE_OPERAND (t, N)))                \
2654
       { error (MSG); return TREE_OPERAND (t, N); }} while (0)
2655
 
2656
  switch (TREE_CODE (t))
2657
    {
2658
    case SSA_NAME:
2659
      if (SSA_NAME_IN_FREE_LIST (t))
2660
        {
2661
          error ("SSA name in freelist but still referenced");
2662
          return *tp;
2663
        }
2664
      break;
2665
 
2666
    case INDIRECT_REF:
2667
      error ("INDIRECT_REF in gimple IL");
2668
      return t;
2669
 
2670
    case MEM_REF:
2671
      x = TREE_OPERAND (t, 0);
2672
      if (!POINTER_TYPE_P (TREE_TYPE (x))
2673
          || !is_gimple_mem_ref_addr (x))
2674
        {
2675
          error ("invalid first operand of MEM_REF");
2676
          return x;
2677
        }
2678
      if (TREE_CODE (TREE_OPERAND (t, 1)) != INTEGER_CST
2679
          || !POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t, 1))))
2680
        {
2681
          error ("invalid offset operand of MEM_REF");
2682
          return TREE_OPERAND (t, 1);
2683
        }
2684
      if (TREE_CODE (x) == ADDR_EXPR
2685
          && (x = verify_address (x, TREE_OPERAND (x, 0))))
2686
        return x;
2687
      *walk_subtrees = 0;
2688
      break;
2689
 
2690
    case ASSERT_EXPR:
2691
      x = fold (ASSERT_EXPR_COND (t));
2692
      if (x == boolean_false_node)
2693
        {
2694
          error ("ASSERT_EXPR with an always-false condition");
2695
          return *tp;
2696
        }
2697
      break;
2698
 
2699
    case MODIFY_EXPR:
2700
      error ("MODIFY_EXPR not expected while having tuples");
2701
      return *tp;
2702
 
2703
    case ADDR_EXPR:
2704
      {
2705
        tree tem;
2706
 
2707
        gcc_assert (is_gimple_address (t));
2708
 
2709
        /* Skip any references (they will be checked when we recurse down the
2710
           tree) and ensure that any variable used as a prefix is marked
2711
           addressable.  */
2712
        for (x = TREE_OPERAND (t, 0);
2713
             handled_component_p (x);
2714
             x = TREE_OPERAND (x, 0))
2715
          ;
2716
 
2717
        if ((tem = verify_address (t, x)))
2718
          return tem;
2719
 
2720
        if (!(TREE_CODE (x) == VAR_DECL
2721
              || TREE_CODE (x) == PARM_DECL
2722
              || TREE_CODE (x) == RESULT_DECL))
2723
          return NULL;
2724
 
2725
        if (!TREE_ADDRESSABLE (x))
2726
          {
2727
            error ("address taken, but ADDRESSABLE bit not set");
2728
            return x;
2729
          }
2730
 
2731
        break;
2732
      }
2733
 
2734
    case COND_EXPR:
2735
      x = COND_EXPR_COND (t);
2736
      if (!INTEGRAL_TYPE_P (TREE_TYPE (x)))
2737
        {
2738
          error ("non-integral used in condition");
2739
          return x;
2740
        }
2741
      if (!is_gimple_condexpr (x))
2742
        {
2743
          error ("invalid conditional operand");
2744
          return x;
2745
        }
2746
      break;
2747
 
2748
    case NON_LVALUE_EXPR:
2749
    case TRUTH_NOT_EXPR:
2750
      gcc_unreachable ();
2751
 
2752
    CASE_CONVERT:
2753
    case FIX_TRUNC_EXPR:
2754
    case FLOAT_EXPR:
2755
    case NEGATE_EXPR:
2756
    case ABS_EXPR:
2757
    case BIT_NOT_EXPR:
2758
      CHECK_OP (0, "invalid operand to unary operator");
2759
      break;
2760
 
2761
    case REALPART_EXPR:
2762
    case IMAGPART_EXPR:
2763
    case COMPONENT_REF:
2764
    case ARRAY_REF:
2765
    case ARRAY_RANGE_REF:
2766
    case BIT_FIELD_REF:
2767
    case VIEW_CONVERT_EXPR:
2768
      /* We have a nest of references.  Verify that each of the operands
2769
         that determine where to reference is either a constant or a variable,
2770
         verify that the base is valid, and then show we've already checked
2771
         the subtrees.  */
2772
      while (handled_component_p (t))
2773
        {
2774
          if (TREE_CODE (t) == COMPONENT_REF && TREE_OPERAND (t, 2))
2775
            CHECK_OP (2, "invalid COMPONENT_REF offset operator");
2776
          else if (TREE_CODE (t) == ARRAY_REF
2777
                   || TREE_CODE (t) == ARRAY_RANGE_REF)
2778
            {
2779
              CHECK_OP (1, "invalid array index");
2780
              if (TREE_OPERAND (t, 2))
2781
                CHECK_OP (2, "invalid array lower bound");
2782
              if (TREE_OPERAND (t, 3))
2783
                CHECK_OP (3, "invalid array stride");
2784
            }
2785
          else if (TREE_CODE (t) == BIT_FIELD_REF)
2786
            {
2787
              if (!host_integerp (TREE_OPERAND (t, 1), 1)
2788
                  || !host_integerp (TREE_OPERAND (t, 2), 1))
2789
                {
2790
                  error ("invalid position or size operand to BIT_FIELD_REF");
2791
                  return t;
2792
                }
2793
              else if (INTEGRAL_TYPE_P (TREE_TYPE (t))
2794
                       && (TYPE_PRECISION (TREE_TYPE (t))
2795
                           != TREE_INT_CST_LOW (TREE_OPERAND (t, 1))))
2796
                {
2797
                  error ("integral result type precision does not match "
2798
                         "field size of BIT_FIELD_REF");
2799
                  return t;
2800
                }
2801
              if (!INTEGRAL_TYPE_P (TREE_TYPE (t))
2802
                  && (GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (t)))
2803
                      != TREE_INT_CST_LOW (TREE_OPERAND (t, 1))))
2804
                {
2805
                  error ("mode precision of non-integral result does not "
2806
                         "match field size of BIT_FIELD_REF");
2807
                  return t;
2808
                }
2809
            }
2810
 
2811
          t = TREE_OPERAND (t, 0);
2812
        }
2813
 
2814
      if (!is_gimple_min_invariant (t) && !is_gimple_lvalue (t))
2815
        {
2816
          error ("invalid reference prefix");
2817
          return t;
2818
        }
2819
      *walk_subtrees = 0;
2820
      break;
2821
    case PLUS_EXPR:
2822
    case MINUS_EXPR:
2823
      /* PLUS_EXPR and MINUS_EXPR don't work on pointers, they should be done using
2824
         POINTER_PLUS_EXPR. */
2825
      if (POINTER_TYPE_P (TREE_TYPE (t)))
2826
        {
2827
          error ("invalid operand to plus/minus, type is a pointer");
2828
          return t;
2829
        }
2830
      CHECK_OP (0, "invalid operand to binary operator");
2831
      CHECK_OP (1, "invalid operand to binary operator");
2832
      break;
2833
 
2834
    case POINTER_PLUS_EXPR:
2835
      /* Check to make sure the first operand is a pointer or reference type. */
2836
      if (!POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t, 0))))
2837
        {
2838
          error ("invalid operand to pointer plus, first operand is not a pointer");
2839
          return t;
2840
        }
2841
      /* Check to make sure the second operand is a ptrofftype.  */
2842
      if (!ptrofftype_p (TREE_TYPE (TREE_OPERAND (t, 1))))
2843
        {
2844
          error ("invalid operand to pointer plus, second operand is not an "
2845
                 "integer type of appropriate width");
2846
          return t;
2847
        }
2848
      /* FALLTHROUGH */
2849
    case LT_EXPR:
2850
    case LE_EXPR:
2851
    case GT_EXPR:
2852
    case GE_EXPR:
2853
    case EQ_EXPR:
2854
    case NE_EXPR:
2855
    case UNORDERED_EXPR:
2856
    case ORDERED_EXPR:
2857
    case UNLT_EXPR:
2858
    case UNLE_EXPR:
2859
    case UNGT_EXPR:
2860
    case UNGE_EXPR:
2861
    case UNEQ_EXPR:
2862
    case LTGT_EXPR:
2863
    case MULT_EXPR:
2864
    case TRUNC_DIV_EXPR:
2865
    case CEIL_DIV_EXPR:
2866
    case FLOOR_DIV_EXPR:
2867
    case ROUND_DIV_EXPR:
2868
    case TRUNC_MOD_EXPR:
2869
    case CEIL_MOD_EXPR:
2870
    case FLOOR_MOD_EXPR:
2871
    case ROUND_MOD_EXPR:
2872
    case RDIV_EXPR:
2873
    case EXACT_DIV_EXPR:
2874
    case MIN_EXPR:
2875
    case MAX_EXPR:
2876
    case LSHIFT_EXPR:
2877
    case RSHIFT_EXPR:
2878
    case LROTATE_EXPR:
2879
    case RROTATE_EXPR:
2880
    case BIT_IOR_EXPR:
2881
    case BIT_XOR_EXPR:
2882
    case BIT_AND_EXPR:
2883
      CHECK_OP (0, "invalid operand to binary operator");
2884
      CHECK_OP (1, "invalid operand to binary operator");
2885
      break;
2886
 
2887
    case CONSTRUCTOR:
2888
      if (TREE_CONSTANT (t) && TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
2889
        *walk_subtrees = 0;
2890
      break;
2891
 
2892
    case CASE_LABEL_EXPR:
2893
      if (CASE_CHAIN (t))
2894
        {
2895
          error ("invalid CASE_CHAIN");
2896
          return t;
2897
        }
2898
      break;
2899
 
2900
    default:
2901
      break;
2902
    }
2903
  return NULL;
2904
 
2905
#undef CHECK_OP
2906
}
2907
 
2908
 
2909
/* Verify if EXPR is either a GIMPLE ID or a GIMPLE indirect reference.
2910
   Returns true if there is an error, otherwise false.  */
2911
 
2912
static bool
2913
verify_types_in_gimple_min_lval (tree expr)
2914
{
2915
  tree op;
2916
 
2917
  if (is_gimple_id (expr))
2918
    return false;
2919
 
2920
  if (TREE_CODE (expr) != TARGET_MEM_REF
2921
      && TREE_CODE (expr) != MEM_REF)
2922
    {
2923
      error ("invalid expression for min lvalue");
2924
      return true;
2925
    }
2926
 
2927
  /* TARGET_MEM_REFs are strange beasts.  */
2928
  if (TREE_CODE (expr) == TARGET_MEM_REF)
2929
    return false;
2930
 
2931
  op = TREE_OPERAND (expr, 0);
2932
  if (!is_gimple_val (op))
2933
    {
2934
      error ("invalid operand in indirect reference");
2935
      debug_generic_stmt (op);
2936
      return true;
2937
    }
2938
  /* Memory references now generally can involve a value conversion.  */
2939
 
2940
  return false;
2941
}
2942
 
2943
/* Verify if EXPR is a valid GIMPLE reference expression.  If
2944
   REQUIRE_LVALUE is true verifies it is an lvalue.  Returns true
2945
   if there is an error, otherwise false.  */
2946
 
2947
static bool
2948
verify_types_in_gimple_reference (tree expr, bool require_lvalue)
2949
{
2950
  while (handled_component_p (expr))
2951
    {
2952
      tree op = TREE_OPERAND (expr, 0);
2953
 
2954
      if (TREE_CODE (expr) == ARRAY_REF
2955
          || TREE_CODE (expr) == ARRAY_RANGE_REF)
2956
        {
2957
          if (!is_gimple_val (TREE_OPERAND (expr, 1))
2958
              || (TREE_OPERAND (expr, 2)
2959
                  && !is_gimple_val (TREE_OPERAND (expr, 2)))
2960
              || (TREE_OPERAND (expr, 3)
2961
                  && !is_gimple_val (TREE_OPERAND (expr, 3))))
2962
            {
2963
              error ("invalid operands to array reference");
2964
              debug_generic_stmt (expr);
2965
              return true;
2966
            }
2967
        }
2968
 
2969
      /* Verify if the reference array element types are compatible.  */
2970
      if (TREE_CODE (expr) == ARRAY_REF
2971
          && !useless_type_conversion_p (TREE_TYPE (expr),
2972
                                         TREE_TYPE (TREE_TYPE (op))))
2973
        {
2974
          error ("type mismatch in array reference");
2975
          debug_generic_stmt (TREE_TYPE (expr));
2976
          debug_generic_stmt (TREE_TYPE (TREE_TYPE (op)));
2977
          return true;
2978
        }
2979
      if (TREE_CODE (expr) == ARRAY_RANGE_REF
2980
          && !useless_type_conversion_p (TREE_TYPE (TREE_TYPE (expr)),
2981
                                         TREE_TYPE (TREE_TYPE (op))))
2982
        {
2983
          error ("type mismatch in array range reference");
2984
          debug_generic_stmt (TREE_TYPE (TREE_TYPE (expr)));
2985
          debug_generic_stmt (TREE_TYPE (TREE_TYPE (op)));
2986
          return true;
2987
        }
2988
 
2989
      if ((TREE_CODE (expr) == REALPART_EXPR
2990
           || TREE_CODE (expr) == IMAGPART_EXPR)
2991
          && !useless_type_conversion_p (TREE_TYPE (expr),
2992
                                         TREE_TYPE (TREE_TYPE (op))))
2993
        {
2994
          error ("type mismatch in real/imagpart reference");
2995
          debug_generic_stmt (TREE_TYPE (expr));
2996
          debug_generic_stmt (TREE_TYPE (TREE_TYPE (op)));
2997
          return true;
2998
        }
2999
 
3000
      if (TREE_CODE (expr) == COMPONENT_REF
3001
          && !useless_type_conversion_p (TREE_TYPE (expr),
3002
                                         TREE_TYPE (TREE_OPERAND (expr, 1))))
3003
        {
3004
          error ("type mismatch in component reference");
3005
          debug_generic_stmt (TREE_TYPE (expr));
3006
          debug_generic_stmt (TREE_TYPE (TREE_OPERAND (expr, 1)));
3007
          return true;
3008
        }
3009
 
3010
      if (TREE_CODE (expr) == VIEW_CONVERT_EXPR)
3011
        {
3012
          /* For VIEW_CONVERT_EXPRs which are allowed here too, we only check
3013
             that their operand is not an SSA name or an invariant when
3014
             requiring an lvalue (this usually means there is a SRA or IPA-SRA
3015
             bug).  Otherwise there is nothing to verify, gross mismatches at
3016
             most invoke undefined behavior.  */
3017
          if (require_lvalue
3018
              && (TREE_CODE (op) == SSA_NAME
3019
                  || is_gimple_min_invariant (op)))
3020
            {
3021
              error ("conversion of an SSA_NAME on the left hand side");
3022
              debug_generic_stmt (expr);
3023
              return true;
3024
            }
3025
          else if (TREE_CODE (op) == SSA_NAME
3026
                   && TYPE_SIZE (TREE_TYPE (expr)) != TYPE_SIZE (TREE_TYPE (op)))
3027
            {
3028
              error ("conversion of register to a different size");
3029
              debug_generic_stmt (expr);
3030
              return true;
3031
            }
3032
          else if (!handled_component_p (op))
3033
            return false;
3034
        }
3035
 
3036
      expr = op;
3037
    }
3038
 
3039
  if (TREE_CODE (expr) == MEM_REF)
3040
    {
3041
      if (!is_gimple_mem_ref_addr (TREE_OPERAND (expr, 0)))
3042
        {
3043
          error ("invalid address operand in MEM_REF");
3044
          debug_generic_stmt (expr);
3045
          return true;
3046
        }
3047
      if (TREE_CODE (TREE_OPERAND (expr, 1)) != INTEGER_CST
3048
          || !POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (expr, 1))))
3049
        {
3050
          error ("invalid offset operand in MEM_REF");
3051
          debug_generic_stmt (expr);
3052
          return true;
3053
        }
3054
    }
3055
  else if (TREE_CODE (expr) == TARGET_MEM_REF)
3056
    {
3057
      if (!TMR_BASE (expr)
3058
          || !is_gimple_mem_ref_addr (TMR_BASE (expr)))
3059
        {
3060
          error ("invalid address operand in TARGET_MEM_REF");
3061
          return true;
3062
        }
3063
      if (!TMR_OFFSET (expr)
3064
          || TREE_CODE (TMR_OFFSET (expr)) != INTEGER_CST
3065
          || !POINTER_TYPE_P (TREE_TYPE (TMR_OFFSET (expr))))
3066
        {
3067
          error ("invalid offset operand in TARGET_MEM_REF");
3068
          debug_generic_stmt (expr);
3069
          return true;
3070
        }
3071
    }
3072
 
3073
  return ((require_lvalue || !is_gimple_min_invariant (expr))
3074
          && verify_types_in_gimple_min_lval (expr));
3075
}
3076
 
3077
/* Returns true if there is one pointer type in TYPE_POINTER_TO (SRC_OBJ)
3078
   list of pointer-to types that is trivially convertible to DEST.  */
3079
 
3080
static bool
3081
one_pointer_to_useless_type_conversion_p (tree dest, tree src_obj)
3082
{
3083
  tree src;
3084
 
3085
  if (!TYPE_POINTER_TO (src_obj))
3086
    return true;
3087
 
3088
  for (src = TYPE_POINTER_TO (src_obj); src; src = TYPE_NEXT_PTR_TO (src))
3089
    if (useless_type_conversion_p (dest, src))
3090
      return true;
3091
 
3092
  return false;
3093
}
3094
 
3095
/* Return true if TYPE1 is a fixed-point type and if conversions to and
3096
   from TYPE2 can be handled by FIXED_CONVERT_EXPR.  */
3097
 
3098
static bool
3099
valid_fixed_convert_types_p (tree type1, tree type2)
3100
{
3101
  return (FIXED_POINT_TYPE_P (type1)
3102
          && (INTEGRAL_TYPE_P (type2)
3103
              || SCALAR_FLOAT_TYPE_P (type2)
3104
              || FIXED_POINT_TYPE_P (type2)));
3105
}
3106
 
3107
/* Verify the contents of a GIMPLE_CALL STMT.  Returns true when there
3108
   is a problem, otherwise false.  */
3109
 
3110
static bool
3111
verify_gimple_call (gimple stmt)
3112
{
3113
  tree fn = gimple_call_fn (stmt);
3114
  tree fntype, fndecl;
3115
  unsigned i;
3116
 
3117
  if (gimple_call_internal_p (stmt))
3118
    {
3119
      if (fn)
3120
        {
3121
          error ("gimple call has two targets");
3122
          debug_generic_stmt (fn);
3123
          return true;
3124
        }
3125
    }
3126
  else
3127
    {
3128
      if (!fn)
3129
        {
3130
          error ("gimple call has no target");
3131
          return true;
3132
        }
3133
    }
3134
 
3135
  if (fn && !is_gimple_call_addr (fn))
3136
    {
3137
      error ("invalid function in gimple call");
3138
      debug_generic_stmt (fn);
3139
      return true;
3140
    }
3141
 
3142
  if (fn
3143
      && (!POINTER_TYPE_P (TREE_TYPE (fn))
3144
          || (TREE_CODE (TREE_TYPE (TREE_TYPE (fn))) != FUNCTION_TYPE
3145
              && TREE_CODE (TREE_TYPE (TREE_TYPE (fn))) != METHOD_TYPE)))
3146
    {
3147
      error ("non-function in gimple call");
3148
      return true;
3149
    }
3150
 
3151
   fndecl = gimple_call_fndecl (stmt);
3152
   if (fndecl
3153
       && TREE_CODE (fndecl) == FUNCTION_DECL
3154
       && DECL_LOOPING_CONST_OR_PURE_P (fndecl)
3155
       && !DECL_PURE_P (fndecl)
3156
       && !TREE_READONLY (fndecl))
3157
     {
3158
       error ("invalid pure const state for function");
3159
       return true;
3160
     }
3161
 
3162
  if (gimple_call_lhs (stmt)
3163
      && (!is_gimple_lvalue (gimple_call_lhs (stmt))
3164
          || verify_types_in_gimple_reference (gimple_call_lhs (stmt), true)))
3165
    {
3166
      error ("invalid LHS in gimple call");
3167
      return true;
3168
    }
3169
 
3170
  if (gimple_call_lhs (stmt) && gimple_call_noreturn_p (stmt))
3171
    {
3172
      error ("LHS in noreturn call");
3173
      return true;
3174
    }
3175
 
3176
  fntype = gimple_call_fntype (stmt);
3177
  if (fntype
3178
      && gimple_call_lhs (stmt)
3179
      && !useless_type_conversion_p (TREE_TYPE (gimple_call_lhs (stmt)),
3180
                                     TREE_TYPE (fntype))
3181
      /* ???  At least C++ misses conversions at assignments from
3182
         void * call results.
3183
         ???  Java is completely off.  Especially with functions
3184
         returning java.lang.Object.
3185
         For now simply allow arbitrary pointer type conversions.  */
3186
      && !(POINTER_TYPE_P (TREE_TYPE (gimple_call_lhs (stmt)))
3187
           && POINTER_TYPE_P (TREE_TYPE (fntype))))
3188
    {
3189
      error ("invalid conversion in gimple call");
3190
      debug_generic_stmt (TREE_TYPE (gimple_call_lhs (stmt)));
3191
      debug_generic_stmt (TREE_TYPE (fntype));
3192
      return true;
3193
    }
3194
 
3195
  if (gimple_call_chain (stmt)
3196
      && !is_gimple_val (gimple_call_chain (stmt)))
3197
    {
3198
      error ("invalid static chain in gimple call");
3199
      debug_generic_stmt (gimple_call_chain (stmt));
3200
      return true;
3201
    }
3202
 
3203
  /* If there is a static chain argument, this should not be an indirect
3204
     call, and the decl should have DECL_STATIC_CHAIN set.  */
3205
  if (gimple_call_chain (stmt))
3206
    {
3207
      if (!gimple_call_fndecl (stmt))
3208
        {
3209
          error ("static chain in indirect gimple call");
3210
          return true;
3211
        }
3212
      fn = TREE_OPERAND (fn, 0);
3213
 
3214
      if (!DECL_STATIC_CHAIN (fn))
3215
        {
3216
          error ("static chain with function that doesn%'t use one");
3217
          return true;
3218
        }
3219
    }
3220
 
3221
  /* ???  The C frontend passes unpromoted arguments in case it
3222
     didn't see a function declaration before the call.  So for now
3223
     leave the call arguments mostly unverified.  Once we gimplify
3224
     unit-at-a-time we have a chance to fix this.  */
3225
 
3226
  for (i = 0; i < gimple_call_num_args (stmt); ++i)
3227
    {
3228
      tree arg = gimple_call_arg (stmt, i);
3229
      if ((is_gimple_reg_type (TREE_TYPE (arg))
3230
           && !is_gimple_val (arg))
3231
          || (!is_gimple_reg_type (TREE_TYPE (arg))
3232
              && !is_gimple_lvalue (arg)))
3233
        {
3234
          error ("invalid argument to gimple call");
3235
          debug_generic_expr (arg);
3236
          return true;
3237
        }
3238
    }
3239
 
3240
  return false;
3241
}
3242
 
3243
/* Verifies the gimple comparison with the result type TYPE and
3244
   the operands OP0 and OP1.  */
3245
 
3246
static bool
3247
verify_gimple_comparison (tree type, tree op0, tree op1)
3248
{
3249
  tree op0_type = TREE_TYPE (op0);
3250
  tree op1_type = TREE_TYPE (op1);
3251
 
3252
  if (!is_gimple_val (op0) || !is_gimple_val (op1))
3253
    {
3254
      error ("invalid operands in gimple comparison");
3255
      return true;
3256
    }
3257
 
3258
  /* For comparisons we do not have the operations type as the
3259
     effective type the comparison is carried out in.  Instead
3260
     we require that either the first operand is trivially
3261
     convertible into the second, or the other way around.
3262
     Because we special-case pointers to void we allow
3263
     comparisons of pointers with the same mode as well.  */
3264
  if (!useless_type_conversion_p (op0_type, op1_type)
3265
      && !useless_type_conversion_p (op1_type, op0_type)
3266
      && (!POINTER_TYPE_P (op0_type)
3267
          || !POINTER_TYPE_P (op1_type)
3268
          || TYPE_MODE (op0_type) != TYPE_MODE (op1_type)))
3269
    {
3270
      error ("mismatching comparison operand types");
3271
      debug_generic_expr (op0_type);
3272
      debug_generic_expr (op1_type);
3273
      return true;
3274
    }
3275
 
3276
  /* The resulting type of a comparison may be an effective boolean type.  */
3277
  if (INTEGRAL_TYPE_P (type)
3278
      && (TREE_CODE (type) == BOOLEAN_TYPE
3279
          || TYPE_PRECISION (type) == 1))
3280
    ;
3281
  /* Or an integer vector type with the same size and element count
3282
     as the comparison operand types.  */
3283
  else if (TREE_CODE (type) == VECTOR_TYPE
3284
           && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
3285
    {
3286
      if (TREE_CODE (op0_type) != VECTOR_TYPE
3287
          || TREE_CODE (op1_type) != VECTOR_TYPE)
3288
        {
3289
          error ("non-vector operands in vector comparison");
3290
          debug_generic_expr (op0_type);
3291
          debug_generic_expr (op1_type);
3292
          return true;
3293
        }
3294
 
3295
      if (TYPE_VECTOR_SUBPARTS (type) != TYPE_VECTOR_SUBPARTS (op0_type)
3296
          || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (type)))
3297
              != GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0_type)))))
3298
        {
3299
          error ("invalid vector comparison resulting type");
3300
          debug_generic_expr (type);
3301
          return true;
3302
        }
3303
    }
3304
  else
3305
    {
3306
      error ("bogus comparison result type");
3307
      debug_generic_expr (type);
3308
      return true;
3309
    }
3310
 
3311
  return false;
3312
}
3313
 
3314
/* Verify a gimple assignment statement STMT with an unary rhs.
3315
   Returns true if anything is wrong.  */
3316
 
3317
static bool
3318
verify_gimple_assign_unary (gimple stmt)
3319
{
3320
  enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
3321
  tree lhs = gimple_assign_lhs (stmt);
3322
  tree lhs_type = TREE_TYPE (lhs);
3323
  tree rhs1 = gimple_assign_rhs1 (stmt);
3324
  tree rhs1_type = TREE_TYPE (rhs1);
3325
 
3326
  if (!is_gimple_reg (lhs))
3327
    {
3328
      error ("non-register as LHS of unary operation");
3329
      return true;
3330
    }
3331
 
3332
  if (!is_gimple_val (rhs1))
3333
    {
3334
      error ("invalid operand in unary operation");
3335
      return true;
3336
    }
3337
 
3338
  /* First handle conversions.  */
3339
  switch (rhs_code)
3340
    {
3341
    CASE_CONVERT:
3342
      {
3343
        /* Allow conversions between integral types and pointers only if
3344
           there is no sign or zero extension involved.
3345
           For targets were the precision of ptrofftype doesn't match that
3346
           of pointers we need to allow arbitrary conversions from and
3347
           to ptrofftype.  */
3348
        if ((POINTER_TYPE_P (lhs_type)
3349
             && INTEGRAL_TYPE_P (rhs1_type)
3350
             && (TYPE_PRECISION (lhs_type) >= TYPE_PRECISION (rhs1_type)
3351
                 || ptrofftype_p (rhs1_type)))
3352
            || (POINTER_TYPE_P (rhs1_type)
3353
                && INTEGRAL_TYPE_P (lhs_type)
3354
                && (TYPE_PRECISION (rhs1_type) >= TYPE_PRECISION (lhs_type)
3355
                    || ptrofftype_p (sizetype))))
3356
          return false;
3357
 
3358
        /* Allow conversion from integer to offset type and vice versa.  */
3359
        if ((TREE_CODE (lhs_type) == OFFSET_TYPE
3360
             && TREE_CODE (rhs1_type) == INTEGER_TYPE)
3361
            || (TREE_CODE (lhs_type) == INTEGER_TYPE
3362
                && TREE_CODE (rhs1_type) == OFFSET_TYPE))
3363
          return false;
3364
 
3365
        /* Otherwise assert we are converting between types of the
3366
           same kind.  */
3367
        if (INTEGRAL_TYPE_P (lhs_type) != INTEGRAL_TYPE_P (rhs1_type))
3368
          {
3369
            error ("invalid types in nop conversion");
3370
            debug_generic_expr (lhs_type);
3371
            debug_generic_expr (rhs1_type);
3372
            return true;
3373
          }
3374
 
3375
        return false;
3376
      }
3377
 
3378
    case ADDR_SPACE_CONVERT_EXPR:
3379
      {
3380
        if (!POINTER_TYPE_P (rhs1_type) || !POINTER_TYPE_P (lhs_type)
3381
            || (TYPE_ADDR_SPACE (TREE_TYPE (rhs1_type))
3382
                == TYPE_ADDR_SPACE (TREE_TYPE (lhs_type))))
3383
          {
3384
            error ("invalid types in address space conversion");
3385
            debug_generic_expr (lhs_type);
3386
            debug_generic_expr (rhs1_type);
3387
            return true;
3388
          }
3389
 
3390
        return false;
3391
      }
3392
 
3393
    case FIXED_CONVERT_EXPR:
3394
      {
3395
        if (!valid_fixed_convert_types_p (lhs_type, rhs1_type)
3396
            && !valid_fixed_convert_types_p (rhs1_type, lhs_type))
3397
          {
3398
            error ("invalid types in fixed-point conversion");
3399
            debug_generic_expr (lhs_type);
3400
            debug_generic_expr (rhs1_type);
3401
            return true;
3402
          }
3403
 
3404
        return false;
3405
      }
3406
 
3407
    case FLOAT_EXPR:
3408
      {
3409
        if ((!INTEGRAL_TYPE_P (rhs1_type) || !SCALAR_FLOAT_TYPE_P (lhs_type))
3410
            && (!VECTOR_INTEGER_TYPE_P (rhs1_type)
3411
                || !VECTOR_FLOAT_TYPE_P(lhs_type)))
3412
          {
3413
            error ("invalid types in conversion to floating point");
3414
            debug_generic_expr (lhs_type);
3415
            debug_generic_expr (rhs1_type);
3416
            return true;
3417
          }
3418
 
3419
        return false;
3420
      }
3421
 
3422
    case FIX_TRUNC_EXPR:
3423
      {
3424
        if ((!INTEGRAL_TYPE_P (lhs_type) || !SCALAR_FLOAT_TYPE_P (rhs1_type))
3425
            && (!VECTOR_INTEGER_TYPE_P (lhs_type)
3426
                || !VECTOR_FLOAT_TYPE_P(rhs1_type)))
3427
          {
3428
            error ("invalid types in conversion to integer");
3429
            debug_generic_expr (lhs_type);
3430
            debug_generic_expr (rhs1_type);
3431
            return true;
3432
          }
3433
 
3434
        return false;
3435
      }
3436
 
3437
    case VEC_UNPACK_HI_EXPR:
3438
    case VEC_UNPACK_LO_EXPR:
3439
    case REDUC_MAX_EXPR:
3440
    case REDUC_MIN_EXPR:
3441
    case REDUC_PLUS_EXPR:
3442
    case VEC_UNPACK_FLOAT_HI_EXPR:
3443
    case VEC_UNPACK_FLOAT_LO_EXPR:
3444
      /* FIXME.  */
3445
      return false;
3446
 
3447
    case NEGATE_EXPR:
3448
    case ABS_EXPR:
3449
    case BIT_NOT_EXPR:
3450
    case PAREN_EXPR:
3451
    case NON_LVALUE_EXPR:
3452
    case CONJ_EXPR:
3453
      break;
3454
 
3455
    default:
3456
      gcc_unreachable ();
3457
    }
3458
 
3459
  /* For the remaining codes assert there is no conversion involved.  */
3460
  if (!useless_type_conversion_p (lhs_type, rhs1_type))
3461
    {
3462
      error ("non-trivial conversion in unary operation");
3463
      debug_generic_expr (lhs_type);
3464
      debug_generic_expr (rhs1_type);
3465
      return true;
3466
    }
3467
 
3468
  return false;
3469
}
3470
 
3471
/* Verify a gimple assignment statement STMT with a binary rhs.
3472
   Returns true if anything is wrong.  */
3473
 
3474
static bool
3475
verify_gimple_assign_binary (gimple stmt)
3476
{
3477
  enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
3478
  tree lhs = gimple_assign_lhs (stmt);
3479
  tree lhs_type = TREE_TYPE (lhs);
3480
  tree rhs1 = gimple_assign_rhs1 (stmt);
3481
  tree rhs1_type = TREE_TYPE (rhs1);
3482
  tree rhs2 = gimple_assign_rhs2 (stmt);
3483
  tree rhs2_type = TREE_TYPE (rhs2);
3484
 
3485
  if (!is_gimple_reg (lhs))
3486
    {
3487
      error ("non-register as LHS of binary operation");
3488
      return true;
3489
    }
3490
 
3491
  if (!is_gimple_val (rhs1)
3492
      || !is_gimple_val (rhs2))
3493
    {
3494
      error ("invalid operands in binary operation");
3495
      return true;
3496
    }
3497
 
3498
  /* First handle operations that involve different types.  */
3499
  switch (rhs_code)
3500
    {
3501
    case COMPLEX_EXPR:
3502
      {
3503
        if (TREE_CODE (lhs_type) != COMPLEX_TYPE
3504
            || !(INTEGRAL_TYPE_P (rhs1_type)
3505
                 || SCALAR_FLOAT_TYPE_P (rhs1_type))
3506
            || !(INTEGRAL_TYPE_P (rhs2_type)
3507
                 || SCALAR_FLOAT_TYPE_P (rhs2_type)))
3508
          {
3509
            error ("type mismatch in complex expression");
3510
            debug_generic_expr (lhs_type);
3511
            debug_generic_expr (rhs1_type);
3512
            debug_generic_expr (rhs2_type);
3513
            return true;
3514
          }
3515
 
3516
        return false;
3517
      }
3518
 
3519
    case LSHIFT_EXPR:
3520
    case RSHIFT_EXPR:
3521
    case LROTATE_EXPR:
3522
    case RROTATE_EXPR:
3523
      {
3524
        /* Shifts and rotates are ok on integral types, fixed point
3525
           types and integer vector types.  */
3526
        if ((!INTEGRAL_TYPE_P (rhs1_type)
3527
             && !FIXED_POINT_TYPE_P (rhs1_type)
3528
             && !(TREE_CODE (rhs1_type) == VECTOR_TYPE
3529
                  && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))))
3530
            || (!INTEGRAL_TYPE_P (rhs2_type)
3531
                /* Vector shifts of vectors are also ok.  */
3532
                && !(TREE_CODE (rhs1_type) == VECTOR_TYPE
3533
                     && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))
3534
                     && TREE_CODE (rhs2_type) == VECTOR_TYPE
3535
                     && INTEGRAL_TYPE_P (TREE_TYPE (rhs2_type))))
3536
            || !useless_type_conversion_p (lhs_type, rhs1_type))
3537
          {
3538
            error ("type mismatch in shift expression");
3539
            debug_generic_expr (lhs_type);
3540
            debug_generic_expr (rhs1_type);
3541
            debug_generic_expr (rhs2_type);
3542
            return true;
3543
          }
3544
 
3545
        return false;
3546
      }
3547
 
3548
    case VEC_LSHIFT_EXPR:
3549
    case VEC_RSHIFT_EXPR:
3550
      {
3551
        if (TREE_CODE (rhs1_type) != VECTOR_TYPE
3552
            || !(INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))
3553
                 || POINTER_TYPE_P (TREE_TYPE (rhs1_type))
3554
                 || FIXED_POINT_TYPE_P (TREE_TYPE (rhs1_type))
3555
                 || SCALAR_FLOAT_TYPE_P (TREE_TYPE (rhs1_type)))
3556
            || (!INTEGRAL_TYPE_P (rhs2_type)
3557
                && (TREE_CODE (rhs2_type) != VECTOR_TYPE
3558
                    || !INTEGRAL_TYPE_P (TREE_TYPE (rhs2_type))))
3559
            || !useless_type_conversion_p (lhs_type, rhs1_type))
3560
          {
3561
            error ("type mismatch in vector shift expression");
3562
            debug_generic_expr (lhs_type);
3563
            debug_generic_expr (rhs1_type);
3564
            debug_generic_expr (rhs2_type);
3565
            return true;
3566
          }
3567
        /* For shifting a vector of non-integral components we
3568
           only allow shifting by a constant multiple of the element size.  */
3569
        if (!INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))
3570
            && (TREE_CODE (rhs2) != INTEGER_CST
3571
                || !div_if_zero_remainder (EXACT_DIV_EXPR, rhs2,
3572
                                           TYPE_SIZE (TREE_TYPE (rhs1_type)))))
3573
          {
3574
            error ("non-element sized vector shift of floating point vector");
3575
            return true;
3576
          }
3577
 
3578
        return false;
3579
      }
3580
 
3581
    case WIDEN_LSHIFT_EXPR:
3582
      {
3583
        if (!INTEGRAL_TYPE_P (lhs_type)
3584
            || !INTEGRAL_TYPE_P (rhs1_type)
3585
            || TREE_CODE (rhs2) != INTEGER_CST
3586
            || (2 * TYPE_PRECISION (rhs1_type) > TYPE_PRECISION (lhs_type)))
3587
          {
3588
            error ("type mismatch in widening vector shift expression");
3589
            debug_generic_expr (lhs_type);
3590
            debug_generic_expr (rhs1_type);
3591
            debug_generic_expr (rhs2_type);
3592
            return true;
3593
          }
3594
 
3595
        return false;
3596
      }
3597
 
3598
    case VEC_WIDEN_LSHIFT_HI_EXPR:
3599
    case VEC_WIDEN_LSHIFT_LO_EXPR:
3600
      {
3601
        if (TREE_CODE (rhs1_type) != VECTOR_TYPE
3602
            || TREE_CODE (lhs_type) != VECTOR_TYPE
3603
            || !INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))
3604
            || !INTEGRAL_TYPE_P (TREE_TYPE (lhs_type))
3605
            || TREE_CODE (rhs2) != INTEGER_CST
3606
            || (2 * TYPE_PRECISION (TREE_TYPE (rhs1_type))
3607
                > TYPE_PRECISION (TREE_TYPE (lhs_type))))
3608
          {
3609
            error ("type mismatch in widening vector shift expression");
3610
            debug_generic_expr (lhs_type);
3611
            debug_generic_expr (rhs1_type);
3612
            debug_generic_expr (rhs2_type);
3613
            return true;
3614
          }
3615
 
3616
        return false;
3617
      }
3618
 
3619
    case PLUS_EXPR:
3620
    case MINUS_EXPR:
3621
      {
3622
        /* We use regular PLUS_EXPR and MINUS_EXPR for vectors.
3623
           ???  This just makes the checker happy and may not be what is
3624
           intended.  */
3625
        if (TREE_CODE (lhs_type) == VECTOR_TYPE
3626
            && POINTER_TYPE_P (TREE_TYPE (lhs_type)))
3627
          {
3628
            if (TREE_CODE (rhs1_type) != VECTOR_TYPE
3629
                || TREE_CODE (rhs2_type) != VECTOR_TYPE)
3630
              {
3631
                error ("invalid non-vector operands to vector valued plus");
3632
                return true;
3633
              }
3634
            lhs_type = TREE_TYPE (lhs_type);
3635
            rhs1_type = TREE_TYPE (rhs1_type);
3636
            rhs2_type = TREE_TYPE (rhs2_type);
3637
            /* PLUS_EXPR is commutative, so we might end up canonicalizing
3638
               the pointer to 2nd place.  */
3639
            if (POINTER_TYPE_P (rhs2_type))
3640
              {
3641
                tree tem = rhs1_type;
3642
                rhs1_type = rhs2_type;
3643
                rhs2_type = tem;
3644
              }
3645
            goto do_pointer_plus_expr_check;
3646
          }
3647
        if (POINTER_TYPE_P (lhs_type)
3648
            || POINTER_TYPE_P (rhs1_type)
3649
            || POINTER_TYPE_P (rhs2_type))
3650
          {
3651
            error ("invalid (pointer) operands to plus/minus");
3652
            return true;
3653
          }
3654
 
3655
        /* Continue with generic binary expression handling.  */
3656
        break;
3657
      }
3658
 
3659
    case POINTER_PLUS_EXPR:
3660
      {
3661
do_pointer_plus_expr_check:
3662
        if (!POINTER_TYPE_P (rhs1_type)
3663
            || !useless_type_conversion_p (lhs_type, rhs1_type)
3664
            || !ptrofftype_p (rhs2_type))
3665
          {
3666
            error ("type mismatch in pointer plus expression");
3667
            debug_generic_stmt (lhs_type);
3668
            debug_generic_stmt (rhs1_type);
3669
            debug_generic_stmt (rhs2_type);
3670
            return true;
3671
          }
3672
 
3673
        return false;
3674
      }
3675
 
3676
    case TRUTH_ANDIF_EXPR:
3677
    case TRUTH_ORIF_EXPR:
3678
    case TRUTH_AND_EXPR:
3679
    case TRUTH_OR_EXPR:
3680
    case TRUTH_XOR_EXPR:
3681
 
3682
      gcc_unreachable ();
3683
 
3684
    case LT_EXPR:
3685
    case LE_EXPR:
3686
    case GT_EXPR:
3687
    case GE_EXPR:
3688
    case EQ_EXPR:
3689
    case NE_EXPR:
3690
    case UNORDERED_EXPR:
3691
    case ORDERED_EXPR:
3692
    case UNLT_EXPR:
3693
    case UNLE_EXPR:
3694
    case UNGT_EXPR:
3695
    case UNGE_EXPR:
3696
    case UNEQ_EXPR:
3697
    case LTGT_EXPR:
3698
      /* Comparisons are also binary, but the result type is not
3699
         connected to the operand types.  */
3700
      return verify_gimple_comparison (lhs_type, rhs1, rhs2);
3701
 
3702
    case WIDEN_MULT_EXPR:
3703
      if (TREE_CODE (lhs_type) != INTEGER_TYPE)
3704
        return true;
3705
      return ((2 * TYPE_PRECISION (rhs1_type) > TYPE_PRECISION (lhs_type))
3706
              || (TYPE_PRECISION (rhs1_type) != TYPE_PRECISION (rhs2_type)));
3707
 
3708
    case WIDEN_SUM_EXPR:
3709
    case VEC_WIDEN_MULT_HI_EXPR:
3710
    case VEC_WIDEN_MULT_LO_EXPR:
3711
    case VEC_PACK_TRUNC_EXPR:
3712
    case VEC_PACK_SAT_EXPR:
3713
    case VEC_PACK_FIX_TRUNC_EXPR:
3714
      /* FIXME.  */
3715
      return false;
3716
 
3717
    case MULT_EXPR:
3718
    case TRUNC_DIV_EXPR:
3719
    case CEIL_DIV_EXPR:
3720
    case FLOOR_DIV_EXPR:
3721
    case ROUND_DIV_EXPR:
3722
    case TRUNC_MOD_EXPR:
3723
    case CEIL_MOD_EXPR:
3724
    case FLOOR_MOD_EXPR:
3725
    case ROUND_MOD_EXPR:
3726
    case RDIV_EXPR:
3727
    case EXACT_DIV_EXPR:
3728
    case MIN_EXPR:
3729
    case MAX_EXPR:
3730
    case BIT_IOR_EXPR:
3731
    case BIT_XOR_EXPR:
3732
    case BIT_AND_EXPR:
3733
      /* Continue with generic binary expression handling.  */
3734
      break;
3735
 
3736
    default:
3737
      gcc_unreachable ();
3738
    }
3739
 
3740
  if (!useless_type_conversion_p (lhs_type, rhs1_type)
3741
      || !useless_type_conversion_p (lhs_type, rhs2_type))
3742
    {
3743
      error ("type mismatch in binary expression");
3744
      debug_generic_stmt (lhs_type);
3745
      debug_generic_stmt (rhs1_type);
3746
      debug_generic_stmt (rhs2_type);
3747
      return true;
3748
    }
3749
 
3750
  return false;
3751
}
3752
 
3753
/* Verify a gimple assignment statement STMT with a ternary rhs.
3754
   Returns true if anything is wrong.  */
3755
 
3756
static bool
3757
verify_gimple_assign_ternary (gimple stmt)
3758
{
3759
  enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
3760
  tree lhs = gimple_assign_lhs (stmt);
3761
  tree lhs_type = TREE_TYPE (lhs);
3762
  tree rhs1 = gimple_assign_rhs1 (stmt);
3763
  tree rhs1_type = TREE_TYPE (rhs1);
3764
  tree rhs2 = gimple_assign_rhs2 (stmt);
3765
  tree rhs2_type = TREE_TYPE (rhs2);
3766
  tree rhs3 = gimple_assign_rhs3 (stmt);
3767
  tree rhs3_type = TREE_TYPE (rhs3);
3768
 
3769
  if (!is_gimple_reg (lhs))
3770
    {
3771
      error ("non-register as LHS of ternary operation");
3772
      return true;
3773
    }
3774
 
3775
  if (((rhs_code == VEC_COND_EXPR || rhs_code == COND_EXPR)
3776
       ? !is_gimple_condexpr (rhs1) : !is_gimple_val (rhs1))
3777
      || !is_gimple_val (rhs2)
3778
      || !is_gimple_val (rhs3))
3779
    {
3780
      error ("invalid operands in ternary operation");
3781
      return true;
3782
    }
3783
 
3784
  /* First handle operations that involve different types.  */
3785
  switch (rhs_code)
3786
    {
3787
    case WIDEN_MULT_PLUS_EXPR:
3788
    case WIDEN_MULT_MINUS_EXPR:
3789
      if ((!INTEGRAL_TYPE_P (rhs1_type)
3790
           && !FIXED_POINT_TYPE_P (rhs1_type))
3791
          || !useless_type_conversion_p (rhs1_type, rhs2_type)
3792
          || !useless_type_conversion_p (lhs_type, rhs3_type)
3793
          || 2 * TYPE_PRECISION (rhs1_type) > TYPE_PRECISION (lhs_type)
3794
          || TYPE_PRECISION (rhs1_type) != TYPE_PRECISION (rhs2_type))
3795
        {
3796
          error ("type mismatch in widening multiply-accumulate expression");
3797
          debug_generic_expr (lhs_type);
3798
          debug_generic_expr (rhs1_type);
3799
          debug_generic_expr (rhs2_type);
3800
          debug_generic_expr (rhs3_type);
3801
          return true;
3802
        }
3803
      break;
3804
 
3805
    case FMA_EXPR:
3806
      if (!useless_type_conversion_p (lhs_type, rhs1_type)
3807
          || !useless_type_conversion_p (lhs_type, rhs2_type)
3808
          || !useless_type_conversion_p (lhs_type, rhs3_type))
3809
        {
3810
          error ("type mismatch in fused multiply-add expression");
3811
          debug_generic_expr (lhs_type);
3812
          debug_generic_expr (rhs1_type);
3813
          debug_generic_expr (rhs2_type);
3814
          debug_generic_expr (rhs3_type);
3815
          return true;
3816
        }
3817
      break;
3818
 
3819
    case COND_EXPR:
3820
    case VEC_COND_EXPR:
3821
      if (!useless_type_conversion_p (lhs_type, rhs2_type)
3822
          || !useless_type_conversion_p (lhs_type, rhs3_type))
3823
        {
3824
          error ("type mismatch in conditional expression");
3825
          debug_generic_expr (lhs_type);
3826
          debug_generic_expr (rhs2_type);
3827
          debug_generic_expr (rhs3_type);
3828
          return true;
3829
        }
3830
      break;
3831
 
3832
    case VEC_PERM_EXPR:
3833
      if (!useless_type_conversion_p (lhs_type, rhs1_type)
3834
          || !useless_type_conversion_p (lhs_type, rhs2_type))
3835
        {
3836
          error ("type mismatch in vector permute expression");
3837
          debug_generic_expr (lhs_type);
3838
          debug_generic_expr (rhs1_type);
3839
          debug_generic_expr (rhs2_type);
3840
          debug_generic_expr (rhs3_type);
3841
          return true;
3842
        }
3843
 
3844
      if (TREE_CODE (rhs1_type) != VECTOR_TYPE
3845
          || TREE_CODE (rhs2_type) != VECTOR_TYPE
3846
          || TREE_CODE (rhs3_type) != VECTOR_TYPE)
3847
        {
3848
          error ("vector types expected in vector permute expression");
3849
          debug_generic_expr (lhs_type);
3850
          debug_generic_expr (rhs1_type);
3851
          debug_generic_expr (rhs2_type);
3852
          debug_generic_expr (rhs3_type);
3853
          return true;
3854
        }
3855
 
3856
      if (TYPE_VECTOR_SUBPARTS (rhs1_type) != TYPE_VECTOR_SUBPARTS (rhs2_type)
3857
          || TYPE_VECTOR_SUBPARTS (rhs2_type)
3858
             != TYPE_VECTOR_SUBPARTS (rhs3_type)
3859
          || TYPE_VECTOR_SUBPARTS (rhs3_type)
3860
             != TYPE_VECTOR_SUBPARTS (lhs_type))
3861
        {
3862
          error ("vectors with different element number found "
3863
                 "in vector permute expression");
3864
          debug_generic_expr (lhs_type);
3865
          debug_generic_expr (rhs1_type);
3866
          debug_generic_expr (rhs2_type);
3867
          debug_generic_expr (rhs3_type);
3868
          return true;
3869
        }
3870
 
3871
      if (TREE_CODE (TREE_TYPE (rhs3_type)) != INTEGER_TYPE
3872
          || GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (rhs3_type)))
3873
             != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (rhs1_type))))
3874
        {
3875
          error ("invalid mask type in vector permute expression");
3876
          debug_generic_expr (lhs_type);
3877
          debug_generic_expr (rhs1_type);
3878
          debug_generic_expr (rhs2_type);
3879
          debug_generic_expr (rhs3_type);
3880
          return true;
3881
        }
3882
 
3883
      return false;
3884
 
3885
    case DOT_PROD_EXPR:
3886
    case REALIGN_LOAD_EXPR:
3887
      /* FIXME.  */
3888
      return false;
3889
 
3890
    default:
3891
      gcc_unreachable ();
3892
    }
3893
  return false;
3894
}
3895
 
3896
/* Verify a gimple assignment statement STMT with a single rhs.
3897
   Returns true if anything is wrong.  */
3898
 
3899
static bool
3900
verify_gimple_assign_single (gimple stmt)
3901
{
3902
  enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
3903
  tree lhs = gimple_assign_lhs (stmt);
3904
  tree lhs_type = TREE_TYPE (lhs);
3905
  tree rhs1 = gimple_assign_rhs1 (stmt);
3906
  tree rhs1_type = TREE_TYPE (rhs1);
3907
  bool res = false;
3908
 
3909
  if (!useless_type_conversion_p (lhs_type, rhs1_type))
3910
    {
3911
      error ("non-trivial conversion at assignment");
3912
      debug_generic_expr (lhs_type);
3913
      debug_generic_expr (rhs1_type);
3914
      return true;
3915
    }
3916
 
3917
  if (handled_component_p (lhs))
3918
    res |= verify_types_in_gimple_reference (lhs, true);
3919
 
3920
  /* Special codes we cannot handle via their class.  */
3921
  switch (rhs_code)
3922
    {
3923
    case ADDR_EXPR:
3924
      {
3925
        tree op = TREE_OPERAND (rhs1, 0);
3926
        if (!is_gimple_addressable (op))
3927
          {
3928
            error ("invalid operand in unary expression");
3929
            return true;
3930
          }
3931
 
3932
        /* Technically there is no longer a need for matching types, but
3933
           gimple hygiene asks for this check.  In LTO we can end up
3934
           combining incompatible units and thus end up with addresses
3935
           of globals that change their type to a common one.  */
3936
        if (!in_lto_p
3937
            && !types_compatible_p (TREE_TYPE (op),
3938
                                    TREE_TYPE (TREE_TYPE (rhs1)))
3939
            && !one_pointer_to_useless_type_conversion_p (TREE_TYPE (rhs1),
3940
                                                          TREE_TYPE (op)))
3941
          {
3942
            error ("type mismatch in address expression");
3943
            debug_generic_stmt (TREE_TYPE (rhs1));
3944
            debug_generic_stmt (TREE_TYPE (op));
3945
            return true;
3946
          }
3947
 
3948
        return verify_types_in_gimple_reference (op, true);
3949
      }
3950
 
3951
    /* tcc_reference  */
3952
    case INDIRECT_REF:
3953
      error ("INDIRECT_REF in gimple IL");
3954
      return true;
3955
 
3956
    case COMPONENT_REF:
3957
    case BIT_FIELD_REF:
3958
    case ARRAY_REF:
3959
    case ARRAY_RANGE_REF:
3960
    case VIEW_CONVERT_EXPR:
3961
    case REALPART_EXPR:
3962
    case IMAGPART_EXPR:
3963
    case TARGET_MEM_REF:
3964
    case MEM_REF:
3965
      if (!is_gimple_reg (lhs)
3966
          && is_gimple_reg_type (TREE_TYPE (lhs)))
3967
        {
3968
          error ("invalid rhs for gimple memory store");
3969
          debug_generic_stmt (lhs);
3970
          debug_generic_stmt (rhs1);
3971
          return true;
3972
        }
3973
      return res || verify_types_in_gimple_reference (rhs1, false);
3974
 
3975
    /* tcc_constant  */
3976
    case SSA_NAME:
3977
    case INTEGER_CST:
3978
    case REAL_CST:
3979
    case FIXED_CST:
3980
    case COMPLEX_CST:
3981
    case VECTOR_CST:
3982
    case STRING_CST:
3983
      return res;
3984
 
3985
    /* tcc_declaration  */
3986
    case CONST_DECL:
3987
      return res;
3988
    case VAR_DECL:
3989
    case PARM_DECL:
3990
      if (!is_gimple_reg (lhs)
3991
          && !is_gimple_reg (rhs1)
3992
          && is_gimple_reg_type (TREE_TYPE (lhs)))
3993
        {
3994
          error ("invalid rhs for gimple memory store");
3995
          debug_generic_stmt (lhs);
3996
          debug_generic_stmt (rhs1);
3997
          return true;
3998
        }
3999
      return res;
4000
 
4001
    case CONSTRUCTOR:
4002
    case OBJ_TYPE_REF:
4003
    case ASSERT_EXPR:
4004
    case WITH_SIZE_EXPR:
4005
      /* FIXME.  */
4006
      return res;
4007
 
4008
    default:;
4009
    }
4010
 
4011
  return res;
4012
}
4013
 
4014
/* Verify the contents of a GIMPLE_ASSIGN STMT.  Returns true when there
4015
   is a problem, otherwise false.  */
4016
 
4017
static bool
4018
verify_gimple_assign (gimple stmt)
4019
{
4020
  switch (gimple_assign_rhs_class (stmt))
4021
    {
4022
    case GIMPLE_SINGLE_RHS:
4023
      return verify_gimple_assign_single (stmt);
4024
 
4025
    case GIMPLE_UNARY_RHS:
4026
      return verify_gimple_assign_unary (stmt);
4027
 
4028
    case GIMPLE_BINARY_RHS:
4029
      return verify_gimple_assign_binary (stmt);
4030
 
4031
    case GIMPLE_TERNARY_RHS:
4032
      return verify_gimple_assign_ternary (stmt);
4033
 
4034
    default:
4035
      gcc_unreachable ();
4036
    }
4037
}
4038
 
4039
/* Verify the contents of a GIMPLE_RETURN STMT.  Returns true when there
4040
   is a problem, otherwise false.  */
4041
 
4042
static bool
4043
verify_gimple_return (gimple stmt)
4044
{
4045
  tree op = gimple_return_retval (stmt);
4046
  tree restype = TREE_TYPE (TREE_TYPE (cfun->decl));
4047
 
4048
  /* We cannot test for present return values as we do not fix up missing
4049
     return values from the original source.  */
4050
  if (op == NULL)
4051
    return false;
4052
 
4053
  if (!is_gimple_val (op)
4054
      && TREE_CODE (op) != RESULT_DECL)
4055
    {
4056
      error ("invalid operand in return statement");
4057
      debug_generic_stmt (op);
4058
      return true;
4059
    }
4060
 
4061
  if ((TREE_CODE (op) == RESULT_DECL
4062
       && DECL_BY_REFERENCE (op))
4063
      || (TREE_CODE (op) == SSA_NAME
4064
          && TREE_CODE (SSA_NAME_VAR (op)) == RESULT_DECL
4065
          && DECL_BY_REFERENCE (SSA_NAME_VAR (op))))
4066
    op = TREE_TYPE (op);
4067
 
4068
  if (!useless_type_conversion_p (restype, TREE_TYPE (op)))
4069
    {
4070
      error ("invalid conversion in return statement");
4071
      debug_generic_stmt (restype);
4072
      debug_generic_stmt (TREE_TYPE (op));
4073
      return true;
4074
    }
4075
 
4076
  return false;
4077
}
4078
 
4079
 
4080
/* Verify the contents of a GIMPLE_GOTO STMT.  Returns true when there
4081
   is a problem, otherwise false.  */
4082
 
4083
static bool
4084
verify_gimple_goto (gimple stmt)
4085
{
4086
  tree dest = gimple_goto_dest (stmt);
4087
 
4088
  /* ???  We have two canonical forms of direct goto destinations, a
4089
     bare LABEL_DECL and an ADDR_EXPR of a LABEL_DECL.  */
4090
  if (TREE_CODE (dest) != LABEL_DECL
4091
      && (!is_gimple_val (dest)
4092
          || !POINTER_TYPE_P (TREE_TYPE (dest))))
4093
    {
4094
      error ("goto destination is neither a label nor a pointer");
4095
      return true;
4096
    }
4097
 
4098
  return false;
4099
}
4100
 
4101
/* Verify the contents of a GIMPLE_SWITCH STMT.  Returns true when there
4102
   is a problem, otherwise false.  */
4103
 
4104
static bool
4105
verify_gimple_switch (gimple stmt)
4106
{
4107
  if (!is_gimple_val (gimple_switch_index (stmt)))
4108
    {
4109
      error ("invalid operand to switch statement");
4110
      debug_generic_stmt (gimple_switch_index (stmt));
4111
      return true;
4112
    }
4113
 
4114
  return false;
4115
}
4116
 
4117
/* Verify a gimple debug statement STMT.
4118
   Returns true if anything is wrong.  */
4119
 
4120
static bool
4121
verify_gimple_debug (gimple stmt ATTRIBUTE_UNUSED)
4122
{
4123
  /* There isn't much that could be wrong in a gimple debug stmt.  A
4124
     gimple debug bind stmt, for example, maps a tree, that's usually
4125
     a VAR_DECL or a PARM_DECL, but that could also be some scalarized
4126
     component or member of an aggregate type, to another tree, that
4127
     can be an arbitrary expression.  These stmts expand into debug
4128
     insns, and are converted to debug notes by var-tracking.c.  */
4129
  return false;
4130
}
4131
 
4132
/* Verify a gimple label statement STMT.
4133
   Returns true if anything is wrong.  */
4134
 
4135
static bool
4136
verify_gimple_label (gimple stmt)
4137
{
4138
  tree decl = gimple_label_label (stmt);
4139
  int uid;
4140
  bool err = false;
4141
 
4142
  if (TREE_CODE (decl) != LABEL_DECL)
4143
    return true;
4144
 
4145
  uid = LABEL_DECL_UID (decl);
4146
  if (cfun->cfg
4147
      && (uid == -1
4148
          || VEC_index (basic_block,
4149
                        label_to_block_map, uid) != gimple_bb (stmt)))
4150
    {
4151
      error ("incorrect entry in label_to_block_map");
4152
      err |= true;
4153
    }
4154
 
4155
  uid = EH_LANDING_PAD_NR (decl);
4156
  if (uid)
4157
    {
4158
      eh_landing_pad lp = get_eh_landing_pad_from_number (uid);
4159
      if (decl != lp->post_landing_pad)
4160
        {
4161
          error ("incorrect setting of landing pad number");
4162
          err |= true;
4163
        }
4164
    }
4165
 
4166
  return err;
4167
}
4168
 
4169
/* Verify the GIMPLE statement STMT.  Returns true if there is an
4170
   error, otherwise false.  */
4171
 
4172
static bool
4173
verify_gimple_stmt (gimple stmt)
4174
{
4175
  switch (gimple_code (stmt))
4176
    {
4177
    case GIMPLE_ASSIGN:
4178
      return verify_gimple_assign (stmt);
4179
 
4180
    case GIMPLE_LABEL:
4181
      return verify_gimple_label (stmt);
4182
 
4183
    case GIMPLE_CALL:
4184
      return verify_gimple_call (stmt);
4185
 
4186
    case GIMPLE_COND:
4187
      if (TREE_CODE_CLASS (gimple_cond_code (stmt)) != tcc_comparison)
4188
        {
4189
          error ("invalid comparison code in gimple cond");
4190
          return true;
4191
        }
4192
      if (!(!gimple_cond_true_label (stmt)
4193
            || TREE_CODE (gimple_cond_true_label (stmt)) == LABEL_DECL)
4194
          || !(!gimple_cond_false_label (stmt)
4195
               || TREE_CODE (gimple_cond_false_label (stmt)) == LABEL_DECL))
4196
        {
4197
          error ("invalid labels in gimple cond");
4198
          return true;
4199
        }
4200
 
4201
      return verify_gimple_comparison (boolean_type_node,
4202
                                       gimple_cond_lhs (stmt),
4203
                                       gimple_cond_rhs (stmt));
4204
 
4205
    case GIMPLE_GOTO:
4206
      return verify_gimple_goto (stmt);
4207
 
4208
    case GIMPLE_SWITCH:
4209
      return verify_gimple_switch (stmt);
4210
 
4211
    case GIMPLE_RETURN:
4212
      return verify_gimple_return (stmt);
4213
 
4214
    case GIMPLE_ASM:
4215
      return false;
4216
 
4217
    case GIMPLE_TRANSACTION:
4218
      return verify_gimple_transaction (stmt);
4219
 
4220
    /* Tuples that do not have tree operands.  */
4221
    case GIMPLE_NOP:
4222
    case GIMPLE_PREDICT:
4223
    case GIMPLE_RESX:
4224
    case GIMPLE_EH_DISPATCH:
4225
    case GIMPLE_EH_MUST_NOT_THROW:
4226
      return false;
4227
 
4228
    CASE_GIMPLE_OMP:
4229
      /* OpenMP directives are validated by the FE and never operated
4230
         on by the optimizers.  Furthermore, GIMPLE_OMP_FOR may contain
4231
         non-gimple expressions when the main index variable has had
4232
         its address taken.  This does not affect the loop itself
4233
         because the header of an GIMPLE_OMP_FOR is merely used to determine
4234
         how to setup the parallel iteration.  */
4235
      return false;
4236
 
4237
    case GIMPLE_DEBUG:
4238
      return verify_gimple_debug (stmt);
4239
 
4240
    default:
4241
      gcc_unreachable ();
4242
    }
4243
}
4244
 
4245
/* Verify the contents of a GIMPLE_PHI.  Returns true if there is a problem,
4246
   and false otherwise.  */
4247
 
4248
static bool
4249
verify_gimple_phi (gimple phi)
4250
{
4251
  bool err = false;
4252
  unsigned i;
4253
  tree phi_result = gimple_phi_result (phi);
4254
  bool virtual_p;
4255
 
4256
  if (!phi_result)
4257
    {
4258
      error ("invalid PHI result");
4259
      return true;
4260
    }
4261
 
4262
  virtual_p = !is_gimple_reg (phi_result);
4263
  if (TREE_CODE (phi_result) != SSA_NAME
4264
      || (virtual_p
4265
          && SSA_NAME_VAR (phi_result) != gimple_vop (cfun)))
4266
    {
4267
      error ("invalid PHI result");
4268
      err = true;
4269
    }
4270
 
4271
  for (i = 0; i < gimple_phi_num_args (phi); i++)
4272
    {
4273
      tree t = gimple_phi_arg_def (phi, i);
4274
 
4275
      if (!t)
4276
        {
4277
          error ("missing PHI def");
4278
          err |= true;
4279
          continue;
4280
        }
4281
      /* Addressable variables do have SSA_NAMEs but they
4282
         are not considered gimple values.  */
4283
      else if ((TREE_CODE (t) == SSA_NAME
4284
                && virtual_p != !is_gimple_reg (t))
4285
               || (virtual_p
4286
                   && (TREE_CODE (t) != SSA_NAME
4287
                       || SSA_NAME_VAR (t) != gimple_vop (cfun)))
4288
               || (!virtual_p
4289
                   && !is_gimple_val (t)))
4290
        {
4291
          error ("invalid PHI argument");
4292
          debug_generic_expr (t);
4293
          err |= true;
4294
        }
4295
#ifdef ENABLE_TYPES_CHECKING
4296
      if (!useless_type_conversion_p (TREE_TYPE (phi_result), TREE_TYPE (t)))
4297
        {
4298
          error ("incompatible types in PHI argument %u", i);
4299
          debug_generic_stmt (TREE_TYPE (phi_result));
4300
          debug_generic_stmt (TREE_TYPE (t));
4301
          err |= true;
4302
        }
4303
#endif
4304
    }
4305
 
4306
  return err;
4307
}
4308
 
4309
/* Verify the GIMPLE statements inside the sequence STMTS.  */
4310
 
4311
static bool
4312
verify_gimple_in_seq_2 (gimple_seq stmts)
4313
{
4314
  gimple_stmt_iterator ittr;
4315
  bool err = false;
4316
 
4317
  for (ittr = gsi_start (stmts); !gsi_end_p (ittr); gsi_next (&ittr))
4318
    {
4319
      gimple stmt = gsi_stmt (ittr);
4320
 
4321
      switch (gimple_code (stmt))
4322
        {
4323
        case GIMPLE_BIND:
4324
          err |= verify_gimple_in_seq_2 (gimple_bind_body (stmt));
4325
          break;
4326
 
4327
        case GIMPLE_TRY:
4328
          err |= verify_gimple_in_seq_2 (gimple_try_eval (stmt));
4329
          err |= verify_gimple_in_seq_2 (gimple_try_cleanup (stmt));
4330
          break;
4331
 
4332
        case GIMPLE_EH_FILTER:
4333
          err |= verify_gimple_in_seq_2 (gimple_eh_filter_failure (stmt));
4334
          break;
4335
 
4336
        case GIMPLE_EH_ELSE:
4337
          err |= verify_gimple_in_seq_2 (gimple_eh_else_n_body (stmt));
4338
          err |= verify_gimple_in_seq_2 (gimple_eh_else_e_body (stmt));
4339
          break;
4340
 
4341
        case GIMPLE_CATCH:
4342
          err |= verify_gimple_in_seq_2 (gimple_catch_handler (stmt));
4343
          break;
4344
 
4345
        case GIMPLE_TRANSACTION:
4346
          err |= verify_gimple_transaction (stmt);
4347
          break;
4348
 
4349
        default:
4350
          {
4351
            bool err2 = verify_gimple_stmt (stmt);
4352
            if (err2)
4353
              debug_gimple_stmt (stmt);
4354
            err |= err2;
4355
          }
4356
        }
4357
    }
4358
 
4359
  return err;
4360
}
4361
 
4362
/* Verify the contents of a GIMPLE_TRANSACTION.  Returns true if there
4363
   is a problem, otherwise false.  */
4364
 
4365
static bool
4366
verify_gimple_transaction (gimple stmt)
4367
{
4368
  tree lab = gimple_transaction_label (stmt);
4369
  if (lab != NULL && TREE_CODE (lab) != LABEL_DECL)
4370
    return true;
4371
  return verify_gimple_in_seq_2 (gimple_transaction_body (stmt));
4372
}
4373
 
4374
 
4375
/* Verify the GIMPLE statements inside the statement list STMTS.  */
4376
 
4377
DEBUG_FUNCTION void
4378
verify_gimple_in_seq (gimple_seq stmts)
4379
{
4380
  timevar_push (TV_TREE_STMT_VERIFY);
4381
  if (verify_gimple_in_seq_2 (stmts))
4382
    internal_error ("verify_gimple failed");
4383
  timevar_pop (TV_TREE_STMT_VERIFY);
4384
}
4385
 
4386
/* Return true when the T can be shared.  */
4387
 
4388
bool
4389
tree_node_can_be_shared (tree t)
4390
{
4391
  if (IS_TYPE_OR_DECL_P (t)
4392
      || is_gimple_min_invariant (t)
4393
      || TREE_CODE (t) == SSA_NAME
4394
      || t == error_mark_node
4395
      || TREE_CODE (t) == IDENTIFIER_NODE)
4396
    return true;
4397
 
4398
  if (TREE_CODE (t) == CASE_LABEL_EXPR)
4399
    return true;
4400
 
4401
  while (((TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
4402
           && is_gimple_min_invariant (TREE_OPERAND (t, 1)))
4403
         || TREE_CODE (t) == COMPONENT_REF
4404
         || TREE_CODE (t) == REALPART_EXPR
4405
         || TREE_CODE (t) == IMAGPART_EXPR)
4406
    t = TREE_OPERAND (t, 0);
4407
 
4408
  if (DECL_P (t))
4409
    return true;
4410
 
4411
  return false;
4412
}
4413
 
4414
/* Called via walk_gimple_stmt.  Verify tree sharing.  */
4415
 
4416
static tree
4417
verify_node_sharing (tree *tp, int *walk_subtrees, void *data)
4418
{
4419
  struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
4420
  struct pointer_set_t *visited = (struct pointer_set_t *) wi->info;
4421
 
4422
  if (tree_node_can_be_shared (*tp))
4423
    {
4424
      *walk_subtrees = false;
4425
      return NULL;
4426
    }
4427
 
4428
  if (pointer_set_insert (visited, *tp))
4429
    return *tp;
4430
 
4431
  return NULL;
4432
}
4433
 
4434
static bool eh_error_found;
4435
static int
4436
verify_eh_throw_stmt_node (void **slot, void *data)
4437
{
4438
  struct throw_stmt_node *node = (struct throw_stmt_node *)*slot;
4439
  struct pointer_set_t *visited = (struct pointer_set_t *) data;
4440
 
4441
  if (!pointer_set_contains (visited, node->stmt))
4442
    {
4443
      error ("dead STMT in EH table");
4444
      debug_gimple_stmt (node->stmt);
4445
      eh_error_found = true;
4446
    }
4447
  return 1;
4448
}
4449
 
4450
/* Verify the GIMPLE statements in the CFG of FN.  */
4451
 
4452
DEBUG_FUNCTION void
4453
verify_gimple_in_cfg (struct function *fn)
4454
{
4455
  basic_block bb;
4456
  bool err = false;
4457
  struct pointer_set_t *visited, *visited_stmts;
4458
 
4459
  timevar_push (TV_TREE_STMT_VERIFY);
4460
  visited = pointer_set_create ();
4461
  visited_stmts = pointer_set_create ();
4462
 
4463
  FOR_EACH_BB_FN (bb, fn)
4464
    {
4465
      gimple_stmt_iterator gsi;
4466
 
4467
      for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
4468
        {
4469
          gimple phi = gsi_stmt (gsi);
4470
          bool err2 = false;
4471
          unsigned i;
4472
 
4473
          pointer_set_insert (visited_stmts, phi);
4474
 
4475
          if (gimple_bb (phi) != bb)
4476
            {
4477
              error ("gimple_bb (phi) is set to a wrong basic block");
4478
              err2 = true;
4479
            }
4480
 
4481
          err2 |= verify_gimple_phi (phi);
4482
 
4483
          for (i = 0; i < gimple_phi_num_args (phi); i++)
4484
            {
4485
              tree arg = gimple_phi_arg_def (phi, i);
4486
              tree addr = walk_tree (&arg, verify_node_sharing, visited, NULL);
4487
              if (addr)
4488
                {
4489
                  error ("incorrect sharing of tree nodes");
4490
                  debug_generic_expr (addr);
4491
                  err2 |= true;
4492
                }
4493
            }
4494
 
4495
          if (err2)
4496
            debug_gimple_stmt (phi);
4497
          err |= err2;
4498
        }
4499
 
4500
      for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
4501
        {
4502
          gimple stmt = gsi_stmt (gsi);
4503
          bool err2 = false;
4504
          struct walk_stmt_info wi;
4505
          tree addr;
4506
          int lp_nr;
4507
 
4508
          pointer_set_insert (visited_stmts, stmt);
4509
 
4510
          if (gimple_bb (stmt) != bb)
4511
            {
4512
              error ("gimple_bb (stmt) is set to a wrong basic block");
4513
              err2 = true;
4514
            }
4515
 
4516
          err2 |= verify_gimple_stmt (stmt);
4517
 
4518
          memset (&wi, 0, sizeof (wi));
4519
          wi.info = (void *) visited;
4520
          addr = walk_gimple_op (stmt, verify_node_sharing, &wi);
4521
          if (addr)
4522
            {
4523
              error ("incorrect sharing of tree nodes");
4524
              debug_generic_expr (addr);
4525
              err2 |= true;
4526
            }
4527
 
4528
          /* ???  Instead of not checking these stmts at all the walker
4529
             should know its context via wi.  */
4530
          if (!is_gimple_debug (stmt)
4531
              && !is_gimple_omp (stmt))
4532
            {
4533
              memset (&wi, 0, sizeof (wi));
4534
              addr = walk_gimple_op (stmt, verify_expr, &wi);
4535
              if (addr)
4536
                {
4537
                  debug_generic_expr (addr);
4538
                  inform (gimple_location (stmt), "in statement");
4539
                  err2 |= true;
4540
                }
4541
            }
4542
 
4543
          /* If the statement is marked as part of an EH region, then it is
4544
             expected that the statement could throw.  Verify that when we
4545
             have optimizations that simplify statements such that we prove
4546
             that they cannot throw, that we update other data structures
4547
             to match.  */
4548
          lp_nr = lookup_stmt_eh_lp (stmt);
4549
          if (lp_nr != 0)
4550
            {
4551
              if (!stmt_could_throw_p (stmt))
4552
                {
4553
                  error ("statement marked for throw, but doesn%'t");
4554
                  err2 |= true;
4555
                }
4556
              else if (lp_nr > 0
4557
                       && !gsi_one_before_end_p (gsi)
4558
                       && stmt_can_throw_internal (stmt))
4559
                {
4560
                  error ("statement marked for throw in middle of block");
4561
                  err2 |= true;
4562
                }
4563
            }
4564
 
4565
          if (err2)
4566
            debug_gimple_stmt (stmt);
4567
          err |= err2;
4568
        }
4569
    }
4570
 
4571
  eh_error_found = false;
4572
  if (get_eh_throw_stmt_table (cfun))
4573
    htab_traverse (get_eh_throw_stmt_table (cfun),
4574
                   verify_eh_throw_stmt_node,
4575
                   visited_stmts);
4576
 
4577
  if (err || eh_error_found)
4578
    internal_error ("verify_gimple failed");
4579
 
4580
  pointer_set_destroy (visited);
4581
  pointer_set_destroy (visited_stmts);
4582
  verify_histograms ();
4583
  timevar_pop (TV_TREE_STMT_VERIFY);
4584
}
4585
 
4586
 
4587
/* Verifies that the flow information is OK.  */
4588
 
4589
static int
4590
gimple_verify_flow_info (void)
4591
{
4592
  int err = 0;
4593
  basic_block bb;
4594
  gimple_stmt_iterator gsi;
4595
  gimple stmt;
4596
  edge e;
4597
  edge_iterator ei;
4598
 
4599
  if (ENTRY_BLOCK_PTR->il.gimple)
4600
    {
4601
      error ("ENTRY_BLOCK has IL associated with it");
4602
      err = 1;
4603
    }
4604
 
4605
  if (EXIT_BLOCK_PTR->il.gimple)
4606
    {
4607
      error ("EXIT_BLOCK has IL associated with it");
4608
      err = 1;
4609
    }
4610
 
4611
  FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
4612
    if (e->flags & EDGE_FALLTHRU)
4613
      {
4614
        error ("fallthru to exit from bb %d", e->src->index);
4615
        err = 1;
4616
      }
4617
 
4618
  FOR_EACH_BB (bb)
4619
    {
4620
      bool found_ctrl_stmt = false;
4621
 
4622
      stmt = NULL;
4623
 
4624
      /* Skip labels on the start of basic block.  */
4625
      for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
4626
        {
4627
          tree label;
4628
          gimple prev_stmt = stmt;
4629
 
4630
          stmt = gsi_stmt (gsi);
4631
 
4632
          if (gimple_code (stmt) != GIMPLE_LABEL)
4633
            break;
4634
 
4635
          label = gimple_label_label (stmt);
4636
          if (prev_stmt && DECL_NONLOCAL (label))
4637
            {
4638
              error ("nonlocal label ");
4639
              print_generic_expr (stderr, label, 0);
4640
              fprintf (stderr, " is not first in a sequence of labels in bb %d",
4641
                       bb->index);
4642
              err = 1;
4643
            }
4644
 
4645
          if (prev_stmt && EH_LANDING_PAD_NR (label) != 0)
4646
            {
4647
              error ("EH landing pad label ");
4648
              print_generic_expr (stderr, label, 0);
4649
              fprintf (stderr, " is not first in a sequence of labels in bb %d",
4650
                       bb->index);
4651
              err = 1;
4652
            }
4653
 
4654
          if (label_to_block (label) != bb)
4655
            {
4656
              error ("label ");
4657
              print_generic_expr (stderr, label, 0);
4658
              fprintf (stderr, " to block does not match in bb %d",
4659
                       bb->index);
4660
              err = 1;
4661
            }
4662
 
4663
          if (decl_function_context (label) != current_function_decl)
4664
            {
4665
              error ("label ");
4666
              print_generic_expr (stderr, label, 0);
4667
              fprintf (stderr, " has incorrect context in bb %d",
4668
                       bb->index);
4669
              err = 1;
4670
            }
4671
        }
4672
 
4673
      /* Verify that body of basic block BB is free of control flow.  */
4674
      for (; !gsi_end_p (gsi); gsi_next (&gsi))
4675
        {
4676
          gimple stmt = gsi_stmt (gsi);
4677
 
4678
          if (found_ctrl_stmt)
4679
            {
4680
              error ("control flow in the middle of basic block %d",
4681
                     bb->index);
4682
              err = 1;
4683
            }
4684
 
4685
          if (stmt_ends_bb_p (stmt))
4686
            found_ctrl_stmt = true;
4687
 
4688
          if (gimple_code (stmt) == GIMPLE_LABEL)
4689
            {
4690
              error ("label ");
4691
              print_generic_expr (stderr, gimple_label_label (stmt), 0);
4692
              fprintf (stderr, " in the middle of basic block %d", bb->index);
4693
              err = 1;
4694
            }
4695
        }
4696
 
4697
      gsi = gsi_last_bb (bb);
4698
      if (gsi_end_p (gsi))
4699
        continue;
4700
 
4701
      stmt = gsi_stmt (gsi);
4702
 
4703
      if (gimple_code (stmt) == GIMPLE_LABEL)
4704
        continue;
4705
 
4706
      err |= verify_eh_edges (stmt);
4707
 
4708
      if (is_ctrl_stmt (stmt))
4709
        {
4710
          FOR_EACH_EDGE (e, ei, bb->succs)
4711
            if (e->flags & EDGE_FALLTHRU)
4712
              {
4713
                error ("fallthru edge after a control statement in bb %d",
4714
                       bb->index);
4715
                err = 1;
4716
              }
4717
        }
4718
 
4719
      if (gimple_code (stmt) != GIMPLE_COND)
4720
        {
4721
          /* Verify that there are no edges with EDGE_TRUE/FALSE_FLAG set
4722
             after anything else but if statement.  */
4723
          FOR_EACH_EDGE (e, ei, bb->succs)
4724
            if (e->flags & (EDGE_TRUE_VALUE | EDGE_FALSE_VALUE))
4725
              {
4726
                error ("true/false edge after a non-GIMPLE_COND in bb %d",
4727
                       bb->index);
4728
                err = 1;
4729
              }
4730
        }
4731
 
4732
      switch (gimple_code (stmt))
4733
        {
4734
        case GIMPLE_COND:
4735
          {
4736
            edge true_edge;
4737
            edge false_edge;
4738
 
4739
            extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
4740
 
4741
            if (!true_edge
4742
                || !false_edge
4743
                || !(true_edge->flags & EDGE_TRUE_VALUE)
4744
                || !(false_edge->flags & EDGE_FALSE_VALUE)
4745
                || (true_edge->flags & (EDGE_FALLTHRU | EDGE_ABNORMAL))
4746
                || (false_edge->flags & (EDGE_FALLTHRU | EDGE_ABNORMAL))
4747
                || EDGE_COUNT (bb->succs) >= 3)
4748
              {
4749
                error ("wrong outgoing edge flags at end of bb %d",
4750
                       bb->index);
4751
                err = 1;
4752
              }
4753
          }
4754
          break;
4755
 
4756
        case GIMPLE_GOTO:
4757
          if (simple_goto_p (stmt))
4758
            {
4759
              error ("explicit goto at end of bb %d", bb->index);
4760
              err = 1;
4761
            }
4762
          else
4763
            {
4764
              /* FIXME.  We should double check that the labels in the
4765
                 destination blocks have their address taken.  */
4766
              FOR_EACH_EDGE (e, ei, bb->succs)
4767
                if ((e->flags & (EDGE_FALLTHRU | EDGE_TRUE_VALUE
4768
                                 | EDGE_FALSE_VALUE))
4769
                    || !(e->flags & EDGE_ABNORMAL))
4770
                  {
4771
                    error ("wrong outgoing edge flags at end of bb %d",
4772
                           bb->index);
4773
                    err = 1;
4774
                  }
4775
            }
4776
          break;
4777
 
4778
        case GIMPLE_CALL:
4779
          if (!gimple_call_builtin_p (stmt, BUILT_IN_RETURN))
4780
            break;
4781
          /* ... fallthru ... */
4782
        case GIMPLE_RETURN:
4783
          if (!single_succ_p (bb)
4784
              || (single_succ_edge (bb)->flags
4785
                  & (EDGE_FALLTHRU | EDGE_ABNORMAL
4786
                     | EDGE_TRUE_VALUE | EDGE_FALSE_VALUE)))
4787
            {
4788
              error ("wrong outgoing edge flags at end of bb %d", bb->index);
4789
              err = 1;
4790
            }
4791
          if (single_succ (bb) != EXIT_BLOCK_PTR)
4792
            {
4793
              error ("return edge does not point to exit in bb %d",
4794
                     bb->index);
4795
              err = 1;
4796
            }
4797
          break;
4798
 
4799
        case GIMPLE_SWITCH:
4800
          {
4801
            tree prev;
4802
            edge e;
4803
            size_t i, n;
4804
 
4805
            n = gimple_switch_num_labels (stmt);
4806
 
4807
            /* Mark all the destination basic blocks.  */
4808
            for (i = 0; i < n; ++i)
4809
              {
4810
                tree lab = CASE_LABEL (gimple_switch_label (stmt, i));
4811
                basic_block label_bb = label_to_block (lab);
4812
                gcc_assert (!label_bb->aux || label_bb->aux == (void *)1);
4813
                label_bb->aux = (void *)1;
4814
              }
4815
 
4816
            /* Verify that the case labels are sorted.  */
4817
            prev = gimple_switch_label (stmt, 0);
4818
            for (i = 1; i < n; ++i)
4819
              {
4820
                tree c = gimple_switch_label (stmt, i);
4821
                if (!CASE_LOW (c))
4822
                  {
4823
                    error ("found default case not at the start of "
4824
                           "case vector");
4825
                    err = 1;
4826
                    continue;
4827
                  }
4828
                if (CASE_LOW (prev)
4829
                    && !tree_int_cst_lt (CASE_LOW (prev), CASE_LOW (c)))
4830
                  {
4831
                    error ("case labels not sorted: ");
4832
                    print_generic_expr (stderr, prev, 0);
4833
                    fprintf (stderr," is greater than ");
4834
                    print_generic_expr (stderr, c, 0);
4835
                    fprintf (stderr," but comes before it.\n");
4836
                    err = 1;
4837
                  }
4838
                prev = c;
4839
              }
4840
            /* VRP will remove the default case if it can prove it will
4841
               never be executed.  So do not verify there always exists
4842
               a default case here.  */
4843
 
4844
            FOR_EACH_EDGE (e, ei, bb->succs)
4845
              {
4846
                if (!e->dest->aux)
4847
                  {
4848
                    error ("extra outgoing edge %d->%d",
4849
                           bb->index, e->dest->index);
4850
                    err = 1;
4851
                  }
4852
 
4853
                e->dest->aux = (void *)2;
4854
                if ((e->flags & (EDGE_FALLTHRU | EDGE_ABNORMAL
4855
                                 | EDGE_TRUE_VALUE | EDGE_FALSE_VALUE)))
4856
                  {
4857
                    error ("wrong outgoing edge flags at end of bb %d",
4858
                           bb->index);
4859
                    err = 1;
4860
                  }
4861
              }
4862
 
4863
            /* Check that we have all of them.  */
4864
            for (i = 0; i < n; ++i)
4865
              {
4866
                tree lab = CASE_LABEL (gimple_switch_label (stmt, i));
4867
                basic_block label_bb = label_to_block (lab);
4868
 
4869
                if (label_bb->aux != (void *)2)
4870
                  {
4871
                    error ("missing edge %i->%i", bb->index, label_bb->index);
4872
                    err = 1;
4873
                  }
4874
              }
4875
 
4876
            FOR_EACH_EDGE (e, ei, bb->succs)
4877
              e->dest->aux = (void *)0;
4878
          }
4879
          break;
4880
 
4881
        case GIMPLE_EH_DISPATCH:
4882
          err |= verify_eh_dispatch_edge (stmt);
4883
          break;
4884
 
4885
        default:
4886
          break;
4887
        }
4888
    }
4889
 
4890
  if (dom_info_state (CDI_DOMINATORS) >= DOM_NO_FAST_QUERY)
4891
    verify_dominators (CDI_DOMINATORS);
4892
 
4893
  return err;
4894
}
4895
 
4896
 
4897
/* Updates phi nodes after creating a forwarder block joined
4898
   by edge FALLTHRU.  */
4899
 
4900
static void
4901
gimple_make_forwarder_block (edge fallthru)
4902
{
4903
  edge e;
4904
  edge_iterator ei;
4905
  basic_block dummy, bb;
4906
  tree var;
4907
  gimple_stmt_iterator gsi;
4908
 
4909
  dummy = fallthru->src;
4910
  bb = fallthru->dest;
4911
 
4912
  if (single_pred_p (bb))
4913
    return;
4914
 
4915
  /* If we redirected a branch we must create new PHI nodes at the
4916
     start of BB.  */
4917
  for (gsi = gsi_start_phis (dummy); !gsi_end_p (gsi); gsi_next (&gsi))
4918
    {
4919
      gimple phi, new_phi;
4920
 
4921
      phi = gsi_stmt (gsi);
4922
      var = gimple_phi_result (phi);
4923
      new_phi = create_phi_node (var, bb);
4924
      SSA_NAME_DEF_STMT (var) = new_phi;
4925
      gimple_phi_set_result (phi, make_ssa_name (SSA_NAME_VAR (var), phi));
4926
      add_phi_arg (new_phi, gimple_phi_result (phi), fallthru,
4927
                   UNKNOWN_LOCATION);
4928
    }
4929
 
4930
  /* Add the arguments we have stored on edges.  */
4931
  FOR_EACH_EDGE (e, ei, bb->preds)
4932
    {
4933
      if (e == fallthru)
4934
        continue;
4935
 
4936
      flush_pending_stmts (e);
4937
    }
4938
}
4939
 
4940
 
4941
/* Return a non-special label in the head of basic block BLOCK.
4942
   Create one if it doesn't exist.  */
4943
 
4944
tree
4945
gimple_block_label (basic_block bb)
4946
{
4947
  gimple_stmt_iterator i, s = gsi_start_bb (bb);
4948
  bool first = true;
4949
  tree label;
4950
  gimple stmt;
4951
 
4952
  for (i = s; !gsi_end_p (i); first = false, gsi_next (&i))
4953
    {
4954
      stmt = gsi_stmt (i);
4955
      if (gimple_code (stmt) != GIMPLE_LABEL)
4956
        break;
4957
      label = gimple_label_label (stmt);
4958
      if (!DECL_NONLOCAL (label))
4959
        {
4960
          if (!first)
4961
            gsi_move_before (&i, &s);
4962
          return label;
4963
        }
4964
    }
4965
 
4966
  label = create_artificial_label (UNKNOWN_LOCATION);
4967
  stmt = gimple_build_label (label);
4968
  gsi_insert_before (&s, stmt, GSI_NEW_STMT);
4969
  return label;
4970
}
4971
 
4972
 
4973
/* Attempt to perform edge redirection by replacing a possibly complex
4974
   jump instruction by a goto or by removing the jump completely.
4975
   This can apply only if all edges now point to the same block.  The
4976
   parameters and return values are equivalent to
4977
   redirect_edge_and_branch.  */
4978
 
4979
static edge
4980
gimple_try_redirect_by_replacing_jump (edge e, basic_block target)
4981
{
4982
  basic_block src = e->src;
4983
  gimple_stmt_iterator i;
4984
  gimple stmt;
4985
 
4986
  /* We can replace or remove a complex jump only when we have exactly
4987
     two edges.  */
4988
  if (EDGE_COUNT (src->succs) != 2
4989
      /* Verify that all targets will be TARGET.  Specifically, the
4990
         edge that is not E must also go to TARGET.  */
4991
      || EDGE_SUCC (src, EDGE_SUCC (src, 0) == e)->dest != target)
4992
    return NULL;
4993
 
4994
  i = gsi_last_bb (src);
4995
  if (gsi_end_p (i))
4996
    return NULL;
4997
 
4998
  stmt = gsi_stmt (i);
4999
 
5000
  if (gimple_code (stmt) == GIMPLE_COND || gimple_code (stmt) == GIMPLE_SWITCH)
5001
    {
5002
      gsi_remove (&i, true);
5003
      e = ssa_redirect_edge (e, target);
5004
      e->flags = EDGE_FALLTHRU;
5005
      return e;
5006
    }
5007
 
5008
  return NULL;
5009
}
5010
 
5011
 
5012
/* Redirect E to DEST.  Return NULL on failure.  Otherwise, return the
5013
   edge representing the redirected branch.  */
5014
 
5015
static edge
5016
gimple_redirect_edge_and_branch (edge e, basic_block dest)
5017
{
5018
  basic_block bb = e->src;
5019
  gimple_stmt_iterator gsi;
5020
  edge ret;
5021
  gimple stmt;
5022
 
5023
  if (e->flags & EDGE_ABNORMAL)
5024
    return NULL;
5025
 
5026
  if (e->dest == dest)
5027
    return NULL;
5028
 
5029
  if (e->flags & EDGE_EH)
5030
    return redirect_eh_edge (e, dest);
5031
 
5032
  if (e->src != ENTRY_BLOCK_PTR)
5033
    {
5034
      ret = gimple_try_redirect_by_replacing_jump (e, dest);
5035
      if (ret)
5036
        return ret;
5037
    }
5038
 
5039
  gsi = gsi_last_bb (bb);
5040
  stmt = gsi_end_p (gsi) ? NULL : gsi_stmt (gsi);
5041
 
5042
  switch (stmt ? gimple_code (stmt) : GIMPLE_ERROR_MARK)
5043
    {
5044
    case GIMPLE_COND:
5045
      /* For COND_EXPR, we only need to redirect the edge.  */
5046
      break;
5047
 
5048
    case GIMPLE_GOTO:
5049
      /* No non-abnormal edges should lead from a non-simple goto, and
5050
         simple ones should be represented implicitly.  */
5051
      gcc_unreachable ();
5052
 
5053
    case GIMPLE_SWITCH:
5054
      {
5055
        tree label = gimple_block_label (dest);
5056
        tree cases = get_cases_for_edge (e, stmt);
5057
 
5058
        /* If we have a list of cases associated with E, then use it
5059
           as it's a lot faster than walking the entire case vector.  */
5060
        if (cases)
5061
          {
5062
            edge e2 = find_edge (e->src, dest);
5063
            tree last, first;
5064
 
5065
            first = cases;
5066
            while (cases)
5067
              {
5068
                last = cases;
5069
                CASE_LABEL (cases) = label;
5070
                cases = CASE_CHAIN (cases);
5071
              }
5072
 
5073
            /* If there was already an edge in the CFG, then we need
5074
               to move all the cases associated with E to E2.  */
5075
            if (e2)
5076
              {
5077
                tree cases2 = get_cases_for_edge (e2, stmt);
5078
 
5079
                CASE_CHAIN (last) = CASE_CHAIN (cases2);
5080
                CASE_CHAIN (cases2) = first;
5081
              }
5082
            bitmap_set_bit (touched_switch_bbs, gimple_bb (stmt)->index);
5083
          }
5084
        else
5085
          {
5086
            size_t i, n = gimple_switch_num_labels (stmt);
5087
 
5088
            for (i = 0; i < n; i++)
5089
              {
5090
                tree elt = gimple_switch_label (stmt, i);
5091
                if (label_to_block (CASE_LABEL (elt)) == e->dest)
5092
                  CASE_LABEL (elt) = label;
5093
              }
5094
          }
5095
      }
5096
      break;
5097
 
5098
    case GIMPLE_ASM:
5099
      {
5100
        int i, n = gimple_asm_nlabels (stmt);
5101
        tree label = NULL;
5102
 
5103
        for (i = 0; i < n; ++i)
5104
          {
5105
            tree cons = gimple_asm_label_op (stmt, i);
5106
            if (label_to_block (TREE_VALUE (cons)) == e->dest)
5107
              {
5108
                if (!label)
5109
                  label = gimple_block_label (dest);
5110
                TREE_VALUE (cons) = label;
5111
              }
5112
          }
5113
 
5114
        /* If we didn't find any label matching the former edge in the
5115
           asm labels, we must be redirecting the fallthrough
5116
           edge.  */
5117
        gcc_assert (label || (e->flags & EDGE_FALLTHRU));
5118
      }
5119
      break;
5120
 
5121
    case GIMPLE_RETURN:
5122
      gsi_remove (&gsi, true);
5123
      e->flags |= EDGE_FALLTHRU;
5124
      break;
5125
 
5126
    case GIMPLE_OMP_RETURN:
5127
    case GIMPLE_OMP_CONTINUE:
5128
    case GIMPLE_OMP_SECTIONS_SWITCH:
5129
    case GIMPLE_OMP_FOR:
5130
      /* The edges from OMP constructs can be simply redirected.  */
5131
      break;
5132
 
5133
    case GIMPLE_EH_DISPATCH:
5134
      if (!(e->flags & EDGE_FALLTHRU))
5135
        redirect_eh_dispatch_edge (stmt, e, dest);
5136
      break;
5137
 
5138
    case GIMPLE_TRANSACTION:
5139
      /* The ABORT edge has a stored label associated with it, otherwise
5140
         the edges are simply redirectable.  */
5141
      if (e->flags == 0)
5142
        gimple_transaction_set_label (stmt, gimple_block_label (dest));
5143
      break;
5144
 
5145
    default:
5146
      /* Otherwise it must be a fallthru edge, and we don't need to
5147
         do anything besides redirecting it.  */
5148
      gcc_assert (e->flags & EDGE_FALLTHRU);
5149
      break;
5150
    }
5151
 
5152
  /* Update/insert PHI nodes as necessary.  */
5153
 
5154
  /* Now update the edges in the CFG.  */
5155
  e = ssa_redirect_edge (e, dest);
5156
 
5157
  return e;
5158
}
5159
 
5160
/* Returns true if it is possible to remove edge E by redirecting
5161
   it to the destination of the other edge from E->src.  */
5162
 
5163
static bool
5164
gimple_can_remove_branch_p (const_edge e)
5165
{
5166
  if (e->flags & (EDGE_ABNORMAL | EDGE_EH))
5167
    return false;
5168
 
5169
  return true;
5170
}
5171
 
5172
/* Simple wrapper, as we can always redirect fallthru edges.  */
5173
 
5174
static basic_block
5175
gimple_redirect_edge_and_branch_force (edge e, basic_block dest)
5176
{
5177
  e = gimple_redirect_edge_and_branch (e, dest);
5178
  gcc_assert (e);
5179
 
5180
  return NULL;
5181
}
5182
 
5183
 
5184
/* Splits basic block BB after statement STMT (but at least after the
5185
   labels).  If STMT is NULL, BB is split just after the labels.  */
5186
 
5187
static basic_block
5188
gimple_split_block (basic_block bb, void *stmt)
5189
{
5190
  gimple_stmt_iterator gsi;
5191
  gimple_stmt_iterator gsi_tgt;
5192
  gimple act;
5193
  gimple_seq list;
5194
  basic_block new_bb;
5195
  edge e;
5196
  edge_iterator ei;
5197
 
5198
  new_bb = create_empty_bb (bb);
5199
 
5200
  /* Redirect the outgoing edges.  */
5201
  new_bb->succs = bb->succs;
5202
  bb->succs = NULL;
5203
  FOR_EACH_EDGE (e, ei, new_bb->succs)
5204
    e->src = new_bb;
5205
 
5206
  if (stmt && gimple_code ((gimple) stmt) == GIMPLE_LABEL)
5207
    stmt = NULL;
5208
 
5209
  /* Move everything from GSI to the new basic block.  */
5210
  for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
5211
    {
5212
      act = gsi_stmt (gsi);
5213
      if (gimple_code (act) == GIMPLE_LABEL)
5214
        continue;
5215
 
5216
      if (!stmt)
5217
        break;
5218
 
5219
      if (stmt == act)
5220
        {
5221
          gsi_next (&gsi);
5222
          break;
5223
        }
5224
    }
5225
 
5226
  if (gsi_end_p (gsi))
5227
    return new_bb;
5228
 
5229
  /* Split the statement list - avoid re-creating new containers as this
5230
     brings ugly quadratic memory consumption in the inliner.
5231
     (We are still quadratic since we need to update stmt BB pointers,
5232
     sadly.)  */
5233
  list = gsi_split_seq_before (&gsi);
5234
  set_bb_seq (new_bb, list);
5235
  for (gsi_tgt = gsi_start (list);
5236
       !gsi_end_p (gsi_tgt); gsi_next (&gsi_tgt))
5237
    gimple_set_bb (gsi_stmt (gsi_tgt), new_bb);
5238
 
5239
  return new_bb;
5240
}
5241
 
5242
 
5243
/* Moves basic block BB after block AFTER.  */
5244
 
5245
static bool
5246
gimple_move_block_after (basic_block bb, basic_block after)
5247
{
5248
  if (bb->prev_bb == after)
5249
    return true;
5250
 
5251
  unlink_block (bb);
5252
  link_block (bb, after);
5253
 
5254
  return true;
5255
}
5256
 
5257
 
5258
/* Return true if basic_block can be duplicated.  */
5259
 
5260
static bool
5261
gimple_can_duplicate_bb_p (const_basic_block bb ATTRIBUTE_UNUSED)
5262
{
5263
  return true;
5264
}
5265
 
5266
/* Create a duplicate of the basic block BB.  NOTE: This does not
5267
   preserve SSA form.  */
5268
 
5269
static basic_block
5270
gimple_duplicate_bb (basic_block bb)
5271
{
5272
  basic_block new_bb;
5273
  gimple_stmt_iterator gsi, gsi_tgt;
5274
  gimple_seq phis = phi_nodes (bb);
5275
  gimple phi, stmt, copy;
5276
 
5277
  new_bb = create_empty_bb (EXIT_BLOCK_PTR->prev_bb);
5278
 
5279
  /* Copy the PHI nodes.  We ignore PHI node arguments here because
5280
     the incoming edges have not been setup yet.  */
5281
  for (gsi = gsi_start (phis); !gsi_end_p (gsi); gsi_next (&gsi))
5282
    {
5283
      phi = gsi_stmt (gsi);
5284
      copy = create_phi_node (gimple_phi_result (phi), new_bb);
5285
      create_new_def_for (gimple_phi_result (copy), copy,
5286
                          gimple_phi_result_ptr (copy));
5287
    }
5288
 
5289
  gsi_tgt = gsi_start_bb (new_bb);
5290
  for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
5291
    {
5292
      def_operand_p def_p;
5293
      ssa_op_iter op_iter;
5294
      tree lhs;
5295
 
5296
      stmt = gsi_stmt (gsi);
5297
      if (gimple_code (stmt) == GIMPLE_LABEL)
5298
        continue;
5299
 
5300
      /* Don't duplicate label debug stmts.  */
5301
      if (gimple_debug_bind_p (stmt)
5302
          && TREE_CODE (gimple_debug_bind_get_var (stmt))
5303
             == LABEL_DECL)
5304
        continue;
5305
 
5306
      /* Create a new copy of STMT and duplicate STMT's virtual
5307
         operands.  */
5308
      copy = gimple_copy (stmt);
5309
      gsi_insert_after (&gsi_tgt, copy, GSI_NEW_STMT);
5310
 
5311
      maybe_duplicate_eh_stmt (copy, stmt);
5312
      gimple_duplicate_stmt_histograms (cfun, copy, cfun, stmt);
5313
 
5314
      /* When copying around a stmt writing into a local non-user
5315
         aggregate, make sure it won't share stack slot with other
5316
         vars.  */
5317
      lhs = gimple_get_lhs (stmt);
5318
      if (lhs && TREE_CODE (lhs) != SSA_NAME)
5319
        {
5320
          tree base = get_base_address (lhs);
5321
          if (base
5322
              && (TREE_CODE (base) == VAR_DECL
5323
                  || TREE_CODE (base) == RESULT_DECL)
5324
              && DECL_IGNORED_P (base)
5325
              && !TREE_STATIC (base)
5326
              && !DECL_EXTERNAL (base)
5327
              && (TREE_CODE (base) != VAR_DECL
5328
                  || !DECL_HAS_VALUE_EXPR_P (base)))
5329
            DECL_NONSHAREABLE (base) = 1;
5330
        }
5331
 
5332
      /* Create new names for all the definitions created by COPY and
5333
         add replacement mappings for each new name.  */
5334
      FOR_EACH_SSA_DEF_OPERAND (def_p, copy, op_iter, SSA_OP_ALL_DEFS)
5335
        create_new_def_for (DEF_FROM_PTR (def_p), copy, def_p);
5336
    }
5337
 
5338
  return new_bb;
5339
}
5340
 
5341
/* Adds phi node arguments for edge E_COPY after basic block duplication.  */
5342
 
5343
static void
5344
add_phi_args_after_copy_edge (edge e_copy)
5345
{
5346
  basic_block bb, bb_copy = e_copy->src, dest;
5347
  edge e;
5348
  edge_iterator ei;
5349
  gimple phi, phi_copy;
5350
  tree def;
5351
  gimple_stmt_iterator psi, psi_copy;
5352
 
5353
  if (gimple_seq_empty_p (phi_nodes (e_copy->dest)))
5354
    return;
5355
 
5356
  bb = bb_copy->flags & BB_DUPLICATED ? get_bb_original (bb_copy) : bb_copy;
5357
 
5358
  if (e_copy->dest->flags & BB_DUPLICATED)
5359
    dest = get_bb_original (e_copy->dest);
5360
  else
5361
    dest = e_copy->dest;
5362
 
5363
  e = find_edge (bb, dest);
5364
  if (!e)
5365
    {
5366
      /* During loop unrolling the target of the latch edge is copied.
5367
         In this case we are not looking for edge to dest, but to
5368
         duplicated block whose original was dest.  */
5369
      FOR_EACH_EDGE (e, ei, bb->succs)
5370
        {
5371
          if ((e->dest->flags & BB_DUPLICATED)
5372
              && get_bb_original (e->dest) == dest)
5373
            break;
5374
        }
5375
 
5376
      gcc_assert (e != NULL);
5377
    }
5378
 
5379
  for (psi = gsi_start_phis (e->dest),
5380
       psi_copy = gsi_start_phis (e_copy->dest);
5381
       !gsi_end_p (psi);
5382
       gsi_next (&psi), gsi_next (&psi_copy))
5383
    {
5384
      phi = gsi_stmt (psi);
5385
      phi_copy = gsi_stmt (psi_copy);
5386
      def = PHI_ARG_DEF_FROM_EDGE (phi, e);
5387
      add_phi_arg (phi_copy, def, e_copy,
5388
                   gimple_phi_arg_location_from_edge (phi, e));
5389
    }
5390
}
5391
 
5392
 
5393
/* Basic block BB_COPY was created by code duplication.  Add phi node
5394
   arguments for edges going out of BB_COPY.  The blocks that were
5395
   duplicated have BB_DUPLICATED set.  */
5396
 
5397
void
5398
add_phi_args_after_copy_bb (basic_block bb_copy)
5399
{
5400
  edge e_copy;
5401
  edge_iterator ei;
5402
 
5403
  FOR_EACH_EDGE (e_copy, ei, bb_copy->succs)
5404
    {
5405
      add_phi_args_after_copy_edge (e_copy);
5406
    }
5407
}
5408
 
5409
/* Blocks in REGION_COPY array of length N_REGION were created by
5410
   duplication of basic blocks.  Add phi node arguments for edges
5411
   going from these blocks.  If E_COPY is not NULL, also add
5412
   phi node arguments for its destination.*/
5413
 
5414
void
5415
add_phi_args_after_copy (basic_block *region_copy, unsigned n_region,
5416
                         edge e_copy)
5417
{
5418
  unsigned i;
5419
 
5420
  for (i = 0; i < n_region; i++)
5421
    region_copy[i]->flags |= BB_DUPLICATED;
5422
 
5423
  for (i = 0; i < n_region; i++)
5424
    add_phi_args_after_copy_bb (region_copy[i]);
5425
  if (e_copy)
5426
    add_phi_args_after_copy_edge (e_copy);
5427
 
5428
  for (i = 0; i < n_region; i++)
5429
    region_copy[i]->flags &= ~BB_DUPLICATED;
5430
}
5431
 
5432
/* Duplicates a REGION (set of N_REGION basic blocks) with just a single
5433
   important exit edge EXIT.  By important we mean that no SSA name defined
5434
   inside region is live over the other exit edges of the region.  All entry
5435
   edges to the region must go to ENTRY->dest.  The edge ENTRY is redirected
5436
   to the duplicate of the region.  SSA form, dominance and loop information
5437
   is updated.  The new basic blocks are stored to REGION_COPY in the same
5438
   order as they had in REGION, provided that REGION_COPY is not NULL.
5439
   The function returns false if it is unable to copy the region,
5440
   true otherwise.  */
5441
 
5442
bool
5443
gimple_duplicate_sese_region (edge entry, edge exit,
5444
                            basic_block *region, unsigned n_region,
5445
                            basic_block *region_copy)
5446
{
5447
  unsigned i;
5448
  bool free_region_copy = false, copying_header = false;
5449
  struct loop *loop = entry->dest->loop_father;
5450
  edge exit_copy;
5451
  VEC (basic_block, heap) *doms;
5452
  edge redirected;
5453
  int total_freq = 0, entry_freq = 0;
5454
  gcov_type total_count = 0, entry_count = 0;
5455
 
5456
  if (!can_copy_bbs_p (region, n_region))
5457
    return false;
5458
 
5459
  /* Some sanity checking.  Note that we do not check for all possible
5460
     missuses of the functions.  I.e. if you ask to copy something weird,
5461
     it will work, but the state of structures probably will not be
5462
     correct.  */
5463
  for (i = 0; i < n_region; i++)
5464
    {
5465
      /* We do not handle subloops, i.e. all the blocks must belong to the
5466
         same loop.  */
5467
      if (region[i]->loop_father != loop)
5468
        return false;
5469
 
5470
      if (region[i] != entry->dest
5471
          && region[i] == loop->header)
5472
        return false;
5473
    }
5474
 
5475
  set_loop_copy (loop, loop);
5476
 
5477
  /* In case the function is used for loop header copying (which is the primary
5478
     use), ensure that EXIT and its copy will be new latch and entry edges.  */
5479
  if (loop->header == entry->dest)
5480
    {
5481
      copying_header = true;
5482
      set_loop_copy (loop, loop_outer (loop));
5483
 
5484
      if (!dominated_by_p (CDI_DOMINATORS, loop->latch, exit->src))
5485
        return false;
5486
 
5487
      for (i = 0; i < n_region; i++)
5488
        if (region[i] != exit->src
5489
            && dominated_by_p (CDI_DOMINATORS, region[i], exit->src))
5490
          return false;
5491
    }
5492
 
5493
  if (!region_copy)
5494
    {
5495
      region_copy = XNEWVEC (basic_block, n_region);
5496
      free_region_copy = true;
5497
    }
5498
 
5499
  gcc_assert (!need_ssa_update_p (cfun));
5500
 
5501
  /* Record blocks outside the region that are dominated by something
5502
     inside.  */
5503
  doms = NULL;
5504
  initialize_original_copy_tables ();
5505
 
5506
  doms = get_dominated_by_region (CDI_DOMINATORS, region, n_region);
5507
 
5508
  if (entry->dest->count)
5509
    {
5510
      total_count = entry->dest->count;
5511
      entry_count = entry->count;
5512
      /* Fix up corner cases, to avoid division by zero or creation of negative
5513
         frequencies.  */
5514
      if (entry_count > total_count)
5515
        entry_count = total_count;
5516
    }
5517
  else
5518
    {
5519
      total_freq = entry->dest->frequency;
5520
      entry_freq = EDGE_FREQUENCY (entry);
5521
      /* Fix up corner cases, to avoid division by zero or creation of negative
5522
         frequencies.  */
5523
      if (total_freq == 0)
5524
        total_freq = 1;
5525
      else if (entry_freq > total_freq)
5526
        entry_freq = total_freq;
5527
    }
5528
 
5529
  copy_bbs (region, n_region, region_copy, &exit, 1, &exit_copy, loop,
5530
            split_edge_bb_loc (entry));
5531
  if (total_count)
5532
    {
5533
      scale_bbs_frequencies_gcov_type (region, n_region,
5534
                                       total_count - entry_count,
5535
                                       total_count);
5536
      scale_bbs_frequencies_gcov_type (region_copy, n_region, entry_count,
5537
                                       total_count);
5538
    }
5539
  else
5540
    {
5541
      scale_bbs_frequencies_int (region, n_region, total_freq - entry_freq,
5542
                                 total_freq);
5543
      scale_bbs_frequencies_int (region_copy, n_region, entry_freq, total_freq);
5544
    }
5545
 
5546
  if (copying_header)
5547
    {
5548
      loop->header = exit->dest;
5549
      loop->latch = exit->src;
5550
    }
5551
 
5552
  /* Redirect the entry and add the phi node arguments.  */
5553
  redirected = redirect_edge_and_branch (entry, get_bb_copy (entry->dest));
5554
  gcc_assert (redirected != NULL);
5555
  flush_pending_stmts (entry);
5556
 
5557
  /* Concerning updating of dominators:  We must recount dominators
5558
     for entry block and its copy.  Anything that is outside of the
5559
     region, but was dominated by something inside needs recounting as
5560
     well.  */
5561
  set_immediate_dominator (CDI_DOMINATORS, entry->dest, entry->src);
5562
  VEC_safe_push (basic_block, heap, doms, get_bb_original (entry->dest));
5563
  iterate_fix_dominators (CDI_DOMINATORS, doms, false);
5564
  VEC_free (basic_block, heap, doms);
5565
 
5566
  /* Add the other PHI node arguments.  */
5567
  add_phi_args_after_copy (region_copy, n_region, NULL);
5568
 
5569
  /* Update the SSA web.  */
5570
  update_ssa (TODO_update_ssa);
5571
 
5572
  if (free_region_copy)
5573
    free (region_copy);
5574
 
5575
  free_original_copy_tables ();
5576
  return true;
5577
}
5578
 
5579
/* Duplicates REGION consisting of N_REGION blocks.  The new blocks
5580
   are stored to REGION_COPY in the same order in that they appear
5581
   in REGION, if REGION_COPY is not NULL.  ENTRY is the entry to
5582
   the region, EXIT an exit from it.  The condition guarding EXIT
5583
   is moved to ENTRY.  Returns true if duplication succeeds, false
5584
   otherwise.
5585
 
5586
   For example,
5587
 
5588
   some_code;
5589
   if (cond)
5590
     A;
5591
   else
5592
     B;
5593
 
5594
   is transformed to
5595
 
5596
   if (cond)
5597
     {
5598
       some_code;
5599
       A;
5600
     }
5601
   else
5602
     {
5603
       some_code;
5604
       B;
5605
     }
5606
*/
5607
 
5608
bool
5609
gimple_duplicate_sese_tail (edge entry ATTRIBUTE_UNUSED, edge exit ATTRIBUTE_UNUSED,
5610
                          basic_block *region ATTRIBUTE_UNUSED, unsigned n_region ATTRIBUTE_UNUSED,
5611
                          basic_block *region_copy ATTRIBUTE_UNUSED)
5612
{
5613
  unsigned i;
5614
  bool free_region_copy = false;
5615
  struct loop *loop = exit->dest->loop_father;
5616
  struct loop *orig_loop = entry->dest->loop_father;
5617
  basic_block switch_bb, entry_bb, nentry_bb;
5618
  VEC (basic_block, heap) *doms;
5619
  int total_freq = 0, exit_freq = 0;
5620
  gcov_type total_count = 0, exit_count = 0;
5621
  edge exits[2], nexits[2], e;
5622
  gimple_stmt_iterator gsi;
5623
  gimple cond_stmt;
5624
  edge sorig, snew;
5625
  basic_block exit_bb;
5626
  gimple_stmt_iterator psi;
5627
  gimple phi;
5628
  tree def;
5629
 
5630
  gcc_assert (EDGE_COUNT (exit->src->succs) == 2);
5631
  exits[0] = exit;
5632
  exits[1] = EDGE_SUCC (exit->src, EDGE_SUCC (exit->src, 0) == exit);
5633
 
5634
  if (!can_copy_bbs_p (region, n_region))
5635
    return false;
5636
 
5637
  initialize_original_copy_tables ();
5638
  set_loop_copy (orig_loop, loop);
5639
  duplicate_subloops (orig_loop, loop);
5640
 
5641
  if (!region_copy)
5642
    {
5643
      region_copy = XNEWVEC (basic_block, n_region);
5644
      free_region_copy = true;
5645
    }
5646
 
5647
  gcc_assert (!need_ssa_update_p (cfun));
5648
 
5649
  /* Record blocks outside the region that are dominated by something
5650
     inside.  */
5651
  doms = get_dominated_by_region (CDI_DOMINATORS, region, n_region);
5652
 
5653
  if (exit->src->count)
5654
    {
5655
      total_count = exit->src->count;
5656
      exit_count = exit->count;
5657
      /* Fix up corner cases, to avoid division by zero or creation of negative
5658
         frequencies.  */
5659
      if (exit_count > total_count)
5660
        exit_count = total_count;
5661
    }
5662
  else
5663
    {
5664
      total_freq = exit->src->frequency;
5665
      exit_freq = EDGE_FREQUENCY (exit);
5666
      /* Fix up corner cases, to avoid division by zero or creation of negative
5667
         frequencies.  */
5668
      if (total_freq == 0)
5669
        total_freq = 1;
5670
      if (exit_freq > total_freq)
5671
        exit_freq = total_freq;
5672
    }
5673
 
5674
  copy_bbs (region, n_region, region_copy, exits, 2, nexits, orig_loop,
5675
            split_edge_bb_loc (exit));
5676
  if (total_count)
5677
    {
5678
      scale_bbs_frequencies_gcov_type (region, n_region,
5679
                                       total_count - exit_count,
5680
                                       total_count);
5681
      scale_bbs_frequencies_gcov_type (region_copy, n_region, exit_count,
5682
                                       total_count);
5683
    }
5684
  else
5685
    {
5686
      scale_bbs_frequencies_int (region, n_region, total_freq - exit_freq,
5687
                                 total_freq);
5688
      scale_bbs_frequencies_int (region_copy, n_region, exit_freq, total_freq);
5689
    }
5690
 
5691
  /* Create the switch block, and put the exit condition to it.  */
5692
  entry_bb = entry->dest;
5693
  nentry_bb = get_bb_copy (entry_bb);
5694
  if (!last_stmt (entry->src)
5695
      || !stmt_ends_bb_p (last_stmt (entry->src)))
5696
    switch_bb = entry->src;
5697
  else
5698
    switch_bb = split_edge (entry);
5699
  set_immediate_dominator (CDI_DOMINATORS, nentry_bb, switch_bb);
5700
 
5701
  gsi = gsi_last_bb (switch_bb);
5702
  cond_stmt = last_stmt (exit->src);
5703
  gcc_assert (gimple_code (cond_stmt) == GIMPLE_COND);
5704
  cond_stmt = gimple_copy (cond_stmt);
5705
 
5706
  gsi_insert_after (&gsi, cond_stmt, GSI_NEW_STMT);
5707
 
5708
  sorig = single_succ_edge (switch_bb);
5709
  sorig->flags = exits[1]->flags;
5710
  snew = make_edge (switch_bb, nentry_bb, exits[0]->flags);
5711
 
5712
  /* Register the new edge from SWITCH_BB in loop exit lists.  */
5713
  rescan_loop_exit (snew, true, false);
5714
 
5715
  /* Add the PHI node arguments.  */
5716
  add_phi_args_after_copy (region_copy, n_region, snew);
5717
 
5718
  /* Get rid of now superfluous conditions and associated edges (and phi node
5719
     arguments).  */
5720
  exit_bb = exit->dest;
5721
 
5722
  e = redirect_edge_and_branch (exits[0], exits[1]->dest);
5723
  PENDING_STMT (e) = NULL;
5724
 
5725
  /* The latch of ORIG_LOOP was copied, and so was the backedge
5726
     to the original header.  We redirect this backedge to EXIT_BB.  */
5727
  for (i = 0; i < n_region; i++)
5728
    if (get_bb_original (region_copy[i]) == orig_loop->latch)
5729
      {
5730
        gcc_assert (single_succ_edge (region_copy[i]));
5731
        e = redirect_edge_and_branch (single_succ_edge (region_copy[i]), exit_bb);
5732
        PENDING_STMT (e) = NULL;
5733
        for (psi = gsi_start_phis (exit_bb);
5734
             !gsi_end_p (psi);
5735
             gsi_next (&psi))
5736
          {
5737
            phi = gsi_stmt (psi);
5738
            def = PHI_ARG_DEF (phi, nexits[0]->dest_idx);
5739
            add_phi_arg (phi, def, e, gimple_phi_arg_location_from_edge (phi, e));
5740
          }
5741
      }
5742
  e = redirect_edge_and_branch (nexits[0], nexits[1]->dest);
5743
  PENDING_STMT (e) = NULL;
5744
 
5745
  /* Anything that is outside of the region, but was dominated by something
5746
     inside needs to update dominance info.  */
5747
  iterate_fix_dominators (CDI_DOMINATORS, doms, false);
5748
  VEC_free (basic_block, heap, doms);
5749
  /* Update the SSA web.  */
5750
  update_ssa (TODO_update_ssa);
5751
 
5752
  if (free_region_copy)
5753
    free (region_copy);
5754
 
5755
  free_original_copy_tables ();
5756
  return true;
5757
}
5758
 
5759
/* Add all the blocks dominated by ENTRY to the array BBS_P.  Stop
5760
   adding blocks when the dominator traversal reaches EXIT.  This
5761
   function silently assumes that ENTRY strictly dominates EXIT.  */
5762
 
5763
void
5764
gather_blocks_in_sese_region (basic_block entry, basic_block exit,
5765
                              VEC(basic_block,heap) **bbs_p)
5766
{
5767
  basic_block son;
5768
 
5769
  for (son = first_dom_son (CDI_DOMINATORS, entry);
5770
       son;
5771
       son = next_dom_son (CDI_DOMINATORS, son))
5772
    {
5773
      VEC_safe_push (basic_block, heap, *bbs_p, son);
5774
      if (son != exit)
5775
        gather_blocks_in_sese_region (son, exit, bbs_p);
5776
    }
5777
}
5778
 
5779
/* Replaces *TP with a duplicate (belonging to function TO_CONTEXT).
5780
   The duplicates are recorded in VARS_MAP.  */
5781
 
5782
static void
5783
replace_by_duplicate_decl (tree *tp, struct pointer_map_t *vars_map,
5784
                           tree to_context)
5785
{
5786
  tree t = *tp, new_t;
5787
  struct function *f = DECL_STRUCT_FUNCTION (to_context);
5788
  void **loc;
5789
 
5790
  if (DECL_CONTEXT (t) == to_context)
5791
    return;
5792
 
5793
  loc = pointer_map_contains (vars_map, t);
5794
 
5795
  if (!loc)
5796
    {
5797
      loc = pointer_map_insert (vars_map, t);
5798
 
5799
      if (SSA_VAR_P (t))
5800
        {
5801
          new_t = copy_var_decl (t, DECL_NAME (t), TREE_TYPE (t));
5802
          add_local_decl (f, new_t);
5803
        }
5804
      else
5805
        {
5806
          gcc_assert (TREE_CODE (t) == CONST_DECL);
5807
          new_t = copy_node (t);
5808
        }
5809
      DECL_CONTEXT (new_t) = to_context;
5810
 
5811
      *loc = new_t;
5812
    }
5813
  else
5814
    new_t = (tree) *loc;
5815
 
5816
  *tp = new_t;
5817
}
5818
 
5819
 
5820
/* Creates an ssa name in TO_CONTEXT equivalent to NAME.
5821
   VARS_MAP maps old ssa names and var_decls to the new ones.  */
5822
 
5823
static tree
5824
replace_ssa_name (tree name, struct pointer_map_t *vars_map,
5825
                  tree to_context)
5826
{
5827
  void **loc;
5828
  tree new_name, decl = SSA_NAME_VAR (name);
5829
 
5830
  gcc_assert (is_gimple_reg (name));
5831
 
5832
  loc = pointer_map_contains (vars_map, name);
5833
 
5834
  if (!loc)
5835
    {
5836
      replace_by_duplicate_decl (&decl, vars_map, to_context);
5837
 
5838
      push_cfun (DECL_STRUCT_FUNCTION (to_context));
5839
      if (gimple_in_ssa_p (cfun))
5840
        add_referenced_var (decl);
5841
 
5842
      new_name = make_ssa_name (decl, SSA_NAME_DEF_STMT (name));
5843
      if (SSA_NAME_IS_DEFAULT_DEF (name))
5844
        set_default_def (decl, new_name);
5845
      pop_cfun ();
5846
 
5847
      loc = pointer_map_insert (vars_map, name);
5848
      *loc = new_name;
5849
    }
5850
  else
5851
    new_name = (tree) *loc;
5852
 
5853
  return new_name;
5854
}
5855
 
5856
struct move_stmt_d
5857
{
5858
  tree orig_block;
5859
  tree new_block;
5860
  tree from_context;
5861
  tree to_context;
5862
  struct pointer_map_t *vars_map;
5863
  htab_t new_label_map;
5864
  struct pointer_map_t *eh_map;
5865
  bool remap_decls_p;
5866
};
5867
 
5868
/* Helper for move_block_to_fn.  Set TREE_BLOCK in every expression
5869
   contained in *TP if it has been ORIG_BLOCK previously and change the
5870
   DECL_CONTEXT of every local variable referenced in *TP.  */
5871
 
5872
static tree
5873
move_stmt_op (tree *tp, int *walk_subtrees, void *data)
5874
{
5875
  struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
5876
  struct move_stmt_d *p = (struct move_stmt_d *) wi->info;
5877
  tree t = *tp;
5878
 
5879
  if (EXPR_P (t))
5880
    /* We should never have TREE_BLOCK set on non-statements.  */
5881
    gcc_assert (!TREE_BLOCK (t));
5882
 
5883
  else if (DECL_P (t) || TREE_CODE (t) == SSA_NAME)
5884
    {
5885
      if (TREE_CODE (t) == SSA_NAME)
5886
        *tp = replace_ssa_name (t, p->vars_map, p->to_context);
5887
      else if (TREE_CODE (t) == LABEL_DECL)
5888
        {
5889
          if (p->new_label_map)
5890
            {
5891
              struct tree_map in, *out;
5892
              in.base.from = t;
5893
              out = (struct tree_map *)
5894
                htab_find_with_hash (p->new_label_map, &in, DECL_UID (t));
5895
              if (out)
5896
                *tp = t = out->to;
5897
            }
5898
 
5899
          DECL_CONTEXT (t) = p->to_context;
5900
        }
5901
      else if (p->remap_decls_p)
5902
        {
5903
          /* Replace T with its duplicate.  T should no longer appear in the
5904
             parent function, so this looks wasteful; however, it may appear
5905
             in referenced_vars, and more importantly, as virtual operands of
5906
             statements, and in alias lists of other variables.  It would be
5907
             quite difficult to expunge it from all those places.  ??? It might
5908
             suffice to do this for addressable variables.  */
5909
          if ((TREE_CODE (t) == VAR_DECL
5910
               && !is_global_var (t))
5911
              || TREE_CODE (t) == CONST_DECL)
5912
            replace_by_duplicate_decl (tp, p->vars_map, p->to_context);
5913
 
5914
          if (SSA_VAR_P (t)
5915
              && gimple_in_ssa_p (cfun))
5916
            {
5917
              push_cfun (DECL_STRUCT_FUNCTION (p->to_context));
5918
              add_referenced_var (*tp);
5919
              pop_cfun ();
5920
            }
5921
        }
5922
      *walk_subtrees = 0;
5923
    }
5924
  else if (TYPE_P (t))
5925
    *walk_subtrees = 0;
5926
 
5927
  return NULL_TREE;
5928
}
5929
 
5930
/* Helper for move_stmt_r.  Given an EH region number for the source
5931
   function, map that to the duplicate EH regio number in the dest.  */
5932
 
5933
static int
5934
move_stmt_eh_region_nr (int old_nr, struct move_stmt_d *p)
5935
{
5936
  eh_region old_r, new_r;
5937
  void **slot;
5938
 
5939
  old_r = get_eh_region_from_number (old_nr);
5940
  slot = pointer_map_contains (p->eh_map, old_r);
5941
  new_r = (eh_region) *slot;
5942
 
5943
  return new_r->index;
5944
}
5945
 
5946
/* Similar, but operate on INTEGER_CSTs.  */
5947
 
5948
static tree
5949
move_stmt_eh_region_tree_nr (tree old_t_nr, struct move_stmt_d *p)
5950
{
5951
  int old_nr, new_nr;
5952
 
5953
  old_nr = tree_low_cst (old_t_nr, 0);
5954
  new_nr = move_stmt_eh_region_nr (old_nr, p);
5955
 
5956
  return build_int_cst (integer_type_node, new_nr);
5957
}
5958
 
5959
/* Like move_stmt_op, but for gimple statements.
5960
 
5961
   Helper for move_block_to_fn.  Set GIMPLE_BLOCK in every expression
5962
   contained in the current statement in *GSI_P and change the
5963
   DECL_CONTEXT of every local variable referenced in the current
5964
   statement.  */
5965
 
5966
static tree
5967
move_stmt_r (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
5968
             struct walk_stmt_info *wi)
5969
{
5970
  struct move_stmt_d *p = (struct move_stmt_d *) wi->info;
5971
  gimple stmt = gsi_stmt (*gsi_p);
5972
  tree block = gimple_block (stmt);
5973
 
5974
  if (p->orig_block == NULL_TREE
5975
      || block == p->orig_block
5976
      || block == NULL_TREE)
5977
    gimple_set_block (stmt, p->new_block);
5978
#ifdef ENABLE_CHECKING
5979
  else if (block != p->new_block)
5980
    {
5981
      while (block && block != p->orig_block)
5982
        block = BLOCK_SUPERCONTEXT (block);
5983
      gcc_assert (block);
5984
    }
5985
#endif
5986
 
5987
  switch (gimple_code (stmt))
5988
    {
5989
    case GIMPLE_CALL:
5990
      /* Remap the region numbers for __builtin_eh_{pointer,filter}.  */
5991
      {
5992
        tree r, fndecl = gimple_call_fndecl (stmt);
5993
        if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
5994
          switch (DECL_FUNCTION_CODE (fndecl))
5995
            {
5996
            case BUILT_IN_EH_COPY_VALUES:
5997
              r = gimple_call_arg (stmt, 1);
5998
              r = move_stmt_eh_region_tree_nr (r, p);
5999
              gimple_call_set_arg (stmt, 1, r);
6000
              /* FALLTHRU */
6001
 
6002
            case BUILT_IN_EH_POINTER:
6003
            case BUILT_IN_EH_FILTER:
6004
              r = gimple_call_arg (stmt, 0);
6005
              r = move_stmt_eh_region_tree_nr (r, p);
6006
              gimple_call_set_arg (stmt, 0, r);
6007
              break;
6008
 
6009
            default:
6010
              break;
6011
            }
6012
      }
6013
      break;
6014
 
6015
    case GIMPLE_RESX:
6016
      {
6017
        int r = gimple_resx_region (stmt);
6018
        r = move_stmt_eh_region_nr (r, p);
6019
        gimple_resx_set_region (stmt, r);
6020
      }
6021
      break;
6022
 
6023
    case GIMPLE_EH_DISPATCH:
6024
      {
6025
        int r = gimple_eh_dispatch_region (stmt);
6026
        r = move_stmt_eh_region_nr (r, p);
6027
        gimple_eh_dispatch_set_region (stmt, r);
6028
      }
6029
      break;
6030
 
6031
    case GIMPLE_OMP_RETURN:
6032
    case GIMPLE_OMP_CONTINUE:
6033
      break;
6034
    default:
6035
      if (is_gimple_omp (stmt))
6036
        {
6037
          /* Do not remap variables inside OMP directives.  Variables
6038
             referenced in clauses and directive header belong to the
6039
             parent function and should not be moved into the child
6040
             function.  */
6041
          bool save_remap_decls_p = p->remap_decls_p;
6042
          p->remap_decls_p = false;
6043
          *handled_ops_p = true;
6044
 
6045
          walk_gimple_seq (gimple_omp_body (stmt), move_stmt_r,
6046
                           move_stmt_op, wi);
6047
 
6048
          p->remap_decls_p = save_remap_decls_p;
6049
        }
6050
      break;
6051
    }
6052
 
6053
  return NULL_TREE;
6054
}
6055
 
6056
/* Move basic block BB from function CFUN to function DEST_FN.  The
6057
   block is moved out of the original linked list and placed after
6058
   block AFTER in the new list.  Also, the block is removed from the
6059
   original array of blocks and placed in DEST_FN's array of blocks.
6060
   If UPDATE_EDGE_COUNT_P is true, the edge counts on both CFGs is
6061
   updated to reflect the moved edges.
6062
 
6063
   The local variables are remapped to new instances, VARS_MAP is used
6064
   to record the mapping.  */
6065
 
6066
static void
6067
move_block_to_fn (struct function *dest_cfun, basic_block bb,
6068
                  basic_block after, bool update_edge_count_p,
6069
                  struct move_stmt_d *d)
6070
{
6071
  struct control_flow_graph *cfg;
6072
  edge_iterator ei;
6073
  edge e;
6074
  gimple_stmt_iterator si;
6075
  unsigned old_len, new_len;
6076
 
6077
  /* Remove BB from dominance structures.  */
6078
  delete_from_dominance_info (CDI_DOMINATORS, bb);
6079
  if (current_loops)
6080
    remove_bb_from_loops (bb);
6081
 
6082
  /* Link BB to the new linked list.  */
6083
  move_block_after (bb, after);
6084
 
6085
  /* Update the edge count in the corresponding flowgraphs.  */
6086
  if (update_edge_count_p)
6087
    FOR_EACH_EDGE (e, ei, bb->succs)
6088
      {
6089
        cfun->cfg->x_n_edges--;
6090
        dest_cfun->cfg->x_n_edges++;
6091
      }
6092
 
6093
  /* Remove BB from the original basic block array.  */
6094
  VEC_replace (basic_block, cfun->cfg->x_basic_block_info, bb->index, NULL);
6095
  cfun->cfg->x_n_basic_blocks--;
6096
 
6097
  /* Grow DEST_CFUN's basic block array if needed.  */
6098
  cfg = dest_cfun->cfg;
6099
  cfg->x_n_basic_blocks++;
6100
  if (bb->index >= cfg->x_last_basic_block)
6101
    cfg->x_last_basic_block = bb->index + 1;
6102
 
6103
  old_len = VEC_length (basic_block, cfg->x_basic_block_info);
6104
  if ((unsigned) cfg->x_last_basic_block >= old_len)
6105
    {
6106
      new_len = cfg->x_last_basic_block + (cfg->x_last_basic_block + 3) / 4;
6107
      VEC_safe_grow_cleared (basic_block, gc, cfg->x_basic_block_info,
6108
                             new_len);
6109
    }
6110
 
6111
  VEC_replace (basic_block, cfg->x_basic_block_info,
6112
               bb->index, bb);
6113
 
6114
  /* Remap the variables in phi nodes.  */
6115
  for (si = gsi_start_phis (bb); !gsi_end_p (si); )
6116
    {
6117
      gimple phi = gsi_stmt (si);
6118
      use_operand_p use;
6119
      tree op = PHI_RESULT (phi);
6120
      ssa_op_iter oi;
6121
 
6122
      if (!is_gimple_reg (op))
6123
        {
6124
          /* Remove the phi nodes for virtual operands (alias analysis will be
6125
             run for the new function, anyway).  */
6126
          remove_phi_node (&si, true);
6127
          continue;
6128
        }
6129
 
6130
      SET_PHI_RESULT (phi,
6131
                      replace_ssa_name (op, d->vars_map, dest_cfun->decl));
6132
      FOR_EACH_PHI_ARG (use, phi, oi, SSA_OP_USE)
6133
        {
6134
          op = USE_FROM_PTR (use);
6135
          if (TREE_CODE (op) == SSA_NAME)
6136
            SET_USE (use, replace_ssa_name (op, d->vars_map, dest_cfun->decl));
6137
        }
6138
 
6139
      gsi_next (&si);
6140
    }
6141
 
6142
  for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
6143
    {
6144
      gimple stmt = gsi_stmt (si);
6145
      struct walk_stmt_info wi;
6146
 
6147
      memset (&wi, 0, sizeof (wi));
6148
      wi.info = d;
6149
      walk_gimple_stmt (&si, move_stmt_r, move_stmt_op, &wi);
6150
 
6151
      if (gimple_code (stmt) == GIMPLE_LABEL)
6152
        {
6153
          tree label = gimple_label_label (stmt);
6154
          int uid = LABEL_DECL_UID (label);
6155
 
6156
          gcc_assert (uid > -1);
6157
 
6158
          old_len = VEC_length (basic_block, cfg->x_label_to_block_map);
6159
          if (old_len <= (unsigned) uid)
6160
            {
6161
              new_len = 3 * uid / 2 + 1;
6162
              VEC_safe_grow_cleared (basic_block, gc,
6163
                                     cfg->x_label_to_block_map, new_len);
6164
            }
6165
 
6166
          VEC_replace (basic_block, cfg->x_label_to_block_map, uid, bb);
6167
          VEC_replace (basic_block, cfun->cfg->x_label_to_block_map, uid, NULL);
6168
 
6169
          gcc_assert (DECL_CONTEXT (label) == dest_cfun->decl);
6170
 
6171
          if (uid >= dest_cfun->cfg->last_label_uid)
6172
            dest_cfun->cfg->last_label_uid = uid + 1;
6173
        }
6174
 
6175
      maybe_duplicate_eh_stmt_fn (dest_cfun, stmt, cfun, stmt, d->eh_map, 0);
6176
      remove_stmt_from_eh_lp_fn (cfun, stmt);
6177
 
6178
      gimple_duplicate_stmt_histograms (dest_cfun, stmt, cfun, stmt);
6179
      gimple_remove_stmt_histograms (cfun, stmt);
6180
 
6181
      /* We cannot leave any operands allocated from the operand caches of
6182
         the current function.  */
6183
      free_stmt_operands (stmt);
6184
      push_cfun (dest_cfun);
6185
      update_stmt (stmt);
6186
      pop_cfun ();
6187
    }
6188
 
6189
  FOR_EACH_EDGE (e, ei, bb->succs)
6190
    if (e->goto_locus)
6191
      {
6192
        tree block = e->goto_block;
6193
        if (d->orig_block == NULL_TREE
6194
            || block == d->orig_block)
6195
          e->goto_block = d->new_block;
6196
#ifdef ENABLE_CHECKING
6197
        else if (block != d->new_block)
6198
          {
6199
            while (block && block != d->orig_block)
6200
              block = BLOCK_SUPERCONTEXT (block);
6201
            gcc_assert (block);
6202
          }
6203
#endif
6204
      }
6205
}
6206
 
6207
/* Examine the statements in BB (which is in SRC_CFUN); find and return
6208
   the outermost EH region.  Use REGION as the incoming base EH region.  */
6209
 
6210
static eh_region
6211
find_outermost_region_in_block (struct function *src_cfun,
6212
                                basic_block bb, eh_region region)
6213
{
6214
  gimple_stmt_iterator si;
6215
 
6216
  for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
6217
    {
6218
      gimple stmt = gsi_stmt (si);
6219
      eh_region stmt_region;
6220
      int lp_nr;
6221
 
6222
      lp_nr = lookup_stmt_eh_lp_fn (src_cfun, stmt);
6223
      stmt_region = get_eh_region_from_lp_number_fn (src_cfun, lp_nr);
6224
      if (stmt_region)
6225
        {
6226
          if (region == NULL)
6227
            region = stmt_region;
6228
          else if (stmt_region != region)
6229
            {
6230
              region = eh_region_outermost (src_cfun, stmt_region, region);
6231
              gcc_assert (region != NULL);
6232
            }
6233
        }
6234
    }
6235
 
6236
  return region;
6237
}
6238
 
6239
static tree
6240
new_label_mapper (tree decl, void *data)
6241
{
6242
  htab_t hash = (htab_t) data;
6243
  struct tree_map *m;
6244
  void **slot;
6245
 
6246
  gcc_assert (TREE_CODE (decl) == LABEL_DECL);
6247
 
6248
  m = XNEW (struct tree_map);
6249
  m->hash = DECL_UID (decl);
6250
  m->base.from = decl;
6251
  m->to = create_artificial_label (UNKNOWN_LOCATION);
6252
  LABEL_DECL_UID (m->to) = LABEL_DECL_UID (decl);
6253
  if (LABEL_DECL_UID (m->to) >= cfun->cfg->last_label_uid)
6254
    cfun->cfg->last_label_uid = LABEL_DECL_UID (m->to) + 1;
6255
 
6256
  slot = htab_find_slot_with_hash (hash, m, m->hash, INSERT);
6257
  gcc_assert (*slot == NULL);
6258
 
6259
  *slot = m;
6260
 
6261
  return m->to;
6262
}
6263
 
6264
/* Change DECL_CONTEXT of all BLOCK_VARS in block, including
6265
   subblocks.  */
6266
 
6267
static void
6268
replace_block_vars_by_duplicates (tree block, struct pointer_map_t *vars_map,
6269
                                  tree to_context)
6270
{
6271
  tree *tp, t;
6272
 
6273
  for (tp = &BLOCK_VARS (block); *tp; tp = &DECL_CHAIN (*tp))
6274
    {
6275
      t = *tp;
6276
      if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != CONST_DECL)
6277
        continue;
6278
      replace_by_duplicate_decl (&t, vars_map, to_context);
6279
      if (t != *tp)
6280
        {
6281
          if (TREE_CODE (*tp) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (*tp))
6282
            {
6283
              SET_DECL_VALUE_EXPR (t, DECL_VALUE_EXPR (*tp));
6284
              DECL_HAS_VALUE_EXPR_P (t) = 1;
6285
            }
6286
          DECL_CHAIN (t) = DECL_CHAIN (*tp);
6287
          *tp = t;
6288
        }
6289
    }
6290
 
6291
  for (block = BLOCK_SUBBLOCKS (block); block; block = BLOCK_CHAIN (block))
6292
    replace_block_vars_by_duplicates (block, vars_map, to_context);
6293
}
6294
 
6295
/* Move a single-entry, single-exit region delimited by ENTRY_BB and
6296
   EXIT_BB to function DEST_CFUN.  The whole region is replaced by a
6297
   single basic block in the original CFG and the new basic block is
6298
   returned.  DEST_CFUN must not have a CFG yet.
6299
 
6300
   Note that the region need not be a pure SESE region.  Blocks inside
6301
   the region may contain calls to abort/exit.  The only restriction
6302
   is that ENTRY_BB should be the only entry point and it must
6303
   dominate EXIT_BB.
6304
 
6305
   Change TREE_BLOCK of all statements in ORIG_BLOCK to the new
6306
   functions outermost BLOCK, move all subblocks of ORIG_BLOCK
6307
   to the new function.
6308
 
6309
   All local variables referenced in the region are assumed to be in
6310
   the corresponding BLOCK_VARS and unexpanded variable lists
6311
   associated with DEST_CFUN.  */
6312
 
6313
basic_block
6314
move_sese_region_to_fn (struct function *dest_cfun, basic_block entry_bb,
6315
                        basic_block exit_bb, tree orig_block)
6316
{
6317
  VEC(basic_block,heap) *bbs, *dom_bbs;
6318
  basic_block dom_entry = get_immediate_dominator (CDI_DOMINATORS, entry_bb);
6319
  basic_block after, bb, *entry_pred, *exit_succ, abb;
6320
  struct function *saved_cfun = cfun;
6321
  int *entry_flag, *exit_flag;
6322
  unsigned *entry_prob, *exit_prob;
6323
  unsigned i, num_entry_edges, num_exit_edges;
6324
  edge e;
6325
  edge_iterator ei;
6326
  htab_t new_label_map;
6327
  struct pointer_map_t *vars_map, *eh_map;
6328
  struct loop *loop = entry_bb->loop_father;
6329
  struct move_stmt_d d;
6330
 
6331
  /* If ENTRY does not strictly dominate EXIT, this cannot be an SESE
6332
     region.  */
6333
  gcc_assert (entry_bb != exit_bb
6334
              && (!exit_bb
6335
                  || dominated_by_p (CDI_DOMINATORS, exit_bb, entry_bb)));
6336
 
6337
  /* Collect all the blocks in the region.  Manually add ENTRY_BB
6338
     because it won't be added by dfs_enumerate_from.  */
6339
  bbs = NULL;
6340
  VEC_safe_push (basic_block, heap, bbs, entry_bb);
6341
  gather_blocks_in_sese_region (entry_bb, exit_bb, &bbs);
6342
 
6343
  /* The blocks that used to be dominated by something in BBS will now be
6344
     dominated by the new block.  */
6345
  dom_bbs = get_dominated_by_region (CDI_DOMINATORS,
6346
                                     VEC_address (basic_block, bbs),
6347
                                     VEC_length (basic_block, bbs));
6348
 
6349
  /* Detach ENTRY_BB and EXIT_BB from CFUN->CFG.  We need to remember
6350
     the predecessor edges to ENTRY_BB and the successor edges to
6351
     EXIT_BB so that we can re-attach them to the new basic block that
6352
     will replace the region.  */
6353
  num_entry_edges = EDGE_COUNT (entry_bb->preds);
6354
  entry_pred = (basic_block *) xcalloc (num_entry_edges, sizeof (basic_block));
6355
  entry_flag = (int *) xcalloc (num_entry_edges, sizeof (int));
6356
  entry_prob = XNEWVEC (unsigned, num_entry_edges);
6357
  i = 0;
6358
  for (ei = ei_start (entry_bb->preds); (e = ei_safe_edge (ei)) != NULL;)
6359
    {
6360
      entry_prob[i] = e->probability;
6361
      entry_flag[i] = e->flags;
6362
      entry_pred[i++] = e->src;
6363
      remove_edge (e);
6364
    }
6365
 
6366
  if (exit_bb)
6367
    {
6368
      num_exit_edges = EDGE_COUNT (exit_bb->succs);
6369
      exit_succ = (basic_block *) xcalloc (num_exit_edges,
6370
                                           sizeof (basic_block));
6371
      exit_flag = (int *) xcalloc (num_exit_edges, sizeof (int));
6372
      exit_prob = XNEWVEC (unsigned, num_exit_edges);
6373
      i = 0;
6374
      for (ei = ei_start (exit_bb->succs); (e = ei_safe_edge (ei)) != NULL;)
6375
        {
6376
          exit_prob[i] = e->probability;
6377
          exit_flag[i] = e->flags;
6378
          exit_succ[i++] = e->dest;
6379
          remove_edge (e);
6380
        }
6381
    }
6382
  else
6383
    {
6384
      num_exit_edges = 0;
6385
      exit_succ = NULL;
6386
      exit_flag = NULL;
6387
      exit_prob = NULL;
6388
    }
6389
 
6390
  /* Switch context to the child function to initialize DEST_FN's CFG.  */
6391
  gcc_assert (dest_cfun->cfg == NULL);
6392
  push_cfun (dest_cfun);
6393
 
6394
  init_empty_tree_cfg ();
6395
 
6396
  /* Initialize EH information for the new function.  */
6397
  eh_map = NULL;
6398
  new_label_map = NULL;
6399
  if (saved_cfun->eh)
6400
    {
6401
      eh_region region = NULL;
6402
 
6403
      FOR_EACH_VEC_ELT (basic_block, bbs, i, bb)
6404
        region = find_outermost_region_in_block (saved_cfun, bb, region);
6405
 
6406
      init_eh_for_function ();
6407
      if (region != NULL)
6408
        {
6409
          new_label_map = htab_create (17, tree_map_hash, tree_map_eq, free);
6410
          eh_map = duplicate_eh_regions (saved_cfun, region, 0,
6411
                                         new_label_mapper, new_label_map);
6412
        }
6413
    }
6414
 
6415
  pop_cfun ();
6416
 
6417
  /* Move blocks from BBS into DEST_CFUN.  */
6418
  gcc_assert (VEC_length (basic_block, bbs) >= 2);
6419
  after = dest_cfun->cfg->x_entry_block_ptr;
6420
  vars_map = pointer_map_create ();
6421
 
6422
  memset (&d, 0, sizeof (d));
6423
  d.orig_block = orig_block;
6424
  d.new_block = DECL_INITIAL (dest_cfun->decl);
6425
  d.from_context = cfun->decl;
6426
  d.to_context = dest_cfun->decl;
6427
  d.vars_map = vars_map;
6428
  d.new_label_map = new_label_map;
6429
  d.eh_map = eh_map;
6430
  d.remap_decls_p = true;
6431
 
6432
  FOR_EACH_VEC_ELT (basic_block, bbs, i, bb)
6433
    {
6434
      /* No need to update edge counts on the last block.  It has
6435
         already been updated earlier when we detached the region from
6436
         the original CFG.  */
6437
      move_block_to_fn (dest_cfun, bb, after, bb != exit_bb, &d);
6438
      after = bb;
6439
    }
6440
 
6441
  /* Rewire BLOCK_SUBBLOCKS of orig_block.  */
6442
  if (orig_block)
6443
    {
6444
      tree block;
6445
      gcc_assert (BLOCK_SUBBLOCKS (DECL_INITIAL (dest_cfun->decl))
6446
                  == NULL_TREE);
6447
      BLOCK_SUBBLOCKS (DECL_INITIAL (dest_cfun->decl))
6448
        = BLOCK_SUBBLOCKS (orig_block);
6449
      for (block = BLOCK_SUBBLOCKS (orig_block);
6450
           block; block = BLOCK_CHAIN (block))
6451
        BLOCK_SUPERCONTEXT (block) = DECL_INITIAL (dest_cfun->decl);
6452
      BLOCK_SUBBLOCKS (orig_block) = NULL_TREE;
6453
    }
6454
 
6455
  replace_block_vars_by_duplicates (DECL_INITIAL (dest_cfun->decl),
6456
                                    vars_map, dest_cfun->decl);
6457
 
6458
  if (new_label_map)
6459
    htab_delete (new_label_map);
6460
  if (eh_map)
6461
    pointer_map_destroy (eh_map);
6462
  pointer_map_destroy (vars_map);
6463
 
6464
  /* Rewire the entry and exit blocks.  The successor to the entry
6465
     block turns into the successor of DEST_FN's ENTRY_BLOCK_PTR in
6466
     the child function.  Similarly, the predecessor of DEST_FN's
6467
     EXIT_BLOCK_PTR turns into the predecessor of EXIT_BLOCK_PTR.  We
6468
     need to switch CFUN between DEST_CFUN and SAVED_CFUN so that the
6469
     various CFG manipulation function get to the right CFG.
6470
 
6471
     FIXME, this is silly.  The CFG ought to become a parameter to
6472
     these helpers.  */
6473
  push_cfun (dest_cfun);
6474
  make_edge (ENTRY_BLOCK_PTR, entry_bb, EDGE_FALLTHRU);
6475
  if (exit_bb)
6476
    make_edge (exit_bb,  EXIT_BLOCK_PTR, 0);
6477
  pop_cfun ();
6478
 
6479
  /* Back in the original function, the SESE region has disappeared,
6480
     create a new basic block in its place.  */
6481
  bb = create_empty_bb (entry_pred[0]);
6482
  if (current_loops)
6483
    add_bb_to_loop (bb, loop);
6484
  for (i = 0; i < num_entry_edges; i++)
6485
    {
6486
      e = make_edge (entry_pred[i], bb, entry_flag[i]);
6487
      e->probability = entry_prob[i];
6488
    }
6489
 
6490
  for (i = 0; i < num_exit_edges; i++)
6491
    {
6492
      e = make_edge (bb, exit_succ[i], exit_flag[i]);
6493
      e->probability = exit_prob[i];
6494
    }
6495
 
6496
  set_immediate_dominator (CDI_DOMINATORS, bb, dom_entry);
6497
  FOR_EACH_VEC_ELT (basic_block, dom_bbs, i, abb)
6498
    set_immediate_dominator (CDI_DOMINATORS, abb, bb);
6499
  VEC_free (basic_block, heap, dom_bbs);
6500
 
6501
  if (exit_bb)
6502
    {
6503
      free (exit_prob);
6504
      free (exit_flag);
6505
      free (exit_succ);
6506
    }
6507
  free (entry_prob);
6508
  free (entry_flag);
6509
  free (entry_pred);
6510
  VEC_free (basic_block, heap, bbs);
6511
 
6512
  return bb;
6513
}
6514
 
6515
 
6516
/* Dump FUNCTION_DECL FN to file FILE using FLAGS (see TDF_* in tree-pass.h)
6517
   */
6518
 
6519
void
6520
dump_function_to_file (tree fn, FILE *file, int flags)
6521
{
6522
  tree arg, var;
6523
  struct function *dsf;
6524
  bool ignore_topmost_bind = false, any_var = false;
6525
  basic_block bb;
6526
  tree chain;
6527
  bool tmclone = TREE_CODE (fn) == FUNCTION_DECL && decl_is_tm_clone (fn);
6528
 
6529
  fprintf (file, "%s %s(", lang_hooks.decl_printable_name (fn, 2),
6530
           tmclone ? "[tm-clone] " : "");
6531
 
6532
  arg = DECL_ARGUMENTS (fn);
6533
  while (arg)
6534
    {
6535
      print_generic_expr (file, TREE_TYPE (arg), dump_flags);
6536
      fprintf (file, " ");
6537
      print_generic_expr (file, arg, dump_flags);
6538
      if (flags & TDF_VERBOSE)
6539
        print_node (file, "", arg, 4);
6540
      if (DECL_CHAIN (arg))
6541
        fprintf (file, ", ");
6542
      arg = DECL_CHAIN (arg);
6543
    }
6544
  fprintf (file, ")\n");
6545
 
6546
  if (flags & TDF_VERBOSE)
6547
    print_node (file, "", fn, 2);
6548
 
6549
  dsf = DECL_STRUCT_FUNCTION (fn);
6550
  if (dsf && (flags & TDF_EH))
6551
    dump_eh_tree (file, dsf);
6552
 
6553
  if (flags & TDF_RAW && !gimple_has_body_p (fn))
6554
    {
6555
      dump_node (fn, TDF_SLIM | flags, file);
6556
      return;
6557
    }
6558
 
6559
  /* Switch CFUN to point to FN.  */
6560
  push_cfun (DECL_STRUCT_FUNCTION (fn));
6561
 
6562
  /* When GIMPLE is lowered, the variables are no longer available in
6563
     BIND_EXPRs, so display them separately.  */
6564
  if (cfun && cfun->decl == fn && !VEC_empty (tree, cfun->local_decls))
6565
    {
6566
      unsigned ix;
6567
      ignore_topmost_bind = true;
6568
 
6569
      fprintf (file, "{\n");
6570
      FOR_EACH_LOCAL_DECL (cfun, ix, var)
6571
        {
6572
          print_generic_decl (file, var, flags);
6573
          if (flags & TDF_VERBOSE)
6574
            print_node (file, "", var, 4);
6575
          fprintf (file, "\n");
6576
 
6577
          any_var = true;
6578
        }
6579
    }
6580
 
6581
  if (cfun && cfun->decl == fn && cfun->cfg && basic_block_info)
6582
    {
6583
      /* If the CFG has been built, emit a CFG-based dump.  */
6584
      check_bb_profile (ENTRY_BLOCK_PTR, file);
6585
      if (!ignore_topmost_bind)
6586
        fprintf (file, "{\n");
6587
 
6588
      if (any_var && n_basic_blocks)
6589
        fprintf (file, "\n");
6590
 
6591
      FOR_EACH_BB (bb)
6592
        gimple_dump_bb (bb, file, 2, flags);
6593
 
6594
      fprintf (file, "}\n");
6595
      check_bb_profile (EXIT_BLOCK_PTR, file);
6596
    }
6597
  else if (DECL_SAVED_TREE (fn) == NULL)
6598
    {
6599
      /* The function is now in GIMPLE form but the CFG has not been
6600
         built yet.  Emit the single sequence of GIMPLE statements
6601
         that make up its body.  */
6602
      gimple_seq body = gimple_body (fn);
6603
 
6604
      if (gimple_seq_first_stmt (body)
6605
          && gimple_seq_first_stmt (body) == gimple_seq_last_stmt (body)
6606
          && gimple_code (gimple_seq_first_stmt (body)) == GIMPLE_BIND)
6607
        print_gimple_seq (file, body, 0, flags);
6608
      else
6609
        {
6610
          if (!ignore_topmost_bind)
6611
            fprintf (file, "{\n");
6612
 
6613
          if (any_var)
6614
            fprintf (file, "\n");
6615
 
6616
          print_gimple_seq (file, body, 2, flags);
6617
          fprintf (file, "}\n");
6618
        }
6619
    }
6620
  else
6621
    {
6622
      int indent;
6623
 
6624
      /* Make a tree based dump.  */
6625
      chain = DECL_SAVED_TREE (fn);
6626
 
6627
      if (chain && TREE_CODE (chain) == BIND_EXPR)
6628
        {
6629
          if (ignore_topmost_bind)
6630
            {
6631
              chain = BIND_EXPR_BODY (chain);
6632
              indent = 2;
6633
            }
6634
          else
6635
            indent = 0;
6636
        }
6637
      else
6638
        {
6639
          if (!ignore_topmost_bind)
6640
            fprintf (file, "{\n");
6641
          indent = 2;
6642
        }
6643
 
6644
      if (any_var)
6645
        fprintf (file, "\n");
6646
 
6647
      print_generic_stmt_indented (file, chain, flags, indent);
6648
      if (ignore_topmost_bind)
6649
        fprintf (file, "}\n");
6650
    }
6651
 
6652
  if (flags & TDF_ENUMERATE_LOCALS)
6653
    dump_enumerated_decls (file, flags);
6654
  fprintf (file, "\n\n");
6655
 
6656
  /* Restore CFUN.  */
6657
  pop_cfun ();
6658
}
6659
 
6660
 
6661
/* Dump FUNCTION_DECL FN to stderr using FLAGS (see TDF_* in tree.h)  */
6662
 
6663
DEBUG_FUNCTION void
6664
debug_function (tree fn, int flags)
6665
{
6666
  dump_function_to_file (fn, stderr, flags);
6667
}
6668
 
6669
 
6670
/* Print on FILE the indexes for the predecessors of basic_block BB.  */
6671
 
6672
static void
6673
print_pred_bbs (FILE *file, basic_block bb)
6674
{
6675
  edge e;
6676
  edge_iterator ei;
6677
 
6678
  FOR_EACH_EDGE (e, ei, bb->preds)
6679
    fprintf (file, "bb_%d ", e->src->index);
6680
}
6681
 
6682
 
6683
/* Print on FILE the indexes for the successors of basic_block BB.  */
6684
 
6685
static void
6686
print_succ_bbs (FILE *file, basic_block bb)
6687
{
6688
  edge e;
6689
  edge_iterator ei;
6690
 
6691
  FOR_EACH_EDGE (e, ei, bb->succs)
6692
    fprintf (file, "bb_%d ", e->dest->index);
6693
}
6694
 
6695
/* Print to FILE the basic block BB following the VERBOSITY level.  */
6696
 
6697
void
6698
print_loops_bb (FILE *file, basic_block bb, int indent, int verbosity)
6699
{
6700
  char *s_indent = (char *) alloca ((size_t) indent + 1);
6701
  memset ((void *) s_indent, ' ', (size_t) indent);
6702
  s_indent[indent] = '\0';
6703
 
6704
  /* Print basic_block's header.  */
6705
  if (verbosity >= 2)
6706
    {
6707
      fprintf (file, "%s  bb_%d (preds = {", s_indent, bb->index);
6708
      print_pred_bbs (file, bb);
6709
      fprintf (file, "}, succs = {");
6710
      print_succ_bbs (file, bb);
6711
      fprintf (file, "})\n");
6712
    }
6713
 
6714
  /* Print basic_block's body.  */
6715
  if (verbosity >= 3)
6716
    {
6717
      fprintf (file, "%s  {\n", s_indent);
6718
      gimple_dump_bb (bb, file, indent + 4, TDF_VOPS|TDF_MEMSYMS);
6719
      fprintf (file, "%s  }\n", s_indent);
6720
    }
6721
}
6722
 
6723
static void print_loop_and_siblings (FILE *, struct loop *, int, int);
6724
 
6725
/* Pretty print LOOP on FILE, indented INDENT spaces.  Following
6726
   VERBOSITY level this outputs the contents of the loop, or just its
6727
   structure.  */
6728
 
6729
static void
6730
print_loop (FILE *file, struct loop *loop, int indent, int verbosity)
6731
{
6732
  char *s_indent;
6733
  basic_block bb;
6734
 
6735
  if (loop == NULL)
6736
    return;
6737
 
6738
  s_indent = (char *) alloca ((size_t) indent + 1);
6739
  memset ((void *) s_indent, ' ', (size_t) indent);
6740
  s_indent[indent] = '\0';
6741
 
6742
  /* Print loop's header.  */
6743
  fprintf (file, "%sloop_%d (header = %d, latch = %d", s_indent,
6744
           loop->num, loop->header->index, loop->latch->index);
6745
  fprintf (file, ", niter = ");
6746
  print_generic_expr (file, loop->nb_iterations, 0);
6747
 
6748
  if (loop->any_upper_bound)
6749
    {
6750
      fprintf (file, ", upper_bound = ");
6751
      dump_double_int (file, loop->nb_iterations_upper_bound, true);
6752
    }
6753
 
6754
  if (loop->any_estimate)
6755
    {
6756
      fprintf (file, ", estimate = ");
6757
      dump_double_int (file, loop->nb_iterations_estimate, true);
6758
    }
6759
  fprintf (file, ")\n");
6760
 
6761
  /* Print loop's body.  */
6762
  if (verbosity >= 1)
6763
    {
6764
      fprintf (file, "%s{\n", s_indent);
6765
      FOR_EACH_BB (bb)
6766
        if (bb->loop_father == loop)
6767
          print_loops_bb (file, bb, indent, verbosity);
6768
 
6769
      print_loop_and_siblings (file, loop->inner, indent + 2, verbosity);
6770
      fprintf (file, "%s}\n", s_indent);
6771
    }
6772
}
6773
 
6774
/* Print the LOOP and its sibling loops on FILE, indented INDENT
6775
   spaces.  Following VERBOSITY level this outputs the contents of the
6776
   loop, or just its structure.  */
6777
 
6778
static void
6779
print_loop_and_siblings (FILE *file, struct loop *loop, int indent, int verbosity)
6780
{
6781
  if (loop == NULL)
6782
    return;
6783
 
6784
  print_loop (file, loop, indent, verbosity);
6785
  print_loop_and_siblings (file, loop->next, indent, verbosity);
6786
}
6787
 
6788
/* Follow a CFG edge from the entry point of the program, and on entry
6789
   of a loop, pretty print the loop structure on FILE.  */
6790
 
6791
void
6792
print_loops (FILE *file, int verbosity)
6793
{
6794
  basic_block bb;
6795
 
6796
  bb = ENTRY_BLOCK_PTR;
6797
  if (bb && bb->loop_father)
6798
    print_loop_and_siblings (file, bb->loop_father, 0, verbosity);
6799
}
6800
 
6801
 
6802
/* Debugging loops structure at tree level, at some VERBOSITY level.  */
6803
 
6804
DEBUG_FUNCTION void
6805
debug_loops (int verbosity)
6806
{
6807
  print_loops (stderr, verbosity);
6808
}
6809
 
6810
/* Print on stderr the code of LOOP, at some VERBOSITY level.  */
6811
 
6812
DEBUG_FUNCTION void
6813
debug_loop (struct loop *loop, int verbosity)
6814
{
6815
  print_loop (stderr, loop, 0, verbosity);
6816
}
6817
 
6818
/* Print on stderr the code of loop number NUM, at some VERBOSITY
6819
   level.  */
6820
 
6821
DEBUG_FUNCTION void
6822
debug_loop_num (unsigned num, int verbosity)
6823
{
6824
  debug_loop (get_loop (num), verbosity);
6825
}
6826
 
6827
/* Return true if BB ends with a call, possibly followed by some
6828
   instructions that must stay with the call.  Return false,
6829
   otherwise.  */
6830
 
6831
static bool
6832
gimple_block_ends_with_call_p (basic_block bb)
6833
{
6834
  gimple_stmt_iterator gsi = gsi_last_nondebug_bb (bb);
6835
  return !gsi_end_p (gsi) && is_gimple_call (gsi_stmt (gsi));
6836
}
6837
 
6838
 
6839
/* Return true if BB ends with a conditional branch.  Return false,
6840
   otherwise.  */
6841
 
6842
static bool
6843
gimple_block_ends_with_condjump_p (const_basic_block bb)
6844
{
6845
  gimple stmt = last_stmt (CONST_CAST_BB (bb));
6846
  return (stmt && gimple_code (stmt) == GIMPLE_COND);
6847
}
6848
 
6849
 
6850
/* Return true if we need to add fake edge to exit at statement T.
6851
   Helper function for gimple_flow_call_edges_add.  */
6852
 
6853
static bool
6854
need_fake_edge_p (gimple t)
6855
{
6856
  tree fndecl = NULL_TREE;
6857
  int call_flags = 0;
6858
 
6859
  /* NORETURN and LONGJMP calls already have an edge to exit.
6860
     CONST and PURE calls do not need one.
6861
     We don't currently check for CONST and PURE here, although
6862
     it would be a good idea, because those attributes are
6863
     figured out from the RTL in mark_constant_function, and
6864
     the counter incrementation code from -fprofile-arcs
6865
     leads to different results from -fbranch-probabilities.  */
6866
  if (is_gimple_call (t))
6867
    {
6868
      fndecl = gimple_call_fndecl (t);
6869
      call_flags = gimple_call_flags (t);
6870
    }
6871
 
6872
  if (is_gimple_call (t)
6873
      && fndecl
6874
      && DECL_BUILT_IN (fndecl)
6875
      && (call_flags & ECF_NOTHROW)
6876
      && !(call_flags & ECF_RETURNS_TWICE)
6877
      /* fork() doesn't really return twice, but the effect of
6878
         wrapping it in __gcov_fork() which calls __gcov_flush()
6879
         and clears the counters before forking has the same
6880
         effect as returning twice.  Force a fake edge.  */
6881
      && !(DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
6882
           && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FORK))
6883
    return false;
6884
 
6885
  if (is_gimple_call (t))
6886
    {
6887
      edge_iterator ei;
6888
      edge e;
6889
      basic_block bb;
6890
 
6891
      if (!(call_flags & ECF_NORETURN))
6892
        return true;
6893
 
6894
      bb = gimple_bb (t);
6895
      FOR_EACH_EDGE (e, ei, bb->succs)
6896
        if ((e->flags & EDGE_FAKE) == 0)
6897
          return true;
6898
    }
6899
 
6900
  if (gimple_code (t) == GIMPLE_ASM
6901
       && (gimple_asm_volatile_p (t) || gimple_asm_input_p (t)))
6902
    return true;
6903
 
6904
  return false;
6905
}
6906
 
6907
 
6908
/* Add fake edges to the function exit for any non constant and non
6909
   noreturn calls (or noreturn calls with EH/abnormal edges),
6910
   volatile inline assembly in the bitmap of blocks specified by BLOCKS
6911
   or to the whole CFG if BLOCKS is zero.  Return the number of blocks
6912
   that were split.
6913
 
6914
   The goal is to expose cases in which entering a basic block does
6915
   not imply that all subsequent instructions must be executed.  */
6916
 
6917
static int
6918
gimple_flow_call_edges_add (sbitmap blocks)
6919
{
6920
  int i;
6921
  int blocks_split = 0;
6922
  int last_bb = last_basic_block;
6923
  bool check_last_block = false;
6924
 
6925
  if (n_basic_blocks == NUM_FIXED_BLOCKS)
6926
    return 0;
6927
 
6928
  if (! blocks)
6929
    check_last_block = true;
6930
  else
6931
    check_last_block = TEST_BIT (blocks, EXIT_BLOCK_PTR->prev_bb->index);
6932
 
6933
  /* In the last basic block, before epilogue generation, there will be
6934
     a fallthru edge to EXIT.  Special care is required if the last insn
6935
     of the last basic block is a call because make_edge folds duplicate
6936
     edges, which would result in the fallthru edge also being marked
6937
     fake, which would result in the fallthru edge being removed by
6938
     remove_fake_edges, which would result in an invalid CFG.
6939
 
6940
     Moreover, we can't elide the outgoing fake edge, since the block
6941
     profiler needs to take this into account in order to solve the minimal
6942
     spanning tree in the case that the call doesn't return.
6943
 
6944
     Handle this by adding a dummy instruction in a new last basic block.  */
6945
  if (check_last_block)
6946
    {
6947
      basic_block bb = EXIT_BLOCK_PTR->prev_bb;
6948
      gimple_stmt_iterator gsi = gsi_last_nondebug_bb (bb);
6949
      gimple t = NULL;
6950
 
6951
      if (!gsi_end_p (gsi))
6952
        t = gsi_stmt (gsi);
6953
 
6954
      if (t && need_fake_edge_p (t))
6955
        {
6956
          edge e;
6957
 
6958
          e = find_edge (bb, EXIT_BLOCK_PTR);
6959
          if (e)
6960
            {
6961
              gsi_insert_on_edge (e, gimple_build_nop ());
6962
              gsi_commit_edge_inserts ();
6963
            }
6964
        }
6965
    }
6966
 
6967
  /* Now add fake edges to the function exit for any non constant
6968
     calls since there is no way that we can determine if they will
6969
     return or not...  */
6970
  for (i = 0; i < last_bb; i++)
6971
    {
6972
      basic_block bb = BASIC_BLOCK (i);
6973
      gimple_stmt_iterator gsi;
6974
      gimple stmt, last_stmt;
6975
 
6976
      if (!bb)
6977
        continue;
6978
 
6979
      if (blocks && !TEST_BIT (blocks, i))
6980
        continue;
6981
 
6982
      gsi = gsi_last_nondebug_bb (bb);
6983
      if (!gsi_end_p (gsi))
6984
        {
6985
          last_stmt = gsi_stmt (gsi);
6986
          do
6987
            {
6988
              stmt = gsi_stmt (gsi);
6989
              if (need_fake_edge_p (stmt))
6990
                {
6991
                  edge e;
6992
 
6993
                  /* The handling above of the final block before the
6994
                     epilogue should be enough to verify that there is
6995
                     no edge to the exit block in CFG already.
6996
                     Calling make_edge in such case would cause us to
6997
                     mark that edge as fake and remove it later.  */
6998
#ifdef ENABLE_CHECKING
6999
                  if (stmt == last_stmt)
7000
                    {
7001
                      e = find_edge (bb, EXIT_BLOCK_PTR);
7002
                      gcc_assert (e == NULL);
7003
                    }
7004
#endif
7005
 
7006
                  /* Note that the following may create a new basic block
7007
                     and renumber the existing basic blocks.  */
7008
                  if (stmt != last_stmt)
7009
                    {
7010
                      e = split_block (bb, stmt);
7011
                      if (e)
7012
                        blocks_split++;
7013
                    }
7014
                  make_edge (bb, EXIT_BLOCK_PTR, EDGE_FAKE);
7015
                }
7016
              gsi_prev (&gsi);
7017
            }
7018
          while (!gsi_end_p (gsi));
7019
        }
7020
    }
7021
 
7022
  if (blocks_split)
7023
    verify_flow_info ();
7024
 
7025
  return blocks_split;
7026
}
7027
 
7028
/* Removes edge E and all the blocks dominated by it, and updates dominance
7029
   information.  The IL in E->src needs to be updated separately.
7030
   If dominance info is not available, only the edge E is removed.*/
7031
 
7032
void
7033
remove_edge_and_dominated_blocks (edge e)
7034
{
7035
  VEC (basic_block, heap) *bbs_to_remove = NULL;
7036
  VEC (basic_block, heap) *bbs_to_fix_dom = NULL;
7037
  bitmap df, df_idom;
7038
  edge f;
7039
  edge_iterator ei;
7040
  bool none_removed = false;
7041
  unsigned i;
7042
  basic_block bb, dbb;
7043
  bitmap_iterator bi;
7044
 
7045
  if (!dom_info_available_p (CDI_DOMINATORS))
7046
    {
7047
      remove_edge (e);
7048
      return;
7049
    }
7050
 
7051
  /* No updating is needed for edges to exit.  */
7052
  if (e->dest == EXIT_BLOCK_PTR)
7053
    {
7054
      if (cfgcleanup_altered_bbs)
7055
        bitmap_set_bit (cfgcleanup_altered_bbs, e->src->index);
7056
      remove_edge (e);
7057
      return;
7058
    }
7059
 
7060
  /* First, we find the basic blocks to remove.  If E->dest has a predecessor
7061
     that is not dominated by E->dest, then this set is empty.  Otherwise,
7062
     all the basic blocks dominated by E->dest are removed.
7063
 
7064
     Also, to DF_IDOM we store the immediate dominators of the blocks in
7065
     the dominance frontier of E (i.e., of the successors of the
7066
     removed blocks, if there are any, and of E->dest otherwise).  */
7067
  FOR_EACH_EDGE (f, ei, e->dest->preds)
7068
    {
7069
      if (f == e)
7070
        continue;
7071
 
7072
      if (!dominated_by_p (CDI_DOMINATORS, f->src, e->dest))
7073
        {
7074
          none_removed = true;
7075
          break;
7076
        }
7077
    }
7078
 
7079
  df = BITMAP_ALLOC (NULL);
7080
  df_idom = BITMAP_ALLOC (NULL);
7081
 
7082
  if (none_removed)
7083
    bitmap_set_bit (df_idom,
7084
                    get_immediate_dominator (CDI_DOMINATORS, e->dest)->index);
7085
  else
7086
    {
7087
      bbs_to_remove = get_all_dominated_blocks (CDI_DOMINATORS, e->dest);
7088
      FOR_EACH_VEC_ELT (basic_block, bbs_to_remove, i, bb)
7089
        {
7090
          FOR_EACH_EDGE (f, ei, bb->succs)
7091
            {
7092
              if (f->dest != EXIT_BLOCK_PTR)
7093
                bitmap_set_bit (df, f->dest->index);
7094
            }
7095
        }
7096
      FOR_EACH_VEC_ELT (basic_block, bbs_to_remove, i, bb)
7097
        bitmap_clear_bit (df, bb->index);
7098
 
7099
      EXECUTE_IF_SET_IN_BITMAP (df, 0, i, bi)
7100
        {
7101
          bb = BASIC_BLOCK (i);
7102
          bitmap_set_bit (df_idom,
7103
                          get_immediate_dominator (CDI_DOMINATORS, bb)->index);
7104
        }
7105
    }
7106
 
7107
  if (cfgcleanup_altered_bbs)
7108
    {
7109
      /* Record the set of the altered basic blocks.  */
7110
      bitmap_set_bit (cfgcleanup_altered_bbs, e->src->index);
7111
      bitmap_ior_into (cfgcleanup_altered_bbs, df);
7112
    }
7113
 
7114
  /* Remove E and the cancelled blocks.  */
7115
  if (none_removed)
7116
    remove_edge (e);
7117
  else
7118
    {
7119
      /* Walk backwards so as to get a chance to substitute all
7120
         released DEFs into debug stmts.  See
7121
         eliminate_unnecessary_stmts() in tree-ssa-dce.c for more
7122
         details.  */
7123
      for (i = VEC_length (basic_block, bbs_to_remove); i-- > 0; )
7124
        delete_basic_block (VEC_index (basic_block, bbs_to_remove, i));
7125
    }
7126
 
7127
  /* Update the dominance information.  The immediate dominator may change only
7128
     for blocks whose immediate dominator belongs to DF_IDOM:
7129
 
7130
     Suppose that idom(X) = Y before removal of E and idom(X) != Y after the
7131
     removal.  Let Z the arbitrary block such that idom(Z) = Y and
7132
     Z dominates X after the removal.  Before removal, there exists a path P
7133
     from Y to X that avoids Z.  Let F be the last edge on P that is
7134
     removed, and let W = F->dest.  Before removal, idom(W) = Y (since Y
7135
     dominates W, and because of P, Z does not dominate W), and W belongs to
7136
     the dominance frontier of E.  Therefore, Y belongs to DF_IDOM.  */
7137
  EXECUTE_IF_SET_IN_BITMAP (df_idom, 0, i, bi)
7138
    {
7139
      bb = BASIC_BLOCK (i);
7140
      for (dbb = first_dom_son (CDI_DOMINATORS, bb);
7141
           dbb;
7142
           dbb = next_dom_son (CDI_DOMINATORS, dbb))
7143
        VEC_safe_push (basic_block, heap, bbs_to_fix_dom, dbb);
7144
    }
7145
 
7146
  iterate_fix_dominators (CDI_DOMINATORS, bbs_to_fix_dom, true);
7147
 
7148
  BITMAP_FREE (df);
7149
  BITMAP_FREE (df_idom);
7150
  VEC_free (basic_block, heap, bbs_to_remove);
7151
  VEC_free (basic_block, heap, bbs_to_fix_dom);
7152
}
7153
 
7154
/* Purge dead EH edges from basic block BB.  */
7155
 
7156
bool
7157
gimple_purge_dead_eh_edges (basic_block bb)
7158
{
7159
  bool changed = false;
7160
  edge e;
7161
  edge_iterator ei;
7162
  gimple stmt = last_stmt (bb);
7163
 
7164
  if (stmt && stmt_can_throw_internal (stmt))
7165
    return false;
7166
 
7167
  for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
7168
    {
7169
      if (e->flags & EDGE_EH)
7170
        {
7171
          remove_edge_and_dominated_blocks (e);
7172
          changed = true;
7173
        }
7174
      else
7175
        ei_next (&ei);
7176
    }
7177
 
7178
  return changed;
7179
}
7180
 
7181
/* Purge dead EH edges from basic block listed in BLOCKS.  */
7182
 
7183
bool
7184
gimple_purge_all_dead_eh_edges (const_bitmap blocks)
7185
{
7186
  bool changed = false;
7187
  unsigned i;
7188
  bitmap_iterator bi;
7189
 
7190
  EXECUTE_IF_SET_IN_BITMAP (blocks, 0, i, bi)
7191
    {
7192
      basic_block bb = BASIC_BLOCK (i);
7193
 
7194
      /* Earlier gimple_purge_dead_eh_edges could have removed
7195
         this basic block already.  */
7196
      gcc_assert (bb || changed);
7197
      if (bb != NULL)
7198
        changed |= gimple_purge_dead_eh_edges (bb);
7199
    }
7200
 
7201
  return changed;
7202
}
7203
 
7204
/* Purge dead abnormal call edges from basic block BB.  */
7205
 
7206
bool
7207
gimple_purge_dead_abnormal_call_edges (basic_block bb)
7208
{
7209
  bool changed = false;
7210
  edge e;
7211
  edge_iterator ei;
7212
  gimple stmt = last_stmt (bb);
7213
 
7214
  if (!cfun->has_nonlocal_label)
7215
    return false;
7216
 
7217
  if (stmt && stmt_can_make_abnormal_goto (stmt))
7218
    return false;
7219
 
7220
  for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
7221
    {
7222
      if (e->flags & EDGE_ABNORMAL)
7223
        {
7224
          remove_edge_and_dominated_blocks (e);
7225
          changed = true;
7226
        }
7227
      else
7228
        ei_next (&ei);
7229
    }
7230
 
7231
  return changed;
7232
}
7233
 
7234
/* Purge dead abnormal call edges from basic block listed in BLOCKS.  */
7235
 
7236
bool
7237
gimple_purge_all_dead_abnormal_call_edges (const_bitmap blocks)
7238
{
7239
  bool changed = false;
7240
  unsigned i;
7241
  bitmap_iterator bi;
7242
 
7243
  EXECUTE_IF_SET_IN_BITMAP (blocks, 0, i, bi)
7244
    {
7245
      basic_block bb = BASIC_BLOCK (i);
7246
 
7247
      /* Earlier gimple_purge_dead_abnormal_call_edges could have removed
7248
         this basic block already.  */
7249
      gcc_assert (bb || changed);
7250
      if (bb != NULL)
7251
        changed |= gimple_purge_dead_abnormal_call_edges (bb);
7252
    }
7253
 
7254
  return changed;
7255
}
7256
 
7257
/* This function is called whenever a new edge is created or
7258
   redirected.  */
7259
 
7260
static void
7261
gimple_execute_on_growing_pred (edge e)
7262
{
7263
  basic_block bb = e->dest;
7264
 
7265
  if (!gimple_seq_empty_p (phi_nodes (bb)))
7266
    reserve_phi_args_for_new_edge (bb);
7267
}
7268
 
7269
/* This function is called immediately before edge E is removed from
7270
   the edge vector E->dest->preds.  */
7271
 
7272
static void
7273
gimple_execute_on_shrinking_pred (edge e)
7274
{
7275
  if (!gimple_seq_empty_p (phi_nodes (e->dest)))
7276
    remove_phi_args (e);
7277
}
7278
 
7279
/*---------------------------------------------------------------------------
7280
  Helper functions for Loop versioning
7281
  ---------------------------------------------------------------------------*/
7282
 
7283
/* Adjust phi nodes for 'first' basic block.  'second' basic block is a copy
7284
   of 'first'. Both of them are dominated by 'new_head' basic block. When
7285
   'new_head' was created by 'second's incoming edge it received phi arguments
7286
   on the edge by split_edge(). Later, additional edge 'e' was created to
7287
   connect 'new_head' and 'first'. Now this routine adds phi args on this
7288
   additional edge 'e' that new_head to second edge received as part of edge
7289
   splitting.  */
7290
 
7291
static void
7292
gimple_lv_adjust_loop_header_phi (basic_block first, basic_block second,
7293
                                  basic_block new_head, edge e)
7294
{
7295
  gimple phi1, phi2;
7296
  gimple_stmt_iterator psi1, psi2;
7297
  tree def;
7298
  edge e2 = find_edge (new_head, second);
7299
 
7300
  /* Because NEW_HEAD has been created by splitting SECOND's incoming
7301
     edge, we should always have an edge from NEW_HEAD to SECOND.  */
7302
  gcc_assert (e2 != NULL);
7303
 
7304
  /* Browse all 'second' basic block phi nodes and add phi args to
7305
     edge 'e' for 'first' head. PHI args are always in correct order.  */
7306
 
7307
  for (psi2 = gsi_start_phis (second),
7308
       psi1 = gsi_start_phis (first);
7309
       !gsi_end_p (psi2) && !gsi_end_p (psi1);
7310
       gsi_next (&psi2),  gsi_next (&psi1))
7311
    {
7312
      phi1 = gsi_stmt (psi1);
7313
      phi2 = gsi_stmt (psi2);
7314
      def = PHI_ARG_DEF (phi2, e2->dest_idx);
7315
      add_phi_arg (phi1, def, e, gimple_phi_arg_location_from_edge (phi2, e2));
7316
    }
7317
}
7318
 
7319
 
7320
/* Adds a if else statement to COND_BB with condition COND_EXPR.
7321
   SECOND_HEAD is the destination of the THEN and FIRST_HEAD is
7322
   the destination of the ELSE part.  */
7323
 
7324
static void
7325
gimple_lv_add_condition_to_bb (basic_block first_head ATTRIBUTE_UNUSED,
7326
                               basic_block second_head ATTRIBUTE_UNUSED,
7327
                               basic_block cond_bb, void *cond_e)
7328
{
7329
  gimple_stmt_iterator gsi;
7330
  gimple new_cond_expr;
7331
  tree cond_expr = (tree) cond_e;
7332
  edge e0;
7333
 
7334
  /* Build new conditional expr */
7335
  new_cond_expr = gimple_build_cond_from_tree (cond_expr,
7336
                                               NULL_TREE, NULL_TREE);
7337
 
7338
  /* Add new cond in cond_bb.  */
7339
  gsi = gsi_last_bb (cond_bb);
7340
  gsi_insert_after (&gsi, new_cond_expr, GSI_NEW_STMT);
7341
 
7342
  /* Adjust edges appropriately to connect new head with first head
7343
     as well as second head.  */
7344
  e0 = single_succ_edge (cond_bb);
7345
  e0->flags &= ~EDGE_FALLTHRU;
7346
  e0->flags |= EDGE_FALSE_VALUE;
7347
}
7348
 
7349
struct cfg_hooks gimple_cfg_hooks = {
7350
  "gimple",
7351
  gimple_verify_flow_info,
7352
  gimple_dump_bb,               /* dump_bb  */
7353
  create_bb,                    /* create_basic_block  */
7354
  gimple_redirect_edge_and_branch, /* redirect_edge_and_branch  */
7355
  gimple_redirect_edge_and_branch_force, /* redirect_edge_and_branch_force  */
7356
  gimple_can_remove_branch_p,   /* can_remove_branch_p  */
7357
  remove_bb,                    /* delete_basic_block  */
7358
  gimple_split_block,           /* split_block  */
7359
  gimple_move_block_after,      /* move_block_after  */
7360
  gimple_can_merge_blocks_p,    /* can_merge_blocks_p  */
7361
  gimple_merge_blocks,          /* merge_blocks  */
7362
  gimple_predict_edge,          /* predict_edge  */
7363
  gimple_predicted_by_p,        /* predicted_by_p  */
7364
  gimple_can_duplicate_bb_p,    /* can_duplicate_block_p  */
7365
  gimple_duplicate_bb,          /* duplicate_block  */
7366
  gimple_split_edge,            /* split_edge  */
7367
  gimple_make_forwarder_block,  /* make_forward_block  */
7368
  NULL,                         /* tidy_fallthru_edge  */
7369
  NULL,                         /* force_nonfallthru */
7370
  gimple_block_ends_with_call_p,/* block_ends_with_call_p */
7371
  gimple_block_ends_with_condjump_p, /* block_ends_with_condjump_p */
7372
  gimple_flow_call_edges_add,   /* flow_call_edges_add */
7373
  gimple_execute_on_growing_pred,       /* execute_on_growing_pred */
7374
  gimple_execute_on_shrinking_pred, /* execute_on_shrinking_pred */
7375
  gimple_duplicate_loop_to_header_edge, /* duplicate loop for trees */
7376
  gimple_lv_add_condition_to_bb, /* lv_add_condition_to_bb */
7377
  gimple_lv_adjust_loop_header_phi, /* lv_adjust_loop_header_phi*/
7378
  extract_true_false_edges_from_block, /* extract_cond_bb_edges */
7379
  flush_pending_stmts           /* flush_pending_stmts */
7380
};
7381
 
7382
 
7383
/* Split all critical edges.  */
7384
 
7385
static unsigned int
7386
split_critical_edges (void)
7387
{
7388
  basic_block bb;
7389
  edge e;
7390
  edge_iterator ei;
7391
 
7392
  /* split_edge can redirect edges out of SWITCH_EXPRs, which can get
7393
     expensive.  So we want to enable recording of edge to CASE_LABEL_EXPR
7394
     mappings around the calls to split_edge.  */
7395
  start_recording_case_labels ();
7396
  FOR_ALL_BB (bb)
7397
    {
7398
      FOR_EACH_EDGE (e, ei, bb->succs)
7399
        {
7400
          if (EDGE_CRITICAL_P (e) && !(e->flags & EDGE_ABNORMAL))
7401
            split_edge (e);
7402
          /* PRE inserts statements to edges and expects that
7403
             since split_critical_edges was done beforehand, committing edge
7404
             insertions will not split more edges.  In addition to critical
7405
             edges we must split edges that have multiple successors and
7406
             end by control flow statements, such as RESX.
7407
             Go ahead and split them too.  This matches the logic in
7408
             gimple_find_edge_insert_loc.  */
7409
          else if ((!single_pred_p (e->dest)
7410
                    || !gimple_seq_empty_p (phi_nodes (e->dest))
7411
                    || e->dest == EXIT_BLOCK_PTR)
7412
                   && e->src != ENTRY_BLOCK_PTR
7413
                   && !(e->flags & EDGE_ABNORMAL))
7414
            {
7415
              gimple_stmt_iterator gsi;
7416
 
7417
              gsi = gsi_last_bb (e->src);
7418
              if (!gsi_end_p (gsi)
7419
                  && stmt_ends_bb_p (gsi_stmt (gsi))
7420
                  && (gimple_code (gsi_stmt (gsi)) != GIMPLE_RETURN
7421
                      && !gimple_call_builtin_p (gsi_stmt (gsi),
7422
                                                 BUILT_IN_RETURN)))
7423
                split_edge (e);
7424
            }
7425
        }
7426
    }
7427
  end_recording_case_labels ();
7428
  return 0;
7429
}
7430
 
7431
struct gimple_opt_pass pass_split_crit_edges =
7432
{
7433
 {
7434
  GIMPLE_PASS,
7435
  "crited",                          /* name */
7436
  NULL,                          /* gate */
7437
  split_critical_edges,          /* execute */
7438
  NULL,                          /* sub */
7439
  NULL,                          /* next */
7440
  0,                             /* static_pass_number */
7441
  TV_TREE_SPLIT_EDGES,           /* tv_id */
7442
  PROP_cfg,                      /* properties required */
7443
  PROP_no_crit_edges,            /* properties_provided */
7444
  0,                             /* properties_destroyed */
7445
  0,                             /* todo_flags_start */
7446
  TODO_verify_flow               /* todo_flags_finish */
7447
 }
7448
};
7449
 
7450
 
7451
/* Build a ternary operation and gimplify it.  Emit code before GSI.
7452
   Return the gimple_val holding the result.  */
7453
 
7454
tree
7455
gimplify_build3 (gimple_stmt_iterator *gsi, enum tree_code code,
7456
                 tree type, tree a, tree b, tree c)
7457
{
7458
  tree ret;
7459
  location_t loc = gimple_location (gsi_stmt (*gsi));
7460
 
7461
  ret = fold_build3_loc (loc, code, type, a, b, c);
7462
  STRIP_NOPS (ret);
7463
 
7464
  return force_gimple_operand_gsi (gsi, ret, true, NULL, true,
7465
                                   GSI_SAME_STMT);
7466
}
7467
 
7468
/* Build a binary operation and gimplify it.  Emit code before GSI.
7469
   Return the gimple_val holding the result.  */
7470
 
7471
tree
7472
gimplify_build2 (gimple_stmt_iterator *gsi, enum tree_code code,
7473
                 tree type, tree a, tree b)
7474
{
7475
  tree ret;
7476
 
7477
  ret = fold_build2_loc (gimple_location (gsi_stmt (*gsi)), code, type, a, b);
7478
  STRIP_NOPS (ret);
7479
 
7480
  return force_gimple_operand_gsi (gsi, ret, true, NULL, true,
7481
                                   GSI_SAME_STMT);
7482
}
7483
 
7484
/* Build a unary operation and gimplify it.  Emit code before GSI.
7485
   Return the gimple_val holding the result.  */
7486
 
7487
tree
7488
gimplify_build1 (gimple_stmt_iterator *gsi, enum tree_code code, tree type,
7489
                 tree a)
7490
{
7491
  tree ret;
7492
 
7493
  ret = fold_build1_loc (gimple_location (gsi_stmt (*gsi)), code, type, a);
7494
  STRIP_NOPS (ret);
7495
 
7496
  return force_gimple_operand_gsi (gsi, ret, true, NULL, true,
7497
                                   GSI_SAME_STMT);
7498
}
7499
 
7500
 
7501
 
7502
/* Emit return warnings.  */
7503
 
7504
static unsigned int
7505
execute_warn_function_return (void)
7506
{
7507
  source_location location;
7508
  gimple last;
7509
  edge e;
7510
  edge_iterator ei;
7511
 
7512
  /* If we have a path to EXIT, then we do return.  */
7513
  if (TREE_THIS_VOLATILE (cfun->decl)
7514
      && EDGE_COUNT (EXIT_BLOCK_PTR->preds) > 0)
7515
    {
7516
      location = UNKNOWN_LOCATION;
7517
      FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
7518
        {
7519
          last = last_stmt (e->src);
7520
          if ((gimple_code (last) == GIMPLE_RETURN
7521
               || gimple_call_builtin_p (last, BUILT_IN_RETURN))
7522
              && (location = gimple_location (last)) != UNKNOWN_LOCATION)
7523
            break;
7524
        }
7525
      if (location == UNKNOWN_LOCATION)
7526
        location = cfun->function_end_locus;
7527
      warning_at (location, 0, "%<noreturn%> function does return");
7528
    }
7529
 
7530
  /* If we see "return;" in some basic block, then we do reach the end
7531
     without returning a value.  */
7532
  else if (warn_return_type
7533
           && !TREE_NO_WARNING (cfun->decl)
7534
           && EDGE_COUNT (EXIT_BLOCK_PTR->preds) > 0
7535
           && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (cfun->decl))))
7536
    {
7537
      FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
7538
        {
7539
          gimple last = last_stmt (e->src);
7540
          if (gimple_code (last) == GIMPLE_RETURN
7541
              && gimple_return_retval (last) == NULL
7542
              && !gimple_no_warning_p (last))
7543
            {
7544
              location = gimple_location (last);
7545
              if (location == UNKNOWN_LOCATION)
7546
                  location = cfun->function_end_locus;
7547
              warning_at (location, OPT_Wreturn_type, "control reaches end of non-void function");
7548
              TREE_NO_WARNING (cfun->decl) = 1;
7549
              break;
7550
            }
7551
        }
7552
    }
7553
  return 0;
7554
}
7555
 
7556
 
7557
/* Given a basic block B which ends with a conditional and has
7558
   precisely two successors, determine which of the edges is taken if
7559
   the conditional is true and which is taken if the conditional is
7560
   false.  Set TRUE_EDGE and FALSE_EDGE appropriately.  */
7561
 
7562
void
7563
extract_true_false_edges_from_block (basic_block b,
7564
                                     edge *true_edge,
7565
                                     edge *false_edge)
7566
{
7567
  edge e = EDGE_SUCC (b, 0);
7568
 
7569
  if (e->flags & EDGE_TRUE_VALUE)
7570
    {
7571
      *true_edge = e;
7572
      *false_edge = EDGE_SUCC (b, 1);
7573
    }
7574
  else
7575
    {
7576
      *false_edge = e;
7577
      *true_edge = EDGE_SUCC (b, 1);
7578
    }
7579
}
7580
 
7581
struct gimple_opt_pass pass_warn_function_return =
7582
{
7583
 {
7584
  GIMPLE_PASS,
7585
  "*warn_function_return",              /* name */
7586
  NULL,                                 /* gate */
7587
  execute_warn_function_return,         /* execute */
7588
  NULL,                                 /* sub */
7589
  NULL,                                 /* next */
7590
  0,                                     /* static_pass_number */
7591
  TV_NONE,                              /* tv_id */
7592
  PROP_cfg,                             /* properties_required */
7593
  0,                                     /* properties_provided */
7594
  0,                                     /* properties_destroyed */
7595
  0,                                     /* todo_flags_start */
7596
 
7597
 }
7598
};
7599
 
7600
/* Emit noreturn warnings.  */
7601
 
7602
static unsigned int
7603
execute_warn_function_noreturn (void)
7604
{
7605
  if (!TREE_THIS_VOLATILE (current_function_decl)
7606
      && EDGE_COUNT (EXIT_BLOCK_PTR->preds) == 0)
7607
    warn_function_noreturn (current_function_decl);
7608
  return 0;
7609
}
7610
 
7611
static bool
7612
gate_warn_function_noreturn (void)
7613
{
7614
  return warn_suggest_attribute_noreturn;
7615
}
7616
 
7617
struct gimple_opt_pass pass_warn_function_noreturn =
7618
{
7619
 {
7620
  GIMPLE_PASS,
7621
  "*warn_function_noreturn",            /* name */
7622
  gate_warn_function_noreturn,          /* gate */
7623
  execute_warn_function_noreturn,       /* execute */
7624
  NULL,                                 /* sub */
7625
  NULL,                                 /* next */
7626
  0,                                     /* static_pass_number */
7627
  TV_NONE,                              /* tv_id */
7628
  PROP_cfg,                             /* properties_required */
7629
  0,                                     /* properties_provided */
7630
  0,                                     /* properties_destroyed */
7631
  0,                                     /* todo_flags_start */
7632
 
7633
 }
7634
};
7635
 
7636
 
7637
/* Walk a gimplified function and warn for functions whose return value is
7638
   ignored and attribute((warn_unused_result)) is set.  This is done before
7639
   inlining, so we don't have to worry about that.  */
7640
 
7641
static void
7642
do_warn_unused_result (gimple_seq seq)
7643
{
7644
  tree fdecl, ftype;
7645
  gimple_stmt_iterator i;
7646
 
7647
  for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
7648
    {
7649
      gimple g = gsi_stmt (i);
7650
 
7651
      switch (gimple_code (g))
7652
        {
7653
        case GIMPLE_BIND:
7654
          do_warn_unused_result (gimple_bind_body (g));
7655
          break;
7656
        case GIMPLE_TRY:
7657
          do_warn_unused_result (gimple_try_eval (g));
7658
          do_warn_unused_result (gimple_try_cleanup (g));
7659
          break;
7660
        case GIMPLE_CATCH:
7661
          do_warn_unused_result (gimple_catch_handler (g));
7662
          break;
7663
        case GIMPLE_EH_FILTER:
7664
          do_warn_unused_result (gimple_eh_filter_failure (g));
7665
          break;
7666
 
7667
        case GIMPLE_CALL:
7668
          if (gimple_call_lhs (g))
7669
            break;
7670
          if (gimple_call_internal_p (g))
7671
            break;
7672
 
7673
          /* This is a naked call, as opposed to a GIMPLE_CALL with an
7674
             LHS.  All calls whose value is ignored should be
7675
             represented like this.  Look for the attribute.  */
7676
          fdecl = gimple_call_fndecl (g);
7677
          ftype = gimple_call_fntype (g);
7678
 
7679
          if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
7680
            {
7681
              location_t loc = gimple_location (g);
7682
 
7683
              if (fdecl)
7684
                warning_at (loc, OPT_Wunused_result,
7685
                            "ignoring return value of %qD, "
7686
                            "declared with attribute warn_unused_result",
7687
                            fdecl);
7688
              else
7689
                warning_at (loc, OPT_Wunused_result,
7690
                            "ignoring return value of function "
7691
                            "declared with attribute warn_unused_result");
7692
            }
7693
          break;
7694
 
7695
        default:
7696
          /* Not a container, not a call, or a call whose value is used.  */
7697
          break;
7698
        }
7699
    }
7700
}
7701
 
7702
static unsigned int
7703
run_warn_unused_result (void)
7704
{
7705
  do_warn_unused_result (gimple_body (current_function_decl));
7706
  return 0;
7707
}
7708
 
7709
static bool
7710
gate_warn_unused_result (void)
7711
{
7712
  return flag_warn_unused_result;
7713
}
7714
 
7715
struct gimple_opt_pass pass_warn_unused_result =
7716
{
7717
  {
7718
    GIMPLE_PASS,
7719
    "*warn_unused_result",              /* name */
7720
    gate_warn_unused_result,            /* gate */
7721
    run_warn_unused_result,             /* execute */
7722
    NULL,                               /* sub */
7723
    NULL,                               /* next */
7724
    0,                                   /* static_pass_number */
7725
    TV_NONE,                            /* tv_id */
7726
    PROP_gimple_any,                    /* properties_required */
7727
    0,                                   /* properties_provided */
7728
    0,                                   /* properties_destroyed */
7729
    0,                                   /* todo_flags_start */
7730
    0,                                   /* todo_flags_finish */
7731
  }
7732
};

powered by: WebSVN 2.1.0

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