/* Instruction scheduling pass.
- Copyright (C) 1992, 93-97, 1998 Free Software Foundation, Inc.
+ Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998,
+ 1999, 2000 Free Software Foundation, Inc.
Contributed by Michael Tiemann (tiemann@cygnus.com) Enhanced by,
and currently maintained by, Jim Wilson (wilson@cygnus.com)
- This file is part of GNU CC.
+This file is part of GNU CC.
- GNU CC 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 version.
+GNU CC 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 version.
- GNU CC is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
+GNU CC is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+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 GNU CC; see the file COPYING. If not, write to the Free
- the Free Software Foundation, 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+You should have received a copy of the GNU General Public License
+along with GNU CC; see the file COPYING. If not, write to the Free
+the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+02111-1307, USA. */
/* Instruction scheduling pass.
This pass must update information that subsequent passes expect to
be correct. Namely: reg_n_refs, reg_n_sets, reg_n_deaths,
- reg_n_calls_crossed, and reg_live_length. Also, basic_block_head,
- basic_block_end.
+ reg_n_calls_crossed, and reg_live_length. Also, BLOCK_HEAD,
+ BLOCK_END.
The information in the line number notes is carefully retained by
this pass. Notes that refer to the starting and ending of
\f
#include "config.h"
#include "system.h"
+#include "toplev.h"
#include "rtl.h"
+#include "tm_p.h"
+#include "hard-reg-set.h"
#include "basic-block.h"
#include "regs.h"
-#include "hard-reg-set.h"
+#include "function.h"
#include "flags.h"
#include "insn-config.h"
#include "insn-attr.h"
#include "except.h"
#include "toplev.h"
+#include "recog.h"
extern char *reg_known_equiv_p;
extern rtx *reg_known_value;
/* target_units bitmask has 1 for each unit in the cpu. It should be
possible to compute this variable from the machine description.
- But currently it is computed by examinning the insn list. Since
+ But currently it is computed by examining the insn list. Since
this is only needed for visualization, it seems an acceptable
solution. (For understanding the mapping of bits to units, see
- definition of function_units[] in "insn-attrtab.c") */
+ definition of function_units[] in "insn-attrtab.c".) */
static int target_units = 0;
#endif
/* sched-verbose controls the amount of debugging output the
- scheduler prints. It is controlled by -fsched-verbose-N:
+ scheduler prints. It is controlled by -fsched-verbose=N:
N>0 and no -DSR : the output is directed to stderr.
N>=10 will direct the printouts to stderr (regardless of -dSR).
N=1: same as -dSR.
static int sched_verbose_param = 0;
static int sched_verbose = 0;
-/* nr_inter/spec counts interblock/speculative motion for the function */
+/* nr_inter/spec counts interblock/speculative motion for the function. */
static int nr_inter, nr_spec;
-/* debugging file. all printouts are sent to dump, which is always set,
+/* Debugging file. All printouts are sent to dump, which is always set,
either to stderr, or to the dump listing file (-dRS). */
static FILE *dump = 0;
/* fix_sched_param() is called from toplev.c upon detection
- of the -fsched-***-N options. */
+ of the -fsched-verbose=N option. */
void
fix_sched_param (param, val)
- char *param, *val;
+ const char *param, *val;
{
if (!strcmp (param, "verbose"))
sched_verbose_param = atoi (val);
warning ("fix_sched_param: unknown param: %s", param);
}
+/* Describe state of dependencies used during sched_analyze phase. */
+struct deps
+{
+ /* The *_insns and *_mems are paired lists. Each pending memory operation
+ will have a pointer to the MEM rtx on one list and a pointer to the
+ containing insn on the other list in the same place in the list. */
+
+ /* We can't use add_dependence like the old code did, because a single insn
+ may have multiple memory accesses, and hence needs to be on the list
+ once for each memory access. Add_dependence won't let you add an insn
+ to a list more than once. */
+
+ /* An INSN_LIST containing all insns with pending read operations. */
+ rtx pending_read_insns;
+
+ /* An EXPR_LIST containing all MEM rtx's which are pending reads. */
+ rtx pending_read_mems;
+
+ /* An INSN_LIST containing all insns with pending write operations. */
+ rtx pending_write_insns;
+
+ /* An EXPR_LIST containing all MEM rtx's which are pending writes. */
+ rtx pending_write_mems;
+
+ /* Indicates the combined length of the two pending lists. We must prevent
+ these lists from ever growing too large since the number of dependencies
+ produced is at least O(N*N), and execution time is at least O(4*N*N), as
+ a function of the length of these pending lists. */
+ int pending_lists_length;
+
+ /* The last insn upon which all memory references must depend.
+ This is an insn which flushed the pending lists, creating a dependency
+ between it and all previously pending memory references. This creates
+ a barrier (or a checkpoint) which no memory reference is allowed to cross.
+
+ This includes all non constant CALL_INSNs. When we do interprocedural
+ alias analysis, this restriction can be relaxed.
+ This may also be an INSN that writes memory if the pending lists grow
+ too large. */
+ rtx last_pending_memory_flush;
+
+ /* The last function call we have seen. All hard regs, and, of course,
+ the last function call, must depend on this. */
+ rtx last_function_call;
+
+ /* Used to keep post-call psuedo/hard reg movements together with
+ the call. */
+ int in_post_call_group_p;
+
+ /* The LOG_LINKS field of this is a list of insns which use a pseudo
+ register that does not already cross a call. We create
+ dependencies between each of those insn and the next call insn,
+ to ensure that they won't cross a call after scheduling is done. */
+ rtx sched_before_next_call;
+
+ /* Element N is the next insn that sets (hard or pseudo) register
+ N within the current basic block; or zero, if there is no
+ such insn. Needed for new registers which may be introduced
+ by splitting insns. */
+ rtx *reg_last_uses;
+ rtx *reg_last_sets;
+ rtx *reg_last_clobbers;
+};
-/* Arrays set up by scheduling for the same respective purposes as
- similar-named arrays set up by flow analysis. We work with these
- arrays during the scheduling pass so we can compare values against
- unscheduled code.
-
- Values of these arrays are copied at the end of this pass into the
- arrays set up by flow analysis. */
-static int *sched_reg_n_calls_crossed;
-static int *sched_reg_live_length;
-static int *sched_reg_basic_block;
-
-/* We need to know the current block number during the post scheduling
- update of live register information so that we can also update
- REG_BASIC_BLOCK if a register changes blocks. */
-static int current_block_num;
-
-/* Element N is the next insn that sets (hard or pseudo) register
- N within the current basic block; or zero, if there is no
- such insn. Needed for new registers which may be introduced
- by splitting insns. */
-static rtx *reg_last_uses;
-static rtx *reg_last_sets;
static regset reg_pending_sets;
+static regset reg_pending_clobbers;
static int reg_pending_sets_all;
-/* Vector indexed by INSN_UID giving the original ordering of the insns. */
-static int *insn_luid;
-#define INSN_LUID(INSN) (insn_luid[INSN_UID (INSN)])
-
-/* Vector indexed by INSN_UID giving each instruction a priority. */
-static int *insn_priority;
-#define INSN_PRIORITY(INSN) (insn_priority[INSN_UID (INSN)])
-
-static short *insn_costs;
-#define INSN_COST(INSN) insn_costs[INSN_UID (INSN)]
-
-/* Vector indexed by INSN_UID giving an encoding of the function units
- used. */
-static short *insn_units;
-#define INSN_UNIT(INSN) insn_units[INSN_UID (INSN)]
-
-/* Vector indexed by INSN_UID giving each instruction a register-weight.
- This weight is an estimation of the insn contribution to registers pressure. */
-static int *insn_reg_weight;
-#define INSN_REG_WEIGHT(INSN) (insn_reg_weight[INSN_UID (INSN)])
-
-/* Vector indexed by INSN_UID giving list of insns which
- depend upon INSN. Unlike LOG_LINKS, it represents forward dependences. */
-static rtx *insn_depend;
-#define INSN_DEPEND(INSN) insn_depend[INSN_UID (INSN)]
-
-/* Vector indexed by INSN_UID. Initialized to the number of incoming
- edges in forward dependence graph (= number of LOG_LINKS). As
- scheduling procedes, dependence counts are decreased. An
- instruction moves to the ready list when its counter is zero. */
-static int *insn_dep_count;
-#define INSN_DEP_COUNT(INSN) (insn_dep_count[INSN_UID (INSN)])
-
-/* Vector indexed by INSN_UID giving an encoding of the blockage range
- function. The unit and the range are encoded. */
-static unsigned int *insn_blockage;
-#define INSN_BLOCKAGE(INSN) insn_blockage[INSN_UID (INSN)]
-#define UNIT_BITS 5
-#define BLOCKAGE_MASK ((1 << BLOCKAGE_BITS) - 1)
-#define ENCODE_BLOCKAGE(U, R) \
-((((U) << UNIT_BITS) << BLOCKAGE_BITS \
- | MIN_BLOCKAGE_COST (R)) << BLOCKAGE_BITS \
- | MAX_BLOCKAGE_COST (R))
-#define UNIT_BLOCKED(B) ((B) >> (2 * BLOCKAGE_BITS))
+/* To speed up the test for duplicate dependency links we keep a record
+ of true dependencies created by add_dependence when the average number
+ of instructions in a basic block is very large.
+
+ Studies have shown that there is typically around 5 instructions between
+ branches for typical C code. So we can make a guess that the average
+ basic block is approximately 5 instructions long; we will choose 100X
+ the average size as a very large basic block.
+
+ Each insn has an associated bitmap for its dependencies. Each bitmap
+ has enough entries to represent a dependency on any other insn in the
+ insn chain. */
+static sbitmap *true_dependency_cache;
+
+/* Indexed by INSN_UID, the collection of all data associated with
+ a single instruction. */
+
+struct haifa_insn_data
+{
+ /* A list of insns which depend on the instruction. Unlike LOG_LINKS,
+ it represents forward dependancies. */
+ rtx depend;
+
+ /* The line number note in effect for each insn. For line number
+ notes, this indicates whether the note may be reused. */
+ rtx line_note;
+
+ /* Logical uid gives the original ordering of the insns. */
+ int luid;
+
+ /* A priority for each insn. */
+ int priority;
+
+ /* The number of incoming edges in the forward dependency graph.
+ As scheduling proceds, counts are decreased. An insn moves to
+ the ready queue when its counter reaches zero. */
+ int dep_count;
+
+ /* An encoding of the blockage range function. Both unit and range
+ are coded. */
+ unsigned int blockage;
+
+ /* Number of instructions referring to this insn. */
+ int ref_count;
+
+ /* The minimum clock tick at which the insn becomes ready. This is
+ used to note timing constraints for the insns in the pending list. */
+ int tick;
+
+ short cost;
+
+ /* An encoding of the function units used. */
+ short units;
+
+ /* This weight is an estimation of the insn's contribution to
+ register pressure. */
+ short reg_weight;
+
+ /* Some insns (e.g. call) are not allowed to move across blocks. */
+ unsigned int cant_move : 1;
+
+ /* Set if there's DEF-USE dependance between some speculatively
+ moved load insn and this one. */
+ unsigned int fed_by_spec_load : 1;
+ unsigned int is_load_insn : 1;
+};
+
+static struct haifa_insn_data *h_i_d;
+
+#define INSN_DEPEND(INSN) (h_i_d[INSN_UID (INSN)].depend)
+#define INSN_LUID(INSN) (h_i_d[INSN_UID (INSN)].luid)
+#define INSN_PRIORITY(INSN) (h_i_d[INSN_UID (INSN)].priority)
+#define INSN_DEP_COUNT(INSN) (h_i_d[INSN_UID (INSN)].dep_count)
+#define INSN_COST(INSN) (h_i_d[INSN_UID (INSN)].cost)
+#define INSN_UNIT(INSN) (h_i_d[INSN_UID (INSN)].units)
+#define INSN_REG_WEIGHT(INSN) (h_i_d[INSN_UID (INSN)].reg_weight)
+
+#define INSN_BLOCKAGE(INSN) (h_i_d[INSN_UID (INSN)].blockage)
+#define UNIT_BITS 5
+#define BLOCKAGE_MASK ((1 << BLOCKAGE_BITS) - 1)
+#define ENCODE_BLOCKAGE(U, R) \
+ (((U) << BLOCKAGE_BITS \
+ | MIN_BLOCKAGE_COST (R)) << BLOCKAGE_BITS \
+ | MAX_BLOCKAGE_COST (R))
+#define UNIT_BLOCKED(B) ((B) >> (2 * BLOCKAGE_BITS))
#define BLOCKAGE_RANGE(B) \
(((((B) >> BLOCKAGE_BITS) & BLOCKAGE_MASK) << (HOST_BITS_PER_INT / 2)) \
| ((B) & BLOCKAGE_MASK))
#define DONE_PRIORITY_P(INSN) (INSN_PRIORITY (INSN) < 0)
#define LOW_PRIORITY_P(INSN) ((INSN_PRIORITY (INSN) & 0x7f000000) == 0)
-/* Vector indexed by INSN_UID giving number of insns referring to this insn. */
-static int *insn_ref_count;
-#define INSN_REF_COUNT(INSN) (insn_ref_count[INSN_UID (INSN)])
-
-/* Vector indexed by INSN_UID giving line-number note in effect for each
- insn. For line-number notes, this indicates whether the note may be
- reused. */
-static rtx *line_note;
-#define LINE_NOTE(INSN) (line_note[INSN_UID (INSN)])
+#define INSN_REF_COUNT(INSN) (h_i_d[INSN_UID (INSN)].ref_count)
+#define LINE_NOTE(INSN) (h_i_d[INSN_UID (INSN)].line_note)
+#define INSN_TICK(INSN) (h_i_d[INSN_UID (INSN)].tick)
+#define CANT_MOVE(insn) (h_i_d[INSN_UID (insn)].cant_move)
+#define FED_BY_SPEC_LOAD(insn) (h_i_d[INSN_UID (insn)].fed_by_spec_load)
+#define IS_LOAD_INSN(insn) (h_i_d[INSN_UID (insn)].is_load_insn)
/* Vector indexed by basic block number giving the starting line-number
for each basic block. */
last element in the list. */
static rtx note_list;
-/* Regsets telling whether a given register is live or dead before the last
- scheduled insn. Must scan the instructions once before scheduling to
- determine what registers are live or dead at the end of the block. */
-static regset bb_live_regs;
-
-/* Regset telling whether a given register is live after the insn currently
- being scheduled. Before processing an insn, this is equal to bb_live_regs
- above. This is used so that we can find registers that are newly born/dead
- after processing an insn. */
-static regset old_live_regs;
-
-/* The chain of REG_DEAD notes. REG_DEAD notes are removed from all insns
- during the initial scan and reused later. If there are not exactly as
- many REG_DEAD notes in the post scheduled code as there were in the
- prescheduled code then we trigger an abort because this indicates a bug. */
-static rtx dead_notes;
-
/* Queues, etc. */
/* An instruction is ready to be scheduled when all insns preceding it
#define NEXT_Q(X) (((X)+1) & (INSN_QUEUE_SIZE-1))
#define NEXT_Q_AFTER(X, C) (((X)+C) & (INSN_QUEUE_SIZE-1))
-/* Vector indexed by INSN_UID giving the minimum clock tick at which
- the insn becomes ready. This is used to note timing constraints for
- insns in the pending list. */
-static int *insn_tick;
-#define INSN_TICK(INSN) (insn_tick[INSN_UID (INSN)])
-
-/* Data structure for keeping track of register information
- during that register's life. */
-
-struct sometimes
- {
- int regno;
- int live_length;
- int calls_crossed;
- };
-
/* Forward declarations. */
-static void add_dependence PROTO ((rtx, rtx, enum reg_note));
-static void remove_dependence PROTO ((rtx, rtx));
-static rtx find_insn_list PROTO ((rtx, rtx));
-static int insn_unit PROTO ((rtx));
-static unsigned int blockage_range PROTO ((int, rtx));
-static void clear_units PROTO ((void));
-static int actual_hazard_this_instance PROTO ((int, int, rtx, int, int));
-static void schedule_unit PROTO ((int, rtx, int));
-static int actual_hazard PROTO ((int, rtx, int, int));
-static int potential_hazard PROTO ((int, rtx, int));
-static int insn_cost PROTO ((rtx, rtx, rtx));
-static int priority PROTO ((rtx));
-static void free_pending_lists PROTO ((void));
-static void add_insn_mem_dependence PROTO ((rtx *, rtx *, rtx, rtx));
-static void flush_pending_lists PROTO ((rtx, int));
-static void sched_analyze_1 PROTO ((rtx, rtx));
-static void sched_analyze_2 PROTO ((rtx, rtx));
-static void sched_analyze_insn PROTO ((rtx, rtx, rtx));
-static void sched_analyze PROTO ((rtx, rtx));
-static void sched_note_set PROTO ((rtx, int));
-static int rank_for_schedule PROTO ((const GENERIC_PTR, const GENERIC_PTR));
-static void swap_sort PROTO ((rtx *, int));
-static void queue_insn PROTO ((rtx, int));
-static int schedule_insn PROTO ((rtx, rtx *, int, int));
-static void create_reg_dead_note PROTO ((rtx, rtx));
-static void attach_deaths PROTO ((rtx, rtx, int));
-static void attach_deaths_insn PROTO ((rtx));
-static int new_sometimes_live PROTO ((struct sometimes *, int, int));
-static void finish_sometimes_live PROTO ((struct sometimes *, int));
-static int schedule_block PROTO ((int, int));
-static rtx regno_use_in PROTO ((int, rtx));
-static void split_hard_reg_notes PROTO ((rtx, rtx, rtx));
-static void new_insn_dead_notes PROTO ((rtx, rtx, rtx, rtx));
-static void update_n_sets PROTO ((rtx, int));
-static void update_flow_info PROTO ((rtx, rtx, rtx, rtx));
-static char *safe_concat PROTO ((char *, char *, char *));
-static int insn_issue_delay PROTO ((rtx));
-static int birthing_insn_p PROTO ((rtx));
-static void adjust_priority PROTO ((rtx));
-static void print_insn_chain PROTO ((rtx));
-
-/* Mapping of insns to their original block prior to scheduling. */
-static int *insn_orig_block;
-#define INSN_BLOCK(insn) (insn_orig_block[INSN_UID (insn)])
-
-/* Some insns (e.g. call) are not allowed to move across blocks. */
-static char *cant_move;
-#define CANT_MOVE(insn) (cant_move[INSN_UID (insn)])
+static void add_dependence PARAMS ((rtx, rtx, enum reg_note));
+static void remove_dependence PARAMS ((rtx, rtx));
+static rtx find_insn_list PARAMS ((rtx, rtx));
+static void set_sched_group_p PARAMS ((rtx));
+static int insn_unit PARAMS ((rtx));
+static unsigned int blockage_range PARAMS ((int, rtx));
+static void clear_units PARAMS ((void));
+static int actual_hazard_this_instance PARAMS ((int, int, rtx, int, int));
+static void schedule_unit PARAMS ((int, rtx, int));
+static int actual_hazard PARAMS ((int, rtx, int, int));
+static int potential_hazard PARAMS ((int, rtx, int));
+static int insn_cost PARAMS ((rtx, rtx, rtx));
+static int priority PARAMS ((rtx));
+static void free_pending_lists PARAMS ((void));
+static void add_insn_mem_dependence PARAMS ((struct deps *, rtx *, rtx *, rtx,
+ rtx));
+static void flush_pending_lists PARAMS ((struct deps *, rtx, int));
+static void sched_analyze_1 PARAMS ((struct deps *, rtx, rtx));
+static void sched_analyze_2 PARAMS ((struct deps *, rtx, rtx));
+static void sched_analyze_insn PARAMS ((struct deps *, rtx, rtx, rtx));
+static void sched_analyze PARAMS ((struct deps *, rtx, rtx));
+static int rank_for_schedule PARAMS ((const PTR, const PTR));
+static void swap_sort PARAMS ((rtx *, int));
+static void queue_insn PARAMS ((rtx, int));
+static int schedule_insn PARAMS ((rtx, rtx *, int, int));
+static void find_insn_reg_weight PARAMS ((int));
+static int schedule_block PARAMS ((int, int));
+static char *safe_concat PARAMS ((char *, char *, const char *));
+static int insn_issue_delay PARAMS ((rtx));
+static void adjust_priority PARAMS ((rtx));
/* Control flow graph edges are kept in circular lists. */
typedef struct
int next_in;
int next_out;
}
-edge;
-static edge *edge_table;
+haifa_edge;
+static haifa_edge *edge_table;
#define NEXT_IN(edge) (edge_table[edge].next_in)
#define NEXT_OUT(edge) (edge_table[edge].next_out)
#define FROM_BLOCK(edge) (edge_table[edge].from_block)
#define TO_BLOCK(edge) (edge_table[edge].to_block)
-/* Number of edges in the control flow graph. (in fact larger than
- that by 1, since edge 0 is unused.) */
+/* Number of edges in the control flow graph. (In fact, larger than
+ that by 1, since edge 0 is unused.) */
static int nr_edges;
-/* Circular list of incoming/outgoing edges of a block */
+/* Circular list of incoming/outgoing edges of a block. */
static int *in_edges;
static int *out_edges;
#define IN_EDGES(block) (in_edges[block])
#define OUT_EDGES(block) (out_edges[block])
-/* List of labels which cannot be deleted, needed for control
- flow graph construction. */
-extern rtx forced_labels;
-static int is_cfg_nonregular PROTO ((void));
-static int build_control_flow PROTO ((int_list_ptr *, int_list_ptr *,
- int *, int *));
-static void new_edge PROTO ((int, int));
+static int is_cfg_nonregular PARAMS ((void));
+static int build_control_flow PARAMS ((struct edge_list *));
+static void new_edge PARAMS ((int, int));
/* A region is the main entity for interblock scheduling: insns
control flow graph edges, in the 'up' direction. */
typedef struct
{
- int rgn_nr_blocks; /* number of blocks in region */
- int rgn_blocks; /* blocks in the region (actually index in rgn_bb_table) */
+ int rgn_nr_blocks; /* Number of blocks in region. */
+ int rgn_blocks; /* cblocks in the region (actually index in rgn_bb_table). */
}
region;
-/* Number of regions in the procedure */
+/* Number of regions in the procedure. */
static int nr_regions;
-/* Table of region descriptions */
+/* Table of region descriptions. */
static region *rgn_table;
-/* Array of lists of regions' blocks */
+/* Array of lists of regions' blocks. */
static int *rgn_bb_table;
/* Topological order of blocks in the region (if b2 is reachable from
- b1, block_to_bb[b2] > block_to_bb[b1]).
- Note: A basic block is always referred to by either block or b,
- while its topological order name (in the region) is refered to by
- bb.
- */
+ b1, block_to_bb[b2] > block_to_bb[b1]). Note: A basic block is
+ always referred to by either block or b, while its topological
+ order name (in the region) is refered to by bb. */
static int *block_to_bb;
/* The number of the region containing a block. */
#define BLOCK_TO_BB(block) (block_to_bb[block])
#define CONTAINING_RGN(block) (containing_rgn[block])
-void debug_regions PROTO ((void));
-static void find_single_block_region PROTO ((void));
-static void find_rgns PROTO ((int_list_ptr *, int_list_ptr *,
- int *, int *, sbitmap *));
-static int too_large PROTO ((int, int *, int *));
+void debug_regions PARAMS ((void));
+static void find_single_block_region PARAMS ((void));
+static void find_rgns PARAMS ((struct edge_list *, sbitmap *));
+static int too_large PARAMS ((int, int *, int *));
-extern void debug_live PROTO ((int, int));
+extern void debug_live PARAMS ((int, int));
/* Blocks of the current region being scheduled. */
static int current_nr_blocks;
static int current_blocks;
-/* The mapping from bb to block */
+/* The mapping from bb to block. */
#define BB_TO_BLOCK(bb) (rgn_bb_table[current_blocks + (bb)])
typedef unsigned HOST_WIDE_INT *bitset;
typedef struct
{
- int *first_member; /* pointer to the list start in bitlst_table. */
- int nr_members; /* the number of members of the bit list. */
+ int *first_member; /* Pointer to the list start in bitlst_table. */
+ int nr_members; /* The number of members of the bit list. */
}
bitlst;
static int bitlst_table_size;
static int *bitlst_table;
-static char bitset_member PROTO ((bitset, int, int));
-static void extract_bitlst PROTO ((bitset, int, bitlst *));
+static char bitset_member PARAMS ((bitset, int, int));
+static void extract_bitlst PARAMS ((bitset, int, int, bitlst *));
-/* target info declarations.
+/* Target info declarations.
The block currently being scheduled is referred to as the "target" block,
while other blocks in the region from which insns can be moved to the
After a speculative motion, live information should be modified in
the 'update' blocks.
- Lists of split and update blocks for each candidate of the current
- target are in array bblst_table */
+ Lists of split and update blocks for each candidate of the current
+ target are in array bblst_table. */
static int *bblst_table, bblst_size, bblst_last;
#define IS_VALID(src) ( candidate_table[src].is_valid )
/* List of edges. */
typedef bitlst edgelst;
-/* target info functions */
-static void split_edges PROTO ((int, int, edgelst *));
-static void compute_trg_info PROTO ((int));
-void debug_candidate PROTO ((int));
-void debug_candidates PROTO ((int));
+/* Target info functions. */
+static void split_edges PARAMS ((int, int, edgelst *));
+static void compute_trg_info PARAMS ((int));
+void debug_candidate PARAMS ((int));
+void debug_candidates PARAMS ((int));
/* Bit-set of bbs, where bit 'i' stands for bb 'i'. */
bb i in the region. */
static bbset *dom;
-/* bb 0 is the only region entry */
+/* bb 0 is the only region entry. */
#define IS_RGN_ENTRY(bb) (!bb)
/* Is bb_src dominated by bb_trg. */
of bb i relative to the region entry. */
static float *prob;
-/* The probability of bb_src, relative to bb_trg. Note, that while the
+/* The probability of bb_src, relative to bb_trg. Note, that while the
'prob[bb]' is a float in [0, 1], this macro returns an integer
in [0, 100]. */
#define GET_SRC_PROB(bb_src, bb_trg) ((int) (100.0 * (prob[bb_src] / \
/* Number of edges in the region. */
static int rgn_nr_edges;
-/* Array of size rgn_nr_edges. */
+/* Array of size rgn_nr_edges. */
static int *rgn_edges;
-/* Number of words in an edgeset. */
+/* Number of words in an edgeset. */
static int edgeset_size;
+/* Number of bits in an edgeset. */
+static int edgeset_bitsize;
+
/* Mapping from each edge in the graph to its number in the rgn. */
static int *edge_to_bit;
#define EDGE_TO_BIT(edge) (edge_to_bit[edge])
/* For every bb, a set of its ancestor edges. */
static edgeset *ancestor_edges;
-static void compute_dom_prob_ps PROTO ((int));
+static void compute_dom_prob_ps PARAMS ((int));
#define ABS_VALUE(x) (((x)<0)?(-(x)):(x))
-#define INSN_PROBABILITY(INSN) (SRC_PROB (BLOCK_TO_BB (INSN_BLOCK (INSN))))
-#define IS_SPECULATIVE_INSN(INSN) (IS_SPECULATIVE (BLOCK_TO_BB (INSN_BLOCK (INSN))))
-#define INSN_BB(INSN) (BLOCK_TO_BB (INSN_BLOCK (INSN)))
+#define INSN_PROBABILITY(INSN) (SRC_PROB (BLOCK_TO_BB (BLOCK_NUM (INSN))))
+#define IS_SPECULATIVE_INSN(INSN) (IS_SPECULATIVE (BLOCK_TO_BB (BLOCK_NUM (INSN))))
+#define INSN_BB(INSN) (BLOCK_TO_BB (BLOCK_NUM (INSN)))
-/* parameters affecting the decision of rank_for_schedule() */
+/* Parameters affecting the decision of rank_for_schedule(). */
#define MIN_DIFF_PRIORITY 2
#define MIN_PROBABILITY 40
#define MIN_PROB_DIFF 10
-/* speculative scheduling functions */
-static int check_live_1 PROTO ((int, rtx));
-static void update_live_1 PROTO ((int, rtx));
-static int check_live PROTO ((rtx, int));
-static void update_live PROTO ((rtx, int));
-static void set_spec_fed PROTO ((rtx));
-static int is_pfree PROTO ((rtx, int, int));
-static int find_conditional_protection PROTO ((rtx, int));
-static int is_conditionally_protected PROTO ((rtx, int, int));
-static int may_trap_exp PROTO ((rtx, int));
-static int haifa_classify_insn PROTO ((rtx));
-static int is_prisky PROTO ((rtx, int, int));
-static int is_exception_free PROTO ((rtx, int, int));
-
-static char find_insn_mem_list PROTO ((rtx, rtx, rtx, rtx));
-static void compute_block_forward_dependences PROTO ((int));
-static void init_rgn_data_dependences PROTO ((int));
-static void add_branch_dependences PROTO ((rtx, rtx));
-static void compute_block_backward_dependences PROTO ((int));
-void debug_dependencies PROTO ((void));
+/* Speculative scheduling functions. */
+static int check_live_1 PARAMS ((int, rtx));
+static void update_live_1 PARAMS ((int, rtx));
+static int check_live PARAMS ((rtx, int));
+static void update_live PARAMS ((rtx, int));
+static void set_spec_fed PARAMS ((rtx));
+static int is_pfree PARAMS ((rtx, int, int));
+static int find_conditional_protection PARAMS ((rtx, int));
+static int is_conditionally_protected PARAMS ((rtx, int, int));
+static int may_trap_exp PARAMS ((rtx, int));
+static int haifa_classify_insn PARAMS ((rtx));
+static int is_prisky PARAMS ((rtx, int, int));
+static int is_exception_free PARAMS ((rtx, int, int));
+
+static char find_insn_mem_list PARAMS ((rtx, rtx, rtx, rtx));
+static void compute_block_forward_dependences PARAMS ((int));
+static void add_branch_dependences PARAMS ((rtx, rtx));
+static void compute_block_backward_dependences PARAMS ((int));
+void debug_dependencies PARAMS ((void));
/* Notes handling mechanism:
=========================
unlink_other_notes ()). After scheduling the block, these notes are
inserted at the beginning of the block (in schedule_block()). */
-static rtx unlink_other_notes PROTO ((rtx, rtx));
-static rtx unlink_line_notes PROTO ((rtx, rtx));
-static void rm_line_notes PROTO ((int));
-static void save_line_notes PROTO ((int));
-static void restore_line_notes PROTO ((int));
-static void rm_redundant_line_notes PROTO ((void));
-static void rm_other_notes PROTO ((rtx, rtx));
-static rtx reemit_notes PROTO ((rtx, rtx));
-
-static void get_block_head_tail PROTO ((int, rtx *, rtx *));
-
-static void find_pre_sched_live PROTO ((int));
-static void find_post_sched_live PROTO ((int));
-static void update_reg_usage PROTO ((void));
-static int queue_to_ready PROTO ((rtx [], int));
-
-static void debug_ready_list PROTO ((rtx[], int));
-static void init_target_units PROTO ((void));
-static void insn_print_units PROTO ((rtx));
-static int get_visual_tbl_length PROTO ((void));
-static void init_block_visualization PROTO ((void));
-static void print_block_visualization PROTO ((int, char *));
-static void visualize_scheduled_insns PROTO ((int, int));
-static void visualize_no_unit PROTO ((rtx));
-static void visualize_stall_cycles PROTO ((int, int));
-static void print_exp PROTO ((char *, rtx, int));
-static void print_value PROTO ((char *, rtx, int));
-static void print_pattern PROTO ((char *, rtx, int));
-static void print_insn PROTO ((char *, rtx, int));
-void debug_reg_vector PROTO ((regset));
-
-static rtx move_insn1 PROTO ((rtx, rtx));
-static rtx move_insn PROTO ((rtx, rtx));
-static rtx group_leader PROTO ((rtx));
-static int set_priorities PROTO ((int));
-static void init_rtx_vector PROTO ((rtx **, rtx *, int, int));
-static void schedule_region PROTO ((int));
-static void split_block_insns PROTO ((int));
+static rtx unlink_other_notes PARAMS ((rtx, rtx));
+static rtx unlink_line_notes PARAMS ((rtx, rtx));
+static void rm_line_notes PARAMS ((int));
+static void save_line_notes PARAMS ((int));
+static void restore_line_notes PARAMS ((int));
+static void rm_redundant_line_notes PARAMS ((void));
+static void rm_other_notes PARAMS ((rtx, rtx));
+static rtx reemit_notes PARAMS ((rtx, rtx));
+
+static void get_block_head_tail PARAMS ((int, rtx *, rtx *));
+static void get_bb_head_tail PARAMS ((int, rtx *, rtx *));
+
+static int queue_to_ready PARAMS ((rtx [], int));
+
+static void debug_ready_list PARAMS ((rtx[], int));
+static void init_target_units PARAMS ((void));
+static void insn_print_units PARAMS ((rtx));
+static int get_visual_tbl_length PARAMS ((void));
+static void init_block_visualization PARAMS ((void));
+static void print_block_visualization PARAMS ((int, const char *));
+static void visualize_scheduled_insns PARAMS ((int, int));
+static void visualize_no_unit PARAMS ((rtx));
+static void visualize_stall_cycles PARAMS ((int, int));
+static void print_exp PARAMS ((char *, rtx, int));
+static void print_value PARAMS ((char *, rtx, int));
+static void print_pattern PARAMS ((char *, rtx, int));
+static void print_insn PARAMS ((char *, rtx, int));
+void debug_reg_vector PARAMS ((regset));
+
+static rtx move_insn1 PARAMS ((rtx, rtx));
+static rtx move_insn PARAMS ((rtx, rtx));
+static rtx group_leader PARAMS ((rtx));
+static int set_priorities PARAMS ((int));
+static void init_deps PARAMS ((struct deps *));
+static void schedule_region PARAMS ((int));
+static void propagate_deps PARAMS ((int, struct deps *, int));
#endif /* INSN_SCHEDULING */
\f
#define SIZE_FOR_MODE(X) (GET_MODE_SIZE (GET_MODE (X)))
-/* Helper functions for instruction scheduling. */
-
-/* An INSN_LIST containing all INSN_LISTs allocated but currently unused. */
-static rtx unused_insn_list;
-
-/* An EXPR_LIST containing all EXPR_LISTs allocated but currently unused. */
-static rtx unused_expr_list;
-
-static void free_list PROTO ((rtx *, rtx *));
-static rtx alloc_INSN_LIST PROTO ((rtx, rtx));
-static rtx alloc_EXPR_LIST PROTO ((int, rtx, rtx));
-
-static void
-free_list (listp, unused_listp)
- rtx *listp, *unused_listp;
-{
- register rtx link, prev_link;
-
- if (*listp == 0)
- return;
-
- prev_link = *listp;
- link = XEXP (prev_link, 1);
-
- while (link)
- {
- prev_link = link;
- link = XEXP (link, 1);
- }
-
- XEXP (prev_link, 1) = *unused_listp;
- *unused_listp = *listp;
- *listp = 0;
-}
-
-static rtx
-alloc_INSN_LIST (val, next)
- rtx val, next;
-{
- rtx r;
-
- if (unused_insn_list)
- {
- r = unused_insn_list;
- unused_insn_list = XEXP (r, 1);
- XEXP (r, 0) = val;
- XEXP (r, 1) = next;
- PUT_REG_NOTE_KIND (r, VOIDmode);
- }
- else
- r = gen_rtx_INSN_LIST (VOIDmode, val, next);
-
- return r;
-}
-
-static rtx
-alloc_EXPR_LIST (kind, val, next)
- int kind;
- rtx val, next;
-{
- rtx r;
-
- if (unused_insn_list)
- {
- r = unused_insn_list;
- unused_insn_list = XEXP (r, 1);
- XEXP (r, 0) = val;
- XEXP (r, 1) = next;
- PUT_REG_NOTE_KIND (r, kind);
- }
- else
- r = gen_rtx_EXPR_LIST (kind, val, next);
-
- return r;
-}
-
/* Add ELEM wrapped in an INSN_LIST with reg note kind DEP_TYPE to the
LOG_LINKS of INSN, if not already there. DEP_TYPE indicates the type
of dependence that this link represents. */
if (insn == elem)
return;
+ /* We can get a dependency on deleted insns due to optimizations in
+ the register allocation and reloading or due to splitting. Any
+ such dependency is useless and can be ignored. */
+ if (GET_CODE (elem) == NOTE)
+ return;
+
/* If elem is part of a sequence that must be scheduled together, then
make the dependence point to the last insn of the sequence.
When HAVE_cc0, it is possible for NOTEs to exist between users and
setters of the condition codes, so we must skip past notes here.
Otherwise, NOTEs are impossible here. */
-
- next = NEXT_INSN (elem);
-
-#ifdef HAVE_cc0
- while (next && GET_CODE (next) == NOTE)
- next = NEXT_INSN (next);
-#endif
-
+ next = next_nonnote_insn (elem);
if (next && SCHED_GROUP_P (next)
&& GET_CODE (next) != CODE_LABEL)
{
/* Notes will never intervene here though, so don't bother checking
for them. */
+ /* Hah! Wrong. */
/* We must reject CODE_LABELs, so that we don't get confused by one
that has LABEL_PRESERVE_P set, which is represented by the same
bit in the rtl as SCHED_GROUP_P. A CODE_LABEL can never be
SCHED_GROUP_P. */
- while (NEXT_INSN (next) && SCHED_GROUP_P (NEXT_INSN (next))
- && GET_CODE (NEXT_INSN (next)) != CODE_LABEL)
- next = NEXT_INSN (next);
+
+ rtx nnext;
+ while ((nnext = next_nonnote_insn (next)) != NULL
+ && SCHED_GROUP_P (nnext)
+ && GET_CODE (nnext) != CODE_LABEL)
+ next = nnext;
/* Again, don't depend an insn on itself. */
if (insn == next)
&& (INSN_BB (elem) != INSN_BB (insn)))
return;
+ /* If we already have a true dependency for ELEM, then we do not
+ need to do anything. Avoiding the list walk below can cut
+ compile times dramatically for some code. */
+ if (true_dependency_cache
+ && TEST_BIT (true_dependency_cache[INSN_LUID (insn)], INSN_LUID (elem)))
+ return;
#endif
/* Check that we don't already have this dependence. */
one, then change the existing dependence to this type. */
if ((int) dep_type < (int) REG_NOTE_KIND (link))
PUT_REG_NOTE_KIND (link, dep_type);
+
+#ifdef INSN_SCHEDULING
+ /* If we are adding a true dependency to INSN's LOG_LINKs, then
+ note that in the bitmap cache of true dependency information. */
+ if ((int)dep_type == 0 && true_dependency_cache)
+ SET_BIT (true_dependency_cache[INSN_LUID (insn)], INSN_LUID (elem));
+#endif
return;
}
/* Might want to check one level of transitivity to save conses. */
/* Insn dependency, not data dependency. */
PUT_REG_NOTE_KIND (link, dep_type);
+
+#ifdef INSN_SCHEDULING
+ /* If we are adding a true dependency to INSN's LOG_LINKs, then
+ note that in the bitmap cache of true dependency information. */
+ if ((int)dep_type == 0 && true_dependency_cache)
+ SET_BIT (true_dependency_cache[INSN_LUID (insn)], INSN_LUID (elem));
+#endif
}
/* Remove ELEM wrapped in an INSN_LIST from the LOG_LINKS
else
LOG_LINKS (insn) = next;
- XEXP (link, 1) = unused_insn_list;
- unused_insn_list = link;
+#ifdef INSN_SCHEDULING
+ /* If we are removing a true dependency from the LOG_LINKS list,
+ make sure to remove it from the cache too. */
+ if (REG_NOTE_KIND (link) == 0 && true_dependency_cache)
+ RESET_BIT (true_dependency_cache[INSN_LUID (insn)],
+ INSN_LUID (elem));
+#endif
+
+ free_INSN_LIST_node (link);
found = 1;
}
abort ();
return;
}
+
+/* Return the INSN_LIST containing INSN in LIST, or NULL
+ if LIST does not contain INSN. */
+
+static inline rtx
+find_insn_list (insn, list)
+ rtx insn;
+ rtx list;
+{
+ while (list)
+ {
+ if (XEXP (list, 0) == insn)
+ return list;
+ list = XEXP (list, 1);
+ }
+ return 0;
+}
+
+/* Set SCHED_GROUP_P and care for the rest of the bookkeeping that
+ goes along with that. */
+
+static void
+set_sched_group_p (insn)
+ rtx insn;
+{
+ rtx link, prev;
+
+ SCHED_GROUP_P (insn) = 1;
+
+ /* There may be a note before this insn now, but all notes will
+ be removed before we actually try to schedule the insns, so
+ it won't cause a problem later. We must avoid it here though. */
+ prev = prev_nonnote_insn (insn);
+
+ /* Make a copy of all dependencies on the immediately previous insn,
+ and add to this insn. This is so that all the dependencies will
+ apply to the group. Remove an explicit dependence on this insn
+ as SCHED_GROUP_P now represents it. */
+
+ if (find_insn_list (prev, LOG_LINKS (insn)))
+ remove_dependence (insn, prev);
+
+ for (link = LOG_LINKS (prev); link; link = XEXP (link, 1))
+ add_dependence (insn, XEXP (link, 0), REG_NOTE_KIND (link));
+}
\f
#ifndef INSN_SCHEDULING
void
schedule_insns (dump_file)
- FILE *dump_file;
+ FILE *dump_file ATTRIBUTE_UNUSED;
{
}
#else
/* Computation of memory dependencies. */
-/* The *_insns and *_mems are paired lists. Each pending memory operation
- will have a pointer to the MEM rtx on one list and a pointer to the
- containing insn on the other list in the same place in the list. */
-
-/* We can't use add_dependence like the old code did, because a single insn
- may have multiple memory accesses, and hence needs to be on the list
- once for each memory access. Add_dependence won't let you add an insn
- to a list more than once. */
-
-/* An INSN_LIST containing all insns with pending read operations. */
-static rtx pending_read_insns;
-
-/* An EXPR_LIST containing all MEM rtx's which are pending reads. */
-static rtx pending_read_mems;
-
-/* An INSN_LIST containing all insns with pending write operations. */
-static rtx pending_write_insns;
-
-/* An EXPR_LIST containing all MEM rtx's which are pending writes. */
-static rtx pending_write_mems;
-
-/* Indicates the combined length of the two pending lists. We must prevent
- these lists from ever growing too large since the number of dependencies
- produced is at least O(N*N), and execution time is at least O(4*N*N), as
- a function of the length of these pending lists. */
-
-static int pending_lists_length;
-
-/* The last insn upon which all memory references must depend.
- This is an insn which flushed the pending lists, creating a dependency
- between it and all previously pending memory references. This creates
- a barrier (or a checkpoint) which no memory reference is allowed to cross.
-
- This includes all non constant CALL_INSNs. When we do interprocedural
- alias analysis, this restriction can be relaxed.
- This may also be an INSN that writes memory if the pending lists grow
- too large. */
-
-static rtx last_pending_memory_flush;
-
-/* The last function call we have seen. All hard regs, and, of course,
- the last function call, must depend on this. */
-
-static rtx last_function_call;
-
-/* The LOG_LINKS field of this is a list of insns which use a pseudo register
- that does not already cross a call. We create dependencies between each
- of those insn and the next call insn, to ensure that they won't cross a call
- after scheduling is done. */
+/* Data structures for the computation of data dependences in a regions. We
+ keep one mem_deps structure for every basic block. Before analyzing the
+ data dependences for a bb, its variables are initialized as a function of
+ the variables of its predecessors. When the analysis for a bb completes,
+ we save the contents to the corresponding bb_mem_deps[bb] variable. */
-static rtx sched_before_next_call;
+static struct deps *bb_deps;
/* Pointer to the last instruction scheduled. Used by rank_for_schedule,
so that insns independent of the last scheduled insn will be preferred
static rtx last_scheduled_insn;
-/* Data structures for the computation of data dependences in a regions. We
- keep one copy of each of the declared above variables for each bb in the
- region. Before analyzing the data dependences for a bb, its variables
- are initialized as a function of the variables of its predecessors. When
- the analysis for a bb completes, we save the contents of each variable X
- to a corresponding bb_X[bb] variable. For example, pending_read_insns is
- copied to bb_pending_read_insns[bb]. Another change is that few
- variables are now a list of insns rather than a single insn:
- last_pending_memory_flash, last_function_call, reg_last_sets. The
- manipulation of these variables was changed appropriately. */
-
-static rtx **bb_reg_last_uses;
-static rtx **bb_reg_last_sets;
-
-static rtx *bb_pending_read_insns;
-static rtx *bb_pending_read_mems;
-static rtx *bb_pending_write_insns;
-static rtx *bb_pending_write_mems;
-static int *bb_pending_lists_length;
-
-static rtx *bb_last_pending_memory_flush;
-static rtx *bb_last_function_call;
-static rtx *bb_sched_before_next_call;
-
-/* functions for construction of the control flow graph. */
+/* Functions for construction of the control flow graph. */
/* Return 1 if control flow graph should not be constructed, 0 otherwise.
/* If we have a label that could be the target of a nonlocal goto, then
the cfg is not well structured. */
- if (nonlocal_label_rtx_list () != NULL)
+ if (nonlocal_goto_handler_labels)
return 1;
/* If we have any forced labels, then the cfg is not well structured. */
/* If we have non-jumping insns which refer to labels, then we consider
the cfg not well structured. */
- /* check for labels referred to other thn by jumps */
+ /* Check for labels referred to other thn by jumps. */
for (b = 0; b < n_basic_blocks; b++)
- for (insn = basic_block_head[b];; insn = NEXT_INSN (insn))
+ for (insn = BLOCK_HEAD (b);; insn = NEXT_INSN (insn))
{
code = GET_CODE (insn);
if (GET_RTX_CLASS (code) == 'i')
return 1;
}
- if (insn == basic_block_end[b])
+ if (insn == BLOCK_END (b))
break;
}
prevent cross block scheduling. */
static int
-build_control_flow (s_preds, s_succs, num_preds, num_succs)
- int_list_ptr *s_preds;
- int_list_ptr *s_succs;
- int *num_preds;
- int *num_succs;
+build_control_flow (edge_list)
+ struct edge_list *edge_list;
{
- int i;
- int_list_ptr succ;
- int unreachable;
+ int i, unreachable, num_edges;
- /* Count the number of edges in the cfg. */
- nr_edges = 0;
+ /* This already accounts for entry/exit edges. */
+ num_edges = NUM_EDGES (edge_list);
+
+ /* Unreachable loops with more than one basic block are detected
+ during the DFS traversal in find_rgns.
+
+ Unreachable loops with a single block are detected here. This
+ test is redundant with the one in find_rgns, but it's much
+ cheaper to go ahead and catch the trivial case here. */
unreachable = 0;
for (i = 0; i < n_basic_blocks; i++)
{
- nr_edges += num_succs[i];
+ basic_block b = BASIC_BLOCK (i);
- /* Unreachable loops with more than one basic block are detected
- during the DFS traversal in find_rgns.
-
- Unreachable loops with a single block are detected here. This
- test is redundant with the one in find_rgns, but it's much
- cheaper to go ahead and catch the trivial case here. */
- if (num_preds[i] == 0
- || (num_preds[i] == 1 && INT_LIST_VAL (s_preds[i]) == i))
+ if (b->pred == NULL
+ || (b->pred->src == b
+ && b->pred->pred_next == NULL))
unreachable = 1;
}
- /* Account for entry/exit edges. */
- nr_edges += 2;
-
- in_edges = (int *) xmalloc (n_basic_blocks * sizeof (int));
- out_edges = (int *) xmalloc (n_basic_blocks * sizeof (int));
- bzero ((char *) in_edges, n_basic_blocks * sizeof (int));
- bzero ((char *) out_edges, n_basic_blocks * sizeof (int));
-
- edge_table = (edge *) xmalloc ((nr_edges) * sizeof (edge));
- bzero ((char *) edge_table, ((nr_edges) * sizeof (edge)));
+ /* ??? We can kill these soon. */
+ in_edges = (int *) xcalloc (n_basic_blocks, sizeof (int));
+ out_edges = (int *) xcalloc (n_basic_blocks, sizeof (int));
+ edge_table = (haifa_edge *) xcalloc (num_edges, sizeof (haifa_edge));
nr_edges = 0;
- for (i = 0; i < n_basic_blocks; i++)
- for (succ = s_succs[i]; succ; succ = succ->next)
- {
- if (INT_LIST_VAL (succ) != EXIT_BLOCK)
- new_edge (i, INT_LIST_VAL (succ));
- }
+ for (i = 0; i < num_edges; i++)
+ {
+ edge e = INDEX_EDGE (edge_list, i);
+
+ if (e->dest != EXIT_BLOCK_PTR
+ && e->src != ENTRY_BLOCK_PTR)
+ new_edge (e->src->index, e->dest->index);
+ }
- /* increment by 1, since edge 0 is unused. */
+ /* Increment by 1, since edge 0 is unused. */
nr_edges++;
return unreachable;
int e, next_edge;
int curr_edge, fst_edge;
- /* check for duplicates */
+ /* Check for duplicates. */
fst_edge = curr_edge = OUT_EDGES (source);
while (curr_edge)
{
/* BITSET macros for operations on the control flow graph. */
-/* Compute bitwise union of two bitsets. */
+/* Compute bitwise union of two bitsets. */
#define BITSET_UNION(set1, set2, len) \
do { register bitset tp = set1, sp = set2; \
register int i; \
for (i = 0; i < len; i++) \
*(tp++) |= *(sp++); } while (0)
-/* Compute bitwise intersection of two bitsets. */
+/* Compute bitwise intersection of two bitsets. */
#define BITSET_INTER(set1, set2, len) \
do { register bitset tp = set1, sp = set2; \
register int i; \
for (i = 0; i < len; i++) \
*(tp++) &= *(sp++); } while (0)
-/* Compute bitwise difference of two bitsets. */
+/* Compute bitwise difference of two bitsets. */
#define BITSET_DIFFER(set1, set2, len) \
do { register bitset tp = set1, sp = set2; \
register int i; \
for (i = 0; i < len; i++) \
*(tp++) &= ~*(sp++); } while (0)
-/* Inverts every bit of bitset 'set' */
+/* Inverts every bit of bitset 'set'. */
#define BITSET_INVERT(set, len) \
do { register bitset tmpset = set; \
register int i; \
}
-/* Check if the index'th bit in bitset set is on. */
+/* Check if the index'th bit in bitset set is on. */
static char
bitset_member (set, index, len)
/* Translate a bit-set SET to a list BL of the bit-set members. */
static void
-extract_bitlst (set, len, bl)
+extract_bitlst (set, len, bitlen, bl)
bitset set;
int len;
+ int bitlen;
bitlst *bl;
{
int i, j, offset;
unsigned HOST_WIDE_INT word;
- /* bblst table space is reused in each call to extract_bitlst */
+ /* bblst table space is reused in each call to extract_bitlst. */
bitlst_table_last = 0;
bl->first_member = &bitlst_table[bitlst_table_last];
bl->nr_members = 0;
+ /* Iterate over each word in the bitset. */
for (i = 0; i < len; i++)
{
word = set[i];
offset = i * HOST_BITS_PER_WIDE_INT;
- for (j = 0; word; j++)
+
+ /* Iterate over each bit in the word, but do not
+ go beyond the end of the defined bits. */
+ for (j = 0; offset < bitlen && word; j++)
{
if (word & 1)
{
}
-/* functions for the construction of regions */
+/* Functions for the construction of regions. */
/* Print the regions, for debugging purposes. Callable from debugger. */
int block, *num_bbs, *num_insns;
{
(*num_bbs)++;
- (*num_insns) += (INSN_LUID (basic_block_end[block]) -
- INSN_LUID (basic_block_head[block]));
+ (*num_insns) += (INSN_LUID (BLOCK_END (block)) -
+ INSN_LUID (BLOCK_HEAD (block)));
if ((*num_bbs > MAX_RGN_BLOCKS) || (*num_insns > MAX_RGN_INSNS))
return 1;
else
of edge tables. That would simplify it somewhat. */
static void
-find_rgns (s_preds, s_succs, num_preds, num_succs, dom)
- int_list_ptr *s_preds;
- int_list_ptr *s_succs;
- int *num_preds;
- int *num_succs;
+find_rgns (edge_list, dom)
+ struct edge_list *edge_list;
sbitmap *dom;
{
- int *max_hdr, *dfs_nr, *stack, *queue, *degree;
+ int *max_hdr, *dfs_nr, *stack, *degree;
char no_loops = 1;
int node, child, loop_head, i, head, tail;
int count = 0, sp, idx = 0, current_edge = out_edges[0];
/* Note if a block is in the block queue. */
sbitmap in_stack;
+ int num_edges = NUM_EDGES (edge_list);
+
/* Perform a DFS traversal of the cfg. Identify loop headers, inner loops
and a mapping from block to its loop header (if the block is contained
in a loop, else -1).
STACK, SP and DFS_NR are only used during the first traversal. */
/* Allocate and initialize variables for the first traversal. */
- max_hdr = (int *) alloca (n_basic_blocks * sizeof (int));
- dfs_nr = (int *) alloca (n_basic_blocks * sizeof (int));
- bzero ((char *) dfs_nr, n_basic_blocks * sizeof (int));
- stack = (int *) alloca (nr_edges * sizeof (int));
+ max_hdr = (int *) xmalloc (n_basic_blocks * sizeof (int));
+ dfs_nr = (int *) xcalloc (n_basic_blocks, sizeof (int));
+ stack = (int *) xmalloc (nr_edges * sizeof (int));
inner = sbitmap_alloc (n_basic_blocks);
sbitmap_ones (inner);
stack[++sp] = current_edge;
SET_BIT (passed, current_edge);
current_edge = OUT_EDGES (child);
+
+ /* This is temporary until haifa is converted to use rth's new
+ cfg routines which have true entry/exit blocks and the
+ appropriate edges from/to those blocks.
+
+ Generally we update dfs_nr for a node when we process its
+ out edge. However, if the node has no out edge then we will
+ not set dfs_nr for that node. This can confuse the scheduler
+ into thinking that we have unreachable blocks, which in turn
+ disables cross block scheduling.
+
+ So, if we have a node with no out edges, go ahead and mark it
+ as reachable now. */
+ if (current_edge == 0)
+ dfs_nr[child] = ++count;
}
/* Another check for unreachable blocks. The earlier test in
to hold degree counts. */
degree = dfs_nr;
- /* Compute the in-degree of every block in the graph */
for (i = 0; i < n_basic_blocks; i++)
- degree[i] = num_preds[i];
+ degree[i] = 0;
+ for (i = 0; i < num_edges; i++)
+ {
+ edge e = INDEX_EDGE (edge_list, i);
+
+ if (e->dest != EXIT_BLOCK_PTR)
+ degree[e->dest->index]++;
+ }
/* Do not perform region scheduling if there are any unreachable
blocks. */
if (!unreachable)
{
+ int *queue;
+
if (no_loops)
SET_BIT (header, 0);
/* Second travsersal:find reducible inner loops and topologically sort
block of each region. */
- queue = (int *) alloca (n_basic_blocks * sizeof (int));
+ queue = (int *) xmalloc (n_basic_blocks * sizeof (int));
/* Find blocks which are inner loop headers. We still have non-reducible
loops to consider at this point. */
{
if (TEST_BIT (header, i) && TEST_BIT (inner, i))
{
- int_list_ptr ps;
+ edge e;
int j;
/* Now check that the loop is reducible. We do this separate
from finding inner loops so that we do not find a reducible
- loop which contains an inner non-reducible loop.
+ loop which contains an inner non-reducible loop.
- A simple way to find reducible/natrual loops is to verify
+ A simple way to find reducible/natural loops is to verify
that each block in the loop is dominated by the loop
header.
}
}
- /* If we exited the loop early, then I is the header of a non
- reducible loop and we should quit processing it now. */
+ /* If we exited the loop early, then I is the header of
+ a non-reducible loop and we should quit processing it
+ now. */
if (j != n_basic_blocks)
continue;
/* Decrease degree of all I's successors for topological
ordering. */
- for (ps = s_succs[i]; ps; ps = ps->next)
- if (INT_LIST_VAL (ps) != EXIT_BLOCK
- && INT_LIST_VAL (ps) != ENTRY_BLOCK)
- --degree[INT_LIST_VAL(ps)];
+ for (e = BASIC_BLOCK (i)->succ; e; e = e->succ_next)
+ if (e->dest != EXIT_BLOCK_PTR)
+ --degree[e->dest->index];
/* Estimate # insns, and count # blocks in the region. */
num_bbs = 1;
- num_insns = (INSN_LUID (basic_block_end[i])
- - INSN_LUID (basic_block_head[i]));
+ num_insns = (INSN_LUID (BLOCK_END (i))
+ - INSN_LUID (BLOCK_HEAD (i)));
- /* Find all loop latches (blocks which back edges to the loop
+ /* Find all loop latches (blocks with back edges to the loop
header) or all the leaf blocks in the cfg has no loops.
Place those blocks into the queue. */
for (j = 0; j < n_basic_blocks; j++)
/* Leaf nodes have only a single successor which must
be EXIT_BLOCK. */
- if (num_succs[j] == 1
- && INT_LIST_VAL (s_succs[j]) == EXIT_BLOCK)
+ if (BASIC_BLOCK (j)->succ
+ && BASIC_BLOCK (j)->succ->dest == EXIT_BLOCK_PTR
+ && BASIC_BLOCK (j)->succ->succ_next == NULL)
{
queue[++tail] = j;
SET_BIT (in_queue, j);
}
else
{
- int_list_ptr ps;
+ edge e;
- for (ps = s_preds[i]; ps; ps = ps->next)
+ for (e = BASIC_BLOCK (i)->pred; e; e = e->pred_next)
{
- node = INT_LIST_VAL (ps);
-
- if (node == ENTRY_BLOCK || node == EXIT_BLOCK)
+ if (e->src == ENTRY_BLOCK_PTR)
continue;
-
+
+ node = e->src->index;
+
if (max_hdr[node] == loop_head && node != i)
{
/* This is a loop latch. */
while (head < tail && !too_large_failure)
{
- int_list_ptr ps;
+ edge e;
child = queue[++head];
- for (ps = s_preds[child]; ps; ps = ps->next)
+ for (e = BASIC_BLOCK (child)->pred; e; e = e->pred_next)
{
- node = INT_LIST_VAL (ps);
+ node = e->src->index;
/* See discussion above about nodes not marked as in
this loop during the initial DFS traversal. */
- if (node == ENTRY_BLOCK || node == EXIT_BLOCK
+ if (e->src == ENTRY_BLOCK_PTR
|| max_hdr[node] != loop_head)
{
tail = -1;
CONTAINING_RGN (i) = nr_regions;
BLOCK_TO_BB (i) = count = 0;
- /* Remove blocks from queue[] when their in degree becomes
- zero. Repeat until no blocks are left on the list. This
- produces a topological list of blocks in the region. */
+ /* Remove blocks from queue[] when their in degree
+ becomes zero. Repeat until no blocks are left on the
+ list. This produces a topological list of blocks in
+ the region. */
while (tail >= 0)
{
- int_list_ptr ps;
-
if (head < 0)
head = tail;
child = queue[head];
if (degree[child] == 0)
{
+ edge e;
+
degree[child] = -1;
rgn_bb_table[idx++] = child;
BLOCK_TO_BB (child) = ++count;
CONTAINING_RGN (child) = nr_regions;
queue[head] = queue[tail--];
- for (ps = s_succs[child]; ps; ps = ps->next)
- if (INT_LIST_VAL (ps) != ENTRY_BLOCK
- && INT_LIST_VAL (ps) != EXIT_BLOCK)
- --degree[INT_LIST_VAL (ps)];
+ for (e = BASIC_BLOCK (child)->succ;
+ e;
+ e = e->succ_next)
+ if (e->dest != EXIT_BLOCK_PTR)
+ --degree[e->dest->index];
}
else
--head;
}
}
}
+ free (queue);
}
/* Any block that did not end up in a region is placed into a region
BLOCK_TO_BB (i) = 0;
}
+ free (max_hdr);
+ free (dfs_nr);
+ free (stack);
free (passed);
free (header);
free (inner);
}
-/* functions for regions scheduling information */
+/* Functions for regions scheduling information. */
/* Compute dominators, probability, and potential-split-edges of bb.
Assume that these values were already computed for bb's predecessors. */
fst_in_edge = nxt_in_edge = IN_EDGES (BB_TO_BLOCK (bb));
- /* intialize dom[bb] to '111..1' */
+ /* Intialize dom[bb] to '111..1'. */
BITSET_INVERT (dom[bb], bbset_size);
do
BITSET_ADD (pot_split[bb], EDGE_TO_BIT (fst_out_edge), edgeset_size);
- /* the successor doesn't belong the region? */
+ /* The successor doesn't belong in the region? */
if (CONTAINING_RGN (TO_BLOCK (fst_out_edge)) !=
CONTAINING_RGN (BB_TO_BLOCK (bb)))
++nr_rgn_out_edges;
while (fst_out_edge != nxt_out_edge)
{
++nr_out_edges;
- /* the successor doesn't belong the region? */
+ /* The successor doesn't belong in the region? */
if (CONTAINING_RGN (TO_BLOCK (nxt_out_edge)) !=
CONTAINING_RGN (BB_TO_BLOCK (bb)))
++nr_rgn_out_edges;
}
- /* now nr_rgn_out_edges is the number of region-exit edges from pred,
- and nr_out_edges will be the number of pred out edges not leaving
- the region. */
+ /* Now nr_rgn_out_edges is the number of region-exit edges from
+ pred, and nr_out_edges will be the number of pred out edges
+ not leaving the region. */
nr_out_edges -= nr_rgn_out_edges;
if (nr_rgn_out_edges > 0)
prob[bb] += 0.9 * prob[BLOCK_TO_BB (pred)] / nr_out_edges;
fprintf (dump, ";; bb_prob(%d, %d) = %3d\n", bb, BB_TO_BLOCK (bb), (int) (100.0 * prob[bb]));
} /* compute_dom_prob_ps */
-/* functions for target info */
+/* Functions for target info. */
/* Compute in BL the list of split-edges of bb_src relatively to bb_trg.
Note that bb_trg dominates bb_src. */
edgelst *bl;
{
int es = edgeset_size;
- edgeset src = (edgeset) alloca (es * sizeof (HOST_WIDE_INT));
+ edgeset src = (edgeset) xcalloc (es, sizeof (HOST_WIDE_INT));
while (es--)
src[es] = (pot_split[bb_src])[es];
BITSET_DIFFER (src, pot_split[bb_trg], edgeset_size);
- extract_bitlst (src, edgeset_size, bl);
+ extract_bitlst (src, edgeset_size, edgeset_bitsize, bl);
+ free (src);
}
int check_block, update_idx;
int i, j, k, fst_edge, nxt_edge;
- /* define some of the fields for the target bb as well */
+ /* Define some of the fields for the target bb as well. */
sp = candidate_table + trg;
sp->is_valid = 1;
sp->is_speculative = 0;
}
-/* functions for speculative scheduing */
+/* Functions for speculative scheduing. */
/* Return 0 if x is a set of a register alive in the beginning of one
of the split-blocks of src, otherwise return 1. */
|| GET_CODE (reg) == STRICT_LOW_PART)
reg = XEXP (reg, 0);
+ if (GET_CODE (reg) == PARALLEL
+ && GET_MODE (reg) == BLKmode)
+ {
+ register int i;
+ for (i = XVECLEN (reg, 0) - 1; i >= 0; i--)
+ if (check_live_1 (src, XVECEXP (reg, 0, i)))
+ return 1;
+ return 0;
+ }
+
if (GET_CODE (reg) != REG)
return 1;
if (regno < FIRST_PSEUDO_REGISTER && global_regs[regno])
{
- /* Global registers are assumed live */
+ /* Global registers are assumed live. */
return 0;
}
else
{
if (regno < FIRST_PSEUDO_REGISTER)
{
- /* check for hard registers */
+ /* Check for hard registers. */
int j = HARD_REGNO_NREGS (regno, GET_MODE (reg));
while (--j >= 0)
{
{
int b = candidate_table[src].split_bbs.first_member[i];
- if (REGNO_REG_SET_P (basic_block_live_at_start[b], regno + j))
+ if (REGNO_REG_SET_P (BASIC_BLOCK (b)->global_live_at_start,
+ regno + j))
{
return 0;
}
}
else
{
- /* check for psuedo registers */
+ /* Check for psuedo registers. */
for (i = 0; i < candidate_table[src].split_bbs.nr_members; i++)
{
int b = candidate_table[src].split_bbs.first_member[i];
- if (REGNO_REG_SET_P (basic_block_live_at_start[b], regno))
+ if (REGNO_REG_SET_P (BASIC_BLOCK (b)->global_live_at_start, regno))
{
return 0;
}
|| GET_CODE (reg) == STRICT_LOW_PART)
reg = XEXP (reg, 0);
+ if (GET_CODE (reg) == PARALLEL
+ && GET_MODE (reg) == BLKmode)
+ {
+ register int i;
+ for (i = XVECLEN (reg, 0) - 1; i >= 0; i--)
+ update_live_1 (src, XVECEXP (reg, 0, i));
+ return;
+ }
+
if (GET_CODE (reg) != REG)
return;
{
int b = candidate_table[src].update_bbs.first_member[i];
- SET_REGNO_REG_SET (basic_block_live_at_start[b], regno + j);
+ SET_REGNO_REG_SET (BASIC_BLOCK (b)->global_live_at_start,
+ regno + j);
}
}
}
{
int b = candidate_table[src].update_bbs.first_member[i];
- SET_REGNO_REG_SET (basic_block_live_at_start[b], regno);
+ SET_REGNO_REG_SET (BASIC_BLOCK (b)->global_live_at_start, regno);
}
}
}
rtx insn;
int src;
{
- /* find the registers set by instruction */
+ /* Find the registers set by instruction. */
if (GET_CODE (PATTERN (insn)) == SET
|| GET_CODE (PATTERN (insn)) == CLOBBER)
return check_live_1 (src, PATTERN (insn));
rtx insn;
int src;
{
- /* find the registers set by instruction */
+ /* Find the registers set by instruction. */
if (GET_CODE (PATTERN (insn)) == SET
|| GET_CODE (PATTERN (insn)) == CLOBBER)
update_live_1 (src, PATTERN (insn));
- insn1 is not in the same block as load-insn
- there is a DEF-USE dependence chain (insn1, ..., load-insn)
- - test-insn is either a compare or a branch, not in the same block as load-insn
+ - test-insn is either a compare or a branch, not in the same block
+ as load-insn
- load-insn is reachable from test-insn
- there is a DEF-USE dependence chain (insn1, ..., test-insn)
#define WORST_CLASS(class1, class2) \
((class1 > class2) ? class1 : class2)
-/* Indexed by INSN_UID, and set if there's DEF-USE dependence between */
-/* some speculatively moved load insn and this one. */
-char *fed_by_spec_load;
-char *is_load_insn;
-
/* Non-zero if block bb_to is equal to, or reachable from block bb_from. */
#define IS_REACHABLE(bb_from, bb_to) \
(bb_from == bb_to \
|| (bitset_member (ancestor_edges[bb_to], \
EDGE_TO_BIT (IN_EDGES (BB_TO_BLOCK (bb_from))), \
edgeset_size)))
-#define FED_BY_SPEC_LOAD(insn) (fed_by_spec_load[INSN_UID (insn)])
-#define IS_LOAD_INSN(insn) (is_load_insn[INSN_UID (insn)])
-/* Non-zero iff the address is comprised from at most 1 register */
+/* Non-zero iff the address is comprised from at most 1 register. */
#define CONST_BASED_ADDRESS_P(x) \
(GET_CODE (x) == REG \
|| ((GET_CODE (x) == PLUS || GET_CODE (x) == MINUS \
FED_BY_SPEC_LOAD (XEXP (link, 0)) = 1;
} /* set_spec_fed */
-/* On the path from the insn to load_insn_bb, find a conditional branch */
-/* depending on insn, that guards the speculative load. */
+/* On the path from the insn to load_insn_bb, find a conditional
+branch depending on insn, that guards the speculative load. */
static int
find_conditional_protection (insn, load_insn_bb)
{
rtx link;
- /* iterate through DEF-USE forward dependences */
+ /* Iterate through DEF-USE forward dependences. */
for (link = INSN_DEPEND (insn); link; link = XEXP (link, 1))
{
rtx next = XEXP (link, 0);
- if ((CONTAINING_RGN (INSN_BLOCK (next)) ==
+ if ((CONTAINING_RGN (BLOCK_NUM (next)) ==
CONTAINING_RGN (BB_TO_BLOCK (load_insn_bb)))
&& IS_REACHABLE (INSN_BB (next), load_insn_bb)
&& load_insn_bb != INSN_BB (next)
{
rtx insn1 = XEXP (link, 0);
- /* must be a DEF-USE dependence upon non-branch */
+ /* Must be a DEF-USE dependence upon non-branch. */
if (GET_MODE (link) != VOIDmode
|| GET_CODE (insn1) == JUMP_INSN)
continue;
- /* must exist a path: region-entry -> ... -> bb_trg -> ... load_insn */
+ /* Must exist a path: region-entry -> ... -> bb_trg -> ... load_insn. */
if (INSN_BB (insn1) == bb_src
- || (CONTAINING_RGN (INSN_BLOCK (insn1))
+ || (CONTAINING_RGN (BLOCK_NUM (insn1))
!= CONTAINING_RGN (BB_TO_BLOCK (bb_src)))
|| (!IS_REACHABLE (bb_trg, INSN_BB (insn1))
&& !IS_REACHABLE (INSN_BB (insn1), bb_trg)))
continue;
- /* now search for the conditional-branch */
+ /* Now search for the conditional-branch. */
if (find_conditional_protection (insn1, bb_src))
return 1;
- /* recursive step: search another insn1, "above" current insn1. */
+ /* Recursive step: search another insn1, "above" current insn1. */
return is_conditionally_protected (insn1, bb_src, bb_trg);
}
- /* the chain does not exsist */
+ /* The chain does not exist. */
return 0;
} /* is_conditionally_protected */
register candidate *candp = candidate_table + bb_src;
if (candp->split_bbs.nr_members != 1)
- /* must have exactly one escape block */
+ /* Must have exactly one escape block. */
return 0;
for (back_link = LOG_LINKS (load_insn);
if (GET_MODE (back_link) == VOIDmode)
{
- /* found a DEF-USE dependence (insn1, load_insn) */
+ /* Found a DEF-USE dependence (insn1, load_insn). */
rtx fore_link;
for (fore_link = INSN_DEPEND (insn1);
rtx insn2 = XEXP (fore_link, 0);
if (GET_MODE (fore_link) == VOIDmode)
{
- /* found a DEF-USE dependence (insn1, insn2) */
+ /* Found a DEF-USE dependence (insn1, insn2). */
if (haifa_classify_insn (insn2) != PFREE_CANDIDATE)
- /* insn2 not guaranteed to be a 1 base reg load */
+ /* insn2 not guaranteed to be a 1 base reg load. */
continue;
if (INSN_BB (insn2) == bb_trg)
- /* insn2 is the similar load, in the target block */
+ /* insn2 is the similar load, in the target block. */
return 1;
- if (*(candp->split_bbs.first_member) == INSN_BLOCK (insn2))
- /* insn2 is a similar load, in a split-block */
+ if (*(candp->split_bbs.first_member) == BLOCK_NUM (insn2))
+ /* insn2 is a similar load, in a split-block. */
return 1;
}
}
}
}
- /* couldn't find a similar load */
+ /* Couldn't find a similar load. */
return 0;
} /* is_pfree */
}
if (code == MEM)
{
- /* The insn uses memory */
- /* a volatile load */
+ /* The insn uses memory: a volatile load. */
if (MEM_VOLATILE_P (x))
return IRISKY;
- /* an exception-free load */
+ /* An exception-free load. */
if (!may_trap_p (x))
return IFREE;
- /* a load with 1 base register, to be further checked */
+ /* A load with 1 base register, to be further checked. */
if (CONST_BASED_ADDRESS_P (XEXP (x, 0)))
return PFREE_CANDIDATE;
- /* no info on the load, to be further checked */
+ /* No info on the load, to be further checked. */
return PRISKY_CANDIDATE;
}
else
{
- char *fmt;
+ const char *fmt;
int i, insn_class = TRAP_FREE;
- /* neither store nor load, check if it may cause a trap */
+ /* Neither store nor load, check if it may cause a trap. */
if (may_trap_p (x))
return TRAP_RISKY;
- /* recursive step: walk the insn... */
+ /* Recursive step: walk the insn... */
fmt = GET_RTX_FORMAT (code);
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
{
switch (code)
{
case CLOBBER:
- /* test if it is a 'store' */
+ /* Test if it is a 'store'. */
tmp_class = may_trap_exp (XEXP (XVECEXP (pat, 0, i), 0), 1);
break;
case SET:
- /* test if it is a store */
+ /* Test if it is a store. */
tmp_class = may_trap_exp (SET_DEST (XVECEXP (pat, 0, i)), 1);
if (tmp_class == TRAP_RISKY)
break;
- /* test if it is a load */
+ /* Test if it is a load. */
tmp_class =
WORST_CLASS (tmp_class,
may_trap_exp (SET_SRC (XVECEXP (pat, 0, i)), 0));
break;
+ case COND_EXEC:
case TRAP_IF:
tmp_class = TRAP_RISKY;
break;
switch (code)
{
case CLOBBER:
- /* test if it is a 'store' */
+ /* Test if it is a 'store'. */
tmp_class = may_trap_exp (XEXP (pat, 0), 1);
break;
case SET:
- /* test if it is a store */
+ /* Test if it is a store. */
tmp_class = may_trap_exp (SET_DEST (pat), 1);
if (tmp_class == TRAP_RISKY)
break;
- /* test if it is a load */
+ /* Test if it is a load. */
tmp_class =
WORST_CLASS (tmp_class,
may_trap_exp (SET_SRC (pat), 0));
break;
+ case COND_EXEC:
case TRAP_IF:
tmp_class = TRAP_RISKY;
break;
return 1;
if (LOG_LINKS (load_insn) == NULL)
- /* dependence may 'hide' out of the region. */
+ /* Dependence may 'hide' out of the region. */
return 1;
if (is_conditionally_protected (load_insn, bb_src, bb_trg))
{
int insn_class = haifa_classify_insn (insn);
- /* handle non-load insns */
+ /* Handle non-load insns. */
switch (insn_class)
{
case TRAP_FREE:
default:;
}
- /* handle loads */
+ /* Handle loads. */
if (!flag_schedule_speculative_load)
return 0;
IS_LOAD_INSN (insn) = 1;
case PFREE_CANDIDATE:
if (is_pfree (insn, bb_src, bb_trg))
return 1;
- /* don't 'break' here: PFREE-candidate is also PRISKY-candidate */
+ /* Don't 'break' here: PFREE-candidate is also PRISKY-candidate. */
case PRISKY_CANDIDATE:
if (!flag_schedule_speculative_load_dangerous
|| is_prisky (insn, bb_src, bb_trg))
We are careful to build only dependencies which actually exist, and
use transitivity to avoid building too many links. */
\f
-/* Return the INSN_LIST containing INSN in LIST, or NULL
- if LIST does not contain INSN. */
-
-HAIFA_INLINE static rtx
-find_insn_list (insn, list)
- rtx insn;
- rtx list;
-{
- while (list)
- {
- if (XEXP (list, 0) == insn)
- return list;
- list = XEXP (list, 1);
- }
- return 0;
-}
-
-
-/* Return 1 if the pair (insn, x) is found in (LIST, LIST1), or 0 otherwise. */
+/* Return 1 if the pair (insn, x) is found in (LIST, LIST1), or 0
+ otherwise. */
HAIFA_INLINE static char
find_insn_mem_list (insn, x, list, list1)
range, don't cache it. */
if (FUNCTION_UNITS_SIZE < HOST_BITS_PER_SHORT
|| unit >= 0
- || (~unit & ((1 << (HOST_BITS_PER_SHORT - 1)) - 1)) == 0)
+ || (unit & ~((1 << (HOST_BITS_PER_SHORT - 1)) - 1)) == 0)
INSN_UNIT (insn) = unit;
}
return (unit > 0 ? unit - 1 : unit);
unsigned int blockage = INSN_BLOCKAGE (insn);
unsigned int range;
- if (UNIT_BLOCKED (blockage) != unit + 1)
+ if ((int) UNIT_BLOCKED (blockage) != unit + 1)
{
range = function_units[unit].blockage_range_function (insn);
/* We only cache the blockage range for one unit and then only if
bzero ((char *) unit_n_insns, sizeof (unit_n_insns));
}
-/* Return the issue-delay of an insn */
+/* Return the issue-delay of an insn. */
HAIFA_INLINE static int
insn_issue_delay (insn)
int i, delay = 0;
int unit = insn_unit (insn);
- /* efficiency note: in fact, we are working 'hard' to compute a
+ /* Efficiency note: in fact, we are working 'hard' to compute a
value that was available in md file, and is not available in
function_units[] structure. It would be nice to have this
value there, too. */
int unit, instance, clock, cost;
rtx insn;
{
- int tick = unit_tick[instance]; /* issue time of the last issued insn */
+ int tick = unit_tick[instance]; /* Issue time of the last issued insn. */
if (tick - clock > cost)
{
int instance = unit;
int best_cost = actual_hazard_this_instance (unit, instance, insn,
clock, cost);
+#if MAX_MULTIPLICITY > 1
int this_cost;
-#if MAX_MULTIPLICITY > 1
if (best_cost > cost)
{
for (i = function_units[unit].multiplicity - 1; i > 0; i--)
}
}
- /* in this case estimate cost without caring how insn is used. */
+ /* In this case estimate cost without caring how insn is used. */
if (link == 0 && used == 0)
return cost;
and LINK_COST_ZERO. */
if (LINK_COST_FREE (link))
- cost = 1;
+ cost = 0;
#ifdef ADJUST_COST
else if (!LINK_COST_ZERO (link))
{
int ncost = cost;
ADJUST_COST (used, link, insn, ncost);
- if (ncost <= 1)
- LINK_COST_FREE (link) = ncost = 1;
+ if (ncost < 1)
+ {
+ LINK_COST_FREE (link) = 1;
+ ncost = 0;
+ }
if (cost == ncost)
LINK_COST_ZERO (link) = 1;
cost = ncost;
int this_priority;
rtx link;
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
return 0;
if ((this_priority = INSN_PRIORITY (insn)) == 0)
next = XEXP (link, 0);
- /* critical path is meaningful in block boundaries only */
- if (INSN_BLOCK (next) != INSN_BLOCK (insn))
+ /* Critical path is meaningful in block boundaries only. */
+ if (BLOCK_NUM (next) != BLOCK_NUM (insn))
continue;
next_priority = insn_cost (insn, link, next) + priority (next);
static void
free_pending_lists ()
{
- if (current_nr_blocks <= 1)
- {
- free_list (&pending_read_insns, &unused_insn_list);
- free_list (&pending_write_insns, &unused_insn_list);
- free_list (&pending_read_mems, &unused_expr_list);
- free_list (&pending_write_mems, &unused_expr_list);
- }
- else
- {
- /* interblock scheduling */
- int bb;
+ int bb;
- for (bb = 0; bb < current_nr_blocks; bb++)
- {
- free_list (&bb_pending_read_insns[bb], &unused_insn_list);
- free_list (&bb_pending_write_insns[bb], &unused_insn_list);
- free_list (&bb_pending_read_mems[bb], &unused_expr_list);
- free_list (&bb_pending_write_mems[bb], &unused_expr_list);
- }
+ for (bb = 0; bb < current_nr_blocks; bb++)
+ {
+ free_INSN_LIST_list (&bb_deps[bb].pending_read_insns);
+ free_INSN_LIST_list (&bb_deps[bb].pending_write_insns);
+ free_EXPR_LIST_list (&bb_deps[bb].pending_read_mems);
+ free_EXPR_LIST_list (&bb_deps[bb].pending_write_mems);
}
}
so that we can do memory aliasing on it. */
static void
-add_insn_mem_dependence (insn_list, mem_list, insn, mem)
+add_insn_mem_dependence (deps, insn_list, mem_list, insn, mem)
+ struct deps *deps;
rtx *insn_list, *mem_list, insn, mem;
{
register rtx link;
link = alloc_EXPR_LIST (VOIDmode, mem, *mem_list);
*mem_list = link;
- pending_lists_length++;
+ deps->pending_lists_length++;
}
\f
-
/* Make a dependency between every memory reference on the pending lists
and INSN, thus flushing the pending lists. If ONLY_WRITE, don't flush
the read list. */
static void
-flush_pending_lists (insn, only_write)
+flush_pending_lists (deps, insn, only_write)
+ struct deps *deps;
rtx insn;
int only_write;
{
rtx u;
rtx link;
- while (pending_read_insns && ! only_write)
+ while (deps->pending_read_insns && ! only_write)
{
- add_dependence (insn, XEXP (pending_read_insns, 0), REG_DEP_ANTI);
+ add_dependence (insn, XEXP (deps->pending_read_insns, 0),
+ REG_DEP_ANTI);
- link = pending_read_insns;
- pending_read_insns = XEXP (pending_read_insns, 1);
- XEXP (link, 1) = unused_insn_list;
- unused_insn_list = link;
+ link = deps->pending_read_insns;
+ deps->pending_read_insns = XEXP (deps->pending_read_insns, 1);
+ free_INSN_LIST_node (link);
- link = pending_read_mems;
- pending_read_mems = XEXP (pending_read_mems, 1);
- XEXP (link, 1) = unused_expr_list;
- unused_expr_list = link;
+ link = deps->pending_read_mems;
+ deps->pending_read_mems = XEXP (deps->pending_read_mems, 1);
+ free_EXPR_LIST_node (link);
}
- while (pending_write_insns)
+ while (deps->pending_write_insns)
{
- add_dependence (insn, XEXP (pending_write_insns, 0), REG_DEP_ANTI);
+ add_dependence (insn, XEXP (deps->pending_write_insns, 0),
+ REG_DEP_ANTI);
- link = pending_write_insns;
- pending_write_insns = XEXP (pending_write_insns, 1);
- XEXP (link, 1) = unused_insn_list;
- unused_insn_list = link;
+ link = deps->pending_write_insns;
+ deps->pending_write_insns = XEXP (deps->pending_write_insns, 1);
+ free_INSN_LIST_node (link);
- link = pending_write_mems;
- pending_write_mems = XEXP (pending_write_mems, 1);
- XEXP (link, 1) = unused_expr_list;
- unused_expr_list = link;
+ link = deps->pending_write_mems;
+ deps->pending_write_mems = XEXP (deps->pending_write_mems, 1);
+ free_EXPR_LIST_node (link);
}
- pending_lists_length = 0;
+ deps->pending_lists_length = 0;
- /* last_pending_memory_flush is now a list of insns */
- for (u = last_pending_memory_flush; u; u = XEXP (u, 1))
+ /* last_pending_memory_flush is now a list of insns. */
+ for (u = deps->last_pending_memory_flush; u; u = XEXP (u, 1))
add_dependence (insn, XEXP (u, 0), REG_DEP_ANTI);
- free_list (&last_pending_memory_flush, &unused_insn_list);
- last_pending_memory_flush = alloc_INSN_LIST (insn, NULL_RTX);
+ free_INSN_LIST_list (&deps->last_pending_memory_flush);
+ deps->last_pending_memory_flush = alloc_INSN_LIST (insn, NULL_RTX);
}
-/* Analyze a single SET or CLOBBER rtx, X, creating all dependencies generated
- by the write to the destination of X, and reads of everything mentioned. */
+/* Analyze a single SET, CLOBBER, PRE_DEC, POST_DEC, PRE_INC or POST_INC
+ rtx, X, creating all dependencies generated by the write to the
+ destination of X, and reads of everything mentioned. */
static void
-sched_analyze_1 (x, insn)
+sched_analyze_1 (deps, x, insn)
+ struct deps *deps;
rtx x;
rtx insn;
{
register int regno;
- register rtx dest = SET_DEST (x);
+ register rtx dest = XEXP (x, 0);
+ enum rtx_code code = GET_CODE (x);
if (dest == 0)
return;
+ if (GET_CODE (dest) == PARALLEL
+ && GET_MODE (dest) == BLKmode)
+ {
+ register int i;
+ for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
+ sched_analyze_1 (deps, XVECEXP (dest, 0, i), insn);
+ if (GET_CODE (x) == SET)
+ sched_analyze_2 (deps, SET_SRC (x), insn);
+ return;
+ }
+
while (GET_CODE (dest) == STRICT_LOW_PART || GET_CODE (dest) == SUBREG
|| GET_CODE (dest) == ZERO_EXTRACT || GET_CODE (dest) == SIGN_EXTRACT)
{
if (GET_CODE (dest) == ZERO_EXTRACT || GET_CODE (dest) == SIGN_EXTRACT)
{
/* The second and third arguments are values read by this insn. */
- sched_analyze_2 (XEXP (dest, 1), insn);
- sched_analyze_2 (XEXP (dest, 2), insn);
+ sched_analyze_2 (deps, XEXP (dest, 1), insn);
+ sched_analyze_2 (deps, XEXP (dest, 2), insn);
}
- dest = SUBREG_REG (dest);
+ dest = XEXP (dest, 0);
}
if (GET_CODE (dest) == REG)
i = HARD_REGNO_NREGS (regno, GET_MODE (dest));
while (--i >= 0)
{
+ int r = regno + i;
rtx u;
- for (u = reg_last_uses[regno + i]; u; u = XEXP (u, 1))
+ for (u = deps->reg_last_uses[r]; u; u = XEXP (u, 1))
add_dependence (insn, XEXP (u, 0), REG_DEP_ANTI);
- reg_last_uses[regno + i] = 0;
- for (u = reg_last_sets[regno + i]; u; u = XEXP (u, 1))
+ for (u = deps->reg_last_sets[r]; u; u = XEXP (u, 1))
add_dependence (insn, XEXP (u, 0), REG_DEP_OUTPUT);
- SET_REGNO_REG_SET (reg_pending_sets, regno + i);
+ /* Clobbers need not be ordered with respect to one
+ another, but sets must be ordered with respect to a
+ pending clobber. */
+ if (code == SET)
+ {
+ free_INSN_LIST_list (&deps->reg_last_uses[r]);
+ for (u = deps->reg_last_clobbers[r]; u; u = XEXP (u, 1))
+ add_dependence (insn, XEXP (u, 0), REG_DEP_OUTPUT);
+ SET_REGNO_REG_SET (reg_pending_sets, r);
+ }
+ else
+ SET_REGNO_REG_SET (reg_pending_clobbers, r);
- if ((call_used_regs[regno + i] || global_regs[regno + i]))
- /* Function calls clobber all call_used regs. */
- for (u = last_function_call; u; u = XEXP (u, 1))
+ /* Function calls clobber all call_used regs. */
+ if (global_regs[r] || (code == SET && call_used_regs[r]))
+ for (u = deps->last_function_call; u; u = XEXP (u, 1))
add_dependence (insn, XEXP (u, 0), REG_DEP_ANTI);
}
}
{
rtx u;
- for (u = reg_last_uses[regno]; u; u = XEXP (u, 1))
+ for (u = deps->reg_last_uses[regno]; u; u = XEXP (u, 1))
add_dependence (insn, XEXP (u, 0), REG_DEP_ANTI);
- reg_last_uses[regno] = 0;
- for (u = reg_last_sets[regno]; u; u = XEXP (u, 1))
+ for (u = deps->reg_last_sets[regno]; u; u = XEXP (u, 1))
add_dependence (insn, XEXP (u, 0), REG_DEP_OUTPUT);
- SET_REGNO_REG_SET (reg_pending_sets, regno);
+ if (code == SET)
+ {
+ free_INSN_LIST_list (&deps->reg_last_uses[regno]);
+ for (u = deps->reg_last_clobbers[regno]; u; u = XEXP (u, 1))
+ add_dependence (insn, XEXP (u, 0), REG_DEP_OUTPUT);
+ SET_REGNO_REG_SET (reg_pending_sets, regno);
+ }
+ else
+ SET_REGNO_REG_SET (reg_pending_clobbers, regno);
/* Pseudos that are REG_EQUIV to something may be replaced
by that during reloading. We need only add dependencies for
if (!reload_completed
&& reg_known_equiv_p[regno]
&& GET_CODE (reg_known_value[regno]) == MEM)
- sched_analyze_2 (XEXP (reg_known_value[regno], 0), insn);
+ sched_analyze_2 (deps, XEXP (reg_known_value[regno], 0), insn);
/* Don't let it cross a call after scheduling if it doesn't
already cross one. */
if (REG_N_CALLS_CROSSED (regno) == 0)
- for (u = last_function_call; u; u = XEXP (u, 1))
+ for (u = deps->last_function_call; u; u = XEXP (u, 1))
add_dependence (insn, XEXP (u, 0), REG_DEP_ANTI);
}
}
{
/* Writing memory. */
- if (pending_lists_length > 32)
+ if (deps->pending_lists_length > 32)
{
/* Flush all pending reads and writes to prevent the pending lists
from getting any larger. Insn scheduling runs too slowly when
seems like a reasonable number. When compiling GCC with itself,
this flush occurs 8 times for sparc, and 10 times for m88k using
the number 32. */
- flush_pending_lists (insn, 0);
+ flush_pending_lists (deps, insn, 0);
}
else
{
rtx u;
rtx pending, pending_mem;
- pending = pending_read_insns;
- pending_mem = pending_read_mems;
+ pending = deps->pending_read_insns;
+ pending_mem = deps->pending_read_mems;
while (pending)
{
- /* If a dependency already exists, don't create a new one. */
- if (!find_insn_list (XEXP (pending, 0), LOG_LINKS (insn)))
- if (anti_dependence (XEXP (pending_mem, 0), dest))
- add_dependence (insn, XEXP (pending, 0), REG_DEP_ANTI);
+ if (anti_dependence (XEXP (pending_mem, 0), dest))
+ add_dependence (insn, XEXP (pending, 0), REG_DEP_ANTI);
pending = XEXP (pending, 1);
pending_mem = XEXP (pending_mem, 1);
}
- pending = pending_write_insns;
- pending_mem = pending_write_mems;
+ pending = deps->pending_write_insns;
+ pending_mem = deps->pending_write_mems;
while (pending)
{
- /* If a dependency already exists, don't create a new one. */
- if (!find_insn_list (XEXP (pending, 0), LOG_LINKS (insn)))
- if (output_dependence (XEXP (pending_mem, 0), dest))
- add_dependence (insn, XEXP (pending, 0), REG_DEP_OUTPUT);
+ if (output_dependence (XEXP (pending_mem, 0), dest))
+ add_dependence (insn, XEXP (pending, 0), REG_DEP_OUTPUT);
pending = XEXP (pending, 1);
pending_mem = XEXP (pending_mem, 1);
}
- for (u = last_pending_memory_flush; u; u = XEXP (u, 1))
+ for (u = deps->last_pending_memory_flush; u; u = XEXP (u, 1))
add_dependence (insn, XEXP (u, 0), REG_DEP_ANTI);
- add_insn_mem_dependence (&pending_write_insns, &pending_write_mems,
- insn, dest);
+ add_insn_mem_dependence (deps, &deps->pending_write_insns,
+ &deps->pending_write_mems, insn, dest);
}
- sched_analyze_2 (XEXP (dest, 0), insn);
+ sched_analyze_2 (deps, XEXP (dest, 0), insn);
}
/* Analyze reads. */
if (GET_CODE (x) == SET)
- sched_analyze_2 (SET_SRC (x), insn);
+ sched_analyze_2 (deps, SET_SRC (x), insn);
}
/* Analyze the uses of memory and registers in rtx X in INSN. */
static void
-sched_analyze_2 (x, insn)
+sched_analyze_2 (deps, x, insn)
+ struct deps *deps;
rtx x;
rtx insn;
{
register int i;
register int j;
register enum rtx_code code;
- register char *fmt;
+ register const char *fmt;
if (x == 0)
return;
#ifdef HAVE_cc0
case CC0:
- {
- rtx link, prev;
-
- /* User of CC0 depends on immediately preceding insn. */
- SCHED_GROUP_P (insn) = 1;
-
- /* There may be a note before this insn now, but all notes will
- be removed before we actually try to schedule the insns, so
- it won't cause a problem later. We must avoid it here though. */
- prev = prev_nonnote_insn (insn);
-
- /* Make a copy of all dependencies on the immediately previous insn,
- and add to this insn. This is so that all the dependencies will
- apply to the group. Remove an explicit dependence on this insn
- as SCHED_GROUP_P now represents it. */
-
- if (find_insn_list (prev, LOG_LINKS (insn)))
- remove_dependence (insn, prev);
-
- for (link = LOG_LINKS (prev); link; link = XEXP (link, 1))
- add_dependence (insn, XEXP (link, 0), REG_NOTE_KIND (link));
-
- return;
- }
+ /* User of CC0 depends on immediately preceding insn. */
+ set_sched_group_p (insn);
+ return;
#endif
case REG:
i = HARD_REGNO_NREGS (regno, GET_MODE (x));
while (--i >= 0)
{
- reg_last_uses[regno + i]
- = alloc_INSN_LIST (insn, reg_last_uses[regno + i]);
+ int r = regno + i;
+ deps->reg_last_uses[r]
+ = alloc_INSN_LIST (insn, deps->reg_last_uses[r]);
+
+ for (u = deps->reg_last_sets[r]; u; u = XEXP (u, 1))
+ add_dependence (insn, XEXP (u, 0), 0);
- for (u = reg_last_sets[regno + i]; u; u = XEXP (u, 1))
+ /* ??? This should never happen. */
+ for (u = deps->reg_last_clobbers[r]; u; u = XEXP (u, 1))
add_dependence (insn, XEXP (u, 0), 0);
- if ((call_used_regs[regno + i] || global_regs[regno + i]))
+ if (call_used_regs[r] || global_regs[r])
/* Function calls clobber all call_used regs. */
- for (u = last_function_call; u; u = XEXP (u, 1))
+ for (u = deps->last_function_call; u; u = XEXP (u, 1))
add_dependence (insn, XEXP (u, 0), REG_DEP_ANTI);
}
}
else
{
- reg_last_uses[regno] = alloc_INSN_LIST (insn, reg_last_uses[regno]);
+ deps->reg_last_uses[regno]
+ = alloc_INSN_LIST (insn, deps->reg_last_uses[regno]);
+
+ for (u = deps->reg_last_sets[regno]; u; u = XEXP (u, 1))
+ add_dependence (insn, XEXP (u, 0), 0);
- for (u = reg_last_sets[regno]; u; u = XEXP (u, 1))
+ /* ??? This should never happen. */
+ for (u = deps->reg_last_clobbers[regno]; u; u = XEXP (u, 1))
add_dependence (insn, XEXP (u, 0), 0);
/* Pseudos that are REG_EQUIV to something may be replaced
if (!reload_completed
&& reg_known_equiv_p[regno]
&& GET_CODE (reg_known_value[regno]) == MEM)
- sched_analyze_2 (XEXP (reg_known_value[regno], 0), insn);
+ sched_analyze_2 (deps, XEXP (reg_known_value[regno], 0), insn);
/* If the register does not already cross any calls, then add this
insn to the sched_before_next_call list so that it will still
not cross calls after scheduling. */
if (REG_N_CALLS_CROSSED (regno) == 0)
- add_dependence (sched_before_next_call, insn, REG_DEP_ANTI);
+ add_dependence (deps->sched_before_next_call, insn,
+ REG_DEP_ANTI);
}
return;
}
rtx u;
rtx pending, pending_mem;
- pending = pending_read_insns;
- pending_mem = pending_read_mems;
+ pending = deps->pending_read_insns;
+ pending_mem = deps->pending_read_mems;
while (pending)
{
- /* If a dependency already exists, don't create a new one. */
- if (!find_insn_list (XEXP (pending, 0), LOG_LINKS (insn)))
- if (read_dependence (XEXP (pending_mem, 0), x))
- add_dependence (insn, XEXP (pending, 0), REG_DEP_ANTI);
+ if (read_dependence (XEXP (pending_mem, 0), x))
+ add_dependence (insn, XEXP (pending, 0), REG_DEP_ANTI);
pending = XEXP (pending, 1);
pending_mem = XEXP (pending_mem, 1);
}
- pending = pending_write_insns;
- pending_mem = pending_write_mems;
+ pending = deps->pending_write_insns;
+ pending_mem = deps->pending_write_mems;
while (pending)
{
- /* If a dependency already exists, don't create a new one. */
- if (!find_insn_list (XEXP (pending, 0), LOG_LINKS (insn)))
- if (true_dependence (XEXP (pending_mem, 0), VOIDmode,
- x, rtx_varies_p))
- add_dependence (insn, XEXP (pending, 0), 0);
+ if (true_dependence (XEXP (pending_mem, 0), VOIDmode,
+ x, rtx_varies_p))
+ add_dependence (insn, XEXP (pending, 0), 0);
pending = XEXP (pending, 1);
pending_mem = XEXP (pending_mem, 1);
}
- for (u = last_pending_memory_flush; u; u = XEXP (u, 1))
+ for (u = deps->last_pending_memory_flush; u; u = XEXP (u, 1))
add_dependence (insn, XEXP (u, 0), REG_DEP_ANTI);
/* Always add these dependencies to pending_reads, since
this insn may be followed by a write. */
- add_insn_mem_dependence (&pending_read_insns, &pending_read_mems,
- insn, x);
+ add_insn_mem_dependence (deps, &deps->pending_read_insns,
+ &deps->pending_read_mems, insn, x);
/* Take advantage of tail recursion here. */
- sched_analyze_2 (XEXP (x, 0), insn);
+ sched_analyze_2 (deps, XEXP (x, 0), insn);
return;
}
/* Force pending stores to memory in case a trap handler needs them. */
case TRAP_IF:
- flush_pending_lists (insn, 1);
+ flush_pending_lists (deps, insn, 1);
break;
case ASM_OPERANDS:
int max_reg = max_reg_num ();
for (i = 0; i < max_reg; i++)
{
- for (u = reg_last_uses[i]; u; u = XEXP (u, 1))
+ for (u = deps->reg_last_uses[i]; u; u = XEXP (u, 1))
add_dependence (insn, XEXP (u, 0), REG_DEP_ANTI);
- reg_last_uses[i] = 0;
+ free_INSN_LIST_list (&deps->reg_last_uses[i]);
- /* reg_last_sets[r] is now a list of insns */
- for (u = reg_last_sets[i]; u; u = XEXP (u, 1))
+ for (u = deps->reg_last_sets[i]; u; u = XEXP (u, 1))
+ add_dependence (insn, XEXP (u, 0), 0);
+
+ for (u = deps->reg_last_clobbers[i]; u; u = XEXP (u, 1))
add_dependence (insn, XEXP (u, 0), 0);
}
reg_pending_sets_all = 1;
- flush_pending_lists (insn, 0);
+ flush_pending_lists (deps, insn, 0);
}
/* For all ASM_OPERANDS, we must traverse the vector of input operands.
if (code == ASM_OPERANDS)
{
for (j = 0; j < ASM_OPERANDS_INPUT_LENGTH (x); j++)
- sched_analyze_2 (ASM_OPERANDS_INPUT (x, j), insn);
+ sched_analyze_2 (deps, ASM_OPERANDS_INPUT (x, j), insn);
return;
}
break;
instructions. Thus we need to pass them to both sched_analyze_1
and sched_analyze_2. We must call sched_analyze_2 first in order
to get the proper antecedent for the read. */
- sched_analyze_2 (XEXP (x, 0), insn);
- sched_analyze_1 (x, insn);
+ sched_analyze_2 (deps, XEXP (x, 0), insn);
+ sched_analyze_1 (deps, x, insn);
+ return;
+
+ case POST_MODIFY:
+ case PRE_MODIFY:
+ /* op0 = op0 + op1 */
+ sched_analyze_2 (deps, XEXP (x, 0), insn);
+ sched_analyze_2 (deps, XEXP (x, 1), insn);
+ sched_analyze_1 (deps, x, insn);
return;
default:
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
{
if (fmt[i] == 'e')
- sched_analyze_2 (XEXP (x, i), insn);
+ sched_analyze_2 (deps, XEXP (x, i), insn);
else if (fmt[i] == 'E')
for (j = 0; j < XVECLEN (x, i); j++)
- sched_analyze_2 (XVECEXP (x, i, j), insn);
+ sched_analyze_2 (deps, XVECEXP (x, i, j), insn);
}
}
/* Analyze an INSN with pattern X to find all dependencies. */
static void
-sched_analyze_insn (x, insn, loop_notes)
+sched_analyze_insn (deps, x, insn, loop_notes)
+ struct deps *deps;
rtx x, insn;
rtx loop_notes;
{
int maxreg = max_reg_num ();
int i;
+ if (code == COND_EXEC)
+ {
+ sched_analyze_2 (deps, COND_EXEC_TEST (x), insn);
+
+ /* ??? Should be recording conditions so we reduce the number of
+ false dependancies. */
+ x = COND_EXEC_CODE (x);
+ code = GET_CODE (x);
+ }
if (code == SET || code == CLOBBER)
- sched_analyze_1 (x, insn);
+ sched_analyze_1 (deps, x, insn);
else if (code == PARALLEL)
{
register int i;
for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
{
- code = GET_CODE (XVECEXP (x, 0, i));
+ rtx sub = XVECEXP (x, 0, i);
+ code = GET_CODE (sub);
+
+ if (code == COND_EXEC)
+ {
+ sched_analyze_2 (deps, COND_EXEC_TEST (sub), insn);
+ sub = COND_EXEC_CODE (sub);
+ code = GET_CODE (sub);
+ }
if (code == SET || code == CLOBBER)
- sched_analyze_1 (XVECEXP (x, 0, i), insn);
+ sched_analyze_1 (deps, sub, insn);
else
- sched_analyze_2 (XVECEXP (x, 0, i), insn);
+ sched_analyze_2 (deps, sub, insn);
}
}
else
- sched_analyze_2 (x, insn);
+ sched_analyze_2 (deps, x, insn);
/* Mark registers CLOBBERED or used by called function. */
if (GET_CODE (insn) == CALL_INSN)
for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
{
if (GET_CODE (XEXP (link, 0)) == CLOBBER)
- sched_analyze_1 (XEXP (link, 0), insn);
+ sched_analyze_1 (deps, XEXP (link, 0), insn);
else
- sched_analyze_2 (XEXP (link, 0), insn);
+ sched_analyze_2 (deps, XEXP (link, 0), insn);
}
- /* If there is a {LOOP,EHREGION}_{BEG,END} note in the middle of a basic block, then
- we must be sure that no instructions are scheduled across it.
+ /* If there is a {LOOP,EHREGION}_{BEG,END} note in the middle of a basic
+ block, then we must be sure that no instructions are scheduled across it.
Otherwise, the reg_n_refs info (which depends on loop_depth) would
become incorrect. */
if (loop_notes)
{
int max_reg = max_reg_num ();
+ int schedule_barrier_found = 0;
rtx link;
- for (i = 0; i < max_reg; i++)
+ /* Update loop_notes with any notes from this insn. Also determine
+ if any of the notes on the list correspond to instruction scheduling
+ barriers (loop, eh & setjmp notes, but not range notes. */
+ link = loop_notes;
+ while (XEXP (link, 1))
{
- rtx u;
- for (u = reg_last_uses[i]; u; u = XEXP (u, 1))
- add_dependence (insn, XEXP (u, 0), REG_DEP_ANTI);
- reg_last_uses[i] = 0;
+ if (INTVAL (XEXP (link, 0)) == NOTE_INSN_LOOP_BEG
+ || INTVAL (XEXP (link, 0)) == NOTE_INSN_LOOP_END
+ || INTVAL (XEXP (link, 0)) == NOTE_INSN_EH_REGION_BEG
+ || INTVAL (XEXP (link, 0)) == NOTE_INSN_EH_REGION_END
+ || INTVAL (XEXP (link, 0)) == NOTE_INSN_SETJMP)
+ schedule_barrier_found = 1;
- /* reg_last_sets[r] is now a list of insns */
- for (u = reg_last_sets[i]; u; u = XEXP (u, 1))
- add_dependence (insn, XEXP (u, 0), 0);
+ link = XEXP (link, 1);
}
- reg_pending_sets_all = 1;
-
- flush_pending_lists (insn, 0);
-
- link = loop_notes;
- while (XEXP (link, 1))
- link = XEXP (link, 1);
XEXP (link, 1) = REG_NOTES (insn);
REG_NOTES (insn) = loop_notes;
- }
- /* After reload, it is possible for an instruction to have a REG_DEAD note
- for a register that actually dies a few instructions earlier. For
- example, this can happen with SECONDARY_MEMORY_NEEDED reloads.
- In this case, we must consider the insn to use the register mentioned
- in the REG_DEAD note. Otherwise, we may accidentally move this insn
- after another insn that sets the register, thus getting obviously invalid
- rtl. This confuses reorg which believes that REG_DEAD notes are still
- meaningful.
+ /* Add dependencies if a scheduling barrier was found. */
+ if (schedule_barrier_found)
+ {
+ for (i = 0; i < max_reg; i++)
+ {
+ rtx u;
+ for (u = deps->reg_last_uses[i]; u; u = XEXP (u, 1))
+ add_dependence (insn, XEXP (u, 0), REG_DEP_ANTI);
+ free_INSN_LIST_list (&deps->reg_last_uses[i]);
- ??? We would get better code if we fixed reload to put the REG_DEAD
- notes in the right places, but that may not be worth the effort. */
+ for (u = deps->reg_last_sets[i]; u; u = XEXP (u, 1))
+ add_dependence (insn, XEXP (u, 0), 0);
- if (reload_completed)
- {
- rtx note;
+ for (u = deps->reg_last_clobbers[i]; u; u = XEXP (u, 1))
+ add_dependence (insn, XEXP (u, 0), 0);
+ }
+ reg_pending_sets_all = 1;
+
+ flush_pending_lists (deps, insn, 0);
+ }
- for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
- if (REG_NOTE_KIND (note) == REG_DEAD)
- sched_analyze_2 (XEXP (note, 0), insn);
}
- EXECUTE_IF_SET_IN_REG_SET (reg_pending_sets, 0, i,
- {
- /* reg_last_sets[r] is now a list of insns */
- free_list (®_last_sets[i], &unused_insn_list);
- reg_last_sets[i]
- = alloc_INSN_LIST (insn, NULL_RTX);
- });
+ /* Accumulate clobbers until the next set so that it will be output dependent
+ on all of them. At the next set we can clear the clobber list, since
+ subsequent sets will be output dependent on it. */
+ EXECUTE_IF_SET_IN_REG_SET
+ (reg_pending_sets, 0, i,
+ {
+ free_INSN_LIST_list (&deps->reg_last_sets[i]);
+ free_INSN_LIST_list (&deps->reg_last_clobbers[i]);
+ deps->reg_last_sets[i] = alloc_INSN_LIST (insn, NULL_RTX);
+ });
+ EXECUTE_IF_SET_IN_REG_SET
+ (reg_pending_clobbers, 0, i,
+ {
+ deps->reg_last_clobbers[i]
+ = alloc_INSN_LIST (insn, deps->reg_last_clobbers[i]);
+ });
CLEAR_REG_SET (reg_pending_sets);
+ CLEAR_REG_SET (reg_pending_clobbers);
if (reg_pending_sets_all)
{
for (i = 0; i < maxreg; i++)
{
- /* reg_last_sets[r] is now a list of insns */
- free_list (®_last_sets[i], &unused_insn_list);
- reg_last_sets[i] = alloc_INSN_LIST (insn, NULL_RTX);
+ free_INSN_LIST_list (&deps->reg_last_sets[i]);
+ free_INSN_LIST_list (&deps->reg_last_clobbers[i]);
+ deps->reg_last_sets[i] = alloc_INSN_LIST (insn, NULL_RTX);
}
reg_pending_sets_all = 0;
}
- /* Handle function calls and function returns created by the epilogue
- threading code. */
- if (GET_CODE (insn) == CALL_INSN || GET_CODE (insn) == JUMP_INSN)
+ /* If a post-call group is still open, see if it should remain so.
+ This insn must be a simple move of a hard reg to a pseudo or
+ vice-versa.
+
+ We must avoid moving these insns for correctness on
+ SMALL_REGISTER_CLASS machines, and for special registers like
+ PIC_OFFSET_TABLE_REGNUM. For simplicity, extend this to all
+ hard regs for all targets. */
+
+ if (deps->in_post_call_group_p)
{
- rtx dep_insn;
- rtx prev_dep_insn;
-
- /* When scheduling instructions, we make sure calls don't lose their
- accompanying USE insns by depending them one on another in order.
-
- Also, we must do the same thing for returns created by the epilogue
- threading code. Note this code works only in this special case,
- because other passes make no guarantee that they will never emit
- an instruction between a USE and a RETURN. There is such a guarantee
- for USE instructions immediately before a call. */
-
- prev_dep_insn = insn;
- dep_insn = PREV_INSN (insn);
- while (GET_CODE (dep_insn) == INSN
- && GET_CODE (PATTERN (dep_insn)) == USE
- && GET_CODE (XEXP (PATTERN (dep_insn), 0)) == REG)
- {
- SCHED_GROUP_P (prev_dep_insn) = 1;
+ rtx tmp, set = single_set (insn);
+ int src_regno, dest_regno;
+
+ if (set == NULL)
+ goto end_call_group;
- /* Make a copy of all dependencies on dep_insn, and add to insn.
- This is so that all of the dependencies will apply to the
- group. */
+ tmp = SET_DEST (set);
+ if (GET_CODE (tmp) == SUBREG)
+ tmp = SUBREG_REG (tmp);
+ if (GET_CODE (tmp) == REG)
+ dest_regno = REGNO (tmp);
+ else
+ goto end_call_group;
- for (link = LOG_LINKS (dep_insn); link; link = XEXP (link, 1))
- add_dependence (insn, XEXP (link, 0), REG_NOTE_KIND (link));
+ tmp = SET_SRC (set);
+ if (GET_CODE (tmp) == SUBREG)
+ tmp = SUBREG_REG (tmp);
+ if (GET_CODE (tmp) == REG)
+ src_regno = REGNO (tmp);
+ else
+ goto end_call_group;
- prev_dep_insn = dep_insn;
- dep_insn = PREV_INSN (dep_insn);
+ if (src_regno < FIRST_PSEUDO_REGISTER
+ || dest_regno < FIRST_PSEUDO_REGISTER)
+ {
+ set_sched_group_p (insn);
+ CANT_MOVE (insn) = 1;
+ }
+ else
+ {
+ end_call_group:
+ deps->in_post_call_group_p = 0;
}
}
}
for every dependency. */
static void
-sched_analyze (head, tail)
+sched_analyze (deps, head, tail)
+ struct deps *deps;
rtx head, tail;
{
register rtx insn;
{
if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN)
{
- sched_analyze_insn (PATTERN (insn), insn, loop_notes);
+ /* Clear out the stale LOG_LINKS from flow. */
+ free_INSN_LIST_list (&LOG_LINKS (insn));
+
+ /* Clear out stale SCHED_GROUP_P. */
+ SCHED_GROUP_P (insn) = 0;
+
+ /* Make each JUMP_INSN a scheduling barrier for memory
+ references. */
+ if (GET_CODE (insn) == JUMP_INSN)
+ deps->last_pending_memory_flush
+ = alloc_INSN_LIST (insn, deps->last_pending_memory_flush);
+ sched_analyze_insn (deps, PATTERN (insn), insn, loop_notes);
loop_notes = 0;
}
else if (GET_CODE (insn) == CALL_INSN)
rtx x;
register int i;
+ /* Clear out stale SCHED_GROUP_P. */
+ SCHED_GROUP_P (insn) = 0;
+
CANT_MOVE (insn) = 1;
+ /* Clear out the stale LOG_LINKS from flow. */
+ free_INSN_LIST_list (&LOG_LINKS (insn));
+
/* Any instruction using a hard register which may get clobbered
by a call needs to be marked as dependent on this call.
This prevents a use of a hard return reg from being moved
int max_reg = max_reg_num ();
for (i = 0; i < max_reg; i++)
{
- for (u = reg_last_uses[i]; u; u = XEXP (u, 1))
+ for (u = deps->reg_last_uses[i]; u; u = XEXP (u, 1))
add_dependence (insn, XEXP (u, 0), REG_DEP_ANTI);
+ free_INSN_LIST_list (&deps->reg_last_uses[i]);
- reg_last_uses[i] = 0;
+ for (u = deps->reg_last_sets[i]; u; u = XEXP (u, 1))
+ add_dependence (insn, XEXP (u, 0), 0);
- /* reg_last_sets[r] is now a list of insns */
- for (u = reg_last_sets[i]; u; u = XEXP (u, 1))
+ for (u = deps->reg_last_clobbers[i]; u; u = XEXP (u, 1))
add_dependence (insn, XEXP (u, 0), 0);
}
reg_pending_sets_all = 1;
- /* Add a pair of fake REG_NOTE which we will later
+ /* Add a pair of REG_SAVE_NOTEs which we will later
convert back into a NOTE_INSN_SETJMP note. See
reemit_notes for why we use a pair of NOTEs. */
- REG_NOTES (insn) = alloc_EXPR_LIST (REG_DEAD,
+ REG_NOTES (insn) = alloc_EXPR_LIST (REG_SAVE_NOTE,
GEN_INT (0),
REG_NOTES (insn));
- REG_NOTES (insn) = alloc_EXPR_LIST (REG_DEAD,
+ REG_NOTES (insn) = alloc_EXPR_LIST (REG_SAVE_NOTE,
GEN_INT (NOTE_INSN_SETJMP),
REG_NOTES (insn));
}
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
if (call_used_regs[i] || global_regs[i])
{
- for (u = reg_last_uses[i]; u; u = XEXP (u, 1))
+ for (u = deps->reg_last_uses[i]; u; u = XEXP (u, 1))
add_dependence (insn, XEXP (u, 0), REG_DEP_ANTI);
- reg_last_uses[i] = 0;
- /* reg_last_sets[r] is now a list of insns */
- for (u = reg_last_sets[i]; u; u = XEXP (u, 1))
+ for (u = deps->reg_last_sets[i]; u; u = XEXP (u, 1))
add_dependence (insn, XEXP (u, 0), REG_DEP_ANTI);
- SET_REGNO_REG_SET (reg_pending_sets, i);
+ SET_REGNO_REG_SET (reg_pending_clobbers, i);
}
}
/* For each insn which shouldn't cross a call, add a dependence
between that insn and this call insn. */
- x = LOG_LINKS (sched_before_next_call);
+ x = LOG_LINKS (deps->sched_before_next_call);
while (x)
{
add_dependence (insn, XEXP (x, 0), REG_DEP_ANTI);
x = XEXP (x, 1);
}
- LOG_LINKS (sched_before_next_call) = 0;
+ free_INSN_LIST_list (&LOG_LINKS (deps->sched_before_next_call));
- sched_analyze_insn (PATTERN (insn), insn, loop_notes);
+ sched_analyze_insn (deps, PATTERN (insn), insn, loop_notes);
loop_notes = 0;
/* In the absence of interprocedural alias analysis, we must flush
all pending reads and writes, and start new dependencies starting
from here. But only flush writes for constant calls (which may
be passed a pointer to something we haven't written yet). */
- flush_pending_lists (insn, CONST_CALL_P (insn));
+ flush_pending_lists (deps, insn, CONST_CALL_P (insn));
/* Depend this function call (actually, the user of this
function call) on all hard register clobberage. */
- /* last_function_call is now a list of insns */
- free_list(&last_function_call, &unused_insn_list);
- last_function_call = alloc_INSN_LIST (insn, NULL_RTX);
+ /* last_function_call is now a list of insns. */
+ free_INSN_LIST_list (&deps->last_function_call);
+ deps->last_function_call = alloc_INSN_LIST (insn, NULL_RTX);
+
+ /* Before reload, begin a post-call group, so as to keep the
+ lifetimes of hard registers correct. */
+ if (! reload_completed)
+ deps->in_post_call_group_p = 1;
}
- /* See comments on reemit_notes as to why we do this. */
+ /* See comments on reemit_notes as to why we do this.
+ ??? Actually, the reemit_notes just say what is done, not why. */
+
+ else if (GET_CODE (insn) == NOTE
+ && (NOTE_LINE_NUMBER (insn) == NOTE_INSN_RANGE_BEG
+ || NOTE_LINE_NUMBER (insn) == NOTE_INSN_RANGE_END))
+ {
+ loop_notes = alloc_EXPR_LIST (REG_SAVE_NOTE, NOTE_RANGE_INFO (insn),
+ loop_notes);
+ loop_notes = alloc_EXPR_LIST (REG_SAVE_NOTE,
+ GEN_INT (NOTE_LINE_NUMBER (insn)),
+ loop_notes);
+ }
else if (GET_CODE (insn) == NOTE
&& (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG
|| NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END
|| NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG
|| NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END
- || NOTE_LINE_NUMBER (insn) == NOTE_INSN_RANGE_START
- || NOTE_LINE_NUMBER (insn) == NOTE_INSN_RANGE_END
|| (NOTE_LINE_NUMBER (insn) == NOTE_INSN_SETJMP
&& GET_CODE (PREV_INSN (insn)) != CALL_INSN)))
{
- loop_notes = alloc_EXPR_LIST (REG_DEAD,
- GEN_INT (NOTE_BLOCK_NUMBER (insn)),
+ rtx rtx_region;
+
+ if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG
+ || NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END)
+ rtx_region = GEN_INT (NOTE_EH_HANDLER (insn));
+ else
+ rtx_region = GEN_INT (0);
+
+ loop_notes = alloc_EXPR_LIST (REG_SAVE_NOTE,
+ rtx_region,
loop_notes);
- loop_notes = alloc_EXPR_LIST (REG_DEAD,
+ loop_notes = alloc_EXPR_LIST (REG_SAVE_NOTE,
GEN_INT (NOTE_LINE_NUMBER (insn)),
loop_notes);
CONST_CALL_P (loop_notes) = CONST_CALL_P (insn);
abort ();
}
\f
-/* Called when we see a set of a register. If death is true, then we are
- scanning backwards. Mark that register as unborn. If nobody says
- otherwise, that is how things will remain. If death is false, then we
- are scanning forwards. Mark that register as being born. */
-
-static void
-sched_note_set (x, death)
- rtx x;
- int death;
-{
- register int regno;
- register rtx reg = SET_DEST (x);
- int subreg_p = 0;
-
- if (reg == 0)
- return;
-
- while (GET_CODE (reg) == SUBREG || GET_CODE (reg) == STRICT_LOW_PART
- || GET_CODE (reg) == SIGN_EXTRACT || GET_CODE (reg) == ZERO_EXTRACT)
- {
- /* Must treat modification of just one hardware register of a multi-reg
- value or just a byte field of a register exactly the same way that
- mark_set_1 in flow.c does, i.e. anything except a paradoxical subreg
- does not kill the entire register. */
- if (GET_CODE (reg) != SUBREG
- || REG_SIZE (SUBREG_REG (reg)) > REG_SIZE (reg))
- subreg_p = 1;
-
- reg = SUBREG_REG (reg);
- }
-
- if (GET_CODE (reg) != REG)
- return;
-
- /* Global registers are always live, so the code below does not apply
- to them. */
-
- regno = REGNO (reg);
- if (regno >= FIRST_PSEUDO_REGISTER || !global_regs[regno])
- {
- if (death)
- {
- /* If we only set part of the register, then this set does not
- kill it. */
- if (subreg_p)
- return;
-
- /* Try killing this register. */
- if (regno < FIRST_PSEUDO_REGISTER)
- {
- int j = HARD_REGNO_NREGS (regno, GET_MODE (reg));
- while (--j >= 0)
- {
- CLEAR_REGNO_REG_SET (bb_live_regs, regno + j);
- }
- }
- else
- {
- /* Recompute REG_BASIC_BLOCK as we update all the other
- dataflow information. */
- if (sched_reg_basic_block[regno] == REG_BLOCK_UNKNOWN)
- sched_reg_basic_block[regno] = current_block_num;
- else if (sched_reg_basic_block[regno] != current_block_num)
- sched_reg_basic_block[regno] = REG_BLOCK_GLOBAL;
-
- CLEAR_REGNO_REG_SET (bb_live_regs, regno);
- }
- }
- else
- {
- /* Make the register live again. */
- if (regno < FIRST_PSEUDO_REGISTER)
- {
- int j = HARD_REGNO_NREGS (regno, GET_MODE (reg));
- while (--j >= 0)
- {
- SET_REGNO_REG_SET (bb_live_regs, regno + j);
- }
- }
- else
- {
- SET_REGNO_REG_SET (bb_live_regs, regno);
- }
- }
- }
-}
-\f
/* Macros and functions for keeping the priority queue sorted, and
dealing with queueing and dequeueing of instructions. */
static int
rank_for_schedule (x, y)
- const GENERIC_PTR x;
- const GENERIC_PTR y;
+ const PTR x;
+ const PTR y;
{
- rtx tmp = *(rtx *)y;
- rtx tmp2 = *(rtx *)x;
+ rtx tmp = *(const rtx *)y;
+ rtx tmp2 = *(const rtx *)x;
rtx link;
int tmp_class, tmp2_class, depend_count1, depend_count2;
int val, priority_val, spec_val, prob_val, weight_val;
- /* prefer insn with higher priority */
+ /* Prefer insn with higher priority. */
priority_val = INSN_PRIORITY (tmp2) - INSN_PRIORITY (tmp);
if (priority_val)
return priority_val;
- /* prefer an insn with smaller contribution to registers-pressure */
+ /* Prefer an insn with smaller contribution to registers-pressure. */
if (!reload_completed &&
(weight_val = INSN_REG_WEIGHT (tmp) - INSN_REG_WEIGHT (tmp2)))
return (weight_val);
- /* some comparison make sense in interblock scheduling only */
+ /* Some comparison make sense in interblock scheduling only. */
if (INSN_BB (tmp) != INSN_BB (tmp2))
{
- /* prefer an inblock motion on an interblock motion */
+ /* Prefer an inblock motion on an interblock motion. */
if ((INSN_BB (tmp2) == target_bb) && (INSN_BB (tmp) != target_bb))
return 1;
if ((INSN_BB (tmp) == target_bb) && (INSN_BB (tmp2) != target_bb))
return -1;
- /* prefer a useful motion on a speculative one */
+ /* Prefer a useful motion on a speculative one. */
if ((spec_val = IS_SPECULATIVE_INSN (tmp) - IS_SPECULATIVE_INSN (tmp2)))
return (spec_val);
- /* prefer a more probable (speculative) insn */
+ /* Prefer a more probable (speculative) insn. */
prob_val = INSN_PROBABILITY (tmp2) - INSN_PROBABILITY (tmp);
if (prob_val)
return (prob_val);
}
- /* compare insns based on their relation to the last-scheduled-insn */
+ /* Compare insns based on their relation to the last-scheduled-insn. */
if (last_scheduled_insn)
{
/* Classify the instructions into three classes:
fprintf (dump, ";;\t\tReady-->Q: insn %d: ", INSN_UID (insn));
if (INSN_BB (insn) != target_bb)
- fprintf (dump, "(b%d) ", INSN_BLOCK (insn));
+ fprintf (dump, "(b%d) ", BLOCK_NUM (insn));
fprintf (dump, "queued for %d cycles.\n", n_cycles);
}
}
-/* Return nonzero if PAT is the pattern of an insn which makes a
- register live. */
-
-HAIFA_INLINE static int
-birthing_insn_p (pat)
- rtx pat;
-{
- int j;
-
- if (reload_completed == 1)
- return 0;
-
- if (GET_CODE (pat) == SET
- && GET_CODE (SET_DEST (pat)) == REG)
- {
- rtx dest = SET_DEST (pat);
- int i = REGNO (dest);
-
- /* It would be more accurate to use refers_to_regno_p or
- reg_mentioned_p to determine when the dest is not live before this
- insn. */
-
- if (REGNO_REG_SET_P (bb_live_regs, i))
- return (REG_N_SETS (i) == 1);
-
- return 0;
- }
- if (GET_CODE (pat) == PARALLEL)
- {
- for (j = 0; j < XVECLEN (pat, 0); j++)
- if (birthing_insn_p (XVECEXP (pat, 0, j)))
- return 1;
- }
- return 0;
-}
-
/* PREV is an insn that is ready to execute. Adjust its priority if that
- will help shorten register lifetimes. */
+ will help shorten or lengthen register lifetimes as appropriate. Also
+ provide a hook for the target to tweek itself. */
HAIFA_INLINE static void
adjust_priority (prev)
- rtx prev;
+ rtx prev ATTRIBUTE_UNUSED;
{
- /* Trying to shorten register lives after reload has completed
- is useless and wrong. It gives inaccurate schedules. */
- if (reload_completed == 0)
- {
- rtx note;
- int n_deaths = 0;
-
- /* ??? This code has no effect, because REG_DEAD notes are removed
- before we ever get here. */
- for (note = REG_NOTES (prev); note; note = XEXP (note, 1))
- if (REG_NOTE_KIND (note) == REG_DEAD)
- n_deaths += 1;
-
- /* Defer scheduling insns which kill registers, since that
- shortens register lives. Prefer scheduling insns which
- make registers live for the same reason. */
- switch (n_deaths)
- {
- default:
- INSN_PRIORITY (prev) >>= 3;
- break;
- case 3:
- INSN_PRIORITY (prev) >>= 2;
- break;
- case 2:
- case 1:
- INSN_PRIORITY (prev) >>= 1;
- break;
- case 0:
- if (birthing_insn_p (PATTERN (prev)))
- {
- int max = max_priority;
+ /* ??? There used to be code here to try and estimate how an insn
+ affected register lifetimes, but it did it by looking at REG_DEAD
+ notes, which we removed in schedule_region. Nor did it try to
+ take into account register pressure or anything useful like that.
+
+ Revisit when we have a machine model to work with and not before. */
- if (max > INSN_PRIORITY (prev))
- INSN_PRIORITY (prev) = max;
- }
- break;
- }
#ifdef ADJUST_PRIORITY
- ADJUST_PRIORITY (prev);
+ ADJUST_PRIORITY (prev);
#endif
- }
}
+/* Clock at which the previous instruction was issued. */
+static int last_clock_var;
+
/* INSN is the "currently executing insn". Launch each insn which was
waiting on INSN. READY is a vector of insns which are ready to fire.
N_READY is the number of elements in READY. CLOCK is the current
if (sched_verbose >= 2)
{
- fprintf (dump, ";;\t\t--> scheduling insn <<<%d>>> on unit ", INSN_UID (insn));
+ fprintf (dump, ";;\t\t--> scheduling insn <<<%d>>> on unit ",
+ INSN_UID (insn));
insn_print_units (insn);
fprintf (dump, "\n");
}
int effective_cost = INSN_TICK (next) - clock;
/* For speculative insns, before inserting to ready/queue,
- check live, exception-free, and issue-delay */
+ check live, exception-free, and issue-delay. */
if (INSN_BB (next) != target_bb
&& (!IS_VALID (INSN_BB (next))
|| CANT_MOVE (next)
if (sched_verbose >= 2)
{
- fprintf (dump, ";;\t\tdependences resolved: insn %d ", INSN_UID (next));
+ fprintf (dump, ";;\t\tdependences resolved: insn %d ",
+ INSN_UID (next));
if (current_nr_blocks > 1 && INSN_BB (next) != target_bb)
- fprintf (dump, "/b%d ", INSN_BLOCK (next));
+ fprintf (dump, "/b%d ", BLOCK_NUM (next));
- if (effective_cost <= 1)
+ if (effective_cost < 1)
fprintf (dump, "into ready\n");
else
fprintf (dump, "into queue with cost=%d\n", effective_cost);
/* Adjust the priority of NEXT and either put it on the ready
list or queue it. */
adjust_priority (next);
- if (effective_cost <= 1)
+ if (effective_cost < 1)
ready[n_ready++] = next;
else
queue_insn (next, effective_cost);
}
}
- return n_ready;
-}
-
-
-/* Add a REG_DEAD note for REG to INSN, reusing a REG_DEAD note from the
- dead_notes list. */
-
-static void
-create_reg_dead_note (reg, insn)
- rtx reg, insn;
-{
- rtx link;
-
- /* The number of registers killed after scheduling must be the same as the
- number of registers killed before scheduling. The number of REG_DEAD
- notes may not be conserved, i.e. two SImode hard register REG_DEAD notes
- might become one DImode hard register REG_DEAD note, but the number of
- registers killed will be conserved.
-
- We carefully remove REG_DEAD notes from the dead_notes list, so that
- there will be none left at the end. If we run out early, then there
- is a bug somewhere in flow, combine and/or sched. */
-
- if (dead_notes == 0)
- {
- if (current_nr_blocks <= 1)
- abort ();
- else
- link = alloc_EXPR_LIST (REG_DEAD, NULL_RTX, NULL_RTX);
- }
- else
- {
- /* Number of regs killed by REG. */
- int regs_killed = (REGNO (reg) >= FIRST_PSEUDO_REGISTER ? 1
- : HARD_REGNO_NREGS (REGNO (reg), GET_MODE (reg)));
- /* Number of regs killed by REG_DEAD notes taken off the list. */
- int reg_note_regs;
-
- link = dead_notes;
- reg_note_regs = (REGNO (XEXP (link, 0)) >= FIRST_PSEUDO_REGISTER ? 1
- : HARD_REGNO_NREGS (REGNO (XEXP (link, 0)),
- GET_MODE (XEXP (link, 0))));
- while (reg_note_regs < regs_killed)
- {
- link = XEXP (link, 1);
-
- /* LINK might be zero if we killed more registers after scheduling
- than before, and the last hard register we kill is actually
- multiple hard regs.
-
- This is normal for interblock scheduling, so deal with it in
- that case, else abort. */
- if (link == NULL_RTX && current_nr_blocks <= 1)
- abort ();
- else if (link == NULL_RTX)
- link = alloc_EXPR_LIST (REG_DEAD, gen_rtx_REG (word_mode, 0),
- NULL_RTX);
-
- reg_note_regs += (REGNO (XEXP (link, 0)) >= FIRST_PSEUDO_REGISTER ? 1
- : HARD_REGNO_NREGS (REGNO (XEXP (link, 0)),
- GET_MODE (XEXP (link, 0))));
- }
- dead_notes = XEXP (link, 1);
-
- /* If we took too many regs kills off, put the extra ones back. */
- while (reg_note_regs > regs_killed)
- {
- rtx temp_reg, temp_link;
-
- temp_reg = gen_rtx_REG (word_mode, 0);
- temp_link = alloc_EXPR_LIST (REG_DEAD, temp_reg, dead_notes);
- dead_notes = temp_link;
- reg_note_regs--;
- }
- }
-
- XEXP (link, 0) = reg;
- XEXP (link, 1) = REG_NOTES (insn);
- REG_NOTES (insn) = link;
-}
-
-/* Subroutine on attach_deaths_insn--handles the recursive search
- through INSN. If SET_P is true, then x is being modified by the insn. */
-
-static void
-attach_deaths (x, insn, set_p)
- rtx x;
- rtx insn;
- int set_p;
-{
- register int i;
- register int j;
- register enum rtx_code code;
- register char *fmt;
-
- if (x == 0)
- return;
-
- code = GET_CODE (x);
-
- switch (code)
- {
- case CONST_INT:
- case CONST_DOUBLE:
- case LABEL_REF:
- case SYMBOL_REF:
- case CONST:
- case CODE_LABEL:
- case PC:
- case CC0:
- /* Get rid of the easy cases first. */
- return;
-
- case REG:
- {
- /* If the register dies in this insn, queue that note, and mark
- this register as needing to die. */
- /* This code is very similar to mark_used_1 (if set_p is false)
- and mark_set_1 (if set_p is true) in flow.c. */
-
- register int regno;
- int some_needed;
- int all_needed;
-
- if (set_p)
- return;
-
- regno = REGNO (x);
- all_needed = some_needed = REGNO_REG_SET_P (old_live_regs, regno);
- if (regno < FIRST_PSEUDO_REGISTER)
- {
- int n;
-
- n = HARD_REGNO_NREGS (regno, GET_MODE (x));
- while (--n > 0)
- {
- int needed = (REGNO_REG_SET_P (old_live_regs, regno + n));
- some_needed |= needed;
- all_needed &= needed;
- }
- }
-
- /* If it wasn't live before we started, then add a REG_DEAD note.
- We must check the previous lifetime info not the current info,
- because we may have to execute this code several times, e.g.
- once for a clobber (which doesn't add a note) and later
- for a use (which does add a note).
-
- Always make the register live. We must do this even if it was
- live before, because this may be an insn which sets and uses
- the same register, in which case the register has already been
- killed, so we must make it live again.
-
- Global registers are always live, and should never have a REG_DEAD
- note added for them, so none of the code below applies to them. */
-
- if (regno >= FIRST_PSEUDO_REGISTER || ! global_regs[regno])
- {
- /* Never add REG_DEAD notes for the FRAME_POINTER_REGNUM or the
- STACK_POINTER_REGNUM, since these are always considered to be
- live. Similarly for ARG_POINTER_REGNUM if it is fixed. */
- if (regno != FRAME_POINTER_REGNUM
-#if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
- && ! (regno == HARD_FRAME_POINTER_REGNUM)
-#endif
-#if ARG_POINTER_REGNUM != FRAME_POINTER_REGNUM
- && ! (regno == ARG_POINTER_REGNUM && fixed_regs[regno])
-#endif
- && regno != STACK_POINTER_REGNUM)
- {
- if (! all_needed && ! dead_or_set_p (insn, x))
- {
- /* Check for the case where the register dying partially
- overlaps the register set by this insn. */
- if (regno < FIRST_PSEUDO_REGISTER
- && HARD_REGNO_NREGS (regno, GET_MODE (x)) > 1)
- {
- int n = HARD_REGNO_NREGS (regno, GET_MODE (x));
- while (--n >= 0)
- some_needed |= dead_or_set_regno_p (insn, regno + n);
- }
-
- /* If none of the words in X is needed, make a REG_DEAD
- note. Otherwise, we must make partial REG_DEAD
- notes. */
- if (! some_needed)
- create_reg_dead_note (x, insn);
- else
- {
- int i;
-
- /* Don't make a REG_DEAD note for a part of a
- register that is set in the insn. */
- for (i = HARD_REGNO_NREGS (regno, GET_MODE (x)) - 1;
- i >= 0; i--)
- if (! REGNO_REG_SET_P (old_live_regs, regno+i)
- && ! dead_or_set_regno_p (insn, regno + i))
- create_reg_dead_note (gen_rtx_REG (reg_raw_mode[regno + i],
- regno + i),
- insn);
- }
- }
- }
-
- if (regno < FIRST_PSEUDO_REGISTER)
- {
- int j = HARD_REGNO_NREGS (regno, GET_MODE (x));
- while (--j >= 0)
- {
- SET_REGNO_REG_SET (bb_live_regs, regno + j);
- }
- }
- else
- {
- /* Recompute REG_BASIC_BLOCK as we update all the other
- dataflow information. */
- if (sched_reg_basic_block[regno] == REG_BLOCK_UNKNOWN)
- sched_reg_basic_block[regno] = current_block_num;
- else if (sched_reg_basic_block[regno] != current_block_num)
- sched_reg_basic_block[regno] = REG_BLOCK_GLOBAL;
-
- SET_REGNO_REG_SET (bb_live_regs, regno);
- }
- }
- return;
- }
-
- case MEM:
- /* Handle tail-recursive case. */
- attach_deaths (XEXP (x, 0), insn, 0);
- return;
-
- case SUBREG:
- attach_deaths (SUBREG_REG (x), insn,
- set_p && ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))
- <= UNITS_PER_WORD)
- || (GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))
- == GET_MODE_SIZE (GET_MODE ((x))))));
- return;
-
- case STRICT_LOW_PART:
- attach_deaths (XEXP (x, 0), insn, 0);
- return;
-
- case ZERO_EXTRACT:
- case SIGN_EXTRACT:
- attach_deaths (XEXP (x, 0), insn, 0);
- attach_deaths (XEXP (x, 1), insn, 0);
- attach_deaths (XEXP (x, 2), insn, 0);
- return;
-
- default:
- /* Other cases: walk the insn. */
- fmt = GET_RTX_FORMAT (code);
- for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
- {
- if (fmt[i] == 'e')
- attach_deaths (XEXP (x, i), insn, 0);
- else if (fmt[i] == 'E')
- for (j = 0; j < XVECLEN (x, i); j++)
- attach_deaths (XVECEXP (x, i, j), insn, 0);
- }
- }
-}
-
-/* After INSN has executed, add register death notes for each register
- that is dead after INSN. */
-
-static void
-attach_deaths_insn (insn)
- rtx insn;
-{
- rtx x = PATTERN (insn);
- register RTX_CODE code = GET_CODE (x);
- rtx link;
-
- if (code == SET)
+ /* Annotate the instruction with issue information -- TImode
+ indicates that the instruction is expected not to be able
+ to issue on the same cycle as the previous insn. A machine
+ may use this information to decide how the instruction should
+ be aligned. */
+ if (reload_completed && issue_rate > 1)
{
- attach_deaths (SET_SRC (x), insn, 0);
-
- /* A register might die here even if it is the destination, e.g.
- it is the target of a volatile read and is otherwise unused.
- Hence we must always call attach_deaths for the SET_DEST. */
- attach_deaths (SET_DEST (x), insn, 1);
+ PUT_MODE (insn, clock > last_clock_var ? TImode : VOIDmode);
+ last_clock_var = clock;
}
- else if (code == PARALLEL)
- {
- register int i;
- for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
- {
- code = GET_CODE (XVECEXP (x, 0, i));
- if (code == SET)
- {
- attach_deaths (SET_SRC (XVECEXP (x, 0, i)), insn, 0);
- attach_deaths (SET_DEST (XVECEXP (x, 0, i)), insn, 1);
- }
- /* Flow does not add REG_DEAD notes to registers that die in
- clobbers, so we can't either. */
- else if (code != CLOBBER)
- attach_deaths (XVECEXP (x, 0, i), insn, 0);
- }
- }
- /* If this is a CLOBBER, only add REG_DEAD notes to registers inside a
- MEM being clobbered, just like flow. */
- else if (code == CLOBBER && GET_CODE (XEXP (x, 0)) == MEM)
- attach_deaths (XEXP (XEXP (x, 0), 0), insn, 0);
- /* Otherwise don't add a death note to things being clobbered. */
- else if (code != CLOBBER)
- attach_deaths (x, insn, 0);
-
- /* Make death notes for things used in the called function. */
- if (GET_CODE (insn) == CALL_INSN)
- for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
- attach_deaths (XEXP (XEXP (link, 0), 0), insn,
- GET_CODE (XEXP (link, 0)) == CLOBBER);
+ return n_ready;
}
-/* functions for handlnig of notes */
+/* Functions for handling of notes. */
/* Delete notes beginning with INSN and put them in the chain
of notes ended by NOTE_LIST.
if (next)
PREV_INSN (next) = prev;
- /* Don't save away NOTE_INSN_SETJMPs, because they must remain
- immediately after the call they follow. We use a fake
- (REG_DEAD (const_int -1)) note to remember them.
- Likewise with NOTE_INSN_{LOOP,EHREGION}_{BEG, END}. */
+ /* See sched_analyze to see how these are handled. */
if (NOTE_LINE_NUMBER (insn) != NOTE_INSN_SETJMP
&& NOTE_LINE_NUMBER (insn) != NOTE_INSN_LOOP_BEG
&& NOTE_LINE_NUMBER (insn) != NOTE_INSN_LOOP_END
- && NOTE_LINE_NUMBER (insn) != NOTE_INSN_RANGE_START
+ && NOTE_LINE_NUMBER (insn) != NOTE_INSN_RANGE_BEG
&& NOTE_LINE_NUMBER (insn) != NOTE_INSN_RANGE_END
&& NOTE_LINE_NUMBER (insn) != NOTE_INSN_EH_REGION_BEG
&& NOTE_LINE_NUMBER (insn) != NOTE_INSN_EH_REGION_END)
/* Return the head and tail pointers of BB. */
HAIFA_INLINE static void
-get_block_head_tail (bb, headp, tailp)
- int bb;
+get_block_head_tail (b, headp, tailp)
+ int b;
rtx *headp;
rtx *tailp;
{
rtx head;
rtx tail;
- int b;
-
- b = BB_TO_BLOCK (bb);
/* HEAD and TAIL delimit the basic block being scheduled. */
- head = basic_block_head[b];
- tail = basic_block_end[b];
+ head = BLOCK_HEAD (b);
+ tail = BLOCK_END (b);
/* Don't include any notes or labels at the beginning of the
basic block, or notes at the ends of basic blocks. */
*tailp = tail;
}
-/* Delete line notes from bb. Save them so they can be later restored
- (in restore_line_notes ()). */
-
-static void
+HAIFA_INLINE static void
+get_bb_head_tail (bb, headp, tailp)
+ int bb;
+ rtx *headp;
+ rtx *tailp;
+{
+ get_block_head_tail (BB_TO_BLOCK (bb), headp, tailp);
+}
+
+/* Delete line notes from bb. Save them so they can be later restored
+ (in restore_line_notes ()). */
+
+static void
rm_line_notes (bb)
int bb;
{
rtx head;
rtx insn;
- get_block_head_tail (bb, &head, &tail);
+ get_bb_head_tail (bb, &head, &tail);
- if (head == tail
- && (GET_RTX_CLASS (GET_CODE (head)) != 'i'))
+ if (head == tail && (! INSN_P (head)))
return;
next_tail = NEXT_INSN (tail);
rtx line = line_note_head[BB_TO_BLOCK (bb)];
rtx insn;
- get_block_head_tail (bb, &head, &tail);
+ get_bb_head_tail (bb, &head, &tail);
next_tail = NEXT_INSN (tail);
- for (insn = basic_block_head[BB_TO_BLOCK (bb)];
+ for (insn = BLOCK_HEAD (BB_TO_BLOCK (bb));
insn != next_tail;
insn = NEXT_INSN (insn))
if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
b = BB_TO_BLOCK (bb);
- head = basic_block_head[b];
- next_tail = NEXT_INSN (basic_block_end[b]);
+ head = BLOCK_HEAD (b);
+ next_tail = NEXT_INSN (BLOCK_END (b));
/* Determine the current line-number. We want to know the current
line number of the first insn of the block here, in case it is
rtx next_tail;
rtx insn;
- if (head == tail
- && (GET_RTX_CLASS (GET_CODE (head)) != 'i'))
+ if (head == tail && (! INSN_P (head)))
return;
next_tail = NEXT_INSN (tail);
}
}
-/* Constructor for `sometimes' data structure. */
-
-static int
-new_sometimes_live (regs_sometimes_live, regno, sometimes_max)
- struct sometimes *regs_sometimes_live;
- int regno;
- int sometimes_max;
-{
- register struct sometimes *p;
-
- /* There should never be a register greater than max_regno here. If there
- is, it means that a define_split has created a new pseudo reg. This
- is not allowed, since there will not be flow info available for any
- new register, so catch the error here. */
- if (regno >= max_regno)
- abort ();
-
- p = ®s_sometimes_live[sometimes_max];
- p->regno = regno;
- p->live_length = 0;
- p->calls_crossed = 0;
- sometimes_max++;
- return sometimes_max;
-}
-
-/* Count lengths of all regs we are currently tracking,
- and find new registers no longer live. */
-
-static void
-finish_sometimes_live (regs_sometimes_live, sometimes_max)
- struct sometimes *regs_sometimes_live;
- int sometimes_max;
-{
- int i;
-
- for (i = 0; i < sometimes_max; i++)
- {
- register struct sometimes *p = ®s_sometimes_live[i];
- int regno = p->regno;
-
- sched_reg_live_length[regno] += p->live_length;
- sched_reg_n_calls_crossed[regno] += p->calls_crossed;
- }
-}
-
-/* functions for computation of registers live/usage info */
-
-/* It is assumed that prior to scheduling basic_block_live_at_start (b)
- contains the registers that are alive at the entry to b.
-
- Two passes follow: The first pass is performed before the scheduling
- of a region. It scans each block of the region forward, computing
- the set of registers alive at the end of the basic block and
- discard REG_DEAD notes (done by find_pre_sched_live ()).
-
- The second path is invoked after scheduling all region blocks.
- It scans each block of the region backward, a block being traversed
- only after its succesors in the region. When the set of registers
- live at the end of a basic block may be changed by the scheduling
- (this may happen for multiple blocks region), it is computed as
- the union of the registers live at the start of its succesors.
- The last-use information is updated by inserting REG_DEAD notes.
- (done by find_post_sched_live ()) */
+/* Functions for computation of registers live/usage info. */
-/* Scan all the insns to be scheduled, removing register death notes.
- Register death notes end up in DEAD_NOTES.
- Recreate the register life information for the end of this basic
- block. */
+/* Calculate INSN_REG_WEIGHT for all insns of a block. */
static void
-find_pre_sched_live (bb)
- int bb;
+find_insn_reg_weight (b)
+ int b;
{
rtx insn, next_tail, head, tail;
- int b = BB_TO_BLOCK (bb);
- get_block_head_tail (bb, &head, &tail);
- COPY_REG_SET (bb_live_regs, basic_block_live_at_start[b]);
+ get_block_head_tail (b, &head, &tail);
next_tail = NEXT_INSN (tail);
for (insn = head; insn != next_tail; insn = NEXT_INSN (insn))
{
- rtx prev, next, link;
int reg_weight = 0;
+ rtx x;
/* Handle register life information. */
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
- {
- /* See if the register gets born here. */
- /* We must check for registers being born before we check for
- registers dying. It is possible for a register to be born and
- die in the same insn, e.g. reading from a volatile memory
- location into an otherwise unused register. Such a register
- must be marked as dead after this insn. */
- if (GET_CODE (PATTERN (insn)) == SET
- || GET_CODE (PATTERN (insn)) == CLOBBER)
- {
- sched_note_set (PATTERN (insn), 0);
- reg_weight++;
- }
-
- else if (GET_CODE (PATTERN (insn)) == PARALLEL)
- {
- int j;
- for (j = XVECLEN (PATTERN (insn), 0) - 1; j >= 0; j--)
- if (GET_CODE (XVECEXP (PATTERN (insn), 0, j)) == SET
- || GET_CODE (XVECEXP (PATTERN (insn), 0, j)) == CLOBBER)
- {
- sched_note_set (XVECEXP (PATTERN (insn), 0, j), 0);
- reg_weight++;
- }
-
- /* ??? This code is obsolete and should be deleted. It
- is harmless though, so we will leave it in for now. */
- for (j = XVECLEN (PATTERN (insn), 0) - 1; j >= 0; j--)
- if (GET_CODE (XVECEXP (PATTERN (insn), 0, j)) == USE)
- sched_note_set (XVECEXP (PATTERN (insn), 0, j), 0);
- }
-
- /* Each call cobbers (makes live) all call-clobbered regs
- that are not global or fixed. Note that the function-value
- reg is a call_clobbered reg. */
- if (GET_CODE (insn) == CALL_INSN)
- {
- int j;
- for (j = 0; j < FIRST_PSEUDO_REGISTER; j++)
- if (call_used_regs[j] && !global_regs[j]
- && ! fixed_regs[j])
- {
- SET_REGNO_REG_SET (bb_live_regs, j);
- }
- }
-
- /* Need to know what registers this insn kills. */
- for (prev = 0, link = REG_NOTES (insn); link; link = next)
- {
- next = XEXP (link, 1);
- if ((REG_NOTE_KIND (link) == REG_DEAD
- || REG_NOTE_KIND (link) == REG_UNUSED)
- /* Verify that the REG_NOTE has a valid value. */
- && GET_CODE (XEXP (link, 0)) == REG)
- {
- register int regno = REGNO (XEXP (link, 0));
-
- reg_weight--;
-
- /* Only unlink REG_DEAD notes; leave REG_UNUSED notes
- alone. */
- if (REG_NOTE_KIND (link) == REG_DEAD)
- {
- if (prev)
- XEXP (prev, 1) = next;
- else
- REG_NOTES (insn) = next;
- XEXP (link, 1) = dead_notes;
- dead_notes = link;
- }
- else
- prev = link;
-
- if (regno < FIRST_PSEUDO_REGISTER)
- {
- int j = HARD_REGNO_NREGS (regno,
- GET_MODE (XEXP (link, 0)));
- while (--j >= 0)
- {
- CLEAR_REGNO_REG_SET (bb_live_regs, regno+j);
- }
- }
- else
- {
- CLEAR_REGNO_REG_SET (bb_live_regs, regno);
- }
- }
- else
- prev = link;
- }
- }
-
- INSN_REG_WEIGHT (insn) = reg_weight;
- }
-}
-
-/* Update register life and usage information for block bb
- after scheduling. Put register dead notes back in the code. */
-
-static void
-find_post_sched_live (bb)
- int bb;
-{
- int sometimes_max;
- int j, i;
- int b;
- rtx insn;
- rtx head, tail, prev_head, next_tail;
-
- register struct sometimes *regs_sometimes_live;
-
- b = BB_TO_BLOCK (bb);
-
- /* compute live regs at the end of bb as a function of its successors. */
- if (current_nr_blocks > 1)
- {
- int e;
- int first_edge;
-
- first_edge = e = OUT_EDGES (b);
- CLEAR_REG_SET (bb_live_regs);
-
- if (e)
- do
- {
- int b_succ;
-
- b_succ = TO_BLOCK (e);
- IOR_REG_SET (bb_live_regs, basic_block_live_at_start[b_succ]);
- e = NEXT_OUT (e);
- }
- while (e != first_edge);
- }
-
- get_block_head_tail (bb, &head, &tail);
- next_tail = NEXT_INSN (tail);
- prev_head = PREV_INSN (head);
-
- EXECUTE_IF_SET_IN_REG_SET (bb_live_regs, FIRST_PSEUDO_REGISTER, i,
- {
- sched_reg_basic_block[i] = REG_BLOCK_GLOBAL;
- });
-
- /* if the block is empty, same regs are alive at its end and its start.
- since this is not guaranteed after interblock scheduling, make sure they
- are truly identical. */
- if (NEXT_INSN (prev_head) == tail
- && (GET_RTX_CLASS (GET_CODE (tail)) != 'i'))
- {
- if (current_nr_blocks > 1)
- COPY_REG_SET (basic_block_live_at_start[b], bb_live_regs);
-
- return;
- }
-
- b = BB_TO_BLOCK (bb);
- current_block_num = b;
-
- /* Keep track of register lives. */
- old_live_regs = ALLOCA_REG_SET ();
- regs_sometimes_live
- = (struct sometimes *) alloca (max_regno * sizeof (struct sometimes));
- sometimes_max = 0;
-
- /* initiate "sometimes" data, starting with registers live at end */
- sometimes_max = 0;
- COPY_REG_SET (old_live_regs, bb_live_regs);
- EXECUTE_IF_SET_IN_REG_SET (bb_live_regs, 0, j,
- {
- sometimes_max
- = new_sometimes_live (regs_sometimes_live,
- j, sometimes_max);
- });
-
- /* scan insns back, computing regs live info */
- for (insn = tail; insn != prev_head; insn = PREV_INSN (insn))
- {
- /* First we kill registers set by this insn, and then we
- make registers used by this insn live. This is the opposite
- order used above because we are traversing the instructions
- backwards. */
-
- /* Strictly speaking, we should scan REG_UNUSED notes and make
- every register mentioned there live, however, we will just
- kill them again immediately below, so there doesn't seem to
- be any reason why we bother to do this. */
-
- /* See if this is the last notice we must take of a register. */
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
continue;
- if (GET_CODE (PATTERN (insn)) == SET
- || GET_CODE (PATTERN (insn)) == CLOBBER)
- sched_note_set (PATTERN (insn), 1);
- else if (GET_CODE (PATTERN (insn)) == PARALLEL)
+ /* Increment weight for each register born here. */
+ x = PATTERN (insn);
+ if ((GET_CODE (x) == SET || GET_CODE (x) == CLOBBER)
+ && register_operand (SET_DEST (x), VOIDmode))
+ reg_weight++;
+ else if (GET_CODE (x) == PARALLEL)
{
- for (j = XVECLEN (PATTERN (insn), 0) - 1; j >= 0; j--)
- if (GET_CODE (XVECEXP (PATTERN (insn), 0, j)) == SET
- || GET_CODE (XVECEXP (PATTERN (insn), 0, j)) == CLOBBER)
- sched_note_set (XVECEXP (PATTERN (insn), 0, j), 1);
+ int j;
+ for (j = XVECLEN (x, 0) - 1; j >= 0; j--)
+ {
+ x = XVECEXP (PATTERN (insn), 0, j);
+ if ((GET_CODE (x) == SET || GET_CODE (x) == CLOBBER)
+ && register_operand (SET_DEST (x), VOIDmode))
+ reg_weight++;
+ }
}
- /* This code keeps life analysis information up to date. */
- if (GET_CODE (insn) == CALL_INSN)
+ /* Decrement weight for each register that dies here. */
+ for (x = REG_NOTES (insn); x; x = XEXP (x, 1))
{
- register struct sometimes *p;
-
- /* A call kills all call used registers that are not
- global or fixed, except for those mentioned in the call
- pattern which will be made live again later. */
- for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
- if (call_used_regs[i] && ! global_regs[i]
- && ! fixed_regs[i])
- {
- CLEAR_REGNO_REG_SET (bb_live_regs, i);
- }
-
- /* Regs live at the time of a call instruction must not
- go in a register clobbered by calls. Record this for
- all regs now live. Note that insns which are born or
- die in a call do not cross a call, so this must be done
- after the killings (above) and before the births
- (below). */
- p = regs_sometimes_live;
- for (i = 0; i < sometimes_max; i++, p++)
- if (REGNO_REG_SET_P (bb_live_regs, p->regno))
- p->calls_crossed += 1;
+ if (REG_NOTE_KIND (x) == REG_DEAD
+ || REG_NOTE_KIND (x) == REG_UNUSED)
+ reg_weight--;
}
- /* Make every register used live, and add REG_DEAD notes for
- registers which were not live before we started. */
- attach_deaths_insn (insn);
-
- /* Find registers now made live by that instruction. */
- EXECUTE_IF_AND_COMPL_IN_REG_SET (bb_live_regs, old_live_regs, 0, j,
- {
- sometimes_max
- = new_sometimes_live (regs_sometimes_live,
- j, sometimes_max);
- });
- IOR_REG_SET (old_live_regs, bb_live_regs);
-
- /* Count lengths of all regs we are worrying about now,
- and handle registers no longer live. */
-
- for (i = 0; i < sometimes_max; i++)
- {
- register struct sometimes *p = ®s_sometimes_live[i];
- int regno = p->regno;
-
- p->live_length += 1;
-
- if (!REGNO_REG_SET_P (bb_live_regs, regno))
- {
- /* This is the end of one of this register's lifetime
- segments. Save the lifetime info collected so far,
- and clear its bit in the old_live_regs entry. */
- sched_reg_live_length[regno] += p->live_length;
- sched_reg_n_calls_crossed[regno] += p->calls_crossed;
- CLEAR_REGNO_REG_SET (old_live_regs, p->regno);
-
- /* Delete the reg_sometimes_live entry for this reg by
- copying the last entry over top of it. */
- *p = regs_sometimes_live[--sometimes_max];
- /* ...and decrement i so that this newly copied entry
- will be processed. */
- i--;
- }
- }
+ INSN_REG_WEIGHT (insn) = reg_weight;
}
-
- finish_sometimes_live (regs_sometimes_live, sometimes_max);
-
- /* In interblock scheduling, basic_block_live_at_start may have changed. */
- if (current_nr_blocks > 1)
- COPY_REG_SET (basic_block_live_at_start[b], bb_live_regs);
-
-
- FREE_REG_SET (old_live_regs);
-} /* find_post_sched_live */
-
-/* After scheduling the subroutine, restore information about uses of
- registers. */
-
-static void
-update_reg_usage ()
-{
- int regno;
-
- if (n_basic_blocks > 0)
- EXECUTE_IF_SET_IN_REG_SET (bb_live_regs, FIRST_PSEUDO_REGISTER, regno,
- {
- sched_reg_basic_block[regno]
- = REG_BLOCK_GLOBAL;
- });
-
- for (regno = 0; regno < max_regno; regno++)
- if (sched_reg_live_length[regno])
- {
- if (sched_verbose)
- {
- if (REG_LIVE_LENGTH (regno) > sched_reg_live_length[regno])
- fprintf (dump,
- ";; register %d life shortened from %d to %d\n",
- regno, REG_LIVE_LENGTH (regno),
- sched_reg_live_length[regno]);
- /* Negative values are special; don't overwrite the current
- reg_live_length value if it is negative. */
- else if (REG_LIVE_LENGTH (regno) < sched_reg_live_length[regno]
- && REG_LIVE_LENGTH (regno) >= 0)
- fprintf (dump,
- ";; register %d life extended from %d to %d\n",
- regno, REG_LIVE_LENGTH (regno),
- sched_reg_live_length[regno]);
-
- if (!REG_N_CALLS_CROSSED (regno)
- && sched_reg_n_calls_crossed[regno])
- fprintf (dump,
- ";; register %d now crosses calls\n", regno);
- else if (REG_N_CALLS_CROSSED (regno)
- && !sched_reg_n_calls_crossed[regno]
- && REG_BASIC_BLOCK (regno) != REG_BLOCK_GLOBAL)
- fprintf (dump,
- ";; register %d no longer crosses calls\n", regno);
-
- if (REG_BASIC_BLOCK (regno) != sched_reg_basic_block[regno]
- && sched_reg_basic_block[regno] != REG_BLOCK_UNKNOWN
- && REG_BASIC_BLOCK(regno) != REG_BLOCK_UNKNOWN)
- fprintf (dump,
- ";; register %d changed basic block from %d to %d\n",
- regno, REG_BASIC_BLOCK(regno),
- sched_reg_basic_block[regno]);
-
- }
- /* Negative values are special; don't overwrite the current
- reg_live_length value if it is negative. */
- if (REG_LIVE_LENGTH (regno) >= 0)
- REG_LIVE_LENGTH (regno) = sched_reg_live_length[regno];
-
- if (sched_reg_basic_block[regno] != REG_BLOCK_UNKNOWN
- && REG_BASIC_BLOCK(regno) != REG_BLOCK_UNKNOWN)
- REG_BASIC_BLOCK(regno) = sched_reg_basic_block[regno];
-
- /* We can't change the value of reg_n_calls_crossed to zero for
- pseudos which are live in more than one block.
-
- This is because combine might have made an optimization which
- invalidated basic_block_live_at_start and reg_n_calls_crossed,
- but it does not update them. If we update reg_n_calls_crossed
- here, the two variables are now inconsistent, and this might
- confuse the caller-save code into saving a register that doesn't
- need to be saved. This is only a problem when we zero calls
- crossed for a pseudo live in multiple basic blocks.
-
- Alternatively, we could try to correctly update basic block live
- at start here in sched, but that seems complicated.
-
- Note: it is possible that a global register became local, as result
- of interblock motion, but will remain marked as a global register. */
- if (sched_reg_n_calls_crossed[regno]
- || REG_BASIC_BLOCK (regno) != REG_BLOCK_GLOBAL)
- REG_N_CALLS_CROSSED (regno) = sched_reg_n_calls_crossed[regno];
-
- }
}
-/* Scheduling clock, modified in schedule_block() and queue_to_ready () */
+/* Scheduling clock, modified in schedule_block() and queue_to_ready (). */
static int clock_var;
/* Move insns that became ready to fire from queue to ready list. */
fprintf (dump, ";;\t\tQ-->Ready: insn %d: ", INSN_UID (insn));
if (sched_verbose >= 2 && INSN_BB (insn) != target_bb)
- fprintf (dump, "(b%d) ", INSN_BLOCK (insn));
+ fprintf (dump, "(b%d) ", BLOCK_NUM (insn));
ready[n_ready++] = insn;
if (sched_verbose >= 2)
fprintf (dump, ";;\t\tQ-->Ready: insn %d: ", INSN_UID (insn));
if (sched_verbose >= 2 && INSN_BB (insn) != target_bb)
- fprintf (dump, "(b%d) ", INSN_BLOCK (insn));
+ fprintf (dump, "(b%d) ", BLOCK_NUM (insn));
ready[n_ready++] = insn;
if (sched_verbose >= 2)
return n_ready;
}
-/* Print the ready list for debugging purposes. Callable from debugger. */
+/* Print the ready list for debugging purposes. Callable from debugger. */
static void
debug_ready_list (ready, n_ready)
{
fprintf (dump, " %d", INSN_UID (ready[i]));
if (current_nr_blocks > 1 && INSN_BB (ready[i]) != target_bb)
- fprintf (dump, "/b%d", INSN_BLOCK (ready[i]));
+ fprintf (dump, "/b%d", BLOCK_NUM (ready[i]));
}
fprintf (dump, "\n");
}
int n_vis_no_unit;
rtx vis_no_unit[10];
-/* Finds units that are in use in this fuction. Required only
+/* Finds units that are in use in this fuction. Required only
for visualization. */
static void
for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
{
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
continue;
unit = insn_unit (insn);
}
}
-/* Return the length of the visualization table */
+/* Return the length of the visualization table. */
static int
get_visual_tbl_length ()
int n, n1;
char *s;
- /* compute length of one field in line */
- s = (char *) alloca (INSN_LEN + 5);
+ /* Compute length of one field in line. */
+ s = (char *) alloca (INSN_LEN + 6);
sprintf (s, " %33s", "uname");
n1 = strlen (s);
- /* compute length of one line */
+ /* Compute length of one line. */
n = strlen (";; ");
n += n1;
for (unit = 0; unit < FUNCTION_UNITS_SIZE; unit++)
n += n1;
n += strlen ("\n") + 2;
- /* compute length of visualization string */
+ /* Compute length of visualization string. */
return (MAX_VISUAL_LINES * n);
}
-/* Init block visualization debugging info */
+/* Init block visualization debugging info. */
static void
init_block_visualization ()
n_vis_no_unit = 0;
}
-#define BUF_LEN 256
+#define BUF_LEN 2048
static char *
safe_concat (buf, cur, str)
char *buf;
char *cur;
- char *str;
+ const char *str;
{
- char *end = buf + BUF_LEN - 2; /* leave room for null */
+ char *end = buf + BUF_LEN - 2; /* Leave room for null. */
int c;
if (cur > end)
return cur;
}
-/* This recognizes rtx, I classified as expressions. These are always */
-/* represent some action on values or results of other expression, */
-/* that may be stored in objects representing values. */
+/* This recognizes rtx, I classified as expressions. These are always
+ represent some action on values or results of other expression, that
+ may be stored in objects representing values. */
static void
print_exp (buf, x, verbose)
int verbose;
{
char tmp[BUF_LEN];
- char *st[4];
+ const char *st[4];
char *cur = buf;
- char *fun = (char *)0;
- char *sep;
+ const char *fun = (char *)0;
+ const char *sep;
rtx op[4];
int i;
{
case PLUS:
op[0] = XEXP (x, 0);
- st[1] = "+";
- op[1] = XEXP (x, 1);
+ if (GET_CODE (XEXP (x, 1)) == CONST_INT
+ && INTVAL (XEXP (x, 1)) < 0)
+ {
+ st[1] = "-";
+ op[1] = GEN_INT (-INTVAL (XEXP (x, 1)));
+ }
+ else
+ {
+ st[1] = "+";
+ op[1] = XEXP (x, 1);
+ }
break;
case LO_SUM:
op[0] = XEXP (x, 0);
}
break;
default:
- /* if (verbose) debug_rtx (x); */
+ /* If (verbose) debug_rtx (x); */
st[0] = GET_RTX_NAME (GET_CODE (x));
break;
}
- /* Print this as a function? */
+ /* Print this as a function? */
if (fun)
{
cur = safe_concat (buf, cur, fun);
cur = safe_concat (buf, cur, ")");
} /* print_exp */
-/* Prints rtxes, i customly classified as values. They're constants, */
-/* registers, labels, symbols and memory accesses. */
+/* Prints rtxes, I customly classified as values. They're constants,
+ registers, labels, symbols and memory accesses. */
static void
print_value (buf, x, verbose)
switch (GET_CODE (x))
{
case CONST_INT:
- sprintf (t, "0x%lx", (long)INTVAL (x));
+ sprintf (t, HOST_WIDE_INT_PRINT_HEX, INTVAL (x));
cur = safe_concat (buf, cur, t);
break;
case CONST_DOUBLE:
}
} /* print_value */
-/* The next step in insn detalization, its pattern recognition */
+/* The next step in insn detalization, its pattern recognition. */
static void
print_pattern (buf, x, verbose)
print_value (t1, XEXP (x, 0), verbose);
sprintf (buf, "use %s", t1);
break;
+ case COND_EXEC:
+ print_value (t1, COND_EXEC_CODE (x), verbose);
+ print_value (t2, COND_EXEC_TEST (x), verbose);
+ sprintf (buf, "cond_exec %s %s", t1, t2);
+ break;
case PARALLEL:
{
int i;
/* This is the main function in rtl visualization mechanism. It
accepts an rtx and tries to recognize it as an insn, then prints it
- properly in human readable form, resembling assembler mnemonics. */
-/* For every insn it prints its UID and BB the insn belongs */
-/* too. (probably the last "option" should be extended somehow, since */
-/* it depends now on sched.c inner variables ...) */
+ properly in human readable form, resembling assembler mnemonics.
+ For every insn it prints its UID and BB the insn belongs too.
+ (Probably the last "option" should be extended somehow, since it
+ depends now on sched.c inner variables ...) */
static void
print_insn (buf, x, verbose)
}
} /* print_insn */
-void
-print_insn_chain (rtx_first)
- rtx rtx_first;
-{
- register rtx tmp_rtx;
- char str[BUF_LEN];
-
- strcpy (str, "(nil)\n");
- if (rtx_first != 0)
- switch (GET_CODE (rtx_first))
- {
- case INSN:
- case JUMP_INSN:
- case CALL_INSN:
- case NOTE:
- case CODE_LABEL:
- case BARRIER:
- for (tmp_rtx = rtx_first; tmp_rtx != NULL;
- tmp_rtx = NEXT_INSN (tmp_rtx))
- {
- print_insn (str, tmp_rtx, 0);
- printf ("%s\n", str);
- }
- break;
- default:
- print_insn (str, rtx_first, 0);
- printf ("%s\n", str);
- }
-} /* print_insn_chain */
-
-/* Print visualization debugging info */
+/* Print visualization debugging info. */
static void
print_block_visualization (b, s)
int b;
- char *s;
+ const char *s;
{
int unit, i;
- /* print header */
+ /* Print header. */
fprintf (dump, "\n;; ==================== scheduling visualization for block %d %s \n", b, s);
- /* Print names of units */
+ /* Print names of units. */
fprintf (dump, ";; %-8s", "clock");
for (unit = 0; unit < FUNCTION_UNITS_SIZE; unit++)
if (function_units[unit].bitmask & target_units)
fprintf (dump, " %-33s", "==============================");
fprintf (dump, " %-8s\n", "=======");
- /* Print insns in each cycle */
+ /* Print insns in each cycle. */
fprintf (dump, "%s\n", visual_tbl);
}
-/* Print insns in the 'no_unit' column of visualization */
+/* Print insns in the 'no_unit' column of visualization. */
static void
visualize_no_unit (insn)
{
int i, unit;
- /* if no more room, split table into two */
+ /* If no more room, split table into two. */
if (n_visual_lines >= MAX_VISUAL_LINES)
{
print_block_visualization (b, "(incomplete)");
int instance = unit + i * FUNCTION_UNITS_SIZE;
rtx insn = unit_last_insn[instance];
- /* print insns that still keep the unit busy */
+ /* Print insns that still keep the unit busy. */
if (insn &&
actual_hazard_this_instance (unit, instance, insn, clock, 0))
{
sprintf (visual_tbl + strlen (visual_tbl), " %-33s", "------------------------------");
}
- /* print insns that are not assigned to any unit */
+ /* Print insns that are not assigned to any unit. */
for (i = 0; i < n_vis_no_unit; i++)
sprintf (visual_tbl + strlen (visual_tbl), " %-8d",
INSN_UID (vis_no_unit[i]));
sprintf (visual_tbl + strlen (visual_tbl), "\n");
}
-/* Print stalled cycles */
+/* Print stalled cycles. */
static void
visualize_stall_cycles (b, stalls)
{
int i;
- /* if no more room, split table into two */
+ /* If no more room, split table into two. */
if (n_visual_lines >= MAX_VISUAL_LINES)
{
print_block_visualization (b, "(incomplete)");
sprintf (visual_tbl + strlen (visual_tbl), "\n");
}
-/* move_insn1: Remove INSN from insn chain, and link it after LAST insn */
+/* move_insn1: Remove INSN from insn chain, and link it after LAST insn. */
static rtx
move_insn1 (insn, last)
return insn;
}
-/* Search INSN for fake REG_DEAD note pairs for NOTE_INSN_SETJMP,
+/* Search INSN for REG_SAVE_NOTE note pairs for NOTE_INSN_SETJMP,
NOTE_INSN_{LOOP,EHREGION}_{BEG,END}; and convert them back into
- NOTEs. The REG_DEAD note following first one is contains the saved
- value for NOTE_BLOCK_NUMBER which is useful for
+ NOTEs. The REG_SAVE_NOTE note following first one is contains the
+ saved value for NOTE_BLOCK_NUMBER which is useful for
NOTE_INSN_EH_REGION_{BEG,END} NOTEs. LAST is the last instruction
output by the instruction scheduler. Return the new value of LAST. */
retval = last;
for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
{
- if (REG_NOTE_KIND (note) == REG_DEAD
- && GET_CODE (XEXP (note, 0)) == CONST_INT)
+ if (REG_NOTE_KIND (note) == REG_SAVE_NOTE)
{
- if (INTVAL (XEXP (note, 0)) == NOTE_INSN_SETJMP)
+ enum insn_note note_type = INTVAL (XEXP (note, 0));
+
+ if (note_type == NOTE_INSN_SETJMP)
{
- retval = emit_note_after (INTVAL (XEXP (note, 0)), insn);
+ retval = emit_note_after (NOTE_INSN_SETJMP, insn);
CONST_CALL_P (retval) = CONST_CALL_P (note);
remove_note (insn, note);
note = XEXP (note, 1);
}
+ else if (note_type == NOTE_INSN_RANGE_BEG
+ || note_type == NOTE_INSN_RANGE_END)
+ {
+ last = emit_note_before (note_type, last);
+ remove_note (insn, note);
+ note = XEXP (note, 1);
+ NOTE_RANGE_INFO (last) = XEXP (note, 0);
+ }
else
{
- last = emit_note_before (INTVAL (XEXP (note, 0)), last);
+ last = emit_note_before (note_type, last);
remove_note (insn, note);
note = XEXP (note, 1);
- NOTE_BLOCK_NUMBER (last) = INTVAL (XEXP (note, 0));
+ if (note_type == NOTE_INSN_EH_REGION_BEG
+ || note_type == NOTE_INSN_EH_REGION_END)
+ NOTE_EH_HANDLER (last) = INTVAL (XEXP (note, 0));
}
remove_note (insn, note);
}
/* Local variables. */
rtx insn, last;
rtx *ready;
- int i;
int n_ready = 0;
int can_issue_more;
- /* flow block of this bb */
+ /* Flow block of this bb. */
int b = BB_TO_BLOCK (bb);
/* target_n_insns == number of insns in b before scheduling starts.
sched_target_n_insns == how many of b's insns were scheduled.
- sched_n_insns == how many insns were scheduled in b */
+ sched_n_insns == how many insns were scheduled in b. */
int target_n_insns = 0;
int sched_target_n_insns = 0;
int sched_n_insns = 0;
#define NEED_TAIL 2
int new_needs;
- /* head/tail info for this block */
+ /* Head/tail info for this block. */
rtx prev_head;
rtx next_tail;
rtx head;
However, it was removed when it proved to be of marginal benefit
and caused problems because schedule_block and compute_forward_dependences
had different notions of what the "head" insn was. */
- get_block_head_tail (bb, &head, &tail);
-
- /* Interblock scheduling could have moved the original head insn from this
- block into a proceeding block. This may also cause schedule_block and
- compute_forward_dependences to have different notions of what the
- "head" insn was.
-
- If the interblock movement happened to make this block start with
- some notes (LOOP, EH or SETJMP) before the first real insn, then
- HEAD will have various special notes attached to it which must be
- removed so that we don't end up with extra copies of the notes. */
- if (GET_RTX_CLASS (GET_CODE (head)) == 'i')
+ get_bb_head_tail (bb, &head, &tail);
+
+ /* rm_other_notes only removes notes which are _inside_ the
+ block---that is, it won't remove notes before the first real insn
+ or after the last real insn of the block. So if the first insn
+ has a REG_SAVE_NOTE which would otherwise be emitted before the
+ insn, it is redundant with the note before the start of the
+ block, and so we have to take it out.
+
+ FIXME: Probably the same thing should be done with REG_SAVE_NOTEs
+ referencing NOTE_INSN_SETJMP at the end of the block. */
+ if (INSN_P (head))
{
rtx note;
for (note = REG_NOTES (head); note; note = XEXP (note, 1))
- if (REG_NOTE_KIND (note) == REG_DEAD
- && GET_CODE (XEXP (note, 0)) == CONST_INT)
- remove_note (head, note);
+ if (REG_NOTE_KIND (note) == REG_SAVE_NOTE)
+ {
+ if (INTVAL (XEXP (note, 0)) != NOTE_INSN_SETJMP)
+ {
+ remove_note (head, note);
+ note = XEXP (note, 1);
+ remove_note (head, note);
+ }
+ else
+ note = XEXP (note, 1);
+ }
}
next_tail = NEXT_INSN (tail);
/* If the only insn left is a NOTE or a CODE_LABEL, then there is no need
to schedule this block. */
- if (head == tail
- && (GET_RTX_CLASS (GET_CODE (head)) != 'i'))
+ if (head == tail && (! INSN_P (head)))
return (sched_n_insns);
- /* debug info */
+ /* Debug info. */
if (sched_verbose)
{
fprintf (dump, ";; ======================================================\n");
fprintf (dump,
";; -- basic block %d from %d to %d -- %s reload\n",
- b, INSN_UID (basic_block_head[b]),
- INSN_UID (basic_block_end[b]),
+ b, INSN_UID (BLOCK_HEAD (b)), INSN_UID (BLOCK_END (b)),
(reload_completed ? "after" : "before"));
fprintf (dump, ";; ======================================================\n");
fprintf (dump, "\n");
init_block_visualization ();
}
- /* remove remaining note insns from the block, save them in
+ /* Remove remaining note insns from the block, save them in
note_list. These notes are restored at the end of
schedule_block (). */
note_list = 0;
target_bb = bb;
- /* prepare current target block info */
+ /* Prepare current target block info. */
if (current_nr_blocks > 1)
{
- candidate_table = (candidate *) alloca (current_nr_blocks * sizeof (candidate));
+ candidate_table = (candidate *) xmalloc (current_nr_blocks
+ * sizeof (candidate));
bblst_last = 0;
/* ??? It is not clear why bblst_size is computed this way. The original
members) seems to be a reasonable solution. */
/* ??? Or perhaps there is a bug somewhere else in this file? */
bblst_size = (current_nr_blocks - bb) * rgn_nr_edges * 2;
- bblst_table = (int *) alloca (bblst_size * sizeof (int));
+ bblst_table = (int *) xmalloc (bblst_size * sizeof (int));
bitlst_table_last = 0;
bitlst_table_size = rgn_nr_edges;
- bitlst_table = (int *) alloca (rgn_nr_edges * sizeof (int));
+ bitlst_table = (int *) xmalloc (rgn_nr_edges * sizeof (int));
compute_trg_info (bb);
}
clear_units ();
- /* Allocate the ready list */
- ready = (rtx *) alloca ((rgn_n_insns + 1) * sizeof (rtx));
+ /* Allocate the ready list. */
+ ready = (rtx *) xmalloc ((rgn_n_insns + 1) * sizeof (rtx));
/* Print debugging information. */
if (sched_verbose >= 5)
{
rtx next;
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
continue;
next = NEXT_INSN (insn);
if (INSN_DEP_COUNT (insn) == 0
- && (SCHED_GROUP_P (next) == 0 || GET_RTX_CLASS (GET_CODE (next)) != 'i'))
+ && (SCHED_GROUP_P (next) == 0 || ! INSN_P (next)))
ready[n_ready++] = insn;
if (!(SCHED_GROUP_P (insn)))
target_n_insns++;
rtx src_next_tail;
rtx tail, head;
- get_block_head_tail (bb_src, &head, &tail);
+ get_bb_head_tail (bb_src, &head, &tail);
src_next_tail = NEXT_INSN (tail);
src_head = head;
- if (head == tail
- && (GET_RTX_CLASS (GET_CODE (head)) != 'i'))
+ if (head == tail && (! INSN_P (head)))
continue;
for (insn = src_head; insn != src_next_tail; insn = NEXT_INSN (insn))
{
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
continue;
if (!CANT_MOVE (insn)
|| (insn_issue_delay (insn) <= 3
&& check_live (insn, bb_src)
&& is_exception_free (insn, bb_src, target_bb))))
-
{
rtx next;
- next = NEXT_INSN (insn);
+ /* Note that we havn't squirrled away the notes for
+ blocks other than the current. So if this is a
+ speculative insn, NEXT might otherwise be a note. */
+ next = next_nonnote_insn (insn);
if (INSN_DEP_COUNT (insn) == 0
- && (SCHED_GROUP_P (next) == 0
- || GET_RTX_CLASS (GET_CODE (next)) != 'i'))
+ && (! next
+ || SCHED_GROUP_P (next) == 0
+ || ! INSN_P (next)))
ready[n_ready++] = insn;
}
}
MD_SCHED_INIT (dump, sched_verbose);
#endif
- /* no insns scheduled in this block yet */
+ /* No insns scheduled in this block yet. */
last_scheduled_insn = 0;
- /* Sort the ready list */
- SCHED_SORT (ready, n_ready);
-#ifdef MD_SCHED_REORDER
- MD_SCHED_REORDER (dump, sched_verbose, ready, n_ready);
-#endif
-
- if (sched_verbose >= 2)
- {
- fprintf (dump, ";;\t\tReady list initially: ");
- debug_ready_list (ready, n_ready);
- }
-
/* Q_SIZE is the total number of insns in the queue. */
q_ptr = 0;
q_size = 0;
- clock_var = 0;
+ last_clock_var = 0;
bzero ((char *) insn_queue, sizeof (insn_queue));
+ /* Start just before the beginning of time. */
+ clock_var = -1;
+
/* We start inserting insns after PREV_HEAD. */
last = prev_head;
/* Initialize INSN_QUEUE, LIST and NEW_NEEDS. */
- new_needs = (NEXT_INSN (prev_head) == basic_block_head[b]
+ new_needs = (NEXT_INSN (prev_head) == BLOCK_HEAD (b)
? NEED_HEAD : NEED_NOTHING);
- if (PREV_INSN (next_tail) == basic_block_end[b])
+ if (PREV_INSN (next_tail) == BLOCK_END (b))
new_needs |= NEED_TAIL;
- /* loop until all the insns in BB are scheduled. */
+ /* Loop until all the insns in BB are scheduled. */
while (sched_target_n_insns < target_n_insns)
{
- int b1;
-
clock_var++;
/* Add to the ready list all pending insns that can be issued now.
debug_ready_list (ready, n_ready);
}
- /* Sort the ready list. */
+ /* Sort the ready list based on priority. */
SCHED_SORT (ready, n_ready);
+
+ /* Allow the target to reorder the list, typically for
+ better instruction bundling. */
#ifdef MD_SCHED_REORDER
- MD_SCHED_REORDER (dump, sched_verbose, ready, n_ready);
+ MD_SCHED_REORDER (dump, sched_verbose, ready, n_ready, clock_var,
+ can_issue_more);
+#else
+ can_issue_more = issue_rate;
#endif
if (sched_verbose)
debug_ready_list (ready, n_ready);
}
- /* Issue insns from ready list.
- It is important to count down from n_ready, because n_ready may change
- as insns are issued. */
- can_issue_more = issue_rate;
- for (i = n_ready - 1; i >= 0 && can_issue_more; i--)
+ /* Issue insns from ready list. */
+ while (n_ready != 0 && can_issue_more)
{
- rtx insn = ready[i];
+ /* Select and remove the insn from the ready list. */
+ rtx insn = ready[--n_ready];
int cost = actual_hazard (insn_unit (insn), insn, clock_var, 0);
- if (cost > 1)
+ if (cost >= 1)
{
queue_insn (insn, cost);
- ready[i] = ready[--n_ready]; /* remove insn from ready list */
+ continue;
}
- else if (cost == 0)
+
+ /* An interblock motion? */
+ if (INSN_BB (insn) != target_bb)
{
- /* an interblock motion? */
- if (INSN_BB (insn) != target_bb)
- {
- rtx temp;
+ rtx temp;
+ basic_block b1;
- if (IS_SPECULATIVE_INSN (insn))
- {
+ if (IS_SPECULATIVE_INSN (insn))
+ {
+ if (!check_live (insn, INSN_BB (insn)))
+ continue;
+ update_live (insn, INSN_BB (insn));
- if (!check_live (insn, INSN_BB (insn)))
- {
- /* speculative motion, live check failed, remove
- insn from ready list */
- ready[i] = ready[--n_ready];
- continue;
- }
- update_live (insn, INSN_BB (insn));
+ /* For speculative load, mark insns fed by it. */
+ if (IS_LOAD_INSN (insn) || FED_BY_SPEC_LOAD (insn))
+ set_spec_fed (insn);
- /* for speculative load, mark insns fed by it. */
- if (IS_LOAD_INSN (insn) || FED_BY_SPEC_LOAD (insn))
- set_spec_fed (insn);
+ nr_spec++;
+ }
+ nr_inter++;
- nr_spec++;
- }
- nr_inter++;
+ /* Find the beginning of the scheduling group. */
+ /* ??? Ought to update basic block here, but later bits of
+ schedule_block assumes the original insn block is
+ still intact. */
- temp = insn;
- while (SCHED_GROUP_P (temp))
- temp = PREV_INSN (temp);
+ temp = insn;
+ while (SCHED_GROUP_P (temp))
+ temp = PREV_INSN (temp);
- /* Update source block boundaries. */
- b1 = INSN_BLOCK (temp);
- if (temp == basic_block_head[b1]
- && insn == basic_block_end[b1])
- {
- /* We moved all the insns in the basic block.
- Emit a note after the last insn and update the
- begin/end boundaries to point to the note. */
- emit_note_after (NOTE_INSN_DELETED, insn);
- basic_block_end[b1] = NEXT_INSN (insn);
- basic_block_head[b1] = NEXT_INSN (insn);
- }
- else if (insn == basic_block_end[b1])
- {
- /* We took insns from the end of the basic block,
- so update the end of block boundary so that it
- points to the first insn we did not move. */
- basic_block_end[b1] = PREV_INSN (temp);
- }
- else if (temp == basic_block_head[b1])
- {
- /* We took insns from the start of the basic block,
- so update the start of block boundary so that
- it points to the first insn we did not move. */
- basic_block_head[b1] = NEXT_INSN (insn);
- }
+ /* Update source block boundaries. */
+ b1 = BLOCK_FOR_INSN (temp);
+ if (temp == b1->head && insn == b1->end)
+ {
+ /* We moved all the insns in the basic block.
+ Emit a note after the last insn and update the
+ begin/end boundaries to point to the note. */
+ rtx note = emit_note_after (NOTE_INSN_DELETED, insn);
+ b1->head = note;
+ b1->end = note;
}
- else
+ else if (insn == b1->end)
+ {
+ /* We took insns from the end of the basic block,
+ so update the end of block boundary so that it
+ points to the first insn we did not move. */
+ b1->end = PREV_INSN (temp);
+ }
+ else if (temp == b1->head)
{
- /* in block motion */
- sched_target_n_insns++;
+ /* We took insns from the start of the basic block,
+ so update the start of block boundary so that
+ it points to the first insn we did not move. */
+ b1->head = NEXT_INSN (insn);
}
+ }
+ else
+ {
+ /* In block motion. */
+ sched_target_n_insns++;
+ }
- last_scheduled_insn = insn;
- last = move_insn (insn, last);
- sched_n_insns++;
+ last_scheduled_insn = insn;
+ last = move_insn (insn, last);
+ sched_n_insns++;
#ifdef MD_SCHED_VARIABLE_ISSUE
- MD_SCHED_VARIABLE_ISSUE (dump, sched_verbose, insn, can_issue_more);
+ MD_SCHED_VARIABLE_ISSUE (dump, sched_verbose, insn,
+ can_issue_more);
#else
- can_issue_more--;
+ can_issue_more--;
#endif
- n_ready = schedule_insn (insn, ready, n_ready, clock_var);
+ n_ready = schedule_insn (insn, ready, n_ready, clock_var);
- /* remove insn from ready list */
- ready[i] = ready[--n_ready];
-
- /* close this block after scheduling its jump */
- if (GET_CODE (last_scheduled_insn) == JUMP_INSN)
- break;
- }
+ /* Close this block after scheduling its jump. */
+ if (GET_CODE (last_scheduled_insn) == JUMP_INSN)
+ break;
}
- /* debug info */
+ /* Debug info. */
if (sched_verbose)
- {
- visualize_scheduled_insns (b, clock_var);
- }
+ visualize_scheduled_insns (b, clock_var);
}
- /* debug info */
+ /* Debug info. */
if (sched_verbose)
{
fprintf (dump, ";;\tReady list (final): ");
if (!flag_schedule_interblock && q_size != 0)
abort ();
- /* update head/tail boundaries. */
+ /* Update head/tail boundaries. */
head = NEXT_INSN (prev_head);
tail = last;
head = note_head;
}
- /* update target block boundaries. */
+ /* Update target block boundaries. */
if (new_needs & NEED_HEAD)
- basic_block_head[b] = head;
+ BLOCK_HEAD (b) = head;
if (new_needs & NEED_TAIL)
- basic_block_end[b] = tail;
+ BLOCK_END (b) = tail;
- /* debugging */
+ /* Debugging. */
if (sched_verbose)
{
fprintf (dump, ";; total time = %d\n;; new basic block head = %d\n",
- clock_var, INSN_UID (basic_block_head[b]));
+ clock_var, INSN_UID (BLOCK_HEAD (b)));
fprintf (dump, ";; new basic block end = %d\n\n",
- INSN_UID (basic_block_end[b]));
+ INSN_UID (BLOCK_END (b)));
+ }
+
+ /* Clean up. */
+ if (current_nr_blocks > 1)
+ {
+ free (candidate_table);
+ free (bblst_table);
+ free (bitlst_table);
}
+ free (ready);
return (sched_n_insns);
} /* schedule_block () */
\f
-/* print the bit-set of registers, S. callable from debugger */
+/* Print the bit-set of registers, S, callable from debugger. */
extern void
debug_reg_vector (s)
rtx next_tail;
enum reg_note dep_type;
- get_block_head_tail (bb, &head, &tail);
+ get_bb_head_tail (bb, &head, &tail);
next_tail = NEXT_INSN (tail);
for (insn = head; insn != next_tail; insn = NEXT_INSN (insn))
{
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
continue;
insn = group_leader (insn);
if (x != XEXP (link, 0))
continue;
- /* Ignore dependences upon deleted insn */
- if (GET_CODE (x) == NOTE || INSN_DELETED_P (x))
- continue;
- if (find_insn_list (insn, INSN_DEPEND (x)))
- continue;
+#ifdef ENABLE_CHECKING
+ /* If add_dependence is working properly there should never
+ be notes, deleted insns or duplicates in the backward
+ links. Thus we need not check for them here.
+
+ However, if we have enabled checking we might as well go
+ ahead and verify that add_dependence worked properly. */
+ if (GET_CODE (x) == NOTE
+ || INSN_DELETED_P (x)
+ || find_insn_list (insn, INSN_DEPEND (x)))
+ abort ();
+#endif
new_link = alloc_INSN_LIST (insn, INSN_DEPEND (x));
}
/* Initialize variables for region data dependence analysis.
- n_bbs is the number of region blocks */
+ n_bbs is the number of region blocks. */
-__inline static void
-init_rgn_data_dependences (n_bbs)
- int n_bbs;
+static void
+init_deps (deps)
+ struct deps *deps;
{
- int bb;
-
- /* variables for which one copy exists for each block */
- bzero ((char *) bb_pending_read_insns, n_bbs * sizeof (rtx));
- bzero ((char *) bb_pending_read_mems, n_bbs * sizeof (rtx));
- bzero ((char *) bb_pending_write_insns, n_bbs * sizeof (rtx));
- bzero ((char *) bb_pending_write_mems, n_bbs * sizeof (rtx));
- bzero ((char *) bb_pending_lists_length, n_bbs * sizeof (rtx));
- bzero ((char *) bb_last_pending_memory_flush, n_bbs * sizeof (rtx));
- bzero ((char *) bb_last_function_call, n_bbs * sizeof (rtx));
- bzero ((char *) bb_sched_before_next_call, n_bbs * sizeof (rtx));
-
- /* Create an insn here so that we can hang dependencies off of it later. */
- for (bb = 0; bb < n_bbs; bb++)
- {
- bb_sched_before_next_call[bb] =
- gen_rtx_INSN (VOIDmode, 0, NULL_RTX, NULL_RTX,
- NULL_RTX, 0, NULL_RTX, NULL_RTX);
- LOG_LINKS (bb_sched_before_next_call[bb]) = 0;
- }
+ int maxreg = max_reg_num ();
+ deps->reg_last_uses = (rtx *) xcalloc (maxreg, sizeof (rtx));
+ deps->reg_last_sets = (rtx *) xcalloc (maxreg, sizeof (rtx));
+ deps->reg_last_clobbers = (rtx *) xcalloc (maxreg, sizeof (rtx));
+
+ deps->pending_read_insns = 0;
+ deps->pending_read_mems = 0;
+ deps->pending_write_insns = 0;
+ deps->pending_write_mems = 0;
+ deps->pending_lists_length = 0;
+ deps->last_pending_memory_flush = 0;
+ deps->last_function_call = 0;
+ deps->in_post_call_group_p = 0;
+
+ deps->sched_before_next_call
+ = gen_rtx_INSN (VOIDmode, 0, NULL_RTX, NULL_RTX,
+ NULL_RTX, 0, NULL_RTX, NULL_RTX);
+ LOG_LINKS (deps->sched_before_next_call) = 0;
}
-/* Add dependences so that branches are scheduled to run last in their block */
+/* Add dependences so that branches are scheduled to run last in their
+ block. */
static void
add_branch_dependences (head, tail)
rtx head, tail;
{
-
rtx insn, last;
- /* For all branches, calls, uses, and cc0 setters, force them to remain
- in order at the end of the block by adding dependencies and giving
- the last a high priority. There may be notes present, and prev_head
- may also be a note.
+ /* For all branches, calls, uses, clobbers, and cc0 setters, force them
+ to remain in order at the end of the block by adding dependencies and
+ giving the last a high priority. There may be notes present, and
+ prev_head may also be a note.
Branches must obviously remain at the end. Calls should remain at the
end since moving them results in worse register allocation. Uses remain
at the end because they can't be moved away from their cc0 user. */
insn = tail;
last = 0;
- while (GET_CODE (insn) == CALL_INSN || GET_CODE (insn) == JUMP_INSN
+ while (GET_CODE (insn) == CALL_INSN
+ || GET_CODE (insn) == JUMP_INSN
|| (GET_CODE (insn) == INSN
&& (GET_CODE (PATTERN (insn)) == USE
+ || GET_CODE (PATTERN (insn)) == CLOBBER
#ifdef HAVE_cc0
|| sets_cc0_p (PATTERN (insn))
#endif
insn = PREV_INSN (insn);
}
- /* make sure these insns are scheduled last in their block */
+ /* Make sure these insns are scheduled last in their block. */
insn = last;
if (insn != 0)
while (insn != head)
if (INSN_REF_COUNT (insn) != 0)
continue;
- if (!find_insn_list (last, LOG_LINKS (insn)))
- add_dependence (last, insn, REG_DEP_ANTI);
+ add_dependence (last, insn, REG_DEP_ANTI);
INSN_REF_COUNT (insn) = 1;
/* Skip over insns that are part of a group. */
}
}
-/* Compute bacward dependences inside BB. In a multiple blocks region:
- (1) a bb is analyzed after its predecessors, and (2) the lists in
- effect at the end of bb (after analyzing for bb) are inherited by
- bb's successrs.
+/* After computing the dependencies for block BB, propagate the dependencies
+ found in TMP_DEPS to the successors of the block. MAX_REG is the number
+ of registers. */
+static void
+propagate_deps (bb, tmp_deps, max_reg)
+ int bb;
+ struct deps *tmp_deps;
+ int max_reg;
+{
+ int b = BB_TO_BLOCK (bb);
+ int e, first_edge;
+ int reg;
+ rtx link_insn, link_mem;
+ rtx u;
- Specifically for reg-reg data dependences, the block insns are
- scanned by sched_analyze () top-to-bottom. Two lists are
- naintained by sched_analyze (): reg_last_defs[] for register DEFs,
- and reg_last_uses[] for register USEs.
+ /* These lists should point to the right place, for correct
+ freeing later. */
+ bb_deps[bb].pending_read_insns = tmp_deps->pending_read_insns;
+ bb_deps[bb].pending_read_mems = tmp_deps->pending_read_mems;
+ bb_deps[bb].pending_write_insns = tmp_deps->pending_write_insns;
+ bb_deps[bb].pending_write_mems = tmp_deps->pending_write_mems;
- When analysis is completed for bb, we update for its successors:
- ; - DEFS[succ] = Union (DEFS [succ], DEFS [bb])
- ; - USES[succ] = Union (USES [succ], DEFS [bb])
+ /* bb's structures are inherited by its successors. */
+ first_edge = e = OUT_EDGES (b);
+ if (e <= 0)
+ return;
- The mechanism for computing mem-mem data dependence is very
- similar, and the result is interblock dependences in the region. */
+ do
+ {
+ rtx x;
+ int b_succ = TO_BLOCK (e);
+ int bb_succ = BLOCK_TO_BB (b_succ);
+ struct deps *succ_deps = bb_deps + bb_succ;
-static void
-compute_block_backward_dependences (bb)
- int bb;
-{
- int b;
- rtx x;
- rtx head, tail;
- int max_reg = max_reg_num ();
+ /* Only bbs "below" bb, in the same region, are interesting. */
+ if (CONTAINING_RGN (b) != CONTAINING_RGN (b_succ)
+ || bb_succ <= bb)
+ {
+ e = NEXT_OUT (e);
+ continue;
+ }
- b = BB_TO_BLOCK (bb);
+ for (reg = 0; reg < max_reg; reg++)
+ {
+ /* reg-last-uses lists are inherited by bb_succ. */
+ for (u = tmp_deps->reg_last_uses[reg]; u; u = XEXP (u, 1))
+ {
+ if (find_insn_list (XEXP (u, 0),
+ succ_deps->reg_last_uses[reg]))
+ continue;
- if (current_nr_blocks == 1)
- {
- reg_last_uses = (rtx *) alloca (max_reg * sizeof (rtx));
- reg_last_sets = (rtx *) alloca (max_reg * sizeof (rtx));
-
- bzero ((char *) reg_last_uses, max_reg * sizeof (rtx));
- bzero ((char *) reg_last_sets, max_reg * sizeof (rtx));
-
- pending_read_insns = 0;
- pending_read_mems = 0;
- pending_write_insns = 0;
- pending_write_mems = 0;
- pending_lists_length = 0;
- last_function_call = 0;
- last_pending_memory_flush = 0;
- sched_before_next_call
- = gen_rtx_INSN (VOIDmode, 0, NULL_RTX, NULL_RTX,
- NULL_RTX, 0, NULL_RTX, NULL_RTX);
- LOG_LINKS (sched_before_next_call) = 0;
- }
- else
- {
- reg_last_uses = bb_reg_last_uses[bb];
- reg_last_sets = bb_reg_last_sets[bb];
-
- pending_read_insns = bb_pending_read_insns[bb];
- pending_read_mems = bb_pending_read_mems[bb];
- pending_write_insns = bb_pending_write_insns[bb];
- pending_write_mems = bb_pending_write_mems[bb];
- pending_lists_length = bb_pending_lists_length[bb];
- last_function_call = bb_last_function_call[bb];
- last_pending_memory_flush = bb_last_pending_memory_flush[bb];
-
- sched_before_next_call = bb_sched_before_next_call[bb];
- }
+ succ_deps->reg_last_uses[reg]
+ = alloc_INSN_LIST (XEXP (u, 0),
+ succ_deps->reg_last_uses[reg]);
+ }
- /* do the analysis for this block */
- get_block_head_tail (bb, &head, &tail);
- sched_analyze (head, tail);
- add_branch_dependences (head, tail);
+ /* reg-last-defs lists are inherited by bb_succ. */
+ for (u = tmp_deps->reg_last_sets[reg]; u; u = XEXP (u, 1))
+ {
+ if (find_insn_list (XEXP (u, 0),
+ succ_deps->reg_last_sets[reg]))
+ continue;
- if (current_nr_blocks > 1)
- {
- int e, first_edge;
- int b_succ, bb_succ;
- int reg;
- rtx link_insn, link_mem;
- rtx u;
-
- /* these lists should point to the right place, for correct freeing later. */
- bb_pending_read_insns[bb] = pending_read_insns;
- bb_pending_read_mems[bb] = pending_read_mems;
- bb_pending_write_insns[bb] = pending_write_insns;
- bb_pending_write_mems[bb] = pending_write_mems;
-
- /* bb's structures are inherited by it's successors */
- first_edge = e = OUT_EDGES (b);
- if (e > 0)
- do
- {
- b_succ = TO_BLOCK (e);
- bb_succ = BLOCK_TO_BB (b_succ);
+ succ_deps->reg_last_sets[reg]
+ = alloc_INSN_LIST (XEXP (u, 0),
+ succ_deps->reg_last_sets[reg]);
+ }
- /* only bbs "below" bb, in the same region, are interesting */
- if (CONTAINING_RGN (b) != CONTAINING_RGN (b_succ)
- || bb_succ <= bb)
- {
- e = NEXT_OUT (e);
+ for (u = tmp_deps->reg_last_clobbers[reg]; u; u = XEXP (u, 1))
+ {
+ if (find_insn_list (XEXP (u, 0),
+ succ_deps->reg_last_clobbers[reg]))
continue;
- }
- for (reg = 0; reg < max_reg; reg++)
- {
+ succ_deps->reg_last_clobbers[reg]
+ = alloc_INSN_LIST (XEXP (u, 0),
+ succ_deps->reg_last_clobbers[reg]);
+ }
+ }
- /* reg-last-uses lists are inherited by bb_succ */
- for (u = reg_last_uses[reg]; u; u = XEXP (u, 1))
- {
- if (find_insn_list (XEXP (u, 0), (bb_reg_last_uses[bb_succ])[reg]))
- continue;
+ /* Mem read/write lists are inherited by bb_succ. */
+ link_insn = tmp_deps->pending_read_insns;
+ link_mem = tmp_deps->pending_read_mems;
+ while (link_insn)
+ {
+ if (!(find_insn_mem_list (XEXP (link_insn, 0),
+ XEXP (link_mem, 0),
+ succ_deps->pending_read_insns,
+ succ_deps->pending_read_mems)))
+ add_insn_mem_dependence (succ_deps, &succ_deps->pending_read_insns,
+ &succ_deps->pending_read_mems,
+ XEXP (link_insn, 0), XEXP (link_mem, 0));
+ link_insn = XEXP (link_insn, 1);
+ link_mem = XEXP (link_mem, 1);
+ }
- (bb_reg_last_uses[bb_succ])[reg]
- = alloc_INSN_LIST (XEXP (u, 0),
- (bb_reg_last_uses[bb_succ])[reg]);
- }
+ link_insn = tmp_deps->pending_write_insns;
+ link_mem = tmp_deps->pending_write_mems;
+ while (link_insn)
+ {
+ if (!(find_insn_mem_list (XEXP (link_insn, 0),
+ XEXP (link_mem, 0),
+ succ_deps->pending_write_insns,
+ succ_deps->pending_write_mems)))
+ add_insn_mem_dependence (succ_deps,
+ &succ_deps->pending_write_insns,
+ &succ_deps->pending_write_mems,
+ XEXP (link_insn, 0), XEXP (link_mem, 0));
+
+ link_insn = XEXP (link_insn, 1);
+ link_mem = XEXP (link_mem, 1);
+ }
- /* reg-last-defs lists are inherited by bb_succ */
- for (u = reg_last_sets[reg]; u; u = XEXP (u, 1))
- {
- if (find_insn_list (XEXP (u, 0), (bb_reg_last_sets[bb_succ])[reg]))
- continue;
+ /* last_function_call is inherited by bb_succ. */
+ for (u = tmp_deps->last_function_call; u; u = XEXP (u, 1))
+ {
+ if (find_insn_list (XEXP (u, 0),
+ succ_deps->last_function_call))
+ continue;
- (bb_reg_last_sets[bb_succ])[reg]
- = alloc_INSN_LIST (XEXP (u, 0),
- (bb_reg_last_sets[bb_succ])[reg]);
- }
- }
+ succ_deps->last_function_call
+ = alloc_INSN_LIST (XEXP (u, 0),
+ succ_deps->last_function_call);
+ }
- /* mem read/write lists are inherited by bb_succ */
- link_insn = pending_read_insns;
- link_mem = pending_read_mems;
- while (link_insn)
- {
- if (!(find_insn_mem_list (XEXP (link_insn, 0), XEXP (link_mem, 0),
- bb_pending_read_insns[bb_succ],
- bb_pending_read_mems[bb_succ])))
- add_insn_mem_dependence (&bb_pending_read_insns[bb_succ],
- &bb_pending_read_mems[bb_succ],
- XEXP (link_insn, 0), XEXP (link_mem, 0));
- link_insn = XEXP (link_insn, 1);
- link_mem = XEXP (link_mem, 1);
- }
+ /* last_pending_memory_flush is inherited by bb_succ. */
+ for (u = tmp_deps->last_pending_memory_flush; u; u = XEXP (u, 1))
+ {
+ if (find_insn_list (XEXP (u, 0),
+ succ_deps->last_pending_memory_flush))
+ continue;
- link_insn = pending_write_insns;
- link_mem = pending_write_mems;
- while (link_insn)
- {
- if (!(find_insn_mem_list (XEXP (link_insn, 0), XEXP (link_mem, 0),
- bb_pending_write_insns[bb_succ],
- bb_pending_write_mems[bb_succ])))
- add_insn_mem_dependence (&bb_pending_write_insns[bb_succ],
- &bb_pending_write_mems[bb_succ],
- XEXP (link_insn, 0), XEXP (link_mem, 0));
-
- link_insn = XEXP (link_insn, 1);
- link_mem = XEXP (link_mem, 1);
- }
+ succ_deps->last_pending_memory_flush
+ = alloc_INSN_LIST (XEXP (u, 0),
+ succ_deps->last_pending_memory_flush);
+ }
- /* last_function_call is inherited by bb_succ */
- for (u = last_function_call; u; u = XEXP (u, 1))
- {
- if (find_insn_list (XEXP (u, 0), bb_last_function_call[bb_succ]))
- continue;
+ /* sched_before_next_call is inherited by bb_succ. */
+ x = LOG_LINKS (tmp_deps->sched_before_next_call);
+ for (; x; x = XEXP (x, 1))
+ add_dependence (succ_deps->sched_before_next_call,
+ XEXP (x, 0), REG_DEP_ANTI);
- bb_last_function_call[bb_succ]
- = alloc_INSN_LIST (XEXP (u, 0),
- bb_last_function_call[bb_succ]);
- }
+ e = NEXT_OUT (e);
+ }
+ while (e != first_edge);
+}
- /* last_pending_memory_flush is inherited by bb_succ */
- for (u = last_pending_memory_flush; u; u = XEXP (u, 1))
- {
- if (find_insn_list (XEXP (u, 0), bb_last_pending_memory_flush[bb_succ]))
- continue;
+/* Compute backward dependences inside bb. In a multiple blocks region:
+ (1) a bb is analyzed after its predecessors, and (2) the lists in
+ effect at the end of bb (after analyzing for bb) are inherited by
+ bb's successrs.
- bb_last_pending_memory_flush[bb_succ]
- = alloc_INSN_LIST (XEXP (u, 0),
- bb_last_pending_memory_flush[bb_succ]);
- }
+ Specifically for reg-reg data dependences, the block insns are
+ scanned by sched_analyze () top-to-bottom. Two lists are
+ maintained by sched_analyze (): reg_last_sets[] for register DEFs,
+ and reg_last_uses[] for register USEs.
- /* sched_before_next_call is inherited by bb_succ */
- x = LOG_LINKS (sched_before_next_call);
- for (; x; x = XEXP (x, 1))
- add_dependence (bb_sched_before_next_call[bb_succ],
- XEXP (x, 0), REG_DEP_ANTI);
+ When analysis is completed for bb, we update for its successors:
+ ; - DEFS[succ] = Union (DEFS [succ], DEFS [bb])
+ ; - USES[succ] = Union (USES [succ], DEFS [bb])
- e = NEXT_OUT (e);
- }
- while (e != first_edge);
- }
+ The mechanism for computing mem-mem data dependence is very
+ similar, and the result is interblock dependences in the region. */
- /* Free up the INSN_LISTs
+static void
+compute_block_backward_dependences (bb)
+ int bb;
+{
+ int i;
+ rtx head, tail;
+ int max_reg = max_reg_num ();
+ struct deps tmp_deps;
+
+ tmp_deps = bb_deps[bb];
+
+ /* Do the analysis for this block. */
+ get_bb_head_tail (bb, &head, &tail);
+ sched_analyze (&tmp_deps, head, tail);
+ add_branch_dependences (head, tail);
+
+ if (current_nr_blocks > 1)
+ propagate_deps (bb, &tmp_deps, max_reg);
+
+ /* Free up the INSN_LISTs.
Note this loop is executed max_reg * nr_regions times. It's first
- implementation accounted for over 90% of the calls to free_list.
- The list was empty for the vast majority of those calls. On the PA,
- not calling free_list in those cases improves -O2 compile times by
+ implementation accounted for over 90% of the calls to free_INSN_LIST_list.
+ The list was empty for the vast majority of those calls. On the PA, not
+ calling free_INSN_LIST_list in those cases improves -O2 compile times by
3-5% on average. */
- for (b = 0; b < max_reg; ++b)
+ for (i = 0; i < max_reg; ++i)
{
- if (reg_last_sets[b])
- free_list (®_last_sets[b], &unused_insn_list);
- if (reg_last_uses[b])
- free_list (®_last_uses[b], &unused_insn_list);
+ if (tmp_deps.reg_last_clobbers[i])
+ free_INSN_LIST_list (&tmp_deps.reg_last_clobbers[i]);
+ if (tmp_deps.reg_last_sets[i])
+ free_INSN_LIST_list (&tmp_deps.reg_last_sets[i]);
+ if (tmp_deps.reg_last_uses[i])
+ free_INSN_LIST_list (&tmp_deps.reg_last_uses[i]);
}
/* Assert that we won't need bb_reg_last_* for this block anymore. */
- if (current_nr_blocks > 1)
- {
- bb_reg_last_uses[bb] = (rtx *) NULL_RTX;
- bb_reg_last_sets[bb] = (rtx *) NULL_RTX;
- }
+ free (bb_deps[bb].reg_last_uses);
+ free (bb_deps[bb].reg_last_sets);
+ free (bb_deps[bb].reg_last_clobbers);
+ bb_deps[bb].reg_last_uses = 0;
+ bb_deps[bb].reg_last_sets = 0;
+ bb_deps[bb].reg_last_clobbers = 0;
}
-/* Print dependences for debugging, callable from debugger */
+/* Print dependences for debugging, callable from debugger. */
void
debug_dependencies ()
rtx next_tail;
rtx insn;
- get_block_head_tail (bb, &head, &tail);
+ get_bb_head_tail (bb, &head, &tail);
next_tail = NEXT_INSN (tail);
fprintf (dump, "\n;; --- Region Dependences --- b %d bb %d \n",
BB_TO_BLOCK (bb), bb);
rtx link;
int unit, range;
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
{
int n;
fprintf (dump, ";; %6d ", INSN_UID (insn));
fprintf (dump, "\n");
}
-/* Set_priorities: compute priority of each insn in the block */
+/* Set_priorities: compute priority of each insn in the block. */
static int
set_priorities (bb)
rtx prev_head;
rtx head;
- get_block_head_tail (bb, &head, &tail);
+ get_bb_head_tail (bb, &head, &tail);
prev_head = PREV_INSN (head);
- if (head == tail
- && (GET_RTX_CLASS (GET_CODE (head)) != 'i'))
+ if (head == tail && (! INSN_P (head)))
return 0;
n_insn = 0;
return n_insn;
}
-/* Make each element of VECTOR point at an rtx-vector,
- taking the space for all those rtx-vectors from SPACE.
- SPACE is of type (rtx *), but it is really as long as NELTS rtx-vectors.
- BYTES_PER_ELT is the number of bytes in one rtx-vector.
- (this is the same as init_regset_vector () in flow.c) */
-
-static void
-init_rtx_vector (vector, space, nelts, bytes_per_elt)
- rtx **vector;
- rtx *space;
- int nelts;
- int bytes_per_elt;
-{
- register int i;
- register rtx *p = space;
-
- for (i = 0; i < nelts; i++)
- {
- vector[i] = p;
- p += bytes_per_elt / sizeof (*p);
- }
-}
-
/* Schedule a region. A region is either an inner loop, a loop-free
subroutine, or a single basic block. Each bb in the region is
scheduled after its flow predecessors. */
int bb;
int rgn_n_insns = 0;
int sched_rgn_n_insns = 0;
+ regset_head reg_pending_sets_head;
+ regset_head reg_pending_clobbers_head;
- /* set variables for the current region */
+ /* Set variables for the current region. */
current_nr_blocks = RGN_NR_BLOCKS (rgn);
current_blocks = RGN_BLOCKS (rgn);
- reg_pending_sets = ALLOCA_REG_SET ();
+ reg_pending_sets = INITIALIZE_REG_SET (reg_pending_sets_head);
+ reg_pending_clobbers = INITIALIZE_REG_SET (reg_pending_clobbers_head);
reg_pending_sets_all = 0;
- /* initializations for region data dependence analyisis */
- if (current_nr_blocks > 1)
- {
- rtx *space;
- int maxreg = max_reg_num ();
-
- bb_reg_last_uses = (rtx **) alloca (current_nr_blocks * sizeof (rtx *));
- space = (rtx *) alloca (current_nr_blocks * maxreg * sizeof (rtx));
- bzero ((char *) space, current_nr_blocks * maxreg * sizeof (rtx));
- init_rtx_vector (bb_reg_last_uses, space, current_nr_blocks, maxreg * sizeof (rtx *));
-
- bb_reg_last_sets = (rtx **) alloca (current_nr_blocks * sizeof (rtx *));
- space = (rtx *) alloca (current_nr_blocks * maxreg * sizeof (rtx));
- bzero ((char *) space, current_nr_blocks * maxreg * sizeof (rtx));
- init_rtx_vector (bb_reg_last_sets, space, current_nr_blocks, maxreg * sizeof (rtx *));
-
- bb_pending_read_insns = (rtx *) alloca (current_nr_blocks * sizeof (rtx));
- bb_pending_read_mems = (rtx *) alloca (current_nr_blocks * sizeof (rtx));
- bb_pending_write_insns = (rtx *) alloca (current_nr_blocks * sizeof (rtx));
- bb_pending_write_mems = (rtx *) alloca (current_nr_blocks * sizeof (rtx));
- bb_pending_lists_length = (int *) alloca (current_nr_blocks * sizeof (int));
- bb_last_pending_memory_flush = (rtx *) alloca (current_nr_blocks * sizeof (rtx));
- bb_last_function_call = (rtx *) alloca (current_nr_blocks * sizeof (rtx));
- bb_sched_before_next_call = (rtx *) alloca (current_nr_blocks * sizeof (rtx));
-
- init_rgn_data_dependences (current_nr_blocks);
- }
+ /* Initializations for region data dependence analyisis. */
+ bb_deps = (struct deps *) xmalloc (sizeof (struct deps) * current_nr_blocks);
+ for (bb = 0; bb < current_nr_blocks; bb++)
+ init_deps (bb_deps + bb);
- /* compute LOG_LINKS */
+ /* Compute LOG_LINKS. */
for (bb = 0; bb < current_nr_blocks; bb++)
compute_block_backward_dependences (bb);
- /* compute INSN_DEPEND */
+ /* Compute INSN_DEPEND. */
for (bb = current_nr_blocks - 1; bb >= 0; bb--)
compute_block_forward_dependences (bb);
- /* Delete line notes, compute live-regs at block end, and set priorities. */
- dead_notes = 0;
+ /* Delete line notes and set priorities. */
for (bb = 0; bb < current_nr_blocks; bb++)
{
- if (reload_completed == 0)
- find_pre_sched_live (bb);
-
if (write_symbols != NO_DEBUG)
{
save_line_notes (bb);
rgn_n_insns += set_priorities (bb);
}
- /* compute interblock info: probabilities, split-edges, dominators, etc. */
+ /* Compute interblock info: probabilities, split-edges, dominators, etc. */
if (current_nr_blocks > 1)
{
int i;
- prob = (float *) alloca ((current_nr_blocks) * sizeof (float));
+ prob = (float *) xmalloc ((current_nr_blocks) * sizeof (float));
bbset_size = current_nr_blocks / HOST_BITS_PER_WIDE_INT + 1;
- dom = (bbset *) alloca (current_nr_blocks * sizeof (bbset));
+ dom = (bbset *) xmalloc (current_nr_blocks * sizeof (bbset));
for (i = 0; i < current_nr_blocks; i++)
- {
- dom[i] = (bbset) alloca (bbset_size * sizeof (HOST_WIDE_INT));
- bzero ((char *) dom[i], bbset_size * sizeof (HOST_WIDE_INT));
- }
+ dom[i] = (bbset) xcalloc (bbset_size, sizeof (HOST_WIDE_INT));
- /* edge to bit */
+ /* Edge to bit. */
rgn_nr_edges = 0;
- edge_to_bit = (int *) alloca (nr_edges * sizeof (int));
+ edge_to_bit = (int *) xmalloc (nr_edges * sizeof (int));
for (i = 1; i < nr_edges; i++)
if (CONTAINING_RGN (FROM_BLOCK (i)) == rgn)
EDGE_TO_BIT (i) = rgn_nr_edges++;
- rgn_edges = (int *) alloca (rgn_nr_edges * sizeof (int));
+ rgn_edges = (int *) xmalloc (rgn_nr_edges * sizeof (int));
rgn_nr_edges = 0;
for (i = 1; i < nr_edges; i++)
if (CONTAINING_RGN (FROM_BLOCK (i)) == (rgn))
rgn_edges[rgn_nr_edges++] = i;
- /* split edges */
+ /* Split edges. */
edgeset_size = rgn_nr_edges / HOST_BITS_PER_WIDE_INT + 1;
- pot_split = (edgeset *) alloca (current_nr_blocks * sizeof (edgeset));
- ancestor_edges = (edgeset *) alloca (current_nr_blocks * sizeof (edgeset));
+ edgeset_bitsize = rgn_nr_edges;
+ pot_split = (edgeset *) xmalloc (current_nr_blocks * sizeof (edgeset));
+ ancestor_edges
+ = (edgeset *) xmalloc (current_nr_blocks * sizeof (edgeset));
for (i = 0; i < current_nr_blocks; i++)
{
pot_split[i] =
- (edgeset) alloca (edgeset_size * sizeof (HOST_WIDE_INT));
- bzero ((char *) pot_split[i],
- edgeset_size * sizeof (HOST_WIDE_INT));
+ (edgeset) xcalloc (edgeset_size, sizeof (HOST_WIDE_INT));
ancestor_edges[i] =
- (edgeset) alloca (edgeset_size * sizeof (HOST_WIDE_INT));
- bzero ((char *) ancestor_edges[i],
- edgeset_size * sizeof (HOST_WIDE_INT));
+ (edgeset) xcalloc (edgeset_size, sizeof (HOST_WIDE_INT));
}
- /* compute probabilities, dominators, split_edges */
+ /* Compute probabilities, dominators, split_edges. */
for (bb = 0; bb < current_nr_blocks; bb++)
compute_dom_prob_ps (bb);
}
- /* now we can schedule all blocks */
+ /* Now we can schedule all blocks. */
for (bb = 0; bb < current_nr_blocks; bb++)
- {
- sched_rgn_n_insns += schedule_block (bb, rgn_n_insns);
-
-#ifdef USE_C_ALLOCA
- alloca (0);
-#endif
- }
+ sched_rgn_n_insns += schedule_block (bb, rgn_n_insns);
- /* sanity check: verify that all region insns were scheduled */
+ /* Sanity check: verify that all region insns were scheduled. */
if (sched_rgn_n_insns != rgn_n_insns)
abort ();
- /* update register life and usage information */
- if (reload_completed == 0)
- {
- for (bb = current_nr_blocks - 1; bb >= 0; bb--)
- find_post_sched_live (bb);
-
- if (current_nr_blocks <= 1)
- /* Sanity check. There should be no REG_DEAD notes leftover at the end.
- In practice, this can occur as the result of bugs in flow, combine.c,
- and/or sched.c. The values of the REG_DEAD notes remaining are
- meaningless, because dead_notes is just used as a free list. */
- if (dead_notes != 0)
- abort ();
- }
-
- /* restore line notes. */
+ /* Restore line notes. */
if (write_symbols != NO_DEBUG)
{
for (bb = 0; bb < current_nr_blocks; bb++)
restore_line_notes (bb);
}
- /* Done with this region */
+ /* Done with this region. */
free_pending_lists ();
FREE_REG_SET (reg_pending_sets);
-}
-
-/* Subroutine of split_hard_reg_notes. Searches X for any reference to
- REGNO, returning the rtx of the reference found if any. Otherwise,
- returns 0. */
-
-static rtx
-regno_use_in (regno, x)
- int regno;
- rtx x;
-{
- register char *fmt;
- int i, j;
- rtx tem;
-
- if (GET_CODE (x) == REG && REGNO (x) == regno)
- return x;
-
- fmt = GET_RTX_FORMAT (GET_CODE (x));
- for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
- {
- if (fmt[i] == 'e')
- {
- if ((tem = regno_use_in (regno, XEXP (x, i))))
- return tem;
- }
- else if (fmt[i] == 'E')
- for (j = XVECLEN (x, i) - 1; j >= 0; j--)
- if ((tem = regno_use_in (regno, XVECEXP (x, i, j))))
- return tem;
- }
-
- return 0;
-}
-
-/* Subroutine of update_flow_info. Determines whether any new REG_NOTEs are
- needed for the hard register mentioned in the note. This can happen
- if the reference to the hard register in the original insn was split into
- several smaller hard register references in the split insns. */
-
-static void
-split_hard_reg_notes (note, first, last)
- rtx note, first, last;
-{
- rtx reg, temp, link;
- int n_regs, i, new_reg;
- rtx insn;
-
- /* Assume that this is a REG_DEAD note. */
- if (REG_NOTE_KIND (note) != REG_DEAD)
- abort ();
-
- reg = XEXP (note, 0);
-
- n_regs = HARD_REGNO_NREGS (REGNO (reg), GET_MODE (reg));
-
- for (i = 0; i < n_regs; i++)
- {
- new_reg = REGNO (reg) + i;
-
- /* Check for references to new_reg in the split insns. */
- for (insn = last;; insn = PREV_INSN (insn))
- {
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
- && (temp = regno_use_in (new_reg, PATTERN (insn))))
- {
- /* Create a new reg dead note ere. */
- link = alloc_EXPR_LIST (REG_DEAD, temp, REG_NOTES (insn));
- REG_NOTES (insn) = link;
-
- /* If killed multiple registers here, then add in the excess. */
- i += HARD_REGNO_NREGS (REGNO (temp), GET_MODE (temp)) - 1;
-
- break;
- }
- /* It isn't mentioned anywhere, so no new reg note is needed for
- this register. */
- if (insn == first)
- break;
- }
- }
-}
-
-/* Subroutine of update_flow_info. Determines whether a SET or CLOBBER in an
- insn created by splitting needs a REG_DEAD or REG_UNUSED note added. */
-
-static void
-new_insn_dead_notes (pat, insn, last, orig_insn)
- rtx pat, insn, last, orig_insn;
-{
- rtx dest, tem, set;
-
- /* PAT is either a CLOBBER or a SET here. */
- dest = XEXP (pat, 0);
-
- while (GET_CODE (dest) == ZERO_EXTRACT || GET_CODE (dest) == SUBREG
- || GET_CODE (dest) == STRICT_LOW_PART
- || GET_CODE (dest) == SIGN_EXTRACT)
- dest = XEXP (dest, 0);
-
- if (GET_CODE (dest) == REG)
- {
- /* If the original insn already used this register, we may not add new
- notes for it. One example for a split that needs this test is
- when a multi-word memory access with register-indirect addressing
- is split into multiple memory accesses with auto-increment and
- one adjusting add instruction for the address register. */
- if (reg_referenced_p (dest, PATTERN (orig_insn)))
- return;
- for (tem = last; tem != insn; tem = PREV_INSN (tem))
- {
- if (GET_RTX_CLASS (GET_CODE (tem)) == 'i'
- && reg_overlap_mentioned_p (dest, PATTERN (tem))
- && (set = single_set (tem)))
- {
- rtx tem_dest = SET_DEST (set);
-
- while (GET_CODE (tem_dest) == ZERO_EXTRACT
- || GET_CODE (tem_dest) == SUBREG
- || GET_CODE (tem_dest) == STRICT_LOW_PART
- || GET_CODE (tem_dest) == SIGN_EXTRACT)
- tem_dest = XEXP (tem_dest, 0);
-
- if (!rtx_equal_p (tem_dest, dest))
- {
- /* Use the same scheme as combine.c, don't put both REG_DEAD
- and REG_UNUSED notes on the same insn. */
- if (!find_regno_note (tem, REG_UNUSED, REGNO (dest))
- && !find_regno_note (tem, REG_DEAD, REGNO (dest)))
- {
- rtx note = alloc_EXPR_LIST (REG_DEAD, dest,
- REG_NOTES (tem));
- REG_NOTES (tem) = note;
- }
- /* The reg only dies in one insn, the last one that uses
- it. */
- break;
- }
- else if (reg_overlap_mentioned_p (dest, SET_SRC (set)))
- /* We found an instruction that both uses the register,
- and sets it, so no new REG_NOTE is needed for this set. */
- break;
- }
- }
- /* If this is a set, it must die somewhere, unless it is the dest of
- the original insn, and hence is live after the original insn. Abort
- if it isn't supposed to be live after the original insn.
-
- If this is a clobber, then just add a REG_UNUSED note. */
- if (tem == insn)
- {
- int live_after_orig_insn = 0;
- rtx pattern = PATTERN (orig_insn);
- int i;
-
- if (GET_CODE (pat) == CLOBBER)
- {
- rtx note = alloc_EXPR_LIST (REG_UNUSED, dest, REG_NOTES (insn));
- REG_NOTES (insn) = note;
- return;
- }
-
- /* The original insn could have multiple sets, so search the
- insn for all sets. */
- if (GET_CODE (pattern) == SET)
- {
- if (reg_overlap_mentioned_p (dest, SET_DEST (pattern)))
- live_after_orig_insn = 1;
- }
- else if (GET_CODE (pattern) == PARALLEL)
- {
- for (i = 0; i < XVECLEN (pattern, 0); i++)
- if (GET_CODE (XVECEXP (pattern, 0, i)) == SET
- && reg_overlap_mentioned_p (dest,
- SET_DEST (XVECEXP (pattern,
- 0, i))))
- live_after_orig_insn = 1;
- }
-
- if (!live_after_orig_insn)
- abort ();
- }
- }
-}
-
-/* Subroutine of update_flow_info. Update the value of reg_n_sets for all
- registers modified by X. INC is -1 if the containing insn is being deleted,
- and is 1 if the containing insn is a newly generated insn. */
-
-static void
-update_n_sets (x, inc)
- rtx x;
- int inc;
-{
- rtx dest = SET_DEST (x);
-
- while (GET_CODE (dest) == STRICT_LOW_PART || GET_CODE (dest) == SUBREG
- || GET_CODE (dest) == ZERO_EXTRACT || GET_CODE (dest) == SIGN_EXTRACT)
- dest = SUBREG_REG (dest);
-
- if (GET_CODE (dest) == REG)
- {
- int regno = REGNO (dest);
-
- if (regno < FIRST_PSEUDO_REGISTER)
- {
- register int i;
- int endregno = regno + HARD_REGNO_NREGS (regno, GET_MODE (dest));
-
- for (i = regno; i < endregno; i++)
- REG_N_SETS (i) += inc;
- }
- else
- REG_N_SETS (regno) += inc;
- }
-}
-
-/* Updates all flow-analysis related quantities (including REG_NOTES) for
- the insns from FIRST to LAST inclusive that were created by splitting
- ORIG_INSN. NOTES are the original REG_NOTES. */
-
-static void
-update_flow_info (notes, first, last, orig_insn)
- rtx notes;
- rtx first, last;
- rtx orig_insn;
-{
- rtx insn, note;
- rtx next;
- rtx orig_dest, temp;
- rtx set;
-
- /* Get and save the destination set by the original insn. */
-
- orig_dest = single_set (orig_insn);
- if (orig_dest)
- orig_dest = SET_DEST (orig_dest);
-
- /* Move REG_NOTES from the original insn to where they now belong. */
-
- for (note = notes; note; note = next)
- {
- next = XEXP (note, 1);
- switch (REG_NOTE_KIND (note))
- {
- case REG_DEAD:
- case REG_UNUSED:
- /* Move these notes from the original insn to the last new insn where
- the register is now set. */
-
- for (insn = last;; insn = PREV_INSN (insn))
- {
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
- && reg_mentioned_p (XEXP (note, 0), PATTERN (insn)))
- {
- /* If this note refers to a multiple word hard register, it
- may have been split into several smaller hard register
- references, so handle it specially. */
- temp = XEXP (note, 0);
- if (REG_NOTE_KIND (note) == REG_DEAD
- && GET_CODE (temp) == REG
- && REGNO (temp) < FIRST_PSEUDO_REGISTER
- && HARD_REGNO_NREGS (REGNO (temp), GET_MODE (temp)) > 1)
- split_hard_reg_notes (note, first, last);
- else
- {
- XEXP (note, 1) = REG_NOTES (insn);
- REG_NOTES (insn) = note;
- }
-
- /* Sometimes need to convert REG_UNUSED notes to REG_DEAD
- notes. */
- /* ??? This won't handle multiple word registers correctly,
- but should be good enough for now. */
- if (REG_NOTE_KIND (note) == REG_UNUSED
- && GET_CODE (XEXP (note, 0)) != SCRATCH
- && !dead_or_set_p (insn, XEXP (note, 0)))
- PUT_REG_NOTE_KIND (note, REG_DEAD);
-
- /* The reg only dies in one insn, the last one that uses
- it. */
- break;
- }
- /* It must die somewhere, fail it we couldn't find where it died.
-
- If this is a REG_UNUSED note, then it must be a temporary
- register that was not needed by this instantiation of the
- pattern, so we can safely ignore it. */
- if (insn == first)
- {
- /* After reload, REG_DEAD notes come sometimes an
- instruction after the register actually dies. */
- if (reload_completed && REG_NOTE_KIND (note) == REG_DEAD)
- {
- XEXP (note, 1) = REG_NOTES (insn);
- REG_NOTES (insn) = note;
- break;
- }
-
- if (REG_NOTE_KIND (note) != REG_UNUSED)
- abort ();
-
- break;
- }
- }
- break;
-
- case REG_WAS_0:
- /* If the insn that set the register to 0 was deleted, this
- note cannot be relied on any longer. The destination might
- even have been moved to memory.
- This was observed for SH4 with execute/920501-6.c compilation,
- -O2 -fomit-frame-pointer -finline-functions . */
- if (GET_CODE (XEXP (note, 0)) == NOTE
- || INSN_DELETED_P (XEXP (note, 0)))
- break;
- /* This note applies to the dest of the original insn. Find the
- first new insn that now has the same dest, and move the note
- there. */
-
- if (!orig_dest)
- abort ();
-
- for (insn = first;; insn = NEXT_INSN (insn))
- {
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
- && (temp = single_set (insn))
- && rtx_equal_p (SET_DEST (temp), orig_dest))
- {
- XEXP (note, 1) = REG_NOTES (insn);
- REG_NOTES (insn) = note;
- /* The reg is only zero before one insn, the first that
- uses it. */
- break;
- }
- /* If this note refers to a multiple word hard
- register, it may have been split into several smaller
- hard register references. We could split the notes,
- but simply dropping them is good enough. */
- if (GET_CODE (orig_dest) == REG
- && REGNO (orig_dest) < FIRST_PSEUDO_REGISTER
- && HARD_REGNO_NREGS (REGNO (orig_dest),
- GET_MODE (orig_dest)) > 1)
- break;
- /* It must be set somewhere, fail if we couldn't find where it
- was set. */
- if (insn == last)
- abort ();
- }
- break;
-
- case REG_EQUAL:
- case REG_EQUIV:
- /* A REG_EQUIV or REG_EQUAL note on an insn with more than one
- set is meaningless. Just drop the note. */
- if (!orig_dest)
- break;
-
- case REG_NO_CONFLICT:
- /* These notes apply to the dest of the original insn. Find the last
- new insn that now has the same dest, and move the note there. */
-
- if (!orig_dest)
- abort ();
-
- for (insn = last;; insn = PREV_INSN (insn))
- {
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
- && (temp = single_set (insn))
- && rtx_equal_p (SET_DEST (temp), orig_dest))
- {
- XEXP (note, 1) = REG_NOTES (insn);
- REG_NOTES (insn) = note;
- /* Only put this note on one of the new insns. */
- break;
- }
-
- /* The original dest must still be set someplace. Abort if we
- couldn't find it. */
- if (insn == first)
- {
- /* However, if this note refers to a multiple word hard
- register, it may have been split into several smaller
- hard register references. We could split the notes,
- but simply dropping them is good enough. */
- if (GET_CODE (orig_dest) == REG
- && REGNO (orig_dest) < FIRST_PSEUDO_REGISTER
- && HARD_REGNO_NREGS (REGNO (orig_dest),
- GET_MODE (orig_dest)) > 1)
- break;
- /* Likewise for multi-word memory references. */
- if (GET_CODE (orig_dest) == MEM
- && SIZE_FOR_MODE (orig_dest) > UNITS_PER_WORD)
- break;
- abort ();
- }
- }
- break;
-
- case REG_LIBCALL:
- /* Move a REG_LIBCALL note to the first insn created, and update
- the corresponding REG_RETVAL note. */
- XEXP (note, 1) = REG_NOTES (first);
- REG_NOTES (first) = note;
-
- insn = XEXP (note, 0);
- note = find_reg_note (insn, REG_RETVAL, NULL_RTX);
- if (note)
- XEXP (note, 0) = first;
- break;
-
- case REG_EXEC_COUNT:
- /* Move a REG_EXEC_COUNT note to the first insn created. */
- XEXP (note, 1) = REG_NOTES (first);
- REG_NOTES (first) = note;
- break;
-
- case REG_RETVAL:
- /* Move a REG_RETVAL note to the last insn created, and update
- the corresponding REG_LIBCALL note. */
- XEXP (note, 1) = REG_NOTES (last);
- REG_NOTES (last) = note;
-
- insn = XEXP (note, 0);
- note = find_reg_note (insn, REG_LIBCALL, NULL_RTX);
- if (note)
- XEXP (note, 0) = last;
- break;
-
- case REG_NONNEG:
- case REG_BR_PROB:
- /* This should be moved to whichever instruction is a JUMP_INSN. */
-
- for (insn = last;; insn = PREV_INSN (insn))
- {
- if (GET_CODE (insn) == JUMP_INSN)
- {
- XEXP (note, 1) = REG_NOTES (insn);
- REG_NOTES (insn) = note;
- /* Only put this note on one of the new insns. */
- break;
- }
- /* Fail if we couldn't find a JUMP_INSN. */
- if (insn == first)
- abort ();
- }
- break;
+ FREE_REG_SET (reg_pending_clobbers);
- case REG_INC:
- /* reload sometimes leaves obsolete REG_INC notes around. */
- if (reload_completed)
- break;
- /* This should be moved to whichever instruction now has the
- increment operation. */
- abort ();
-
- case REG_LABEL:
- /* Should be moved to the new insn(s) which use the label. */
- for (insn = first; insn != NEXT_INSN (last); insn = NEXT_INSN (insn))
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
- && reg_mentioned_p (XEXP (note, 0), PATTERN (insn)))
- {
- REG_NOTES (insn) = alloc_EXPR_LIST (REG_LABEL,
- XEXP (note, 0),
- REG_NOTES (insn));
- }
- break;
+ free (bb_deps);
- case REG_CC_SETTER:
- case REG_CC_USER:
- /* These two notes will never appear until after reorg, so we don't
- have to handle them here. */
- default:
- abort ();
- }
- }
-
- /* Each new insn created, except the last, has a new set. If the destination
- is a register, then this reg is now live across several insns, whereas
- previously the dest reg was born and died within the same insn. To
- reflect this, we now need a REG_DEAD note on the insn where this
- dest reg dies.
-
- Similarly, the new insns may have clobbers that need REG_UNUSED notes. */
-
- for (insn = first; insn != last; insn = NEXT_INSN (insn))
+ if (current_nr_blocks > 1)
{
- rtx pat;
int i;
- pat = PATTERN (insn);
- if (GET_CODE (pat) == SET || GET_CODE (pat) == CLOBBER)
- new_insn_dead_notes (pat, insn, last, orig_insn);
- else if (GET_CODE (pat) == PARALLEL)
- {
- for (i = 0; i < XVECLEN (pat, 0); i++)
- if (GET_CODE (XVECEXP (pat, 0, i)) == SET
- || GET_CODE (XVECEXP (pat, 0, i)) == CLOBBER)
- new_insn_dead_notes (XVECEXP (pat, 0, i), insn, last, orig_insn);
- }
- }
-
- /* If any insn, except the last, uses the register set by the last insn,
- then we need a new REG_DEAD note on that insn. In this case, there
- would not have been a REG_DEAD note for this register in the original
- insn because it was used and set within one insn. */
-
- set = single_set (last);
- if (set)
- {
- rtx dest = SET_DEST (set);
-
- while (GET_CODE (dest) == ZERO_EXTRACT || GET_CODE (dest) == SUBREG
- || GET_CODE (dest) == STRICT_LOW_PART
- || GET_CODE (dest) == SIGN_EXTRACT)
- dest = XEXP (dest, 0);
-
- if (GET_CODE (dest) == REG
- /* Global registers are always live, so the code below does not
- apply to them. */
- && (REGNO (dest) >= FIRST_PSEUDO_REGISTER
- || ! global_regs[REGNO (dest)]))
- {
- rtx stop_insn = PREV_INSN (first);
-
- /* If the last insn uses the register that it is setting, then
- we don't want to put a REG_DEAD note there. Search backwards
- to find the first insn that sets but does not use DEST. */
-
- insn = last;
- if (reg_overlap_mentioned_p (dest, SET_SRC (set)))
- {
- for (insn = PREV_INSN (insn); insn != first;
- insn = PREV_INSN (insn))
- {
- if ((set = single_set (insn))
- && reg_mentioned_p (dest, SET_DEST (set))
- && ! reg_overlap_mentioned_p (dest, SET_SRC (set)))
- break;
- }
- }
-
- /* Now find the first insn that uses but does not set DEST. */
-
- for (insn = PREV_INSN (insn); insn != stop_insn;
- insn = PREV_INSN (insn))
- {
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
- && reg_mentioned_p (dest, PATTERN (insn))
- && (set = single_set (insn)))
- {
- rtx insn_dest = SET_DEST (set);
-
- while (GET_CODE (insn_dest) == ZERO_EXTRACT
- || GET_CODE (insn_dest) == SUBREG
- || GET_CODE (insn_dest) == STRICT_LOW_PART
- || GET_CODE (insn_dest) == SIGN_EXTRACT)
- insn_dest = XEXP (insn_dest, 0);
-
- if (insn_dest != dest)
- {
- note = alloc_EXPR_LIST (REG_DEAD, dest, REG_NOTES (insn));
- REG_NOTES (insn) = note;
- /* The reg only dies in one insn, the last one
- that uses it. */
- break;
- }
- }
- }
- }
- }
-
- /* If the original dest is modifying a multiple register target, and the
- original instruction was split such that the original dest is now set
- by two or more SUBREG sets, then the split insns no longer kill the
- destination of the original insn.
-
- In this case, if there exists an instruction in the same basic block,
- before the split insn, which uses the original dest, and this use is
- killed by the original insn, then we must remove the REG_DEAD note on
- this insn, because it is now superfluous.
-
- This does not apply when a hard register gets split, because the code
- knows how to handle overlapping hard registers properly. */
- if (orig_dest && GET_CODE (orig_dest) == REG)
- {
- int found_orig_dest = 0;
- int found_split_dest = 0;
-
- for (insn = first;; insn = NEXT_INSN (insn))
- {
- rtx pat;
- int i;
-
- /* I'm not sure if this can happen, but let's be safe. */
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
- continue;
-
- pat = PATTERN (insn);
- i = GET_CODE (pat) == PARALLEL ? XVECLEN (pat, 0) : 0;
- set = pat;
-
- for (;;)
- {
- if (GET_CODE (set) == SET)
- {
- if (GET_CODE (SET_DEST (set)) == REG
- && REGNO (SET_DEST (set)) == REGNO (orig_dest))
- {
- found_orig_dest = 1;
- break;
- }
- else if (GET_CODE (SET_DEST (set)) == SUBREG
- && SUBREG_REG (SET_DEST (set)) == orig_dest)
- {
- found_split_dest = 1;
- break;
- }
- }
- if (--i < 0)
- break;
- set = XVECEXP (pat, 0, i);
- }
-
- if (insn == last)
- break;
- }
-
- if (found_split_dest)
- {
- /* Search backwards from FIRST, looking for the first insn that uses
- the original dest. Stop if we pass a CODE_LABEL or a JUMP_INSN.
- If we find an insn, and it has a REG_DEAD note, then delete the
- note. */
-
- for (insn = first; insn; insn = PREV_INSN (insn))
- {
- if (GET_CODE (insn) == CODE_LABEL
- || GET_CODE (insn) == JUMP_INSN)
- break;
- else if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
- && reg_mentioned_p (orig_dest, insn))
- {
- note = find_regno_note (insn, REG_DEAD, REGNO (orig_dest));
- if (note)
- remove_note (insn, note);
- }
- }
- }
- else if (!found_orig_dest)
+ free (prob);
+ for (i = 0; i < current_nr_blocks; ++i)
{
- /* This should never happen. */
- abort ();
+ free (dom[i]);
+ free (pot_split[i]);
+ free (ancestor_edges[i]);
}
- }
-
- /* Update reg_n_sets. This is necessary to prevent local alloc from
- converting REG_EQUAL notes to REG_EQUIV when splitting has modified
- a reg from set once to set multiple times. */
-
- {
- rtx x = PATTERN (orig_insn);
- RTX_CODE code = GET_CODE (x);
-
- if (code == SET || code == CLOBBER)
- update_n_sets (x, -1);
- else if (code == PARALLEL)
- {
- int i;
- for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
- {
- code = GET_CODE (XVECEXP (x, 0, i));
- if (code == SET || code == CLOBBER)
- update_n_sets (XVECEXP (x, 0, i), -1);
- }
- }
-
- for (insn = first;; insn = NEXT_INSN (insn))
- {
- x = PATTERN (insn);
- code = GET_CODE (x);
-
- if (code == SET || code == CLOBBER)
- update_n_sets (x, 1);
- else if (code == PARALLEL)
- {
- int i;
- for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
- {
- code = GET_CODE (XVECEXP (x, 0, i));
- if (code == SET || code == CLOBBER)
- update_n_sets (XVECEXP (x, 0, i), 1);
- }
- }
-
- if (insn == last)
- break;
- }
- }
-}
-
-/* Do the splitting of insns in the block b. */
-
-static void
-split_block_insns (b)
- int b;
-{
- rtx insn, next;
-
- for (insn = basic_block_head[b];; insn = next)
- {
- rtx set, last, first, notes;
-
- /* Can't use `next_real_insn' because that
- might go across CODE_LABELS and short-out basic blocks. */
- next = NEXT_INSN (insn);
- if (GET_CODE (insn) != INSN)
- {
- if (insn == basic_block_end[b])
- break;
-
- continue;
- }
-
- /* Don't split no-op move insns. These should silently disappear
- later in final. Splitting such insns would break the code
- that handles REG_NO_CONFLICT blocks. */
- set = single_set (insn);
- if (set && rtx_equal_p (SET_SRC (set), SET_DEST (set)))
- {
- if (insn == basic_block_end[b])
- break;
-
- /* Nops get in the way while scheduling, so delete them now if
- register allocation has already been done. It is too risky
- to try to do this before register allocation, and there are
- unlikely to be very many nops then anyways. */
- if (reload_completed)
- {
- PUT_CODE (insn, NOTE);
- NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
- NOTE_SOURCE_FILE (insn) = 0;
- }
-
- continue;
- }
-
- /* Split insns here to get max fine-grain parallelism. */
- first = PREV_INSN (insn);
- notes = REG_NOTES (insn);
- last = try_split (PATTERN (insn), insn, 1);
- if (last != insn)
- {
- /* try_split returns the NOTE that INSN became. */
- first = NEXT_INSN (first);
- update_flow_info (notes, first, last, insn);
-
- PUT_CODE (insn, NOTE);
- NOTE_SOURCE_FILE (insn) = 0;
- NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
- if (insn == basic_block_head[b])
- basic_block_head[b] = first;
- if (insn == basic_block_end[b])
- {
- basic_block_end[b] = last;
- break;
- }
- }
-
- if (insn == basic_block_end[b])
- break;
+ free (dom);
+ free (edge_to_bit);
+ free (rgn_edges);
+ free (pot_split);
+ free (ancestor_edges);
}
}
schedule_insns (dump_file)
FILE *dump_file;
{
-
+ int *deaths_in_region;
+ sbitmap blocks, large_region_blocks;
int max_uid;
int b;
rtx insn;
int rgn;
-
int luid;
+ int any_large_regions;
- /* disable speculative loads in their presence if cc0 defined */
+ /* Disable speculative loads in their presence if cc0 defined. */
#ifdef HAVE_cc0
flag_schedule_speculative_load = 0;
#endif
if (n_basic_blocks == 0)
return;
- /* set dump and sched_verbose for the desired debugging output. If no
- dump-file was specified, but -fsched-verbose-N (any N), print to stderr.
- For -fsched-verbose-N, N>=10, print everything to stderr. */
+ /* Set dump and sched_verbose for the desired debugging output. If no
+ dump-file was specified, but -fsched-verbose=N (any N), print to stderr.
+ For -fsched-verbose=N, N>=10, print everything to stderr. */
sched_verbose = sched_verbose_param;
if (sched_verbose_param == 0 && dump_file)
sched_verbose = 1;
nr_inter = 0;
nr_spec = 0;
- /* Initialize the unused_*_lists. We can't use the ones left over from
- the previous function, because gcc has freed that memory. We can use
- the ones left over from the first sched pass in the second pass however,
- so only clear them on the first sched pass. The first pass is before
- reload if flag_schedule_insns is set, otherwise it is afterwards. */
-
- if (reload_completed == 0 || !flag_schedule_insns)
- {
- unused_insn_list = 0;
- unused_expr_list = 0;
- }
-
- /* initialize issue_rate */
+ /* Initialize issue_rate. */
issue_rate = ISSUE_RATE;
- /* do the splitting first for all blocks */
- for (b = 0; b < n_basic_blocks; b++)
- split_block_insns (b);
-
- max_uid = (get_max_uid () + 1);
-
- cant_move = (char *) xmalloc (max_uid * sizeof (char));
- bzero ((char *) cant_move, max_uid * sizeof (char));
+ split_all_insns (1);
- fed_by_spec_load = (char *) xmalloc (max_uid * sizeof (char));
- bzero ((char *) fed_by_spec_load, max_uid * sizeof (char));
+ /* We use LUID 0 for the fake insn (UID 0) which holds dependencies for
+ pseudos which do not cross calls. */
+ max_uid = get_max_uid () + 1;
- is_load_insn = (char *) xmalloc (max_uid * sizeof (char));
- bzero ((char *) is_load_insn, max_uid * sizeof (char));
+ h_i_d = (struct haifa_insn_data *) xcalloc (max_uid, sizeof (*h_i_d));
- insn_orig_block = (int *) xmalloc (max_uid * sizeof (int));
- insn_luid = (int *) xmalloc (max_uid * sizeof (int));
-
- luid = 0;
+ h_i_d[0].luid = 0;
+ luid = 1;
for (b = 0; b < n_basic_blocks; b++)
- for (insn = basic_block_head[b];; insn = NEXT_INSN (insn))
+ for (insn = BLOCK_HEAD (b);; insn = NEXT_INSN (insn))
{
- INSN_BLOCK (insn) = b;
- INSN_LUID (insn) = luid++;
+ INSN_LUID (insn) = luid;
+
+ /* Increment the next luid, unless this is a note. We don't
+ really need separate IDs for notes and we don't want to
+ schedule differently depending on whether or not there are
+ line-number notes, i.e., depending on whether or not we're
+ generating debugging information. */
+ if (GET_CODE (insn) != NOTE)
+ ++luid;
- if (insn == basic_block_end[b])
+ if (insn == BLOCK_END (b))
break;
}
-
- /* after reload, remove inter-blocks dependences computed before reload. */
- if (reload_completed)
+
+ /* ?!? We could save some memory by computing a per-region luid mapping
+ which could reduce both the number of vectors in the cache and the size
+ of each vector. Instead we just avoid the cache entirely unless the
+ average number of instructions in a basic block is very high. See
+ the comment before the declaration of true_dependency_cache for
+ what we consider "very high". */
+ if (luid / n_basic_blocks > 100 * 5)
{
- int b;
- rtx insn;
-
- for (b = 0; b < n_basic_blocks; b++)
- for (insn = basic_block_head[b];; insn = NEXT_INSN (insn))
- {
- rtx link, prev;
-
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
- {
- prev = NULL_RTX;
- link = LOG_LINKS (insn);
- while (link)
- {
- rtx x = XEXP (link, 0);
-
- if (INSN_BLOCK (x) != b)
- {
- remove_dependence (insn, x);
- link = prev ? XEXP (prev, 1) : LOG_LINKS (insn);
- }
- else
- prev = link, link = XEXP (prev, 1);
- }
- }
-
- if (insn == basic_block_end[b])
- break;
- }
+ true_dependency_cache = sbitmap_vector_alloc (luid, luid);
+ sbitmap_vector_zero (true_dependency_cache, luid);
}
nr_regions = 0;
- rgn_table = (region *) alloca ((n_basic_blocks) * sizeof (region));
- rgn_bb_table = (int *) alloca ((n_basic_blocks) * sizeof (int));
- block_to_bb = (int *) alloca ((n_basic_blocks) * sizeof (int));
- containing_rgn = (int *) alloca ((n_basic_blocks) * sizeof (int));
+ rgn_table = (region *) xmalloc ((n_basic_blocks) * sizeof (region));
+ rgn_bb_table = (int *) xmalloc ((n_basic_blocks) * sizeof (int));
+ block_to_bb = (int *) xmalloc ((n_basic_blocks) * sizeof (int));
+ containing_rgn = (int *) xmalloc ((n_basic_blocks) * sizeof (int));
- /* compute regions for scheduling */
+ blocks = sbitmap_alloc (n_basic_blocks);
+ large_region_blocks = sbitmap_alloc (n_basic_blocks);
+
+ compute_bb_for_insn (max_uid);
+
+ /* Compute regions for scheduling. */
if (reload_completed
|| n_basic_blocks == 1
|| !flag_schedule_interblock)
}
else
{
- /* verify that a 'good' control flow graph can be built */
+ /* Verify that a 'good' control flow graph can be built. */
if (is_cfg_nonregular ())
{
find_single_block_region ();
}
else
{
- int_list_ptr *s_preds, *s_succs;
- int *num_preds, *num_succs;
- sbitmap *dom, *pdom;
-
- s_preds = (int_list_ptr *) alloca (n_basic_blocks
- * sizeof (int_list_ptr));
- s_succs = (int_list_ptr *) alloca (n_basic_blocks
- * sizeof (int_list_ptr));
- num_preds = (int *) alloca (n_basic_blocks * sizeof (int));
- num_succs = (int *) alloca (n_basic_blocks * sizeof (int));
+ sbitmap *dom;
+ struct edge_list *edge_list;
+
dom = sbitmap_vector_alloc (n_basic_blocks, n_basic_blocks);
- pdom = sbitmap_vector_alloc (n_basic_blocks, n_basic_blocks);
/* The scheduler runs after flow; therefore, we can't blindly call
back into find_basic_blocks since doing so could invalidate the
- info in basic_block_live_at_start.
+ info in global_live_at_start.
Consider a block consisting entirely of dead stores; after life
analysis it would be a block of NOTE_INSN_DELETED notes. If
We could (should?) recompute register live information. Doing
so may even be beneficial. */
+ edge_list = create_edge_list ();
- compute_preds_succs (s_preds, s_succs, num_preds, num_succs);
-
- /* Compute the dominators and post dominators. We don't currently use
- post dominators, but we should for speculative motion analysis. */
- compute_dominators (dom, pdom, s_preds, s_succs);
+ /* Compute the dominators and post dominators. We don't
+ currently use post dominators, but we should for
+ speculative motion analysis. */
+ compute_flow_dominators (dom, NULL);
/* build_control_flow will return nonzero if it detects unreachable
blocks or any other irregularity with the cfg which prevents
cross block scheduling. */
- if (build_control_flow (s_preds, s_succs, num_preds, num_succs) != 0)
+ if (build_control_flow (edge_list) != 0)
find_single_block_region ();
else
- find_rgns (s_preds, s_succs, num_preds, num_succs, dom);
+ find_rgns (edge_list, dom);
if (sched_verbose >= 3)
debug_regions ();
+ /* We are done with flow's edge list. */
+ free_edge_list (edge_list);
+
/* For now. This will move as more and more of haifa is converted
- to using the cfg code in flow.c */
- free_bb_mem ();
+ to using the cfg code in flow.c. */
free (dom);
- free (pdom);
}
}
- /* Allocate data for this pass. See comments, above,
- for what these vectors do.
-
- We use xmalloc instead of alloca, because max_uid can be very large
- when there is a lot of function inlining. If we used alloca, we could
- exceed stack limits on some hosts for some inputs. */
- insn_priority = (int *) xmalloc (max_uid * sizeof (int));
- insn_reg_weight = (int *) xmalloc (max_uid * sizeof (int));
- insn_tick = (int *) xmalloc (max_uid * sizeof (int));
- insn_costs = (short *) xmalloc (max_uid * sizeof (short));
- insn_units = (short *) xmalloc (max_uid * sizeof (short));
- insn_blockage = (unsigned int *) xmalloc (max_uid * sizeof (unsigned int));
- insn_ref_count = (int *) xmalloc (max_uid * sizeof (int));
-
- /* Allocate for forward dependencies */
- insn_dep_count = (int *) xmalloc (max_uid * sizeof (int));
- insn_depend = (rtx *) xmalloc (max_uid * sizeof (rtx));
-
- if (reload_completed == 0)
- {
- int i;
+ deaths_in_region = (int *) xmalloc (sizeof (int) * nr_regions);
- sched_reg_n_calls_crossed = (int *) alloca (max_regno * sizeof (int));
- sched_reg_live_length = (int *) alloca (max_regno * sizeof (int));
- sched_reg_basic_block = (int *) alloca (max_regno * sizeof (int));
- bb_live_regs = ALLOCA_REG_SET ();
- bzero ((char *) sched_reg_n_calls_crossed, max_regno * sizeof (int));
- bzero ((char *) sched_reg_live_length, max_regno * sizeof (int));
-
- for (i = 0; i < max_regno; i++)
- sched_reg_basic_block[i] = REG_BLOCK_UNKNOWN;
- }
- else
- {
- sched_reg_n_calls_crossed = 0;
- sched_reg_live_length = 0;
- bb_live_regs = 0;
- }
init_alias_analysis ();
if (write_symbols != NO_DEBUG)
{
rtx line;
- line_note = (rtx *) xmalloc (max_uid * sizeof (rtx));
- bzero ((char *) line_note, max_uid * sizeof (rtx));
- line_note_head = (rtx *) alloca (n_basic_blocks * sizeof (rtx));
- bzero ((char *) line_note_head, n_basic_blocks * sizeof (rtx));
+ line_note_head = (rtx *) xcalloc (n_basic_blocks, sizeof (rtx));
/* Save-line-note-head:
Determine the line-number at the start of each basic block.
determine the correct line number for the first insn of the block. */
for (b = 0; b < n_basic_blocks; b++)
- for (line = basic_block_head[b]; line; line = PREV_INSN (line))
+ for (line = BLOCK_HEAD (b); line; line = PREV_INSN (line))
if (GET_CODE (line) == NOTE && NOTE_LINE_NUMBER (line) > 0)
{
line_note_head[b] = line;
}
}
- bzero ((char *) insn_priority, max_uid * sizeof (int));
- bzero ((char *) insn_reg_weight, max_uid * sizeof (int));
- bzero ((char *) insn_tick, max_uid * sizeof (int));
- bzero ((char *) insn_costs, max_uid * sizeof (short));
- bzero ((char *) insn_units, max_uid * sizeof (short));
- bzero ((char *) insn_blockage, max_uid * sizeof (unsigned int));
- bzero ((char *) insn_ref_count, max_uid * sizeof (int));
-
- /* Initialize for forward dependencies */
- bzero ((char *) insn_depend, max_uid * sizeof (rtx));
- bzero ((char *) insn_dep_count, max_uid * sizeof (int));
-
- /* Find units used in this fuction, for visualization */
+ /* Find units used in this fuction, for visualization. */
if (sched_verbose)
init_target_units ();
/* ??? Add a NOTE after the last insn of the last basic block. It is not
known why this is done. */
- insn = basic_block_end[n_basic_blocks - 1];
+ insn = BLOCK_END (n_basic_blocks - 1);
if (NEXT_INSN (insn) == 0
|| (GET_CODE (insn) != NOTE
&& GET_CODE (insn) != CODE_LABEL
- /* Don't emit a NOTE if it would end up between an unconditional
- jump and a BARRIER. */
+ /* Don't emit a NOTE if it would end up between an unconditional
+ jump and a BARRIER. */
&& !(GET_CODE (insn) == JUMP_INSN
&& GET_CODE (NEXT_INSN (insn)) == BARRIER)))
- emit_note_after (NOTE_INSN_DELETED, basic_block_end[n_basic_blocks - 1]);
+ emit_note_after (NOTE_INSN_DELETED, BLOCK_END (n_basic_blocks - 1));
+
+ /* Compute INSN_REG_WEIGHT for all blocks. We must do this before
+ removing death notes. */
+ for (b = n_basic_blocks - 1; b >= 0; b--)
+ find_insn_reg_weight (b);
- /* Schedule every region in the subroutine */
+ /* Remove all death notes from the subroutine. */
for (rgn = 0; rgn < nr_regions; rgn++)
{
- schedule_region (rgn);
+ 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);
+ }
+
+ /* Schedule every region in the subroutine. */
+ for (rgn = 0; rgn < nr_regions; rgn++)
+ schedule_region (rgn);
+
+ /* Update life analysis for the subroutine. Do single block regions
+ first so that we can verify that live_at_start didn't change. Then
+ do all other blocks. */
+ /* ??? There is an outside possibility that update_life_info, or more
+ to the point propagate_block, could get called with non-zero flags
+ more than once for one basic block. This would be kinda bad if it
+ were to happen, since REG_INFO would be accumulated twice for the
+ block, and we'd have twice the REG_DEAD notes.
+
+ I'm fairly certain that this _shouldn't_ happen, since I don't think
+ that live_at_start should change at region heads. Not sure what the
+ best way to test for this kind of thing... */
+
+ allocate_reg_life_data ();
+ compute_bb_for_insn (max_uid);
-#ifdef USE_C_ALLOCA
- alloca (0);
+ any_large_regions = 0;
+ sbitmap_ones (large_region_blocks);
+
+ 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
+ }
+
+ if (any_large_regions)
+ {
+ update_life_info (large_region_blocks, UPDATE_LIFE_GLOBAL,
+ PROP_DEATH_NOTES | PROP_REG_INFO);
}
/* Reposition the prologue and epilogue notes in case we moved the
if (reload_completed)
reposition_prologue_and_epilogue_notes (get_insns ());
- /* delete redundant line notes. */
+ /* Delete redundant line notes. */
if (write_symbols != NO_DEBUG)
rm_redundant_line_notes ();
- /* Update information about uses of registers in the subroutine. */
- if (reload_completed == 0)
- update_reg_usage ();
-
if (sched_verbose)
{
if (reload_completed == 0 && flag_schedule_interblock)
fprintf (dump, "\n\n");
}
- free (cant_move);
- free (fed_by_spec_load);
- free (is_load_insn);
- free (insn_orig_block);
- free (insn_luid);
+ /* Clean up. */
+ end_alias_analysis ();
- free (insn_priority);
- free (insn_reg_weight);
- free (insn_tick);
- free (insn_costs);
- free (insn_units);
- free (insn_blockage);
- free (insn_ref_count);
+ if (true_dependency_cache)
+ {
+ free (true_dependency_cache);
+ true_dependency_cache = NULL;
+ }
+ free (rgn_table);
+ free (rgn_bb_table);
+ free (block_to_bb);
+ free (containing_rgn);
- free (insn_dep_count);
- free (insn_depend);
+ free (h_i_d);
if (write_symbols != NO_DEBUG)
- free (line_note);
-
- if (bb_live_regs)
- FREE_REG_SET (bb_live_regs);
+ free (line_note_head);
if (edge_table)
{
free (out_edges);
out_edges = NULL;
}
+
+ sbitmap_free (blocks);
+ sbitmap_free (large_region_blocks);
+
+ free (deaths_in_region);
}
+
#endif /* INSN_SCHEDULING */
OSDN Git Service
