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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gcc-4.5.1/] [gcc/] [gimple-iterator.c] - Blame information for rev 826

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 280 jeremybenn
/* Iterator routines for GIMPLE statements.
2
   Copyright (C) 2007, 2008, 2010 Free Software Foundation, Inc.
3
   Contributed by Aldy Hernandez  <aldy@quesejoda.com>
4
 
5
This file is part of GCC.
6
 
7
GCC is free software; you can redistribute it and/or modify it under
8
the terms of the GNU General Public License as published by the Free
9
Software Foundation; either version 3, or (at your option) any later
10
version.
11
 
12
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13
WARRANTY; without even the implied warranty of MERCHANTABILITY or
14
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15
for more details.
16
 
17
You should have received a copy of the GNU General Public License
18
along with GCC; see the file COPYING3.  If not see
19
<http://www.gnu.org/licenses/>.  */
20
 
21
#include "config.h"
22
#include "system.h"
23
#include "coretypes.h"
24
#include "tm.h"
25
#include "tree.h"
26
#include "gimple.h"
27
#include "tree-flow.h"
28
#include "value-prof.h"
29
 
30
 
31
/* Mark the statement STMT as modified, and update it.  */
32
 
33
static inline void
34
update_modified_stmt (gimple stmt)
35
{
36
  if (!ssa_operands_active ())
37
    return;
38
  update_stmt_if_modified (stmt);
39
}
40
 
41
 
42
/* Mark the statements in SEQ as modified, and update them.  */
43
 
44
static void
45
update_modified_stmts (gimple_seq seq)
46
{
47
  gimple_stmt_iterator gsi;
48
 
49
  if (!ssa_operands_active ())
50
    return;
51
  for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
52
    update_stmt_if_modified (gsi_stmt (gsi));
53
}
54
 
55
 
56
/* Set BB to be the basic block for all the statements in the list
57
   starting at FIRST and LAST.  */
58
 
59
static void
60
update_bb_for_stmts (gimple_seq_node first, basic_block bb)
61
{
62
  gimple_seq_node n;
63
 
64
  for (n = first; n; n = n->next)
65
    gimple_set_bb (n->stmt, bb);
66
}
67
 
68
 
69
/* Insert the sequence delimited by nodes FIRST and LAST before
70
   iterator I.  M specifies how to update iterator I after insertion
71
   (see enum gsi_iterator_update).
72
 
73
   This routine assumes that there is a forward and backward path
74
   between FIRST and LAST (i.e., they are linked in a doubly-linked
75
   list).  Additionally, if FIRST == LAST, this routine will properly
76
   insert a single node.  */
77
 
78
static void
79
gsi_insert_seq_nodes_before (gimple_stmt_iterator *i,
80
                             gimple_seq_node first,
81
                             gimple_seq_node last,
82
                             enum gsi_iterator_update mode)
83
{
84
  basic_block bb;
85
  gimple_seq_node cur = i->ptr;
86
 
87
  if ((bb = gsi_bb (*i)) != NULL)
88
    update_bb_for_stmts (first, bb);
89
 
90
  /* Link SEQ before CUR in the sequence.  */
91
  if (cur)
92
    {
93
      first->prev = cur->prev;
94
      if (first->prev)
95
        first->prev->next = first;
96
      else
97
        gimple_seq_set_first (i->seq, first);
98
      last->next = cur;
99
      cur->prev = last;
100
    }
101
  else
102
    {
103
      gimple_seq_node itlast = gimple_seq_last (i->seq);
104
 
105
      /* If CUR is NULL, we link at the end of the sequence (this case happens
106
         when gsi_after_labels is called for a basic block that contains only
107
         labels, so it returns an iterator after the end of the block, and
108
         we need to insert before it; it might be cleaner to add a flag to the
109
         iterator saying whether we are at the start or end of the list).  */
110
      first->prev = itlast;
111
      if (itlast)
112
        itlast->next = first;
113
      else
114
        gimple_seq_set_first (i->seq, first);
115
      gimple_seq_set_last (i->seq, last);
116
    }
117
 
118
  /* Update the iterator, if requested.  */
119
  switch (mode)
120
    {
121
    case GSI_NEW_STMT:
122
    case GSI_CONTINUE_LINKING:
123
      i->ptr = first;
124
      break;
125
    case GSI_SAME_STMT:
126
      break;
127
    default:
128
      gcc_unreachable ();
129
    }
130
}
131
 
