/* Instruction scheduling pass.
- Copyright (C) 1992, 93-98, 1999 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.
#include "toplev.h"
#include "rtl.h"
#include "tm_p.h"
+#include "hard-reg-set.h"
#include "basic-block.h"
#include "regs.h"
#include "function.h"
-#include "hard-reg-set.h"
#include "flags.h"
#include "insn-config.h"
#include "insn-attr.h"
#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 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)
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;
+};
-/* 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 rtx *reg_last_clobbers;
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)])
-
/* 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.
insn chain. */
static sbitmap *true_dependency_cache;
-/* 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) << BLOCKAGE_BITS \
- | MIN_BLOCKAGE_COST (R)) << BLOCKAGE_BITS \
- | MAX_BLOCKAGE_COST (R))
-#define UNIT_BLOCKED(B) ((B) >> (2 * BLOCKAGE_BITS))
+/* 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. */
#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)])
-
/* Forward declarations. */
-static void add_dependence PROTO ((rtx, rtx, enum reg_note));
-#ifdef HAVE_cc0
-static void remove_dependence PROTO ((rtx, rtx));
-#endif
-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 int rank_for_schedule PROTO ((const PTR, const 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 find_insn_reg_weight PROTO ((int));
-static int schedule_block PROTO ((int, int));
-static char *safe_concat PROTO ((char *, char *, const char *));
-static int insn_issue_delay PROTO ((rtx));
-static void adjust_priority PROTO ((rtx));
-
-/* 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
-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
#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 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.
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));
+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'. */
/* 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 (BLOCK_NUM (INSN))))
#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));
+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 get_bb_head_tail PROTO ((int, rtx *, rtx *));
-
-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, const 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 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
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. */
#endif
}
-#ifdef HAVE_cc0
/* Remove ELEM wrapped in an INSN_LIST from the LOG_LINKS
of INSN. Abort if not found. */
abort ();
return;
}
-#endif /* HAVE_cc0 */
+
+/* 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_reg_last_clobbers;
-
-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. */
/* Return 1 if control flow graph should not be constructed, 0 otherwise.
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];
-
- /* Unreachable loops with more than one basic block are detected
- during the DFS traversal in find_rgns.
+ basic_block b = BASIC_BLOCK (i);
- 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;
-
+ /* ??? 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 (nr_edges, sizeof (haifa_edge));
+ 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. */
nr_edges++;
/* 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;
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)
{
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, *degree;
/* 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).
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 (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
/* 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;
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;
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;
edgelst *bl;
{
int es = edgeset_size;
- edgeset src = (edgeset) xmalloc (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);
}
#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. */
#define CONST_BASED_ADDRESS_P(x) \
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;
WORST_CLASS (tmp_class,
may_trap_exp (SET_SRC (pat), 0));
break;
+ case COND_EXEC:
case TRAP_IF:
tmp_class = TRAP_RISKY;
break;
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. */
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)
static void
free_pending_lists ()
{
- if (current_nr_blocks <= 1)
- {
- free_INSN_LIST_list (&pending_read_insns);
- free_INSN_LIST_list (&pending_write_insns);
- free_EXPR_LIST_list (&pending_read_mems);
- free_EXPR_LIST_list (&pending_write_mems);
- }
- else
- {
- /* Interblock scheduling. */
- int bb;
+ int bb;
- for (bb = 0; bb < current_nr_blocks; bb++)
- {
- free_INSN_LIST_list (&bb_pending_read_insns[bb]);
- free_INSN_LIST_list (&bb_pending_write_insns[bb]);
- free_EXPR_LIST_list (&bb_pending_read_mems[bb]);
- free_EXPR_LIST_list (&bb_pending_write_mems[bb]);
- }
+ 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);
+ 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);
+ 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);
+ 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);
+ 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))
+ for (u = deps->last_pending_memory_flush; u; u = XEXP (u, 1))
add_dependence (insn, XEXP (u, 0), REG_DEP_ANTI);
- free_INSN_LIST_list (&last_pending_memory_flush);
- 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, CLOBBER, PRE_DEC, POST_DEC, PRE_INC or POST_INC
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 i;
for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
- sched_analyze_1 (XVECEXP (dest, 0, i), insn);
+ sched_analyze_1 (deps, XVECEXP (dest, 0, i), insn);
if (GET_CODE (x) == SET)
- sched_analyze_2 (SET_SRC (x), insn);
+ sched_analyze_2 (deps, SET_SRC (x), insn);
return;
}
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 = XEXP (dest, 0);
}
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);
- 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);
/* Clobbers need not be ordered with respect to one
pending clobber. */
if (code == SET)
{
- free_INSN_LIST_list (®_last_uses[regno + i]);
- for (u = reg_last_clobbers[regno + i]; u; u = XEXP (u, 1))
+ 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, regno + i);
+ SET_REGNO_REG_SET (reg_pending_sets, r);
}
else
- SET_REGNO_REG_SET (reg_pending_clobbers, regno + i);
+ SET_REGNO_REG_SET (reg_pending_clobbers, r);
/* Function calls clobber all call_used regs. */
- if (global_regs[regno + i]
- || (code == SET && call_used_regs[regno + i]))
- for (u = last_function_call; u; u = XEXP (u, 1))
+ 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);
- 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);
if (code == SET)
{
- free_INSN_LIST_list (®_last_uses[regno]);
- for (u = reg_last_clobbers[regno]; u; u = XEXP (u, 1))
+ 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);
}
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 (anti_dependence (XEXP (pending_mem, 0), dest))
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 (output_dependence (XEXP (pending_mem, 0), dest))
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;
{
#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 = 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), 0);
/* ??? This should never happen. */
- for (u = reg_last_clobbers[regno + i]; u; u = XEXP (u, 1))
+ 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 = 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), 0);
/* ??? This should never happen. */
- for (u = reg_last_clobbers[regno]; u; u = XEXP (u, 1))
+ 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 (read_dependence (XEXP (pending_mem, 0), x))
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 (true_dependence (XEXP (pending_mem, 0), VOIDmode,
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);
- free_INSN_LIST_list (®_last_uses[i]);
+ free_INSN_LIST_list (&deps->reg_last_uses[i]);
- 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 = reg_last_clobbers[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;
- 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
for (i = 0; i < max_reg; i++)
{
rtx u;
- 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 (®_last_uses[i]);
+ free_INSN_LIST_list (&deps->reg_last_uses[i]);
- 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 = reg_last_clobbers[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;
- flush_pending_lists (insn, 0);
+ flush_pending_lists (deps, insn, 0);
}
}
/* 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 (®_last_sets[i]);
- free_INSN_LIST_list (®_last_clobbers[i]);
- reg_last_sets[i]
- = alloc_INSN_LIST (insn, NULL_RTX);
- });
- EXECUTE_IF_SET_IN_REG_SET (reg_pending_clobbers, 0, i,
- {
- reg_last_clobbers[i]
- = alloc_INSN_LIST (insn,
- reg_last_clobbers[i]);
- });
+ 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);
{
for (i = 0; i < maxreg; i++)
{
- free_INSN_LIST_list (®_last_sets[i]);
- free_INSN_LIST_list (®_last_clobbers[i]);
- 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;
- /* 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. */
+ if (set == NULL)
+ goto end_call_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;
/* 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)
- last_pending_memory_flush
- = alloc_INSN_LIST (insn, last_pending_memory_flush);
- sched_analyze_insn (PATTERN (insn), insn, loop_notes);
+ 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. */
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 (®_last_uses[i]);
+ free_INSN_LIST_list (&deps->reg_last_uses[i]);
- 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 = reg_last_clobbers[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;
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);
- 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_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);
}
- free_INSN_LIST_list (&LOG_LINKS (sched_before_next_call));
+ 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_INSN_LIST_list(&last_function_call);
- last_function_call = alloc_INSN_LIST (insn, NULL_RTX);
+ 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.
??? Actually, the reemit_notes just say what is done, not why. */
else if (GET_CODE (insn) == NOTE
- && (NOTE_LINE_NUMBER (insn) == NOTE_INSN_RANGE_START
+ && (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),
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;
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)
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 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);
rtx x;
/* Handle register life information. */
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
continue;
/* Increment weight for each register born here. */
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);
n_vis_no_unit = 0;
}
-#define BUF_LEN 256
+#define BUF_LEN 2048
static char *
safe_concat (buf, cur, str)
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;
{
if (REG_NOTE_KIND (note) == REG_SAVE_NOTE)
{
- int note_type = INTVAL (XEXP (note, 0));
+ enum insn_note note_type = INTVAL (XEXP (note, 0));
+
if (note_type == NOTE_INSN_SETJMP)
{
retval = emit_note_after (NOTE_INSN_SETJMP, insn);
remove_note (insn, note);
note = XEXP (note, 1);
}
- else if (note_type == NOTE_INSN_RANGE_START
+ else if (note_type == NOTE_INSN_RANGE_BEG
|| note_type == NOTE_INSN_RANGE_END)
{
last = emit_note_before (note_type, last);
had different notions of what the "head" insn was. */
get_bb_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.
+ /* 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.
- 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')
+ 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_SAVE_NOTE)
- remove_note (head, 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. */
{
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++;
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)
if (INSN_DEP_COUNT (insn) == 0
&& (! next
|| SCHED_GROUP_P (next) == 0
- || GET_RTX_CLASS (GET_CODE (next)) != 'i'))
+ || ! INSN_P (next)))
ready[n_ready++] = insn;
}
}
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);
/* Initialize variables for region data dependence analysis.
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 (int));
- 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
add_branch_dependences (head, tail)
rtx head, tail;
{
-
rtx insn, last;
/* For all branches, calls, uses, clobbers, and cc0 setters, force them
}
}
+/* 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;
+
+ /* 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;
+
+ /* bb's structures are inherited by its successors. */
+ first_edge = e = OUT_EDGES (b);
+ if (e <= 0)
+ return;
+
+ 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;
+
+ /* 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;
+ }
+
+ 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;
+
+ succ_deps->reg_last_uses[reg]
+ = alloc_INSN_LIST (XEXP (u, 0),
+ succ_deps->reg_last_uses[reg]);
+ }
+
+ /* 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;
+
+ succ_deps->reg_last_sets[reg]
+ = alloc_INSN_LIST (XEXP (u, 0),
+ succ_deps->reg_last_sets[reg]);
+ }
+
+ 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;
+
+ succ_deps->reg_last_clobbers[reg]
+ = alloc_INSN_LIST (XEXP (u, 0),
+ succ_deps->reg_last_clobbers[reg]);
+ }
+ }
+
+ /* 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);
+ }
+
+ 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);
+ }
+
+ /* 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;
+
+ succ_deps->last_function_call
+ = alloc_INSN_LIST (XEXP (u, 0),
+ succ_deps->last_function_call);
+ }
+
+ /* 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;
+
+ succ_deps->last_pending_memory_flush
+ = alloc_INSN_LIST (XEXP (u, 0),
+ succ_deps->last_pending_memory_flush);
+ }
+
+ /* 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);
+
+ e = NEXT_OUT (e);
+ }
+ while (e != first_edge);
+}
+
/* 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
compute_block_backward_dependences (bb)
int bb;
{
- int b;
- rtx x;
+ int i;
rtx head, tail;
int max_reg = max_reg_num ();
+ struct deps tmp_deps;
- b = BB_TO_BLOCK (bb);
-
- if (current_nr_blocks == 1)
- {
- reg_last_uses = (rtx *) xcalloc (max_reg, sizeof (rtx));
- reg_last_sets = (rtx *) xcalloc (max_reg, sizeof (rtx));
- reg_last_clobbers = (rtx *) xcalloc (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];
- reg_last_clobbers = bb_reg_last_clobbers[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];
- }
+ tmp_deps = bb_deps[bb];
/* Do the analysis for this block. */
get_bb_head_tail (bb, &head, &tail);
- sched_analyze (head, tail);
+ sched_analyze (&tmp_deps, head, tail);
add_branch_dependences (head, tail);
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);
-
- /* 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;
- }
-
- for (reg = 0; reg < max_reg; 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;
-
- (bb_reg_last_uses[bb_succ])[reg]
- = alloc_INSN_LIST (XEXP (u, 0),
- (bb_reg_last_uses[bb_succ])[reg]);
- }
-
- /* 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;
-
- (bb_reg_last_sets[bb_succ])[reg]
- = alloc_INSN_LIST (XEXP (u, 0),
- (bb_reg_last_sets[bb_succ])[reg]);
- }
-
- for (u = reg_last_clobbers[reg]; u; u = XEXP (u, 1))
- {
- if (find_insn_list (XEXP (u, 0),
- (bb_reg_last_clobbers[bb_succ])[reg]))
- continue;
-
- (bb_reg_last_clobbers[bb_succ])[reg]
- = alloc_INSN_LIST (XEXP (u, 0),
- (bb_reg_last_clobbers[bb_succ])[reg]);
- }
- }
-
- /* 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);
- }
-
- 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);
- }
-
- /* 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;
-
- bb_last_function_call[bb_succ]
- = alloc_INSN_LIST (XEXP (u, 0),
- bb_last_function_call[bb_succ]);
- }
-
- /* 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;
-
- bb_last_pending_memory_flush[bb_succ]
- = alloc_INSN_LIST (XEXP (u, 0),
- bb_last_pending_memory_flush[bb_succ]);
- }
-
- /* 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);
-
- e = NEXT_OUT (e);
- }
- while (e != first_edge);
- }
+ propagate_deps (bb, &tmp_deps, max_reg);
/* Free up the INSN_LISTs.
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_clobbers[b])
- free_INSN_LIST_list (®_last_clobbers[b]);
- if (reg_last_sets[b])
- free_INSN_LIST_list (®_last_sets[b]);
- if (reg_last_uses[b])
- free_INSN_LIST_list (®_last_uses[b]);
+ 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;
- bb_reg_last_clobbers[bb] = (rtx *) NULL_RTX;
- }
- else if (current_nr_blocks == 1)
- {
- free (reg_last_uses);
- free (reg_last_sets);
- free (reg_last_clobbers);
- }
+ 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. */
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));
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;
- rtx *bb_reg_last_uses_space = NULL;
- rtx *bb_reg_last_sets_space = NULL;
- rtx *bb_reg_last_clobbers_space = NULL;
+ regset_head reg_pending_sets_head;
+ regset_head reg_pending_clobbers_head;
/* 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_clobbers = 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 **) xmalloc (current_nr_blocks * sizeof (rtx *));
- bb_reg_last_uses_space
- = (rtx *) xcalloc (current_nr_blocks * maxreg, sizeof (rtx));
- init_rtx_vector (bb_reg_last_uses, bb_reg_last_uses_space,
- current_nr_blocks, maxreg * sizeof (rtx *));
-
- bb_reg_last_sets = (rtx **) xmalloc (current_nr_blocks * sizeof (rtx *));
- bb_reg_last_sets_space
- = (rtx *) xcalloc (current_nr_blocks * maxreg, sizeof (rtx));
- init_rtx_vector (bb_reg_last_sets, bb_reg_last_sets_space,
- current_nr_blocks, maxreg * sizeof (rtx *));
-
- bb_reg_last_clobbers =
- (rtx **) xmalloc (current_nr_blocks * sizeof (rtx *));
- bb_reg_last_clobbers_space
- = (rtx *) xcalloc (current_nr_blocks * maxreg, sizeof (rtx));
- init_rtx_vector (bb_reg_last_clobbers, bb_reg_last_clobbers_space,
- current_nr_blocks, maxreg * sizeof (rtx *));
-
- bb_pending_read_insns
- = (rtx *) xmalloc (current_nr_blocks * sizeof (rtx));
- bb_pending_read_mems
- = (rtx *) xmalloc (current_nr_blocks * sizeof (rtx));
- bb_pending_write_insns =
- (rtx *) xmalloc (current_nr_blocks * sizeof (rtx));
- bb_pending_write_mems
- = (rtx *) xmalloc (current_nr_blocks * sizeof (rtx));
- bb_pending_lists_length =
- (int *) xmalloc (current_nr_blocks * sizeof (int));
- bb_last_pending_memory_flush =
- (rtx *) xmalloc (current_nr_blocks * sizeof (rtx));
- bb_last_function_call
- = (rtx *) xmalloc (current_nr_blocks * sizeof (rtx));
- bb_sched_before_next_call =
- (rtx *) xmalloc (current_nr_blocks * sizeof (rtx));
-
- init_rgn_data_dependences (current_nr_blocks);
- }
+ 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. */
for (bb = 0; bb < current_nr_blocks; bb++)
/* Split edges. */
edgeset_size = rgn_nr_edges / HOST_BITS_PER_WIDE_INT + 1;
+ edgeset_bitsize = rgn_nr_edges;
pot_split = (edgeset *) xmalloc (current_nr_blocks * sizeof (edgeset));
ancestor_edges
= (edgeset *) xmalloc (current_nr_blocks * sizeof (edgeset));
FREE_REG_SET (reg_pending_sets);
FREE_REG_SET (reg_pending_clobbers);
+ free (bb_deps);
+
if (current_nr_blocks > 1)
{
int i;
- free (bb_reg_last_uses_space);
- free (bb_reg_last_uses);
- free (bb_reg_last_sets_space);
- free (bb_reg_last_sets);
- free (bb_reg_last_clobbers_space);
- free (bb_reg_last_clobbers);
- free (bb_pending_read_insns);
- free (bb_pending_read_mems);
- free (bb_pending_write_insns);
- free (bb_pending_write_mems);
- free (bb_pending_lists_length);
- free (bb_last_pending_memory_flush);
- free (bb_last_function_call);
- free (bb_sched_before_next_call);
free (prob);
for (i = 0; i < current_nr_blocks; ++i)
{
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. */
+ 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;
pseudos which do not cross calls. */
max_uid = get_max_uid () + 1;
- cant_move = xcalloc (max_uid, sizeof (char));
- fed_by_spec_load = xcalloc (max_uid, sizeof (char));
- is_load_insn = xcalloc (max_uid, sizeof (char));
+ h_i_d = (struct haifa_insn_data *) xcalloc (max_uid, sizeof (*h_i_d));
- insn_luid = (int *) xmalloc (max_uid * sizeof (int));
-
- insn_luid[0] = 0;
+ h_i_d[0].luid = 0;
luid = 1;
for (b = 0; b < n_basic_blocks; b++)
for (insn = BLOCK_HEAD (b);; insn = NEXT_INSN (insn))
}
else
{
- int_list_ptr *s_preds, *s_succs;
- int *num_preds, *num_succs;
- sbitmap *dom, *pdom;
-
- s_preds = (int_list_ptr *) xmalloc (n_basic_blocks
- * sizeof (int_list_ptr));
- s_succs = (int_list_ptr *) xmalloc (n_basic_blocks
- * sizeof (int_list_ptr));
- num_preds = (int *) xmalloc (n_basic_blocks * sizeof (int));
- num_succs = (int *) xmalloc (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
We could (should?) recompute register live information. Doing
so may even be beneficial. */
-
- compute_preds_succs (s_preds, s_succs, num_preds, num_succs);
+ edge_list = create_edge_list ();
/* 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_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 ();
free (dom);
- free (pdom);
- free (s_preds);
- free (s_succs);
- free (num_preds);
- free (num_succs);
}
}
- /* 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 *) xcalloc (max_uid, sizeof (int));
- insn_reg_weight = (int *) xcalloc (max_uid, sizeof (int));
- insn_tick = (int *) xcalloc (max_uid, sizeof (int));
- insn_costs = (short *) xcalloc (max_uid, sizeof (short));
- insn_units = (short *) xcalloc (max_uid, sizeof (short));
- insn_blockage = (unsigned int *) xcalloc (max_uid, sizeof (unsigned int));
- insn_ref_count = (int *) xcalloc (max_uid, sizeof (int));
-
- /* Allocate for forward dependencies. */
- insn_dep_count = (int *) xcalloc (max_uid, sizeof (int));
- insn_depend = (rtx *) xcalloc (max_uid, sizeof (rtx));
-
- deaths_in_region = (int *) xmalloc (sizeof(int) * nr_regions);
+ deaths_in_region = (int *) xmalloc (sizeof (int) * nr_regions);
init_alias_analysis ();
{
rtx line;
- line_note = (rtx *) xcalloc (max_uid, sizeof (rtx));
line_note_head = (rtx *) xcalloc (n_basic_blocks, sizeof (rtx));
/* Save-line-note-head:
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,
- PROP_DEATH_NOTES | PROP_REG_INFO);
+ (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 ();
+ abort ();
+#endif
}
if (any_large_regions)
free (rgn_bb_table);
free (block_to_bb);
free (containing_rgn);
- free (cant_move);
- free (fed_by_spec_load);
- free (is_load_insn);
- free (insn_luid);
-
- free (insn_priority);
- free (insn_reg_weight);
- free (insn_tick);
- free (insn_costs);
- free (insn_units);
- free (insn_blockage);
- free (insn_ref_count);
-
- free (insn_dep_count);
- free (insn_depend);
+
+ free (h_i_d);
if (write_symbols != NO_DEBUG)
- {
- free (line_note);
- free (line_note_head);
- }
+ free (line_note_head);
if (edge_table)
{
OSDN Git Service
