* emit-rtl.c (replace_equiv_address): New function.
* expr.h (replace_equiv_address): New declaration.
* explow.c (validize_mem): Call it instead of change_address and
also call if -fforce-addr and address is constant.
* expr.c: Replace more calls to change_address with adjust_address
and/or replace_equiv_address or to validize_mem.
* function.c, regmove.c, config/alpha/alpha.c: Likewise.
* config/arm/arm.md, config/clipper/clipper.md: Likewise.
* config/dsp16xx/dsp16xx.md, config/fr30/fr30.c: Likewise.
* config/i370/i370.md, config/i860/i860.md: Likewise.
* config/i960/i960.md, config/mips/mips.c: Likewise.
* config/mips/mips.md, config/pa/pa.md: Likewise.
* config/pdp11/pdp11.md, config/rs6000/rs6000.c: Likewise.
* config/rs6000/rs6000.md, config/sh/sh.md: Likewise.
From-SVN: r43762
+Wed Jul 4 13:40:02 2001 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * emit-rtl.c (replace_equiv_address): New function.
+ * expr.h (replace_equiv_address): New declaration.
+ * explow.c (validize_mem): Call it instead of change_address and
+ also call if -fforce-addr and address is constant.
+ * expr.c: Replace more calls to change_address with adjust_address
+ and/or replace_equiv_address or to validize_mem.
+ * function.c, regmove.c, config/alpha/alpha.c: Likewise.
+ * config/arm/arm.md, config/clipper/clipper.md: Likewise.
+ * config/dsp16xx/dsp16xx.md, config/fr30/fr30.c: Likewise.
+ * config/i370/i370.md, config/i860/i860.md: Likewise.
+ * config/i960/i960.md, config/mips/mips.c: Likewise.
+ * config/mips/mips.md, config/pa/pa.md: Likewise.
+ * config/pdp11/pdp11.md, config/rs6000/rs6000.c: Likewise.
+ * config/rs6000/rs6000.md, config/sh/sh.md: Likewise.
+
2001-07-04 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
* bitmap.c (bitmap_union_of_diff): Don't use BITMAP_ALLOCA.
}
/* No appropriate mode; fall back on memory. */
- orig_src = change_address (orig_src, GET_MODE (orig_src),
- copy_addr_to_reg (XEXP (orig_src, 0)));
+ orig_src = replace_equiv_address (orig_src,
+ copy_addr_to_reg (XEXP (orig_src, 0)));
src_align = GET_MODE_BITSIZE (GET_MODE (tmp));
}
for (i = 0; i < words; ++i)
emit_move_insn (data_regs[nregs + i],
- change_address (orig_src, SImode,
- plus_constant (XEXP (orig_src, 0),
- ofs + i * 4)));
+ adjust_address (orig_src, SImode, ofs + i * 4));
nregs += words;
bytes -= words * 4;
/* No appropriate mode; fall back on memory. We can speed things
up by recognizing extra alignment information. */
- orig_dst = change_address (orig_dst, GET_MODE (orig_dst),
- copy_addr_to_reg (XEXP (orig_dst, 0)));
+ orig_dst = replace_equiv_address (orig_dst,
+ copy_addr_to_reg (XEXP (orig_dst, 0)));
dst_align = GET_MODE_BITSIZE (GET_MODE (tmp));
}
}
/* No appropriate mode; fall back on memory. */
- orig_dst = change_address (orig_dst, GET_MODE (orig_dst),
- copy_addr_to_reg (tmp));
+ orig_dst = replace_equiv_address (orig_dst, copy_addr_to_reg (tmp));
align = GET_MODE_BITSIZE (GET_MODE (XEXP (tmp, 0)));
}
"TARGET_ARM"
"
{
- rtx addr = XEXP (operands[1], 0);
+ rtx op1 = operands[1];
+ rtx addr = XEXP (op1, 0);
enum rtx_code code = GET_CODE (addr);
if ((code == PLUS && GET_CODE (XEXP (addr, 1)) != CONST_INT)
|| code == MINUS)
- addr = force_reg (SImode, addr);
+ op1 = replace_equiv_address (operands[1], force_reg (SImode, addr));
- operands[4] = change_address (operands[1], QImode,
- plus_constant (addr, 1));
+ operands[4] = adjust_address (op1, QImode, 1);
operands[1] = adjust_address (operands[1], QImode, 0);
operands[3] = gen_lowpart (QImode, operands[0]);
operands[0] = gen_lowpart (SImode, operands[0]);
"TARGET_ARM"
"
{
- rtx addr = XEXP (operands[1], 0);
+ rtx op1 = operands[1];
+ rtx addr = XEXP (op1, 0);
enum rtx_code code = GET_CODE (addr);
if ((code == PLUS && GET_CODE (XEXP (addr, 1)) != CONST_INT)
|| code == MINUS)
- addr = force_reg (SImode, addr);
+ op1 = replace_equiv_address (op1, force_reg (SImode, addr));
- operands[4] = change_address (operands[1], QImode,
- plus_constant (addr, 1));
+ operands[4] = adjust_address (op1, QImode, 1);
operands[1] = adjust_address (operands[1], QImode, 0);
operands[3] = gen_lowpart (QImode, operands[0]);
operands[0] = gen_lowpart (SImode, operands[0]);
{
HOST_WIDE_INT value = INTVAL (operands[1]);
rtx addr = XEXP (operands[0], 0);
+ rtx op0 = operands[0];
enum rtx_code code = GET_CODE (addr);
if ((code == PLUS && GET_CODE (XEXP (addr, 1)) != CONST_INT)
|| code == MINUS)
- addr = force_reg (SImode, addr);
+ op0 = replace_equiv_address (op0, force_reg (SImode, addr));
operands[1] = gen_reg_rtx (SImode);
if (BYTES_BIG_ENDIAN)
}
}
- operands[3] = change_address (operands[0], QImode,
- plus_constant (addr, 1));
+ operands[3] = adjust_address (op0, QImode, 1);
operands[0] = adjust_address (operands[0], QImode, 0);
}"
)
if (GET_CODE (operands[0]) == MEM
&& !memory_address_p (GET_MODE (operands[0]),
XEXP (operands[0], 0)))
- {
- rtx temp = copy_to_reg (XEXP (operands[0], 0));
- operands[0] = change_address (operands[0], VOIDmode, temp);
- }
+ operands[0]
+ = replace_equiv_address (operands[0],
+ copy_to_reg (XEXP (operands[0], 0)));
if (GET_CODE (operands[1]) == MEM
&& !memory_address_p (GET_MODE (operands[1]),
XEXP (operands[1], 0)))
- {
- rtx temp = copy_to_reg (XEXP (operands[1], 0));
- operands[1] = change_address (operands[1], VOIDmode, temp);
- }
+ operands[1]
+ = replace_equiv_address (operands[1],
+ copy_to_reg (XEXP (operands[1], 0)));
}
/* Handle loading a large integer during reload */
else if (GET_CODE (operands[1]) == CONST_INT
if (GET_CODE (operands[0]) == MEM
&& !memory_address_p (GET_MODE (operands[0]),
XEXP (operands[0], 0)))
- {
- rtx temp = copy_to_reg (XEXP (operands[0], 0));
- operands[0] = change_address (operands[0], VOIDmode, temp);
- }
+ operands[0]
+ = replace_equiv_address (operands[0],
+ copy_to_reg (XEXP (operands[0], 0)));
if (GET_CODE (operands[1]) == MEM
&& !memory_address_p (GET_MODE (operands[1]),
XEXP (operands[1], 0)))
- {
- rtx temp = copy_to_reg (XEXP (operands[1], 0));
- operands[1] = change_address (operands[1], VOIDmode, temp);
- }
+ operands[1]
+ = replace_equiv_address (operands[1],
+ copy_to_reg (XEXP (operands[1], 0)));
}
/* Handle loading a large integer during reload */
else if (GET_CODE (operands[1]) == CONST_INT
operands[6] = addr0;
operands[7] = addr1;
- operands[0] = change_address (operands[0], VOIDmode, addr0);
- operands[1] = change_address (operands[1], VOIDmode, addr1);
+ operands[0] = replace_equiv_address (operands[0], addr0);
+ operands[1] = replace_equiv_address (operands[1], addr1);
if (GET_CODE (operands[2]) != CONST_INT)
operands[2] = force_reg (SImode, operands[2]);
operands[5] = addr0;
operands[6] = addr1;
- operands[0] = change_address (operands[0], VOIDmode, addr0);
- operands[1] = change_address (operands[1], VOIDmode, addr1);
+ operands[0] = replace_equiv_address (operands[0], VOIDmode, addr0);
+ operands[1] = replace_equiv_address (operands[1], VOIDmode, addr1);
}")
(define_insn ""
if (reverse)
{
emit_insn (gen_rtx_SET (VOIDmode, dest1,
- change_address (src, SImode, addr)));
+ adjust_address (src, SImode, 0)));
emit_insn (gen_rtx_SET (SImode, dest0,
gen_rtx_REG (SImode, REGNO (addr))));
emit_insn (gen_rtx_SET (SImode, dest0,
else
{
emit_insn (gen_rtx_SET (VOIDmode, dest0,
- change_address (src, SImode, addr)));
+ adjust_address (src, SImode, 0)));
emit_insn (gen_rtx_SET (SImode, dest1,
gen_rtx_REG (SImode, REGNO (addr))));
emit_insn (gen_rtx_SET (SImode, dest1,
src0 = operand_subword (src, 0, TRUE, mode);
src1 = operand_subword (src, 1, TRUE, mode);
- emit_insn (gen_rtx_SET (VOIDmode,
- change_address (dest, SImode, addr),
+ emit_insn (gen_rtx_SET (VOIDmode, adjust_address (dest, SImode, 0),
src0));
if (REGNO (addr) == STACK_POINTER_REGNUM
""
"
{
-/*
- XXX bogus, i think, unless change_address has a side effet we need
- rtx op0;
-
- op0 = XEXP (operands[0], 0);
- if (GET_CODE (op0) == REG
- || (GET_CODE (op0) == PLUS && GET_CODE (XEXP (op0, 0)) == REG
- && GET_CODE (XEXP (op0, 1)) == CONST_INT
- && (unsigned) INTVAL (XEXP (op0, 1)) < 4096))
- op0 = operands[0];
- else
- op0 = change_address (operands[0], VOIDmode,
- copy_to_mode_reg (SImode, op0));
-
-*/
{
/* implementation suggested by Richard Henderson <rth@cygnus.com> */
rtx reg1 = gen_reg_rtx (DImode);
&& (unsigned) INTVAL (XEXP (op0, 1)) < 4096))
op0 = operands[0];
else
- op0 = change_address (operands[0], VOIDmode,
- copy_to_mode_reg (SImode, op0));
+ op0 = replace_equiv_address (operands[0], copy_to_mode_reg (SImode, op0));
op1 = XEXP (operands[1], 0);
if (GET_CODE (op1) == REG
&& (unsigned) INTVAL (XEXP (op1, 1)) < 4096))
op1 = operands[1];
else
- op1 = change_address (operands[1], VOIDmode,
- copy_to_mode_reg (SImode, op1));
+ op1 = replace_equiv_address (operands[1], copy_to_mode_reg (SImode, op1));
if (GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) < 256)
emit_insn (gen_rtx_PARALLEL (VOIDmode,
operands[7] = copy_to_mode_reg (SImode, XEXP (operands[0], 0));
operands[8] = copy_to_mode_reg (SImode, XEXP (operands[1], 0));
- operands[0] = change_address (operands[0], VOIDmode, operands[7]);
- operands[1] = change_address (operands[1], VOIDmode, operands[8]);
+ operands[0] = replace_equiv_address (operands[0], operands[7]);
+ operands[1] = replace_equiv_address (operands[1], operands[8]);
}")
(define_insn ""
/* Make sure the address is just one reg and will stay that way. */
if (! call_insn_operand (operands[0], QImode))
operands[0]
- = change_address (operands[0], VOIDmode,
- copy_to_mode_reg (Pmode, XEXP (operands[0], 0)));
+ = replace_equiv_address (operands[0],
+ copy_to_mode_reg (Pmode,
+ XEXP (operands[0], 0)));
if (INTVAL (operands[1]) > 0)
{
emit_move_insn (arg_pointer_rtx, stack_pointer_rtx);
/* Make sure the address is just one reg and will stay that way. */
if (! call_insn_operand (operands[1], QImode))
operands[1]
- = change_address (operands[1], VOIDmode,
- copy_to_mode_reg (Pmode, XEXP (operands[1], 0)));
+ = replace_equiv_address (operands[1],
+ copy_to_mode_reg (Pmode,
+ XEXP (operands[1], 0)));
if (INTVAL (operands[2]) > 0)
{
emit_move_insn (arg_pointer_rtx, stack_pointer_rtx);
{
int regno;
int count;
- rtx from;
+ int offset = 0;
if (GET_CODE (operands[0]) != MEM
|| GET_CODE (operands[1]) != REG
FAIL;
regno = REGNO (operands[1]);
- from = memory_address (SImode, XEXP (operands[0], 0));
while (count >= 4 && ((regno & 3) == 0))
{
- emit_move_insn (change_address (operands[0], TImode, from),
+ emit_move_insn (adjust_address (operands[0], TImode, offset),
gen_rtx_REG (TImode, regno));
count -= 4;
regno += 4;
- from = memory_address (TImode, plus_constant (from, 16));
+ offset += 16;
}
while (count >= 2 && ((regno & 1) == 0))
{
- emit_move_insn (change_address (operands[0], DImode, from),
+ emit_move_insn (adjust_address (operands[0], DImode, offset),
gen_rtx_REG (DImode, regno));
count -= 2;
regno += 2;
- from = memory_address (DImode, plus_constant (from, 8));
+ offset += 8;
}
while (count > 0)
{
- emit_move_insn (change_address (operands[0], SImode, from),
+ emit_move_insn (adjust_address (operands[0], SImode, offset),
gen_rtx_REG (SImode, regno));
count -= 1;
regno += 1;
- from = memory_address (SImode, plus_constant (from, 4));
+ offset += 4;
}
DONE;
}")
rtx src_reg; /* register holding source address */
unsigned int bytes; /* # bytes to move */
int align; /* alignment */
- rtx orig_dest; /* original dest for change_address */
+ rtx orig_dest; /* original dest */
rtx orig_src; /* original source for making a reg note */
{
- rtx dest_mem = change_address (orig_dest, BLKmode, dest_reg);
- rtx src_mem = change_address (orig_src, BLKmode, src_reg);
+ rtx dest_mem = replace_equiv_address (orig_dest, dest_reg);
+ rtx src_mem = replace_equiv_address (orig_src, src_reg);
rtx align_rtx = GEN_INT (align);
rtx label;
rtx final_src;
move_by_pieces (orig_dest, orig_src, bytes, align * BITS_PER_WORD);
else if (constp && bytes <= (unsigned)2 * MAX_MOVE_BYTES)
- emit_insn (gen_movstrsi_internal (change_address (orig_dest, BLKmode,
- dest_reg),
- change_address (orig_src, BLKmode,
- src_reg),
+ emit_insn (gen_movstrsi_internal (replace_equiv_address (orig_dest,
+ dest_reg),
+ replace_equiv_address (orig_src,
+ src_reg),
bytes_rtx, align_rtx));
else if (constp && align >= (unsigned) UNITS_PER_WORD && optimize)
/* Bytes at the end of the loop. */
if (leftover)
- emit_insn (gen_movstrsi_internal (change_address (orig_dest, BLKmode,
- dest_reg),
- change_address (orig_src, BLKmode,
- src_reg),
+ emit_insn (gen_movstrsi_internal (replace_equiv_address (orig_dest,
+ dest_reg),
+ replace_equiv_address (orig_src,
+ src_reg),
GEN_INT (leftover),
GEN_INT (align)));
}
{
rtx memword, offword, hi_word, lo_word;
rtx addr = find_replacement (&XEXP (operands[1], 0));
- rtx op1 = change_address (operands[1], VOIDmode, addr);
+ rtx op1 = replace_equiv_address (operands[1], addr);
scratch = gen_rtx_REG (SImode, REGNO (scratch));
memword = adjust_address (op1, SImode, 0);
{
rtx scratch, memword, offword, hi_word, lo_word;
rtx addr = find_replacement (&XEXP (operands[0], 0));
- rtx op0 = change_address (operands[0], VOIDmode, addr);
+ rtx op0 = replace_equiv_address (operands[0], addr);
scratch = gen_rtx_REG (SImode, REGNO (operands[2]));
memword = adjust_address (op0, SImode, 0);
/* Fall through means we're going to use our block move pattern. */
operands[0]
- = change_address (operands[0], VOIDmode,
- copy_to_mode_reg (SImode, XEXP (operands[0], 0)));
+ = replace_equiv_address (operands[0],
+ copy_to_mode_reg (SImode, XEXP (operands[0], 0)));
operands[1]
- = change_address (operands[1], VOIDmode,
- copy_to_mode_reg (SImode, XEXP (operands[1], 0)));
+ = replace_equiv_address (operands[1],
+ copy_to_mode_reg (SImode, XEXP (operands[1], 0)));
operands[4] = gen_reg_rtx (SImode);
operands[5] = gen_reg_rtx (SImode);
operands[6] = gen_reg_rtx (SImode);
"
{
operands[0]
- = change_address (operands[0], VOIDmode,
- copy_to_mode_reg (Pmode, XEXP (operands[0], 0)));
+ = replace_equiv_address (operands[0],
+ copy_to_mode_reg (Pmode, XEXP (operands[0], 0)));
operands[1]
- = change_address (operands[1], VOIDmode,
- copy_to_mode_reg (Pmode, XEXP (operands[1], 0)));
+ = replace_equiv_address (operands[1],
+ copy_to_mode_reg (Pmode, XEXP (operands[1], 0)));
operands[5] = XEXP (operands[0], 0);
operands[6] = XEXP (operands[1], 0);
if (GET_CODE (operands[0]) == MEM
&& GET_CODE (XEXP (operands[0], 0)) != REG
&& ! reload_in_progress)
- operands[0] = change_address (operands[0], TImode,
- copy_addr_to_reg (XEXP (operands[0], 0)));
+ operands[0]
+ = replace_equiv_address (operands[0],
+ copy_addr_to_reg (XEXP (operands[0], 0)));
if (GET_CODE (operands[1]) == MEM
&& GET_CODE (XEXP (operands[1], 0)) != REG
&& ! reload_in_progress)
- operands[1] = change_address (operands[1], TImode,
- copy_addr_to_reg (XEXP (operands[1], 0)));
+ operands[1]
+ = replace_equiv_address (operands[1],
+ copy_addr_to_reg (XEXP (operands[1], 0)));
break;
default:
;; Machine description for IBM RISC System 6000 (POWER) for GNU C compiler
;; Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
-;; 1999, 2000 Free Software Foundation, Inc.
+;; 1999, 2000, 2001 Free Software Foundation, Inc.
;; Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
;; This file is part of GNU CC.
{
int regno;
int count;
- rtx from;
+ rtx op1;
int i;
/* Support only loading a constant number of fixed-point registers from
regno = REGNO (operands[0]);
operands[3] = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (count));
- from = force_reg (SImode, XEXP (operands[1], 0));
+ op1 = replace_equiv_address (operands[1],
+ force_reg (SImode, XEXP (operands[1], 0)));
for (i = 0; i < count; i++)
XVECEXP (operands[3], 0, i)
= gen_rtx_SET (VOIDmode, gen_rtx_REG (SImode, regno + i),
- change_address (operands[1], SImode,
- plus_constant (from, i * 4)));
+ adjust_address (op1, SImode, i * 4));
}")
(define_insn ""
int regno;
int count;
rtx to;
+ rtx op0;
int i;
/* Support only storing a constant number of fixed-point registers to
operands[3] = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (count + 1));
to = force_reg (SImode, XEXP (operands[0], 0));
+ op0 = replace_equiv_address (operands[0], to);
XVECEXP (operands[3], 0, 0)
- = gen_rtx_SET (VOIDmode, change_address (operands[0], SImode, to),
- operands[1]);
+ = gen_rtx_SET (VOIDmode, op0, operands[1]);
XVECEXP (operands[3], 0, 1) = gen_rtx_CLOBBER (VOIDmode,
gen_rtx_SCRATCH (SImode));
for (i = 1; i < count; i++)
XVECEXP (operands[3], 0, i + 1)
= gen_rtx_SET (VOIDmode,
- change_address (operands[0], SImode,
- plus_constant (to, i * 4)),
+ adjust_address (op0, SImode, i * 4),
gen_rtx_REG (SImode, regno + i));
}")
emit_insn (gen_movsi (shift_reg, operands[3]));
addr_target = copy_addr_to_reg (plus_constant (orig_address, size - 1));
- operands[0] = change_address (operands[0], QImode, addr_target);
+ operands[0] = replace_equiv_address (operands[0], addr_target);
emit_insn (gen_movqi (operands[0], gen_rtx_SUBREG (QImode, shift_reg, 0)));
while (size -= 1)
MEM_COPY_ATTRIBUTES (new, memref);
return new;
}
+
/* Return a memory reference like MEMREF, but with its mode changed
to MODE and its address offset by OFFSET bytes. */
return
change_address (memref, mode, plus_constant (XEXP (memref, 0), offset));
}
+
+/* Return a memory reference like MEMREF, but with its address changed to
+ ADDR. The caller is asserting that the actual piece of memory pointed
+ to is the same, just the form of the address is being changed, such as
+ by putting something into a register. */
+
+rtx
+replace_equiv_address (memref, addr)
+ rtx memref;
+ rtx addr;
+{
+ /* For now, this is just a wrapper for change_address, but eventually
+ will do memref tracking. */
+ return change_address (memref, VOIDmode, addr);
+}
\f
/* Return a newly created CODE_LABEL rtx with a unique label number. */
{
if (GET_CODE (ref) != MEM)
return ref;
- if (memory_address_p (GET_MODE (ref), XEXP (ref, 0)))
+ if (! (flag_force_addr && CONSTANT_ADDRESS_P (XEXP (ref, 0)))
+ && memory_address_p (GET_MODE (ref), XEXP (ref, 0)))
return ref;
+
/* Don't alter REF itself, since that is probably a stack slot. */
- return change_address (ref, GET_MODE (ref), XEXP (ref, 0));
+ return replace_equiv_address (ref, XEXP (ref, 0));
}
\f
/* Given REF, either a MEM or a REG, and T, either the type of X or
if (size <= UNITS_PER_WORD
&& (mode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0)) != BLKmode)
{
- emit_move_insn (change_address (x, mode, NULL),
- gen_rtx_REG (mode, regno));
+ emit_move_insn (adjust_address (x, mode, 0), gen_rtx_REG (mode, regno));
return;
}
&& ! push_operand (x, GET_MODE (x)))
|| (flag_force_addr
&& CONSTANT_ADDRESS_P (XEXP (x, 0)))))
- x = change_address (x, VOIDmode, XEXP (x, 0));
+ x = validize_mem (x);
if (GET_CODE (y) == MEM
&& (! memory_address_p (GET_MODE (y), XEXP (y, 0))
|| (flag_force_addr
&& CONSTANT_ADDRESS_P (XEXP (y, 0)))))
- y = change_address (y, VOIDmode, XEXP (y, 0));
+ y = validize_mem (y);
if (mode == BLKmode)
abort ();
if (GET_CODE (XEXP (temp, 0)) == REG)
to_rtx = temp;
else
- to_rtx = change_address (to_rtx, mode1,
- force_reg (GET_MODE (XEXP (temp, 0)),
- XEXP (temp, 0)));
+ to_rtx = (replace_equiv_address
+ (to_rtx, force_reg (GET_MODE (XEXP (temp, 0)),
+ XEXP (temp, 0))));
bitpos = 0;
}
&& GET_CODE (XEXP (addr, 1)) == CONST_INT
&& (XEXP (addr, 0) == virtual_incoming_args_rtx
|| XEXP (addr, 0) == virtual_stack_vars_rtx)))
- addr = copy_to_reg (addr);
+ target = replace_equiv_address (target, copy_to_reg (addr));
/* Now build a reference to just the desired component. */
- to_rtx = copy_rtx (change_address (target, mode,
- plus_constant (addr,
- (bitpos
- / BITS_PER_UNIT))));
+ to_rtx = copy_rtx (adjust_address (target, mode,
+ bitpos / BITS_PER_UNIT));
+
MEM_SET_IN_STRUCT_P (to_rtx, 1);
/* If the address of the structure varies, then it might be on
the stack. And, stack slots may be shared across scopes.
| TYPE_QUAL_CONST)),
0, 1, 1);
- if (! memory_address_p (TYPE_MODE (part_type), XEXP (target, 0)))
- target = change_address (target, TYPE_MODE (part_type), NULL_RTX);
parts = tree_cons (to_be_saved,
build (RTL_EXPR, part_type, NULL_TREE,
- (tree) target),
+ (tree) validize_mem (target)),
parts);
- store_expr (TREE_PURPOSE (parts), RTL_EXPR_RTL (TREE_VALUE (parts)), 0);
+ store_expr (TREE_PURPOSE (parts),
+ RTL_EXPR_RTL (TREE_VALUE (parts)), 0);
}
return parts;
}
abort ();
addr = XEXP (DECL_RTL (exp), 0);
if (GET_CODE (addr) == MEM)
- addr = change_address (addr, Pmode,
- fix_lexical_addr (XEXP (addr, 0), exp));
+ addr
+ = replace_equiv_address (addr,
+ fix_lexical_addr (XEXP (addr, 0), exp));
else
addr = fix_lexical_addr (addr, exp);
- temp = change_address (DECL_RTL (exp), mode, addr);
+ temp = replace_equiv_address (DECL_RTL (exp), addr);
}
/* This is the case of an array whose size is to be determined
else if (GET_CODE (DECL_RTL (exp)) == MEM
&& GET_CODE (XEXP (DECL_RTL (exp), 0)) == REG)
- temp = change_address (DECL_RTL (exp), GET_MODE (DECL_RTL (exp)),
- XEXP (DECL_RTL (exp), 0));
+ temp = validize_mem (DECL_RTL (exp));
/* If DECL_RTL is memory, we are in the normal case and either
the address is not valid or it is not a register and -fforce-addr
XEXP (DECL_RTL (exp), 0))
|| (flag_force_addr
&& GET_CODE (XEXP (DECL_RTL (exp), 0)) != REG)))
- temp = change_address (DECL_RTL (exp), VOIDmode,
- copy_rtx (XEXP (DECL_RTL (exp), 0)));
+ temp = replace_equiv_address (DECL_RTL (exp),
+ copy_rtx (XEXP (DECL_RTL (exp), 0)));
/* If we got something, return it. But first, set the alignment
if the address is a register. */
&& (! memory_address_p (mode, XEXP (TREE_CST_RTL (exp), 0))
|| (flag_force_addr
&& GET_CODE (XEXP (TREE_CST_RTL (exp), 0)) != REG)))
- return change_address (TREE_CST_RTL (exp), VOIDmode,
- copy_rtx (XEXP (TREE_CST_RTL (exp), 0)));
+ return replace_equiv_address (TREE_CST_RTL (exp),
+ copy_rtx (XEXP (TREE_CST_RTL (exp), 0)));
return TREE_CST_RTL (exp);
case EXPR_WITH_FILE_LOCATION:
}
if (temp == 0 || GET_CODE (temp) != MEM)
abort ();
- return change_address (temp, mode,
- fix_lexical_addr (XEXP (temp, 0), exp));
+ return
+ replace_equiv_address (temp,
+ fix_lexical_addr (XEXP (temp, 0), exp));
}
if (SAVE_EXPR_RTL (exp) == 0)
{
if (modifier != EXPAND_CONST_ADDRESS
&& modifier != EXPAND_INITIALIZER
- && modifier != EXPAND_SUM
- && (! memory_address_p (GET_MODE (constructor),
- XEXP (constructor, 0))
- || (flag_force_addr
- && GET_CODE (XEXP (constructor, 0)) != REG)))
- constructor = change_address (constructor, VOIDmode,
- XEXP (constructor, 0));
+ && modifier != EXPAND_SUM)
+ constructor = validize_mem (constructor);
+
return constructor;
}
else
if (GET_CODE (XEXP (temp, 0)) == REG)
op0 = temp;
else
- op0 = change_address (op0, mode1,
- force_reg (GET_MODE (XEXP (temp, 0)),
- XEXP (temp, 0)));
+ op0 = (replace_equiv_address
+ (op0,
+ force_reg (GET_MODE (XEXP (temp, 0)),
+ XEXP (temp, 0))));
bitpos = 0;
}
: copy_to_reg (XEXP (op0, 0)));
rtx temp, result;
- op0 = change_address (op0, VOIDmode, addr);
+ op0 = replace_equiv_address (op0, addr);
temp = force_reg (GET_MODE (op0), op0);
if (! (*insn_data[icode].operand[2].predicate) (op1, mode))
op1 = force_reg (mode, op1);
to MODE and its address offset by OFFSET bytes. */
extern rtx adjust_address PARAMS ((rtx, enum machine_mode, HOST_WIDE_INT));
+/* Return a memory reference like MEMREF, but with its address changed to
+ ADDR. The caller is asserting that the actual piece of memory pointed
+ to is the same, just the form of the address is being changed, such as
+ by putting something into a register. */
+extern rtx replace_equiv_address PARAMS ((rtx, rtx));
+
/* Return a memory reference like MEMREF, but which is known to have a
valid address. */
extern rtx validize_mem PARAMS ((rtx));
seq = gen_sequence ();
end_sequence ();
emit_insn_before (seq, insn);
- return change_address (x, VOIDmode, temp);
+ return replace_equiv_address (x, temp);
}
return x;
}
&& ! reg_mentioned_p (stack_pointer_rtx, src)
&& memory_address_p (GET_MODE (dest), stack_pointer_rtx)
&& validate_change (insn, &SET_DEST (set),
- change_address (dest, VOIDmode,
- stack_pointer_rtx), 0))
+ replace_equiv_address (dest,
+ stack_pointer_rtx),
+ 0))
{
if (last_sp_set == bb->head)
bb->head = NEXT_INSN (last_sp_set);
projects / platform / upstream / gcc.git / commitdiff