132
 
133
/* Inserts the sequence of statements SEQ before the statement pointed
134
   by iterator I.  MODE indicates what to do with the iterator after
135
   insertion (see enum gsi_iterator_update).
136
 
137
   This function does not scan for new operands.  It is provided for
138
   the use of the gimplifier, which manipulates statements for which
139
   def/use information has not yet been constructed.  Most callers
140
   should use gsi_insert_seq_before.  */
141
 
142
void
143
gsi_insert_seq_before_without_update (gimple_stmt_iterator *i, gimple_seq seq,
144
                                      enum gsi_iterator_update mode)
145
{
146
  gimple_seq_node first, last;
147
 
148
  if (seq == NULL)
149
    return;
150
 
151
  /* Don't allow inserting a sequence into itself.  */
152
  gcc_assert (seq != i->seq);
153
 
154
  first = gimple_seq_first (seq);
155
  last = gimple_seq_last (seq);
156
 
157
  gimple_seq_set_first (seq, NULL);
158
  gimple_seq_set_last (seq, NULL);
159
  gimple_seq_free (seq);
160
 
161
  /* Empty sequences need no work.  */
162
  if (!first || !last)
163
    {
164
      gcc_assert (first == last);
165
      return;
166
    }
167
 
168
  gsi_insert_seq_nodes_before (i, first, last, mode);
169
}
170
 
171
 
172
/* Inserts the sequence of statements SEQ before the statement pointed
173
   by iterator I.  MODE indicates what to do with the iterator after
174
   insertion (see enum gsi_iterator_update). Scan the statements in SEQ
175
   for new operands.  */
176
 
177
void
178
gsi_insert_seq_before (gimple_stmt_iterator *i, gimple_seq seq,
179
                       enum gsi_iterator_update mode)
180
{
181
  update_modified_stmts (seq);
182
  gsi_insert_seq_before_without_update (i, seq, mode);
183
}
184
 
185
 
186
/* Insert the sequence delimited by nodes FIRST and LAST after
187
   iterator I.  M specifies how to update iterator I after insertion
188
   (see enum gsi_iterator_update).
189
 
190
   This routine assumes that there is a forward and backward path
191
   between FIRST and LAST (i.e., they are linked in a doubly-linked
192
   list).  Additionally, if FIRST == LAST, this routine will properly
193
   insert a single node.  */
194
 
195
static void
196
gsi_insert_seq_nodes_after (gimple_stmt_iterator *i,
197
                            gimple_seq_node first,
198
                            gimple_seq_node last,
199
                            enum gsi_iterator_update m)
200
{
201
  basic_block bb;
202
  gimple_seq_node cur = i->ptr;
203
 
204
  /* If the iterator is inside a basic block, we need to update the
205
     basic block information for all the nodes between FIRST and LAST.  */
206
  if ((bb = gsi_bb (*i)) != NULL)
207
    update_bb_for_stmts (first, bb);
208
 
209
  /* Link SEQ after CUR.  */
210
  if (cur)
211
    {
212
      last->next = cur->next;
213
      if (last->next)
214
        last->next->prev = last;
215
      else
216
        gimple_seq_set_last (i->seq, last);
217
      first->prev = cur;
218
      cur->next = first;
219
    }
220
  else
221
    {
222
      gcc_assert (!gimple_seq_last (i->seq));
223
      gimple_seq_set_first (i->seq, first);
224
      gimple_seq_set_last (i->seq, last);
225
    }
226
 
227
  /* Update the iterator, if requested.  */
228
  switch (m)
229
    {
230
    case GSI_NEW_STMT:
231
      i->ptr = first;
232
      break;
233
    case GSI_CONTINUE_LINKING:
234
      i->ptr = last;
235
      break;
236
    case GSI_SAME_STMT:
237
      gcc_assert (cur);
238
      break;
239
    default:
240
      gcc_unreachable ();
241
    }
242
}
243
 
