+Tue Oct 30 11:08:11 CET 2001 Jan Hubicka <jh@suse.cz>
+
+ * lcm.c (optimize_mode_switching): Do not rebuild liveness information
+ when no changes has been made.
+
+ * gcse.c (reg_set_bitmap): Turn into reg_set.
+ (modify_mem_list_set, canon_modify_mem_list_set)
+ (clear_modify_mem_tables, free_modify_mem_tables): New.
+ (gcse_main); Use free_modify_mem_tables.
+ (free_gcse_mem): Likewise; free the bitmaps.
+ (alloc_gcse_main): Initialize the bitmaps.
+ (canon_list_insert): Set canon_modify_mem_list_set.
+ (record_last_mem_set_info): Likewise; set modify_mem_list_set.
+ (compute_hash_table): Use clear_modify_mem_tables.
+ (reset_opr_set_tables): Likewise.
+ (oprs_not_set_p): reg_set_bitmap is regset.
+ (mark_set, mark_clobber): Likewise.
+
+ * df.h (DF_EQUIV_NOTES): New constant.
+ (df_insn_refs_record): Record uses inside or REG_EQUIV/EQUAL notes
+ when asked for.
+
+ * sched-rgn.c (CHECK_DEAD_NOTES): New constant.
+ (init_regions, schedule_insns): Conditionalize the checking
+ code by CHECK_DEAD_NOTES; avoid multiple calls to update_life_info.
+
Tue Oct 30 11:02:31 CET 2001 Jan Hubicka <jh@suse.cz>
* i386.md (movti_rex64 splitter): Fix condition.
if (INSN_P (insn))
{
+ rtx note;
+
/* Record register defs */
df_defs_record (df, PATTERN (insn), bb, insn);
+
+ if (df->flags & DF_EQUIV_NOTES)
+ for (note = REG_NOTES (insn); note;
+ note = XEXP (note, 1))
+ {
+ switch (REG_NOTE_KIND (note))
+ {
+ case REG_EQUIV:
+ case REG_EQUAL:
+ df_uses_record (df, &XEXP (note, 0), DF_REF_REG_USE,
+ bb, insn);
+ default:
+ break;
+ }
+ }
if (GET_CODE (insn) == CALL_INSN)
{
#define DF_RU_CHAIN 128 /* Reg-use chain. */
#define DF_ALL 255
#define DF_HARD_REGS 1024
+#define DF_EQUIV_NOTES 2048 /* Mark uses present in EQUIV/EQUAL notes. */
enum df_ref_type {DF_REF_REG_DEF, DF_REF_REG_USE, DF_REF_REG_MEM_LOAD,
DF_REF_REG_MEM_STORE};
/* Bitmap containing one bit for each register in the program.
Used when performing GCSE to track which registers have been set since
the start of the basic block. */
-static sbitmap reg_set_bitmap;
+static regset reg_set_bitmap;
/* For each block, a bitmap of registers set in the block.
This is used by expr_killed_p and compute_transp.
/* Array, indexed by basic block number for a list of insns which modify
memory within that block. */
static rtx * modify_mem_list;
+bitmap modify_mem_list_set;
/* This array parallels modify_mem_list, but is kept canonicalized. */
static rtx * canon_modify_mem_list;
+bitmap canon_modify_mem_list_set;
/* Various variables for statistics gathering. */
/* Memory used in a pass.
basic_block));
static void free_store_memory PARAMS ((void));
static void store_motion PARAMS ((void));
+static void clear_modify_mem_tables PARAMS ((void));
+static void free_modify_mem_tables PARAMS ((void));
\f
/* Entry point for global common subexpression elimination.
F is the first instruction in the function. */
basic blocks. */
if (changed)
{
- int i;
-
- for (i = 0; i < orig_bb_count; i++)
- {
- if (modify_mem_list[i])
- free_INSN_LIST_list (modify_mem_list + i);
- if (canon_modify_mem_list[i])
- free_INSN_LIST_list (canon_modify_mem_list + i);
- }
+ free_modify_mem_tables ();
modify_mem_list
= (rtx *) gmalloc (n_basic_blocks * sizeof (rtx *));
canon_modify_mem_list
CUID_INSN (i++) = insn;
/* Allocate vars to track sets of regs. */
- reg_set_bitmap = (sbitmap) sbitmap_alloc (max_gcse_regno);
+ reg_set_bitmap = BITMAP_XMALLOC ();
/* Allocate vars to track sets of regs, memory per block. */
reg_set_in_block = (sbitmap *) sbitmap_vector_alloc (n_basic_blocks,
canon_modify_mem_list = (rtx *) gmalloc (n_basic_blocks * sizeof (rtx *));
memset ((char *) modify_mem_list, 0, n_basic_blocks * sizeof (rtx *));
memset ((char *) canon_modify_mem_list, 0, n_basic_blocks * sizeof (rtx *));
+ modify_mem_list_set = BITMAP_XMALLOC ();
+ canon_modify_mem_list_set = BITMAP_XMALLOC ();
}
/* Free memory allocated by alloc_gcse_mem. */
free (uid_cuid);
free (cuid_insn);
- free (reg_set_bitmap);
+ BITMAP_XFREE (reg_set_bitmap);
sbitmap_vector_free (reg_set_in_block);
- /* re-Cache any INSN_LIST nodes we have allocated. */
- {
- int i;
-
- for (i = 0; i < n_basic_blocks; i++)
- {
- if (modify_mem_list[i])
- free_INSN_LIST_list (modify_mem_list + i);
- if (canon_modify_mem_list[i])
- free_INSN_LIST_list (canon_modify_mem_list + i);
- }
-
- free (modify_mem_list);
- free (canon_modify_mem_list);
- modify_mem_list = 0;
- canon_modify_mem_list = 0;
- }
+ free_modify_mem_tables ();
+ BITMAP_XFREE (modify_mem_list_set);
+ BITMAP_XFREE (canon_modify_mem_list_set);
}
/* Many of the global optimization algorithms work by solving dataflow
alloc_INSN_LIST (dest_addr, canon_modify_mem_list[BLOCK_NUM (insn)]);
canon_modify_mem_list[BLOCK_NUM (insn)] =
alloc_INSN_LIST (dest, canon_modify_mem_list[BLOCK_NUM (insn)]);
+ bitmap_set_bit (canon_modify_mem_list_set, BLOCK_NUM (insn));
}
/* Record memory modification information for INSN. We do not actually care
everything. */
modify_mem_list[BLOCK_NUM (insn)] =
alloc_INSN_LIST (insn, modify_mem_list[BLOCK_NUM (insn)]);
+ bitmap_set_bit (modify_mem_list_set, BLOCK_NUM (insn));
if (GET_CODE (insn) == CALL_INSN)
{
need to insert a pair of items, as canon_list_insert does. */
canon_modify_mem_list[BLOCK_NUM (insn)] =
alloc_INSN_LIST (insn, canon_modify_mem_list[BLOCK_NUM (insn)]);
+ bitmap_set_bit (canon_modify_mem_list_set, BLOCK_NUM (insn));
}
else
note_stores (PATTERN (insn), canon_list_insert, (void*)insn );
sbitmap_vector_zero (reg_set_in_block, n_basic_blocks);
/* re-Cache any INSN_LIST nodes we have allocated. */
- {
- int i;
- for (i = 0; i < n_basic_blocks; i++)
- {
- if (modify_mem_list[i])
- free_INSN_LIST_list (modify_mem_list + i);
- if (canon_modify_mem_list[i])
- free_INSN_LIST_list (canon_modify_mem_list + i);
- }
- }
+ clear_modify_mem_tables ();
/* Some working arrays used to track first and last set in each block. */
reg_avail_info = (struct reg_avail_info*)
gmalloc (max_gcse_regno * sizeof (struct reg_avail_info));
return expr;
}
+/* Clear canon_modify_mem_list and modify_mem_list tables. */
+static void
+clear_modify_mem_tables ()
+{
+ int i;
+
+ EXECUTE_IF_SET_IN_BITMAP
+ (canon_modify_mem_list_set, 0, i,
+ free_INSN_LIST_list (modify_mem_list + i));
+ bitmap_clear (canon_modify_mem_list_set);
+
+ EXECUTE_IF_SET_IN_BITMAP
+ (canon_modify_mem_list_set, 0, i,
+ free_INSN_LIST_list (canon_modify_mem_list + i));
+ bitmap_clear (modify_mem_list_set);
+}
+
+/* Release memory used by modify_mem_list_set and canon_modify_mem_list_set. */
+
+static void
+free_modify_mem_tables ()
+{
+ clear_modify_mem_tables ();
+ free (modify_mem_list);
+ free (canon_modify_mem_list);
+ modify_mem_list = 0;
+ canon_modify_mem_list = 0;
+}
+
/* Reset tables used to keep track of what's still available [since the
start of the block]. */
{
/* Maintain a bitmap of which regs have been set since beginning of
the block. */
- sbitmap_zero (reg_set_bitmap);
+ CLEAR_REG_SET (reg_set_bitmap);
/* Also keep a record of the last instruction to modify memory.
For now this is very trivial, we only record whether any memory
location has been modified. */
- {
- int i;
-
- /* re-Cache any INSN_LIST nodes we have allocated. */
- for (i = 0; i < n_basic_blocks; i++)
- {
- if (modify_mem_list[i])
- free_INSN_LIST_list (modify_mem_list + i);
- if (canon_modify_mem_list[i])
- free_INSN_LIST_list (canon_modify_mem_list + i);
- }
- }
+ clear_modify_mem_tables ();
}
/* Return non-zero if the operands of X are not set before INSN in
return oprs_not_set_p (XEXP (x, 0), insn);
case REG:
- return ! TEST_BIT (reg_set_bitmap, REGNO (x));
+ return ! REGNO_REG_SET_P (reg_set_bitmap, REGNO (x));
default:
break;
dest = XEXP (dest, 0);
if (GET_CODE (dest) == REG)
- SET_BIT (reg_set_bitmap, REGNO (dest));
+ SET_REGNO_REG_SET (reg_set_bitmap, REGNO (dest));
else if (GET_CODE (dest) == MEM)
record_last_mem_set_info (insn);
clob = XEXP (clob, 0);
if (GET_CODE (clob) == REG)
- SET_BIT (reg_set_bitmap, REGNO (clob));
+ SET_REGNO_REG_SET (reg_set_bitmap, REGNO (clob));
else
record_last_mem_set_info (insn);
}
int i, j;
int n_entities;
int max_num_modes = 0;
+ bool emited = false;
#ifdef NORMAL_MODE
/* Increment n_basic_blocks before allocating bb_info. */
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
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)
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))
if (need_commit)
commit_edge_insertions ();
+ if (!need_commit && !emited)
+ return 0;
+
/* Ideally we'd figure out what blocks were affected and start from
there, but this is enormously complicated by commit_edge_insertions,
which would screw up any indicies we'd collected, and also need to
/* Ok, floating point instructions exist. If not optimizing,
build the CFG and run life analysis. */
if (!optimize)
- find_basic_blocks (first, max_reg_num (), file);
- count_or_remove_death_notes (NULL, 1);
- life_analysis (first, file, PROP_DEATH_NOTES);
+ {
+ find_basic_blocks (first, max_reg_num (), file);
+ count_or_remove_death_notes (NULL, 1);
+ life_analysis (first, file, PROP_DEATH_NOTES);
+ }
mark_dfs_back_edges ();
/* Set up block info for each basic block. */
#include "recog.h"
#include "sched-int.h"
+/* Define when we want to do count REG_DEAD notes before and after scheduling
+ for sanity checking. We can't do that when conditional execution is used,
+ as REG_DEAD exist only for unconditional deaths. */
+
+#if !defined (HAVE_conditional_execution) && defined (ENABLE_CHECKING)
+#define CHECK_DEAD_NOTES 1
+#else
+#define CHECK_DEAD_NOTES 0
+#endif
+
+
#ifdef INSN_SCHEDULING
/* Some accessor macros for h_i_d members only used within this file. */
#define INSN_REF_COUNT(INSN) (h_i_d[INSN_UID (INSN)].ref_count)
block_to_bb = (int *) xmalloc ((n_basic_blocks) * sizeof (int));
containing_rgn = (int *) xmalloc ((n_basic_blocks) * sizeof (int));
- blocks = sbitmap_alloc (n_basic_blocks);
-
/* Compute regions for scheduling. */
if (reload_completed
|| n_basic_blocks == 1
}
}
- deaths_in_region = (int *) xmalloc (sizeof (int) * nr_regions);
- /* Remove all death notes from the subroutine. */
- for (rgn = 0; rgn < nr_regions; rgn++)
+ if (CHECK_DEAD_NOTES)
{
- int b;
+ blocks = sbitmap_alloc (n_basic_blocks);
+ deaths_in_region = (int *) xmalloc (sizeof (int) * nr_regions);
+ /* Remove all death notes from the subroutine. */
+ for (rgn = 0; rgn < nr_regions; rgn++)
+ {
+ int b;
- sbitmap_zero (blocks);
- for (b = RGN_NR_BLOCKS (rgn) - 1; b >= 0; --b)
- SET_BIT (blocks, rgn_bb_table[RGN_BLOCKS (rgn) + b]);
+ sbitmap_zero (blocks);
+ for (b = RGN_NR_BLOCKS (rgn) - 1; b >= 0; --b)
+ SET_BIT (blocks, rgn_bb_table[RGN_BLOCKS (rgn) + b]);
- deaths_in_region[rgn] = count_or_remove_death_notes (blocks, 1);
+ deaths_in_region[rgn] = count_or_remove_death_notes (blocks, 1);
+ }
+ sbitmap_free (blocks);
}
-
- sbitmap_free (blocks);
+ else
+ count_or_remove_death_notes (NULL, 1);
}
/* The one entry point in this file. DUMP_FILE is the dump file for
sbitmap_ones (large_region_blocks);
blocks = sbitmap_alloc (n_basic_blocks);
+ sbitmap_zero (blocks);
+ /* Update life information. For regions consisting of multiple blocks
+ we've possibly done interblock scheduling that affects global liveness.
+ For regions consisting of single blocks we need to do only local
+ liveness. */
for (rgn = 0; rgn < nr_regions; rgn++)
if (RGN_NR_BLOCKS (rgn) > 1)
any_large_regions = 1;
else
{
- sbitmap_zero (blocks);
SET_BIT (blocks, rgn_bb_table[RGN_BLOCKS (rgn)]);
RESET_BIT (large_region_blocks, rgn_bb_table[RGN_BLOCKS (rgn)]);
-
- /* Don't update reg info after reload, since that affects
- regs_ever_live, which should not change after reload. */
- update_life_info (blocks, UPDATE_LIFE_LOCAL,
- (reload_completed ? PROP_DEATH_NOTES
- : PROP_DEATH_NOTES | PROP_REG_INFO));
-
-#ifndef HAVE_conditional_execution
- /* ??? REG_DEAD notes only exist for unconditional deaths. We need
- a count of the conditional plus unconditional deaths for this to
- work out. */
- /* In the single block case, the count of registers that died should
- not have changed during the schedule. */
- if (count_or_remove_death_notes (blocks, 0) != deaths_in_region[rgn])
- abort ();
-#endif
}
+ /* Don't update reg info after reload, since that affects
+ regs_ever_live, which should not change after reload. */
+ update_life_info (blocks, UPDATE_LIFE_LOCAL,
+ (reload_completed ? PROP_DEATH_NOTES
+ : PROP_DEATH_NOTES | PROP_REG_INFO));
if (any_large_regions)
{
update_life_info (large_region_blocks, UPDATE_LIFE_GLOBAL,
PROP_DEATH_NOTES | PROP_REG_INFO);
}
+ if (CHECK_DEAD_NOTES)
+ {
+ /* Remove all death notes from the subroutine. */
+ for (rgn = 0; rgn < nr_regions; rgn++)
+ if (RGN_NR_BLOCKS (rgn) == 1)
+ {
+ int b;
+
+ sbitmap_zero (blocks);
+ SET_BIT (blocks, rgn_bb_table[RGN_BLOCKS (rgn)]);
+
+ if (deaths_in_region[rgn]
+ != count_or_remove_death_notes (blocks, 0))
+ abort ();
+ }
+ free (deaths_in_region);
+ }
+
/* Reposition the prologue and epilogue notes in case we moved the
prologue/epilogue insns. */
if (reload_completed)
sbitmap_free (blocks);
sbitmap_free (large_region_blocks);
-
- free (deaths_in_region);
}
#endif
projects / platform / upstream / gcc.git / commitdiff