OSDN Git Service

* lcm.c: Move all mode-switching related functions from here...
[pf3gnuchains/gcc-fork.git] / gcc / mode-switching.c
1 /* CPU mode switching
2    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
3    Free Software Foundation, Inc.
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 2, 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 COPYING.  If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA.  */
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "rtl.h"
27 #include "regs.h"
28 #include "hard-reg-set.h"
29 #include "flags.h"
30 #include "real.h"
31 #include "insn-config.h"
32 #include "recog.h"
33 #include "basic-block.h"
34 #include "output.h"
35 #include "tm_p.h"
36 #include "function.h"
37
38 /* We want target macros for the mode switching code to be able to refer
39    to instruction attribute values.  */
40 #include "insn-attr.h"
41
42 #ifdef OPTIMIZE_MODE_SWITCHING
43
44 /* The algorithm for setting the modes consists of scanning the insn list
45    and finding all the insns which require a specific mode.  Each insn gets
46    a unique struct seginfo element.  These structures are inserted into a list
47    for each basic block.  For each entity, there is an array of bb_info over
48    the flow graph basic blocks (local var 'bb_info'), and contains a list
49    of all insns within that basic block, in the order they are encountered.
50
51    For each entity, any basic block WITHOUT any insns requiring a specific
52    mode are given a single entry, without a mode.  (Each basic block
53    in the flow graph must have at least one entry in the segment table.)
54
55    The LCM algorithm is then run over the flow graph to determine where to
56    place the sets to the highest-priority value in respect of first the first
57    insn in any one block.  Any adjustments required to the transparency
58    vectors are made, then the next iteration starts for the next-lower
59    priority mode, till for each entity all modes are exhausted.
60
61    More details are located in the code for optimize_mode_switching().  */
62 \f
63 /* This structure contains the information for each insn which requires
64    either single or double mode to be set.
65    MODE is the mode this insn must be executed in.
66    INSN_PTR is the insn to be executed (may be the note that marks the
67    beginning of a basic block).
68    BBNUM is the flow graph basic block this insn occurs in.
69    NEXT is the next insn in the same basic block.  */
70 struct seginfo
71 {
72   int mode;
73   rtx insn_ptr;
74   int bbnum;
75   struct seginfo *next;
76   HARD_REG_SET regs_live;
77 };
78
79 struct bb_info
80 {
81   struct seginfo *seginfo;
82   int computing;
83 };
84
85 /* These bitmaps are used for the LCM algorithm.  */
86
87 static sbitmap *antic;
88 static sbitmap *transp;
89 static sbitmap *comp;
90
91 static struct seginfo * new_seginfo (int, rtx, int, HARD_REG_SET);
92 static void add_seginfo (struct bb_info *, struct seginfo *);
93 static void reg_dies (rtx, HARD_REG_SET);
94 static void reg_becomes_live (rtx, rtx, void *);
95 static void make_preds_opaque (basic_block, int);
96 \f
97
98 /* This function will allocate a new BBINFO structure, initialized
99    with the MODE, INSN, and basic block BB parameters.  */
100
101 static struct seginfo *
102 new_seginfo (int mode, rtx insn, int bb, HARD_REG_SET regs_live)
103 {
104   struct seginfo *ptr;
105   ptr = xmalloc (sizeof (struct seginfo));
106   ptr->mode = mode;
107   ptr->insn_ptr = insn;
108   ptr->bbnum = bb;
109   ptr->next = NULL;
110   COPY_HARD_REG_SET (ptr->regs_live, regs_live);
111   return ptr;
112 }
113
114 /* Add a seginfo element to the end of a list.
115    HEAD is a pointer to the list beginning.
116    INFO is the structure to be linked in.  */
117
118 static void
119 add_seginfo (struct bb_info *head, struct seginfo *info)
120 {
121   struct seginfo *ptr;
122
123   if (head->seginfo == NULL)
124     head->seginfo = info;
125   else
126     {
127       ptr = head->seginfo;
128       while (ptr->next != NULL)
129         ptr = ptr->next;
130       ptr->next = info;
131     }
132 }
133
134 /* Make all predecessors of basic block B opaque, recursively, till we hit
135    some that are already non-transparent, or an edge where aux is set; that
136    denotes that a mode set is to be done on that edge.
137    J is the bit number in the bitmaps that corresponds to the entity that
138    we are currently handling mode-switching for.  */
139
140 static void
141 make_preds_opaque (basic_block b, int j)
142 {
143   edge e;
144   edge_iterator ei;
145
146   FOR_EACH_EDGE (e, ei, b->preds)
147     {
148       basic_block pb = e->src;
149
150       if (e->aux || ! TEST_BIT (transp[pb->index], j))
151         continue;
152
153       RESET_BIT (transp[pb->index], j);
154       make_preds_opaque (pb, j);
155     }
156 }
157
158 /* Record in LIVE that register REG died.  */
159
160 static void
161 reg_dies (rtx reg, HARD_REG_SET live)
162 {
163   int regno, nregs;
164
165   if (!REG_P (reg))
166     return;
167
168   regno = REGNO (reg);
169   if (regno < FIRST_PSEUDO_REGISTER)
170     for (nregs = hard_regno_nregs[regno][GET_MODE (reg)] - 1; nregs >= 0;
171          nregs--)
172       CLEAR_HARD_REG_BIT (live, regno + nregs);
173 }
174
175 /* Record in LIVE that register REG became live.
176    This is called via note_stores.  */
177
178 static void
179 reg_becomes_live (rtx reg, rtx setter ATTRIBUTE_UNUSED, void *live)
180 {
181   int regno, nregs;
182
183   if (GET_CODE (reg) == SUBREG)
184     reg = SUBREG_REG (reg);
185
186   if (!REG_P (reg))
187     return;
188
189   regno = REGNO (reg);
190   if (regno < FIRST_PSEUDO_REGISTER)
191     for (nregs = hard_regno_nregs[regno][GET_MODE (reg)] - 1; nregs >= 0;
192          nregs--)
193       SET_HARD_REG_BIT (* (HARD_REG_SET *) live, regno + nregs);
194 }
195
196 /* Make sure if MODE_ENTRY is defined the MODE_EXIT is defined
197    and vice versa.  */
198 #if defined (MODE_ENTRY) != defined (MODE_EXIT)
199  #error "Both MODE_ENTRY and MODE_EXIT must be defined"
200 #endif
201
202 #if defined (MODE_ENTRY) && defined (MODE_EXIT)
203 /* Split the fallthrough edge to the exit block, so that we can note
204    that there NORMAL_MODE is required.  Return the new block if it's
205    inserted before the exit block.  Otherwise return null.  */
206
207 static basic_block
208 create_pre_exit (int n_entities, int *entity_map, const int *num_modes)
209 {
210   edge eg;
211   edge_iterator ei;
212   basic_block pre_exit;
213
214   /* The only non-call predecessor at this stage is a block with a
215      fallthrough edge; there can be at most one, but there could be
216      none at all, e.g. when exit is called.  */
217   pre_exit = 0;
218   FOR_EACH_EDGE (eg, ei, EXIT_BLOCK_PTR->preds)
219     if (eg->flags & EDGE_FALLTHRU)
220       {
221         basic_block src_bb = eg->src;
222         regset live_at_end = src_bb->global_live_at_end;
223         rtx last_insn, ret_reg;
224
225         gcc_assert (!pre_exit);
226         /* If this function returns a value at the end, we have to
227            insert the final mode switch before the return value copy
228            to its hard register.  */
229         if (EDGE_COUNT (EXIT_BLOCK_PTR->preds) == 1
230             && NONJUMP_INSN_P ((last_insn = BB_END (src_bb)))
231             && GET_CODE (PATTERN (last_insn)) == USE
232             && GET_CODE ((ret_reg = XEXP (PATTERN (last_insn), 0))) == REG)
233           {
234             int ret_start = REGNO (ret_reg);
235             int nregs = hard_regno_nregs[ret_start][GET_MODE (ret_reg)];
236             int ret_end = ret_start + nregs;
237             int short_block = 0;
238             int maybe_builtin_apply = 0;
239             int forced_late_switch = 0;
240             rtx before_return_copy;
241
242             do
243               {
244                 rtx return_copy = PREV_INSN (last_insn);
245                 rtx return_copy_pat, copy_reg;
246                 int copy_start, copy_num;
247                 int j;
248
249                 if (INSN_P (return_copy))
250                   {
251                     if (GET_CODE (PATTERN (return_copy)) == USE
252                         && GET_CODE (XEXP (PATTERN (return_copy), 0)) == REG
253                         && (FUNCTION_VALUE_REGNO_P
254                             (REGNO (XEXP (PATTERN (return_copy), 0)))))
255                       {
256                         maybe_builtin_apply = 1;
257                         last_insn = return_copy;
258                         continue;
259                       }
260                     /* If the return register is not (in its entirety)
261                        likely spilled, the return copy might be
262                        partially or completely optimized away.  */
263                     return_copy_pat = single_set (return_copy);
264                     if (!return_copy_pat)
265                       {
266                         return_copy_pat = PATTERN (return_copy);
267                         if (GET_CODE (return_copy_pat) != CLOBBER)
268                           break;
269                       }
270                     copy_reg = SET_DEST (return_copy_pat);
271                     if (GET_CODE (copy_reg) == REG)
272                       copy_start = REGNO (copy_reg);
273                     else if (GET_CODE (copy_reg) == SUBREG
274                              && GET_CODE (SUBREG_REG (copy_reg)) == REG)
275                       copy_start = REGNO (SUBREG_REG (copy_reg));
276                     else
277                       break;
278                     if (copy_start >= FIRST_PSEUDO_REGISTER)
279                       break;
280                     copy_num
281                       = hard_regno_nregs[copy_start][GET_MODE (copy_reg)];
282
283                     /* If the return register is not likely spilled, - as is
284                        the case for floating point on SH4 - then it might
285                        be set by an arithmetic operation that needs a
286                        different mode than the exit block.  */
287                     for (j = n_entities - 1; j >= 0; j--)
288                       {
289                         int e = entity_map[j];
290                         int mode = MODE_NEEDED (e, return_copy);
291
292                         if (mode != num_modes[e] && mode != MODE_EXIT (e))
293                           break;
294                       }
295                     if (j >= 0)
296                       {
297                         /* For the SH4, floating point loads depend on fpscr,
298                            thus we might need to put the final mode switch
299                            after the return value copy.  That is still OK,
300                            because a floating point return value does not
301                            conflict with address reloads.  */
302                         if (copy_start >= ret_start
303                             && copy_start + copy_num <= ret_end
304                             && OBJECT_P (SET_SRC (return_copy_pat)))
305                           forced_late_switch = 1;
306                         break;
307                       }
308
309                     if (copy_start >= ret_start
310                         && copy_start + copy_num <= ret_end)
311                       nregs -= copy_num;
312                     else if (!maybe_builtin_apply
313                              || !FUNCTION_VALUE_REGNO_P (copy_start))
314                       break;
315                     last_insn = return_copy;
316                   }
317                 /* ??? Exception handling can lead to the return value
318                    copy being already separated from the return value use,
319                    as in  unwind-dw2.c .
320                    Similarly, conditionally returning without a value,
321                    and conditionally using builtin_return can lead to an
322                    isolated use.  */
323                 if (return_copy == BB_HEAD (src_bb))
324                   {
325                     short_block = 1;
326                     break;
327                   }
328                 last_insn = return_copy;
329               }
330             while (nregs);
331             
332             /* If we didn't see a full return value copy, verify that there
333                is a plausible reason for this.  If some, but not all of the
334                return register is likely spilled, we can expect that there
335                is a copy for the likely spilled part.  */
336             gcc_assert (!nregs
337                         || forced_late_switch
338                         || short_block
339                         || !(CLASS_LIKELY_SPILLED_P
340                              (REGNO_REG_CLASS (ret_start)))
341                         || (nregs
342                             != hard_regno_nregs[ret_start][GET_MODE (ret_reg)])
343                         /* For multi-hard-register floating point
344                            values, sometimes the likely-spilled part
345                            is ordinarily copied first, then the other
346                            part is set with an arithmetic operation.
347                            This doesn't actually cause reload
348                            failures, so let it pass.  */
349                         || (GET_MODE_CLASS (GET_MODE (ret_reg)) != MODE_INT
350                             && nregs != 1));
351             
352             if (INSN_P (last_insn))
353               {
354                 before_return_copy
355                   = emit_note_before (NOTE_INSN_DELETED, last_insn);
356                 /* Instructions preceding LAST_INSN in the same block might
357                    require a different mode than MODE_EXIT, so if we might
358                    have such instructions, keep them in a separate block
359                    from pre_exit.  */
360                 if (last_insn != BB_HEAD (src_bb))
361                   src_bb = split_block (src_bb,
362                                         PREV_INSN (before_return_copy))->dest;
363               }
364             else
365               before_return_copy = last_insn;
366             pre_exit = split_block (src_bb, before_return_copy)->src;
367           }
368         else
369           {
370             pre_exit = split_edge (eg);
371             COPY_REG_SET (pre_exit->global_live_at_start, live_at_end);
372             COPY_REG_SET (pre_exit->global_live_at_end, live_at_end);
373           }
374       }
375
376   return pre_exit;
377 }
378 #endif
379
380 /* Find all insns that need a particular mode setting, and insert the
381    necessary mode switches.  Return true if we did work.  */
382
383 int
384 optimize_mode_switching (FILE *file)
385 {
386   rtx insn;
387   int e;
388   basic_block bb;
389   int need_commit = 0;
390   sbitmap *kill;
391   struct edge_list *edge_list;
392   static const int num_modes[] = NUM_MODES_FOR_MODE_SWITCHING;
393 #define N_ENTITIES ARRAY_SIZE (num_modes)
394   int entity_map[N_ENTITIES];
395   struct bb_info *bb_info[N_ENTITIES];
396   int i, j;
397   int n_entities;
398   int max_num_modes = 0;
399   bool emited = false;
400   basic_block post_entry ATTRIBUTE_UNUSED, pre_exit ATTRIBUTE_UNUSED;
401
402   clear_bb_flags ();
403
404   for (e = N_ENTITIES - 1, n_entities = 0; e >= 0; e--)
405     if (OPTIMIZE_MODE_SWITCHING (e))
406       {
407         int entry_exit_extra = 0;
408
409         /* Create the list of segments within each basic block.
410            If NORMAL_MODE is defined, allow for two extra
411            blocks split from the entry and exit block.  */
412 #if defined (MODE_ENTRY) && defined (MODE_EXIT)
413         entry_exit_extra = 3;
414 #endif
415         bb_info[n_entities]
416           = xcalloc (last_basic_block + entry_exit_extra, sizeof **bb_info);
417         entity_map[n_entities++] = e;
418         if (num_modes[e] > max_num_modes)
419           max_num_modes = num_modes[e];
420       }
421
422   if (! n_entities)
423     return 0;
424
425 #if defined (MODE_ENTRY) && defined (MODE_EXIT)
426   /* Split the edge from the entry block, so that we can note that
427      there NORMAL_MODE is supplied.  */
428   post_entry = split_edge (single_succ_edge (ENTRY_BLOCK_PTR));
429   pre_exit = create_pre_exit (n_entities, entity_map, num_modes);
430 #endif
431
432   /* Create the bitmap vectors.  */
433
434   antic = sbitmap_vector_alloc (last_basic_block, n_entities);
435   transp = sbitmap_vector_alloc (last_basic_block, n_entities);
436   comp = sbitmap_vector_alloc (last_basic_block, n_entities);
437
438   sbitmap_vector_ones (transp, last_basic_block);
439
440   for (j = n_entities - 1; j >= 0; j--)
441     {
442       int e = entity_map[j];
443       int no_mode = num_modes[e];
444       struct bb_info *info = bb_info[j];
445
446       /* Determine what the first use (if any) need for a mode of entity E is.
447          This will be the mode that is anticipatable for this block.
448          Also compute the initial transparency settings.  */
449       FOR_EACH_BB (bb)
450         {
451           struct seginfo *ptr;
452           int last_mode = no_mode;
453           HARD_REG_SET live_now;
454
455           REG_SET_TO_HARD_REG_SET (live_now,
456                                    bb->global_live_at_start);
457           for (insn = BB_HEAD (bb);
458                insn != NULL && insn != NEXT_INSN (BB_END (bb));
459                insn = NEXT_INSN (insn))
460             {
461               if (INSN_P (insn))
462                 {
463                   int mode = MODE_NEEDED (e, insn);
464                   rtx link;
465
466                   if (mode != no_mode && mode != last_mode)
467                     {
468                       last_mode = mode;
469                       ptr = new_seginfo (mode, insn, bb->index, live_now);
470                       add_seginfo (info + bb->index, ptr);
471                       RESET_BIT (transp[bb->index], j);
472                     }
473 #ifdef MODE_AFTER
474                   last_mode = MODE_AFTER (last_mode, insn);
475 #endif
476                   /* Update LIVE_NOW.  */
477                   for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
478                     if (REG_NOTE_KIND (link) == REG_DEAD)
479                       reg_dies (XEXP (link, 0), live_now);
480
481                   note_stores (PATTERN (insn), reg_becomes_live, &live_now);
482                   for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
483                     if (REG_NOTE_KIND (link) == REG_UNUSED)
484                       reg_dies (XEXP (link, 0), live_now);
485                 }
486             }
487
488           info[bb->index].computing = last_mode;
489           /* Check for blocks without ANY mode requirements.  */
490           if (last_mode == no_mode)
491             {
492               ptr = new_seginfo (no_mode, BB_END (bb), bb->index, live_now);
493               add_seginfo (info + bb->index, ptr);
494             }
495         }
496 #if defined (MODE_ENTRY) && defined (MODE_EXIT)
497       {
498         int mode = MODE_ENTRY (e);
499
500         if (mode != no_mode)
501           {
502             bb = post_entry;
503
504             /* By always making this nontransparent, we save
505                an extra check in make_preds_opaque.  We also
506                need this to avoid confusing pre_edge_lcm when
507                antic is cleared but transp and comp are set.  */
508             RESET_BIT (transp[bb->index], j);
509
510             /* Insert a fake computing definition of MODE into entry
511                blocks which compute no mode. This represents the mode on
512                entry.  */
513             info[bb->index].computing = mode;
514
515             if (pre_exit)
516               info[pre_exit->index].seginfo->mode = MODE_EXIT (e);
517           }
518       }
519 #endif /* NORMAL_MODE */
520     }
521
522   kill = sbitmap_vector_alloc (last_basic_block, n_entities);
523   for (i = 0; i < max_num_modes; i++)
524     {
525       int current_mode[N_ENTITIES];
526       sbitmap *delete;
527       sbitmap *insert;
528
529       /* Set the anticipatable and computing arrays.  */
530       sbitmap_vector_zero (antic, last_basic_block);
531       sbitmap_vector_zero (comp, last_basic_block);
532       for (j = n_entities - 1; j >= 0; j--)
533         {
534           int m = current_mode[j] = MODE_PRIORITY_TO_MODE (entity_map[j], i);
535           struct bb_info *info = bb_info[j];
536
537           FOR_EACH_BB (bb)
538             {
539               if (info[bb->index].seginfo->mode == m)
540                 SET_BIT (antic[bb->index], j);
541
542               if (info[bb->index].computing == m)
543                 SET_BIT (comp[bb->index], j);
544             }
545         }
546
547       /* Calculate the optimal locations for the
548          placement mode switches to modes with priority I.  */
549
550       FOR_EACH_BB (bb)
551         sbitmap_not (kill[bb->index], transp[bb->index]);
552       edge_list = pre_edge_lcm (file, 1, transp, comp, antic,
553                                 kill, &insert, &delete);
554
555       for (j = n_entities - 1; j >= 0; j--)
556         {
557           /* Insert all mode sets that have been inserted by lcm.  */
558           int no_mode = num_modes[entity_map[j]];
559
560           /* Wherever we have moved a mode setting upwards in the flow graph,
561              the blocks between the new setting site and the now redundant
562              computation ceases to be transparent for any lower-priority
563              mode of the same entity.  First set the aux field of each
564              insertion site edge non-transparent, then propagate the new
565              non-transparency from the redundant computation upwards till
566              we hit an insertion site or an already non-transparent block.  */
567           for (e = NUM_EDGES (edge_list) - 1; e >= 0; e--)
568             {
569               edge eg = INDEX_EDGE (edge_list, e);
570               int mode;
571               basic_block src_bb;
572               HARD_REG_SET live_at_edge;
573               rtx mode_set;
574
575               eg->aux = 0;
576
577               if (! TEST_BIT (insert[e], j))
578                 continue;
579
580               eg->aux = (void *)1;
581
582               mode = current_mode[j];
583               src_bb = eg->src;
584
585               REG_SET_TO_HARD_REG_SET (live_at_edge,
586                                        src_bb->global_live_at_end);
587
588               start_sequence ();
589               EMIT_MODE_SET (entity_map[j], mode, live_at_edge);
590               mode_set = get_insns ();
591               end_sequence ();
592
593               /* Do not bother to insert empty sequence.  */
594               if (mode_set == NULL_RTX)
595                 continue;
596
597               /* If this is an abnormal edge, we'll insert at the end
598                  of the previous block.  */
599               if (eg->flags & EDGE_ABNORMAL)
600                 {
601                   emited = true;
602                   if (JUMP_P (BB_END (src_bb)))
603                     emit_insn_before (mode_set, BB_END (src_bb));
604                   else
605                     {
606                       /* It doesn't make sense to switch to normal
607                          mode after a CALL_INSN.  The cases in which a
608                          CALL_INSN may have an abnormal edge are
609                          sibcalls and EH edges.  In the case of
610                          sibcalls, the dest basic-block is the
611                          EXIT_BLOCK, that runs in normal mode; it is
612                          assumed that a sibcall insn requires normal
613                          mode itself, so no mode switch would be
614                          required after the call (it wouldn't make
615                          sense, anyway).  In the case of EH edges, EH
616                          entry points also start in normal mode, so a
617                          similar reasoning applies.  */
618                       gcc_assert (NONJUMP_INSN_P (BB_END (src_bb)));
619                       emit_insn_after (mode_set, BB_END (src_bb));
620                     }
621                   bb_info[j][src_bb->index].computing = mode;
622                   RESET_BIT (transp[src_bb->index], j);
623                 }
624               else
625                 {
626                   need_commit = 1;
627                   insert_insn_on_edge (mode_set, eg);
628                 }
629             }
630
631           FOR_EACH_BB_REVERSE (bb)
632             if (TEST_BIT (delete[bb->index], j))
633               {
634                 make_preds_opaque (bb, j);
635                 /* Cancel the 'deleted' mode set.  */
636                 bb_info[j][bb->index].seginfo->mode = no_mode;
637               }
638         }
639
640       sbitmap_vector_free (delete);
641       sbitmap_vector_free (insert);
642       clear_aux_for_edges ();
643       free_edge_list (edge_list);
644     }
645
646   /* Now output the remaining mode sets in all the segments.  */
647   for (j = n_entities - 1; j >= 0; j--)
648     {
649       int no_mode = num_modes[entity_map[j]];
650
651       FOR_EACH_BB_REVERSE (bb)
652         {
653           struct seginfo *ptr, *next;
654           for (ptr = bb_info[j][bb->index].seginfo; ptr; ptr = next)
655             {
656               next = ptr->next;
657               if (ptr->mode != no_mode)
658                 {
659                   rtx mode_set;
660
661                   start_sequence ();
662                   EMIT_MODE_SET (entity_map[j], ptr->mode, ptr->regs_live);
663                   mode_set = get_insns ();
664                   end_sequence ();
665
666                   /* Insert MODE_SET only if it is nonempty.  */
667                   if (mode_set != NULL_RTX)
668                     {
669                       emited = true;
670                       if (NOTE_P (ptr->insn_ptr)
671                           && (NOTE_LINE_NUMBER (ptr->insn_ptr)
672                               == NOTE_INSN_BASIC_BLOCK))
673                         emit_insn_after (mode_set, ptr->insn_ptr);
674                       else
675                         emit_insn_before (mode_set, ptr->insn_ptr);
676                     }
677                 }
678
679               free (ptr);
680             }
681         }
682
683       free (bb_info[j]);
684     }
685
686   /* Finished. Free up all the things we've allocated.  */
687
688   sbitmap_vector_free (kill);
689   sbitmap_vector_free (antic);
690   sbitmap_vector_free (transp);
691   sbitmap_vector_free (comp);
692
693   if (need_commit)
694     commit_edge_insertions ();
695
696 #if defined (MODE_ENTRY) && defined (MODE_EXIT)
697   cleanup_cfg (CLEANUP_NO_INSN_DEL);
698 #else
699   if (!need_commit && !emited)
700     return 0;
701 #endif
702
703   max_regno = max_reg_num ();
704   allocate_reg_info (max_regno, FALSE, FALSE);
705   update_life_info_in_dirty_blocks (UPDATE_LIFE_GLOBAL_RM_NOTES,
706                                     (PROP_DEATH_NOTES | PROP_KILL_DEAD_CODE
707                                      | PROP_SCAN_DEAD_CODE));
708
709   return 1;
710 }
711 #endif /* OPTIMIZE_MODE_SWITCHING */