244
 
245
/* Links sequence SEQ after the statement pointed-to by iterator I.
246
   MODE is as in gsi_insert_after.
247
 
248
   This function does not scan for new operands.  It is provided for
249
   the use of the gimplifier, which manipulates statements for which
250
   def/use information has not yet been constructed.  Most callers
251
   should use gsi_insert_seq_after.  */
252
 
253
void
254
gsi_insert_seq_after_without_update (gimple_stmt_iterator *i, gimple_seq seq,
255
                                     enum gsi_iterator_update mode)
256
{
257
  gimple_seq_node first, last;
258
 
259
  if (seq == NULL)
260
    return;
261
 
262
  /* Don't allow inserting a sequence into itself.  */
263
  gcc_assert (seq != i->seq);
264
 
265
  first = gimple_seq_first (seq);
266
  last = gimple_seq_last (seq);
267
 
268
  gimple_seq_set_first (seq, NULL);
269
  gimple_seq_set_last (seq, NULL);
270
  gimple_seq_free (seq);
271
 
272
  /* Empty sequences need no work.  */
273
  if (!first || !last)
274
    {
275
      gcc_assert (first == last);
276
      return;
277
    }
278
 
279
  gsi_insert_seq_nodes_after (i, first, last, mode);
280
}
281
 
282
 
283
/* Links sequence SEQ after the statement pointed-to by iterator I.
284
   MODE is as in gsi_insert_after.  Scan the statements in SEQ
285
   for new operands.  */
286
 
287
void
288
gsi_insert_seq_after (gimple_stmt_iterator *i, gimple_seq seq,
289
                      enum gsi_iterator_update mode)
290
{
291
  update_modified_stmts (seq);
292
  gsi_insert_seq_after_without_update (i, seq, mode);
293
}
294
 
295
 
296
/* Move all statements in the sequence after I to a new sequence.
297
   Return this new sequence.  */
298
 
299
gimple_seq
300
gsi_split_seq_after (gimple_stmt_iterator i)
301
{
302
  gimple_seq_node cur, next;
303
  gimple_seq old_seq, new_seq;
304
 
305
  cur = i.ptr;
306
 
307
  /* How can we possibly split after the end, or before the beginning?  */
308
  gcc_assert (cur && cur->next);
309
  next = cur->next;
310
 
311
  old_seq = i.seq;
312
  new_seq = gimple_seq_alloc ();
313
 
314
  gimple_seq_set_first (new_seq, next);
315
  gimple_seq_set_last (new_seq, gimple_seq_last (old_seq));
316
  gimple_seq_set_last (old_seq, cur);
317
  cur->next = NULL;
318
  next->prev = NULL;
319
 
320
  return new_seq;
321
}
322
 
323
 
324
/* Move all statements in the sequence before I to a new sequence.
325
   Return this new sequence.  I is set to the head of the new list.  */
326
 
327
gimple_seq
328
gsi_split_seq_before (gimple_stmt_iterator *i)
329
{
330
  gimple_seq_node cur, prev;
331
  gimple_seq old_seq, new_seq;
332
 
333
  cur = i->ptr;
334
 
335
  /* How can we possibly split after the end?  */
336
  gcc_assert (cur);
337
  prev = cur->prev;
338
 
339
  old_seq = i->seq;
340
  new_seq = gimple_seq_alloc ();
341
  i->seq = new_seq;
342
 
343
  /* Set the limits on NEW_SEQ.  */
344
  gimple_seq_set_first (new_seq, cur);
345
  gimple_seq_set_last (new_seq, gimple_seq_last (old_seq));
346
 
347
  /* Cut OLD_SEQ before I.  */
348
  gimple_seq_set_last (old_seq, prev);
349
  cur->prev = NULL;
350
  if (prev)
351
    prev->next = NULL;
352
  else
353
    gimple_seq_set_first (old_seq, NULL);
354
 
355
  return new_seq;
356
}
357
 
