diff options
author | kan <kan@FreeBSD.org> | 2004-07-28 03:11:36 +0000 |
---|---|---|
committer | kan <kan@FreeBSD.org> | 2004-07-28 03:11:36 +0000 |
commit | 5e00ec74d8ce58f99801200d4d3d0412c7cc1b28 (patch) | |
tree | 052f4bb635f2bea2c5e350bd60c902be100a0d1e /contrib/gcc/lcm.c | |
parent | 87b8398a7d9f9bf0e28bbcd54a4fc27db2125f38 (diff) | |
download | FreeBSD-src-5e00ec74d8ce58f99801200d4d3d0412c7cc1b28.zip FreeBSD-src-5e00ec74d8ce58f99801200d4d3d0412c7cc1b28.tar.gz |
Gcc 3.4.2 20040728.
Diffstat (limited to 'contrib/gcc/lcm.c')
-rw-r--r-- | contrib/gcc/lcm.c | 217 |
1 files changed, 89 insertions, 128 deletions
diff --git a/contrib/gcc/lcm.c b/contrib/gcc/lcm.c index bdbae42..c866904 100644 --- a/contrib/gcc/lcm.c +++ b/contrib/gcc/lcm.c @@ -1,5 +1,6 @@ /* Generic partial redundancy elimination with lazy code motion support. - Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc. + Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 + Free Software Foundation, Inc. This file is part of GCC. @@ -51,6 +52,8 @@ 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" @@ -61,38 +64,29 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "basic-block.h" #include "output.h" #include "tm_p.h" +#include "function.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. */ @@ -101,11 +95,8 @@ 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; @@ -115,8 +106,7 @@ compute_antinout_edge (antloc, transp, antin, antout) /* 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 = xmalloc (sizeof (basic_block) * n_basic_blocks); /* We want a maximal solution, so make an optimistic initialization of ANTIN. */ @@ -126,7 +116,7 @@ compute_antinout_edge (antloc, transp, antin, antout) optimistic initialization of ANTIN above. */ FOR_EACH_BB_REVERSE (bb) { - *qin++ =bb; + *qin++ = bb; bb->aux = bb; } @@ -186,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; @@ -255,9 +244,8 @@ 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; @@ -270,7 +258,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)); + = xmalloc (sizeof (basic_block) * (n_basic_blocks + 1)); /* Initialize a mapping from each edge to its index. */ for (i = 0; i < num_edges; i++) @@ -305,7 +293,7 @@ compute_laterin (edge_list, earliest, antloc, later, laterin) 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. */ + of n_basic_blocks + 1 elements is not necessary. */ qend = &worklist[n_basic_blocks]; qlen = n_basic_blocks; @@ -358,10 +346,9 @@ 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 *delete) { int x; basic_block bb; @@ -385,15 +372,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 (FILE *file ATTRIBUTE_UNUSED, int n_exprs, sbitmap *transp, + sbitmap *avloc, sbitmap *antloc, sbitmap *kill, + sbitmap **insert, sbitmap **delete) { sbitmap *antin, *antout, *earliest; sbitmap *avin, *avout; @@ -488,8 +469,8 @@ 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; @@ -498,8 +479,7 @@ compute_available (avloc, kill, avout, avin) /* 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 = xmalloc (sizeof (basic_block) * n_basic_blocks); /* We want a maximal solution. */ sbitmap_vector_ones (avout, last_basic_block); @@ -570,11 +550,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; @@ -616,9 +594,8 @@ 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; @@ -629,8 +606,7 @@ compute_nearerout (edge_list, farthest, st_avloc, nearer, nearerout) /* 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 = xmalloc (sizeof (basic_block) * (n_basic_blocks + 1)); /* Initialize NEARER for each edge and build a mapping from an edge to its index. */ @@ -699,10 +675,9 @@ 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 *delete) { int x; basic_block bb; @@ -726,16 +701,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 (FILE *file ATTRIBUTE_UNUSED, int n_exprs, sbitmap *transp, + sbitmap *st_avloc, sbitmap *st_antloc, sbitmap *kill, + sbitmap **insert, sbitmap **delete) { sbitmap *st_antin, *st_antout; sbitmap *st_avout, *st_avin, *farthest; @@ -746,8 +714,8 @@ 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 (last_basic_block, n_exprs); - st_antout = (sbitmap *) sbitmap_vector_alloc (last_basic_block, n_exprs); + 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); @@ -847,9 +815,9 @@ pre_edge_rev_lcm (file, n_exprs, transp, st_avloc, st_antloc, kill, 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 + insn in any one block. Any adjustments required to the transparency vectors are made, then the next iteration starts for the next-lower - priority mode, till for each entity all modes are exhasted. + priority mode, till for each entity all modes are exhausted. More details are located in the code for optimize_mode_switching(). */ @@ -884,11 +852,11 @@ 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)); +static struct seginfo * new_seginfo (int, rtx, int, HARD_REG_SET); +static void add_seginfo (struct bb_info *, struct seginfo *); +static void reg_dies (rtx, HARD_REG_SET); +static void reg_becomes_live (rtx, rtx, void *); +static void make_preds_opaque (basic_block, int); #endif #ifdef OPTIMIZE_MODE_SWITCHING @@ -897,11 +865,7 @@ static void make_preds_opaque PARAMS ((basic_block, int)); 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; +new_seginfo (int mode, rtx insn, int bb, HARD_REG_SET regs_live) { struct seginfo *ptr; ptr = xmalloc (sizeof (struct seginfo)); @@ -918,9 +882,7 @@ new_seginfo (mode, insn, bb, regs_live) INFO is the structure to be linked in. */ static void -add_seginfo (head, info) - struct bb_info *head; - struct seginfo *info; +add_seginfo (struct bb_info *head, struct seginfo *info) { struct seginfo *ptr; @@ -942,9 +904,7 @@ add_seginfo (head, info) we are currently handling mode-switching for. */ static void -make_preds_opaque (b, j) - basic_block b; - int j; +make_preds_opaque (basic_block b, int j) { edge e; @@ -963,9 +923,7 @@ make_preds_opaque (b, j) /* Record in LIVE that register REG died. */ static void -reg_dies (reg, live) - rtx reg; - HARD_REG_SET live; +reg_dies (rtx reg, HARD_REG_SET live) { int regno, nregs; @@ -983,10 +941,7 @@ reg_dies (reg, live) This is called via note_stores. */ static void -reg_becomes_live (reg, setter, live) - rtx reg; - rtx setter ATTRIBUTE_UNUSED; - void *live; +reg_becomes_live (rtx reg, rtx setter ATTRIBUTE_UNUSED, void *live) { int regno, nregs; @@ -1003,12 +958,17 @@ reg_becomes_live (reg, setter, live) SET_HARD_REG_BIT (* (HARD_REG_SET *) live, regno + nregs); } +/* Make sure if MODE_ENTRY is defined the MODE_EXIT is defined + and vice versa. */ +#if defined (MODE_ENTRY) != defined (MODE_EXIT) + #error "Both MODE_ENTRY and MODE_EXIT must be defined" +#endif + /* 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; +optimize_mode_switching (FILE *file) { rtx insn; int e; @@ -1036,12 +996,11 @@ optimize_mode_switching (file) /* Create the list of segments within each basic block. If NORMAL_MODE is defined, allow for two extra blocks split from the entry and exit block. */ -#ifdef NORMAL_MODE +#if defined (MODE_ENTRY) && defined (MODE_EXIT) entry_exit_extra = 2; #endif bb_info[n_entities] - = (struct bb_info *) xcalloc (last_basic_block + entry_exit_extra, - sizeof **bb_info); + = xcalloc (last_basic_block + entry_exit_extra, sizeof **bb_info); entity_map[n_entities++] = e; if (num_modes[e] > max_num_modes) max_num_modes = num_modes[e]; @@ -1050,7 +1009,7 @@ optimize_mode_switching (file) if (! n_entities) return 0; -#ifdef NORMAL_MODE +#if defined (MODE_ENTRY) && defined (MODE_EXIT) { /* Split the edge from the entry block and the fallthrough edge to the exit block, so that we can note that there NORMAL_MODE is supplied / @@ -1099,8 +1058,8 @@ optimize_mode_switching (file) REG_SET_TO_HARD_REG_SET (live_now, bb->global_live_at_start); - for (insn = bb->head; - insn != NULL && insn != NEXT_INSN (bb->end); + for (insn = BB_HEAD (bb); + insn != NULL && insn != NEXT_INSN (BB_END (bb)); insn = NEXT_INSN (insn)) { if (INSN_P (insn)) @@ -1115,7 +1074,9 @@ optimize_mode_switching (file) add_seginfo (info + bb->index, ptr); RESET_BIT (transp[bb->index], j); } - +#ifdef MODE_AFTER + last_mode = MODE_AFTER (last_mode, insn); +#endif /* Update LIVE_NOW. */ for (link = REG_NOTES (insn); link; link = XEXP (link, 1)) if (REG_NOTE_KIND (link) == REG_DEAD) @@ -1132,13 +1093,13 @@ optimize_mode_switching (file) /* Check for blocks without ANY mode requirements. */ if (last_mode == no_mode) { - ptr = new_seginfo (no_mode, bb->end, bb->index, live_now); + ptr = new_seginfo (no_mode, BB_END (bb), bb->index, live_now); add_seginfo (info + bb->index, ptr); } } -#ifdef NORMAL_MODE +#if defined (MODE_ENTRY) && defined (MODE_EXIT) { - int mode = NORMAL_MODE (e); + int mode = MODE_ENTRY (e); if (mode != no_mode) { @@ -1156,7 +1117,7 @@ optimize_mode_switching (file) info[bb->index].computing = mode; if (pre_exit) - info[pre_exit->index].seginfo->mode = mode; + info[pre_exit->index].seginfo->mode = MODE_EXIT (e); } } #endif /* NORMAL_MODE */ @@ -1240,8 +1201,8 @@ optimize_mode_switching (file) if (eg->flags & EDGE_ABNORMAL) { emited = true; - if (GET_CODE (src_bb->end) == JUMP_INSN) - emit_insn_before (mode_set, src_bb->end); + if (GET_CODE (BB_END (src_bb)) == JUMP_INSN) + emit_insn_before (mode_set, BB_END (src_bb)); /* 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 @@ -1253,8 +1214,8 @@ optimize_mode_switching (file) 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 if (GET_CODE (BB_END (src_bb)) == INSN) + emit_insn_after (mode_set, BB_END (src_bb)); else abort (); bb_info[j][src_bb->index].computing = mode; @@ -1332,7 +1293,7 @@ optimize_mode_switching (file) if (need_commit) commit_edge_insertions (); -#ifdef NORMAL_MODE +#if defined (MODE_ENTRY) && defined (MODE_EXIT) cleanup_cfg (CLEANUP_NO_INSN_DEL); #else if (!need_commit && !emited) |