X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=blobdiff_plain;f=gcc%2Flcm.c;h=61c67e04ae7a5f0fe760bd9d572d48fe1b169c71;hp=3cb9fe067b42129e6259706ed9f8f2b0880366e1;hb=fed8ee662bb6f01ae0e2234b0eecfbad7d20a018;hpb=4c26117afc55fbf0b998d0bf25f1ab56da4dd180 diff --git a/gcc/lcm.c b/gcc/lcm.c index 3cb9fe067b4..61c67e04ae7 100644 --- a/gcc/lcm.c +++ b/gcc/lcm.c @@ -1,11 +1,12 @@ /* Generic partial redundancy elimination with lazy code motion support. - Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc. + Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, + 2010, 2011 Free Software Foundation, Inc. This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free -Software Foundation; either version 2, or (at your option) any later +Software Foundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, but WITHOUT ANY @@ -14,9 +15,8 @@ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License -along with GCC; see the file COPYING. If not, write to the Free -Software Foundation, 59 Temple Place - Suite 330, Boston, MA -02111-1307, USA. */ +along with GCC; see the file COPYING3. If not see +. */ /* These routines are meant to be used by various optimization passes which can be modeled as lazy code motion problems. @@ -51,47 +51,41 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "config.h" #include "system.h" +#include "coretypes.h" +#include "tm.h" #include "rtl.h" #include "regs.h" #include "hard-reg-set.h" #include "flags.h" -#include "real.h" #include "insn-config.h" #include "recog.h" #include "basic-block.h" +#include "output.h" #include "tm_p.h" +#include "function.h" +#include "sbitmap.h" /* We want target macros for the mode switching code to be able to refer to instruction attribute values. */ #include "insn-attr.h" /* Edge based LCM routines. */ -static void compute_antinout_edge PARAMS ((sbitmap *, sbitmap *, - sbitmap *, sbitmap *)); -static void compute_earliest PARAMS ((struct edge_list *, int, - sbitmap *, sbitmap *, - sbitmap *, sbitmap *, - sbitmap *)); -static void compute_laterin PARAMS ((struct edge_list *, sbitmap *, - sbitmap *, sbitmap *, - sbitmap *)); -static void compute_insert_delete PARAMS ((struct edge_list *edge_list, - sbitmap *, sbitmap *, - sbitmap *, sbitmap *, - sbitmap *)); +static void compute_antinout_edge (sbitmap *, sbitmap *, sbitmap *, sbitmap *); +static void compute_earliest (struct edge_list *, int, sbitmap *, sbitmap *, + sbitmap *, sbitmap *, sbitmap *); +static void compute_laterin (struct edge_list *, sbitmap *, sbitmap *, + sbitmap *, sbitmap *); +static void compute_insert_delete (struct edge_list *edge_list, sbitmap *, + sbitmap *, sbitmap *, sbitmap *, sbitmap *); /* Edge based LCM routines on a reverse flowgraph. */ -static void compute_farthest PARAMS ((struct edge_list *, int, - sbitmap *, sbitmap *, - sbitmap*, sbitmap *, - sbitmap *)); -static void compute_nearerout PARAMS ((struct edge_list *, sbitmap *, - sbitmap *, sbitmap *, - sbitmap *)); -static void compute_rev_insert_delete PARAMS ((struct edge_list *edge_list, - sbitmap *, sbitmap *, - sbitmap *, sbitmap *, - sbitmap *)); +static void compute_farthest (struct edge_list *, int, sbitmap *, sbitmap *, + sbitmap*, sbitmap *, sbitmap *); +static void compute_nearerout (struct edge_list *, sbitmap *, sbitmap *, + sbitmap *, sbitmap *); +static void compute_rev_insert_delete (struct edge_list *edge_list, sbitmap *, + sbitmap *, sbitmap *, sbitmap *, + sbitmap *); /* Edge based lcm routines. */ @@ -100,42 +94,39 @@ static void compute_rev_insert_delete PARAMS ((struct edge_list *edge_list, Other than that, its pretty much identical to compute_antinout. */ static void -compute_antinout_edge (antloc, transp, antin, antout) - sbitmap *antloc; - sbitmap *transp; - sbitmap *antin; - sbitmap *antout; +compute_antinout_edge (sbitmap *antloc, sbitmap *transp, sbitmap *antin, + sbitmap *antout) { basic_block bb; edge e; basic_block *worklist, *qin, *qout, *qend; unsigned int qlen; + edge_iterator ei; /* Allocate a worklist array/queue. Entries are only added to the list if they were not already on the list. So the size is bounded by the number of basic blocks. */ - qin = qout = worklist - = (basic_block *) xmalloc (sizeof (basic_block) * n_basic_blocks); + qin = qout = worklist = XNEWVEC (basic_block, n_basic_blocks); /* We want a maximal solution, so make an optimistic initialization of ANTIN. */ - sbitmap_vector_ones (antin, n_basic_blocks); + sbitmap_vector_ones (antin, last_basic_block); /* Put every block on the worklist; this is necessary because of the optimistic initialization of ANTIN above. */ FOR_EACH_BB_REVERSE (bb) { - *qin++ =bb; + *qin++ = bb; bb->aux = bb; } qin = worklist; - qend = &worklist[n_basic_blocks]; - qlen = n_basic_blocks; + qend = &worklist[n_basic_blocks - NUM_FIXED_BLOCKS]; + qlen = n_basic_blocks - NUM_FIXED_BLOCKS; /* Mark blocks which are predecessors of the exit block so that we can easily identify them below. */ - for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next) + FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds) e->src->aux = EXIT_BLOCK_PTR; /* Iterate until the worklist is empty. */ @@ -146,7 +137,7 @@ compute_antinout_edge (antloc, transp, antin, antout) qlen--; if (qout >= qend) - qout = worklist; + qout = worklist; if (bb->aux == EXIT_BLOCK_PTR) /* Do not clear the aux field for blocks which are predecessors of @@ -166,14 +157,14 @@ compute_antinout_edge (antloc, transp, antin, antout) /* If the in state of this block changed, then we need to add the predecessors of this block to the worklist if they are not already on the worklist. */ - for (e = bb->pred; e; e = e->pred_next) + FOR_EACH_EDGE (e, ei, bb->preds) if (!e->src->aux && e->src != ENTRY_BLOCK_PTR) { *qin++ = e->src; e->src->aux = e; qlen++; if (qin >= qend) - qin = worklist; + qin = worklist; } } @@ -185,10 +176,9 @@ compute_antinout_edge (antloc, transp, antin, antout) /* Compute the earliest vector for edge based lcm. */ static void -compute_earliest (edge_list, n_exprs, antin, antout, avout, kill, earliest) - struct edge_list *edge_list; - int n_exprs; - sbitmap *antin, *antout, *avout, *kill, *earliest; +compute_earliest (struct edge_list *edge_list, int n_exprs, sbitmap *antin, + sbitmap *antout, sbitmap *avout, sbitmap *kill, + sbitmap *earliest) { sbitmap difference, temp_bitmap; int x, num_edges; @@ -206,12 +196,8 @@ compute_earliest (edge_list, n_exprs, antin, antout, avout, kill, earliest) if (pred == ENTRY_BLOCK_PTR) sbitmap_copy (earliest[x], antin[succ->index]); else - { - /* We refer to the EXIT_BLOCK index, instead of testing for - EXIT_BLOCK_PTR, so that EXIT_BLOCK_PTR's index can be - changed so as to pretend it's a regular block, so that - its antin can be taken into account. */ - if (succ->index == EXIT_BLOCK) + { + if (succ == EXIT_BLOCK_PTR) sbitmap_zero (earliest[x]); else { @@ -258,14 +244,14 @@ compute_earliest (edge_list, n_exprs, antin, antout, avout, kill, earliest) to compute it. */ static void -compute_laterin (edge_list, earliest, antloc, later, laterin) - struct edge_list *edge_list; - sbitmap *earliest, *antloc, *later, *laterin; +compute_laterin (struct edge_list *edge_list, sbitmap *earliest, + sbitmap *antloc, sbitmap *later, sbitmap *laterin) { int num_edges, i; edge e; basic_block *worklist, *qin, *qout, *qend, bb; unsigned int qlen; + edge_iterator ei; num_edges = NUM_EDGES (edge_list); @@ -273,7 +259,7 @@ compute_laterin (edge_list, earliest, antloc, later, laterin) list if they were not already on the list. So the size is bounded by the number of basic blocks. */ qin = qout = worklist - = (basic_block *) xmalloc (sizeof (basic_block) * (n_basic_blocks + 1)); + = XNEWVEC (basic_block, n_basic_blocks); /* Initialize a mapping from each edge to its index. */ for (i = 0; i < num_edges; i++) @@ -295,7 +281,7 @@ compute_laterin (edge_list, earliest, antloc, later, laterin) do not want to be overly optimistic. Consider an outgoing edge from the entry block. That edge should always have a LATER value the same as EARLIEST for that edge. */ - for (e = ENTRY_BLOCK_PTR->succ; e; e = e->succ_next) + FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs) sbitmap_copy (later[(size_t) e->aux], earliest[(size_t) e->aux]); /* Add all the blocks to the worklist. This prevents an early exit from @@ -305,12 +291,12 @@ compute_laterin (edge_list, earliest, antloc, later, laterin) *qin++ = bb; bb->aux = bb; } - qin = worklist; + /* Note that we do not use the last allocated element for our queue, - as EXIT_BLOCK is never inserted into it. In fact the above allocation - of n_basic_blocks + 1 elements is not encessary. */ - qend = &worklist[n_basic_blocks]; - qlen = n_basic_blocks; + as EXIT_BLOCK is never inserted into it. */ + qin = worklist; + qend = &worklist[n_basic_blocks - NUM_FIXED_BLOCKS]; + qlen = n_basic_blocks - NUM_FIXED_BLOCKS; /* Iterate until the worklist is empty. */ while (qlen) @@ -320,15 +306,16 @@ compute_laterin (edge_list, earliest, antloc, later, laterin) bb->aux = NULL; qlen--; if (qout >= qend) - qout = worklist; + qout = worklist; /* Compute the intersection of LATERIN for each incoming edge to B. */ sbitmap_ones (laterin[bb->index]); - for (e = bb->pred; e != NULL; e = e->pred_next) - sbitmap_a_and_b (laterin[bb->index], laterin[bb->index], later[(size_t)e->aux]); + FOR_EACH_EDGE (e, ei, bb->preds) + sbitmap_a_and_b (laterin[bb->index], laterin[bb->index], + later[(size_t)e->aux]); /* Calculate LATER for all outgoing edges. */ - for (e = bb->succ; e != NULL; e = e->succ_next) + FOR_EACH_EDGE (e, ei, bb->succs) if (sbitmap_union_of_diff_cg (later[(size_t) e->aux], earliest[(size_t) e->aux], laterin[e->src->index], @@ -348,10 +335,10 @@ compute_laterin (edge_list, earliest, antloc, later, laterin) /* Computation of insertion and deletion points requires computing LATERIN for the EXIT block. We allocated an extra entry in the LATERIN array for just this purpose. */ - sbitmap_ones (laterin[n_basic_blocks]); - for (e = EXIT_BLOCK_PTR->pred; e != NULL; e = e->pred_next) - sbitmap_a_and_b (laterin[n_basic_blocks], - laterin[n_basic_blocks], + sbitmap_ones (laterin[last_basic_block]); + FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds) + sbitmap_a_and_b (laterin[last_basic_block], + laterin[last_basic_block], later[(size_t) e->aux]); clear_aux_for_edges (); @@ -361,23 +348,23 @@ compute_laterin (edge_list, earliest, antloc, later, laterin) /* Compute the insertion and deletion points for edge based LCM. */ static void -compute_insert_delete (edge_list, antloc, later, laterin, - insert, delete) - struct edge_list *edge_list; - sbitmap *antloc, *later, *laterin, *insert, *delete; +compute_insert_delete (struct edge_list *edge_list, sbitmap *antloc, + sbitmap *later, sbitmap *laterin, sbitmap *insert, + sbitmap *del) { int x; basic_block bb; FOR_EACH_BB (bb) - sbitmap_difference (delete[bb->index], antloc[bb->index], laterin[bb->index]); + sbitmap_difference (del[bb->index], antloc[bb->index], + laterin[bb->index]); for (x = 0; x < NUM_EDGES (edge_list); x++) { basic_block b = INDEX_EDGE_SUCC_BB (edge_list, x); if (b == EXIT_BLOCK_PTR) - sbitmap_difference (insert[x], later[x], laterin[n_basic_blocks]); + sbitmap_difference (insert[x], later[x], laterin[last_basic_block]); else sbitmap_difference (insert[x], later[x], laterin[b->index]); } @@ -388,15 +375,9 @@ compute_insert_delete (edge_list, antloc, later, laterin, map the insert vector to what edge an expression should be inserted on. */ struct edge_list * -pre_edge_lcm (file, n_exprs, transp, avloc, antloc, kill, insert, delete) - FILE *file ATTRIBUTE_UNUSED; - int n_exprs; - sbitmap *transp; - sbitmap *avloc; - sbitmap *antloc; - sbitmap *kill; - sbitmap **insert; - sbitmap **delete; +pre_edge_lcm (int n_exprs, sbitmap *transp, + sbitmap *avloc, sbitmap *antloc, sbitmap *kill, + sbitmap **insert, sbitmap **del) { sbitmap *antin, *antout, *earliest; sbitmap *avin, *avout; @@ -408,34 +389,34 @@ pre_edge_lcm (file, n_exprs, transp, avloc, antloc, kill, insert, delete) num_edges = NUM_EDGES (edge_list); #ifdef LCM_DEBUG_INFO - if (file) + if (dump_file) { - fprintf (file, "Edge List:\n"); - verify_edge_list (file, edge_list); - print_edge_list (file, edge_list); - dump_sbitmap_vector (file, "transp", "", transp, n_basic_blocks); - dump_sbitmap_vector (file, "antloc", "", antloc, n_basic_blocks); - dump_sbitmap_vector (file, "avloc", "", avloc, n_basic_blocks); - dump_sbitmap_vector (file, "kill", "", kill, n_basic_blocks); + fprintf (dump_file, "Edge List:\n"); + verify_edge_list (dump_file, edge_list); + print_edge_list (dump_file, edge_list); + dump_sbitmap_vector (dump_file, "transp", "", transp, last_basic_block); + dump_sbitmap_vector (dump_file, "antloc", "", antloc, last_basic_block); + dump_sbitmap_vector (dump_file, "avloc", "", avloc, last_basic_block); + dump_sbitmap_vector (dump_file, "kill", "", kill, last_basic_block); } #endif /* Compute global availability. */ - avin = sbitmap_vector_alloc (n_basic_blocks, n_exprs); - avout = sbitmap_vector_alloc (n_basic_blocks, n_exprs); + avin = sbitmap_vector_alloc (last_basic_block, n_exprs); + avout = sbitmap_vector_alloc (last_basic_block, n_exprs); compute_available (avloc, kill, avout, avin); sbitmap_vector_free (avin); /* Compute global anticipatability. */ - antin = sbitmap_vector_alloc (n_basic_blocks, n_exprs); - antout = sbitmap_vector_alloc (n_basic_blocks, n_exprs); + antin = sbitmap_vector_alloc (last_basic_block, n_exprs); + antout = sbitmap_vector_alloc (last_basic_block, n_exprs); compute_antinout_edge (antloc, transp, antin, antout); #ifdef LCM_DEBUG_INFO - if (file) + if (dump_file) { - dump_sbitmap_vector (file, "antin", "", antin, n_basic_blocks); - dump_sbitmap_vector (file, "antout", "", antout, n_basic_blocks); + dump_sbitmap_vector (dump_file, "antin", "", antin, last_basic_block); + dump_sbitmap_vector (dump_file, "antout", "", antout, last_basic_block); } #endif @@ -444,8 +425,8 @@ pre_edge_lcm (file, n_exprs, transp, avloc, antloc, kill, insert, delete) compute_earliest (edge_list, n_exprs, antin, antout, avout, kill, earliest); #ifdef LCM_DEBUG_INFO - if (file) - dump_sbitmap_vector (file, "earliest", "", earliest, num_edges); + if (dump_file) + dump_sbitmap_vector (dump_file, "earliest", "", earliest, num_edges); #endif sbitmap_vector_free (antout); @@ -455,32 +436,34 @@ pre_edge_lcm (file, n_exprs, transp, avloc, antloc, kill, insert, delete) later = sbitmap_vector_alloc (num_edges, n_exprs); /* Allocate an extra element for the exit block in the laterin vector. */ - laterin = sbitmap_vector_alloc (n_basic_blocks + 1, n_exprs); + laterin = sbitmap_vector_alloc (last_basic_block + 1, n_exprs); compute_laterin (edge_list, earliest, antloc, later, laterin); #ifdef LCM_DEBUG_INFO - if (file) + if (dump_file) { - dump_sbitmap_vector (file, "laterin", "", laterin, n_basic_blocks + 1); - dump_sbitmap_vector (file, "later", "", later, num_edges); + dump_sbitmap_vector (dump_file, "laterin", "", laterin, last_basic_block + 1); + dump_sbitmap_vector (dump_file, "later", "", later, num_edges); } #endif sbitmap_vector_free (earliest); *insert = sbitmap_vector_alloc (num_edges, n_exprs); - *delete = sbitmap_vector_alloc (n_basic_blocks, n_exprs); - compute_insert_delete (edge_list, antloc, later, laterin, *insert, *delete); + *del = sbitmap_vector_alloc (last_basic_block, n_exprs); + sbitmap_vector_zero (*insert, num_edges); + sbitmap_vector_zero (*del, last_basic_block); + compute_insert_delete (edge_list, antloc, later, laterin, *insert, *del); sbitmap_vector_free (laterin); sbitmap_vector_free (later); #ifdef LCM_DEBUG_INFO - if (file) + if (dump_file) { - dump_sbitmap_vector (file, "pre_insert_map", "", *insert, num_edges); - dump_sbitmap_vector (file, "pre_delete_map", "", *delete, - n_basic_blocks); + dump_sbitmap_vector (dump_file, "pre_insert_map", "", *insert, num_edges); + dump_sbitmap_vector (dump_file, "pre_delete_map", "", *del, + last_basic_block); } #endif @@ -491,21 +474,22 @@ pre_edge_lcm (file, n_exprs, transp, avloc, antloc, kill, insert, delete) Return the number of passes we performed to iterate to a solution. */ void -compute_available (avloc, kill, avout, avin) - sbitmap *avloc, *kill, *avout, *avin; +compute_available (sbitmap *avloc, sbitmap *kill, sbitmap *avout, + sbitmap *avin) { edge e; basic_block *worklist, *qin, *qout, *qend, bb; unsigned int qlen; + edge_iterator ei; /* Allocate a worklist array/queue. Entries are only added to the list if they were not already on the list. So the size is bounded by the number of basic blocks. */ - qin = qout = worklist - = (basic_block *) xmalloc (sizeof (basic_block) * n_basic_blocks); + qin = qout = worklist = + XNEWVEC (basic_block, n_basic_blocks - NUM_FIXED_BLOCKS); /* We want a maximal solution. */ - sbitmap_vector_ones (avout, n_basic_blocks); + sbitmap_vector_ones (avout, last_basic_block); /* Put every block on the worklist; this is necessary because of the optimistic initialization of AVOUT above. */ @@ -516,12 +500,12 @@ compute_available (avloc, kill, avout, avin) } qin = worklist; - qend = &worklist[n_basic_blocks]; - qlen = n_basic_blocks; + qend = &worklist[n_basic_blocks - NUM_FIXED_BLOCKS]; + qlen = n_basic_blocks - NUM_FIXED_BLOCKS; /* Mark blocks which are successors of the entry block so that we can easily identify them below. */ - for (e = ENTRY_BLOCK_PTR->succ; e; e = e->succ_next) + FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs) e->dest->aux = ENTRY_BLOCK_PTR; /* Iterate until the worklist is empty. */ @@ -532,7 +516,7 @@ compute_available (avloc, kill, avout, avin) qlen--; if (qout >= qend) - qout = worklist; + qout = worklist; /* If one of the predecessor blocks is the ENTRY block, then the intersection of avouts is the null set. We can identify such blocks @@ -549,11 +533,12 @@ compute_available (avloc, kill, avout, avin) sbitmap_intersection_of_preds (avin[bb->index], avout, bb->index); } - if (sbitmap_union_of_diff_cg (avout[bb->index], avloc[bb->index], avin[bb->index], kill[bb->index])) + if (sbitmap_union_of_diff_cg (avout[bb->index], avloc[bb->index], + avin[bb->index], kill[bb->index])) /* If the out state of this block changed, then we need to add the successors of this block to the worklist if they are not already on the worklist. */ - for (e = bb->succ; e; e = e->succ_next) + FOR_EACH_EDGE (e, ei, bb->succs) if (!e->dest->aux && e->dest != EXIT_BLOCK_PTR) { *qin++ = e->dest; @@ -561,7 +546,7 @@ compute_available (avloc, kill, avout, avin) qlen++; if (qin >= qend) - qin = worklist; + qin = worklist; } } @@ -573,11 +558,9 @@ compute_available (avloc, kill, avout, avin) /* Compute the farthest vector for edge based lcm. */ static void -compute_farthest (edge_list, n_exprs, st_avout, st_avin, st_antin, - kill, farthest) - struct edge_list *edge_list; - int n_exprs; - sbitmap *st_avout, *st_avin, *st_antin, *kill, *farthest; +compute_farthest (struct edge_list *edge_list, int n_exprs, + sbitmap *st_avout, sbitmap *st_avin, sbitmap *st_antin, + sbitmap *kill, sbitmap *farthest) { sbitmap difference, temp_bitmap; int x, num_edges; @@ -619,21 +602,20 @@ compute_farthest (edge_list, n_exprs, st_avout, st_avin, st_antin, implementation can be found before compute_laterin. */ static void -compute_nearerout (edge_list, farthest, st_avloc, nearer, nearerout) - struct edge_list *edge_list; - sbitmap *farthest, *st_avloc, *nearer, *nearerout; +compute_nearerout (struct edge_list *edge_list, sbitmap *farthest, + sbitmap *st_avloc, sbitmap *nearer, sbitmap *nearerout) { int num_edges, i; edge e; basic_block *worklist, *tos, bb; + edge_iterator ei; num_edges = NUM_EDGES (edge_list); /* Allocate a worklist array/queue. Entries are only added to the list if they were not already on the list. So the size is bounded by the number of basic blocks. */ - tos = worklist - = (basic_block *) xmalloc (sizeof (basic_block) * (n_basic_blocks + 1)); + tos = worklist = XNEWVEC (basic_block, n_basic_blocks + 1); /* Initialize NEARER for each edge and build a mapping from an edge to its index. */ @@ -647,7 +629,7 @@ compute_nearerout (edge_list, farthest, st_avloc, nearer, nearerout) do not want to be overly optimistic. Consider an incoming edge to the exit block. That edge should always have a NEARER value the same as FARTHEST for that edge. */ - for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next) + FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds) sbitmap_copy (nearer[(size_t)e->aux], farthest[(size_t)e->aux]); /* Add all the blocks to the worklist. This prevents an early exit @@ -667,12 +649,12 @@ compute_nearerout (edge_list, farthest, st_avloc, nearer, nearerout) /* Compute the intersection of NEARER for each outgoing edge from B. */ sbitmap_ones (nearerout[bb->index]); - for (e = bb->succ; e != NULL; e = e->succ_next) + FOR_EACH_EDGE (e, ei, bb->succs) sbitmap_a_and_b (nearerout[bb->index], nearerout[bb->index], nearer[(size_t) e->aux]); /* Calculate NEARER for all incoming edges. */ - for (e = bb->pred; e != NULL; e = e->pred_next) + FOR_EACH_EDGE (e, ei, bb->preds) if (sbitmap_union_of_diff_cg (nearer[(size_t) e->aux], farthest[(size_t) e->aux], nearerout[e->dest->index], @@ -689,10 +671,10 @@ compute_nearerout (edge_list, farthest, st_avloc, nearer, nearerout) /* Computation of insertion and deletion points requires computing NEAREROUT for the ENTRY block. We allocated an extra entry in the NEAREROUT array for just this purpose. */ - sbitmap_ones (nearerout[n_basic_blocks]); - for (e = ENTRY_BLOCK_PTR->succ; e != NULL; e = e->succ_next) - sbitmap_a_and_b (nearerout[n_basic_blocks], - nearerout[n_basic_blocks], + sbitmap_ones (nearerout[last_basic_block]); + FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs) + sbitmap_a_and_b (nearerout[last_basic_block], + nearerout[last_basic_block], nearer[(size_t) e->aux]); clear_aux_for_edges (); @@ -702,22 +684,22 @@ compute_nearerout (edge_list, farthest, st_avloc, nearer, nearerout) /* Compute the insertion and deletion points for edge based LCM. */ static void -compute_rev_insert_delete (edge_list, st_avloc, nearer, nearerout, - insert, delete) - struct edge_list *edge_list; - sbitmap *st_avloc, *nearer, *nearerout, *insert, *delete; +compute_rev_insert_delete (struct edge_list *edge_list, sbitmap *st_avloc, + sbitmap *nearer, sbitmap *nearerout, + sbitmap *insert, sbitmap *del) { int x; basic_block bb; FOR_EACH_BB (bb) - sbitmap_difference (delete[bb->index], st_avloc[bb->index], nearerout[bb->index]); + sbitmap_difference (del[bb->index], st_avloc[bb->index], + nearerout[bb->index]); for (x = 0; x < NUM_EDGES (edge_list); x++) { basic_block b = INDEX_EDGE_PRED_BB (edge_list, x); if (b == ENTRY_BLOCK_PTR) - sbitmap_difference (insert[x], nearer[x], nearerout[n_basic_blocks]); + sbitmap_difference (insert[x], nearer[x], nearerout[last_basic_block]); else sbitmap_difference (insert[x], nearer[x], nearerout[b->index]); } @@ -729,16 +711,9 @@ compute_rev_insert_delete (edge_list, st_avloc, nearer, nearerout, an expression should be inserted on. */ struct edge_list * -pre_edge_rev_lcm (file, n_exprs, transp, st_avloc, st_antloc, kill, - insert, delete) - FILE *file ATTRIBUTE_UNUSED; - int n_exprs; - sbitmap *transp; - sbitmap *st_avloc; - sbitmap *st_antloc; - sbitmap *kill; - sbitmap **insert; - sbitmap **delete; +pre_edge_rev_lcm (int n_exprs, sbitmap *transp, + sbitmap *st_avloc, sbitmap *st_antloc, sbitmap *kill, + sbitmap **insert, sbitmap **del) { sbitmap *st_antin, *st_antout; sbitmap *st_avout, *st_avin, *farthest; @@ -749,37 +724,37 @@ pre_edge_rev_lcm (file, n_exprs, transp, st_avloc, st_antloc, kill, edge_list = create_edge_list (); num_edges = NUM_EDGES (edge_list); - st_antin = (sbitmap *) sbitmap_vector_alloc (n_basic_blocks, n_exprs); - st_antout = (sbitmap *) sbitmap_vector_alloc (n_basic_blocks, n_exprs); - sbitmap_vector_zero (st_antin, n_basic_blocks); - sbitmap_vector_zero (st_antout, n_basic_blocks); + st_antin = sbitmap_vector_alloc (last_basic_block, n_exprs); + st_antout = sbitmap_vector_alloc (last_basic_block, n_exprs); + sbitmap_vector_zero (st_antin, last_basic_block); + sbitmap_vector_zero (st_antout, last_basic_block); compute_antinout_edge (st_antloc, transp, st_antin, st_antout); /* Compute global anticipatability. */ - st_avout = sbitmap_vector_alloc (n_basic_blocks, n_exprs); - st_avin = sbitmap_vector_alloc (n_basic_blocks, n_exprs); + st_avout = sbitmap_vector_alloc (last_basic_block, n_exprs); + st_avin = sbitmap_vector_alloc (last_basic_block, n_exprs); compute_available (st_avloc, kill, st_avout, st_avin); #ifdef LCM_DEBUG_INFO - if (file) + if (dump_file) { - fprintf (file, "Edge List:\n"); - verify_edge_list (file, edge_list); - print_edge_list (file, edge_list); - dump_sbitmap_vector (file, "transp", "", transp, n_basic_blocks); - dump_sbitmap_vector (file, "st_avloc", "", st_avloc, n_basic_blocks); - dump_sbitmap_vector (file, "st_antloc", "", st_antloc, n_basic_blocks); - dump_sbitmap_vector (file, "st_antin", "", st_antin, n_basic_blocks); - dump_sbitmap_vector (file, "st_antout", "", st_antout, n_basic_blocks); - dump_sbitmap_vector (file, "st_kill", "", kill, n_basic_blocks); + fprintf (dump_file, "Edge List:\n"); + verify_edge_list (dump_file, edge_list); + print_edge_list (dump_file, edge_list); + dump_sbitmap_vector (dump_file, "transp", "", transp, last_basic_block); + dump_sbitmap_vector (dump_file, "st_avloc", "", st_avloc, last_basic_block); + dump_sbitmap_vector (dump_file, "st_antloc", "", st_antloc, last_basic_block); + dump_sbitmap_vector (dump_file, "st_antin", "", st_antin, last_basic_block); + dump_sbitmap_vector (dump_file, "st_antout", "", st_antout, last_basic_block); + dump_sbitmap_vector (dump_file, "st_kill", "", kill, last_basic_block); } #endif #ifdef LCM_DEBUG_INFO - if (file) + if (dump_file) { - dump_sbitmap_vector (file, "st_avout", "", st_avout, n_basic_blocks); - dump_sbitmap_vector (file, "st_avin", "", st_avin, n_basic_blocks); + dump_sbitmap_vector (dump_file, "st_avout", "", st_avout, last_basic_block); + dump_sbitmap_vector (dump_file, "st_avin", "", st_avin, last_basic_block); } #endif @@ -789,8 +764,8 @@ pre_edge_rev_lcm (file, n_exprs, transp, st_avloc, st_antloc, kill, kill, farthest); #ifdef LCM_DEBUG_INFO - if (file) - dump_sbitmap_vector (file, "farthest", "", farthest, num_edges); + if (dump_file) + dump_sbitmap_vector (dump_file, "farthest", "", farthest, num_edges); #endif sbitmap_vector_free (st_antin); @@ -802,606 +777,36 @@ pre_edge_rev_lcm (file, n_exprs, transp, st_avloc, st_antloc, kill, nearer = sbitmap_vector_alloc (num_edges, n_exprs); /* Allocate an extra element for the entry block. */ - nearerout = sbitmap_vector_alloc (n_basic_blocks + 1, n_exprs); + nearerout = sbitmap_vector_alloc (last_basic_block + 1, n_exprs); compute_nearerout (edge_list, farthest, st_avloc, nearer, nearerout); #ifdef LCM_DEBUG_INFO - if (file) + if (dump_file) { - dump_sbitmap_vector (file, "nearerout", "", nearerout, - n_basic_blocks + 1); - dump_sbitmap_vector (file, "nearer", "", nearer, num_edges); + dump_sbitmap_vector (dump_file, "nearerout", "", nearerout, + last_basic_block + 1); + dump_sbitmap_vector (dump_file, "nearer", "", nearer, num_edges); } #endif sbitmap_vector_free (farthest); *insert = sbitmap_vector_alloc (num_edges, n_exprs); - *delete = sbitmap_vector_alloc (n_basic_blocks, n_exprs); + *del = sbitmap_vector_alloc (last_basic_block, n_exprs); compute_rev_insert_delete (edge_list, st_avloc, nearer, nearerout, - *insert, *delete); + *insert, *del); sbitmap_vector_free (nearerout); sbitmap_vector_free (nearer); #ifdef LCM_DEBUG_INFO - if (file) + if (dump_file) { - dump_sbitmap_vector (file, "pre_insert_map", "", *insert, num_edges); - dump_sbitmap_vector (file, "pre_delete_map", "", *delete, - n_basic_blocks); + dump_sbitmap_vector (dump_file, "pre_insert_map", "", *insert, num_edges); + dump_sbitmap_vector (dump_file, "pre_delete_map", "", *del, + last_basic_block); } #endif return edge_list; } -/* Mode switching: - - The algorithm for setting the modes consists of scanning the insn list - and finding all the insns which require a specific mode. Each insn gets - a unique struct seginfo element. These structures are inserted into a list - for each basic block. For each entity, there is an array of bb_info over - the flow graph basic blocks (local var 'bb_info'), and contains a list - of all insns within that basic block, in the order they are encountered. - - For each entity, any basic block WITHOUT any insns requiring a specific - mode are given a single entry, without a mode. (Each basic block - in the flow graph must have at least one entry in the segment table.) - - The LCM algorithm is then run over the flow graph to determine where to - place the sets to the highest-priority value in respect of first the first - insn in any one block. Any adjustments required to the transparancy - vectors are made, then the next iteration starts for the next-lower - priority mode, till for each entity all modes are exhasted. - - More details are located in the code for optimize_mode_switching(). */ - -/* This structure contains the information for each insn which requires - either single or double mode to be set. - MODE is the mode this insn must be executed in. - INSN_PTR is the insn to be executed (may be the note that marks the - beginning of a basic block). - BBNUM is the flow graph basic block this insn occurs in. - NEXT is the next insn in the same basic block. */ -struct seginfo -{ - int mode; - rtx insn_ptr; - int bbnum; - struct seginfo *next; - HARD_REG_SET regs_live; -}; - -struct bb_info -{ - struct seginfo *seginfo; - int computing; -}; - -/* These bitmaps are used for the LCM algorithm. */ - -#ifdef OPTIMIZE_MODE_SWITCHING -static sbitmap *antic; -static sbitmap *transp; -static sbitmap *comp; -static sbitmap *delete; -static sbitmap *insert; - -static struct seginfo * new_seginfo PARAMS ((int, rtx, int, HARD_REG_SET)); -static void add_seginfo PARAMS ((struct bb_info *, struct seginfo *)); -static void reg_dies PARAMS ((rtx, HARD_REG_SET)); -static void reg_becomes_live PARAMS ((rtx, rtx, void *)); -static void make_preds_opaque PARAMS ((basic_block, int)); -#endif - -#ifdef OPTIMIZE_MODE_SWITCHING - -/* This function will allocate a new BBINFO structure, initialized - with the MODE, INSN, and basic block BB parameters. */ - -static struct seginfo * -new_seginfo (mode, insn, bb, regs_live) - int mode; - rtx insn; - int bb; - HARD_REG_SET regs_live; -{ - struct seginfo *ptr; - ptr = xmalloc (sizeof (struct seginfo)); - ptr->mode = mode; - ptr->insn_ptr = insn; - ptr->bbnum = bb; - ptr->next = NULL; - COPY_HARD_REG_SET (ptr->regs_live, regs_live); - return ptr; -} - -/* Add a seginfo element to the end of a list. - HEAD is a pointer to the list beginning. - INFO is the structure to be linked in. */ - -static void -add_seginfo (head, info) - struct bb_info *head; - struct seginfo *info; -{ - struct seginfo *ptr; - - if (head->seginfo == NULL) - head->seginfo = info; - else - { - ptr = head->seginfo; - while (ptr->next != NULL) - ptr = ptr->next; - ptr->next = info; - } -} - -/* Make all predecessors of basic block B opaque, recursively, till we hit - some that are already non-transparent, or an edge where aux is set; that - denotes that a mode set is to be done on that edge. - J is the bit number in the bitmaps that corresponds to the entity that - we are currently handling mode-switching for. */ - -static void -make_preds_opaque (b, j) - basic_block b; - int j; -{ - edge e; - - for (e = b->pred; e; e = e->pred_next) - { - basic_block pb = e->src; - - if (e->aux || ! TEST_BIT (transp[pb->index], j)) - continue; - - RESET_BIT (transp[pb->index], j); - make_preds_opaque (pb, j); - } -} - -/* Record in LIVE that register REG died. */ - -static void -reg_dies (reg, live) - rtx reg; - HARD_REG_SET live; -{ - int regno, nregs; - - if (GET_CODE (reg) != REG) - return; - - regno = REGNO (reg); - if (regno < FIRST_PSEUDO_REGISTER) - for (nregs = HARD_REGNO_NREGS (regno, GET_MODE (reg)) - 1; nregs >= 0; - nregs--) - CLEAR_HARD_REG_BIT (live, regno + nregs); -} - -/* Record in LIVE that register REG became live. - This is called via note_stores. */ - -static void -reg_becomes_live (reg, setter, live) - rtx reg; - rtx setter ATTRIBUTE_UNUSED; - void *live; -{ - int regno, nregs; - - if (GET_CODE (reg) == SUBREG) - reg = SUBREG_REG (reg); - - if (GET_CODE (reg) != REG) - return; - - regno = REGNO (reg); - if (regno < FIRST_PSEUDO_REGISTER) - for (nregs = HARD_REGNO_NREGS (regno, GET_MODE (reg)) - 1; nregs >= 0; - nregs--) - SET_HARD_REG_BIT (* (HARD_REG_SET *) live, regno + nregs); -} - -/* Find all insns that need a particular mode setting, and insert the - necessary mode switches. Return true if we did work. */ - -int -optimize_mode_switching (file) - FILE *file; -{ - rtx insn; - int e; - basic_block bb; - int need_commit = 0; - sbitmap *kill; - struct edge_list *edge_list; - static const int num_modes[] = NUM_MODES_FOR_MODE_SWITCHING; -#define N_ENTITIES ARRAY_SIZE (num_modes) - int entity_map[N_ENTITIES]; - struct bb_info *bb_info[N_ENTITIES]; - int i, j; - int n_entities; - int max_num_modes = 0; - bool emited = false; - - clear_bb_flags (); -#ifdef NORMAL_MODE - /* Increment n_basic_blocks before allocating bb_info. */ - n_basic_blocks++; -#endif - - for (e = N_ENTITIES - 1, n_entities = 0; e >= 0; e--) - if (OPTIMIZE_MODE_SWITCHING (e)) - { - /* Create the list of segments within each basic block. */ - bb_info[n_entities] - = (struct bb_info *) xcalloc (n_basic_blocks, sizeof **bb_info); - entity_map[n_entities++] = e; - if (num_modes[e] > max_num_modes) - max_num_modes = num_modes[e]; - } - -#ifdef NORMAL_MODE - /* Decrement it back in case we return below. */ - n_basic_blocks--; -#endif - - if (! n_entities) - return 0; - -#ifdef NORMAL_MODE - /* We're going to pretend the EXIT_BLOCK is a regular basic block, - so that switching back to normal mode when entering the - EXIT_BLOCK isn't optimized away. We do this by incrementing the - basic block count, growing the VARRAY of basic_block_info and - appending the EXIT_BLOCK_PTR to it. */ - n_basic_blocks++; - if (VARRAY_SIZE (basic_block_info) < n_basic_blocks) - VARRAY_GROW (basic_block_info, n_basic_blocks); - BASIC_BLOCK (n_basic_blocks - 1) = EXIT_BLOCK_PTR; - EXIT_BLOCK_PTR->index = n_basic_blocks - 1; -#endif - - /* Create the bitmap vectors. */ - - antic = sbitmap_vector_alloc (n_basic_blocks, n_entities); - transp = sbitmap_vector_alloc (n_basic_blocks, n_entities); - comp = sbitmap_vector_alloc (n_basic_blocks, n_entities); - - sbitmap_vector_ones (transp, n_basic_blocks); - - for (j = n_entities - 1; j >= 0; j--) - { - int e = entity_map[j]; - int no_mode = num_modes[e]; - struct bb_info *info = bb_info[j]; - - /* Determine what the first use (if any) need for a mode of entity E is. - This will be the mode that is anticipatable for this block. - Also compute the initial transparency settings. */ - FOR_EACH_BB (bb) - { - struct seginfo *ptr; - int last_mode = no_mode; - HARD_REG_SET live_now; - - REG_SET_TO_HARD_REG_SET (live_now, - bb->global_live_at_start); - for (insn = bb->head; - insn != NULL && insn != NEXT_INSN (bb->end); - insn = NEXT_INSN (insn)) - { - if (INSN_P (insn)) - { - int mode = MODE_NEEDED (e, insn); - rtx link; - - if (mode != no_mode && mode != last_mode) - { - last_mode = mode; - ptr = new_seginfo (mode, insn, bb->index, live_now); - add_seginfo (info + bb->index, ptr); - RESET_BIT (transp[bb->index], j); - } - - /* Update LIVE_NOW. */ - for (link = REG_NOTES (insn); link; link = XEXP (link, 1)) - if (REG_NOTE_KIND (link) == REG_DEAD) - reg_dies (XEXP (link, 0), live_now); - - note_stores (PATTERN (insn), reg_becomes_live, &live_now); - for (link = REG_NOTES (insn); link; link = XEXP (link, 1)) - if (REG_NOTE_KIND (link) == REG_UNUSED) - reg_dies (XEXP (link, 0), live_now); - } - } - - info[bb->index].computing = last_mode; - /* Check for blocks without ANY mode requirements. */ - if (last_mode == no_mode) - { - ptr = new_seginfo (no_mode, insn, bb->index, live_now); - add_seginfo (info + bb->index, ptr); - } - } -#ifdef NORMAL_MODE - { - int mode = NORMAL_MODE (e); - - if (mode != no_mode) - { - edge eg; - - for (eg = ENTRY_BLOCK_PTR->succ; eg; eg = eg->succ_next) - { - bb = eg->dest; - - /* By always making this nontransparent, we save - an extra check in make_preds_opaque. We also - need this to avoid confusing pre_edge_lcm when - antic is cleared but transp and comp are set. */ - RESET_BIT (transp[bb->index], j); - - /* If the block already has MODE, pretend it - has none (because we don't need to set it), - but retain whatever mode it computes. */ - if (info[bb].seginfo->mode == mode) - info[bb].seginfo->mode = no_mode; - - /* Insert a fake computing definition of MODE into entry - blocks which compute no mode. This represents the mode on - entry. */ - else if (info[bb].computing == no_mode) - { - info[bb].computing = mode; - info[bb].seginfo->mode = no_mode; - } - } - - bb = EXIT_BLOCK_PTR; - info[bb].seginfo->mode = mode; - } - } -#endif /* NORMAL_MODE */ - } - - kill = sbitmap_vector_alloc (n_basic_blocks, n_entities); - for (i = 0; i < max_num_modes; i++) - { - int current_mode[N_ENTITIES]; - - /* Set the anticipatable and computing arrays. */ - sbitmap_vector_zero (antic, n_basic_blocks); - sbitmap_vector_zero (comp, n_basic_blocks); - for (j = n_entities - 1; j >= 0; j--) - { - int m = current_mode[j] = MODE_PRIORITY_TO_MODE (entity_map[j], i); - struct bb_info *info = bb_info[j]; - - FOR_EACH_BB (bb) - { - if (info[bb->index].seginfo->mode == m) - SET_BIT (antic[bb->index], j); - - if (info[bb->index].computing == m) - SET_BIT (comp[bb->index], j); - } - } - - /* Calculate the optimal locations for the - placement mode switches to modes with priority I. */ - - FOR_EACH_BB (bb) - sbitmap_not (kill[bb->index], transp[bb->index]); - edge_list = pre_edge_lcm (file, 1, transp, comp, antic, - kill, &insert, &delete); - - for (j = n_entities - 1; j >= 0; j--) - { - /* Insert all mode sets that have been inserted by lcm. */ - int no_mode = num_modes[entity_map[j]]; - - /* Wherever we have moved a mode setting upwards in the flow graph, - the blocks between the new setting site and the now redundant - computation ceases to be transparent for any lower-priority - mode of the same entity. First set the aux field of each - insertion site edge non-transparent, then propagate the new - non-transparency from the redundant computation upwards till - we hit an insertion site or an already non-transparent block. */ - for (e = NUM_EDGES (edge_list) - 1; e >= 0; e--) - { - edge eg = INDEX_EDGE (edge_list, e); - int mode; - basic_block src_bb; - HARD_REG_SET live_at_edge; - rtx mode_set; - - eg->aux = 0; - - if (! TEST_BIT (insert[e], j)) - continue; - - eg->aux = (void *)1; - - mode = current_mode[j]; - src_bb = eg->src; - - REG_SET_TO_HARD_REG_SET (live_at_edge, - src_bb->global_live_at_end); - - start_sequence (); - EMIT_MODE_SET (entity_map[j], mode, live_at_edge); - mode_set = gen_sequence (); - end_sequence (); - - /* Do not bother to insert empty sequence. */ - if (GET_CODE (mode_set) == SEQUENCE - && !XVECLEN (mode_set, 0)) - continue; - - /* If this is an abnormal edge, we'll insert at the end - of the previous block. */ - if (eg->flags & EDGE_ABNORMAL) - { - emited = true; - if (GET_CODE (src_bb->end) == JUMP_INSN) - emit_insn_before (mode_set, src_bb->end); - /* It doesn't make sense to switch to normal mode - after a CALL_INSN, so we're going to abort if we - find one. The cases in which a CALL_INSN may - have an abnormal edge are sibcalls and EH edges. - In the case of sibcalls, the dest basic-block is - the EXIT_BLOCK, that runs in normal mode; it is - assumed that a sibcall insn requires normal mode - itself, so no mode switch would be required after - the call (it wouldn't make sense, anyway). In - the case of EH edges, EH entry points also start - in normal mode, so a similar reasoning applies. */ - else if (GET_CODE (src_bb->end) == INSN) - emit_insn_after (mode_set, src_bb->end); - else - abort (); - bb_info[j][src_bb->index].computing = mode; - RESET_BIT (transp[src_bb->index], j); - } - else - { - need_commit = 1; - insert_insn_on_edge (mode_set, eg); - } - } - - FOR_EACH_BB_REVERSE (bb) - if (TEST_BIT (delete[bb->index], j)) - { - make_preds_opaque (bb, j); - /* Cancel the 'deleted' mode set. */ - bb_info[j][bb->index].seginfo->mode = no_mode; - } - } - - clear_aux_for_edges (); - free_edge_list (edge_list); - } - -#ifdef NORMAL_MODE - /* Restore the special status of EXIT_BLOCK. */ - n_basic_blocks--; - VARRAY_POP (basic_block_info); - EXIT_BLOCK_PTR->index = EXIT_BLOCK; -#endif - - /* Now output the remaining mode sets in all the segments. */ - for (j = n_entities - 1; j >= 0; j--) - { - int no_mode = num_modes[entity_map[j]]; - -#ifdef NORMAL_MODE - if (bb_info[j][n_basic_blocks].seginfo->mode != no_mode) - { - edge eg; - struct seginfo *ptr = bb_info[j][n_basic_blocks].seginfo; - - for (eg = EXIT_BLOCK_PTR->pred; eg; eg = eg->pred_next) - { - rtx mode_set; - - if (bb_info[j][eg->src->index].computing == ptr->mode) - continue; - - start_sequence (); - EMIT_MODE_SET (entity_map[j], ptr->mode, ptr->regs_live); - mode_set = gen_sequence (); - end_sequence (); - - /* Do not bother to insert empty sequence. */ - if (GET_CODE (mode_set) == SEQUENCE - && !XVECLEN (mode_set, 0)) - continue; - - /* If this is an abnormal edge, we'll insert at the end of the - previous block. */ - if (eg->flags & EDGE_ABNORMAL) - { - emited = true; - if (GET_CODE (eg->src->end) == JUMP_INSN) - emit_insn_before (mode_set, eg->src->end); - else if (GET_CODE (eg->src->end) == INSN) - emit_insn_after (mode_set, eg->src->end); - else - abort (); - } - else - { - need_commit = 1; - insert_insn_on_edge (mode_set, eg); - } - } - - } -#endif - - FOR_EACH_BB_REVERSE (bb) - { - struct seginfo *ptr, *next; - for (ptr = bb_info[j][bb->index].seginfo; ptr; ptr = next) - { - next = ptr->next; - if (ptr->mode != no_mode) - { - rtx mode_set; - - start_sequence (); - EMIT_MODE_SET (entity_map[j], ptr->mode, ptr->regs_live); - mode_set = gen_sequence (); - end_sequence (); - - /* Do not bother to insert empty sequence. */ - if (GET_CODE (mode_set) == SEQUENCE - && !XVECLEN (mode_set, 0)) - continue; - - emited = true; - if (GET_CODE (ptr->insn_ptr) == NOTE - && (NOTE_LINE_NUMBER (ptr->insn_ptr) - == NOTE_INSN_BASIC_BLOCK)) - emit_insn_after (mode_set, ptr->insn_ptr); - else - emit_insn_before (mode_set, ptr->insn_ptr); - } - - free (ptr); - } - } - - free (bb_info[j]); - } - - /* Finished. Free up all the things we've allocated. */ - - sbitmap_vector_free (kill); - sbitmap_vector_free (antic); - sbitmap_vector_free (transp); - sbitmap_vector_free (comp); - sbitmap_vector_free (delete); - sbitmap_vector_free (insert); - - if (need_commit) - commit_edge_insertions (); - - if (!need_commit && !emited) - return 0; - - max_regno = max_reg_num (); - allocate_reg_info (max_regno, FALSE, FALSE); - update_life_info_in_dirty_blocks (UPDATE_LIFE_GLOBAL_RM_NOTES, - (PROP_DEATH_NOTES | PROP_KILL_DEAD_CODE - | PROP_SCAN_DEAD_CODE)); - - return 1; -} -#endif /* OPTIMIZE_MODE_SWITCHING */