358
 
359
/* Replace the statement pointed-to by GSI to STMT.  If UPDATE_EH_INFO
360
   is true, the exception handling information of the original
361
   statement is moved to the new statement.  Assignments must only be
362
   replaced with assignments to the same LHS.  */
363
 
364
void
365
gsi_replace (gimple_stmt_iterator *gsi, gimple stmt, bool update_eh_info)
366
{
367
  gimple orig_stmt = gsi_stmt (*gsi);
368
 
369
  if (stmt == orig_stmt)
370
    return;
371
 
372
  gcc_assert (!gimple_has_lhs (orig_stmt)
373
              || gimple_get_lhs (orig_stmt) == gimple_get_lhs (stmt));
374
 
375
  gimple_set_location (stmt, gimple_location (orig_stmt));
376
  gimple_set_bb (stmt, gsi_bb (*gsi));
377
 
378
  /* Preserve EH region information from the original statement, if
379
     requested by the caller.  */
380
  if (update_eh_info)
381
    maybe_clean_or_replace_eh_stmt (orig_stmt, stmt);
382
 
383
  gimple_duplicate_stmt_histograms (cfun, stmt, cfun, orig_stmt);
384
 
385
  /* Free all the data flow information for ORIG_STMT.  */
386
  gimple_set_bb (orig_stmt, NULL);
387
  gimple_remove_stmt_histograms (cfun, orig_stmt);
388
  delink_stmt_imm_use (orig_stmt);
389
 
390
  *gsi_stmt_ptr (gsi) = stmt;
391
  gimple_set_modified (stmt, true);
392
  update_modified_stmt (stmt);
393
}
394
 
395
 
396
/* Insert statement STMT before the statement pointed-to by iterator I.
397
   M specifies how to update iterator I after insertion (see enum
398
   gsi_iterator_update).
399
 
400
   This function does not scan for new operands.  It is provided for
401
   the use of the gimplifier, which manipulates statements for which
402
   def/use information has not yet been constructed.  Most callers
403
   should use gsi_insert_before.  */
404
 
405
void
406
gsi_insert_before_without_update (gimple_stmt_iterator *i, gimple stmt,
407
                                  enum gsi_iterator_update m)
408
{
409
  gimple_seq_node n;
410
 
411
  n = GGC_NEW (struct gimple_seq_node_d);
412
  n->prev = n->next = NULL;
413
  n->stmt = stmt;
414
  gsi_insert_seq_nodes_before (i, n, n, m);
415
}
416
 
417
/* Insert statement STMT before the statement pointed-to by iterator I.
418
   Update STMT's basic block and scan it for new operands.  M
419
   specifies how to update iterator I after insertion (see enum
420
   gsi_iterator_update).  */
421
 
422
void
423
gsi_insert_before (gimple_stmt_iterator *i, gimple stmt,
424
                   enum gsi_iterator_update m)
425
{
426
  update_modified_stmt (stmt);
427
  gsi_insert_before_without_update (i, stmt, m);
428
}
429
 
430
 
431
/* Insert statement STMT after the statement pointed-to by iterator I.
432
   M specifies how to update iterator I after insertion (see enum
433
   gsi_iterator_update).
434
 
435
   This function does not scan for new operands.  It is provided for
436
   the use of the gimplifier, which manipulates statements for which
437
   def/use information has not yet been constructed.  Most callers
438
   should use gsi_insert_after.  */
439
 
440
void
441
gsi_insert_after_without_update (gimple_stmt_iterator *i, gimple stmt,
442
                                 enum gsi_iterator_update m)
