summaryrefslogtreecommitdiff
path: root/gcc/range.c
diff options
context:
space:
mode:
Diffstat (limited to 'gcc/range.c')
-rwxr-xr-xgcc/range.c1932
1 files changed, 1932 insertions, 0 deletions
diff --git a/gcc/range.c b/gcc/range.c
new file mode 100755
index 0000000..d96caca
--- /dev/null
+++ b/gcc/range.c
@@ -0,0 +1,1932 @@
+/* CYGNUS LOCAL LRS */
+/* Allocate registers within a basic block, for GNU compiler.
+ Copyright (C) 1997, 1998 Free Software Foundation, Inc.
+
+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 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 Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
+
+/* Live range support that splits a variable that is spilled to the stack into
+ smaller ranges so that at least the middle of small loops the variable will
+ be run in registers. This is run after global allocation if one or more
+ variables were denied a register, and then global allocation is done once
+ again. */
+
+#include "config.h"
+#include "system.h"
+#include "rtl.h"
+#include "tree.h"
+#include "flags.h"
+#include "basic-block.h"
+#include "regs.h"
+#include "hard-reg-set.h"
+#include "insn-config.h"
+#include "recog.h"
+#include "output.h"
+#include "expr.h"
+#include "except.h"
+#include "function.h"
+#include "obstack.h"
+#include "range.h"
+#include "toplev.h"
+
+extern struct obstack *rtl_obstack;
+
+/* Information that we gather about registers */
+typedef struct rinfo_def {
+ rtx reg; /* Register insn */
+ int refs; /* # of register references */
+ int sets; /* # of register sets/clobbers */
+ int deaths; /* # of register deaths */
+ int live_length; /* # of insns in range value is live */
+ int n_calls; /* # of calls this reg crosses */
+ int copy_flags; /* copy {in,out} flags */
+} rinfo;
+
+/* Basic blocks expressed as a linked list */
+typedef struct bb_link_def {
+ int block; /* block number or -1 */
+ rtx first_insn; /* first insn in block */
+ rtx last_insn; /* last insn in block */
+ regset live_at_start; /* live information */
+} bb_link;
+
+/* Symbol/block node that a variable is declared in and whether a register
+ only holds constants. */
+typedef struct var_info_def {
+ tree symbol; /* DECL_NODE of the symbol */
+ tree block; /* BLOCK_NODE variable is declared in */
+ rtx constant_value; /* what value a register always holds */
+} var_info;
+
+int range_max_unique; /* Range #, monotonically increasing */
+
+static rinfo *range_info; /* Register information */
+static var_info *range_vars; /* Map regno -> variable */
+static int *range_regs; /* Registers used in the loop */
+static int range_num_regs; /* # of registers in range_regs */
+static int range_loop_depth; /* current loop depth */
+static int range_update_used_p; /* whether range_used should be set */
+static regset range_used; /* regs used in the current range */
+static regset range_set; /* regs set in the current range */
+static regset range_live; /* regs currently live */
+static regset range_mixed_mode; /* regs that use different modes */
+static regset range_no_move; /* regs that don't have simple moves */
+static unsigned range_max_uid; /* Size of UID->basic block mapping */
+static bb_link **range_block_insn; /* Map INSN # to basic block # */
+static bb_link *range_block_orig; /* original basic blocks */
+
+/* Linked list of live ranges to try allocating registers in first before
+ allocating all of the remaining registers. */
+rtx live_range_list;
+
+#define RANGE_BLOCK_NUM(INSN) \
+(((unsigned)INSN_UID (INSN) < (unsigned)range_max_uid \
+ && range_block_insn[INSN_UID (INSN)]) \
+ ? range_block_insn[INSN_UID (INSN)]->block : -1)
+
+/* Forward references */
+static void range_mark PROTO((rtx, int, rtx));
+static void range_basic_mark PROTO((rtx, regset, rtx));
+static void range_basic_insn PROTO((rtx, regset, int));
+static void range_bad_insn PROTO((FILE *, char *, rtx));
+static void range_print_flags PROTO((FILE *, int, char *));
+static void print_blocks_internal PROTO((FILE *, tree, int));
+static int range_inner PROTO((FILE *, rtx, rtx, rtx, rtx,
+ regset, regset, int));
+static void range_update_basic_block PROTO((FILE *, rtx, bb_link *,
+ int, int));
+static void range_finish PROTO((FILE *, rtx, int, int));
+static void range_scan_blocks PROTO((tree, tree));
+static int range_compare PROTO((const GENERIC_PTR,
+ const GENERIC_PTR));
+
+
+/* Determine which registers are used/set */
+
+static void
+range_mark (x, set_p, insn)
+ rtx x;
+ int set_p;
+ rtx insn;
+{
+ register RTX_CODE code = GET_CODE (x);
+ register int i, regno;
+ register char *fmt;
+
+restart:
+
+ switch (code)
+ {
+ default:
+ break;
+
+ /* Make sure we mark the registers that are set */
+ case SET:
+ range_mark (SET_DEST (x), TRUE, insn);
+ range_mark (SET_SRC (x), FALSE, insn);
+ return;
+
+ /* Treat clobber like a set. */
+ /* Pre-increment and friends always update as well as reference. */
+ case CLOBBER:
+ case PRE_INC:
+ case PRE_DEC:
+ case POST_INC:
+ case POST_DEC:
+ range_mark (XEXP (x, 0), TRUE, insn);
+ return;
+
+ /* Memory addresses just reference the register, even if this is a SET */
+ case MEM:
+ range_mark (XEXP (x, 0), FALSE, insn);
+ return;
+
+ /* Treat subregs as using/modifying the whole register. */
+ case SUBREG:
+ x = SUBREG_REG (x);
+ code = GET_CODE (x);
+ goto restart;
+
+ /* Actual registers, skip hard registers */
+ case REG:
+ regno = REGNO (x);
+ if (regno >= FIRST_PSEUDO_REGISTER)
+ {
+ if (!range_info[regno].reg)
+ range_info[regno].reg = x;
+ else if (GET_MODE (x) != GET_MODE (range_info[regno].reg))
+ SET_REGNO_REG_SET (range_mixed_mode, regno);
+
+ range_info[regno].refs += 2*range_loop_depth;
+ SET_REGNO_REG_SET (range_live, regno);
+ if (range_update_used_p)
+ SET_REGNO_REG_SET (range_used, regno);
+
+ /* If there isn't a simple move pattern for the mode, skip it */
+ if (mov_optab->handlers[(int) GET_MODE (x)].insn_code
+ == CODE_FOR_nothing)
+ SET_REGNO_REG_SET (range_no_move, regno);
+
+ if (set_p)
+ {
+ range_info[regno].sets++;
+ SET_REGNO_REG_SET (range_set, regno);
+ }
+ }
+
+ return;
+ }
+
+ fmt = GET_RTX_FORMAT (code);
+ for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
+ {
+ if (fmt[i] == 'e')
+ range_mark (XEXP (x, i), set_p, insn);
+
+ else if (fmt[i] == 'E')
+ {
+ register unsigned j;
+ for (j = 0; j < XVECLEN (x, i); j++)
+ range_mark (XVECEXP (x, i, j), set_p, insn);
+ }
+ }
+}
+
+
+/* Like range_mark, except more stripped down, to just care about what
+ registers are currently live. */
+
+static void
+range_basic_mark (x, live, insn)
+ rtx x;
+ regset live;
+ rtx insn;
+{
+ register RTX_CODE code = GET_CODE (x);
+ register int i, regno, lim;
+ register char *fmt;
+
+restart:
+ switch (code)
+ {
+ default:
+ break;
+
+ /* Treat subregs as using/modifying the whole register. */
+ case SUBREG:
+ x = SUBREG_REG (x);
+ code = GET_CODE (x);
+ goto restart;
+
+ /* Actual registers */
+ case REG:
+ regno = REGNO (x);
+ lim = regno + ((regno >= FIRST_PSEUDO_REGISTER)
+ ? 1
+ : HARD_REGNO_NREGS (regno, GET_MODE (x)));
+
+ for (i = regno; i < lim; i++)
+ SET_REGNO_REG_SET (live, i);
+ return;
+ }
+
+ fmt = GET_RTX_FORMAT (code);
+ for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
+ {
+ if (fmt[i] == 'e')
+ range_basic_mark (XEXP (x, i), live, insn);
+
+ else if (fmt[i] == 'E')
+ {
+ register unsigned j;
+ for (j = 0; j < XVECLEN (x, i); j++)
+ range_basic_mark (XVECEXP (x, i, j), live, insn);
+ }
+ }
+}
+
+/* For an INSN, CALL_INSN, or JUMP_INSN, update basic live/dead information. */
+
+static void
+range_basic_insn (insn, live, range_max_regno)
+ rtx insn;
+ regset live;
+ int range_max_regno;
+{
+ rtx note, x;
+ int i;
+
+ range_basic_mark (PATTERN (insn), live, insn);
+
+ /* Remember if the value is only set to one constant. */
+ if (GET_CODE (insn) == INSN
+ && (x = single_set (insn)) != NULL_RTX
+ && (GET_CODE (SET_DEST (x)) == REG
+ && REG_N_SETS (REGNO (SET_DEST (x))) == 1
+ && CONSTANT_P (SET_SRC (x)))
+ && REGNO (SET_DEST (x)) < range_max_regno)
+ range_vars[ REGNO (SET_DEST (x))].constant_value = SET_SRC (x);
+
+ /* figure out which registers are now dead. */
+ for (note = REG_NOTES (insn); note != NULL_RTX; note = XEXP (note, 1))
+ {
+ if (REG_NOTE_KIND (note) == REG_DEAD
+ && GET_CODE (XEXP (note, 0)) == REG)
+ {
+ rtx reg = XEXP (note, 0);
+ int regno = REGNO (reg);
+ int lim = regno + ((regno >= FIRST_PSEUDO_REGISTER)
+ ? 1
+ : HARD_REGNO_NREGS (regno, GET_MODE (reg)));
+
+ for (i = regno; i < lim; i++)
+ CLEAR_REGNO_REG_SET (live, i);
+ }
+ }
+}
+
+
+/* Sort the registers by number of uses */
+
+static int
+range_compare (v1p, v2p)
+ const GENERIC_PTR v1p;
+ const GENERIC_PTR v2p;
+{
+ int i1 = *(int *)v1p;
+ int i2 = *(int *)v2p;
+ int r1 = range_info[i1].refs;
+ int r2 = range_info[i2].refs;
+
+ if (r2 - r1)
+ return r2 - r1;
+
+ /* Make sure that range_compare always is stable, so if the values are equal,
+ compare based on pseduo register number. */
+ return REGNO (range_info[i2].reg) - REGNO (range_info[i1].reg);
+}
+
+
+/* If writing a .range file, print a message and an rtl. */
+
+static void
+range_bad_insn (stream, msg, insn)
+ FILE *stream;
+ char *msg;
+ rtx insn;
+{
+ if (stream)
+ {
+ fputs (msg, stream);
+ print_rtl (stream, PATTERN (insn));
+ putc ('\n', stream);
+ }
+}
+
+
+/* Print out to STREAM the copyin/copyout flags. */
+
+static void
+range_print_flags (stream, flags, prefix)
+ FILE *stream;
+ int flags;
+ char *prefix;
+{
+ if ((flags & LIVE_RANGE_COPYIN) != 0)
+ {
+ fprintf (stream, "%scopyin", prefix);
+ prefix = ", ";
+ }
+
+ if ((flags & LIVE_RANGE_COPYIN_CONST) != 0)
+ {
+ fprintf (stream, "%sconst", prefix);
+ prefix = ", ";
+ }
+
+ if ((flags & LIVE_RANGE_COPYOUT) != 0)
+ fprintf (stream, "%scopyout", prefix);
+
+}
+
+
+/* Print out range information to STREAM, using RANGE as the range_info rtx,
+ printing TAB and COMMENT at the beginning of each line. */
+
+void
+live_range_print (stream, range, tab, comment)
+ FILE *stream;
+ rtx range;
+ char *tab;
+ char *comment;
+{
+ int i;
+
+ fprintf (stream,
+ "%s%s range #%d start, %d calls, basic block {start/end} %d/%d, loop depth %d\n",
+ tab, comment,
+ RANGE_INFO_UNIQUE (range), RANGE_INFO_NCALLS (range),
+ RANGE_INFO_BB_START (range), RANGE_INFO_BB_END (range),
+ RANGE_INFO_LOOP_DEPTH (range));
+
+ for (i = 0; i < (int)RANGE_INFO_NUM_REGS (range); i++)
+ {
+ int pseudo = RANGE_REG_PSEUDO (range, i);
+ int copy = RANGE_REG_COPY (range, i);
+
+ fprintf (stream, "%s%s reg %d", tab, comment, pseudo);
+ if (reg_renumber)
+ {
+ if ((unsigned)pseudo >= (unsigned)max_regno)
+ fprintf (stream, " (illegal)");
+ else if (reg_renumber[pseudo] >= 0)
+ fprintf (stream, " (%s)", reg_names[ reg_renumber[pseudo]]);
+ }
+
+ fprintf (stream, ", copy %d", copy);
+ if (reg_renumber)
+ {
+ if ((unsigned)copy >= (unsigned)max_regno)
+ fprintf (stream, " (illegal)");
+ else if (reg_renumber[copy] >= 0)
+ fprintf (stream, " (%s)", reg_names[ reg_renumber[copy]]);
+ }
+
+ fprintf (stream,
+ ", %d ref(s), %d set(s), %d death(s), %d live length, %d calls",
+ RANGE_REG_REFS (range, i),
+ RANGE_REG_SETS (range, i),
+ RANGE_REG_DEATHS (range, i),
+ RANGE_REG_LIVE_LENGTH (range, i),
+ RANGE_REG_N_CALLS (range, i));
+
+ range_print_flags (stream, RANGE_REG_COPY_FLAGS (range, i), ", ");
+ if (REG_USERVAR_P (regno_reg_rtx[pseudo]))
+ {
+ fprintf (stream, ", user");
+ if (RANGE_REG_SYMBOL_NODE (range, i))
+ {
+ tree name = DECL_NAME (RANGE_REG_SYMBOL_NODE (range, i));
+ if (name)
+ fprintf (stream, " [%s]", IDENTIFIER_POINTER (name));
+ }
+ }
+
+ if (REGNO_POINTER_FLAG (pseudo))
+ fprintf (stream, ", ptr");
+
+ putc ('\n', stream);
+ }
+}
+
+
+/* CYGNUS LOCAL -- meissner/live range */
+/* Print the scoping blocks in the current function */
+
+static void
+print_blocks_internal (stream, block, level)
+ FILE *stream;
+ tree block;
+ int level;
+{
+ /* Loop over all blocks */
+ for (; block != NULL_TREE; block = BLOCK_CHAIN (block))
+ {
+ int i;
+ tree vars_types[2];
+ static char *vars_types_name[] = {"vars: ", "types:"};
+
+ fprintf (stream, "%*sBlock ", level*4, "");
+ fprintf (stream, HOST_WIDE_INT_PRINT_HEX, (HOST_WIDE_INT) block);
+
+ if (BLOCK_CHAIN (block))
+ {
+ fprintf (stream, ", chain ");
+ fprintf (stream, HOST_WIDE_INT_PRINT_HEX,
+ (HOST_WIDE_INT) BLOCK_CHAIN (block));
+ }
+
+ if (BLOCK_VARS (block))
+ {
+ fprintf (stream, ", vars ");
+ fprintf (stream, HOST_WIDE_INT_PRINT_HEX,
+ (HOST_WIDE_INT) BLOCK_VARS (block));
+ }
+
+ if (BLOCK_TYPE_TAGS (block))
+ {
+ fprintf (stream, ", types ");
+ fprintf (stream, HOST_WIDE_INT_PRINT_HEX,
+ (HOST_WIDE_INT) BLOCK_TYPE_TAGS (block));
+ }
+
+ if (BLOCK_SUBBLOCKS (block))
+ {
+ fprintf (stream, ", subblocks ");
+ fprintf (stream, HOST_WIDE_INT_PRINT_HEX,
+ (HOST_WIDE_INT) BLOCK_SUBBLOCKS (block));
+ }
+
+ if (BLOCK_ABSTRACT_ORIGIN (block))
+ {
+ fprintf (stream, ", abstract origin ");
+ fprintf (stream, HOST_WIDE_INT_PRINT_HEX,
+ (HOST_WIDE_INT) BLOCK_ABSTRACT_ORIGIN (block));
+ }
+
+ if (BLOCK_ABSTRACT (block))
+ fprintf (stream, ", abstract");
+
+ if (BLOCK_LIVE_RANGE_FLAG (block))
+ fprintf (stream, ", live-range");
+
+ if (BLOCK_LIVE_RANGE_VAR_FLAG (block))
+ fprintf (stream, ", live-range-vars");
+
+ if (BLOCK_HANDLER_BLOCK (block))
+ fprintf (stream, ", handler");
+
+ if (TREE_USED (block))
+ fprintf (stream, ", used");
+
+ if (TREE_ASM_WRITTEN (block))
+ fprintf (stream, ", asm-written");
+
+ fprintf (stream, "\n");
+ vars_types[0] = BLOCK_VARS (block);
+ vars_types[1] = BLOCK_TYPE_TAGS (block);
+ for (i = 0; i < 2; i++)
+ if (vars_types[i])
+ {
+ tree vars;
+ int indent = ((level < 4) ? 16 : (level*4) + 4) - 1;
+ int len = 0;
+
+ for (vars = BLOCK_VARS (block);
+ vars != NULL_TREE;
+ vars = TREE_CHAIN (vars))
+ {
+ if (DECL_NAME (vars) && IDENTIFIER_POINTER (DECL_NAME (vars)))
+ {
+ if (len == 0)
+ {
+ len = indent + 1 + strlen (vars_types_name[i]);
+ fprintf (stream, "%*s%s", indent+1, "",
+ vars_types_name[i]);
+ }
+
+ len += IDENTIFIER_LENGTH (DECL_NAME (vars)) + 1;
+ if (len >= 80 && len > indent)
+ {
+ len = indent;
+ fprintf (stream, "\n%*s", indent, "");
+ }
+
+ fprintf (stream, " %.*s",
+ IDENTIFIER_LENGTH (DECL_NAME (vars)),
+ IDENTIFIER_POINTER (DECL_NAME (vars)));
+ }
+ }
+
+ fprintf (stream, "\n\n");
+ }
+
+ print_blocks_internal (stream, BLOCK_SUBBLOCKS (block), level+1);
+ }
+}
+
+void
+print_all_blocks ()
+{
+ fprintf (stderr, "\n");
+ print_blocks_internal (stderr, DECL_INITIAL (current_function_decl), 0);
+}
+
+
+/* Function with debugging output to STREAM that handles a sequence of insns
+ that goes from RANGE_START to RANGE_END, splitting the range of variables
+ used between INNER_START and INNER_END. Registers in LIVE_AT_START are live
+ at the first insn. BB_{START,END} holds the basic block numbers of the
+ first and last insns. Return the number of variables that had their ranges
+ split into a new pseudo variable used only within the loop. */
+
+static int
+range_inner (stream, range_start, range_end, inner_start, inner_end,
+ live_at_start, live_at_end, loop_depth)
+ FILE *stream;
+ rtx range_start;
+ rtx range_end;
+ rtx inner_start;
+ rtx inner_end;
+ regset live_at_start;
+ regset live_at_end;
+ int loop_depth;
+{
+ rtx insn;
+ rtx pattern;
+ rtx label_ref;
+ rtx label_chain;
+ rtx start;
+ rtx end;
+ rtx *regs;
+ rtvec regs_rtvec;
+ rtx note;
+ int first_label = get_first_label_num ();
+ int last_label = max_label_num ();
+ unsigned num_labels = last_label - first_label + 1;
+ unsigned indx;
+ int i;
+ int regno;
+ int block;
+ int *loop_label_ref = (int *) alloca (sizeof (int) * num_labels);
+ int *all_label_ref = (int *) alloca (sizeof (int) * num_labels);
+ char *found_label_ref = (char *) alloca (sizeof (char) * num_labels);
+ int ok_p = TRUE;
+ int n_insns;
+ int n_calls;
+ regset live_at_start_copy;
+ regset live_at_end_copy;
+ int bb_start;
+ int bb_end;
+ char *nl;
+ rtx ri;
+
+ bzero ((char *)loop_label_ref, sizeof (int) * num_labels);
+ bzero ((char *)all_label_ref, sizeof (int) * num_labels);
+ bzero ((char *) range_info, sizeof (rinfo) * max_reg_num ());
+ CLEAR_REG_SET (range_used);
+ CLEAR_REG_SET (range_set);
+ CLEAR_REG_SET (range_mixed_mode);
+ CLEAR_REG_SET (range_no_move);
+ COPY_REG_SET (range_live, live_at_start);
+ range_num_regs = 0;
+ range_loop_depth = loop_depth;
+
+ if (stream)
+ fprintf (stream, "\nPossible range from %d to %d (inner range %d to %d)\nLive at start: ",
+ INSN_UID (range_start), INSN_UID (range_end),
+ INSN_UID (inner_start), INSN_UID (inner_end));
+
+ /* Mark the live registers as needing copies to the tmp register from the
+ original value. */
+ EXECUTE_IF_SET_IN_REG_SET (live_at_start, FIRST_PSEUDO_REGISTER, i,
+ {
+ range_info[i].copy_flags |= LIVE_RANGE_COPYIN;
+ if (stream)
+ fprintf (stream, " %d", i);
+ if (range_vars[i].constant_value)
+ {
+ range_info[i].copy_flags
+ |= LIVE_RANGE_COPYIN_CONST;
+
+ if (stream)
+ fprintf (stream, " [constant]");
+ }
+ });
+
+ if (stream)
+ {
+ fprintf (stream, "\nLive at end: ");
+ EXECUTE_IF_SET_IN_REG_SET (live_at_end, FIRST_PSEUDO_REGISTER, i,
+ {
+ fprintf (stream, " %d", i);
+ });
+
+ putc ('\n', stream);
+ }
+
+ /* Calculate basic block start and end */
+ bb_start = -1;
+ for (insn = range_start;
+ insn && insn != range_end && (bb_start = RANGE_BLOCK_NUM (insn)) < 0;
+ insn = NEXT_INSN (insn))
+ ;
+
+ bb_end = -1;
+ for (insn = range_end;
+ insn && insn != range_start && (bb_end = RANGE_BLOCK_NUM (insn)) < 0;
+ insn = PREV_INSN (insn))
+ ;
+
+ if (bb_start < 0)
+ {
+ ok_p = FALSE;
+ if (stream)
+ fprintf (stream, "Cannot find basic block start\n");
+ }
+
+ if (bb_end < 0)
+ {
+ ok_p = FALSE;
+ if (stream)
+ fprintf (stream, "Cannot find basic block end\n");
+ }
+
+ /* Scan the loop, looking for jumps outside/inside of the loop. If the
+ loop has such jumps, we ignore it. */
+ n_insns = n_calls = block = 0;
+ range_update_used_p = FALSE;
+ for (insn = range_start; insn && insn != range_end; insn = NEXT_INSN (insn))
+ {
+ enum rtx_code code = GET_CODE (insn);
+ int block_tmp = RANGE_BLOCK_NUM (insn);
+ if (block_tmp >= 0 && block != block_tmp)
+ {
+ block = block_tmp;
+ COPY_REG_SET (range_live, basic_block_live_at_start[block]);
+ }
+
+ /* Only mark registers that appear between INNER_START and INNER_END */
+ if (insn == inner_start)
+ range_update_used_p = TRUE;
+ else if (insn == inner_end)
+ range_update_used_p = FALSE;
+
+ if (GET_RTX_CLASS (code) == 'i')
+ {
+ n_insns++;
+ /* Mark used registers */
+ range_mark (PATTERN (insn), FALSE, insn);
+
+ /* Update live length, & number of calls that the insn crosses */
+ EXECUTE_IF_SET_IN_REG_SET (range_live, FIRST_PSEUDO_REGISTER, i,
+ {
+ range_info[i].live_length++;
+ if (GET_CODE (insn) == CALL_INSN)
+ range_info[i].n_calls++;
+ });
+
+ /* figure out which ones will be dead by the end of the region */
+ for (note = REG_NOTES (insn); note != NULL_RTX; note = XEXP (note, 1))
+ {
+ if (REG_NOTE_KIND (note) == REG_DEAD
+ && GET_CODE (XEXP (note, 0)) == REG
+ && REGNO (XEXP (note, 0)) > FIRST_PSEUDO_REGISTER)
+ {
+ CLEAR_REGNO_REG_SET (range_live, REGNO (XEXP (note, 0)));
+ range_info[ REGNO (XEXP (note, 0)) ].deaths++;
+ }
+ }
+ }
+
+ switch (code)
+ {
+ default:
+ break;
+
+ /* Update loop_depth */
+ case NOTE:
+ if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG)
+ range_loop_depth++;
+ else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END)
+ range_loop_depth++;
+ break;
+
+ /* Record whether there was a call. */
+ case CALL_INSN:
+ n_calls++;
+ break;
+
+ /* Found a label, record the number of uses */
+ case CODE_LABEL:
+ indx = CODE_LABEL_NUMBER (insn) - first_label;
+ if (indx >= num_labels)
+ {
+ if (stream)
+ fprintf (stream, "Code label %d doesn't fit in label table",
+ CODE_LABEL_NUMBER (insn));
+
+ ok_p = FALSE;
+ continue;
+ }
+
+ all_label_ref[indx] = LABEL_NUSES (insn);
+ break;
+
+ /* Found a jump of some sort, see where the jump goes. */
+ case JUMP_INSN:
+ pattern = PATTERN (insn);
+
+ /* Switch statement, process all labels */
+ if (GET_CODE (pattern) == ADDR_VEC
+ || GET_CODE (pattern) == ADDR_DIFF_VEC)
+ {
+ int vec_num = (GET_CODE (PATTERN (insn)) == ADDR_VEC) ? 0 : 1;
+ int len = XVECLEN (pattern, vec_num);
+ bzero ((char *)found_label_ref, sizeof (char) * num_labels);
+
+ for (i = 0; i < len; i++)
+ {
+ label_ref = XEXP (XVECEXP (pattern, vec_num, i), 0);
+ indx = CODE_LABEL_NUMBER (label_ref) - first_label;
+
+ if (indx >= num_labels)
+ {
+ range_bad_insn (stream,
+ "Label ref doesn't fit in label table\n",
+ label_ref);
+ ok_p = FALSE;
+ }
+
+ /* Only process duplicated labels once, since the LABEL_REF
+ chain only includes it once. */
+ else if (!found_label_ref[indx])
+ {
+ found_label_ref[indx] = TRUE;
+ loop_label_ref[indx]++;
+ }
+ }
+ }
+
+ else
+ {
+ label_ref = JUMP_LABEL (insn);
+ if (!label_ref)
+ {
+ rtx sset;
+ range_bad_insn
+ (stream,
+ (((sset = single_set (insn)) != NULL_RTX
+ && (GET_CODE (SET_SRC (sset)) == REG
+ || GET_CODE (SET_SRC (sset)) == SUBREG
+ || GET_CODE (SET_SRC (sset)) == MEM))
+ ? "Jump to indeterminate label in inner loop\n"
+ : "JUMP_LABEL (insn) is null.\n"),
+ insn);
+
+ ok_p = FALSE;
+ continue;
+ }
+
+ if (GET_CODE (label_ref) != CODE_LABEL)
+ {
+ range_bad_insn (stream,
+ "JUMP_LABEL (insn) is not a CODE_LABEL.\n",
+ insn);
+
+ ok_p = FALSE;
+ continue;
+ }
+
+ indx = CODE_LABEL_NUMBER (label_ref) - first_label;
+ if (indx >= num_labels)
+ {
+ range_bad_insn (stream,
+ "Label ref doesn't fit in label table\n",
+ insn);
+
+ ok_p = FALSE;
+ continue;
+ }
+
+ loop_label_ref[indx]++;
+ }
+
+ break;
+ }
+ }
+
+ /* Now that we've scanned the loop, check for any jumps into or out of
+ the loop, and if we've found them, don't do live range splitting.
+ If there are no registers used in the loop, there is nothing to do. */
+ nl = (char *)0;
+ if (ok_p)
+ {
+ for (i = 0; i < (int)num_labels; i++)
+ if (loop_label_ref[i] != all_label_ref[i])
+ {
+ ok_p = FALSE;
+ if (stream)
+ {
+ nl = "\n";
+ if (!all_label_ref[i])
+ fprintf (stream, "label %d was outside of the loop.\n", i+first_label);
+ else
+ fprintf (stream, "label %d had %d references, only %d were in loop.\n",
+ i+first_label, all_label_ref[i], loop_label_ref[i]);
+ }
+ }
+
+ /* ignore any registers that use different modes, or that don't have simple
+ move instructions. */
+ if (stream)
+ {
+ EXECUTE_IF_SET_IN_REG_SET (range_mixed_mode, FIRST_PSEUDO_REGISTER, regno,
+ {
+ nl = "\n";
+ fprintf (stream,
+ "Skipping register %d used with different types\n",
+ regno);
+ });
+
+ EXECUTE_IF_SET_IN_REG_SET (range_no_move, FIRST_PSEUDO_REGISTER, regno,
+ {
+ nl = "\n";
+ fprintf (stream,
+ "Skipping register %d that needs complex moves\n",
+ regno);
+ });
+ }
+
+ IOR_REG_SET (range_mixed_mode, range_no_move);
+ AND_COMPL_REG_SET (range_used, range_mixed_mode);
+ AND_COMPL_REG_SET (range_set, range_mixed_mode);
+ EXECUTE_IF_SET_IN_REG_SET(range_used, FIRST_PSEUDO_REGISTER, regno,
+ {
+ /* If the register isn't live at the end,
+ indicate that it must have died. */
+ if (REGNO_REG_SET_P (live_at_end, regno))
+ range_info[regno].copy_flags
+ |= LIVE_RANGE_COPYOUT;
+
+ /* If the register is only used in a single
+ basic block, let local-alloc allocate
+ a register for it. */
+ if (REG_BASIC_BLOCK (regno) >= 0)
+ {
+ nl = "\n";
+ if (stream)
+ fprintf (stream,
+ "Skipping %d due to being used in a single basic block\n",
+ regno);
+ continue;
+ }
+
+ /* If the register is live only within the
+ range, don't bother with it. */
+ if (REG_LIVE_LENGTH (regno)
+ <= range_info[regno].live_length)
+ {
+ nl = "\n";
+ if (stream)
+ fprintf (stream,
+ "Skipping %d due to being used only in range\n",
+ regno);
+ continue;
+ }
+
+ range_regs[range_num_regs++] = regno;
+ });
+
+ if (range_num_regs == 0)
+ {
+ ok_p = FALSE;
+ if (stream)
+ fprintf (stream, "No registers found in loop\n");
+ }
+ }
+
+ if (stream && nl)
+ fputs (nl, stream);
+
+ if (!ok_p)
+ return 0;
+
+ qsort (range_regs, range_num_regs, sizeof (int), range_compare);
+
+ CLEAR_REG_SET (range_used);
+ for (i = 0; i < range_num_regs; i++)
+ SET_REGNO_REG_SET (range_used, range_regs[i]);
+
+#if 0
+ /* Narrow down range_start so that we include only those insns that reference
+ one of the live range variables. */
+ regs_ref = ALLOCA_REG_SET ();
+ regs_set = ALLOCA_REG_SET ();
+ regs_tmp = ALLOCA_REG_SET ();
+
+ uses_regs = inner_start;
+ for (insn = inner_start; insn; insn = PREV_INSN (insn))
+ {
+ if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
+ && regset_mentioned_p (range_used, PATTERN (insn), FALSE, regs_ref,
+ regs_set))
+ {
+ uses_regs = insn;
+ }
+
+ if (insn == range_start)
+ break;
+ }
+ range_start = uses_regs;
+
+ /* Narrow down range_end so that we include only those insns that reference
+ one of the live range variables. */
+ CLEAR_REG_SET (regs_ref);
+ uses_regs = inner_end;
+ for (insn = inner_end; insn; insn = NEXT_INSN (insn))
+ {
+ if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
+ && regset_mentioned_p (range_used, PATTERN (insn), FALSE, regs_ref,
+ regs_set))
+ {
+ uses_regs = insn;
+ }
+
+ if (insn == range_end)
+ break;
+ }
+ range_end = uses_regs;
+
+ FREE_REG_SET (regs_ref);
+ FREE_REG_SET (regs_set);
+ FREE_REG_SET (regs_tmp);
+#endif
+
+ /* Mark the live range region. */
+ regs = (rtx *) alloca (sizeof (rtx) * range_num_regs);
+ for (i = 0; i < range_num_regs; i++)
+ {
+ int r = range_regs[i];
+ rinfo *ri = &range_info[r];
+
+ if (range_vars[r].block)
+ BLOCK_LIVE_RANGE_VAR_FLAG (range_vars[r].block) = TRUE;
+
+ REG_N_RANGE_CANDIDATE_P (r) = 1;
+ regs[i] = gen_rtx (RANGE_REG, VOIDmode,
+ r, -1, ri->refs, ri->sets, ri->deaths,
+ ri->copy_flags, ri->live_length, ri->n_calls,
+ range_vars[r].symbol, range_vars[r].block);
+ }
+
+ live_at_start_copy = OBSTACK_ALLOC_REG_SET (rtl_obstack);
+ live_at_end_copy = OBSTACK_ALLOC_REG_SET (rtl_obstack);
+ COPY_REG_SET (live_at_start_copy, live_at_start);
+ COPY_REG_SET (live_at_end_copy, live_at_end);
+
+ regs_rtvec = gen_rtvec_v (range_num_regs, regs);
+ start = emit_note_before (NOTE_INSN_RANGE_START, range_start);
+ end = emit_note_after (NOTE_INSN_RANGE_END, range_end);
+
+ ri = gen_rtx (RANGE_INFO, VOIDmode, start, end, regs_rtvec, n_calls, n_insns,
+ range_max_unique++, bb_start, bb_end, loop_depth,
+ live_at_start_copy, live_at_end_copy, 0, 0);
+
+ NOTE_RANGE_INFO (start) = ri;
+ NOTE_RANGE_INFO (end) = ri;
+
+ live_range_list = gen_rtx (INSN_LIST, VOIDmode, start, live_range_list);
+ return range_num_regs;
+}
+
+
+/* Scan all blocks looking for user variables so that we can map from
+ register number back to the appropriate DECL_NODE and BLOCK_NODE. */
+
+static void
+range_scan_blocks (block, args)
+ tree block;
+ tree args;
+{
+ tree var;
+
+ /* Scan arguments */
+ for (var = args; var != NULL_TREE; var = TREE_CHAIN (var))
+ {
+ if (DECL_RTL (var) && GET_CODE (DECL_RTL (var)) == REG)
+ {
+ int regno = REGNO (DECL_RTL (var));
+ if ((unsigned)regno >= (unsigned)max_regno)
+ abort ();
+
+ range_vars[regno].symbol = var;
+ range_vars[regno].block = block;
+ }
+ }
+
+ /* Loop over all blocks */
+ for (; block != NULL_TREE; block = BLOCK_CHAIN (block))
+ if (TREE_USED (block))
+ {
+ /* Record all symbols in the block */
+ for (var = BLOCK_VARS (block); var != NULL_TREE; var = TREE_CHAIN (var))
+ {
+ if (DECL_RTL (var) && GET_CODE (DECL_RTL (var)) == REG)
+ {
+ int regno = REGNO (DECL_RTL (var));
+ if ((unsigned)regno >= (unsigned)max_regno)
+ abort ();
+
+ range_vars[regno].symbol = var;
+ range_vars[regno].block = block;
+ }
+ }
+
+ /* Record the subblocks, and their subblocks... */
+ range_scan_blocks (BLOCK_SUBBLOCKS (block), NULL_TREE);
+ }
+}
+
+
+/* Recalculate the basic blocks due to adding copyins and copyouts. */
+
+static void
+range_update_basic_block (stream, first_insn, new_bb,
+ new_bb_count, range_max_regno)
+ FILE *stream;
+ rtx first_insn;
+ bb_link *new_bb;
+ int new_bb_count;
+ int range_max_regno;
+{
+ int i;
+ rtx insn;
+ rtx range;
+ rtx block_end;
+ rtx block_start;
+ int block;
+ int in_block_p;
+ int old_n_basic_blocks = n_basic_blocks;
+ int *map_bb = (int *) alloca (sizeof (int) * n_basic_blocks);
+ regset live = ALLOCA_REG_SET ();
+
+ COPY_REG_SET (live, basic_block_live_at_start[0]);
+
+ /* Go through and add NOTE_INSN_LIVE notes for each current basic block. */
+ for (i = 0; i < old_n_basic_blocks; i++)
+ {
+ rtx p = emit_note_before (NOTE_INSN_LIVE, BLOCK_HEAD (i));
+ NOTE_LIVE_INFO (p) = gen_rtx (RANGE_LIVE, VOIDmode,
+ basic_block_live_at_start[i], i);
+ map_bb[i] = -1;
+
+ if (stream)
+ {
+ fprintf (stream,
+ "Old basic block #%d, first insn %d, last insn %d, live",
+ i,
+ INSN_UID (BLOCK_HEAD (i)),
+ INSN_UID (BLOCK_END (i)));
+ bitmap_print (stream, basic_block_live_at_start[i], " {", "}\n");
+ }
+ }
+
+ if (stream)
+ putc ('\n', stream);
+
+ /* Recalculate the basic blocks. */
+ free ((char *)x_basic_block_head);
+ free ((char *)x_basic_block_end);
+ x_basic_block_head = x_basic_block_end = (rtx *)0;
+ find_basic_blocks (first_insn, max_regno, stream);
+ free_basic_block_vars (TRUE);
+
+ /* Restore the live information. We assume that flow will find either a
+ previous start of a basic block, or the newly created insn blocks as
+ the start of the new basic blocks. */
+
+ if (old_n_basic_blocks != n_basic_blocks)
+ basic_block_live_at_start
+ = (regset *) oballoc (sizeof (regset) * n_basic_blocks);
+
+ init_regset_vector (basic_block_live_at_start, n_basic_blocks,
+ rtl_obstack);
+
+ block = 0;
+ in_block_p = FALSE;
+ block_start = BLOCK_HEAD (0);
+ block_end = BLOCK_END (0);
+ for (insn = first_insn; insn; insn = NEXT_INSN (insn))
+ {
+ /* If this is the start of a basic block update live information. */
+ if (insn == block_start)
+ {
+ int i;
+ in_block_p = TRUE;
+
+ /* See if this was the start of one of the "new" basic
+ blocks. If so, get register livetime information from
+ the data we saved when we created the range. */
+ for (i = 0; i < new_bb_count; i++)
+ if (new_bb[i].first_insn == insn)
+ break;
+
+ if (i < new_bb_count)
+ COPY_REG_SET (live, new_bb[i].live_at_start);
+
+ COPY_REG_SET (basic_block_live_at_start[block], live);
+ }
+
+ if (GET_CODE (insn) == NOTE)
+ {
+ /* Is this where an old basic block began? */
+ if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LIVE)
+ {
+ rtx info = NOTE_LIVE_INFO (insn);
+ COPY_REG_SET (live, RANGE_LIVE_BITMAP (info));
+ map_bb[RANGE_LIVE_ORIG_BLOCK (info)] = block;
+ FREE_REG_SET (RANGE_LIVE_BITMAP (info));
+ NOTE_LIVE_INFO (insn) = NULL_RTX;
+ if (stream)
+ fprintf (stream, "Old basic block #%d is now %d.\n",
+ RANGE_LIVE_ORIG_BLOCK (info), block);
+ }
+
+ /* If a range start/end, use stored live information. */
+ else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_RANGE_START)
+ {
+ rtx ri = NOTE_RANGE_INFO (insn);
+ int old_block = RANGE_INFO_BB_START (ri);
+
+ RANGE_INFO_BB_START (ri) = block;
+ COPY_REG_SET (live, RANGE_INFO_LIVE_START (ri));
+ if (stream)
+ fprintf (stream,
+ "Changing range start basic block from %d to %d\n",
+ old_block, block);
+ }
+
+ else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_RANGE_END)
+ {
+ rtx ri = NOTE_RANGE_INFO (insn);
+ int old_block = RANGE_INFO_BB_END (ri);
+ int new_block = (in_block_p) ? block : block-1;
+
+ RANGE_INFO_BB_END (ri) = new_block;
+ COPY_REG_SET (live, RANGE_INFO_LIVE_END (ri));
+ if (stream)
+ fprintf (stream,
+ "Changing range end basic block from %d to %d\n",
+ old_block, new_block);
+ }
+ }
+
+ /* Update live/dead information. */
+ if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ range_basic_insn (insn, live, range_max_regno);
+
+ /* Advance basic block if at end. */
+ if (insn == block_end)
+ {
+ block++;
+ in_block_p = FALSE;
+ if (block < n_basic_blocks)
+ {
+ block_start = BLOCK_HEAD (block);
+ block_end = BLOCK_END (block);
+ }
+ else
+ block_start = block_end = NULL_RTX;
+ }
+ }
+
+ if (stream)
+ {
+ putc ('\n', stream);
+ fflush (stream);
+ }
+
+ /* Update REG_BASIC_BLOCK field now. */
+ for (i = 0; i < max_regno; i++)
+ {
+ if (REG_BASIC_BLOCK (i) >= 0)
+ REG_BASIC_BLOCK (i) = map_bb[REG_BASIC_BLOCK (i)];
+ }
+}
+
+
+/* Allocate the new registers for live range splitting. Do this after we've
+ scanned all of the insns, so that we grow the tables only once. */
+
+static void
+range_finish (stream, first_insn, count, range_max_regno)
+ FILE *stream;
+ rtx first_insn;
+ int count;
+ int range_max_regno;
+{
+ rtx range;
+ int new_max_regno = max_reg_num () + count;
+ rtx *replacements = (rtx *) alloca (new_max_regno * sizeof (rtx));
+ regset old_dead = ALLOCA_REG_SET ();
+ regset new_live = ALLOCA_REG_SET ();
+ regset copyouts = ALLOCA_REG_SET ();
+ rtx insn;
+ int i;
+ tree *block_list /* set up NOTE_BLOCK_NUM field */
+ = ((write_symbols == NO_DEBUG)
+ ? (tree *)0
+ : identify_blocks (DECL_INITIAL (current_function_decl), first_insn));
+
+ bb_link *new_bb;
+ int new_bb_count = 0;
+ int max_bb_count = 0;
+
+ no_new_pseudos = 0;
+ for (range = live_range_list; range; range = XEXP (range, 1))
+ max_bb_count += 2;
+
+ new_bb = (bb_link *) alloca (sizeof (bb_link) * max_bb_count);
+ bzero ((char *)new_bb, sizeof (bb_link) * max_bb_count);
+
+ if (stream)
+ putc ('\n', stream);
+
+ /* Grow the register tables */
+ allocate_reg_info (new_max_regno, FALSE, FALSE);
+
+ for (range = live_range_list; range; range = XEXP (range, 1))
+ {
+ rtx range_start = XEXP (range, 0);
+ rtx ri = NOTE_RANGE_INFO (range_start);
+ rtx range_end = RANGE_INFO_NOTE_END (ri);
+ int bb_start = RANGE_INFO_BB_START (ri);
+ int bb_end = RANGE_INFO_BB_END (ri);
+ int bb = (bb_start >= 0 && bb_start == bb_end) ? bb_start : -2;
+ rtx after;
+ rtx before;
+ int new_scope_p = (write_symbols != NO_DEBUG /* create new scope */
+ && flag_live_range_scope /* block for vars? */
+ && (write_symbols != DBX_DEBUG
+ || !LIVE_RANGE_GDBSTAB_P ()));
+
+ after = range_start;
+ before = range_end;
+
+ bzero ((char *)replacements, new_max_regno * sizeof (rtx));
+ CLEAR_REG_SET (old_dead);
+ CLEAR_REG_SET (copyouts);
+
+ /* Allocate new registers, set up the fields needed. */
+ for (i = 0; i < (int)RANGE_INFO_NUM_REGS (ri); i++)
+ {
+ int old_regno = RANGE_REG_PSEUDO (ri, i);
+ rtx old_reg = regno_reg_rtx[old_regno];
+ enum machine_mode mode = GET_MODE (old_reg);
+ rtx new_reg = gen_reg_rtx (mode);
+ int new_regno = REGNO (new_reg);
+
+ replacements[old_regno] = new_reg;
+
+ RANGE_REG_COPY (ri, i) = new_regno;
+ REG_N_RANGE_COPY_P (new_regno) = TRUE;
+ REG_N_REFS (new_regno) = RANGE_REG_REFS (ri, i);
+ REG_N_SETS (new_regno) = RANGE_REG_SETS (ri, i);
+ REG_N_DEATHS (new_regno) = RANGE_REG_DEATHS (ri, i);
+ REG_LIVE_LENGTH (new_regno) = RANGE_REG_LIVE_LENGTH (ri, i);
+ REG_N_CALLS_CROSSED (new_regno) = RANGE_REG_N_CALLS (ri, i);
+ REG_CHANGES_SIZE (new_regno) = 0;
+ REG_BASIC_BLOCK (new_regno) = bb;
+ REGNO_POINTER_FLAG (new_regno) = REGNO_POINTER_FLAG (old_regno);
+ REGNO_POINTER_ALIGN (new_regno) = REGNO_POINTER_ALIGN (old_regno);
+ REG_FUNCTION_VALUE_P (new_reg) = REG_FUNCTION_VALUE_P (old_reg);
+ REG_USERVAR_P (new_reg) = REG_USERVAR_P (old_reg);
+ REG_LOOP_TEST_P (new_reg) = REG_LOOP_TEST_P (old_reg);
+ RTX_UNCHANGING_P (new_reg) = RTX_UNCHANGING_P (old_reg);
+
+#if 0
+ /* Until we can make sure we get this right, don't update the
+ reference counts on the old register. */
+ REG_N_REFS (old_regno) -= REG_N_REFS (new_regno);
+ REG_N_SETS (old_regno) -= REG_N_SETS (new_regno);
+ REG_N_DEATHS (old_regno) -= REG_N_DEATHS (new_regno);
+ REG_N_CALLS_CROSSED (old_regno) -= REG_N_CALLS_CROSSED (new_regno);
+ REG_LIVE_LENGTH (old_regno) -= REG_LIVE_LENGTH (new_regno);
+
+ if (REG_N_REFS (old_regno) <= 0)
+ error ("Setting # references of register %d to %d\n",
+ old_regno, REG_N_REFS (old_regno));
+
+ if (REG_N_SETS (old_regno) < 0)
+ error ("Setting # sets of register %d to %d\n",
+ old_regno, REG_N_SETS (old_regno));
+
+ if (REG_N_CALLS_CROSSED (old_regno) < 0)
+ error ("Setting # calls crossed of register %d to %d\n",
+ old_regno, REG_N_CALLS_CROSSED (old_regno));
+
+ if (REG_N_DEATHS (old_regno) < 0)
+ error ("Setting # deaths of register %d to %d\n",
+ old_regno, REG_N_SETS (old_regno));
+
+ if (REG_LIVE_LENGTH (old_regno) <= 0)
+ error ("Setting live length of register %d to %d\n",
+ old_regno, REG_LIVE_LENGTH (old_regno));
+#endif
+
+ SET_REGNO_REG_SET (old_dead, old_regno);
+
+ /* If this is a user variable, add the range into the list of
+ different ranges the variable spans. */
+ if (RANGE_REG_SYMBOL_NODE (ri, i))
+ {
+ tree sym = RANGE_REG_SYMBOL_NODE (ri, i);
+ rtx var = DECL_LIVE_RANGE_RTL (sym);
+
+ if (!var)
+ DECL_LIVE_RANGE_RTL (sym) = var
+ = gen_rtx (RANGE_VAR, VOIDmode, NULL_RTX,
+ RANGE_REG_BLOCK_NODE (ri, i), 0);
+
+ RANGE_VAR_NUM (var)++;
+ RANGE_VAR_LIST (var) = gen_rtx (EXPR_LIST, VOIDmode, ri,
+ RANGE_VAR_LIST (var));
+ }
+
+#if 0
+ /* global.c implements regs_may_share as requiring the registers
+ to share the same hard register. */
+ regs_may_share = gen_rtx (EXPR_LIST, VOIDmode, old_reg,
+ gen_rtx (EXPR_LIST, VOIDmode, new_reg,
+ regs_may_share));
+#endif
+
+ /* Create a new scoping block for debug information if needed. */
+ if (new_scope_p
+ && RANGE_REG_SYMBOL_NODE (ri, i) != NULL_TREE
+ && RANGE_REG_BLOCK_NODE (ri, i) != NULL_TREE)
+ {
+ new_scope_p = FALSE;
+ range_start = emit_note_after (NOTE_INSN_BLOCK_BEG, range_start);
+ NOTE_BLOCK_NUMBER (range_start) = NOTE_BLOCK_LIVE_RANGE_BLOCK;
+
+ range_end = emit_note_before (NOTE_INSN_BLOCK_END, range_end);
+ NOTE_BLOCK_NUMBER (range_end) = NOTE_BLOCK_LIVE_RANGE_BLOCK;
+
+ if (stream)
+ fprintf (stream, "Creating new scoping block\n");
+ }
+
+ /* If needed, generate the appropriate copies into and out of
+ the new register. Tell global.c that we want to share registers
+ if possible. Since we might be creating a new basic block
+ for the copyin or copyout, tell local alloc to keep its grubby
+ paws off of the registers that need copies. */
+ if ((RANGE_REG_COPY_FLAGS (ri, i) & LIVE_RANGE_COPYIN) != 0)
+ {
+ after
+ = emit_insn_after (GEN_FCN (mov_optab->handlers[(int) mode].insn_code)
+ (new_reg, old_reg), after);
+
+ RANGE_REG_LIVE_LENGTH (ri, i)++;
+ REG_LIVE_LENGTH (old_regno)++;
+ REG_LIVE_LENGTH (new_regno)++;
+ REG_N_REFS (old_regno)++;
+ REG_N_REFS (new_regno)++;
+ REG_N_SETS (new_regno)++;
+ REG_N_DEATHS (old_regno)++;
+ REG_BASIC_BLOCK (new_regno) = REG_BLOCK_GLOBAL;
+ REG_NOTES (after) = gen_rtx (EXPR_LIST, REG_EQUAL /* REG_EQUIV */, old_reg,
+ gen_rtx (EXPR_LIST, REG_DEAD,
+ old_reg,
+ REG_NOTES (after)));
+ }
+
+ if ((RANGE_REG_COPY_FLAGS (ri, i) & LIVE_RANGE_COPYOUT) != 0)
+ {
+ before
+ = emit_insn_before (GEN_FCN (mov_optab->handlers[(int) mode].insn_code)
+ (old_reg, new_reg), before);
+
+ RANGE_REG_LIVE_LENGTH (ri, i)++;
+ REG_LIVE_LENGTH (old_regno)++;
+ REG_LIVE_LENGTH (new_regno)++;
+ REG_N_REFS (old_regno)++;
+ REG_N_REFS (new_regno)++;
+ REG_N_SETS (old_regno)++;
+ REG_N_DEATHS (new_regno)++;
+ REG_BASIC_BLOCK (new_regno) = REG_BLOCK_GLOBAL;
+ REG_NOTES (before) = gen_rtx (EXPR_LIST, REG_DEAD, new_reg,
+ REG_NOTES (before));
+ SET_REGNO_REG_SET (copyouts, new_regno);
+ }
+ }
+
+ /* Add insns created for copyins to new basic block list, if new copyins
+ were created, and the insns aren't already part of a basic block. */
+ if (range_start != after)
+ {
+ int in_bb_p;
+ rtx end;
+
+ /* If the insns created are the first, add them to the beginning
+ of the basic block. */
+ if (bb_start == 0)
+ {
+ rtx temp = get_insns ();
+ /* Search forward until we hit a CODE_LABEL or real insn. */
+ while (! (GET_CODE (temp) == CODE_LABEL
+ || GET_RTX_CLASS (GET_CODE (temp)) == 'i'))
+ temp = NEXT_INSN (temp);
+ BLOCK_HEAD (0) = temp;
+ }
+
+
+ /* Check if the insns are already in the basic block */
+ in_bb_p = FALSE;
+ end = BLOCK_END (bb_start);
+ for (insn = BLOCK_HEAD (bb_start);
+ insn && insn != end;
+ insn = NEXT_INSN (insn))
+ {
+ if (insn == after)
+ {
+ in_bb_p = TRUE;
+ break;
+ }
+ }
+
+ /* If needed, create a new basic block. */
+ if (!in_bb_p)
+ {
+ bb_link *p = &new_bb[new_bb_count++];
+ p->first_insn = NEXT_INSN (range_start);
+ p->last_insn = after;
+ p->live_at_start = RANGE_INFO_LIVE_START (ri);
+ }
+ }
+
+ /* Add insns created for copyouts to new basic block list, if new
+ copyouts were created, and the insns aren't already part of a basic
+ block, or can be added to a basic block trivally. */
+ if (range_end != before)
+ {
+ int in_bb_p = FALSE;
+ rtx end = BLOCK_END (bb_end);
+
+ /* Check if the insns are already in the basic block */
+ for (insn = BLOCK_HEAD (bb_end);
+ insn && insn != end;
+ insn = NEXT_INSN (insn))
+ {
+ if (insn == before)
+ {
+ in_bb_p = TRUE;
+ break;
+ }
+ }
+
+ /* If needed, create a new basic block. */
+ if (!in_bb_p)
+ {
+ bb_link *p = &new_bb[new_bb_count++];
+ p->first_insn = before;
+ p->last_insn = PREV_INSN (range_end);
+ p->live_at_start = OBSTACK_ALLOC_REG_SET (rtl_obstack);
+ IOR_REG_SET (p->live_at_start, RANGE_INFO_LIVE_END (ri));
+ IOR_REG_SET (p->live_at_start, copyouts);
+ AND_COMPL_REG_SET (p->live_at_start, old_dead);
+ }
+ }
+
+ /* Replace the registers */
+ for (insn = NEXT_INSN (after);
+ insn != NULL_RTX && insn != before;
+ insn = NEXT_INSN (insn))
+ {
+ enum rtx_code code = GET_CODE (insn);
+
+ if (GET_RTX_CLASS (code) == 'i')
+ {
+ rtx note;
+ PATTERN (insn) = replace_regs (PATTERN (insn), replacements,
+ new_max_regno, TRUE);
+
+ for (note = REG_NOTES (insn);
+ note != NULL_RTX;
+ note = XEXP (note, 1))
+ {
+ if ((REG_NOTE_KIND (note) == REG_DEAD
+ || REG_NOTE_KIND (note) == REG_UNUSED)
+ && GET_CODE (XEXP (note, 0)) == REG
+ && replacements[ REGNO (XEXP (note, 0))] != NULL_RTX)
+ XEXP (note, 0) = replacements[ REGNO (XEXP (note, 0))];
+ }
+ }
+ }
+ }
+
+ if (stream)
+ fflush (stream);
+
+ /* Update # registers */
+ max_regno = new_max_regno;
+
+ /* Recalculate basic blocks if we need to. */
+ if (new_bb_count)
+ range_update_basic_block (stream, first_insn, new_bb,
+ new_bb_count, range_max_regno);
+
+ /* After recreating the basic block, update the live information,
+ replacing the old registers with the new copies. */
+ for (range = live_range_list; range; range = XEXP (range, 1))
+ {
+ rtx range_start = XEXP (range, 0);
+ rtx ri = NOTE_RANGE_INFO (range_start);
+ int bb_start = RANGE_INFO_BB_START (ri);
+ int bb_end = RANGE_INFO_BB_END (ri);
+ int block;
+
+ bzero ((char *)replacements, new_max_regno * sizeof (rtx));
+ CLEAR_REG_SET (old_dead);
+ for (i = 0; i < (int)RANGE_INFO_NUM_REGS (ri); i++)
+ {
+ int old_regno = RANGE_REG_PSEUDO (ri, i);
+ int new_regno = RANGE_REG_COPY (ri, i);
+ if (new_regno >= 0)
+ {
+ replacements[old_regno] = regno_reg_rtx[new_regno];
+ SET_REGNO_REG_SET (old_dead, old_regno);
+ }
+ }
+
+ /* Update live information */
+ for (block = bb_start+1; block <= bb_end; block++)
+ {
+ regset bits = basic_block_live_at_start[block];
+
+ CLEAR_REG_SET (new_live);
+ EXECUTE_IF_AND_IN_REG_SET (bits, old_dead,
+ FIRST_PSEUDO_REGISTER, i,
+ {
+ int n = REGNO (replacements[i]);
+ SET_REGNO_REG_SET (new_live, n);
+ });
+
+ AND_COMPL_REG_SET (bits, old_dead);
+ IOR_REG_SET (bits, new_live);
+ basic_block_live_at_start[block] = bits;
+ }
+
+ if (stream)
+ {
+ putc ('\n', stream);
+ live_range_print (stream, ri, "::", "");
+ }
+ }
+
+ /* Add new scoping blocks and reset NOTE_BLOCK_NUMBER field. */
+ if (write_symbols != NO_DEBUG)
+ {
+ reorder_blocks (block_list, DECL_INITIAL (current_function_decl),
+ first_insn);
+ free ((char *)block_list);
+ }
+
+ /* Release any storage allocated */
+ FREE_REG_SET (old_dead);
+ FREE_REG_SET (new_live);
+ FREE_REG_SET (copyouts);
+
+ if (stream)
+ {
+ putc ('\n', stream);
+ print_blocks_internal (stream, DECL_INITIAL (current_function_decl), 0);
+ putc ('\n', stream);
+ fflush (stream);
+ }
+ no_new_pseudos = 1;
+}
+
+/* Main function for live_range support. Return the number of variables that
+ were spilled to the stack were used in small loops and were copied into new
+ pseudo registers for the run of that loop. Since we are run after
+ flow_analysis and local_alloc, we have to set up the appropriate tables for
+ any new pseudo variables we create. */
+
+int
+live_range (first_insn, stream)
+ rtx first_insn;
+ FILE *stream;
+{
+ rtx insn;
+ rtx prev;
+ rtx next;
+ rtx loop_start = NULL_RTX;
+ rtx loop_prefix = NULL_RTX;
+ int count = 0;
+ int i;
+ int basic_block;
+ int user_block;
+ int loop_user_block;
+ int loop_depth;
+ int range_max_regno;
+ regset live;
+ regset simple_insns_live;
+ regset loop_live;
+ rtx simple_insns = NULL_RTX;
+ int *insn_ruid;
+ int ruid;
+
+ struct skip_flags {
+ int *flag;
+ char *reason;
+ };
+
+ /* Awkward cases we don't want to handle. */
+ static struct skip_flags skip[] = {
+ { &current_function_has_nonlocal_label, "nonlocal label" },
+ { &current_function_has_nonlocal_goto, "nonlocal goto" },
+ { &current_function_calls_setjmp, "calls setjmp" },
+ { &current_function_calls_longjmp, "calls longjmp" }
+ };
+
+ for (i = 0; i < (int)(sizeof (skip) / sizeof (skip[0])); i++)
+ if (*skip[i].flag)
+ {
+ if (stream)
+ fprintf (stream, "Function has %s, skipping live range splitting\n",
+ skip[i].reason);
+
+ return 0;
+ }
+
+ if (n_basic_blocks <= 0)
+ {
+ if (stream)
+ fprintf (stream, "Function has no more than 1 basic block, skipping live range splitting\n");
+
+ return 0;
+ }
+
+ live_range_list = NULL_RTX;
+ range_set = ALLOCA_REG_SET ();
+ range_used = ALLOCA_REG_SET ();
+ range_mixed_mode = ALLOCA_REG_SET ();
+ range_no_move = ALLOCA_REG_SET ();
+ range_live = ALLOCA_REG_SET ();
+ live = ALLOCA_REG_SET ();
+ simple_insns_live = ALLOCA_REG_SET ();
+ loop_live = ALLOCA_REG_SET ();
+ range_max_regno = max_regno;
+ range_info = (rinfo *) alloca (sizeof (rinfo) * max_regno);
+ range_regs = (int *) alloca (sizeof (int) * max_regno);
+ range_max_uid = (unsigned)get_max_uid ();
+ range_vars = (var_info *) alloca (sizeof (var_info) * max_regno);
+ range_block_insn = (bb_link **) alloca (sizeof (bb_link *) * range_max_uid);
+ range_block_orig = (bb_link *) alloca (sizeof (bb_link) * n_basic_blocks);
+ bzero ((char *)range_vars, sizeof (var_info) * max_regno);
+ bzero ((char *)range_block_insn, sizeof (bb_link *) * range_max_uid);
+ bzero ((char *)range_block_orig, sizeof (bb_link) * n_basic_blocks);
+
+ /* Figure out which basic block things are in. */
+ for (i = 0; i < n_basic_blocks; i++)
+ {
+ rtx end = BLOCK_END (i);
+ rtx head = BLOCK_HEAD (i);
+ range_block_orig[i].block = i;
+ range_block_orig[i].first_insn = head;
+ range_block_orig[i].last_insn = end;
+ range_block_orig[i].live_at_start = basic_block_live_at_start[i];
+
+ range_block_insn[INSN_UID (end)] = &range_block_orig[i];
+ for (insn = head; insn && insn != end; insn = NEXT_INSN (insn))
+ range_block_insn[INSN_UID (insn)] = &range_block_orig[i];
+ }
+
+ /* Map user variables to their pseudo register */
+ range_scan_blocks (DECL_INITIAL (current_function_decl),
+ DECL_ARGUMENTS (current_function_decl));
+
+ /* Search for inner loops that do not span logical block boundaries.
+ Include an non-jump INSNs before the loop to include any setup for the
+ loop that is not included within the LOOP_BEG note. */
+ basic_block = loop_user_block = loop_depth = 0;
+ user_block = 0;
+ COPY_REG_SET (live, basic_block_live_at_start[0]);
+
+ insn_ruid = (int *) alloca ((range_max_uid + 1) * sizeof (int));
+ bzero ((char *) insn_ruid, (range_max_uid + 1) * sizeof (int));
+ ruid = 0;
+
+ for (insn = first_insn; insn; insn = NEXT_INSN (insn))
+ {
+ int block_tmp;
+ enum rtx_code code = GET_CODE (insn);
+
+ /* This might be a note insn emitted by range_inner, in which case we
+ can't put it in insn_ruid because that will give an out-of-range
+ array access. Since we only use it for JUMP_INSNs this should be
+ OK. */
+
+ if (INSN_UID (insn) <= range_max_uid)
+ insn_ruid[INSN_UID (insn)] = ++ruid;
+
+ /* If this is a different basic block, update live variables. */
+ block_tmp = RANGE_BLOCK_NUM (insn);
+ if (block_tmp >= 0 && basic_block != block_tmp)
+ {
+ basic_block = block_tmp;
+ COPY_REG_SET (live, basic_block_live_at_start[basic_block]);
+ }
+
+ /* Keep track of liveness for simple insns that might preceed LOOP_BEG */
+ if (GET_CODE (insn) == INSN && simple_insns == NULL_RTX)
+ {
+#ifdef HAVE_cc0
+ if (reg_referenced_p (cc0_rtx, PATTERN (insn)))
+ simple_insns = NULL_RTX;
+ else
+#endif
+ {
+ simple_insns = insn;
+ COPY_REG_SET (simple_insns_live, live);
+ }
+ }
+ else if (GET_CODE (insn) != INSN)
+ {
+ /* Allow simple notes to not zap the simple_insns block */
+ if (GET_CODE (insn) != NOTE
+ || (NOTE_LINE_NUMBER (insn) < 0
+ && NOTE_LINE_NUMBER (insn) != NOTE_INSN_LOOP_BEG
+ && NOTE_LINE_NUMBER (insn) != NOTE_INSN_DELETED))
+ simple_insns = NULL_RTX;
+ }
+
+ /* Update live/dead information. */
+ if (GET_RTX_CLASS (code) == 'i')
+ range_basic_insn (insn, live, range_max_regno);
+
+ /* Look for inner loops */
+ else if (code == NOTE)
+ {
+ if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG)
+ {
+ /* Add simple insns that occur before the loop begins */
+ if (simple_insns)
+ {
+ loop_prefix = simple_insns;
+ COPY_REG_SET (loop_live, simple_insns_live);
+ }
+ else
+ {
+ loop_prefix = insn;
+ COPY_REG_SET (loop_live, live);
+ }
+
+ loop_start = insn;
+ loop_user_block = user_block;
+ loop_depth++;
+ }
+
+ else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END)
+ {
+ loop_depth--;
+ if (loop_start && loop_user_block == user_block)
+ {
+ rtx scan_start;
+
+ /* See whether a new basic block begins with the
+ next insn -- if so, use its live information. */
+ rtx follow_insn, p;
+ for (follow_insn = NEXT_INSN (insn);
+ (follow_insn
+ && ((block_tmp = RANGE_BLOCK_NUM (follow_insn)) < 0
+ || block_tmp == basic_block)
+ && GET_CODE (follow_insn) == NOTE);
+ follow_insn = NEXT_INSN (follow_insn))
+ ;
+
+ if (!follow_insn)
+ CLEAR_REG_SET (live);
+ else if (block_tmp >= 0 && block_tmp != basic_block)
+ COPY_REG_SET (live, basic_block_live_at_start[block_tmp]);
+
+ /* Do not create live ranges for phony loops. The code to
+ detect phony loops was mostly lifted from scan_loop.
+
+ Try to find the label for the start of the loop. */
+ for (p = NEXT_INSN (loop_start);
+ (p != insn
+ && GET_CODE (p) != CODE_LABEL
+ && GET_RTX_CLASS (GET_CODE (p)) != 'i'
+ && (GET_CODE (p) != NOTE
+ || (NOTE_LINE_NUMBER (p) != NOTE_INSN_LOOP_BEG
+ && NOTE_LINE_NUMBER (p) != NOTE_INSN_LOOP_END)));
+ p = NEXT_INSN (p))
+ ;
+
+ scan_start = p;
+
+ /* Detect a jump to the bottom of the loop. */
+ if (GET_CODE (p) == JUMP_INSN)
+ {
+ if (simplejump_p (p)
+ && JUMP_LABEL (p) != 0
+ /* Check to see whether the jump actually
+ jumps out of the loop (meaning it's no loop).
+ This case can happen for things like do
+ do {..} while (0). */
+ && insn_ruid[INSN_UID (JUMP_LABEL (p))] > 0
+ && (insn_ruid[INSN_UID (loop_start)]
+ <= insn_ruid[INSN_UID (JUMP_LABEL (p))])
+ && (insn_ruid[INSN_UID (insn)]
+ >= insn_ruid[INSN_UID (JUMP_LABEL (p))]))
+ scan_start = JUMP_LABEL (p);
+ }
+
+ /* If we did not find the CODE_LABEL for the start of this
+ loop, then we either have a phony loop or something very
+ strange has happened. Do not perform LRS opts on such
+ a loop. */
+ if (GET_CODE (scan_start) == CODE_LABEL)
+ count += range_inner (stream, loop_prefix, insn, loop_start,
+ insn, loop_live, live, loop_depth);
+ }
+
+ loop_start = NULL_RTX;
+ loop_prefix = NULL_RTX;
+ }
+
+ else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG)
+ user_block++;
+
+ else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)
+ user_block--;
+ }
+ }
+
+ /* Reverse list of live ranges so that it goes forwards, not backwards. */
+ prev = next = NULL_RTX;
+ for (insn = live_range_list; insn != NULL_RTX; insn = next)
+ {
+ next = XEXP (insn, 1);
+ XEXP (insn, 1) = prev;
+ prev = insn;
+ }
+ live_range_list = prev;
+
+ /* If we discovered any live ranges, create them now */
+ if (count)
+ range_finish (stream, first_insn, count, range_max_regno);
+
+ FREE_REG_SET (range_set);
+ FREE_REG_SET (range_used);
+ FREE_REG_SET (range_live);
+ FREE_REG_SET (range_mixed_mode);
+ FREE_REG_SET (range_no_move);
+ FREE_REG_SET (simple_insns_live);
+ FREE_REG_SET (loop_live);
+ FREE_REG_SET (live);
+ range_block_insn = (bb_link **)0;
+ range_block_orig = (bb_link *)0;
+ range_info = (rinfo *)0;
+ range_regs = (int *)0;
+
+ return count;
+}
+
+
+/* Initialize live_range information */
+
+void
+init_live_range ()
+{
+ live_range_list = NULL_RTX;
+}
+/* END CYGNUS LOCAL */
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-06 18:58:06 +0000