443
{
444
  gimple_seq_node n;
445
 
446
  n = GGC_NEW (struct gimple_seq_node_d);
447
  n->prev = n->next = NULL;
448
  n->stmt = stmt;
449
  gsi_insert_seq_nodes_after (i, n, n, m);
450
}
451
 
452
 
453
/* Insert statement STMT after the statement pointed-to by iterator I.
454
   Update STMT's basic block and scan it for new operands.  M
455
   specifies how to update iterator I after insertion (see enum
456
   gsi_iterator_update).  */
457
 
458
void
459
gsi_insert_after (gimple_stmt_iterator *i, gimple stmt,
460
                  enum gsi_iterator_update m)
461
{
462
  update_modified_stmt (stmt);
463
  gsi_insert_after_without_update (i, stmt, m);
464
}
465
 
466
 
467
/* Remove the current stmt from the sequence.  The iterator is updated
468
   to point to the next statement.
469
 
470
   REMOVE_PERMANENTLY is true when the statement is going to be removed
471
   from the IL and not reinserted elsewhere.  In that case we remove the
472
   statement pointed to by iterator I from the EH tables, and free its
473
   operand caches.  Otherwise we do not modify this information.  */
474
 
475
void
476
gsi_remove (gimple_stmt_iterator *i, bool remove_permanently)
477
{
478
  gimple_seq_node cur, next, prev;
479
  gimple stmt = gsi_stmt (*i);
480
 
481
  if (gimple_code (stmt) != GIMPLE_PHI)
482
    insert_debug_temps_for_defs (i);
483
 
484
  /* Free all the data flow information for STMT.  */
485
  gimple_set_bb (stmt, NULL);
486
  delink_stmt_imm_use (stmt);
487
  gimple_set_modified (stmt, true);
488
 
489
  if (remove_permanently)
490
    {
491
      remove_stmt_from_eh_lp (stmt);
492
      gimple_remove_stmt_histograms (cfun, stmt);
493
    }
494
 
495
  /* Update the iterator and re-wire the links in I->SEQ.  */
496
  cur = i->ptr;
497
  next = cur->next;
498
  prev = cur->prev;
499
 
500
  if (prev)
501
    prev->next = next;
502
  else
503
    gimple_seq_set_first (i->seq, next);
504
 
505
  if (next)
506
    next->prev = prev;
507
  else
508
    gimple_seq_set_last (i->seq, prev);
509
 
510
  i->ptr = next;
511
}
512
 
513
 
514
/* Finds iterator for STMT.  */
515
 
516
gimple_stmt_iterator
517
gsi_for_stmt (gimple stmt)
518
{
519
  gimple_stmt_iterator i;
520
  basic_block bb = gimple_bb (stmt);
521
 
522
  if (gimple_code (stmt) == GIMPLE_PHI)
523
    i = gsi_start_phis (bb);
524
  else
525
    i = gsi_start_bb (bb);
526
 
527
  for (; !gsi_end_p (i); gsi_next (&i))
528
    if (gsi_stmt (i) == stmt)
529
      return i;
530
 
531
  gcc_unreachable ();
532
}
533
 
534
 
535
/* Move the statement at FROM so it comes right after the statement at TO.  */
536
 
537
void
538
gsi_move_after (gimple_stmt_iterator *from, gimple_stmt_iterator *to)
539
{
540
  gimple stmt = gsi_stmt (*from);
541
  gsi_remove (from, false);
542
 
543
  /* We must have GSI_NEW_STMT here, as gsi_move_after is sometimes used to
544
     move statements to an empty block.  */
545
  gsi_insert_after (to, stmt, GSI_NEW_STMT);
546
}
547
 
548
 
549
/* Move the statement at FROM so it comes right before the statement
550
   at TO.  */
551
 
552
void
553
gsi_move_before (gimple_stmt_iterator *from, gimple_stmt_iterator *to)
554
{
555
  gimple stmt = gsi_stmt (*from);
556
  gsi_remove (from, false);
557
 
558
  /* For consistency with gsi_move_after, it might be better to have
559
     GSI_NEW_STMT here; however, that breaks several places that expect
560
     that TO does not change.  */
561
  gsi_insert_before (to, stmt, GSI_SAME_STMT);
562
}
563
 
564
 
565
/* Move the statement at FROM to the end of basic block BB.  */
566
 
567
void
568
gsi_move_to_bb_end (gimple_stmt_iterator *from, basic_block bb)
569
{
570
  gimple_stmt_iterator last = gsi_last_bb (bb);
571
#ifdef ENABLE_CHECKING
572
  gcc_assert (gsi_bb (last) == bb);
573
#endif
574
 
575
  /* Have to check gsi_end_p because it could be an empty block.  */
576
  if (!gsi_end_p (last) && is_ctrl_stmt (gsi_stmt (last)))
577
    gsi_move_before (from, &last);
578
  else
579
    gsi_move_after (from, &last);
580
}
581
 
582
 
583
/* Add STMT to the pending list of edge E.  No actual insertion is
584
   made until a call to gsi_commit_edge_inserts () is made.  */
585
 
586
void
587
gsi_insert_on_edge (edge e, gimple stmt)
588
{
589
  gimple_seq_add_stmt (&PENDING_STMT (e), stmt);
590
}
591
 
592
/* Add the sequence of statements SEQ to the pending list of edge E.
593
   No actual insertion is made until a call to gsi_commit_edge_inserts
594
   is made.  */
595
 
596
void
597
gsi_insert_seq_on_edge (edge e, gimple_seq seq)
598
{
599
  gimple_seq_add_seq (&PENDING_STMT (e), seq);
600
}
601
 
602
 
603
/* Insert the statement pointed-to by GSI into edge E.  Every attempt
604
   is made to place the statement in an existing basic block, but
605
   sometimes that isn't possible.  When it isn't possible, the edge is
606
   split and the statement is added to the new block.
607
 
608
   In all cases, the returned *GSI points to the correct location.  The
609
   return value is true if insertion should be done after the location,
610
   or false if it should be done before the location.  If a new basic block
611
   has to be created, it is stored in *NEW_BB.  */
612
 
613
static bool
614
gimple_find_edge_insert_loc (edge e, gimple_stmt_iterator *gsi,
615
                             basic_block *new_bb)
616
{
617
  basic_block dest, src;
618
  gimple tmp;
619
 
620
  dest = e->dest;
621
 
622
  /* If the destination has one predecessor which has no PHI nodes,
623
     insert there.  Except for the exit block.
624
 
625
     The requirement for no PHI nodes could be relaxed.  Basically we
626
     would have to examine the PHIs to prove that none of them used
627
     the value set by the statement we want to insert on E.  That
628
     hardly seems worth the effort.  */
629
 restart:
630
  if (single_pred_p (dest)
631
      && gimple_seq_empty_p (phi_nodes (dest))
632
      && dest != EXIT_BLOCK_PTR)
633
    {
634
      *gsi = gsi_start_bb (dest);
635
      if (gsi_end_p (*gsi))
636
        return true;
637
 
638
      /* Make sure we insert after any leading labels.  */
639
      tmp = gsi_stmt (*gsi);
640
      while (gimple_code (tmp) == GIMPLE_LABEL)
641
        {
642
          gsi_next (gsi);
643
          if (gsi_end_p (*gsi))
644
            break;
645
          tmp = gsi_stmt (*gsi);
646
        }
647
 
648
      if (gsi_end_p (*gsi))
649
        {
650
          *gsi = gsi_last_bb (dest);
651
          return true;
652
        }
653
      else
654
        return false;
655
    }
656
 
657
  /* If the source has one successor, the edge is not abnormal and
658
     the last statement does not end a basic block, insert there.
659
     Except for the entry block.  */
660
  src = e->src;
661
  if ((e->flags & EDGE_ABNORMAL) == 0
662
      && single_succ_p (src)
663
      && src != ENTRY_BLOCK_PTR)
664
    {
665
      *gsi = gsi_last_bb (src);
666
      if (gsi_end_p (*gsi))
667
        return true;
668
 
669
      tmp = gsi_stmt (*gsi);
670
      if (!stmt_ends_bb_p (tmp))
671
        return true;
672
 
673
      switch (gimple_code (tmp))
674
        {
675
        case GIMPLE_RETURN:
676
        case GIMPLE_RESX:
677
          return false;
678
        default:
679
          break;
680
        }
681
    }
682
 
683
  /* Otherwise, create a new basic block, and split this edge.  */
684
  dest = split_edge (e);
685
  if (new_bb)
686
    *new_bb = dest;
687
  e = single_pred_edge (dest);
688
  goto restart;
689
}
690
 
691
 
692
/* Similar to gsi_insert_on_edge+gsi_commit_edge_inserts.  If a new
693
   block has to be created, it is returned.  */
694
 
695
basic_block
696
gsi_insert_on_edge_immediate (edge e, gimple stmt)
697
{
698
  gimple_stmt_iterator gsi;
699
  basic_block new_bb = NULL;
700
 
701
  gcc_assert (!PENDING_STMT (e));
702
 
703
  if (gimple_find_edge_insert_loc (e, &gsi, &new_bb))
704
    gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
705
  else
706
    gsi_insert_before (&gsi, stmt, GSI_NEW_STMT);
707
 
708
  return new_bb;
709
}
710
 
711
/* Insert STMTS on edge E.  If a new block has to be created, it
712
   is returned.  */
713
 
714
basic_block
715
gsi_insert_seq_on_edge_immediate (edge e, gimple_seq stmts)
716
{
717
  gimple_stmt_iterator gsi;
718
  basic_block new_bb = NULL;
719
 
720
  gcc_assert (!PENDING_STMT (e));
721
 
722
  if (gimple_find_edge_insert_loc (e, &gsi, &new_bb))
723
    gsi_insert_seq_after (&gsi, stmts, GSI_NEW_STMT);
724
  else
725
    gsi_insert_seq_before (&gsi, stmts, GSI_NEW_STMT);
726
 
727
  return new_bb;
728
}
729
 
730
/* This routine will commit all pending edge insertions, creating any new
731
   basic blocks which are necessary.  */
732
 
733
void
734
gsi_commit_edge_inserts (void)
735
{
736
  basic_block bb;
737
  edge e;
738
  edge_iterator ei;
739
 
740
  gsi_commit_one_edge_insert (single_succ_edge (ENTRY_BLOCK_PTR), NULL);
741
 
742
  FOR_EACH_BB (bb)
743
    FOR_EACH_EDGE (e, ei, bb->succs)
744
      gsi_commit_one_edge_insert (e, NULL);
745
}
746
 
747
 
748
/* Commit insertions pending at edge E. If a new block is created, set NEW_BB
749
   to this block, otherwise set it to NULL.  */
750
 
751
void
752
gsi_commit_one_edge_insert (edge e, basic_block *new_bb)
753
{
754
  if (new_bb)
755
    *new_bb = NULL;
756
 
757
  if (PENDING_STMT (e))
758
    {
759
      gimple_stmt_iterator gsi;
760
      gimple_seq seq = PENDING_STMT (e);
761
 
762
      PENDING_STMT (e) = NULL;
763
 
764
      if (gimple_find_edge_insert_loc (e, &gsi, new_bb))
765
        gsi_insert_seq_after (&gsi, seq, GSI_NEW_STMT);
766
      else
767
        gsi_insert_seq_before (&gsi, seq, GSI_NEW_STMT);
768
    }
769
}
770
 
771
/* Returns iterator at the start of the list of phi nodes of BB.  */
772
 
773
gimple_stmt_iterator
774
gsi_start_phis (basic_block bb)
775
{
776
  return gsi_start (phi_nodes (bb));
777
}

powered by: WebSVN 2.1.0

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