/* Analyze RTL for GNU compiler.
|
/* Analyze RTL for GNU compiler.
|
Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
|
Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
|
1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software
|
1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software
|
Foundation, Inc.
|
Foundation, Inc.
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
GCC 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
|
the terms of the GNU General Public License as published by the Free
|
Software Foundation; either version 3, or (at your option) any later
|
Software Foundation; either version 3, or (at your option) any later
|
version.
|
version.
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
for more details.
|
for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "toplev.h"
|
#include "toplev.h"
|
#include "rtl.h"
|
#include "rtl.h"
|
#include "hard-reg-set.h"
|
#include "hard-reg-set.h"
|
#include "insn-config.h"
|
#include "insn-config.h"
|
#include "recog.h"
|
#include "recog.h"
|
#include "target.h"
|
#include "target.h"
|
#include "output.h"
|
#include "output.h"
|
#include "tm_p.h"
|
#include "tm_p.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "real.h"
|
#include "real.h"
|
#include "regs.h"
|
#include "regs.h"
|
#include "function.h"
|
#include "function.h"
|
|
|
/* Forward declarations */
|
/* Forward declarations */
|
static void set_of_1 (rtx, rtx, void *);
|
static void set_of_1 (rtx, rtx, void *);
|
static bool covers_regno_p (rtx, unsigned int);
|
static bool covers_regno_p (rtx, unsigned int);
|
static bool covers_regno_no_parallel_p (rtx, unsigned int);
|
static bool covers_regno_no_parallel_p (rtx, unsigned int);
|
static int rtx_referenced_p_1 (rtx *, void *);
|
static int rtx_referenced_p_1 (rtx *, void *);
|
static int computed_jump_p_1 (rtx);
|
static int computed_jump_p_1 (rtx);
|
static void parms_set (rtx, rtx, void *);
|
static void parms_set (rtx, rtx, void *);
|
|
|
static unsigned HOST_WIDE_INT cached_nonzero_bits (rtx, enum machine_mode,
|
static unsigned HOST_WIDE_INT cached_nonzero_bits (rtx, enum machine_mode,
|
rtx, enum machine_mode,
|
rtx, enum machine_mode,
|
unsigned HOST_WIDE_INT);
|
unsigned HOST_WIDE_INT);
|
static unsigned HOST_WIDE_INT nonzero_bits1 (rtx, enum machine_mode, rtx,
|
static unsigned HOST_WIDE_INT nonzero_bits1 (rtx, enum machine_mode, rtx,
|
enum machine_mode,
|
enum machine_mode,
|
unsigned HOST_WIDE_INT);
|
unsigned HOST_WIDE_INT);
|
static unsigned int cached_num_sign_bit_copies (rtx, enum machine_mode, rtx,
|
static unsigned int cached_num_sign_bit_copies (rtx, enum machine_mode, rtx,
|
enum machine_mode,
|
enum machine_mode,
|
unsigned int);
|
unsigned int);
|
static unsigned int num_sign_bit_copies1 (rtx, enum machine_mode, rtx,
|
static unsigned int num_sign_bit_copies1 (rtx, enum machine_mode, rtx,
|
enum machine_mode, unsigned int);
|
enum machine_mode, unsigned int);
|
|
|
/* Offset of the first 'e', 'E' or 'V' operand for each rtx code, or
|
/* Offset of the first 'e', 'E' or 'V' operand for each rtx code, or
|
-1 if a code has no such operand. */
|
-1 if a code has no such operand. */
|
static int non_rtx_starting_operands[NUM_RTX_CODE];
|
static int non_rtx_starting_operands[NUM_RTX_CODE];
|
|
|
/* Bit flags that specify the machine subtype we are compiling for.
|
/* Bit flags that specify the machine subtype we are compiling for.
|
Bits are tested using macros TARGET_... defined in the tm.h file
|
Bits are tested using macros TARGET_... defined in the tm.h file
|
and set by `-m...' switches. Must be defined in rtlanal.c. */
|
and set by `-m...' switches. Must be defined in rtlanal.c. */
|
|
|
int target_flags;
|
int target_flags;
|
|
|
/* Truncation narrows the mode from SOURCE mode to DESTINATION mode.
|
/* Truncation narrows the mode from SOURCE mode to DESTINATION mode.
|
If TARGET_MODE_REP_EXTENDED (DESTINATION, DESTINATION_REP) is
|
If TARGET_MODE_REP_EXTENDED (DESTINATION, DESTINATION_REP) is
|
SIGN_EXTEND then while narrowing we also have to enforce the
|
SIGN_EXTEND then while narrowing we also have to enforce the
|
representation and sign-extend the value to mode DESTINATION_REP.
|
representation and sign-extend the value to mode DESTINATION_REP.
|
|
|
If the value is already sign-extended to DESTINATION_REP mode we
|
If the value is already sign-extended to DESTINATION_REP mode we
|
can just switch to DESTINATION mode on it. For each pair of
|
can just switch to DESTINATION mode on it. For each pair of
|
integral modes SOURCE and DESTINATION, when truncating from SOURCE
|
integral modes SOURCE and DESTINATION, when truncating from SOURCE
|
to DESTINATION, NUM_SIGN_BIT_COPIES_IN_REP[SOURCE][DESTINATION]
|
to DESTINATION, NUM_SIGN_BIT_COPIES_IN_REP[SOURCE][DESTINATION]
|
contains the number of high-order bits in SOURCE that have to be
|
contains the number of high-order bits in SOURCE that have to be
|
copies of the sign-bit so that we can do this mode-switch to
|
copies of the sign-bit so that we can do this mode-switch to
|
DESTINATION. */
|
DESTINATION. */
|
|
|
static unsigned int
|
static unsigned int
|
num_sign_bit_copies_in_rep[MAX_MODE_INT + 1][MAX_MODE_INT + 1];
|
num_sign_bit_copies_in_rep[MAX_MODE_INT + 1][MAX_MODE_INT + 1];
|
|
|
/* Return 1 if the value of X is unstable
|
/* Return 1 if the value of X is unstable
|
(would be different at a different point in the program).
|
(would be different at a different point in the program).
|
The frame pointer, arg pointer, etc. are considered stable
|
The frame pointer, arg pointer, etc. are considered stable
|
(within one function) and so is anything marked `unchanging'. */
|
(within one function) and so is anything marked `unchanging'. */
|
|
|
int
|
int
|
rtx_unstable_p (rtx x)
|
rtx_unstable_p (rtx x)
|
{
|
{
|
RTX_CODE code = GET_CODE (x);
|
RTX_CODE code = GET_CODE (x);
|
int i;
|
int i;
|
const char *fmt;
|
const char *fmt;
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case MEM:
|
case MEM:
|
return !MEM_READONLY_P (x) || rtx_unstable_p (XEXP (x, 0));
|
return !MEM_READONLY_P (x) || rtx_unstable_p (XEXP (x, 0));
|
|
|
case CONST:
|
case CONST:
|
case CONST_INT:
|
case CONST_INT:
|
case CONST_DOUBLE:
|
case CONST_DOUBLE:
|
case CONST_VECTOR:
|
case CONST_VECTOR:
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
case LABEL_REF:
|
case LABEL_REF:
|
return 0;
|
return 0;
|
|
|
case REG:
|
case REG:
|
/* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
|
/* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
|
if (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
|
if (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
|
/* The arg pointer varies if it is not a fixed register. */
|
/* The arg pointer varies if it is not a fixed register. */
|
|| (x == arg_pointer_rtx && fixed_regs[ARG_POINTER_REGNUM]))
|
|| (x == arg_pointer_rtx && fixed_regs[ARG_POINTER_REGNUM]))
|
return 0;
|
return 0;
|
#ifndef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
|
#ifndef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
|
/* ??? When call-clobbered, the value is stable modulo the restore
|
/* ??? When call-clobbered, the value is stable modulo the restore
|
that must happen after a call. This currently screws up local-alloc
|
that must happen after a call. This currently screws up local-alloc
|
into believing that the restore is not needed. */
|
into believing that the restore is not needed. */
|
if (x == pic_offset_table_rtx)
|
if (x == pic_offset_table_rtx)
|
return 0;
|
return 0;
|
#endif
|
#endif
|
return 1;
|
return 1;
|
|
|
case ASM_OPERANDS:
|
case ASM_OPERANDS:
|
if (MEM_VOLATILE_P (x))
|
if (MEM_VOLATILE_P (x))
|
return 1;
|
return 1;
|
|
|
/* Fall through. */
|
/* Fall through. */
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
fmt = GET_RTX_FORMAT (code);
|
fmt = GET_RTX_FORMAT (code);
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
if (fmt[i] == 'e')
|
if (fmt[i] == 'e')
|
{
|
{
|
if (rtx_unstable_p (XEXP (x, i)))
|
if (rtx_unstable_p (XEXP (x, i)))
|
return 1;
|
return 1;
|
}
|
}
|
else if (fmt[i] == 'E')
|
else if (fmt[i] == 'E')
|
{
|
{
|
int j;
|
int j;
|
for (j = 0; j < XVECLEN (x, i); j++)
|
for (j = 0; j < XVECLEN (x, i); j++)
|
if (rtx_unstable_p (XVECEXP (x, i, j)))
|
if (rtx_unstable_p (XVECEXP (x, i, j)))
|
return 1;
|
return 1;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return 1 if X has a value that can vary even between two
|
/* Return 1 if X has a value that can vary even between two
|
executions of the program. 0 means X can be compared reliably
|
executions of the program. 0 means X can be compared reliably
|
against certain constants or near-constants.
|
against certain constants or near-constants.
|
FOR_ALIAS is nonzero if we are called from alias analysis; if it is
|
FOR_ALIAS is nonzero if we are called from alias analysis; if it is
|
zero, we are slightly more conservative.
|
zero, we are slightly more conservative.
|
The frame pointer and the arg pointer are considered constant. */
|
The frame pointer and the arg pointer are considered constant. */
|
|
|
int
|
int
|
rtx_varies_p (rtx x, int for_alias)
|
rtx_varies_p (rtx x, int for_alias)
|
{
|
{
|
RTX_CODE code;
|
RTX_CODE code;
|
int i;
|
int i;
|
const char *fmt;
|
const char *fmt;
|
|
|
if (!x)
|
if (!x)
|
return 0;
|
return 0;
|
|
|
code = GET_CODE (x);
|
code = GET_CODE (x);
|
switch (code)
|
switch (code)
|
{
|
{
|
case MEM:
|
case MEM:
|
return !MEM_READONLY_P (x) || rtx_varies_p (XEXP (x, 0), for_alias);
|
return !MEM_READONLY_P (x) || rtx_varies_p (XEXP (x, 0), for_alias);
|
|
|
case CONST:
|
case CONST:
|
case CONST_INT:
|
case CONST_INT:
|
case CONST_DOUBLE:
|
case CONST_DOUBLE:
|
case CONST_VECTOR:
|
case CONST_VECTOR:
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
case LABEL_REF:
|
case LABEL_REF:
|
return 0;
|
return 0;
|
|
|
case REG:
|
case REG:
|
/* Note that we have to test for the actual rtx used for the frame
|
/* Note that we have to test for the actual rtx used for the frame
|
and arg pointers and not just the register number in case we have
|
and arg pointers and not just the register number in case we have
|
eliminated the frame and/or arg pointer and are using it
|
eliminated the frame and/or arg pointer and are using it
|
for pseudos. */
|
for pseudos. */
|
if (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
|
if (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
|
/* The arg pointer varies if it is not a fixed register. */
|
/* The arg pointer varies if it is not a fixed register. */
|
|| (x == arg_pointer_rtx && fixed_regs[ARG_POINTER_REGNUM]))
|
|| (x == arg_pointer_rtx && fixed_regs[ARG_POINTER_REGNUM]))
|
return 0;
|
return 0;
|
if (x == pic_offset_table_rtx
|
if (x == pic_offset_table_rtx
|
#ifdef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
|
#ifdef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
|
/* ??? When call-clobbered, the value is stable modulo the restore
|
/* ??? When call-clobbered, the value is stable modulo the restore
|
that must happen after a call. This currently screws up
|
that must happen after a call. This currently screws up
|
local-alloc into believing that the restore is not needed, so we
|
local-alloc into believing that the restore is not needed, so we
|
must return 0 only if we are called from alias analysis. */
|
must return 0 only if we are called from alias analysis. */
|
&& for_alias
|
&& for_alias
|
#endif
|
#endif
|
)
|
)
|
return 0;
|
return 0;
|
return 1;
|
return 1;
|
|
|
case LO_SUM:
|
case LO_SUM:
|
/* The operand 0 of a LO_SUM is considered constant
|
/* The operand 0 of a LO_SUM is considered constant
|
(in fact it is related specifically to operand 1)
|
(in fact it is related specifically to operand 1)
|
during alias analysis. */
|
during alias analysis. */
|
return (! for_alias && rtx_varies_p (XEXP (x, 0), for_alias))
|
return (! for_alias && rtx_varies_p (XEXP (x, 0), for_alias))
|
|| rtx_varies_p (XEXP (x, 1), for_alias);
|
|| rtx_varies_p (XEXP (x, 1), for_alias);
|
|
|
case ASM_OPERANDS:
|
case ASM_OPERANDS:
|
if (MEM_VOLATILE_P (x))
|
if (MEM_VOLATILE_P (x))
|
return 1;
|
return 1;
|
|
|
/* Fall through. */
|
/* Fall through. */
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
fmt = GET_RTX_FORMAT (code);
|
fmt = GET_RTX_FORMAT (code);
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
if (fmt[i] == 'e')
|
if (fmt[i] == 'e')
|
{
|
{
|
if (rtx_varies_p (XEXP (x, i), for_alias))
|
if (rtx_varies_p (XEXP (x, i), for_alias))
|
return 1;
|
return 1;
|
}
|
}
|
else if (fmt[i] == 'E')
|
else if (fmt[i] == 'E')
|
{
|
{
|
int j;
|
int j;
|
for (j = 0; j < XVECLEN (x, i); j++)
|
for (j = 0; j < XVECLEN (x, i); j++)
|
if (rtx_varies_p (XVECEXP (x, i, j), for_alias))
|
if (rtx_varies_p (XVECEXP (x, i, j), for_alias))
|
return 1;
|
return 1;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return nonzero if the use of X as an address in a MEM can cause a trap.
|
/* Return nonzero if the use of X as an address in a MEM can cause a trap.
|
MODE is the mode of the MEM (not that of X) and UNALIGNED_MEMS controls
|
MODE is the mode of the MEM (not that of X) and UNALIGNED_MEMS controls
|
whether nonzero is returned for unaligned memory accesses on strict
|
whether nonzero is returned for unaligned memory accesses on strict
|
alignment machines. */
|
alignment machines. */
|
|
|
static int
|
static int
|
rtx_addr_can_trap_p_1 (rtx x, enum machine_mode mode, bool unaligned_mems)
|
rtx_addr_can_trap_p_1 (rtx x, enum machine_mode mode, bool unaligned_mems)
|
{
|
{
|
enum rtx_code code = GET_CODE (x);
|
enum rtx_code code = GET_CODE (x);
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
return SYMBOL_REF_WEAK (x);
|
return SYMBOL_REF_WEAK (x);
|
|
|
case LABEL_REF:
|
case LABEL_REF:
|
return 0;
|
return 0;
|
|
|
case REG:
|
case REG:
|
/* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
|
/* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
|
if (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
|
if (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
|
|| x == stack_pointer_rtx
|
|| x == stack_pointer_rtx
|
/* The arg pointer varies if it is not a fixed register. */
|
/* The arg pointer varies if it is not a fixed register. */
|
|| (x == arg_pointer_rtx && fixed_regs[ARG_POINTER_REGNUM]))
|
|| (x == arg_pointer_rtx && fixed_regs[ARG_POINTER_REGNUM]))
|
return 0;
|
return 0;
|
/* All of the virtual frame registers are stack references. */
|
/* All of the virtual frame registers are stack references. */
|
if (REGNO (x) >= FIRST_VIRTUAL_REGISTER
|
if (REGNO (x) >= FIRST_VIRTUAL_REGISTER
|
&& REGNO (x) <= LAST_VIRTUAL_REGISTER)
|
&& REGNO (x) <= LAST_VIRTUAL_REGISTER)
|
return 0;
|
return 0;
|
return 1;
|
return 1;
|
|
|
case CONST:
|
case CONST:
|
return rtx_addr_can_trap_p_1 (XEXP (x, 0), mode, unaligned_mems);
|
return rtx_addr_can_trap_p_1 (XEXP (x, 0), mode, unaligned_mems);
|
|
|
case PLUS:
|
case PLUS:
|
/* An address is assumed not to trap if:
|
/* An address is assumed not to trap if:
|
- it is an address that can't trap plus a constant integer,
|
- it is an address that can't trap plus a constant integer,
|
with the proper remainder modulo the mode size if we are
|
with the proper remainder modulo the mode size if we are
|
considering unaligned memory references. */
|
considering unaligned memory references. */
|
if (!rtx_addr_can_trap_p_1 (XEXP (x, 0), mode, unaligned_mems)
|
if (!rtx_addr_can_trap_p_1 (XEXP (x, 0), mode, unaligned_mems)
|
&& GET_CODE (XEXP (x, 1)) == CONST_INT)
|
&& GET_CODE (XEXP (x, 1)) == CONST_INT)
|
{
|
{
|
HOST_WIDE_INT offset;
|
HOST_WIDE_INT offset;
|
|
|
if (!STRICT_ALIGNMENT
|
if (!STRICT_ALIGNMENT
|
|| !unaligned_mems
|
|| !unaligned_mems
|
|| GET_MODE_SIZE (mode) == 0)
|
|| GET_MODE_SIZE (mode) == 0)
|
return 0;
|
return 0;
|
|
|
offset = INTVAL (XEXP (x, 1));
|
offset = INTVAL (XEXP (x, 1));
|
|
|
#ifdef SPARC_STACK_BOUNDARY_HACK
|
#ifdef SPARC_STACK_BOUNDARY_HACK
|
/* ??? The SPARC port may claim a STACK_BOUNDARY higher than
|
/* ??? The SPARC port may claim a STACK_BOUNDARY higher than
|
the real alignment of %sp. However, when it does this, the
|
the real alignment of %sp. However, when it does this, the
|
alignment of %sp+STACK_POINTER_OFFSET is STACK_BOUNDARY. */
|
alignment of %sp+STACK_POINTER_OFFSET is STACK_BOUNDARY. */
|
if (SPARC_STACK_BOUNDARY_HACK
|
if (SPARC_STACK_BOUNDARY_HACK
|
&& (XEXP (x, 0) == stack_pointer_rtx
|
&& (XEXP (x, 0) == stack_pointer_rtx
|
|| XEXP (x, 0) == hard_frame_pointer_rtx))
|
|| XEXP (x, 0) == hard_frame_pointer_rtx))
|
offset -= STACK_POINTER_OFFSET;
|
offset -= STACK_POINTER_OFFSET;
|
#endif
|
#endif
|
|
|
return offset % GET_MODE_SIZE (mode) != 0;
|
return offset % GET_MODE_SIZE (mode) != 0;
|
}
|
}
|
|
|
/* - or it is the pic register plus a constant. */
|
/* - or it is the pic register plus a constant. */
|
if (XEXP (x, 0) == pic_offset_table_rtx && CONSTANT_P (XEXP (x, 1)))
|
if (XEXP (x, 0) == pic_offset_table_rtx && CONSTANT_P (XEXP (x, 1)))
|
return 0;
|
return 0;
|
|
|
return 1;
|
return 1;
|
|
|
case LO_SUM:
|
case LO_SUM:
|
case PRE_MODIFY:
|
case PRE_MODIFY:
|
return rtx_addr_can_trap_p_1 (XEXP (x, 1), mode, unaligned_mems);
|
return rtx_addr_can_trap_p_1 (XEXP (x, 1), mode, unaligned_mems);
|
|
|
case PRE_DEC:
|
case PRE_DEC:
|
case PRE_INC:
|
case PRE_INC:
|
case POST_DEC:
|
case POST_DEC:
|
case POST_INC:
|
case POST_INC:
|
case POST_MODIFY:
|
case POST_MODIFY:
|
return rtx_addr_can_trap_p_1 (XEXP (x, 0), mode, unaligned_mems);
|
return rtx_addr_can_trap_p_1 (XEXP (x, 0), mode, unaligned_mems);
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
/* If it isn't one of the case above, it can cause a trap. */
|
/* If it isn't one of the case above, it can cause a trap. */
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* Return nonzero if the use of X as an address in a MEM can cause a trap. */
|
/* Return nonzero if the use of X as an address in a MEM can cause a trap. */
|
|
|
int
|
int
|
rtx_addr_can_trap_p (rtx x)
|
rtx_addr_can_trap_p (rtx x)
|
{
|
{
|
return rtx_addr_can_trap_p_1 (x, VOIDmode, false);
|
return rtx_addr_can_trap_p_1 (x, VOIDmode, false);
|
}
|
}
|
|
|
/* Return true if X is an address that is known to not be zero. */
|
/* Return true if X is an address that is known to not be zero. */
|
|
|
bool
|
bool
|
nonzero_address_p (rtx x)
|
nonzero_address_p (rtx x)
|
{
|
{
|
enum rtx_code code = GET_CODE (x);
|
enum rtx_code code = GET_CODE (x);
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
return !SYMBOL_REF_WEAK (x);
|
return !SYMBOL_REF_WEAK (x);
|
|
|
case LABEL_REF:
|
case LABEL_REF:
|
return true;
|
return true;
|
|
|
case REG:
|
case REG:
|
/* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
|
/* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
|
if (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
|
if (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
|
|| x == stack_pointer_rtx
|
|| x == stack_pointer_rtx
|
|| (x == arg_pointer_rtx && fixed_regs[ARG_POINTER_REGNUM]))
|
|| (x == arg_pointer_rtx && fixed_regs[ARG_POINTER_REGNUM]))
|
return true;
|
return true;
|
/* All of the virtual frame registers are stack references. */
|
/* All of the virtual frame registers are stack references. */
|
if (REGNO (x) >= FIRST_VIRTUAL_REGISTER
|
if (REGNO (x) >= FIRST_VIRTUAL_REGISTER
|
&& REGNO (x) <= LAST_VIRTUAL_REGISTER)
|
&& REGNO (x) <= LAST_VIRTUAL_REGISTER)
|
return true;
|
return true;
|
return false;
|
return false;
|
|
|
case CONST:
|
case CONST:
|
return nonzero_address_p (XEXP (x, 0));
|
return nonzero_address_p (XEXP (x, 0));
|
|
|
case PLUS:
|
case PLUS:
|
if (GET_CODE (XEXP (x, 1)) == CONST_INT)
|
if (GET_CODE (XEXP (x, 1)) == CONST_INT)
|
return nonzero_address_p (XEXP (x, 0));
|
return nonzero_address_p (XEXP (x, 0));
|
/* Handle PIC references. */
|
/* Handle PIC references. */
|
else if (XEXP (x, 0) == pic_offset_table_rtx
|
else if (XEXP (x, 0) == pic_offset_table_rtx
|
&& CONSTANT_P (XEXP (x, 1)))
|
&& CONSTANT_P (XEXP (x, 1)))
|
return true;
|
return true;
|
return false;
|
return false;
|
|
|
case PRE_MODIFY:
|
case PRE_MODIFY:
|
/* Similar to the above; allow positive offsets. Further, since
|
/* Similar to the above; allow positive offsets. Further, since
|
auto-inc is only allowed in memories, the register must be a
|
auto-inc is only allowed in memories, the register must be a
|
pointer. */
|
pointer. */
|
if (GET_CODE (XEXP (x, 1)) == CONST_INT
|
if (GET_CODE (XEXP (x, 1)) == CONST_INT
|
&& INTVAL (XEXP (x, 1)) > 0)
|
&& INTVAL (XEXP (x, 1)) > 0)
|
return true;
|
return true;
|
return nonzero_address_p (XEXP (x, 0));
|
return nonzero_address_p (XEXP (x, 0));
|
|
|
case PRE_INC:
|
case PRE_INC:
|
/* Similarly. Further, the offset is always positive. */
|
/* Similarly. Further, the offset is always positive. */
|
return true;
|
return true;
|
|
|
case PRE_DEC:
|
case PRE_DEC:
|
case POST_DEC:
|
case POST_DEC:
|
case POST_INC:
|
case POST_INC:
|
case POST_MODIFY:
|
case POST_MODIFY:
|
return nonzero_address_p (XEXP (x, 0));
|
return nonzero_address_p (XEXP (x, 0));
|
|
|
case LO_SUM:
|
case LO_SUM:
|
return nonzero_address_p (XEXP (x, 1));
|
return nonzero_address_p (XEXP (x, 1));
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
/* If it isn't one of the case above, might be zero. */
|
/* If it isn't one of the case above, might be zero. */
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Return 1 if X refers to a memory location whose address
|
/* Return 1 if X refers to a memory location whose address
|
cannot be compared reliably with constant addresses,
|
cannot be compared reliably with constant addresses,
|
or if X refers to a BLKmode memory object.
|
or if X refers to a BLKmode memory object.
|
FOR_ALIAS is nonzero if we are called from alias analysis; if it is
|
FOR_ALIAS is nonzero if we are called from alias analysis; if it is
|
zero, we are slightly more conservative. */
|
zero, we are slightly more conservative. */
|
|
|
int
|
int
|
rtx_addr_varies_p (rtx x, int for_alias)
|
rtx_addr_varies_p (rtx x, int for_alias)
|
{
|
{
|
enum rtx_code code;
|
enum rtx_code code;
|
int i;
|
int i;
|
const char *fmt;
|
const char *fmt;
|
|
|
if (x == 0)
|
if (x == 0)
|
return 0;
|
return 0;
|
|
|
code = GET_CODE (x);
|
code = GET_CODE (x);
|
if (code == MEM)
|
if (code == MEM)
|
return GET_MODE (x) == BLKmode || rtx_varies_p (XEXP (x, 0), for_alias);
|
return GET_MODE (x) == BLKmode || rtx_varies_p (XEXP (x, 0), for_alias);
|
|
|
fmt = GET_RTX_FORMAT (code);
|
fmt = GET_RTX_FORMAT (code);
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
if (fmt[i] == 'e')
|
if (fmt[i] == 'e')
|
{
|
{
|
if (rtx_addr_varies_p (XEXP (x, i), for_alias))
|
if (rtx_addr_varies_p (XEXP (x, i), for_alias))
|
return 1;
|
return 1;
|
}
|
}
|
else if (fmt[i] == 'E')
|
else if (fmt[i] == 'E')
|
{
|
{
|
int j;
|
int j;
|
for (j = 0; j < XVECLEN (x, i); j++)
|
for (j = 0; j < XVECLEN (x, i); j++)
|
if (rtx_addr_varies_p (XVECEXP (x, i, j), for_alias))
|
if (rtx_addr_varies_p (XVECEXP (x, i, j), for_alias))
|
return 1;
|
return 1;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return the value of the integer term in X, if one is apparent;
|
/* Return the value of the integer term in X, if one is apparent;
|
otherwise return 0.
|
otherwise return 0.
|
Only obvious integer terms are detected.
|
Only obvious integer terms are detected.
|
This is used in cse.c with the `related_value' field. */
|
This is used in cse.c with the `related_value' field. */
|
|
|
HOST_WIDE_INT
|
HOST_WIDE_INT
|
get_integer_term (rtx x)
|
get_integer_term (rtx x)
|
{
|
{
|
if (GET_CODE (x) == CONST)
|
if (GET_CODE (x) == CONST)
|
x = XEXP (x, 0);
|
x = XEXP (x, 0);
|
|
|
if (GET_CODE (x) == MINUS
|
if (GET_CODE (x) == MINUS
|
&& GET_CODE (XEXP (x, 1)) == CONST_INT)
|
&& GET_CODE (XEXP (x, 1)) == CONST_INT)
|
return - INTVAL (XEXP (x, 1));
|
return - INTVAL (XEXP (x, 1));
|
if (GET_CODE (x) == PLUS
|
if (GET_CODE (x) == PLUS
|
&& GET_CODE (XEXP (x, 1)) == CONST_INT)
|
&& GET_CODE (XEXP (x, 1)) == CONST_INT)
|
return INTVAL (XEXP (x, 1));
|
return INTVAL (XEXP (x, 1));
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* If X is a constant, return the value sans apparent integer term;
|
/* If X is a constant, return the value sans apparent integer term;
|
otherwise return 0.
|
otherwise return 0.
|
Only obvious integer terms are detected. */
|
Only obvious integer terms are detected. */
|
|
|
rtx
|
rtx
|
get_related_value (rtx x)
|
get_related_value (rtx x)
|
{
|
{
|
if (GET_CODE (x) != CONST)
|
if (GET_CODE (x) != CONST)
|
return 0;
|
return 0;
|
x = XEXP (x, 0);
|
x = XEXP (x, 0);
|
if (GET_CODE (x) == PLUS
|
if (GET_CODE (x) == PLUS
|
&& GET_CODE (XEXP (x, 1)) == CONST_INT)
|
&& GET_CODE (XEXP (x, 1)) == CONST_INT)
|
return XEXP (x, 0);
|
return XEXP (x, 0);
|
else if (GET_CODE (x) == MINUS
|
else if (GET_CODE (x) == MINUS
|
&& GET_CODE (XEXP (x, 1)) == CONST_INT)
|
&& GET_CODE (XEXP (x, 1)) == CONST_INT)
|
return XEXP (x, 0);
|
return XEXP (x, 0);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return the number of places FIND appears within X. If COUNT_DEST is
|
/* Return the number of places FIND appears within X. If COUNT_DEST is
|
zero, we do not count occurrences inside the destination of a SET. */
|
zero, we do not count occurrences inside the destination of a SET. */
|
|
|
int
|
int
|
count_occurrences (rtx x, rtx find, int count_dest)
|
count_occurrences (rtx x, rtx find, int count_dest)
|
{
|
{
|
int i, j;
|
int i, j;
|
enum rtx_code code;
|
enum rtx_code code;
|
const char *format_ptr;
|
const char *format_ptr;
|
int count;
|
int count;
|
|
|
if (x == find)
|
if (x == find)
|
return 1;
|
return 1;
|
|
|
code = GET_CODE (x);
|
code = GET_CODE (x);
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case REG:
|
case REG:
|
case CONST_INT:
|
case CONST_INT:
|
case CONST_DOUBLE:
|
case CONST_DOUBLE:
|
case CONST_VECTOR:
|
case CONST_VECTOR:
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
case CODE_LABEL:
|
case CODE_LABEL:
|
case PC:
|
case PC:
|
case CC0:
|
case CC0:
|
return 0;
|
return 0;
|
|
|
case MEM:
|
case MEM:
|
if (MEM_P (find) && rtx_equal_p (x, find))
|
if (MEM_P (find) && rtx_equal_p (x, find))
|
return 1;
|
return 1;
|
break;
|
break;
|
|
|
case SET:
|
case SET:
|
if (SET_DEST (x) == find && ! count_dest)
|
if (SET_DEST (x) == find && ! count_dest)
|
return count_occurrences (SET_SRC (x), find, count_dest);
|
return count_occurrences (SET_SRC (x), find, count_dest);
|
break;
|
break;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
format_ptr = GET_RTX_FORMAT (code);
|
format_ptr = GET_RTX_FORMAT (code);
|
count = 0;
|
count = 0;
|
|
|
for (i = 0; i < GET_RTX_LENGTH (code); i++)
|
for (i = 0; i < GET_RTX_LENGTH (code); i++)
|
{
|
{
|
switch (*format_ptr++)
|
switch (*format_ptr++)
|
{
|
{
|
case 'e':
|
case 'e':
|
count += count_occurrences (XEXP (x, i), find, count_dest);
|
count += count_occurrences (XEXP (x, i), find, count_dest);
|
break;
|
break;
|
|
|
case 'E':
|
case 'E':
|
for (j = 0; j < XVECLEN (x, i); j++)
|
for (j = 0; j < XVECLEN (x, i); j++)
|
count += count_occurrences (XVECEXP (x, i, j), find, count_dest);
|
count += count_occurrences (XVECEXP (x, i, j), find, count_dest);
|
break;
|
break;
|
}
|
}
|
}
|
}
|
return count;
|
return count;
|
}
|
}
|
|
|
/* Nonzero if register REG appears somewhere within IN.
|
/* Nonzero if register REG appears somewhere within IN.
|
Also works if REG is not a register; in this case it checks
|
Also works if REG is not a register; in this case it checks
|
for a subexpression of IN that is Lisp "equal" to REG. */
|
for a subexpression of IN that is Lisp "equal" to REG. */
|
|
|
int
|
int
|
reg_mentioned_p (rtx reg, rtx in)
|
reg_mentioned_p (rtx reg, rtx in)
|
{
|
{
|
const char *fmt;
|
const char *fmt;
|
int i;
|
int i;
|
enum rtx_code code;
|
enum rtx_code code;
|
|
|
if (in == 0)
|
if (in == 0)
|
return 0;
|
return 0;
|
|
|
if (reg == in)
|
if (reg == in)
|
return 1;
|
return 1;
|
|
|
if (GET_CODE (in) == LABEL_REF)
|
if (GET_CODE (in) == LABEL_REF)
|
return reg == XEXP (in, 0);
|
return reg == XEXP (in, 0);
|
|
|
code = GET_CODE (in);
|
code = GET_CODE (in);
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
/* Compare registers by number. */
|
/* Compare registers by number. */
|
case REG:
|
case REG:
|
return REG_P (reg) && REGNO (in) == REGNO (reg);
|
return REG_P (reg) && REGNO (in) == REGNO (reg);
|
|
|
/* These codes have no constituent expressions
|
/* These codes have no constituent expressions
|
and are unique. */
|
and are unique. */
|
case SCRATCH:
|
case SCRATCH:
|
case CC0:
|
case CC0:
|
case PC:
|
case PC:
|
return 0;
|
return 0;
|
|
|
case CONST_INT:
|
case CONST_INT:
|
case CONST_VECTOR:
|
case CONST_VECTOR:
|
case CONST_DOUBLE:
|
case CONST_DOUBLE:
|
/* These are kept unique for a given value. */
|
/* These are kept unique for a given value. */
|
return 0;
|
return 0;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
if (GET_CODE (reg) == code && rtx_equal_p (reg, in))
|
if (GET_CODE (reg) == code && rtx_equal_p (reg, in))
|
return 1;
|
return 1;
|
|
|
fmt = GET_RTX_FORMAT (code);
|
fmt = GET_RTX_FORMAT (code);
|
|
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
{
|
{
|
if (fmt[i] == 'E')
|
if (fmt[i] == 'E')
|
{
|
{
|
int j;
|
int j;
|
for (j = XVECLEN (in, i) - 1; j >= 0; j--)
|
for (j = XVECLEN (in, i) - 1; j >= 0; j--)
|
if (reg_mentioned_p (reg, XVECEXP (in, i, j)))
|
if (reg_mentioned_p (reg, XVECEXP (in, i, j)))
|
return 1;
|
return 1;
|
}
|
}
|
else if (fmt[i] == 'e'
|
else if (fmt[i] == 'e'
|
&& reg_mentioned_p (reg, XEXP (in, i)))
|
&& reg_mentioned_p (reg, XEXP (in, i)))
|
return 1;
|
return 1;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return 1 if in between BEG and END, exclusive of BEG and END, there is
|
/* Return 1 if in between BEG and END, exclusive of BEG and END, there is
|
no CODE_LABEL insn. */
|
no CODE_LABEL insn. */
|
|
|
int
|
int
|
no_labels_between_p (rtx beg, rtx end)
|
no_labels_between_p (rtx beg, rtx end)
|
{
|
{
|
rtx p;
|
rtx p;
|
if (beg == end)
|
if (beg == end)
|
return 0;
|
return 0;
|
for (p = NEXT_INSN (beg); p != end; p = NEXT_INSN (p))
|
for (p = NEXT_INSN (beg); p != end; p = NEXT_INSN (p))
|
if (LABEL_P (p))
|
if (LABEL_P (p))
|
return 0;
|
return 0;
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* Nonzero if register REG is used in an insn between
|
/* Nonzero if register REG is used in an insn between
|
FROM_INSN and TO_INSN (exclusive of those two). */
|
FROM_INSN and TO_INSN (exclusive of those two). */
|
|
|
int
|
int
|
reg_used_between_p (rtx reg, rtx from_insn, rtx to_insn)
|
reg_used_between_p (rtx reg, rtx from_insn, rtx to_insn)
|
{
|
{
|
rtx insn;
|
rtx insn;
|
|
|
if (from_insn == to_insn)
|
if (from_insn == to_insn)
|
return 0;
|
return 0;
|
|
|
for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
|
for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
|
if (INSN_P (insn)
|
if (INSN_P (insn)
|
&& (reg_overlap_mentioned_p (reg, PATTERN (insn))
|
&& (reg_overlap_mentioned_p (reg, PATTERN (insn))
|
|| (CALL_P (insn) && find_reg_fusage (insn, USE, reg))))
|
|| (CALL_P (insn) && find_reg_fusage (insn, USE, reg))))
|
return 1;
|
return 1;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Nonzero if the old value of X, a register, is referenced in BODY. If X
|
/* Nonzero if the old value of X, a register, is referenced in BODY. If X
|
is entirely replaced by a new value and the only use is as a SET_DEST,
|
is entirely replaced by a new value and the only use is as a SET_DEST,
|
we do not consider it a reference. */
|
we do not consider it a reference. */
|
|
|
int
|
int
|
reg_referenced_p (rtx x, rtx body)
|
reg_referenced_p (rtx x, rtx body)
|
{
|
{
|
int i;
|
int i;
|
|
|
switch (GET_CODE (body))
|
switch (GET_CODE (body))
|
{
|
{
|
case SET:
|
case SET:
|
if (reg_overlap_mentioned_p (x, SET_SRC (body)))
|
if (reg_overlap_mentioned_p (x, SET_SRC (body)))
|
return 1;
|
return 1;
|
|
|
/* If the destination is anything other than CC0, PC, a REG or a SUBREG
|
/* If the destination is anything other than CC0, PC, a REG or a SUBREG
|
of a REG that occupies all of the REG, the insn references X if
|
of a REG that occupies all of the REG, the insn references X if
|
it is mentioned in the destination. */
|
it is mentioned in the destination. */
|
if (GET_CODE (SET_DEST (body)) != CC0
|
if (GET_CODE (SET_DEST (body)) != CC0
|
&& GET_CODE (SET_DEST (body)) != PC
|
&& GET_CODE (SET_DEST (body)) != PC
|
&& !REG_P (SET_DEST (body))
|
&& !REG_P (SET_DEST (body))
|
&& ! (GET_CODE (SET_DEST (body)) == SUBREG
|
&& ! (GET_CODE (SET_DEST (body)) == SUBREG
|
&& REG_P (SUBREG_REG (SET_DEST (body)))
|
&& REG_P (SUBREG_REG (SET_DEST (body)))
|
&& (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (body))))
|
&& (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (body))))
|
+ (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
|
+ (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
|
== ((GET_MODE_SIZE (GET_MODE (SET_DEST (body)))
|
== ((GET_MODE_SIZE (GET_MODE (SET_DEST (body)))
|
+ (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)))
|
+ (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)))
|
&& reg_overlap_mentioned_p (x, SET_DEST (body)))
|
&& reg_overlap_mentioned_p (x, SET_DEST (body)))
|
return 1;
|
return 1;
|
return 0;
|
return 0;
|
|
|
case ASM_OPERANDS:
|
case ASM_OPERANDS:
|
for (i = ASM_OPERANDS_INPUT_LENGTH (body) - 1; i >= 0; i--)
|
for (i = ASM_OPERANDS_INPUT_LENGTH (body) - 1; i >= 0; i--)
|
if (reg_overlap_mentioned_p (x, ASM_OPERANDS_INPUT (body, i)))
|
if (reg_overlap_mentioned_p (x, ASM_OPERANDS_INPUT (body, i)))
|
return 1;
|
return 1;
|
return 0;
|
return 0;
|
|
|
case CALL:
|
case CALL:
|
case USE:
|
case USE:
|
case IF_THEN_ELSE:
|
case IF_THEN_ELSE:
|
return reg_overlap_mentioned_p (x, body);
|
return reg_overlap_mentioned_p (x, body);
|
|
|
case TRAP_IF:
|
case TRAP_IF:
|
return reg_overlap_mentioned_p (x, TRAP_CONDITION (body));
|
return reg_overlap_mentioned_p (x, TRAP_CONDITION (body));
|
|
|
case PREFETCH:
|
case PREFETCH:
|
return reg_overlap_mentioned_p (x, XEXP (body, 0));
|
return reg_overlap_mentioned_p (x, XEXP (body, 0));
|
|
|
case UNSPEC:
|
case UNSPEC:
|
case UNSPEC_VOLATILE:
|
case UNSPEC_VOLATILE:
|
for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
|
for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
|
if (reg_overlap_mentioned_p (x, XVECEXP (body, 0, i)))
|
if (reg_overlap_mentioned_p (x, XVECEXP (body, 0, i)))
|
return 1;
|
return 1;
|
return 0;
|
return 0;
|
|
|
case PARALLEL:
|
case PARALLEL:
|
for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
|
for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
|
if (reg_referenced_p (x, XVECEXP (body, 0, i)))
|
if (reg_referenced_p (x, XVECEXP (body, 0, i)))
|
return 1;
|
return 1;
|
return 0;
|
return 0;
|
|
|
case CLOBBER:
|
case CLOBBER:
|
if (MEM_P (XEXP (body, 0)))
|
if (MEM_P (XEXP (body, 0)))
|
if (reg_overlap_mentioned_p (x, XEXP (XEXP (body, 0), 0)))
|
if (reg_overlap_mentioned_p (x, XEXP (XEXP (body, 0), 0)))
|
return 1;
|
return 1;
|
return 0;
|
return 0;
|
|
|
case COND_EXEC:
|
case COND_EXEC:
|
if (reg_overlap_mentioned_p (x, COND_EXEC_TEST (body)))
|
if (reg_overlap_mentioned_p (x, COND_EXEC_TEST (body)))
|
return 1;
|
return 1;
|
return reg_referenced_p (x, COND_EXEC_CODE (body));
|
return reg_referenced_p (x, COND_EXEC_CODE (body));
|
|
|
default:
|
default:
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
|
|
/* Nonzero if register REG is set or clobbered in an insn between
|
/* Nonzero if register REG is set or clobbered in an insn between
|
FROM_INSN and TO_INSN (exclusive of those two). */
|
FROM_INSN and TO_INSN (exclusive of those two). */
|
|
|
int
|
int
|
reg_set_between_p (rtx reg, rtx from_insn, rtx to_insn)
|
reg_set_between_p (rtx reg, rtx from_insn, rtx to_insn)
|
{
|
{
|
rtx insn;
|
rtx insn;
|
|
|
if (from_insn == to_insn)
|
if (from_insn == to_insn)
|
return 0;
|
return 0;
|
|
|
for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
|
for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
|
if (INSN_P (insn) && reg_set_p (reg, insn))
|
if (INSN_P (insn) && reg_set_p (reg, insn))
|
return 1;
|
return 1;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Internals of reg_set_between_p. */
|
/* Internals of reg_set_between_p. */
|
int
|
int
|
reg_set_p (rtx reg, rtx insn)
|
reg_set_p (rtx reg, rtx insn)
|
{
|
{
|
/* We can be passed an insn or part of one. If we are passed an insn,
|
/* We can be passed an insn or part of one. If we are passed an insn,
|
check if a side-effect of the insn clobbers REG. */
|
check if a side-effect of the insn clobbers REG. */
|
if (INSN_P (insn)
|
if (INSN_P (insn)
|
&& (FIND_REG_INC_NOTE (insn, reg)
|
&& (FIND_REG_INC_NOTE (insn, reg)
|
|| (CALL_P (insn)
|
|| (CALL_P (insn)
|
&& ((REG_P (reg)
|
&& ((REG_P (reg)
|
&& REGNO (reg) < FIRST_PSEUDO_REGISTER
|
&& REGNO (reg) < FIRST_PSEUDO_REGISTER
|
&& TEST_HARD_REG_BIT (regs_invalidated_by_call,
|
&& TEST_HARD_REG_BIT (regs_invalidated_by_call,
|
REGNO (reg)))
|
REGNO (reg)))
|
|| MEM_P (reg)
|
|| MEM_P (reg)
|
|| find_reg_fusage (insn, CLOBBER, reg)))))
|
|| find_reg_fusage (insn, CLOBBER, reg)))))
|
return 1;
|
return 1;
|
|
|
return set_of (reg, insn) != NULL_RTX;
|
return set_of (reg, insn) != NULL_RTX;
|
}
|
}
|
|
|
/* Similar to reg_set_between_p, but check all registers in X. Return 0
|
/* Similar to reg_set_between_p, but check all registers in X. Return 0
|
only if none of them are modified between START and END. Return 1 if
|
only if none of them are modified between START and END. Return 1 if
|
X contains a MEM; this routine does usememory aliasing. */
|
X contains a MEM; this routine does usememory aliasing. */
|
|
|
int
|
int
|
modified_between_p (rtx x, rtx start, rtx end)
|
modified_between_p (rtx x, rtx start, rtx end)
|
{
|
{
|
enum rtx_code code = GET_CODE (x);
|
enum rtx_code code = GET_CODE (x);
|
const char *fmt;
|
const char *fmt;
|
int i, j;
|
int i, j;
|
rtx insn;
|
rtx insn;
|
|
|
if (start == end)
|
if (start == end)
|
return 0;
|
return 0;
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case CONST_INT:
|
case CONST_INT:
|
case CONST_DOUBLE:
|
case CONST_DOUBLE:
|
case CONST_VECTOR:
|
case CONST_VECTOR:
|
case CONST:
|
case CONST:
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
case LABEL_REF:
|
case LABEL_REF:
|
return 0;
|
return 0;
|
|
|
case PC:
|
case PC:
|
case CC0:
|
case CC0:
|
return 1;
|
return 1;
|
|
|
case MEM:
|
case MEM:
|
if (modified_between_p (XEXP (x, 0), start, end))
|
if (modified_between_p (XEXP (x, 0), start, end))
|
return 1;
|
return 1;
|
if (MEM_READONLY_P (x))
|
if (MEM_READONLY_P (x))
|
return 0;
|
return 0;
|
for (insn = NEXT_INSN (start); insn != end; insn = NEXT_INSN (insn))
|
for (insn = NEXT_INSN (start); insn != end; insn = NEXT_INSN (insn))
|
if (memory_modified_in_insn_p (x, insn))
|
if (memory_modified_in_insn_p (x, insn))
|
return 1;
|
return 1;
|
return 0;
|
return 0;
|
break;
|
break;
|
|
|
case REG:
|
case REG:
|
return reg_set_between_p (x, start, end);
|
return reg_set_between_p (x, start, end);
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
fmt = GET_RTX_FORMAT (code);
|
fmt = GET_RTX_FORMAT (code);
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
{
|
{
|
if (fmt[i] == 'e' && modified_between_p (XEXP (x, i), start, end))
|
if (fmt[i] == 'e' && modified_between_p (XEXP (x, i), start, end))
|
return 1;
|
return 1;
|
|
|
else if (fmt[i] == 'E')
|
else if (fmt[i] == 'E')
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
if (modified_between_p (XVECEXP (x, i, j), start, end))
|
if (modified_between_p (XVECEXP (x, i, j), start, end))
|
return 1;
|
return 1;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Similar to reg_set_p, but check all registers in X. Return 0 only if none
|
/* Similar to reg_set_p, but check all registers in X. Return 0 only if none
|
of them are modified in INSN. Return 1 if X contains a MEM; this routine
|
of them are modified in INSN. Return 1 if X contains a MEM; this routine
|
does use memory aliasing. */
|
does use memory aliasing. */
|
|
|
int
|
int
|
modified_in_p (rtx x, rtx insn)
|
modified_in_p (rtx x, rtx insn)
|
{
|
{
|
enum rtx_code code = GET_CODE (x);
|
enum rtx_code code = GET_CODE (x);
|
const char *fmt;
|
const char *fmt;
|
int i, j;
|
int i, j;
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case CONST_INT:
|
case CONST_INT:
|
case CONST_DOUBLE:
|
case CONST_DOUBLE:
|
case CONST_VECTOR:
|
case CONST_VECTOR:
|
case CONST:
|
case CONST:
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
case LABEL_REF:
|
case LABEL_REF:
|
return 0;
|
return 0;
|
|
|
case PC:
|
case PC:
|
case CC0:
|
case CC0:
|
return 1;
|
return 1;
|
|
|
case MEM:
|
case MEM:
|
if (modified_in_p (XEXP (x, 0), insn))
|
if (modified_in_p (XEXP (x, 0), insn))
|
return 1;
|
return 1;
|
if (MEM_READONLY_P (x))
|
if (MEM_READONLY_P (x))
|
return 0;
|
return 0;
|
if (memory_modified_in_insn_p (x, insn))
|
if (memory_modified_in_insn_p (x, insn))
|
return 1;
|
return 1;
|
return 0;
|
return 0;
|
break;
|
break;
|
|
|
case REG:
|
case REG:
|
return reg_set_p (x, insn);
|
return reg_set_p (x, insn);
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
fmt = GET_RTX_FORMAT (code);
|
fmt = GET_RTX_FORMAT (code);
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
{
|
{
|
if (fmt[i] == 'e' && modified_in_p (XEXP (x, i), insn))
|
if (fmt[i] == 'e' && modified_in_p (XEXP (x, i), insn))
|
return 1;
|
return 1;
|
|
|
else if (fmt[i] == 'E')
|
else if (fmt[i] == 'E')
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
if (modified_in_p (XVECEXP (x, i, j), insn))
|
if (modified_in_p (XVECEXP (x, i, j), insn))
|
return 1;
|
return 1;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Helper function for set_of. */
|
/* Helper function for set_of. */
|
struct set_of_data
|
struct set_of_data
|
{
|
{
|
rtx found;
|
rtx found;
|
rtx pat;
|
rtx pat;
|
};
|
};
|
|
|
static void
|
static void
|
set_of_1 (rtx x, rtx pat, void *data1)
|
set_of_1 (rtx x, rtx pat, void *data1)
|
{
|
{
|
struct set_of_data *data = (struct set_of_data *) (data1);
|
struct set_of_data *data = (struct set_of_data *) (data1);
|
if (rtx_equal_p (x, data->pat)
|
if (rtx_equal_p (x, data->pat)
|
|| (!MEM_P (x) && reg_overlap_mentioned_p (data->pat, x)))
|
|| (!MEM_P (x) && reg_overlap_mentioned_p (data->pat, x)))
|
data->found = pat;
|
data->found = pat;
|
}
|
}
|
|
|
/* Give an INSN, return a SET or CLOBBER expression that does modify PAT
|
/* Give an INSN, return a SET or CLOBBER expression that does modify PAT
|
(either directly or via STRICT_LOW_PART and similar modifiers). */
|
(either directly or via STRICT_LOW_PART and similar modifiers). */
|
rtx
|
rtx
|
set_of (rtx pat, rtx insn)
|
set_of (rtx pat, rtx insn)
|
{
|
{
|
struct set_of_data data;
|
struct set_of_data data;
|
data.found = NULL_RTX;
|
data.found = NULL_RTX;
|
data.pat = pat;
|
data.pat = pat;
|
note_stores (INSN_P (insn) ? PATTERN (insn) : insn, set_of_1, &data);
|
note_stores (INSN_P (insn) ? PATTERN (insn) : insn, set_of_1, &data);
|
return data.found;
|
return data.found;
|
}
|
}
|
|
|
/* Given an INSN, return a SET expression if this insn has only a single SET.
|
/* Given an INSN, return a SET expression if this insn has only a single SET.
|
It may also have CLOBBERs, USEs, or SET whose output
|
It may also have CLOBBERs, USEs, or SET whose output
|
will not be used, which we ignore. */
|
will not be used, which we ignore. */
|
|
|
rtx
|
rtx
|
single_set_2 (rtx insn, rtx pat)
|
single_set_2 (rtx insn, rtx pat)
|
{
|
{
|
rtx set = NULL;
|
rtx set = NULL;
|
int set_verified = 1;
|
int set_verified = 1;
|
int i;
|
int i;
|
|
|
if (GET_CODE (pat) == PARALLEL)
|
if (GET_CODE (pat) == PARALLEL)
|
{
|
{
|
for (i = 0; i < XVECLEN (pat, 0); i++)
|
for (i = 0; i < XVECLEN (pat, 0); i++)
|
{
|
{
|
rtx sub = XVECEXP (pat, 0, i);
|
rtx sub = XVECEXP (pat, 0, i);
|
switch (GET_CODE (sub))
|
switch (GET_CODE (sub))
|
{
|
{
|
case USE:
|
case USE:
|
case CLOBBER:
|
case CLOBBER:
|
break;
|
break;
|
|
|
case SET:
|
case SET:
|
/* We can consider insns having multiple sets, where all
|
/* We can consider insns having multiple sets, where all
|
but one are dead as single set insns. In common case
|
but one are dead as single set insns. In common case
|
only single set is present in the pattern so we want
|
only single set is present in the pattern so we want
|
to avoid checking for REG_UNUSED notes unless necessary.
|
to avoid checking for REG_UNUSED notes unless necessary.
|
|
|
When we reach set first time, we just expect this is
|
When we reach set first time, we just expect this is
|
the single set we are looking for and only when more
|
the single set we are looking for and only when more
|
sets are found in the insn, we check them. */
|
sets are found in the insn, we check them. */
|
if (!set_verified)
|
if (!set_verified)
|
{
|
{
|
if (find_reg_note (insn, REG_UNUSED, SET_DEST (set))
|
if (find_reg_note (insn, REG_UNUSED, SET_DEST (set))
|
&& !side_effects_p (set))
|
&& !side_effects_p (set))
|
set = NULL;
|
set = NULL;
|
else
|
else
|
set_verified = 1;
|
set_verified = 1;
|
}
|
}
|
if (!set)
|
if (!set)
|
set = sub, set_verified = 0;
|
set = sub, set_verified = 0;
|
else if (!find_reg_note (insn, REG_UNUSED, SET_DEST (sub))
|
else if (!find_reg_note (insn, REG_UNUSED, SET_DEST (sub))
|
|| side_effects_p (sub))
|
|| side_effects_p (sub))
|
return NULL_RTX;
|
return NULL_RTX;
|
break;
|
break;
|
|
|
default:
|
default:
|
return NULL_RTX;
|
return NULL_RTX;
|
}
|
}
|
}
|
}
|
}
|
}
|
return set;
|
return set;
|
}
|
}
|
|
|
/* Given an INSN, return nonzero if it has more than one SET, else return
|
/* Given an INSN, return nonzero if it has more than one SET, else return
|
zero. */
|
zero. */
|
|
|
int
|
int
|
multiple_sets (rtx insn)
|
multiple_sets (rtx insn)
|
{
|
{
|
int found;
|
int found;
|
int i;
|
int i;
|
|
|
/* INSN must be an insn. */
|
/* INSN must be an insn. */
|
if (! INSN_P (insn))
|
if (! INSN_P (insn))
|
return 0;
|
return 0;
|
|
|
/* Only a PARALLEL can have multiple SETs. */
|
/* Only a PARALLEL can have multiple SETs. */
|
if (GET_CODE (PATTERN (insn)) == PARALLEL)
|
if (GET_CODE (PATTERN (insn)) == PARALLEL)
|
{
|
{
|
for (i = 0, found = 0; i < XVECLEN (PATTERN (insn), 0); i++)
|
for (i = 0, found = 0; i < XVECLEN (PATTERN (insn), 0); i++)
|
if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
|
if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
|
{
|
{
|
/* If we have already found a SET, then return now. */
|
/* If we have already found a SET, then return now. */
|
if (found)
|
if (found)
|
return 1;
|
return 1;
|
else
|
else
|
found = 1;
|
found = 1;
|
}
|
}
|
}
|
}
|
|
|
/* Either zero or one SET. */
|
/* Either zero or one SET. */
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return nonzero if the destination of SET equals the source
|
/* Return nonzero if the destination of SET equals the source
|
and there are no side effects. */
|
and there are no side effects. */
|
|
|
int
|
int
|
set_noop_p (rtx set)
|
set_noop_p (rtx set)
|
{
|
{
|
rtx src = SET_SRC (set);
|
rtx src = SET_SRC (set);
|
rtx dst = SET_DEST (set);
|
rtx dst = SET_DEST (set);
|
|
|
if (dst == pc_rtx && src == pc_rtx)
|
if (dst == pc_rtx && src == pc_rtx)
|
return 1;
|
return 1;
|
|
|
if (MEM_P (dst) && MEM_P (src))
|
if (MEM_P (dst) && MEM_P (src))
|
return rtx_equal_p (dst, src) && !side_effects_p (dst);
|
return rtx_equal_p (dst, src) && !side_effects_p (dst);
|
|
|
if (GET_CODE (dst) == ZERO_EXTRACT)
|
if (GET_CODE (dst) == ZERO_EXTRACT)
|
return rtx_equal_p (XEXP (dst, 0), src)
|
return rtx_equal_p (XEXP (dst, 0), src)
|
&& ! BYTES_BIG_ENDIAN && XEXP (dst, 2) == const0_rtx
|
&& ! BYTES_BIG_ENDIAN && XEXP (dst, 2) == const0_rtx
|
&& !side_effects_p (src);
|
&& !side_effects_p (src);
|
|
|
if (GET_CODE (dst) == STRICT_LOW_PART)
|
if (GET_CODE (dst) == STRICT_LOW_PART)
|
dst = XEXP (dst, 0);
|
dst = XEXP (dst, 0);
|
|
|
if (GET_CODE (src) == SUBREG && GET_CODE (dst) == SUBREG)
|
if (GET_CODE (src) == SUBREG && GET_CODE (dst) == SUBREG)
|
{
|
{
|
if (SUBREG_BYTE (src) != SUBREG_BYTE (dst))
|
if (SUBREG_BYTE (src) != SUBREG_BYTE (dst))
|
return 0;
|
return 0;
|
src = SUBREG_REG (src);
|
src = SUBREG_REG (src);
|
dst = SUBREG_REG (dst);
|
dst = SUBREG_REG (dst);
|
}
|
}
|
|
|
return (REG_P (src) && REG_P (dst)
|
return (REG_P (src) && REG_P (dst)
|
&& REGNO (src) == REGNO (dst));
|
&& REGNO (src) == REGNO (dst));
|
}
|
}
|
|
|
/* Return nonzero if an insn consists only of SETs, each of which only sets a
|
/* Return nonzero if an insn consists only of SETs, each of which only sets a
|
value to itself. */
|
value to itself. */
|
|
|
int
|
int
|
noop_move_p (rtx insn)
|
noop_move_p (rtx insn)
|
{
|
{
|
rtx pat = PATTERN (insn);
|
rtx pat = PATTERN (insn);
|
|
|
if (INSN_CODE (insn) == NOOP_MOVE_INSN_CODE)
|
if (INSN_CODE (insn) == NOOP_MOVE_INSN_CODE)
|
return 1;
|
return 1;
|
|
|
/* Insns carrying these notes are useful later on. */
|
/* Insns carrying these notes are useful later on. */
|
if (find_reg_note (insn, REG_EQUAL, NULL_RTX))
|
if (find_reg_note (insn, REG_EQUAL, NULL_RTX))
|
return 0;
|
return 0;
|
|
|
/* For now treat an insn with a REG_RETVAL note as a
|
/* For now treat an insn with a REG_RETVAL note as a
|
a special insn which should not be considered a no-op. */
|
a special insn which should not be considered a no-op. */
|
if (find_reg_note (insn, REG_RETVAL, NULL_RTX))
|
if (find_reg_note (insn, REG_RETVAL, NULL_RTX))
|
return 0;
|
return 0;
|
|
|
if (GET_CODE (pat) == SET && set_noop_p (pat))
|
if (GET_CODE (pat) == SET && set_noop_p (pat))
|
return 1;
|
return 1;
|
|
|
if (GET_CODE (pat) == PARALLEL)
|
if (GET_CODE (pat) == PARALLEL)
|
{
|
{
|
int i;
|
int i;
|
/* If nothing but SETs of registers to themselves,
|
/* If nothing but SETs of registers to themselves,
|
this insn can also be deleted. */
|
this insn can also be deleted. */
|
for (i = 0; i < XVECLEN (pat, 0); i++)
|
for (i = 0; i < XVECLEN (pat, 0); i++)
|
{
|
{
|
rtx tem = XVECEXP (pat, 0, i);
|
rtx tem = XVECEXP (pat, 0, i);
|
|
|
if (GET_CODE (tem) == USE
|
if (GET_CODE (tem) == USE
|
|| GET_CODE (tem) == CLOBBER)
|
|| GET_CODE (tem) == CLOBBER)
|
continue;
|
continue;
|
|
|
if (GET_CODE (tem) != SET || ! set_noop_p (tem))
|
if (GET_CODE (tem) != SET || ! set_noop_p (tem))
|
return 0;
|
return 0;
|
}
|
}
|
|
|
return 1;
|
return 1;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
|
|
/* Return the last thing that X was assigned from before *PINSN. If VALID_TO
|
/* Return the last thing that X was assigned from before *PINSN. If VALID_TO
|
is not NULL_RTX then verify that the object is not modified up to VALID_TO.
|
is not NULL_RTX then verify that the object is not modified up to VALID_TO.
|
If the object was modified, if we hit a partial assignment to X, or hit a
|
If the object was modified, if we hit a partial assignment to X, or hit a
|
CODE_LABEL first, return X. If we found an assignment, update *PINSN to
|
CODE_LABEL first, return X. If we found an assignment, update *PINSN to
|
point to it. ALLOW_HWREG is set to 1 if hardware registers are allowed to
|
point to it. ALLOW_HWREG is set to 1 if hardware registers are allowed to
|
be the src. */
|
be the src. */
|
|
|
rtx
|
rtx
|
find_last_value (rtx x, rtx *pinsn, rtx valid_to, int allow_hwreg)
|
find_last_value (rtx x, rtx *pinsn, rtx valid_to, int allow_hwreg)
|
{
|
{
|
rtx p;
|
rtx p;
|
|
|
for (p = PREV_INSN (*pinsn); p && !LABEL_P (p);
|
for (p = PREV_INSN (*pinsn); p && !LABEL_P (p);
|
p = PREV_INSN (p))
|
p = PREV_INSN (p))
|
if (INSN_P (p))
|
if (INSN_P (p))
|
{
|
{
|
rtx set = single_set (p);
|
rtx set = single_set (p);
|
rtx note = find_reg_note (p, REG_EQUAL, NULL_RTX);
|
rtx note = find_reg_note (p, REG_EQUAL, NULL_RTX);
|
|
|
if (set && rtx_equal_p (x, SET_DEST (set)))
|
if (set && rtx_equal_p (x, SET_DEST (set)))
|
{
|
{
|
rtx src = SET_SRC (set);
|
rtx src = SET_SRC (set);
|
|
|
if (note && GET_CODE (XEXP (note, 0)) != EXPR_LIST)
|
if (note && GET_CODE (XEXP (note, 0)) != EXPR_LIST)
|
src = XEXP (note, 0);
|
src = XEXP (note, 0);
|
|
|
if ((valid_to == NULL_RTX
|
if ((valid_to == NULL_RTX
|
|| ! modified_between_p (src, PREV_INSN (p), valid_to))
|
|| ! modified_between_p (src, PREV_INSN (p), valid_to))
|
/* Reject hard registers because we don't usually want
|
/* Reject hard registers because we don't usually want
|
to use them; we'd rather use a pseudo. */
|
to use them; we'd rather use a pseudo. */
|
&& (! (REG_P (src)
|
&& (! (REG_P (src)
|
&& REGNO (src) < FIRST_PSEUDO_REGISTER) || allow_hwreg))
|
&& REGNO (src) < FIRST_PSEUDO_REGISTER) || allow_hwreg))
|
{
|
{
|
*pinsn = p;
|
*pinsn = p;
|
return src;
|
return src;
|
}
|
}
|
}
|
}
|
|
|
/* If set in non-simple way, we don't have a value. */
|
/* If set in non-simple way, we don't have a value. */
|
if (reg_set_p (x, p))
|
if (reg_set_p (x, p))
|
break;
|
break;
|
}
|
}
|
|
|
return x;
|
return x;
|
}
|
}
|
|
|
/* Return nonzero if register in range [REGNO, ENDREGNO)
|
/* Return nonzero if register in range [REGNO, ENDREGNO)
|
appears either explicitly or implicitly in X
|
appears either explicitly or implicitly in X
|
other than being stored into.
|
other than being stored into.
|
|
|
References contained within the substructure at LOC do not count.
|
References contained within the substructure at LOC do not count.
|
LOC may be zero, meaning don't ignore anything. */
|
LOC may be zero, meaning don't ignore anything. */
|
|
|
int
|
int
|
refers_to_regno_p (unsigned int regno, unsigned int endregno, rtx x,
|
refers_to_regno_p (unsigned int regno, unsigned int endregno, rtx x,
|
rtx *loc)
|
rtx *loc)
|
{
|
{
|
int i;
|
int i;
|
unsigned int x_regno;
|
unsigned int x_regno;
|
RTX_CODE code;
|
RTX_CODE code;
|
const char *fmt;
|
const char *fmt;
|
|
|
repeat:
|
repeat:
|
/* The contents of a REG_NONNEG note is always zero, so we must come here
|
/* The contents of a REG_NONNEG note is always zero, so we must come here
|
upon repeat in case the last REG_NOTE is a REG_NONNEG note. */
|
upon repeat in case the last REG_NOTE is a REG_NONNEG note. */
|
if (x == 0)
|
if (x == 0)
|
return 0;
|
return 0;
|
|
|
code = GET_CODE (x);
|
code = GET_CODE (x);
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case REG:
|
case REG:
|
x_regno = REGNO (x);
|
x_regno = REGNO (x);
|
|
|
/* If we modifying the stack, frame, or argument pointer, it will
|
/* If we modifying the stack, frame, or argument pointer, it will
|
clobber a virtual register. In fact, we could be more precise,
|
clobber a virtual register. In fact, we could be more precise,
|
but it isn't worth it. */
|
but it isn't worth it. */
|
if ((x_regno == STACK_POINTER_REGNUM
|
if ((x_regno == STACK_POINTER_REGNUM
|
#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
|
#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
|
|| x_regno == ARG_POINTER_REGNUM
|
|| x_regno == ARG_POINTER_REGNUM
|
#endif
|
#endif
|
|| x_regno == FRAME_POINTER_REGNUM)
|
|| x_regno == FRAME_POINTER_REGNUM)
|
&& regno >= FIRST_VIRTUAL_REGISTER && regno <= LAST_VIRTUAL_REGISTER)
|
&& regno >= FIRST_VIRTUAL_REGISTER && regno <= LAST_VIRTUAL_REGISTER)
|
return 1;
|
return 1;
|
|
|
return (endregno > x_regno
|
return (endregno > x_regno
|
&& regno < x_regno + (x_regno < FIRST_PSEUDO_REGISTER
|
&& regno < x_regno + (x_regno < FIRST_PSEUDO_REGISTER
|
? hard_regno_nregs[x_regno][GET_MODE (x)]
|
? hard_regno_nregs[x_regno][GET_MODE (x)]
|
: 1));
|
: 1));
|
|
|
case SUBREG:
|
case SUBREG:
|
/* If this is a SUBREG of a hard reg, we can see exactly which
|
/* If this is a SUBREG of a hard reg, we can see exactly which
|
registers are being modified. Otherwise, handle normally. */
|
registers are being modified. Otherwise, handle normally. */
|
if (REG_P (SUBREG_REG (x))
|
if (REG_P (SUBREG_REG (x))
|
&& REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER)
|
&& REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER)
|
{
|
{
|
unsigned int inner_regno = subreg_regno (x);
|
unsigned int inner_regno = subreg_regno (x);
|
unsigned int inner_endregno
|
unsigned int inner_endregno
|
= inner_regno + (inner_regno < FIRST_PSEUDO_REGISTER
|
= inner_regno + (inner_regno < FIRST_PSEUDO_REGISTER
|
? hard_regno_nregs[inner_regno][GET_MODE (x)] : 1);
|
? hard_regno_nregs[inner_regno][GET_MODE (x)] : 1);
|
|
|
return endregno > inner_regno && regno < inner_endregno;
|
return endregno > inner_regno && regno < inner_endregno;
|
}
|
}
|
break;
|
break;
|
|
|
case CLOBBER:
|
case CLOBBER:
|
case SET:
|
case SET:
|
if (&SET_DEST (x) != loc
|
if (&SET_DEST (x) != loc
|
/* Note setting a SUBREG counts as referring to the REG it is in for
|
/* Note setting a SUBREG counts as referring to the REG it is in for
|
a pseudo but not for hard registers since we can
|
a pseudo but not for hard registers since we can
|
treat each word individually. */
|
treat each word individually. */
|
&& ((GET_CODE (SET_DEST (x)) == SUBREG
|
&& ((GET_CODE (SET_DEST (x)) == SUBREG
|
&& loc != &SUBREG_REG (SET_DEST (x))
|
&& loc != &SUBREG_REG (SET_DEST (x))
|
&& REG_P (SUBREG_REG (SET_DEST (x)))
|
&& REG_P (SUBREG_REG (SET_DEST (x)))
|
&& REGNO (SUBREG_REG (SET_DEST (x))) >= FIRST_PSEUDO_REGISTER
|
&& REGNO (SUBREG_REG (SET_DEST (x))) >= FIRST_PSEUDO_REGISTER
|
&& refers_to_regno_p (regno, endregno,
|
&& refers_to_regno_p (regno, endregno,
|
SUBREG_REG (SET_DEST (x)), loc))
|
SUBREG_REG (SET_DEST (x)), loc))
|
|| (!REG_P (SET_DEST (x))
|
|| (!REG_P (SET_DEST (x))
|
&& refers_to_regno_p (regno, endregno, SET_DEST (x), loc))))
|
&& refers_to_regno_p (regno, endregno, SET_DEST (x), loc))))
|
return 1;
|
return 1;
|
|
|
if (code == CLOBBER || loc == &SET_SRC (x))
|
if (code == CLOBBER || loc == &SET_SRC (x))
|
return 0;
|
return 0;
|
x = SET_SRC (x);
|
x = SET_SRC (x);
|
goto repeat;
|
goto repeat;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
/* X does not match, so try its subexpressions. */
|
/* X does not match, so try its subexpressions. */
|
|
|
fmt = GET_RTX_FORMAT (code);
|
fmt = GET_RTX_FORMAT (code);
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
{
|
{
|
if (fmt[i] == 'e' && loc != &XEXP (x, i))
|
if (fmt[i] == 'e' && loc != &XEXP (x, i))
|
{
|
{
|
if (i == 0)
|
if (i == 0)
|
{
|
{
|
x = XEXP (x, 0);
|
x = XEXP (x, 0);
|
goto repeat;
|
goto repeat;
|
}
|
}
|
else
|
else
|
if (refers_to_regno_p (regno, endregno, XEXP (x, i), loc))
|
if (refers_to_regno_p (regno, endregno, XEXP (x, i), loc))
|
return 1;
|
return 1;
|
}
|
}
|
else if (fmt[i] == 'E')
|
else if (fmt[i] == 'E')
|
{
|
{
|
int j;
|
int j;
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
if (loc != &XVECEXP (x, i, j)
|
if (loc != &XVECEXP (x, i, j)
|
&& refers_to_regno_p (regno, endregno, XVECEXP (x, i, j), loc))
|
&& refers_to_regno_p (regno, endregno, XVECEXP (x, i, j), loc))
|
return 1;
|
return 1;
|
}
|
}
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
|
/* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
|
we check if any register number in X conflicts with the relevant register
|
we check if any register number in X conflicts with the relevant register
|
numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN
|
numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN
|
contains a MEM (we don't bother checking for memory addresses that can't
|
contains a MEM (we don't bother checking for memory addresses that can't
|
conflict because we expect this to be a rare case. */
|
conflict because we expect this to be a rare case. */
|
|
|
int
|
int
|
reg_overlap_mentioned_p (rtx x, rtx in)
|
reg_overlap_mentioned_p (rtx x, rtx in)
|
{
|
{
|
unsigned int regno, endregno;
|
unsigned int regno, endregno;
|
|
|
/* If either argument is a constant, then modifying X can not
|
/* If either argument is a constant, then modifying X can not
|
affect IN. Here we look at IN, we can profitably combine
|
affect IN. Here we look at IN, we can profitably combine
|
CONSTANT_P (x) with the switch statement below. */
|
CONSTANT_P (x) with the switch statement below. */
|
if (CONSTANT_P (in))
|
if (CONSTANT_P (in))
|
return 0;
|
return 0;
|
|
|
recurse:
|
recurse:
|
switch (GET_CODE (x))
|
switch (GET_CODE (x))
|
{
|
{
|
case STRICT_LOW_PART:
|
case STRICT_LOW_PART:
|
case ZERO_EXTRACT:
|
case ZERO_EXTRACT:
|
case SIGN_EXTRACT:
|
case SIGN_EXTRACT:
|
/* Overly conservative. */
|
/* Overly conservative. */
|
x = XEXP (x, 0);
|
x = XEXP (x, 0);
|
goto recurse;
|
goto recurse;
|
|
|
case SUBREG:
|
case SUBREG:
|
regno = REGNO (SUBREG_REG (x));
|
regno = REGNO (SUBREG_REG (x));
|
if (regno < FIRST_PSEUDO_REGISTER)
|
if (regno < FIRST_PSEUDO_REGISTER)
|
regno = subreg_regno (x);
|
regno = subreg_regno (x);
|
goto do_reg;
|
goto do_reg;
|
|
|
case REG:
|
case REG:
|
regno = REGNO (x);
|
regno = REGNO (x);
|
do_reg:
|
do_reg:
|
endregno = regno + (regno < FIRST_PSEUDO_REGISTER
|
endregno = regno + (regno < FIRST_PSEUDO_REGISTER
|
? hard_regno_nregs[regno][GET_MODE (x)] : 1);
|
? hard_regno_nregs[regno][GET_MODE (x)] : 1);
|
return refers_to_regno_p (regno, endregno, in, (rtx*) 0);
|
return refers_to_regno_p (regno, endregno, in, (rtx*) 0);
|
|
|
case MEM:
|
case MEM:
|
{
|
{
|
const char *fmt;
|
const char *fmt;
|
int i;
|
int i;
|
|
|
if (MEM_P (in))
|
if (MEM_P (in))
|
return 1;
|
return 1;
|
|
|
fmt = GET_RTX_FORMAT (GET_CODE (in));
|
fmt = GET_RTX_FORMAT (GET_CODE (in));
|
for (i = GET_RTX_LENGTH (GET_CODE (in)) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (GET_CODE (in)) - 1; i >= 0; i--)
|
if (fmt[i] == 'e')
|
if (fmt[i] == 'e')
|
{
|
{
|
if (reg_overlap_mentioned_p (x, XEXP (in, i)))
|
if (reg_overlap_mentioned_p (x, XEXP (in, i)))
|
return 1;
|
return 1;
|
}
|
}
|
else if (fmt[i] == 'E')
|
else if (fmt[i] == 'E')
|
{
|
{
|
int j;
|
int j;
|
for (j = XVECLEN (in, i) - 1; j >= 0; --j)
|
for (j = XVECLEN (in, i) - 1; j >= 0; --j)
|
if (reg_overlap_mentioned_p (x, XVECEXP (in, i, j)))
|
if (reg_overlap_mentioned_p (x, XVECEXP (in, i, j)))
|
return 1;
|
return 1;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
case SCRATCH:
|
case SCRATCH:
|
case PC:
|
case PC:
|
case CC0:
|
case CC0:
|
return reg_mentioned_p (x, in);
|
return reg_mentioned_p (x, in);
|
|
|
case PARALLEL:
|
case PARALLEL:
|
{
|
{
|
int i;
|
int i;
|
|
|
/* If any register in here refers to it we return true. */
|
/* If any register in here refers to it we return true. */
|
for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
|
for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
|
if (XEXP (XVECEXP (x, 0, i), 0) != 0
|
if (XEXP (XVECEXP (x, 0, i), 0) != 0
|
&& reg_overlap_mentioned_p (XEXP (XVECEXP (x, 0, i), 0), in))
|
&& reg_overlap_mentioned_p (XEXP (XVECEXP (x, 0, i), 0), in))
|
return 1;
|
return 1;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
default:
|
default:
|
gcc_assert (CONSTANT_P (x));
|
gcc_assert (CONSTANT_P (x));
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
|
|
/* Call FUN on each register or MEM that is stored into or clobbered by X.
|
/* Call FUN on each register or MEM that is stored into or clobbered by X.
|
(X would be the pattern of an insn).
|
(X would be the pattern of an insn).
|
FUN receives two arguments:
|
FUN receives two arguments:
|
the REG, MEM, CC0 or PC being stored in or clobbered,
|
the REG, MEM, CC0 or PC being stored in or clobbered,
|
the SET or CLOBBER rtx that does the store.
|
the SET or CLOBBER rtx that does the store.
|
|
|
If the item being stored in or clobbered is a SUBREG of a hard register,
|
If the item being stored in or clobbered is a SUBREG of a hard register,
|
the SUBREG will be passed. */
|
the SUBREG will be passed. */
|
|
|
void
|
void
|
note_stores (rtx x, void (*fun) (rtx, rtx, void *), void *data)
|
note_stores (rtx x, void (*fun) (rtx, rtx, void *), void *data)
|
{
|
{
|
int i;
|
int i;
|
|
|
if (GET_CODE (x) == COND_EXEC)
|
if (GET_CODE (x) == COND_EXEC)
|
x = COND_EXEC_CODE (x);
|
x = COND_EXEC_CODE (x);
|
|
|
if (GET_CODE (x) == SET || GET_CODE (x) == CLOBBER)
|
if (GET_CODE (x) == SET || GET_CODE (x) == CLOBBER)
|
{
|
{
|
rtx dest = SET_DEST (x);
|
rtx dest = SET_DEST (x);
|
|
|
while ((GET_CODE (dest) == SUBREG
|
while ((GET_CODE (dest) == SUBREG
|
&& (!REG_P (SUBREG_REG (dest))
|
&& (!REG_P (SUBREG_REG (dest))
|
|| REGNO (SUBREG_REG (dest)) >= FIRST_PSEUDO_REGISTER))
|
|| REGNO (SUBREG_REG (dest)) >= FIRST_PSEUDO_REGISTER))
|
|| GET_CODE (dest) == ZERO_EXTRACT
|
|| GET_CODE (dest) == ZERO_EXTRACT
|
|| GET_CODE (dest) == STRICT_LOW_PART)
|
|| GET_CODE (dest) == STRICT_LOW_PART)
|
dest = XEXP (dest, 0);
|
dest = XEXP (dest, 0);
|
|
|
/* If we have a PARALLEL, SET_DEST is a list of EXPR_LIST expressions,
|
/* If we have a PARALLEL, SET_DEST is a list of EXPR_LIST expressions,
|
each of whose first operand is a register. */
|
each of whose first operand is a register. */
|
if (GET_CODE (dest) == PARALLEL)
|
if (GET_CODE (dest) == PARALLEL)
|
{
|
{
|
for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
|
for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
|
if (XEXP (XVECEXP (dest, 0, i), 0) != 0)
|
if (XEXP (XVECEXP (dest, 0, i), 0) != 0)
|
(*fun) (XEXP (XVECEXP (dest, 0, i), 0), x, data);
|
(*fun) (XEXP (XVECEXP (dest, 0, i), 0), x, data);
|
}
|
}
|
else
|
else
|
(*fun) (dest, x, data);
|
(*fun) (dest, x, data);
|
}
|
}
|
|
|
else if (GET_CODE (x) == PARALLEL)
|
else if (GET_CODE (x) == PARALLEL)
|
for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
|
for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
|
note_stores (XVECEXP (x, 0, i), fun, data);
|
note_stores (XVECEXP (x, 0, i), fun, data);
|
}
|
}
|
|
|
/* Like notes_stores, but call FUN for each expression that is being
|
/* Like notes_stores, but call FUN for each expression that is being
|
referenced in PBODY, a pointer to the PATTERN of an insn. We only call
|
referenced in PBODY, a pointer to the PATTERN of an insn. We only call
|
FUN for each expression, not any interior subexpressions. FUN receives a
|
FUN for each expression, not any interior subexpressions. FUN receives a
|
pointer to the expression and the DATA passed to this function.
|
pointer to the expression and the DATA passed to this function.
|
|
|
Note that this is not quite the same test as that done in reg_referenced_p
|
Note that this is not quite the same test as that done in reg_referenced_p
|
since that considers something as being referenced if it is being
|
since that considers something as being referenced if it is being
|
partially set, while we do not. */
|
partially set, while we do not. */
|
|
|
void
|
void
|
note_uses (rtx *pbody, void (*fun) (rtx *, void *), void *data)
|
note_uses (rtx *pbody, void (*fun) (rtx *, void *), void *data)
|
{
|
{
|
rtx body = *pbody;
|
rtx body = *pbody;
|
int i;
|
int i;
|
|
|
switch (GET_CODE (body))
|
switch (GET_CODE (body))
|
{
|
{
|
case COND_EXEC:
|
case COND_EXEC:
|
(*fun) (&COND_EXEC_TEST (body), data);
|
(*fun) (&COND_EXEC_TEST (body), data);
|
note_uses (&COND_EXEC_CODE (body), fun, data);
|
note_uses (&COND_EXEC_CODE (body), fun, data);
|
return;
|
return;
|
|
|
case PARALLEL:
|
case PARALLEL:
|
for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
|
for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
|
note_uses (&XVECEXP (body, 0, i), fun, data);
|
note_uses (&XVECEXP (body, 0, i), fun, data);
|
return;
|
return;
|
|
|
case USE:
|
case USE:
|
(*fun) (&XEXP (body, 0), data);
|
(*fun) (&XEXP (body, 0), data);
|
return;
|
return;
|
|
|
case ASM_OPERANDS:
|
case ASM_OPERANDS:
|
for (i = ASM_OPERANDS_INPUT_LENGTH (body) - 1; i >= 0; i--)
|
for (i = ASM_OPERANDS_INPUT_LENGTH (body) - 1; i >= 0; i--)
|
(*fun) (&ASM_OPERANDS_INPUT (body, i), data);
|
(*fun) (&ASM_OPERANDS_INPUT (body, i), data);
|
return;
|
return;
|
|
|
case TRAP_IF:
|
case TRAP_IF:
|
(*fun) (&TRAP_CONDITION (body), data);
|
(*fun) (&TRAP_CONDITION (body), data);
|
return;
|
return;
|
|
|
case PREFETCH:
|
case PREFETCH:
|
(*fun) (&XEXP (body, 0), data);
|
(*fun) (&XEXP (body, 0), data);
|
return;
|
return;
|
|
|
case UNSPEC:
|
case UNSPEC:
|
case UNSPEC_VOLATILE:
|
case UNSPEC_VOLATILE:
|
for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
|
for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
|
(*fun) (&XVECEXP (body, 0, i), data);
|
(*fun) (&XVECEXP (body, 0, i), data);
|
return;
|
return;
|
|
|
case CLOBBER:
|
case CLOBBER:
|
if (MEM_P (XEXP (body, 0)))
|
if (MEM_P (XEXP (body, 0)))
|
(*fun) (&XEXP (XEXP (body, 0), 0), data);
|
(*fun) (&XEXP (XEXP (body, 0), 0), data);
|
return;
|
return;
|
|
|
case SET:
|
case SET:
|
{
|
{
|
rtx dest = SET_DEST (body);
|
rtx dest = SET_DEST (body);
|
|
|
/* For sets we replace everything in source plus registers in memory
|
/* For sets we replace everything in source plus registers in memory
|
expression in store and operands of a ZERO_EXTRACT. */
|
expression in store and operands of a ZERO_EXTRACT. */
|
(*fun) (&SET_SRC (body), data);
|
(*fun) (&SET_SRC (body), data);
|
|
|
if (GET_CODE (dest) == ZERO_EXTRACT)
|
if (GET_CODE (dest) == ZERO_EXTRACT)
|
{
|
{
|
(*fun) (&XEXP (dest, 1), data);
|
(*fun) (&XEXP (dest, 1), data);
|
(*fun) (&XEXP (dest, 2), data);
|
(*fun) (&XEXP (dest, 2), data);
|
}
|
}
|
|
|
while (GET_CODE (dest) == SUBREG || GET_CODE (dest) == STRICT_LOW_PART)
|
while (GET_CODE (dest) == SUBREG || GET_CODE (dest) == STRICT_LOW_PART)
|
dest = XEXP (dest, 0);
|
dest = XEXP (dest, 0);
|
|
|
if (MEM_P (dest))
|
if (MEM_P (dest))
|
(*fun) (&XEXP (dest, 0), data);
|
(*fun) (&XEXP (dest, 0), data);
|
}
|
}
|
return;
|
return;
|
|
|
default:
|
default:
|
/* All the other possibilities never store. */
|
/* All the other possibilities never store. */
|
(*fun) (pbody, data);
|
(*fun) (pbody, data);
|
return;
|
return;
|
}
|
}
|
}
|
}
|
|
|
/* Return nonzero if X's old contents don't survive after INSN.
|
/* Return nonzero if X's old contents don't survive after INSN.
|
This will be true if X is (cc0) or if X is a register and
|
This will be true if X is (cc0) or if X is a register and
|
X dies in INSN or because INSN entirely sets X.
|
X dies in INSN or because INSN entirely sets X.
|
|
|
"Entirely set" means set directly and not through a SUBREG, or
|
"Entirely set" means set directly and not through a SUBREG, or
|
ZERO_EXTRACT, so no trace of the old contents remains.
|
ZERO_EXTRACT, so no trace of the old contents remains.
|
Likewise, REG_INC does not count.
|
Likewise, REG_INC does not count.
|
|
|
REG may be a hard or pseudo reg. Renumbering is not taken into account,
|
REG may be a hard or pseudo reg. Renumbering is not taken into account,
|
but for this use that makes no difference, since regs don't overlap
|
but for this use that makes no difference, since regs don't overlap
|
during their lifetimes. Therefore, this function may be used
|
during their lifetimes. Therefore, this function may be used
|
at any time after deaths have been computed (in flow.c).
|
at any time after deaths have been computed (in flow.c).
|
|
|
If REG is a hard reg that occupies multiple machine registers, this
|
If REG is a hard reg that occupies multiple machine registers, this
|
function will only return 1 if each of those registers will be replaced
|
function will only return 1 if each of those registers will be replaced
|
by INSN. */
|
by INSN. */
|
|
|
int
|
int
|
dead_or_set_p (rtx insn, rtx x)
|
dead_or_set_p (rtx insn, rtx x)
|
{
|
{
|
unsigned int regno, last_regno;
|
unsigned int regno, last_regno;
|
unsigned int i;
|
unsigned int i;
|
|
|
/* Can't use cc0_rtx below since this file is used by genattrtab.c. */
|
/* Can't use cc0_rtx below since this file is used by genattrtab.c. */
|
if (GET_CODE (x) == CC0)
|
if (GET_CODE (x) == CC0)
|
return 1;
|
return 1;
|
|
|
gcc_assert (REG_P (x));
|
gcc_assert (REG_P (x));
|
|
|
regno = REGNO (x);
|
regno = REGNO (x);
|
last_regno = (regno >= FIRST_PSEUDO_REGISTER ? regno
|
last_regno = (regno >= FIRST_PSEUDO_REGISTER ? regno
|
: regno + hard_regno_nregs[regno][GET_MODE (x)] - 1);
|
: regno + hard_regno_nregs[regno][GET_MODE (x)] - 1);
|
|
|
for (i = regno; i <= last_regno; i++)
|
for (i = regno; i <= last_regno; i++)
|
if (! dead_or_set_regno_p (insn, i))
|
if (! dead_or_set_regno_p (insn, i))
|
return 0;
|
return 0;
|
|
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* Return TRUE iff DEST is a register or subreg of a register and
|
/* Return TRUE iff DEST is a register or subreg of a register and
|
doesn't change the number of words of the inner register, and any
|
doesn't change the number of words of the inner register, and any
|
part of the register is TEST_REGNO. */
|
part of the register is TEST_REGNO. */
|
|
|
static bool
|
static bool
|
covers_regno_no_parallel_p (rtx dest, unsigned int test_regno)
|
covers_regno_no_parallel_p (rtx dest, unsigned int test_regno)
|
{
|
{
|
unsigned int regno, endregno;
|
unsigned int regno, endregno;
|
|
|
if (GET_CODE (dest) == SUBREG
|
if (GET_CODE (dest) == SUBREG
|
&& (((GET_MODE_SIZE (GET_MODE (dest))
|
&& (((GET_MODE_SIZE (GET_MODE (dest))
|
+ UNITS_PER_WORD - 1) / UNITS_PER_WORD)
|
+ UNITS_PER_WORD - 1) / UNITS_PER_WORD)
|
== ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
|
== ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
|
+ UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
|
+ UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
|
dest = SUBREG_REG (dest);
|
dest = SUBREG_REG (dest);
|
|
|
if (!REG_P (dest))
|
if (!REG_P (dest))
|
return false;
|
return false;
|
|
|
regno = REGNO (dest);
|
regno = REGNO (dest);
|
endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
|
endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
|
: regno + hard_regno_nregs[regno][GET_MODE (dest)]);
|
: regno + hard_regno_nregs[regno][GET_MODE (dest)]);
|
return (test_regno >= regno && test_regno < endregno);
|
return (test_regno >= regno && test_regno < endregno);
|
}
|
}
|
|
|
/* Like covers_regno_no_parallel_p, but also handles PARALLELs where
|
/* Like covers_regno_no_parallel_p, but also handles PARALLELs where
|
any member matches the covers_regno_no_parallel_p criteria. */
|
any member matches the covers_regno_no_parallel_p criteria. */
|
|
|
static bool
|
static bool
|
covers_regno_p (rtx dest, unsigned int test_regno)
|
covers_regno_p (rtx dest, unsigned int test_regno)
|
{
|
{
|
if (GET_CODE (dest) == PARALLEL)
|
if (GET_CODE (dest) == PARALLEL)
|
{
|
{
|
/* Some targets place small structures in registers for return
|
/* Some targets place small structures in registers for return
|
values of functions, and those registers are wrapped in
|
values of functions, and those registers are wrapped in
|
PARALLELs that we may see as the destination of a SET. */
|
PARALLELs that we may see as the destination of a SET. */
|
int i;
|
int i;
|
|
|
for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
|
for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
|
{
|
{
|
rtx inner = XEXP (XVECEXP (dest, 0, i), 0);
|
rtx inner = XEXP (XVECEXP (dest, 0, i), 0);
|
if (inner != NULL_RTX
|
if (inner != NULL_RTX
|
&& covers_regno_no_parallel_p (inner, test_regno))
|
&& covers_regno_no_parallel_p (inner, test_regno))
|
return true;
|
return true;
|
}
|
}
|
|
|
return false;
|
return false;
|
}
|
}
|
else
|
else
|
return covers_regno_no_parallel_p (dest, test_regno);
|
return covers_regno_no_parallel_p (dest, test_regno);
|
}
|
}
|
|
|
/* Utility function for dead_or_set_p to check an individual register. Also
|
/* Utility function for dead_or_set_p to check an individual register. Also
|
called from flow.c. */
|
called from flow.c. */
|
|
|
int
|
int
|
dead_or_set_regno_p (rtx insn, unsigned int test_regno)
|
dead_or_set_regno_p (rtx insn, unsigned int test_regno)
|
{
|
{
|
rtx pattern;
|
rtx pattern;
|
|
|
/* See if there is a death note for something that includes TEST_REGNO. */
|
/* See if there is a death note for something that includes TEST_REGNO. */
|
if (find_regno_note (insn, REG_DEAD, test_regno))
|
if (find_regno_note (insn, REG_DEAD, test_regno))
|
return 1;
|
return 1;
|
|
|
if (CALL_P (insn)
|
if (CALL_P (insn)
|
&& find_regno_fusage (insn, CLOBBER, test_regno))
|
&& find_regno_fusage (insn, CLOBBER, test_regno))
|
return 1;
|
return 1;
|
|
|
pattern = PATTERN (insn);
|
pattern = PATTERN (insn);
|
|
|
if (GET_CODE (pattern) == COND_EXEC)
|
if (GET_CODE (pattern) == COND_EXEC)
|
pattern = COND_EXEC_CODE (pattern);
|
pattern = COND_EXEC_CODE (pattern);
|
|
|
if (GET_CODE (pattern) == SET)
|
if (GET_CODE (pattern) == SET)
|
return covers_regno_p (SET_DEST (pattern), test_regno);
|
return covers_regno_p (SET_DEST (pattern), test_regno);
|
else if (GET_CODE (pattern) == PARALLEL)
|
else if (GET_CODE (pattern) == PARALLEL)
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = XVECLEN (pattern, 0) - 1; i >= 0; i--)
|
for (i = XVECLEN (pattern, 0) - 1; i >= 0; i--)
|
{
|
{
|
rtx body = XVECEXP (pattern, 0, i);
|
rtx body = XVECEXP (pattern, 0, i);
|
|
|
if (GET_CODE (body) == COND_EXEC)
|
if (GET_CODE (body) == COND_EXEC)
|
body = COND_EXEC_CODE (body);
|
body = COND_EXEC_CODE (body);
|
|
|
if ((GET_CODE (body) == SET || GET_CODE (body) == CLOBBER)
|
if ((GET_CODE (body) == SET || GET_CODE (body) == CLOBBER)
|
&& covers_regno_p (SET_DEST (body), test_regno))
|
&& covers_regno_p (SET_DEST (body), test_regno))
|
return 1;
|
return 1;
|
}
|
}
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return the reg-note of kind KIND in insn INSN, if there is one.
|
/* Return the reg-note of kind KIND in insn INSN, if there is one.
|
If DATUM is nonzero, look for one whose datum is DATUM. */
|
If DATUM is nonzero, look for one whose datum is DATUM. */
|
|
|
rtx
|
rtx
|
find_reg_note (rtx insn, enum reg_note kind, rtx datum)
|
find_reg_note (rtx insn, enum reg_note kind, rtx datum)
|
{
|
{
|
rtx link;
|
rtx link;
|
|
|
gcc_assert (insn);
|
gcc_assert (insn);
|
|
|
/* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
|
/* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
|
if (! INSN_P (insn))
|
if (! INSN_P (insn))
|
return 0;
|
return 0;
|
if (datum == 0)
|
if (datum == 0)
|
{
|
{
|
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
|
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
|
if (REG_NOTE_KIND (link) == kind)
|
if (REG_NOTE_KIND (link) == kind)
|
return link;
|
return link;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
|
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
|
if (REG_NOTE_KIND (link) == kind && datum == XEXP (link, 0))
|
if (REG_NOTE_KIND (link) == kind && datum == XEXP (link, 0))
|
return link;
|
return link;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return the reg-note of kind KIND in insn INSN which applies to register
|
/* Return the reg-note of kind KIND in insn INSN which applies to register
|
number REGNO, if any. Return 0 if there is no such reg-note. Note that
|
number REGNO, if any. Return 0 if there is no such reg-note. Note that
|
the REGNO of this NOTE need not be REGNO if REGNO is a hard register;
|
the REGNO of this NOTE need not be REGNO if REGNO is a hard register;
|
it might be the case that the note overlaps REGNO. */
|
it might be the case that the note overlaps REGNO. */
|
|
|
rtx
|
rtx
|
find_regno_note (rtx insn, enum reg_note kind, unsigned int regno)
|
find_regno_note (rtx insn, enum reg_note kind, unsigned int regno)
|
{
|
{
|
rtx link;
|
rtx link;
|
|
|
/* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
|
/* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
|
if (! INSN_P (insn))
|
if (! INSN_P (insn))
|
return 0;
|
return 0;
|
|
|
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
|
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
|
if (REG_NOTE_KIND (link) == kind
|
if (REG_NOTE_KIND (link) == kind
|
/* Verify that it is a register, so that scratch and MEM won't cause a
|
/* Verify that it is a register, so that scratch and MEM won't cause a
|
problem here. */
|
problem here. */
|
&& REG_P (XEXP (link, 0))
|
&& REG_P (XEXP (link, 0))
|
&& REGNO (XEXP (link, 0)) <= regno
|
&& REGNO (XEXP (link, 0)) <= regno
|
&& ((REGNO (XEXP (link, 0))
|
&& ((REGNO (XEXP (link, 0))
|
+ (REGNO (XEXP (link, 0)) >= FIRST_PSEUDO_REGISTER ? 1
|
+ (REGNO (XEXP (link, 0)) >= FIRST_PSEUDO_REGISTER ? 1
|
: hard_regno_nregs[REGNO (XEXP (link, 0))]
|
: hard_regno_nregs[REGNO (XEXP (link, 0))]
|
[GET_MODE (XEXP (link, 0))]))
|
[GET_MODE (XEXP (link, 0))]))
|
> regno))
|
> regno))
|
return link;
|
return link;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return a REG_EQUIV or REG_EQUAL note if insn has only a single set and
|
/* Return a REG_EQUIV or REG_EQUAL note if insn has only a single set and
|
has such a note. */
|
has such a note. */
|
|
|
rtx
|
rtx
|
find_reg_equal_equiv_note (rtx insn)
|
find_reg_equal_equiv_note (rtx insn)
|
{
|
{
|
rtx link;
|
rtx link;
|
|
|
if (!INSN_P (insn))
|
if (!INSN_P (insn))
|
return 0;
|
return 0;
|
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
|
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
|
if (REG_NOTE_KIND (link) == REG_EQUAL
|
if (REG_NOTE_KIND (link) == REG_EQUAL
|
|| REG_NOTE_KIND (link) == REG_EQUIV)
|
|| REG_NOTE_KIND (link) == REG_EQUIV)
|
{
|
{
|
if (single_set (insn) == 0)
|
if (single_set (insn) == 0)
|
return 0;
|
return 0;
|
return link;
|
return link;
|
}
|
}
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* Return true if DATUM, or any overlap of DATUM, of kind CODE is found
|
/* Return true if DATUM, or any overlap of DATUM, of kind CODE is found
|
in the CALL_INSN_FUNCTION_USAGE information of INSN. */
|
in the CALL_INSN_FUNCTION_USAGE information of INSN. */
|
|
|
int
|
int
|
find_reg_fusage (rtx insn, enum rtx_code code, rtx datum)
|
find_reg_fusage (rtx insn, enum rtx_code code, rtx datum)
|
{
|
{
|
/* If it's not a CALL_INSN, it can't possibly have a
|
/* If it's not a CALL_INSN, it can't possibly have a
|
CALL_INSN_FUNCTION_USAGE field, so don't bother checking. */
|
CALL_INSN_FUNCTION_USAGE field, so don't bother checking. */
|
if (!CALL_P (insn))
|
if (!CALL_P (insn))
|
return 0;
|
return 0;
|
|
|
gcc_assert (datum);
|
gcc_assert (datum);
|
|
|
if (!REG_P (datum))
|
if (!REG_P (datum))
|
{
|
{
|
rtx link;
|
rtx link;
|
|
|
for (link = CALL_INSN_FUNCTION_USAGE (insn);
|
for (link = CALL_INSN_FUNCTION_USAGE (insn);
|
link;
|
link;
|
link = XEXP (link, 1))
|
link = XEXP (link, 1))
|
if (GET_CODE (XEXP (link, 0)) == code
|
if (GET_CODE (XEXP (link, 0)) == code
|
&& rtx_equal_p (datum, XEXP (XEXP (link, 0), 0)))
|
&& rtx_equal_p (datum, XEXP (XEXP (link, 0), 0)))
|
return 1;
|
return 1;
|
}
|
}
|
else
|
else
|
{
|
{
|
unsigned int regno = REGNO (datum);
|
unsigned int regno = REGNO (datum);
|
|
|
/* CALL_INSN_FUNCTION_USAGE information cannot contain references
|
/* CALL_INSN_FUNCTION_USAGE information cannot contain references
|
to pseudo registers, so don't bother checking. */
|
to pseudo registers, so don't bother checking. */
|
|
|
if (regno < FIRST_PSEUDO_REGISTER)
|
if (regno < FIRST_PSEUDO_REGISTER)
|
{
|
{
|
unsigned int end_regno
|
unsigned int end_regno
|
= regno + hard_regno_nregs[regno][GET_MODE (datum)];
|
= regno + hard_regno_nregs[regno][GET_MODE (datum)];
|
unsigned int i;
|
unsigned int i;
|
|
|
for (i = regno; i < end_regno; i++)
|
for (i = regno; i < end_regno; i++)
|
if (find_regno_fusage (insn, code, i))
|
if (find_regno_fusage (insn, code, i))
|
return 1;
|
return 1;
|
}
|
}
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return true if REGNO, or any overlap of REGNO, of kind CODE is found
|
/* Return true if REGNO, or any overlap of REGNO, of kind CODE is found
|
in the CALL_INSN_FUNCTION_USAGE information of INSN. */
|
in the CALL_INSN_FUNCTION_USAGE information of INSN. */
|
|
|
int
|
int
|
find_regno_fusage (rtx insn, enum rtx_code code, unsigned int regno)
|
find_regno_fusage (rtx insn, enum rtx_code code, unsigned int regno)
|
{
|
{
|
rtx link;
|
rtx link;
|
|
|
/* CALL_INSN_FUNCTION_USAGE information cannot contain references
|
/* CALL_INSN_FUNCTION_USAGE information cannot contain references
|
to pseudo registers, so don't bother checking. */
|
to pseudo registers, so don't bother checking. */
|
|
|
if (regno >= FIRST_PSEUDO_REGISTER
|
if (regno >= FIRST_PSEUDO_REGISTER
|
|| !CALL_P (insn) )
|
|| !CALL_P (insn) )
|
return 0;
|
return 0;
|
|
|
for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
|
for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
|
{
|
{
|
unsigned int regnote;
|
unsigned int regnote;
|
rtx op, reg;
|
rtx op, reg;
|
|
|
if (GET_CODE (op = XEXP (link, 0)) == code
|
if (GET_CODE (op = XEXP (link, 0)) == code
|
&& REG_P (reg = XEXP (op, 0))
|
&& REG_P (reg = XEXP (op, 0))
|
&& (regnote = REGNO (reg)) <= regno
|
&& (regnote = REGNO (reg)) <= regno
|
&& regnote + hard_regno_nregs[regnote][GET_MODE (reg)] > regno)
|
&& regnote + hard_regno_nregs[regnote][GET_MODE (reg)] > regno)
|
return 1;
|
return 1;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return true if INSN is a call to a pure function. */
|
/* Return true if INSN is a call to a pure function. */
|
|
|
int
|
int
|
pure_call_p (rtx insn)
|
pure_call_p (rtx insn)
|
{
|
{
|
rtx link;
|
rtx link;
|
|
|
if (!CALL_P (insn) || ! CONST_OR_PURE_CALL_P (insn))
|
if (!CALL_P (insn) || ! CONST_OR_PURE_CALL_P (insn))
|
return 0;
|
return 0;
|
|
|
/* Look for the note that differentiates const and pure functions. */
|
/* Look for the note that differentiates const and pure functions. */
|
for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
|
for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
|
{
|
{
|
rtx u, m;
|
rtx u, m;
|
|
|
if (GET_CODE (u = XEXP (link, 0)) == USE
|
if (GET_CODE (u = XEXP (link, 0)) == USE
|
&& MEM_P (m = XEXP (u, 0)) && GET_MODE (m) == BLKmode
|
&& MEM_P (m = XEXP (u, 0)) && GET_MODE (m) == BLKmode
|
&& GET_CODE (XEXP (m, 0)) == SCRATCH)
|
&& GET_CODE (XEXP (m, 0)) == SCRATCH)
|
return 1;
|
return 1;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Remove register note NOTE from the REG_NOTES of INSN. */
|
/* Remove register note NOTE from the REG_NOTES of INSN. */
|
|
|
void
|
void
|
remove_note (rtx insn, rtx note)
|
remove_note (rtx insn, rtx note)
|
{
|
{
|
rtx link;
|
rtx link;
|
|
|
if (note == NULL_RTX)
|
if (note == NULL_RTX)
|
return;
|
return;
|
|
|
if (REG_NOTES (insn) == note)
|
if (REG_NOTES (insn) == note)
|
{
|
{
|
REG_NOTES (insn) = XEXP (note, 1);
|
REG_NOTES (insn) = XEXP (note, 1);
|
return;
|
return;
|
}
|
}
|
|
|
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
|
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
|
if (XEXP (link, 1) == note)
|
if (XEXP (link, 1) == note)
|
{
|
{
|
XEXP (link, 1) = XEXP (note, 1);
|
XEXP (link, 1) = XEXP (note, 1);
|
return;
|
return;
|
}
|
}
|
|
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
/* Search LISTP (an EXPR_LIST) for an entry whose first operand is NODE and
|
/* Search LISTP (an EXPR_LIST) for an entry whose first operand is NODE and
|
return 1 if it is found. A simple equality test is used to determine if
|
return 1 if it is found. A simple equality test is used to determine if
|
NODE matches. */
|
NODE matches. */
|
|
|
int
|
int
|
in_expr_list_p (rtx listp, rtx node)
|
in_expr_list_p (rtx listp, rtx node)
|
{
|
{
|
rtx x;
|
rtx x;
|
|
|
for (x = listp; x; x = XEXP (x, 1))
|
for (x = listp; x; x = XEXP (x, 1))
|
if (node == XEXP (x, 0))
|
if (node == XEXP (x, 0))
|
return 1;
|
return 1;
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Search LISTP (an EXPR_LIST) for an entry whose first operand is NODE and
|
/* Search LISTP (an EXPR_LIST) for an entry whose first operand is NODE and
|
remove that entry from the list if it is found.
|
remove that entry from the list if it is found.
|
|
|
A simple equality test is used to determine if NODE matches. */
|
A simple equality test is used to determine if NODE matches. */
|
|
|
void
|
void
|
remove_node_from_expr_list (rtx node, rtx *listp)
|
remove_node_from_expr_list (rtx node, rtx *listp)
|
{
|
{
|
rtx temp = *listp;
|
rtx temp = *listp;
|
rtx prev = NULL_RTX;
|
rtx prev = NULL_RTX;
|
|
|
while (temp)
|
while (temp)
|
{
|
{
|
if (node == XEXP (temp, 0))
|
if (node == XEXP (temp, 0))
|
{
|
{
|
/* Splice the node out of the list. */
|
/* Splice the node out of the list. */
|
if (prev)
|
if (prev)
|
XEXP (prev, 1) = XEXP (temp, 1);
|
XEXP (prev, 1) = XEXP (temp, 1);
|
else
|
else
|
*listp = XEXP (temp, 1);
|
*listp = XEXP (temp, 1);
|
|
|
return;
|
return;
|
}
|
}
|
|
|
prev = temp;
|
prev = temp;
|
temp = XEXP (temp, 1);
|
temp = XEXP (temp, 1);
|
}
|
}
|
}
|
}
|
|
|
/* Nonzero if X contains any volatile instructions. These are instructions
|
/* Nonzero if X contains any volatile instructions. These are instructions
|
which may cause unpredictable machine state instructions, and thus no
|
which may cause unpredictable machine state instructions, and thus no
|
instructions should be moved or combined across them. This includes
|
instructions should be moved or combined across them. This includes
|
only volatile asms and UNSPEC_VOLATILE instructions. */
|
only volatile asms and UNSPEC_VOLATILE instructions. */
|
|
|
int
|
int
|
volatile_insn_p (rtx x)
|
volatile_insn_p (rtx x)
|
{
|
{
|
RTX_CODE code;
|
RTX_CODE code;
|
|
|
code = GET_CODE (x);
|
code = GET_CODE (x);
|
switch (code)
|
switch (code)
|
{
|
{
|
case LABEL_REF:
|
case LABEL_REF:
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
case CONST_INT:
|
case CONST_INT:
|
case CONST:
|
case CONST:
|
case CONST_DOUBLE:
|
case CONST_DOUBLE:
|
case CONST_VECTOR:
|
case CONST_VECTOR:
|
case CC0:
|
case CC0:
|
case PC:
|
case PC:
|
case REG:
|
case REG:
|
case SCRATCH:
|
case SCRATCH:
|
case CLOBBER:
|
case CLOBBER:
|
case ADDR_VEC:
|
case ADDR_VEC:
|
case ADDR_DIFF_VEC:
|
case ADDR_DIFF_VEC:
|
case CALL:
|
case CALL:
|
case MEM:
|
case MEM:
|
return 0;
|
return 0;
|
|
|
case UNSPEC_VOLATILE:
|
case UNSPEC_VOLATILE:
|
/* case TRAP_IF: This isn't clear yet. */
|
/* case TRAP_IF: This isn't clear yet. */
|
return 1;
|
return 1;
|
|
|
case ASM_INPUT:
|
case ASM_INPUT:
|
case ASM_OPERANDS:
|
case ASM_OPERANDS:
|
if (MEM_VOLATILE_P (x))
|
if (MEM_VOLATILE_P (x))
|
return 1;
|
return 1;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
/* Recursively scan the operands of this expression. */
|
/* Recursively scan the operands of this expression. */
|
|
|
{
|
{
|
const char *fmt = GET_RTX_FORMAT (code);
|
const char *fmt = GET_RTX_FORMAT (code);
|
int i;
|
int i;
|
|
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
{
|
{
|
if (fmt[i] == 'e')
|
if (fmt[i] == 'e')
|
{
|
{
|
if (volatile_insn_p (XEXP (x, i)))
|
if (volatile_insn_p (XEXP (x, i)))
|
return 1;
|
return 1;
|
}
|
}
|
else if (fmt[i] == 'E')
|
else if (fmt[i] == 'E')
|
{
|
{
|
int j;
|
int j;
|
for (j = 0; j < XVECLEN (x, i); j++)
|
for (j = 0; j < XVECLEN (x, i); j++)
|
if (volatile_insn_p (XVECEXP (x, i, j)))
|
if (volatile_insn_p (XVECEXP (x, i, j)))
|
return 1;
|
return 1;
|
}
|
}
|
}
|
}
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Nonzero if X contains any volatile memory references
|
/* Nonzero if X contains any volatile memory references
|
UNSPEC_VOLATILE operations or volatile ASM_OPERANDS expressions. */
|
UNSPEC_VOLATILE operations or volatile ASM_OPERANDS expressions. */
|
|
|
int
|
int
|
volatile_refs_p (rtx x)
|
volatile_refs_p (rtx x)
|
{
|
{
|
RTX_CODE code;
|
RTX_CODE code;
|
|
|
code = GET_CODE (x);
|
code = GET_CODE (x);
|
switch (code)
|
switch (code)
|
{
|
{
|
case LABEL_REF:
|
case LABEL_REF:
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
case CONST_INT:
|
case CONST_INT:
|
case CONST:
|
case CONST:
|
case CONST_DOUBLE:
|
case CONST_DOUBLE:
|
case CONST_VECTOR:
|
case CONST_VECTOR:
|
case CC0:
|
case CC0:
|
case PC:
|
case PC:
|
case REG:
|
case REG:
|
case SCRATCH:
|
case SCRATCH:
|
case CLOBBER:
|
case CLOBBER:
|
case ADDR_VEC:
|
case ADDR_VEC:
|
case ADDR_DIFF_VEC:
|
case ADDR_DIFF_VEC:
|
return 0;
|
return 0;
|
|
|
case UNSPEC_VOLATILE:
|
case UNSPEC_VOLATILE:
|
return 1;
|
return 1;
|
|
|
case MEM:
|
case MEM:
|
case ASM_INPUT:
|
case ASM_INPUT:
|
case ASM_OPERANDS:
|
case ASM_OPERANDS:
|
if (MEM_VOLATILE_P (x))
|
if (MEM_VOLATILE_P (x))
|
return 1;
|
return 1;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
/* Recursively scan the operands of this expression. */
|
/* Recursively scan the operands of this expression. */
|
|
|
{
|
{
|
const char *fmt = GET_RTX_FORMAT (code);
|
const char *fmt = GET_RTX_FORMAT (code);
|
int i;
|
int i;
|
|
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
{
|
{
|
if (fmt[i] == 'e')
|
if (fmt[i] == 'e')
|
{
|
{
|
if (volatile_refs_p (XEXP (x, i)))
|
if (volatile_refs_p (XEXP (x, i)))
|
return 1;
|
return 1;
|
}
|
}
|
else if (fmt[i] == 'E')
|
else if (fmt[i] == 'E')
|
{
|
{
|
int j;
|
int j;
|
for (j = 0; j < XVECLEN (x, i); j++)
|
for (j = 0; j < XVECLEN (x, i); j++)
|
if (volatile_refs_p (XVECEXP (x, i, j)))
|
if (volatile_refs_p (XVECEXP (x, i, j)))
|
return 1;
|
return 1;
|
}
|
}
|
}
|
}
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Similar to above, except that it also rejects register pre- and post-
|
/* Similar to above, except that it also rejects register pre- and post-
|
incrementing. */
|
incrementing. */
|
|
|
int
|
int
|
side_effects_p (rtx x)
|
side_effects_p (rtx x)
|
{
|
{
|
RTX_CODE code;
|
RTX_CODE code;
|
|
|
code = GET_CODE (x);
|
code = GET_CODE (x);
|
switch (code)
|
switch (code)
|
{
|
{
|
case LABEL_REF:
|
case LABEL_REF:
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
case CONST_INT:
|
case CONST_INT:
|
case CONST:
|
case CONST:
|
case CONST_DOUBLE:
|
case CONST_DOUBLE:
|
case CONST_VECTOR:
|
case CONST_VECTOR:
|
case CC0:
|
case CC0:
|
case PC:
|
case PC:
|
case REG:
|
case REG:
|
case SCRATCH:
|
case SCRATCH:
|
case ADDR_VEC:
|
case ADDR_VEC:
|
case ADDR_DIFF_VEC:
|
case ADDR_DIFF_VEC:
|
return 0;
|
return 0;
|
|
|
case CLOBBER:
|
case CLOBBER:
|
/* Reject CLOBBER with a non-VOID mode. These are made by combine.c
|
/* Reject CLOBBER with a non-VOID mode. These are made by combine.c
|
when some combination can't be done. If we see one, don't think
|
when some combination can't be done. If we see one, don't think
|
that we can simplify the expression. */
|
that we can simplify the expression. */
|
return (GET_MODE (x) != VOIDmode);
|
return (GET_MODE (x) != VOIDmode);
|
|
|
case PRE_INC:
|
case PRE_INC:
|
case PRE_DEC:
|
case PRE_DEC:
|
case POST_INC:
|
case POST_INC:
|
case POST_DEC:
|
case POST_DEC:
|
case PRE_MODIFY:
|
case PRE_MODIFY:
|
case POST_MODIFY:
|
case POST_MODIFY:
|
case CALL:
|
case CALL:
|
case UNSPEC_VOLATILE:
|
case UNSPEC_VOLATILE:
|
/* case TRAP_IF: This isn't clear yet. */
|
/* case TRAP_IF: This isn't clear yet. */
|
return 1;
|
return 1;
|
|
|
case MEM:
|
case MEM:
|
case ASM_INPUT:
|
case ASM_INPUT:
|
case ASM_OPERANDS:
|
case ASM_OPERANDS:
|
if (MEM_VOLATILE_P (x))
|
if (MEM_VOLATILE_P (x))
|
return 1;
|
return 1;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
/* Recursively scan the operands of this expression. */
|
/* Recursively scan the operands of this expression. */
|
|
|
{
|
{
|
const char *fmt = GET_RTX_FORMAT (code);
|
const char *fmt = GET_RTX_FORMAT (code);
|
int i;
|
int i;
|
|
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
{
|
{
|
if (fmt[i] == 'e')
|
if (fmt[i] == 'e')
|
{
|
{
|
if (side_effects_p (XEXP (x, i)))
|
if (side_effects_p (XEXP (x, i)))
|
return 1;
|
return 1;
|
}
|
}
|
else if (fmt[i] == 'E')
|
else if (fmt[i] == 'E')
|
{
|
{
|
int j;
|
int j;
|
for (j = 0; j < XVECLEN (x, i); j++)
|
for (j = 0; j < XVECLEN (x, i); j++)
|
if (side_effects_p (XVECEXP (x, i, j)))
|
if (side_effects_p (XVECEXP (x, i, j)))
|
return 1;
|
return 1;
|
}
|
}
|
}
|
}
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
enum may_trap_p_flags
|
enum may_trap_p_flags
|
{
|
{
|
MTP_UNALIGNED_MEMS = 1,
|
MTP_UNALIGNED_MEMS = 1,
|
MTP_AFTER_MOVE = 2
|
MTP_AFTER_MOVE = 2
|
};
|
};
|
/* Return nonzero if evaluating rtx X might cause a trap.
|
/* Return nonzero if evaluating rtx X might cause a trap.
|
(FLAGS & MTP_UNALIGNED_MEMS) controls whether nonzero is returned for
|
(FLAGS & MTP_UNALIGNED_MEMS) controls whether nonzero is returned for
|
unaligned memory accesses on strict alignment machines. If
|
unaligned memory accesses on strict alignment machines. If
|
(FLAGS & AFTER_MOVE) is true, returns nonzero even in case the expression
|
(FLAGS & AFTER_MOVE) is true, returns nonzero even in case the expression
|
cannot trap at its current location, but it might become trapping if moved
|
cannot trap at its current location, but it might become trapping if moved
|
elsewhere. */
|
elsewhere. */
|
|
|
static int
|
static int
|
may_trap_p_1 (rtx x, unsigned flags)
|
may_trap_p_1 (rtx x, unsigned flags)
|
{
|
{
|
int i;
|
int i;
|
enum rtx_code code;
|
enum rtx_code code;
|
const char *fmt;
|
const char *fmt;
|
bool unaligned_mems = (flags & MTP_UNALIGNED_MEMS) != 0;
|
bool unaligned_mems = (flags & MTP_UNALIGNED_MEMS) != 0;
|
|
|
if (x == 0)
|
if (x == 0)
|
return 0;
|
return 0;
|
code = GET_CODE (x);
|
code = GET_CODE (x);
|
switch (code)
|
switch (code)
|
{
|
{
|
/* Handle these cases quickly. */
|
/* Handle these cases quickly. */
|
case CONST_INT:
|
case CONST_INT:
|
case CONST_DOUBLE:
|
case CONST_DOUBLE:
|
case CONST_VECTOR:
|
case CONST_VECTOR:
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
case LABEL_REF:
|
case LABEL_REF:
|
case CONST:
|
case CONST:
|
case PC:
|
case PC:
|
case CC0:
|
case CC0:
|
case REG:
|
case REG:
|
case SCRATCH:
|
case SCRATCH:
|
return 0;
|
return 0;
|
|
|
case ASM_INPUT:
|
case ASM_INPUT:
|
case UNSPEC_VOLATILE:
|
case UNSPEC_VOLATILE:
|
case TRAP_IF:
|
case TRAP_IF:
|
return 1;
|
return 1;
|
|
|
case ASM_OPERANDS:
|
case ASM_OPERANDS:
|
return MEM_VOLATILE_P (x);
|
return MEM_VOLATILE_P (x);
|
|
|
/* Memory ref can trap unless it's a static var or a stack slot. */
|
/* Memory ref can trap unless it's a static var or a stack slot. */
|
case MEM:
|
case MEM:
|
if (/* MEM_NOTRAP_P only relates to the actual position of the memory
|
if (/* MEM_NOTRAP_P only relates to the actual position of the memory
|
reference; moving it out of condition might cause its address
|
reference; moving it out of condition might cause its address
|
become invalid. */
|
become invalid. */
|
!(flags & MTP_AFTER_MOVE)
|
!(flags & MTP_AFTER_MOVE)
|
&& MEM_NOTRAP_P (x)
|
&& MEM_NOTRAP_P (x)
|
&& (!STRICT_ALIGNMENT || !unaligned_mems))
|
&& (!STRICT_ALIGNMENT || !unaligned_mems))
|
return 0;
|
return 0;
|
return
|
return
|
rtx_addr_can_trap_p_1 (XEXP (x, 0), GET_MODE (x), unaligned_mems);
|
rtx_addr_can_trap_p_1 (XEXP (x, 0), GET_MODE (x), unaligned_mems);
|
|
|
/* Division by a non-constant might trap. */
|
/* Division by a non-constant might trap. */
|
case DIV:
|
case DIV:
|
case MOD:
|
case MOD:
|
case UDIV:
|
case UDIV:
|
case UMOD:
|
case UMOD:
|
if (HONOR_SNANS (GET_MODE (x)))
|
if (HONOR_SNANS (GET_MODE (x)))
|
return 1;
|
return 1;
|
if (SCALAR_FLOAT_MODE_P (GET_MODE (x)))
|
if (SCALAR_FLOAT_MODE_P (GET_MODE (x)))
|
return flag_trapping_math;
|
return flag_trapping_math;
|
if (!CONSTANT_P (XEXP (x, 1)) || (XEXP (x, 1) == const0_rtx))
|
if (!CONSTANT_P (XEXP (x, 1)) || (XEXP (x, 1) == const0_rtx))
|
return 1;
|
return 1;
|
break;
|
break;
|
|
|
case EXPR_LIST:
|
case EXPR_LIST:
|
/* An EXPR_LIST is used to represent a function call. This
|
/* An EXPR_LIST is used to represent a function call. This
|
certainly may trap. */
|
certainly may trap. */
|
return 1;
|
return 1;
|
|
|
case GE:
|
case GE:
|
case GT:
|
case GT:
|
case LE:
|
case LE:
|
case LT:
|
case LT:
|
case LTGT:
|
case LTGT:
|
case COMPARE:
|
case COMPARE:
|
/* Some floating point comparisons may trap. */
|
/* Some floating point comparisons may trap. */
|
if (!flag_trapping_math)
|
if (!flag_trapping_math)
|
break;
|
break;
|
/* ??? There is no machine independent way to check for tests that trap
|
/* ??? There is no machine independent way to check for tests that trap
|
when COMPARE is used, though many targets do make this distinction.
|
when COMPARE is used, though many targets do make this distinction.
|
For instance, sparc uses CCFPE for compares which generate exceptions
|
For instance, sparc uses CCFPE for compares which generate exceptions
|
and CCFP for compares which do not generate exceptions. */
|
and CCFP for compares which do not generate exceptions. */
|
if (HONOR_NANS (GET_MODE (x)))
|
if (HONOR_NANS (GET_MODE (x)))
|
return 1;
|
return 1;
|
/* But often the compare has some CC mode, so check operand
|
/* But often the compare has some CC mode, so check operand
|
modes as well. */
|
modes as well. */
|
if (HONOR_NANS (GET_MODE (XEXP (x, 0)))
|
if (HONOR_NANS (GET_MODE (XEXP (x, 0)))
|
|| HONOR_NANS (GET_MODE (XEXP (x, 1))))
|
|| HONOR_NANS (GET_MODE (XEXP (x, 1))))
|
return 1;
|
return 1;
|
break;
|
break;
|
|
|
case EQ:
|
case EQ:
|
case NE:
|
case NE:
|
if (HONOR_SNANS (GET_MODE (x)))
|
if (HONOR_SNANS (GET_MODE (x)))
|
return 1;
|
return 1;
|
/* Often comparison is CC mode, so check operand modes. */
|
/* Often comparison is CC mode, so check operand modes. */
|
if (HONOR_SNANS (GET_MODE (XEXP (x, 0)))
|
if (HONOR_SNANS (GET_MODE (XEXP (x, 0)))
|
|| HONOR_SNANS (GET_MODE (XEXP (x, 1))))
|
|| HONOR_SNANS (GET_MODE (XEXP (x, 1))))
|
return 1;
|
return 1;
|
break;
|
break;
|
|
|
case FIX:
|
case FIX:
|
/* Conversion of floating point might trap. */
|
/* Conversion of floating point might trap. */
|
if (flag_trapping_math && HONOR_NANS (GET_MODE (XEXP (x, 0))))
|
if (flag_trapping_math && HONOR_NANS (GET_MODE (XEXP (x, 0))))
|
return 1;
|
return 1;
|
break;
|
break;
|
|
|
case NEG:
|
case NEG:
|
case ABS:
|
case ABS:
|
case SUBREG:
|
case SUBREG:
|
/* These operations don't trap even with floating point. */
|
/* These operations don't trap even with floating point. */
|
break;
|
break;
|
|
|
default:
|
default:
|
/* Any floating arithmetic may trap. */
|
/* Any floating arithmetic may trap. */
|
if (SCALAR_FLOAT_MODE_P (GET_MODE (x))
|
if (SCALAR_FLOAT_MODE_P (GET_MODE (x))
|
&& flag_trapping_math)
|
&& flag_trapping_math)
|
return 1;
|
return 1;
|
}
|
}
|
|
|
fmt = GET_RTX_FORMAT (code);
|
fmt = GET_RTX_FORMAT (code);
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
{
|
{
|
if (fmt[i] == 'e')
|
if (fmt[i] == 'e')
|
{
|
{
|
if (may_trap_p_1 (XEXP (x, i), flags))
|
if (may_trap_p_1 (XEXP (x, i), flags))
|
return 1;
|
return 1;
|
}
|
}
|
else if (fmt[i] == 'E')
|
else if (fmt[i] == 'E')
|
{
|
{
|
int j;
|
int j;
|
for (j = 0; j < XVECLEN (x, i); j++)
|
for (j = 0; j < XVECLEN (x, i); j++)
|
if (may_trap_p_1 (XVECEXP (x, i, j), flags))
|
if (may_trap_p_1 (XVECEXP (x, i, j), flags))
|
return 1;
|
return 1;
|
}
|
}
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return nonzero if evaluating rtx X might cause a trap. */
|
/* Return nonzero if evaluating rtx X might cause a trap. */
|
|
|
int
|
int
|
may_trap_p (rtx x)
|
may_trap_p (rtx x)
|
{
|
{
|
return may_trap_p_1 (x, 0);
|
return may_trap_p_1 (x, 0);
|
}
|
}
|
|
|
/* Return nonzero if evaluating rtx X might cause a trap, when the expression
|
/* Return nonzero if evaluating rtx X might cause a trap, when the expression
|
is moved from its current location by some optimization. */
|
is moved from its current location by some optimization. */
|
|
|
int
|
int
|
may_trap_after_code_motion_p (rtx x)
|
may_trap_after_code_motion_p (rtx x)
|
{
|
{
|
return may_trap_p_1 (x, MTP_AFTER_MOVE);
|
return may_trap_p_1 (x, MTP_AFTER_MOVE);
|
}
|
}
|
|
|
/* Same as above, but additionally return nonzero if evaluating rtx X might
|
/* Same as above, but additionally return nonzero if evaluating rtx X might
|
cause a fault. We define a fault for the purpose of this function as a
|
cause a fault. We define a fault for the purpose of this function as a
|
erroneous execution condition that cannot be encountered during the normal
|
erroneous execution condition that cannot be encountered during the normal
|
execution of a valid program; the typical example is an unaligned memory
|
execution of a valid program; the typical example is an unaligned memory
|
access on a strict alignment machine. The compiler guarantees that it
|
access on a strict alignment machine. The compiler guarantees that it
|
doesn't generate code that will fault from a valid program, but this
|
doesn't generate code that will fault from a valid program, but this
|
guarantee doesn't mean anything for individual instructions. Consider
|
guarantee doesn't mean anything for individual instructions. Consider
|
the following example:
|
the following example:
|
|
|
struct S { int d; union { char *cp; int *ip; }; };
|
struct S { int d; union { char *cp; int *ip; }; };
|
|
|
int foo(struct S *s)
|
int foo(struct S *s)
|
{
|
{
|
if (s->d == 1)
|
if (s->d == 1)
|
return *s->ip;
|
return *s->ip;
|
else
|
else
|
return *s->cp;
|
return *s->cp;
|
}
|
}
|
|
|
on a strict alignment machine. In a valid program, foo will never be
|
on a strict alignment machine. In a valid program, foo will never be
|
invoked on a structure for which d is equal to 1 and the underlying
|
invoked on a structure for which d is equal to 1 and the underlying
|
unique field of the union not aligned on a 4-byte boundary, but the
|
unique field of the union not aligned on a 4-byte boundary, but the
|
expression *s->ip might cause a fault if considered individually.
|
expression *s->ip might cause a fault if considered individually.
|
|
|
At the RTL level, potentially problematic expressions will almost always
|
At the RTL level, potentially problematic expressions will almost always
|
verify may_trap_p; for example, the above dereference can be emitted as
|
verify may_trap_p; for example, the above dereference can be emitted as
|
(mem:SI (reg:P)) and this expression is may_trap_p for a generic register.
|
(mem:SI (reg:P)) and this expression is may_trap_p for a generic register.
|
However, suppose that foo is inlined in a caller that causes s->cp to
|
However, suppose that foo is inlined in a caller that causes s->cp to
|
point to a local character variable and guarantees that s->d is not set
|
point to a local character variable and guarantees that s->d is not set
|
to 1; foo may have been effectively translated into pseudo-RTL as:
|
to 1; foo may have been effectively translated into pseudo-RTL as:
|
|
|
if ((reg:SI) == 1)
|
if ((reg:SI) == 1)
|
(set (reg:SI) (mem:SI (%fp - 7)))
|
(set (reg:SI) (mem:SI (%fp - 7)))
|
else
|
else
|
(set (reg:QI) (mem:QI (%fp - 7)))
|
(set (reg:QI) (mem:QI (%fp - 7)))
|
|
|
Now (mem:SI (%fp - 7)) is considered as not may_trap_p since it is a
|
Now (mem:SI (%fp - 7)) is considered as not may_trap_p since it is a
|
memory reference to a stack slot, but it will certainly cause a fault
|
memory reference to a stack slot, but it will certainly cause a fault
|
on a strict alignment machine. */
|
on a strict alignment machine. */
|
|
|
int
|
int
|
may_trap_or_fault_p (rtx x)
|
may_trap_or_fault_p (rtx x)
|
{
|
{
|
return may_trap_p_1 (x, MTP_UNALIGNED_MEMS);
|
return may_trap_p_1 (x, MTP_UNALIGNED_MEMS);
|
}
|
}
|
|
|
/* Return nonzero if X contains a comparison that is not either EQ or NE,
|
/* Return nonzero if X contains a comparison that is not either EQ or NE,
|
i.e., an inequality. */
|
i.e., an inequality. */
|
|
|
int
|
int
|
inequality_comparisons_p (rtx x)
|
inequality_comparisons_p (rtx x)
|
{
|
{
|
const char *fmt;
|
const char *fmt;
|
int len, i;
|
int len, i;
|
enum rtx_code code = GET_CODE (x);
|
enum rtx_code code = GET_CODE (x);
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case REG:
|
case REG:
|
case SCRATCH:
|
case SCRATCH:
|
case PC:
|
case PC:
|
case CC0:
|
case CC0:
|
case CONST_INT:
|
case CONST_INT:
|
case CONST_DOUBLE:
|
case CONST_DOUBLE:
|
case CONST_VECTOR:
|
case CONST_VECTOR:
|
case CONST:
|
case CONST:
|
case LABEL_REF:
|
case LABEL_REF:
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
return 0;
|
return 0;
|
|
|
case LT:
|
case LT:
|
case LTU:
|
case LTU:
|
case GT:
|
case GT:
|
case GTU:
|
case GTU:
|
case LE:
|
case LE:
|
case LEU:
|
case LEU:
|
case GE:
|
case GE:
|
case GEU:
|
case GEU:
|
return 1;
|
return 1;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
len = GET_RTX_LENGTH (code);
|
len = GET_RTX_LENGTH (code);
|
fmt = GET_RTX_FORMAT (code);
|
fmt = GET_RTX_FORMAT (code);
|
|
|
for (i = 0; i < len; i++)
|
for (i = 0; i < len; i++)
|
{
|
{
|
if (fmt[i] == 'e')
|
if (fmt[i] == 'e')
|
{
|
{
|
if (inequality_comparisons_p (XEXP (x, i)))
|
if (inequality_comparisons_p (XEXP (x, i)))
|
return 1;
|
return 1;
|
}
|
}
|
else if (fmt[i] == 'E')
|
else if (fmt[i] == 'E')
|
{
|
{
|
int j;
|
int j;
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
if (inequality_comparisons_p (XVECEXP (x, i, j)))
|
if (inequality_comparisons_p (XVECEXP (x, i, j)))
|
return 1;
|
return 1;
|
}
|
}
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Replace any occurrence of FROM in X with TO. The function does
|
/* Replace any occurrence of FROM in X with TO. The function does
|
not enter into CONST_DOUBLE for the replace.
|
not enter into CONST_DOUBLE for the replace.
|
|
|
Note that copying is not done so X must not be shared unless all copies
|
Note that copying is not done so X must not be shared unless all copies
|
are to be modified. */
|
are to be modified. */
|
|
|
rtx
|
rtx
|
replace_rtx (rtx x, rtx from, rtx to)
|
replace_rtx (rtx x, rtx from, rtx to)
|
{
|
{
|
int i, j;
|
int i, j;
|
const char *fmt;
|
const char *fmt;
|
|
|
/* The following prevents loops occurrence when we change MEM in
|
/* The following prevents loops occurrence when we change MEM in
|
CONST_DOUBLE onto the same CONST_DOUBLE. */
|
CONST_DOUBLE onto the same CONST_DOUBLE. */
|
if (x != 0 && GET_CODE (x) == CONST_DOUBLE)
|
if (x != 0 && GET_CODE (x) == CONST_DOUBLE)
|
return x;
|
return x;
|
|
|
if (x == from)
|
if (x == from)
|
return to;
|
return to;
|
|
|
/* Allow this function to make replacements in EXPR_LISTs. */
|
/* Allow this function to make replacements in EXPR_LISTs. */
|
if (x == 0)
|
if (x == 0)
|
return 0;
|
return 0;
|
|
|
if (GET_CODE (x) == SUBREG)
|
if (GET_CODE (x) == SUBREG)
|
{
|
{
|
rtx new = replace_rtx (SUBREG_REG (x), from, to);
|
rtx new = replace_rtx (SUBREG_REG (x), from, to);
|
|
|
if (GET_CODE (new) == CONST_INT)
|
if (GET_CODE (new) == CONST_INT)
|
{
|
{
|
x = simplify_subreg (GET_MODE (x), new,
|
x = simplify_subreg (GET_MODE (x), new,
|
GET_MODE (SUBREG_REG (x)),
|
GET_MODE (SUBREG_REG (x)),
|
SUBREG_BYTE (x));
|
SUBREG_BYTE (x));
|
gcc_assert (x);
|
gcc_assert (x);
|
}
|
}
|
else
|
else
|
SUBREG_REG (x) = new;
|
SUBREG_REG (x) = new;
|
|
|
return x;
|
return x;
|
}
|
}
|
else if (GET_CODE (x) == ZERO_EXTEND)
|
else if (GET_CODE (x) == ZERO_EXTEND)
|
{
|
{
|
rtx new = replace_rtx (XEXP (x, 0), from, to);
|
rtx new = replace_rtx (XEXP (x, 0), from, to);
|
|
|
if (GET_CODE (new) == CONST_INT)
|
if (GET_CODE (new) == CONST_INT)
|
{
|
{
|
x = simplify_unary_operation (ZERO_EXTEND, GET_MODE (x),
|
x = simplify_unary_operation (ZERO_EXTEND, GET_MODE (x),
|
new, GET_MODE (XEXP (x, 0)));
|
new, GET_MODE (XEXP (x, 0)));
|
gcc_assert (x);
|
gcc_assert (x);
|
}
|
}
|
else
|
else
|
XEXP (x, 0) = new;
|
XEXP (x, 0) = new;
|
|
|
return x;
|
return x;
|
}
|
}
|
|
|
fmt = GET_RTX_FORMAT (GET_CODE (x));
|
fmt = GET_RTX_FORMAT (GET_CODE (x));
|
for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
|
{
|
{
|
if (fmt[i] == 'e')
|
if (fmt[i] == 'e')
|
XEXP (x, i) = replace_rtx (XEXP (x, i), from, to);
|
XEXP (x, i) = replace_rtx (XEXP (x, i), from, to);
|
else if (fmt[i] == 'E')
|
else if (fmt[i] == 'E')
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
XVECEXP (x, i, j) = replace_rtx (XVECEXP (x, i, j), from, to);
|
XVECEXP (x, i, j) = replace_rtx (XVECEXP (x, i, j), from, to);
|
}
|
}
|
|
|
return x;
|
return x;
|
}
|
}
|
|
|
/* Replace occurrences of the old label in *X with the new one.
|
/* Replace occurrences of the old label in *X with the new one.
|
DATA is a REPLACE_LABEL_DATA containing the old and new labels. */
|
DATA is a REPLACE_LABEL_DATA containing the old and new labels. */
|
|
|
int
|
int
|
replace_label (rtx *x, void *data)
|
replace_label (rtx *x, void *data)
|
{
|
{
|
rtx l = *x;
|
rtx l = *x;
|
rtx old_label = ((replace_label_data *) data)->r1;
|
rtx old_label = ((replace_label_data *) data)->r1;
|
rtx new_label = ((replace_label_data *) data)->r2;
|
rtx new_label = ((replace_label_data *) data)->r2;
|
bool update_label_nuses = ((replace_label_data *) data)->update_label_nuses;
|
bool update_label_nuses = ((replace_label_data *) data)->update_label_nuses;
|
|
|
if (l == NULL_RTX)
|
if (l == NULL_RTX)
|
return 0;
|
return 0;
|
|
|
if (GET_CODE (l) == SYMBOL_REF
|
if (GET_CODE (l) == SYMBOL_REF
|
&& CONSTANT_POOL_ADDRESS_P (l))
|
&& CONSTANT_POOL_ADDRESS_P (l))
|
{
|
{
|
rtx c = get_pool_constant (l);
|
rtx c = get_pool_constant (l);
|
if (rtx_referenced_p (old_label, c))
|
if (rtx_referenced_p (old_label, c))
|
{
|
{
|
rtx new_c, new_l;
|
rtx new_c, new_l;
|
replace_label_data *d = (replace_label_data *) data;
|
replace_label_data *d = (replace_label_data *) data;
|
|
|
/* Create a copy of constant C; replace the label inside
|
/* Create a copy of constant C; replace the label inside
|
but do not update LABEL_NUSES because uses in constant pool
|
but do not update LABEL_NUSES because uses in constant pool
|
are not counted. */
|
are not counted. */
|
new_c = copy_rtx (c);
|
new_c = copy_rtx (c);
|
d->update_label_nuses = false;
|
d->update_label_nuses = false;
|
for_each_rtx (&new_c, replace_label, data);
|
for_each_rtx (&new_c, replace_label, data);
|
d->update_label_nuses = update_label_nuses;
|
d->update_label_nuses = update_label_nuses;
|
|
|
/* Add the new constant NEW_C to constant pool and replace
|
/* Add the new constant NEW_C to constant pool and replace
|
the old reference to constant by new reference. */
|
the old reference to constant by new reference. */
|
new_l = XEXP (force_const_mem (get_pool_mode (l), new_c), 0);
|
new_l = XEXP (force_const_mem (get_pool_mode (l), new_c), 0);
|
*x = replace_rtx (l, l, new_l);
|
*x = replace_rtx (l, l, new_l);
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* If this is a JUMP_INSN, then we also need to fix the JUMP_LABEL
|
/* If this is a JUMP_INSN, then we also need to fix the JUMP_LABEL
|
field. This is not handled by for_each_rtx because it doesn't
|
field. This is not handled by for_each_rtx because it doesn't
|
handle unprinted ('0') fields. */
|
handle unprinted ('0') fields. */
|
if (JUMP_P (l) && JUMP_LABEL (l) == old_label)
|
if (JUMP_P (l) && JUMP_LABEL (l) == old_label)
|
JUMP_LABEL (l) = new_label;
|
JUMP_LABEL (l) = new_label;
|
|
|
if ((GET_CODE (l) == LABEL_REF
|
if ((GET_CODE (l) == LABEL_REF
|
|| GET_CODE (l) == INSN_LIST)
|
|| GET_CODE (l) == INSN_LIST)
|
&& XEXP (l, 0) == old_label)
|
&& XEXP (l, 0) == old_label)
|
{
|
{
|
XEXP (l, 0) = new_label;
|
XEXP (l, 0) = new_label;
|
if (update_label_nuses)
|
if (update_label_nuses)
|
{
|
{
|
++LABEL_NUSES (new_label);
|
++LABEL_NUSES (new_label);
|
--LABEL_NUSES (old_label);
|
--LABEL_NUSES (old_label);
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* When *BODY is equal to X or X is directly referenced by *BODY
|
/* When *BODY is equal to X or X is directly referenced by *BODY
|
return nonzero, thus FOR_EACH_RTX stops traversing and returns nonzero
|
return nonzero, thus FOR_EACH_RTX stops traversing and returns nonzero
|
too, otherwise FOR_EACH_RTX continues traversing *BODY. */
|
too, otherwise FOR_EACH_RTX continues traversing *BODY. */
|
|
|
static int
|
static int
|
rtx_referenced_p_1 (rtx *body, void *x)
|
rtx_referenced_p_1 (rtx *body, void *x)
|
{
|
{
|
rtx y = (rtx) x;
|
rtx y = (rtx) x;
|
|
|
if (*body == NULL_RTX)
|
if (*body == NULL_RTX)
|
return y == NULL_RTX;
|
return y == NULL_RTX;
|
|
|
/* Return true if a label_ref *BODY refers to label Y. */
|
/* Return true if a label_ref *BODY refers to label Y. */
|
if (GET_CODE (*body) == LABEL_REF && LABEL_P (y))
|
if (GET_CODE (*body) == LABEL_REF && LABEL_P (y))
|
return XEXP (*body, 0) == y;
|
return XEXP (*body, 0) == y;
|
|
|
/* If *BODY is a reference to pool constant traverse the constant. */
|
/* If *BODY is a reference to pool constant traverse the constant. */
|
if (GET_CODE (*body) == SYMBOL_REF
|
if (GET_CODE (*body) == SYMBOL_REF
|
&& CONSTANT_POOL_ADDRESS_P (*body))
|
&& CONSTANT_POOL_ADDRESS_P (*body))
|
return rtx_referenced_p (y, get_pool_constant (*body));
|
return rtx_referenced_p (y, get_pool_constant (*body));
|
|
|
/* By default, compare the RTL expressions. */
|
/* By default, compare the RTL expressions. */
|
return rtx_equal_p (*body, y);
|
return rtx_equal_p (*body, y);
|
}
|
}
|
|
|
/* Return true if X is referenced in BODY. */
|
/* Return true if X is referenced in BODY. */
|
|
|
int
|
int
|
rtx_referenced_p (rtx x, rtx body)
|
rtx_referenced_p (rtx x, rtx body)
|
{
|
{
|
return for_each_rtx (&body, rtx_referenced_p_1, x);
|
return for_each_rtx (&body, rtx_referenced_p_1, x);
|
}
|
}
|
|
|
/* If INSN is a tablejump return true and store the label (before jump table) to
|
/* If INSN is a tablejump return true and store the label (before jump table) to
|
*LABELP and the jump table to *TABLEP. LABELP and TABLEP may be NULL. */
|
*LABELP and the jump table to *TABLEP. LABELP and TABLEP may be NULL. */
|
|
|
bool
|
bool
|
tablejump_p (rtx insn, rtx *labelp, rtx *tablep)
|
tablejump_p (rtx insn, rtx *labelp, rtx *tablep)
|
{
|
{
|
rtx label, table;
|
rtx label, table;
|
|
|
if (JUMP_P (insn)
|
if (JUMP_P (insn)
|
&& (label = JUMP_LABEL (insn)) != NULL_RTX
|
&& (label = JUMP_LABEL (insn)) != NULL_RTX
|
&& (table = next_active_insn (label)) != NULL_RTX
|
&& (table = next_active_insn (label)) != NULL_RTX
|
&& JUMP_P (table)
|
&& JUMP_P (table)
|
&& (GET_CODE (PATTERN (table)) == ADDR_VEC
|
&& (GET_CODE (PATTERN (table)) == ADDR_VEC
|
|| GET_CODE (PATTERN (table)) == ADDR_DIFF_VEC))
|
|| GET_CODE (PATTERN (table)) == ADDR_DIFF_VEC))
|
{
|
{
|
if (labelp)
|
if (labelp)
|
*labelp = label;
|
*labelp = label;
|
if (tablep)
|
if (tablep)
|
*tablep = table;
|
*tablep = table;
|
return true;
|
return true;
|
}
|
}
|
return false;
|
return false;
|
}
|
}
|
|
|
/* A subroutine of computed_jump_p, return 1 if X contains a REG or MEM or
|
/* A subroutine of computed_jump_p, return 1 if X contains a REG or MEM or
|
constant that is not in the constant pool and not in the condition
|
constant that is not in the constant pool and not in the condition
|
of an IF_THEN_ELSE. */
|
of an IF_THEN_ELSE. */
|
|
|
static int
|
static int
|
computed_jump_p_1 (rtx x)
|
computed_jump_p_1 (rtx x)
|
{
|
{
|
enum rtx_code code = GET_CODE (x);
|
enum rtx_code code = GET_CODE (x);
|
int i, j;
|
int i, j;
|
const char *fmt;
|
const char *fmt;
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case LABEL_REF:
|
case LABEL_REF:
|
case PC:
|
case PC:
|
return 0;
|
return 0;
|
|
|
case CONST:
|
case CONST:
|
case CONST_INT:
|
case CONST_INT:
|
case CONST_DOUBLE:
|
case CONST_DOUBLE:
|
case CONST_VECTOR:
|
case CONST_VECTOR:
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
case REG:
|
case REG:
|
return 1;
|
return 1;
|
|
|
case MEM:
|
case MEM:
|
return ! (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
|
return ! (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
|
&& CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)));
|
&& CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)));
|
|
|
case IF_THEN_ELSE:
|
case IF_THEN_ELSE:
|
return (computed_jump_p_1 (XEXP (x, 1))
|
return (computed_jump_p_1 (XEXP (x, 1))
|
|| computed_jump_p_1 (XEXP (x, 2)));
|
|| computed_jump_p_1 (XEXP (x, 2)));
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
fmt = GET_RTX_FORMAT (code);
|
fmt = GET_RTX_FORMAT (code);
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
{
|
{
|
if (fmt[i] == 'e'
|
if (fmt[i] == 'e'
|
&& computed_jump_p_1 (XEXP (x, i)))
|
&& computed_jump_p_1 (XEXP (x, i)))
|
return 1;
|
return 1;
|
|
|
else if (fmt[i] == 'E')
|
else if (fmt[i] == 'E')
|
for (j = 0; j < XVECLEN (x, i); j++)
|
for (j = 0; j < XVECLEN (x, i); j++)
|
if (computed_jump_p_1 (XVECEXP (x, i, j)))
|
if (computed_jump_p_1 (XVECEXP (x, i, j)))
|
return 1;
|
return 1;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return nonzero if INSN is an indirect jump (aka computed jump).
|
/* Return nonzero if INSN is an indirect jump (aka computed jump).
|
|
|
Tablejumps and casesi insns are not considered indirect jumps;
|
Tablejumps and casesi insns are not considered indirect jumps;
|
we can recognize them by a (use (label_ref)). */
|
we can recognize them by a (use (label_ref)). */
|
|
|
int
|
int
|
computed_jump_p (rtx insn)
|
computed_jump_p (rtx insn)
|
{
|
{
|
int i;
|
int i;
|
if (JUMP_P (insn))
|
if (JUMP_P (insn))
|
{
|
{
|
rtx pat = PATTERN (insn);
|
rtx pat = PATTERN (insn);
|
|
|
if (find_reg_note (insn, REG_LABEL, NULL_RTX))
|
if (find_reg_note (insn, REG_LABEL, NULL_RTX))
|
return 0;
|
return 0;
|
else if (GET_CODE (pat) == PARALLEL)
|
else if (GET_CODE (pat) == PARALLEL)
|
{
|
{
|
int len = XVECLEN (pat, 0);
|
int len = XVECLEN (pat, 0);
|
int has_use_labelref = 0;
|
int has_use_labelref = 0;
|
|
|
for (i = len - 1; i >= 0; i--)
|
for (i = len - 1; i >= 0; i--)
|
if (GET_CODE (XVECEXP (pat, 0, i)) == USE
|
if (GET_CODE (XVECEXP (pat, 0, i)) == USE
|
&& (GET_CODE (XEXP (XVECEXP (pat, 0, i), 0))
|
&& (GET_CODE (XEXP (XVECEXP (pat, 0, i), 0))
|
== LABEL_REF))
|
== LABEL_REF))
|
has_use_labelref = 1;
|
has_use_labelref = 1;
|
|
|
if (! has_use_labelref)
|
if (! has_use_labelref)
|
for (i = len - 1; i >= 0; i--)
|
for (i = len - 1; i >= 0; i--)
|
if (GET_CODE (XVECEXP (pat, 0, i)) == SET
|
if (GET_CODE (XVECEXP (pat, 0, i)) == SET
|
&& SET_DEST (XVECEXP (pat, 0, i)) == pc_rtx
|
&& SET_DEST (XVECEXP (pat, 0, i)) == pc_rtx
|
&& computed_jump_p_1 (SET_SRC (XVECEXP (pat, 0, i))))
|
&& computed_jump_p_1 (SET_SRC (XVECEXP (pat, 0, i))))
|
return 1;
|
return 1;
|
}
|
}
|
else if (GET_CODE (pat) == SET
|
else if (GET_CODE (pat) == SET
|
&& SET_DEST (pat) == pc_rtx
|
&& SET_DEST (pat) == pc_rtx
|
&& computed_jump_p_1 (SET_SRC (pat)))
|
&& computed_jump_p_1 (SET_SRC (pat)))
|
return 1;
|
return 1;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Optimized loop of for_each_rtx, trying to avoid useless recursive
|
/* Optimized loop of for_each_rtx, trying to avoid useless recursive
|
calls. Processes the subexpressions of EXP and passes them to F. */
|
calls. Processes the subexpressions of EXP and passes them to F. */
|
static int
|
static int
|
for_each_rtx_1 (rtx exp, int n, rtx_function f, void *data)
|
for_each_rtx_1 (rtx exp, int n, rtx_function f, void *data)
|
{
|
{
|
int result, i, j;
|
int result, i, j;
|
const char *format = GET_RTX_FORMAT (GET_CODE (exp));
|
const char *format = GET_RTX_FORMAT (GET_CODE (exp));
|
rtx *x;
|
rtx *x;
|
|
|
for (; format[n] != '\0'; n++)
|
for (; format[n] != '\0'; n++)
|
{
|
{
|
switch (format[n])
|
switch (format[n])
|
{
|
{
|
case 'e':
|
case 'e':
|
/* Call F on X. */
|
/* Call F on X. */
|
x = &XEXP (exp, n);
|
x = &XEXP (exp, n);
|
result = (*f) (x, data);
|
result = (*f) (x, data);
|
if (result == -1)
|
if (result == -1)
|
/* Do not traverse sub-expressions. */
|
/* Do not traverse sub-expressions. */
|
continue;
|
continue;
|
else if (result != 0)
|
else if (result != 0)
|
/* Stop the traversal. */
|
/* Stop the traversal. */
|
return result;
|
return result;
|
|
|
if (*x == NULL_RTX)
|
if (*x == NULL_RTX)
|
/* There are no sub-expressions. */
|
/* There are no sub-expressions. */
|
continue;
|
continue;
|
|
|
i = non_rtx_starting_operands[GET_CODE (*x)];
|
i = non_rtx_starting_operands[GET_CODE (*x)];
|
if (i >= 0)
|
if (i >= 0)
|
{
|
{
|
result = for_each_rtx_1 (*x, i, f, data);
|
result = for_each_rtx_1 (*x, i, f, data);
|
if (result != 0)
|
if (result != 0)
|
return result;
|
return result;
|
}
|
}
|
break;
|
break;
|
|
|
case 'V':
|
case 'V':
|
case 'E':
|
case 'E':
|
if (XVEC (exp, n) == 0)
|
if (XVEC (exp, n) == 0)
|
continue;
|
continue;
|
for (j = 0; j < XVECLEN (exp, n); ++j)
|
for (j = 0; j < XVECLEN (exp, n); ++j)
|
{
|
{
|
/* Call F on X. */
|
/* Call F on X. */
|
x = &XVECEXP (exp, n, j);
|
x = &XVECEXP (exp, n, j);
|
result = (*f) (x, data);
|
result = (*f) (x, data);
|
if (result == -1)
|
if (result == -1)
|
/* Do not traverse sub-expressions. */
|
/* Do not traverse sub-expressions. */
|
continue;
|
continue;
|
else if (result != 0)
|
else if (result != 0)
|
/* Stop the traversal. */
|
/* Stop the traversal. */
|
return result;
|
return result;
|
|
|
if (*x == NULL_RTX)
|
if (*x == NULL_RTX)
|
/* There are no sub-expressions. */
|
/* There are no sub-expressions. */
|
continue;
|
continue;
|
|
|
i = non_rtx_starting_operands[GET_CODE (*x)];
|
i = non_rtx_starting_operands[GET_CODE (*x)];
|
if (i >= 0)
|
if (i >= 0)
|
{
|
{
|
result = for_each_rtx_1 (*x, i, f, data);
|
result = for_each_rtx_1 (*x, i, f, data);
|
if (result != 0)
|
if (result != 0)
|
return result;
|
return result;
|
}
|
}
|
}
|
}
|
break;
|
break;
|
|
|
default:
|
default:
|
/* Nothing to do. */
|
/* Nothing to do. */
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Traverse X via depth-first search, calling F for each
|
/* Traverse X via depth-first search, calling F for each
|
sub-expression (including X itself). F is also passed the DATA.
|
sub-expression (including X itself). F is also passed the DATA.
|
If F returns -1, do not traverse sub-expressions, but continue
|
If F returns -1, do not traverse sub-expressions, but continue
|
traversing the rest of the tree. If F ever returns any other
|
traversing the rest of the tree. If F ever returns any other
|
nonzero value, stop the traversal, and return the value returned
|
nonzero value, stop the traversal, and return the value returned
|
by F. Otherwise, return 0. This function does not traverse inside
|
by F. Otherwise, return 0. This function does not traverse inside
|
tree structure that contains RTX_EXPRs, or into sub-expressions
|
tree structure that contains RTX_EXPRs, or into sub-expressions
|
whose format code is `0' since it is not known whether or not those
|
whose format code is `0' since it is not known whether or not those
|
codes are actually RTL.
|
codes are actually RTL.
|
|
|
This routine is very general, and could (should?) be used to
|
This routine is very general, and could (should?) be used to
|
implement many of the other routines in this file. */
|
implement many of the other routines in this file. */
|
|
|
int
|
int
|
for_each_rtx (rtx *x, rtx_function f, void *data)
|
for_each_rtx (rtx *x, rtx_function f, void *data)
|
{
|
{
|
int result;
|
int result;
|
int i;
|
int i;
|
|
|
/* Call F on X. */
|
/* Call F on X. */
|
result = (*f) (x, data);
|
result = (*f) (x, data);
|
if (result == -1)
|
if (result == -1)
|
/* Do not traverse sub-expressions. */
|
/* Do not traverse sub-expressions. */
|
return 0;
|
return 0;
|
else if (result != 0)
|
else if (result != 0)
|
/* Stop the traversal. */
|
/* Stop the traversal. */
|
return result;
|
return result;
|
|
|
if (*x == NULL_RTX)
|
if (*x == NULL_RTX)
|
/* There are no sub-expressions. */
|
/* There are no sub-expressions. */
|
return 0;
|
return 0;
|
|
|
i = non_rtx_starting_operands[GET_CODE (*x)];
|
i = non_rtx_starting_operands[GET_CODE (*x)];
|
if (i < 0)
|
if (i < 0)
|
return 0;
|
return 0;
|
|
|
return for_each_rtx_1 (*x, i, f, data);
|
return for_each_rtx_1 (*x, i, f, data);
|
}
|
}
|
|
|
|
|
/* Searches X for any reference to REGNO, returning the rtx of the
|
/* Searches X for any reference to REGNO, returning the rtx of the
|
reference found if any. Otherwise, returns NULL_RTX. */
|
reference found if any. Otherwise, returns NULL_RTX. */
|
|
|
rtx
|
rtx
|
regno_use_in (unsigned int regno, rtx x)
|
regno_use_in (unsigned int regno, rtx x)
|
{
|
{
|
const char *fmt;
|
const char *fmt;
|
int i, j;
|
int i, j;
|
rtx tem;
|
rtx tem;
|
|
|
if (REG_P (x) && REGNO (x) == regno)
|
if (REG_P (x) && REGNO (x) == regno)
|
return x;
|
return x;
|
|
|
fmt = GET_RTX_FORMAT (GET_CODE (x));
|
fmt = GET_RTX_FORMAT (GET_CODE (x));
|
for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
|
{
|
{
|
if (fmt[i] == 'e')
|
if (fmt[i] == 'e')
|
{
|
{
|
if ((tem = regno_use_in (regno, XEXP (x, i))))
|
if ((tem = regno_use_in (regno, XEXP (x, i))))
|
return tem;
|
return tem;
|
}
|
}
|
else if (fmt[i] == 'E')
|
else if (fmt[i] == 'E')
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
if ((tem = regno_use_in (regno , XVECEXP (x, i, j))))
|
if ((tem = regno_use_in (regno , XVECEXP (x, i, j))))
|
return tem;
|
return tem;
|
}
|
}
|
|
|
return NULL_RTX;
|
return NULL_RTX;
|
}
|
}
|
|
|
/* Return a value indicating whether OP, an operand of a commutative
|
/* Return a value indicating whether OP, an operand of a commutative
|
operation, is preferred as the first or second operand. The higher
|
operation, is preferred as the first or second operand. The higher
|
the value, the stronger the preference for being the first operand.
|
the value, the stronger the preference for being the first operand.
|
We use negative values to indicate a preference for the first operand
|
We use negative values to indicate a preference for the first operand
|
and positive values for the second operand. */
|
and positive values for the second operand. */
|
|
|
int
|
int
|
commutative_operand_precedence (rtx op)
|
commutative_operand_precedence (rtx op)
|
{
|
{
|
enum rtx_code code = GET_CODE (op);
|
enum rtx_code code = GET_CODE (op);
|
|
|
/* Constants always come the second operand. Prefer "nice" constants. */
|
/* Constants always come the second operand. Prefer "nice" constants. */
|
if (code == CONST_INT)
|
if (code == CONST_INT)
|
return -7;
|
return -7;
|
if (code == CONST_DOUBLE)
|
if (code == CONST_DOUBLE)
|
return -6;
|
return -6;
|
op = avoid_constant_pool_reference (op);
|
op = avoid_constant_pool_reference (op);
|
code = GET_CODE (op);
|
code = GET_CODE (op);
|
|
|
switch (GET_RTX_CLASS (code))
|
switch (GET_RTX_CLASS (code))
|
{
|
{
|
case RTX_CONST_OBJ:
|
case RTX_CONST_OBJ:
|
if (code == CONST_INT)
|
if (code == CONST_INT)
|
return -5;
|
return -5;
|
if (code == CONST_DOUBLE)
|
if (code == CONST_DOUBLE)
|
return -4;
|
return -4;
|
return -3;
|
return -3;
|
|
|
case RTX_EXTRA:
|
case RTX_EXTRA:
|
/* SUBREGs of objects should come second. */
|
/* SUBREGs of objects should come second. */
|
if (code == SUBREG && OBJECT_P (SUBREG_REG (op)))
|
if (code == SUBREG && OBJECT_P (SUBREG_REG (op)))
|
return -2;
|
return -2;
|
|
|
if (!CONSTANT_P (op))
|
if (!CONSTANT_P (op))
|
return 0;
|
return 0;
|
else
|
else
|
/* As for RTX_CONST_OBJ. */
|
/* As for RTX_CONST_OBJ. */
|
return -3;
|
return -3;
|
|
|
case RTX_OBJ:
|
case RTX_OBJ:
|
/* Complex expressions should be the first, so decrease priority
|
/* Complex expressions should be the first, so decrease priority
|
of objects. */
|
of objects. */
|
return -1;
|
return -1;
|
|
|
case RTX_COMM_ARITH:
|
case RTX_COMM_ARITH:
|
/* Prefer operands that are themselves commutative to be first.
|
/* Prefer operands that are themselves commutative to be first.
|
This helps to make things linear. In particular,
|
This helps to make things linear. In particular,
|
(and (and (reg) (reg)) (not (reg))) is canonical. */
|
(and (and (reg) (reg)) (not (reg))) is canonical. */
|
return 4;
|
return 4;
|
|
|
case RTX_BIN_ARITH:
|
case RTX_BIN_ARITH:
|
/* If only one operand is a binary expression, it will be the first
|
/* If only one operand is a binary expression, it will be the first
|
operand. In particular, (plus (minus (reg) (reg)) (neg (reg)))
|
operand. In particular, (plus (minus (reg) (reg)) (neg (reg)))
|
is canonical, although it will usually be further simplified. */
|
is canonical, although it will usually be further simplified. */
|
return 2;
|
return 2;
|
|
|
case RTX_UNARY:
|
case RTX_UNARY:
|
/* Then prefer NEG and NOT. */
|
/* Then prefer NEG and NOT. */
|
if (code == NEG || code == NOT)
|
if (code == NEG || code == NOT)
|
return 1;
|
return 1;
|
|
|
default:
|
default:
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
|
|
/* Return 1 iff it is necessary to swap operands of commutative operation
|
/* Return 1 iff it is necessary to swap operands of commutative operation
|
in order to canonicalize expression. */
|
in order to canonicalize expression. */
|
|
|
int
|
int
|
swap_commutative_operands_p (rtx x, rtx y)
|
swap_commutative_operands_p (rtx x, rtx y)
|
{
|
{
|
return (commutative_operand_precedence (x)
|
return (commutative_operand_precedence (x)
|
< commutative_operand_precedence (y));
|
< commutative_operand_precedence (y));
|
}
|
}
|
|
|
/* Return 1 if X is an autoincrement side effect and the register is
|
/* Return 1 if X is an autoincrement side effect and the register is
|
not the stack pointer. */
|
not the stack pointer. */
|
int
|
int
|
auto_inc_p (rtx x)
|
auto_inc_p (rtx x)
|
{
|
{
|
switch (GET_CODE (x))
|
switch (GET_CODE (x))
|
{
|
{
|
case PRE_INC:
|
case PRE_INC:
|
case POST_INC:
|
case POST_INC:
|
case PRE_DEC:
|
case PRE_DEC:
|
case POST_DEC:
|
case POST_DEC:
|
case PRE_MODIFY:
|
case PRE_MODIFY:
|
case POST_MODIFY:
|
case POST_MODIFY:
|
/* There are no REG_INC notes for SP. */
|
/* There are no REG_INC notes for SP. */
|
if (XEXP (x, 0) != stack_pointer_rtx)
|
if (XEXP (x, 0) != stack_pointer_rtx)
|
return 1;
|
return 1;
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return nonzero if IN contains a piece of rtl that has the address LOC. */
|
/* Return nonzero if IN contains a piece of rtl that has the address LOC. */
|
int
|
int
|
loc_mentioned_in_p (rtx *loc, rtx in)
|
loc_mentioned_in_p (rtx *loc, rtx in)
|
{
|
{
|
enum rtx_code code = GET_CODE (in);
|
enum rtx_code code = GET_CODE (in);
|
const char *fmt = GET_RTX_FORMAT (code);
|
const char *fmt = GET_RTX_FORMAT (code);
|
int i, j;
|
int i, j;
|
|
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
{
|
{
|
if (loc == &in->u.fld[i].rt_rtx)
|
if (loc == &in->u.fld[i].rt_rtx)
|
return 1;
|
return 1;
|
if (fmt[i] == 'e')
|
if (fmt[i] == 'e')
|
{
|
{
|
if (loc_mentioned_in_p (loc, XEXP (in, i)))
|
if (loc_mentioned_in_p (loc, XEXP (in, i)))
|
return 1;
|
return 1;
|
}
|
}
|
else if (fmt[i] == 'E')
|
else if (fmt[i] == 'E')
|
for (j = XVECLEN (in, i) - 1; j >= 0; j--)
|
for (j = XVECLEN (in, i) - 1; j >= 0; j--)
|
if (loc_mentioned_in_p (loc, XVECEXP (in, i, j)))
|
if (loc_mentioned_in_p (loc, XVECEXP (in, i, j)))
|
return 1;
|
return 1;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Helper function for subreg_lsb. Given a subreg's OUTER_MODE, INNER_MODE,
|
/* Helper function for subreg_lsb. Given a subreg's OUTER_MODE, INNER_MODE,
|
and SUBREG_BYTE, return the bit offset where the subreg begins
|
and SUBREG_BYTE, return the bit offset where the subreg begins
|
(counting from the least significant bit of the operand). */
|
(counting from the least significant bit of the operand). */
|
|
|
unsigned int
|
unsigned int
|
subreg_lsb_1 (enum machine_mode outer_mode,
|
subreg_lsb_1 (enum machine_mode outer_mode,
|
enum machine_mode inner_mode,
|
enum machine_mode inner_mode,
|
unsigned int subreg_byte)
|
unsigned int subreg_byte)
|
{
|
{
|
unsigned int bitpos;
|
unsigned int bitpos;
|
unsigned int byte;
|
unsigned int byte;
|
unsigned int word;
|
unsigned int word;
|
|
|
/* A paradoxical subreg begins at bit position 0. */
|
/* A paradoxical subreg begins at bit position 0. */
|
if (GET_MODE_BITSIZE (outer_mode) > GET_MODE_BITSIZE (inner_mode))
|
if (GET_MODE_BITSIZE (outer_mode) > GET_MODE_BITSIZE (inner_mode))
|
return 0;
|
return 0;
|
|
|
if (WORDS_BIG_ENDIAN != BYTES_BIG_ENDIAN)
|
if (WORDS_BIG_ENDIAN != BYTES_BIG_ENDIAN)
|
/* If the subreg crosses a word boundary ensure that
|
/* If the subreg crosses a word boundary ensure that
|
it also begins and ends on a word boundary. */
|
it also begins and ends on a word boundary. */
|
gcc_assert (!((subreg_byte % UNITS_PER_WORD
|
gcc_assert (!((subreg_byte % UNITS_PER_WORD
|
+ GET_MODE_SIZE (outer_mode)) > UNITS_PER_WORD
|
+ GET_MODE_SIZE (outer_mode)) > UNITS_PER_WORD
|
&& (subreg_byte % UNITS_PER_WORD
|
&& (subreg_byte % UNITS_PER_WORD
|
|| GET_MODE_SIZE (outer_mode) % UNITS_PER_WORD)));
|
|| GET_MODE_SIZE (outer_mode) % UNITS_PER_WORD)));
|
|
|
if (WORDS_BIG_ENDIAN)
|
if (WORDS_BIG_ENDIAN)
|
word = (GET_MODE_SIZE (inner_mode)
|
word = (GET_MODE_SIZE (inner_mode)
|
- (subreg_byte + GET_MODE_SIZE (outer_mode))) / UNITS_PER_WORD;
|
- (subreg_byte + GET_MODE_SIZE (outer_mode))) / UNITS_PER_WORD;
|
else
|
else
|
word = subreg_byte / UNITS_PER_WORD;
|
word = subreg_byte / UNITS_PER_WORD;
|
bitpos = word * BITS_PER_WORD;
|
bitpos = word * BITS_PER_WORD;
|
|
|
if (BYTES_BIG_ENDIAN)
|
if (BYTES_BIG_ENDIAN)
|
byte = (GET_MODE_SIZE (inner_mode)
|
byte = (GET_MODE_SIZE (inner_mode)
|
- (subreg_byte + GET_MODE_SIZE (outer_mode))) % UNITS_PER_WORD;
|
- (subreg_byte + GET_MODE_SIZE (outer_mode))) % UNITS_PER_WORD;
|
else
|
else
|
byte = subreg_byte % UNITS_PER_WORD;
|
byte = subreg_byte % UNITS_PER_WORD;
|
bitpos += byte * BITS_PER_UNIT;
|
bitpos += byte * BITS_PER_UNIT;
|
|
|
return bitpos;
|
return bitpos;
|
}
|
}
|
|
|
/* Given a subreg X, return the bit offset where the subreg begins
|
/* Given a subreg X, return the bit offset where the subreg begins
|
(counting from the least significant bit of the reg). */
|
(counting from the least significant bit of the reg). */
|
|
|
unsigned int
|
unsigned int
|
subreg_lsb (rtx x)
|
subreg_lsb (rtx x)
|
{
|
{
|
return subreg_lsb_1 (GET_MODE (x), GET_MODE (SUBREG_REG (x)),
|
return subreg_lsb_1 (GET_MODE (x), GET_MODE (SUBREG_REG (x)),
|
SUBREG_BYTE (x));
|
SUBREG_BYTE (x));
|
}
|
}
|
|
|
/* This function returns the regno offset of a subreg expression.
|
/* This function returns the regno offset of a subreg expression.
|
xregno - A regno of an inner hard subreg_reg (or what will become one).
|
xregno - A regno of an inner hard subreg_reg (or what will become one).
|
xmode - The mode of xregno.
|
xmode - The mode of xregno.
|
offset - The byte offset.
|
offset - The byte offset.
|
ymode - The mode of a top level SUBREG (or what may become one).
|
ymode - The mode of a top level SUBREG (or what may become one).
|
RETURN - The regno offset which would be used. */
|
RETURN - The regno offset which would be used. */
|
unsigned int
|
unsigned int
|
subreg_regno_offset (unsigned int xregno, enum machine_mode xmode,
|
subreg_regno_offset (unsigned int xregno, enum machine_mode xmode,
|
unsigned int offset, enum machine_mode ymode)
|
unsigned int offset, enum machine_mode ymode)
|
{
|
{
|
int nregs_xmode, nregs_ymode;
|
int nregs_xmode, nregs_ymode;
|
int mode_multiple, nregs_multiple;
|
int mode_multiple, nregs_multiple;
|
int y_offset;
|
int y_offset;
|
|
|
gcc_assert (xregno < FIRST_PSEUDO_REGISTER);
|
gcc_assert (xregno < FIRST_PSEUDO_REGISTER);
|
|
|
/* Adjust nregs_xmode to allow for 'holes'. */
|
/* Adjust nregs_xmode to allow for 'holes'. */
|
if (HARD_REGNO_NREGS_HAS_PADDING (xregno, xmode))
|
if (HARD_REGNO_NREGS_HAS_PADDING (xregno, xmode))
|
nregs_xmode = HARD_REGNO_NREGS_WITH_PADDING (xregno, xmode);
|
nregs_xmode = HARD_REGNO_NREGS_WITH_PADDING (xregno, xmode);
|
else
|
else
|
nregs_xmode = hard_regno_nregs[xregno][xmode];
|
nregs_xmode = hard_regno_nregs[xregno][xmode];
|
|
|
nregs_ymode = hard_regno_nregs[xregno][ymode];
|
nregs_ymode = hard_regno_nregs[xregno][ymode];
|
|
|
/* If this is a big endian paradoxical subreg, which uses more actual
|
/* If this is a big endian paradoxical subreg, which uses more actual
|
hard registers than the original register, we must return a negative
|
hard registers than the original register, we must return a negative
|
offset so that we find the proper highpart of the register. */
|
offset so that we find the proper highpart of the register. */
|
if (offset == 0
|
if (offset == 0
|
&& nregs_ymode > nregs_xmode
|
&& nregs_ymode > nregs_xmode
|
&& (GET_MODE_SIZE (ymode) > UNITS_PER_WORD
|
&& (GET_MODE_SIZE (ymode) > UNITS_PER_WORD
|
? WORDS_BIG_ENDIAN : BYTES_BIG_ENDIAN))
|
? WORDS_BIG_ENDIAN : BYTES_BIG_ENDIAN))
|
return nregs_xmode - nregs_ymode;
|
return nregs_xmode - nregs_ymode;
|
|
|
if (offset == 0 || nregs_xmode == nregs_ymode)
|
if (offset == 0 || nregs_xmode == nregs_ymode)
|
return 0;
|
return 0;
|
|
|
/* Size of ymode must not be greater than the size of xmode. */
|
/* Size of ymode must not be greater than the size of xmode. */
|
mode_multiple = GET_MODE_SIZE (xmode) / GET_MODE_SIZE (ymode);
|
mode_multiple = GET_MODE_SIZE (xmode) / GET_MODE_SIZE (ymode);
|
gcc_assert (mode_multiple != 0);
|
gcc_assert (mode_multiple != 0);
|
|
|
y_offset = offset / GET_MODE_SIZE (ymode);
|
y_offset = offset / GET_MODE_SIZE (ymode);
|
nregs_multiple = nregs_xmode / nregs_ymode;
|
nregs_multiple = nregs_xmode / nregs_ymode;
|
return (y_offset / (mode_multiple / nregs_multiple)) * nregs_ymode;
|
return (y_offset / (mode_multiple / nregs_multiple)) * nregs_ymode;
|
}
|
}
|
|
|
/* This function returns true when the offset is representable via
|
/* This function returns true when the offset is representable via
|
subreg_offset in the given regno.
|
subreg_offset in the given regno.
|
xregno - A regno of an inner hard subreg_reg (or what will become one).
|
xregno - A regno of an inner hard subreg_reg (or what will become one).
|
xmode - The mode of xregno.
|
xmode - The mode of xregno.
|
offset - The byte offset.
|
offset - The byte offset.
|
ymode - The mode of a top level SUBREG (or what may become one).
|
ymode - The mode of a top level SUBREG (or what may become one).
|
RETURN - Whether the offset is representable. */
|
RETURN - Whether the offset is representable. */
|
bool
|
bool
|
subreg_offset_representable_p (unsigned int xregno, enum machine_mode xmode,
|
subreg_offset_representable_p (unsigned int xregno, enum machine_mode xmode,
|
unsigned int offset, enum machine_mode ymode)
|
unsigned int offset, enum machine_mode ymode)
|
{
|
{
|
int nregs_xmode, nregs_ymode;
|
int nregs_xmode, nregs_ymode;
|
int mode_multiple, nregs_multiple;
|
int mode_multiple, nregs_multiple;
|
int y_offset;
|
int y_offset;
|
int regsize_xmode, regsize_ymode;
|
int regsize_xmode, regsize_ymode;
|
|
|
gcc_assert (xregno < FIRST_PSEUDO_REGISTER);
|
gcc_assert (xregno < FIRST_PSEUDO_REGISTER);
|
|
|
/* If there are holes in a non-scalar mode in registers, we expect
|
/* If there are holes in a non-scalar mode in registers, we expect
|
that it is made up of its units concatenated together. */
|
that it is made up of its units concatenated together. */
|
if (HARD_REGNO_NREGS_HAS_PADDING (xregno, xmode))
|
if (HARD_REGNO_NREGS_HAS_PADDING (xregno, xmode))
|
{
|
{
|
enum machine_mode xmode_unit;
|
enum machine_mode xmode_unit;
|
|
|
nregs_xmode = HARD_REGNO_NREGS_WITH_PADDING (xregno, xmode);
|
nregs_xmode = HARD_REGNO_NREGS_WITH_PADDING (xregno, xmode);
|
if (GET_MODE_INNER (xmode) == VOIDmode)
|
if (GET_MODE_INNER (xmode) == VOIDmode)
|
xmode_unit = xmode;
|
xmode_unit = xmode;
|
else
|
else
|
xmode_unit = GET_MODE_INNER (xmode);
|
xmode_unit = GET_MODE_INNER (xmode);
|
gcc_assert (HARD_REGNO_NREGS_HAS_PADDING (xregno, xmode_unit));
|
gcc_assert (HARD_REGNO_NREGS_HAS_PADDING (xregno, xmode_unit));
|
gcc_assert (nregs_xmode
|
gcc_assert (nregs_xmode
|
== (GET_MODE_NUNITS (xmode)
|
== (GET_MODE_NUNITS (xmode)
|
* HARD_REGNO_NREGS_WITH_PADDING (xregno, xmode_unit)));
|
* HARD_REGNO_NREGS_WITH_PADDING (xregno, xmode_unit)));
|
gcc_assert (hard_regno_nregs[xregno][xmode]
|
gcc_assert (hard_regno_nregs[xregno][xmode]
|
== (hard_regno_nregs[xregno][xmode_unit]
|
== (hard_regno_nregs[xregno][xmode_unit]
|
* GET_MODE_NUNITS (xmode)));
|
* GET_MODE_NUNITS (xmode)));
|
|
|
/* You can only ask for a SUBREG of a value with holes in the middle
|
/* You can only ask for a SUBREG of a value with holes in the middle
|
if you don't cross the holes. (Such a SUBREG should be done by
|
if you don't cross the holes. (Such a SUBREG should be done by
|
picking a different register class, or doing it in memory if
|
picking a different register class, or doing it in memory if
|
necessary.) An example of a value with holes is XCmode on 32-bit
|
necessary.) An example of a value with holes is XCmode on 32-bit
|
x86 with -m128bit-long-double; it's represented in 6 32-bit registers,
|
x86 with -m128bit-long-double; it's represented in 6 32-bit registers,
|
3 for each part, but in memory it's two 128-bit parts.
|
3 for each part, but in memory it's two 128-bit parts.
|
Padding is assumed to be at the end (not necessarily the 'high part')
|
Padding is assumed to be at the end (not necessarily the 'high part')
|
of each unit. */
|
of each unit. */
|
if ((offset / GET_MODE_SIZE (xmode_unit) + 1
|
if ((offset / GET_MODE_SIZE (xmode_unit) + 1
|
< GET_MODE_NUNITS (xmode))
|
< GET_MODE_NUNITS (xmode))
|
&& (offset / GET_MODE_SIZE (xmode_unit)
|
&& (offset / GET_MODE_SIZE (xmode_unit)
|
!= ((offset + GET_MODE_SIZE (ymode) - 1)
|
!= ((offset + GET_MODE_SIZE (ymode) - 1)
|
/ GET_MODE_SIZE (xmode_unit))))
|
/ GET_MODE_SIZE (xmode_unit))))
|
return false;
|
return false;
|
}
|
}
|
else
|
else
|
nregs_xmode = hard_regno_nregs[xregno][xmode];
|
nregs_xmode = hard_regno_nregs[xregno][xmode];
|
|
|
nregs_ymode = hard_regno_nregs[xregno][ymode];
|
nregs_ymode = hard_regno_nregs[xregno][ymode];
|
|
|
/* Paradoxical subregs are otherwise valid. */
|
/* Paradoxical subregs are otherwise valid. */
|
if (offset == 0
|
if (offset == 0
|
&& nregs_ymode > nregs_xmode
|
&& nregs_ymode > nregs_xmode
|
&& (GET_MODE_SIZE (ymode) > UNITS_PER_WORD
|
&& (GET_MODE_SIZE (ymode) > UNITS_PER_WORD
|
? WORDS_BIG_ENDIAN : BYTES_BIG_ENDIAN))
|
? WORDS_BIG_ENDIAN : BYTES_BIG_ENDIAN))
|
return true;
|
return true;
|
|
|
/* If registers store different numbers of bits in the different
|
/* If registers store different numbers of bits in the different
|
modes, we cannot generally form this subreg. */
|
modes, we cannot generally form this subreg. */
|
regsize_xmode = GET_MODE_SIZE (xmode) / nregs_xmode;
|
regsize_xmode = GET_MODE_SIZE (xmode) / nregs_xmode;
|
regsize_ymode = GET_MODE_SIZE (ymode) / nregs_ymode;
|
regsize_ymode = GET_MODE_SIZE (ymode) / nregs_ymode;
|
if (regsize_xmode > regsize_ymode && nregs_ymode > 1)
|
if (regsize_xmode > regsize_ymode && nregs_ymode > 1)
|
return false;
|
return false;
|
if (regsize_ymode > regsize_xmode && nregs_xmode > 1)
|
if (regsize_ymode > regsize_xmode && nregs_xmode > 1)
|
return false;
|
return false;
|
|
|
/* Lowpart subregs are otherwise valid. */
|
/* Lowpart subregs are otherwise valid. */
|
if (offset == subreg_lowpart_offset (ymode, xmode))
|
if (offset == subreg_lowpart_offset (ymode, xmode))
|
return true;
|
return true;
|
|
|
/* This should always pass, otherwise we don't know how to verify
|
/* This should always pass, otherwise we don't know how to verify
|
the constraint. These conditions may be relaxed but
|
the constraint. These conditions may be relaxed but
|
subreg_regno_offset would need to be redesigned. */
|
subreg_regno_offset would need to be redesigned. */
|
gcc_assert ((GET_MODE_SIZE (xmode) % GET_MODE_SIZE (ymode)) == 0);
|
gcc_assert ((GET_MODE_SIZE (xmode) % GET_MODE_SIZE (ymode)) == 0);
|
gcc_assert ((nregs_xmode % nregs_ymode) == 0);
|
gcc_assert ((nregs_xmode % nregs_ymode) == 0);
|
|
|
/* The XMODE value can be seen as a vector of NREGS_XMODE
|
/* The XMODE value can be seen as a vector of NREGS_XMODE
|
values. The subreg must represent a lowpart of given field.
|
values. The subreg must represent a lowpart of given field.
|
Compute what field it is. */
|
Compute what field it is. */
|
offset -= subreg_lowpart_offset (ymode,
|
offset -= subreg_lowpart_offset (ymode,
|
mode_for_size (GET_MODE_BITSIZE (xmode)
|
mode_for_size (GET_MODE_BITSIZE (xmode)
|
/ nregs_xmode,
|
/ nregs_xmode,
|
MODE_INT, 0));
|
MODE_INT, 0));
|
|
|
/* Size of ymode must not be greater than the size of xmode. */
|
/* Size of ymode must not be greater than the size of xmode. */
|
mode_multiple = GET_MODE_SIZE (xmode) / GET_MODE_SIZE (ymode);
|
mode_multiple = GET_MODE_SIZE (xmode) / GET_MODE_SIZE (ymode);
|
gcc_assert (mode_multiple != 0);
|
gcc_assert (mode_multiple != 0);
|
|
|
y_offset = offset / GET_MODE_SIZE (ymode);
|
y_offset = offset / GET_MODE_SIZE (ymode);
|
nregs_multiple = nregs_xmode / nregs_ymode;
|
nregs_multiple = nregs_xmode / nregs_ymode;
|
|
|
gcc_assert ((offset % GET_MODE_SIZE (ymode)) == 0);
|
gcc_assert ((offset % GET_MODE_SIZE (ymode)) == 0);
|
gcc_assert ((mode_multiple % nregs_multiple) == 0);
|
gcc_assert ((mode_multiple % nregs_multiple) == 0);
|
|
|
return (!(y_offset % (mode_multiple / nregs_multiple)));
|
return (!(y_offset % (mode_multiple / nregs_multiple)));
|
}
|
}
|
|
|
/* Return the final regno that a subreg expression refers to. */
|
/* Return the final regno that a subreg expression refers to. */
|
unsigned int
|
unsigned int
|
subreg_regno (rtx x)
|
subreg_regno (rtx x)
|
{
|
{
|
unsigned int ret;
|
unsigned int ret;
|
rtx subreg = SUBREG_REG (x);
|
rtx subreg = SUBREG_REG (x);
|
int regno = REGNO (subreg);
|
int regno = REGNO (subreg);
|
|
|
ret = regno + subreg_regno_offset (regno,
|
ret = regno + subreg_regno_offset (regno,
|
GET_MODE (subreg),
|
GET_MODE (subreg),
|
SUBREG_BYTE (x),
|
SUBREG_BYTE (x),
|
GET_MODE (x));
|
GET_MODE (x));
|
return ret;
|
return ret;
|
|
|
}
|
}
|
struct parms_set_data
|
struct parms_set_data
|
{
|
{
|
int nregs;
|
int nregs;
|
HARD_REG_SET regs;
|
HARD_REG_SET regs;
|
};
|
};
|
|
|
/* Helper function for noticing stores to parameter registers. */
|
/* Helper function for noticing stores to parameter registers. */
|
static void
|
static void
|
parms_set (rtx x, rtx pat ATTRIBUTE_UNUSED, void *data)
|
parms_set (rtx x, rtx pat ATTRIBUTE_UNUSED, void *data)
|
{
|
{
|
struct parms_set_data *d = data;
|
struct parms_set_data *d = data;
|
if (REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER
|
if (REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER
|
&& TEST_HARD_REG_BIT (d->regs, REGNO (x)))
|
&& TEST_HARD_REG_BIT (d->regs, REGNO (x)))
|
{
|
{
|
CLEAR_HARD_REG_BIT (d->regs, REGNO (x));
|
CLEAR_HARD_REG_BIT (d->regs, REGNO (x));
|
d->nregs--;
|
d->nregs--;
|
}
|
}
|
}
|
}
|
|
|
/* Look backward for first parameter to be loaded.
|
/* Look backward for first parameter to be loaded.
|
Note that loads of all parameters will not necessarily be
|
Note that loads of all parameters will not necessarily be
|
found if CSE has eliminated some of them (e.g., an argument
|
found if CSE has eliminated some of them (e.g., an argument
|
to the outer function is passed down as a parameter).
|
to the outer function is passed down as a parameter).
|
Do not skip BOUNDARY. */
|
Do not skip BOUNDARY. */
|
rtx
|
rtx
|
find_first_parameter_load (rtx call_insn, rtx boundary)
|
find_first_parameter_load (rtx call_insn, rtx boundary)
|
{
|
{
|
struct parms_set_data parm;
|
struct parms_set_data parm;
|
rtx p, before, first_set;
|
rtx p, before, first_set;
|
|
|
/* Since different machines initialize their parameter registers
|
/* Since different machines initialize their parameter registers
|
in different orders, assume nothing. Collect the set of all
|
in different orders, assume nothing. Collect the set of all
|
parameter registers. */
|
parameter registers. */
|
CLEAR_HARD_REG_SET (parm.regs);
|
CLEAR_HARD_REG_SET (parm.regs);
|
parm.nregs = 0;
|
parm.nregs = 0;
|
for (p = CALL_INSN_FUNCTION_USAGE (call_insn); p; p = XEXP (p, 1))
|
for (p = CALL_INSN_FUNCTION_USAGE (call_insn); p; p = XEXP (p, 1))
|
if (GET_CODE (XEXP (p, 0)) == USE
|
if (GET_CODE (XEXP (p, 0)) == USE
|
&& REG_P (XEXP (XEXP (p, 0), 0)))
|
&& REG_P (XEXP (XEXP (p, 0), 0)))
|
{
|
{
|
gcc_assert (REGNO (XEXP (XEXP (p, 0), 0)) < FIRST_PSEUDO_REGISTER);
|
gcc_assert (REGNO (XEXP (XEXP (p, 0), 0)) < FIRST_PSEUDO_REGISTER);
|
|
|
/* We only care about registers which can hold function
|
/* We only care about registers which can hold function
|
arguments. */
|
arguments. */
|
if (!FUNCTION_ARG_REGNO_P (REGNO (XEXP (XEXP (p, 0), 0))))
|
if (!FUNCTION_ARG_REGNO_P (REGNO (XEXP (XEXP (p, 0), 0))))
|
continue;
|
continue;
|
|
|
SET_HARD_REG_BIT (parm.regs, REGNO (XEXP (XEXP (p, 0), 0)));
|
SET_HARD_REG_BIT (parm.regs, REGNO (XEXP (XEXP (p, 0), 0)));
|
parm.nregs++;
|
parm.nregs++;
|
}
|
}
|
before = call_insn;
|
before = call_insn;
|
first_set = call_insn;
|
first_set = call_insn;
|
|
|
/* Search backward for the first set of a register in this set. */
|
/* Search backward for the first set of a register in this set. */
|
while (parm.nregs && before != boundary)
|
while (parm.nregs && before != boundary)
|
{
|
{
|
before = PREV_INSN (before);
|
before = PREV_INSN (before);
|
|
|
/* It is possible that some loads got CSEed from one call to
|
/* It is possible that some loads got CSEed from one call to
|
another. Stop in that case. */
|
another. Stop in that case. */
|
if (CALL_P (before))
|
if (CALL_P (before))
|
break;
|
break;
|
|
|
/* Our caller needs either ensure that we will find all sets
|
/* Our caller needs either ensure that we will find all sets
|
(in case code has not been optimized yet), or take care
|
(in case code has not been optimized yet), or take care
|
for possible labels in a way by setting boundary to preceding
|
for possible labels in a way by setting boundary to preceding
|
CODE_LABEL. */
|
CODE_LABEL. */
|
if (LABEL_P (before))
|
if (LABEL_P (before))
|
{
|
{
|
gcc_assert (before == boundary);
|
gcc_assert (before == boundary);
|
break;
|
break;
|
}
|
}
|
|
|
if (INSN_P (before))
|
if (INSN_P (before))
|
{
|
{
|
int nregs_old = parm.nregs;
|
int nregs_old = parm.nregs;
|
note_stores (PATTERN (before), parms_set, &parm);
|
note_stores (PATTERN (before), parms_set, &parm);
|
/* If we found something that did not set a parameter reg,
|
/* If we found something that did not set a parameter reg,
|
we're done. Do not keep going, as that might result
|
we're done. Do not keep going, as that might result
|
in hoisting an insn before the setting of a pseudo
|
in hoisting an insn before the setting of a pseudo
|
that is used by the hoisted insn. */
|
that is used by the hoisted insn. */
|
if (nregs_old != parm.nregs)
|
if (nregs_old != parm.nregs)
|
first_set = before;
|
first_set = before;
|
else
|
else
|
break;
|
break;
|
}
|
}
|
}
|
}
|
return first_set;
|
return first_set;
|
}
|
}
|
|
|
/* Return true if we should avoid inserting code between INSN and preceding
|
/* Return true if we should avoid inserting code between INSN and preceding
|
call instruction. */
|
call instruction. */
|
|
|
bool
|
bool
|
keep_with_call_p (rtx insn)
|
keep_with_call_p (rtx insn)
|
{
|
{
|
rtx set;
|
rtx set;
|
|
|
if (INSN_P (insn) && (set = single_set (insn)) != NULL)
|
if (INSN_P (insn) && (set = single_set (insn)) != NULL)
|
{
|
{
|
if (REG_P (SET_DEST (set))
|
if (REG_P (SET_DEST (set))
|
&& REGNO (SET_DEST (set)) < FIRST_PSEUDO_REGISTER
|
&& REGNO (SET_DEST (set)) < FIRST_PSEUDO_REGISTER
|
&& fixed_regs[REGNO (SET_DEST (set))]
|
&& fixed_regs[REGNO (SET_DEST (set))]
|
&& general_operand (SET_SRC (set), VOIDmode))
|
&& general_operand (SET_SRC (set), VOIDmode))
|
return true;
|
return true;
|
if (REG_P (SET_SRC (set))
|
if (REG_P (SET_SRC (set))
|
&& FUNCTION_VALUE_REGNO_P (REGNO (SET_SRC (set)))
|
&& FUNCTION_VALUE_REGNO_P (REGNO (SET_SRC (set)))
|
&& REG_P (SET_DEST (set))
|
&& REG_P (SET_DEST (set))
|
&& REGNO (SET_DEST (set)) >= FIRST_PSEUDO_REGISTER)
|
&& REGNO (SET_DEST (set)) >= FIRST_PSEUDO_REGISTER)
|
return true;
|
return true;
|
/* There may be a stack pop just after the call and before the store
|
/* There may be a stack pop just after the call and before the store
|
of the return register. Search for the actual store when deciding
|
of the return register. Search for the actual store when deciding
|
if we can break or not. */
|
if we can break or not. */
|
if (SET_DEST (set) == stack_pointer_rtx)
|
if (SET_DEST (set) == stack_pointer_rtx)
|
{
|
{
|
rtx i2 = next_nonnote_insn (insn);
|
rtx i2 = next_nonnote_insn (insn);
|
if (i2 && keep_with_call_p (i2))
|
if (i2 && keep_with_call_p (i2))
|
return true;
|
return true;
|
}
|
}
|
}
|
}
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Return true if LABEL is a target of JUMP_INSN. This applies only
|
/* Return true if LABEL is a target of JUMP_INSN. This applies only
|
to non-complex jumps. That is, direct unconditional, conditional,
|
to non-complex jumps. That is, direct unconditional, conditional,
|
and tablejumps, but not computed jumps or returns. It also does
|
and tablejumps, but not computed jumps or returns. It also does
|
not apply to the fallthru case of a conditional jump. */
|
not apply to the fallthru case of a conditional jump. */
|
|
|
bool
|
bool
|
label_is_jump_target_p (rtx label, rtx jump_insn)
|
label_is_jump_target_p (rtx label, rtx jump_insn)
|
{
|
{
|
rtx tmp = JUMP_LABEL (jump_insn);
|
rtx tmp = JUMP_LABEL (jump_insn);
|
|
|
if (label == tmp)
|
if (label == tmp)
|
return true;
|
return true;
|
|
|
if (tablejump_p (jump_insn, NULL, &tmp))
|
if (tablejump_p (jump_insn, NULL, &tmp))
|
{
|
{
|
rtvec vec = XVEC (PATTERN (tmp),
|
rtvec vec = XVEC (PATTERN (tmp),
|
GET_CODE (PATTERN (tmp)) == ADDR_DIFF_VEC);
|
GET_CODE (PATTERN (tmp)) == ADDR_DIFF_VEC);
|
int i, veclen = GET_NUM_ELEM (vec);
|
int i, veclen = GET_NUM_ELEM (vec);
|
|
|
for (i = 0; i < veclen; ++i)
|
for (i = 0; i < veclen; ++i)
|
if (XEXP (RTVEC_ELT (vec, i), 0) == label)
|
if (XEXP (RTVEC_ELT (vec, i), 0) == label)
|
return true;
|
return true;
|
}
|
}
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
|
|
/* Return an estimate of the cost of computing rtx X.
|
/* Return an estimate of the cost of computing rtx X.
|
One use is in cse, to decide which expression to keep in the hash table.
|
One use is in cse, to decide which expression to keep in the hash table.
|
Another is in rtl generation, to pick the cheapest way to multiply.
|
Another is in rtl generation, to pick the cheapest way to multiply.
|
Other uses like the latter are expected in the future. */
|
Other uses like the latter are expected in the future. */
|
|
|
int
|
int
|
rtx_cost (rtx x, enum rtx_code outer_code ATTRIBUTE_UNUSED)
|
rtx_cost (rtx x, enum rtx_code outer_code ATTRIBUTE_UNUSED)
|
{
|
{
|
int i, j;
|
int i, j;
|
enum rtx_code code;
|
enum rtx_code code;
|
const char *fmt;
|
const char *fmt;
|
int total;
|
int total;
|
|
|
if (x == 0)
|
if (x == 0)
|
return 0;
|
return 0;
|
|
|
/* Compute the default costs of certain things.
|
/* Compute the default costs of certain things.
|
Note that targetm.rtx_costs can override the defaults. */
|
Note that targetm.rtx_costs can override the defaults. */
|
|
|
code = GET_CODE (x);
|
code = GET_CODE (x);
|
switch (code)
|
switch (code)
|
{
|
{
|
case MULT:
|
case MULT:
|
total = COSTS_N_INSNS (5);
|
total = COSTS_N_INSNS (5);
|
break;
|
break;
|
case DIV:
|
case DIV:
|
case UDIV:
|
case UDIV:
|
case MOD:
|
case MOD:
|
case UMOD:
|
case UMOD:
|
total = COSTS_N_INSNS (7);
|
total = COSTS_N_INSNS (7);
|
break;
|
break;
|
case USE:
|
case USE:
|
/* Used in combine.c as a marker. */
|
/* Used in combine.c as a marker. */
|
total = 0;
|
total = 0;
|
break;
|
break;
|
default:
|
default:
|
total = COSTS_N_INSNS (1);
|
total = COSTS_N_INSNS (1);
|
}
|
}
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case REG:
|
case REG:
|
return 0;
|
return 0;
|
|
|
case SUBREG:
|
case SUBREG:
|
total = 0;
|
total = 0;
|
/* If we can't tie these modes, make this expensive. The larger
|
/* If we can't tie these modes, make this expensive. The larger
|
the mode, the more expensive it is. */
|
the mode, the more expensive it is. */
|
if (! MODES_TIEABLE_P (GET_MODE (x), GET_MODE (SUBREG_REG (x))))
|
if (! MODES_TIEABLE_P (GET_MODE (x), GET_MODE (SUBREG_REG (x))))
|
return COSTS_N_INSNS (2
|
return COSTS_N_INSNS (2
|
+ GET_MODE_SIZE (GET_MODE (x)) / UNITS_PER_WORD);
|
+ GET_MODE_SIZE (GET_MODE (x)) / UNITS_PER_WORD);
|
break;
|
break;
|
|
|
default:
|
default:
|
if (targetm.rtx_costs (x, code, outer_code, &total))
|
if (targetm.rtx_costs (x, code, outer_code, &total))
|
return total;
|
return total;
|
break;
|
break;
|
}
|
}
|
|
|
/* Sum the costs of the sub-rtx's, plus cost of this operation,
|
/* Sum the costs of the sub-rtx's, plus cost of this operation,
|
which is already in total. */
|
which is already in total. */
|
|
|
fmt = GET_RTX_FORMAT (code);
|
fmt = GET_RTX_FORMAT (code);
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
if (fmt[i] == 'e')
|
if (fmt[i] == 'e')
|
total += rtx_cost (XEXP (x, i), code);
|
total += rtx_cost (XEXP (x, i), code);
|
else if (fmt[i] == 'E')
|
else if (fmt[i] == 'E')
|
for (j = 0; j < XVECLEN (x, i); j++)
|
for (j = 0; j < XVECLEN (x, i); j++)
|
total += rtx_cost (XVECEXP (x, i, j), code);
|
total += rtx_cost (XVECEXP (x, i, j), code);
|
|
|
return total;
|
return total;
|
}
|
}
|
|
|
/* Return cost of address expression X.
|
/* Return cost of address expression X.
|
Expect that X is properly formed address reference. */
|
Expect that X is properly formed address reference. */
|
|
|
int
|
int
|
address_cost (rtx x, enum machine_mode mode)
|
address_cost (rtx x, enum machine_mode mode)
|
{
|
{
|
/* We may be asked for cost of various unusual addresses, such as operands
|
/* We may be asked for cost of various unusual addresses, such as operands
|
of push instruction. It is not worthwhile to complicate writing
|
of push instruction. It is not worthwhile to complicate writing
|
of the target hook by such cases. */
|
of the target hook by such cases. */
|
|
|
if (!memory_address_p (mode, x))
|
if (!memory_address_p (mode, x))
|
return 1000;
|
return 1000;
|
|
|
return targetm.address_cost (x);
|
return targetm.address_cost (x);
|
}
|
}
|
|
|
/* If the target doesn't override, compute the cost as with arithmetic. */
|
/* If the target doesn't override, compute the cost as with arithmetic. */
|
|
|
int
|
int
|
default_address_cost (rtx x)
|
default_address_cost (rtx x)
|
{
|
{
|
return rtx_cost (x, MEM);
|
return rtx_cost (x, MEM);
|
}
|
}
|
|
|
|
|
unsigned HOST_WIDE_INT
|
unsigned HOST_WIDE_INT
|
nonzero_bits (rtx x, enum machine_mode mode)
|
nonzero_bits (rtx x, enum machine_mode mode)
|
{
|
{
|
return cached_nonzero_bits (x, mode, NULL_RTX, VOIDmode, 0);
|
return cached_nonzero_bits (x, mode, NULL_RTX, VOIDmode, 0);
|
}
|
}
|
|
|
unsigned int
|
unsigned int
|
num_sign_bit_copies (rtx x, enum machine_mode mode)
|
num_sign_bit_copies (rtx x, enum machine_mode mode)
|
{
|
{
|
return cached_num_sign_bit_copies (x, mode, NULL_RTX, VOIDmode, 0);
|
return cached_num_sign_bit_copies (x, mode, NULL_RTX, VOIDmode, 0);
|
}
|
}
|
|
|
/* The function cached_nonzero_bits is a wrapper around nonzero_bits1.
|
/* The function cached_nonzero_bits is a wrapper around nonzero_bits1.
|
It avoids exponential behavior in nonzero_bits1 when X has
|
It avoids exponential behavior in nonzero_bits1 when X has
|
identical subexpressions on the first or the second level. */
|
identical subexpressions on the first or the second level. */
|
|
|
static unsigned HOST_WIDE_INT
|
static unsigned HOST_WIDE_INT
|
cached_nonzero_bits (rtx x, enum machine_mode mode, rtx known_x,
|
cached_nonzero_bits (rtx x, enum machine_mode mode, rtx known_x,
|
enum machine_mode known_mode,
|
enum machine_mode known_mode,
|
unsigned HOST_WIDE_INT known_ret)
|
unsigned HOST_WIDE_INT known_ret)
|
{
|
{
|
if (x == known_x && mode == known_mode)
|
if (x == known_x && mode == known_mode)
|
return known_ret;
|
return known_ret;
|
|
|
/* Try to find identical subexpressions. If found call
|
/* Try to find identical subexpressions. If found call
|
nonzero_bits1 on X with the subexpressions as KNOWN_X and the
|
nonzero_bits1 on X with the subexpressions as KNOWN_X and the
|
precomputed value for the subexpression as KNOWN_RET. */
|
precomputed value for the subexpression as KNOWN_RET. */
|
|
|
if (ARITHMETIC_P (x))
|
if (ARITHMETIC_P (x))
|
{
|
{
|
rtx x0 = XEXP (x, 0);
|
rtx x0 = XEXP (x, 0);
|
rtx x1 = XEXP (x, 1);
|
rtx x1 = XEXP (x, 1);
|
|
|
/* Check the first level. */
|
/* Check the first level. */
|
if (x0 == x1)
|
if (x0 == x1)
|
return nonzero_bits1 (x, mode, x0, mode,
|
return nonzero_bits1 (x, mode, x0, mode,
|
cached_nonzero_bits (x0, mode, known_x,
|
cached_nonzero_bits (x0, mode, known_x,
|
known_mode, known_ret));
|
known_mode, known_ret));
|
|
|
/* Check the second level. */
|
/* Check the second level. */
|
if (ARITHMETIC_P (x0)
|
if (ARITHMETIC_P (x0)
|
&& (x1 == XEXP (x0, 0) || x1 == XEXP (x0, 1)))
|
&& (x1 == XEXP (x0, 0) || x1 == XEXP (x0, 1)))
|
return nonzero_bits1 (x, mode, x1, mode,
|
return nonzero_bits1 (x, mode, x1, mode,
|
cached_nonzero_bits (x1, mode, known_x,
|
cached_nonzero_bits (x1, mode, known_x,
|
known_mode, known_ret));
|
known_mode, known_ret));
|
|
|
if (ARITHMETIC_P (x1)
|
if (ARITHMETIC_P (x1)
|
&& (x0 == XEXP (x1, 0) || x0 == XEXP (x1, 1)))
|
&& (x0 == XEXP (x1, 0) || x0 == XEXP (x1, 1)))
|
return nonzero_bits1 (x, mode, x0, mode,
|
return nonzero_bits1 (x, mode, x0, mode,
|
cached_nonzero_bits (x0, mode, known_x,
|
cached_nonzero_bits (x0, mode, known_x,
|
known_mode, known_ret));
|
known_mode, known_ret));
|
}
|
}
|
|
|
return nonzero_bits1 (x, mode, known_x, known_mode, known_ret);
|
return nonzero_bits1 (x, mode, known_x, known_mode, known_ret);
|
}
|
}
|
|
|
/* We let num_sign_bit_copies recur into nonzero_bits as that is useful.
|
/* We let num_sign_bit_copies recur into nonzero_bits as that is useful.
|
We don't let nonzero_bits recur into num_sign_bit_copies, because that
|
We don't let nonzero_bits recur into num_sign_bit_copies, because that
|
is less useful. We can't allow both, because that results in exponential
|
is less useful. We can't allow both, because that results in exponential
|
run time recursion. There is a nullstone testcase that triggered
|
run time recursion. There is a nullstone testcase that triggered
|
this. This macro avoids accidental uses of num_sign_bit_copies. */
|
this. This macro avoids accidental uses of num_sign_bit_copies. */
|
#define cached_num_sign_bit_copies sorry_i_am_preventing_exponential_behavior
|
#define cached_num_sign_bit_copies sorry_i_am_preventing_exponential_behavior
|
|
|
/* Given an expression, X, compute which bits in X can be nonzero.
|
/* Given an expression, X, compute which bits in X can be nonzero.
|
We don't care about bits outside of those defined in MODE.
|
We don't care about bits outside of those defined in MODE.
|
|
|
For most X this is simply GET_MODE_MASK (GET_MODE (MODE)), but if X is
|
For most X this is simply GET_MODE_MASK (GET_MODE (MODE)), but if X is
|
an arithmetic operation, we can do better. */
|
an arithmetic operation, we can do better. */
|
|
|
static unsigned HOST_WIDE_INT
|
static unsigned HOST_WIDE_INT
|
nonzero_bits1 (rtx x, enum machine_mode mode, rtx known_x,
|
nonzero_bits1 (rtx x, enum machine_mode mode, rtx known_x,
|
enum machine_mode known_mode,
|
enum machine_mode known_mode,
|
unsigned HOST_WIDE_INT known_ret)
|
unsigned HOST_WIDE_INT known_ret)
|
{
|
{
|
unsigned HOST_WIDE_INT nonzero = GET_MODE_MASK (mode);
|
unsigned HOST_WIDE_INT nonzero = GET_MODE_MASK (mode);
|
unsigned HOST_WIDE_INT inner_nz;
|
unsigned HOST_WIDE_INT inner_nz;
|
enum rtx_code code;
|
enum rtx_code code;
|
unsigned int mode_width = GET_MODE_BITSIZE (mode);
|
unsigned int mode_width = GET_MODE_BITSIZE (mode);
|
|
|
/* For floating-point values, assume all bits are needed. */
|
/* For floating-point values, assume all bits are needed. */
|
if (FLOAT_MODE_P (GET_MODE (x)) || FLOAT_MODE_P (mode))
|
if (FLOAT_MODE_P (GET_MODE (x)) || FLOAT_MODE_P (mode))
|
return nonzero;
|
return nonzero;
|
|
|
/* If X is wider than MODE, use its mode instead. */
|
/* If X is wider than MODE, use its mode instead. */
|
if (GET_MODE_BITSIZE (GET_MODE (x)) > mode_width)
|
if (GET_MODE_BITSIZE (GET_MODE (x)) > mode_width)
|
{
|
{
|
mode = GET_MODE (x);
|
mode = GET_MODE (x);
|
nonzero = GET_MODE_MASK (mode);
|
nonzero = GET_MODE_MASK (mode);
|
mode_width = GET_MODE_BITSIZE (mode);
|
mode_width = GET_MODE_BITSIZE (mode);
|
}
|
}
|
|
|
if (mode_width > HOST_BITS_PER_WIDE_INT)
|
if (mode_width > HOST_BITS_PER_WIDE_INT)
|
/* Our only callers in this case look for single bit values. So
|
/* Our only callers in this case look for single bit values. So
|
just return the mode mask. Those tests will then be false. */
|
just return the mode mask. Those tests will then be false. */
|
return nonzero;
|
return nonzero;
|
|
|
#ifndef WORD_REGISTER_OPERATIONS
|
#ifndef WORD_REGISTER_OPERATIONS
|
/* If MODE is wider than X, but both are a single word for both the host
|
/* If MODE is wider than X, but both are a single word for both the host
|
and target machines, we can compute this from which bits of the
|
and target machines, we can compute this from which bits of the
|
object might be nonzero in its own mode, taking into account the fact
|
object might be nonzero in its own mode, taking into account the fact
|
that on many CISC machines, accessing an object in a wider mode
|
that on many CISC machines, accessing an object in a wider mode
|
causes the high-order bits to become undefined. So they are
|
causes the high-order bits to become undefined. So they are
|
not known to be zero. */
|
not known to be zero. */
|
|
|
if (GET_MODE (x) != VOIDmode && GET_MODE (x) != mode
|
if (GET_MODE (x) != VOIDmode && GET_MODE (x) != mode
|
&& GET_MODE_BITSIZE (GET_MODE (x)) <= BITS_PER_WORD
|
&& GET_MODE_BITSIZE (GET_MODE (x)) <= BITS_PER_WORD
|
&& GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT
|
&& GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT
|
&& GET_MODE_BITSIZE (mode) > GET_MODE_BITSIZE (GET_MODE (x)))
|
&& GET_MODE_BITSIZE (mode) > GET_MODE_BITSIZE (GET_MODE (x)))
|
{
|
{
|
nonzero &= cached_nonzero_bits (x, GET_MODE (x),
|
nonzero &= cached_nonzero_bits (x, GET_MODE (x),
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
nonzero |= GET_MODE_MASK (mode) & ~GET_MODE_MASK (GET_MODE (x));
|
nonzero |= GET_MODE_MASK (mode) & ~GET_MODE_MASK (GET_MODE (x));
|
return nonzero;
|
return nonzero;
|
}
|
}
|
#endif
|
#endif
|
|
|
code = GET_CODE (x);
|
code = GET_CODE (x);
|
switch (code)
|
switch (code)
|
{
|
{
|
case REG:
|
case REG:
|
#if defined(POINTERS_EXTEND_UNSIGNED) && !defined(HAVE_ptr_extend)
|
#if defined(POINTERS_EXTEND_UNSIGNED) && !defined(HAVE_ptr_extend)
|
/* If pointers extend unsigned and this is a pointer in Pmode, say that
|
/* If pointers extend unsigned and this is a pointer in Pmode, say that
|
all the bits above ptr_mode are known to be zero. */
|
all the bits above ptr_mode are known to be zero. */
|
if (POINTERS_EXTEND_UNSIGNED && GET_MODE (x) == Pmode
|
if (POINTERS_EXTEND_UNSIGNED && GET_MODE (x) == Pmode
|
&& REG_POINTER (x))
|
&& REG_POINTER (x))
|
nonzero &= GET_MODE_MASK (ptr_mode);
|
nonzero &= GET_MODE_MASK (ptr_mode);
|
#endif
|
#endif
|
|
|
/* Include declared information about alignment of pointers. */
|
/* Include declared information about alignment of pointers. */
|
/* ??? We don't properly preserve REG_POINTER changes across
|
/* ??? We don't properly preserve REG_POINTER changes across
|
pointer-to-integer casts, so we can't trust it except for
|
pointer-to-integer casts, so we can't trust it except for
|
things that we know must be pointers. See execute/960116-1.c. */
|
things that we know must be pointers. See execute/960116-1.c. */
|
if ((x == stack_pointer_rtx
|
if ((x == stack_pointer_rtx
|
|| x == frame_pointer_rtx
|
|| x == frame_pointer_rtx
|
|| x == arg_pointer_rtx)
|
|| x == arg_pointer_rtx)
|
&& REGNO_POINTER_ALIGN (REGNO (x)))
|
&& REGNO_POINTER_ALIGN (REGNO (x)))
|
{
|
{
|
unsigned HOST_WIDE_INT alignment
|
unsigned HOST_WIDE_INT alignment
|
= REGNO_POINTER_ALIGN (REGNO (x)) / BITS_PER_UNIT;
|
= REGNO_POINTER_ALIGN (REGNO (x)) / BITS_PER_UNIT;
|
|
|
#ifdef PUSH_ROUNDING
|
#ifdef PUSH_ROUNDING
|
/* If PUSH_ROUNDING is defined, it is possible for the
|
/* If PUSH_ROUNDING is defined, it is possible for the
|
stack to be momentarily aligned only to that amount,
|
stack to be momentarily aligned only to that amount,
|
so we pick the least alignment. */
|
so we pick the least alignment. */
|
if (x == stack_pointer_rtx && PUSH_ARGS)
|
if (x == stack_pointer_rtx && PUSH_ARGS)
|
alignment = MIN ((unsigned HOST_WIDE_INT) PUSH_ROUNDING (1),
|
alignment = MIN ((unsigned HOST_WIDE_INT) PUSH_ROUNDING (1),
|
alignment);
|
alignment);
|
#endif
|
#endif
|
|
|
nonzero &= ~(alignment - 1);
|
nonzero &= ~(alignment - 1);
|
}
|
}
|
|
|
{
|
{
|
unsigned HOST_WIDE_INT nonzero_for_hook = nonzero;
|
unsigned HOST_WIDE_INT nonzero_for_hook = nonzero;
|
rtx new = rtl_hooks.reg_nonzero_bits (x, mode, known_x,
|
rtx new = rtl_hooks.reg_nonzero_bits (x, mode, known_x,
|
known_mode, known_ret,
|
known_mode, known_ret,
|
&nonzero_for_hook);
|
&nonzero_for_hook);
|
|
|
if (new)
|
if (new)
|
nonzero_for_hook &= cached_nonzero_bits (new, mode, known_x,
|
nonzero_for_hook &= cached_nonzero_bits (new, mode, known_x,
|
known_mode, known_ret);
|
known_mode, known_ret);
|
|
|
return nonzero_for_hook;
|
return nonzero_for_hook;
|
}
|
}
|
|
|
case CONST_INT:
|
case CONST_INT:
|
#ifdef SHORT_IMMEDIATES_SIGN_EXTEND
|
#ifdef SHORT_IMMEDIATES_SIGN_EXTEND
|
/* If X is negative in MODE, sign-extend the value. */
|
/* If X is negative in MODE, sign-extend the value. */
|
if (INTVAL (x) > 0 && mode_width < BITS_PER_WORD
|
if (INTVAL (x) > 0 && mode_width < BITS_PER_WORD
|
&& 0 != (INTVAL (x) & ((HOST_WIDE_INT) 1 << (mode_width - 1))))
|
&& 0 != (INTVAL (x) & ((HOST_WIDE_INT) 1 << (mode_width - 1))))
|
return (INTVAL (x) | ((HOST_WIDE_INT) (-1) << mode_width));
|
return (INTVAL (x) | ((HOST_WIDE_INT) (-1) << mode_width));
|
#endif
|
#endif
|
|
|
return INTVAL (x);
|
return INTVAL (x);
|
|
|
case MEM:
|
case MEM:
|
#ifdef LOAD_EXTEND_OP
|
#ifdef LOAD_EXTEND_OP
|
/* In many, if not most, RISC machines, reading a byte from memory
|
/* In many, if not most, RISC machines, reading a byte from memory
|
zeros the rest of the register. Noticing that fact saves a lot
|
zeros the rest of the register. Noticing that fact saves a lot
|
of extra zero-extends. */
|
of extra zero-extends. */
|
if (LOAD_EXTEND_OP (GET_MODE (x)) == ZERO_EXTEND)
|
if (LOAD_EXTEND_OP (GET_MODE (x)) == ZERO_EXTEND)
|
nonzero &= GET_MODE_MASK (GET_MODE (x));
|
nonzero &= GET_MODE_MASK (GET_MODE (x));
|
#endif
|
#endif
|
break;
|
break;
|
|
|
case EQ: case NE:
|
case EQ: case NE:
|
case UNEQ: case LTGT:
|
case UNEQ: case LTGT:
|
case GT: case GTU: case UNGT:
|
case GT: case GTU: case UNGT:
|
case LT: case LTU: case UNLT:
|
case LT: case LTU: case UNLT:
|
case GE: case GEU: case UNGE:
|
case GE: case GEU: case UNGE:
|
case LE: case LEU: case UNLE:
|
case LE: case LEU: case UNLE:
|
case UNORDERED: case ORDERED:
|
case UNORDERED: case ORDERED:
|
/* If this produces an integer result, we know which bits are set.
|
/* If this produces an integer result, we know which bits are set.
|
Code here used to clear bits outside the mode of X, but that is
|
Code here used to clear bits outside the mode of X, but that is
|
now done above. */
|
now done above. */
|
/* Mind that MODE is the mode the caller wants to look at this
|
/* Mind that MODE is the mode the caller wants to look at this
|
operation in, and not the actual operation mode. We can wind
|
operation in, and not the actual operation mode. We can wind
|
up with (subreg:DI (gt:V4HI x y)), and we don't have anything
|
up with (subreg:DI (gt:V4HI x y)), and we don't have anything
|
that describes the results of a vector compare. */
|
that describes the results of a vector compare. */
|
if (GET_MODE_CLASS (GET_MODE (x)) == MODE_INT
|
if (GET_MODE_CLASS (GET_MODE (x)) == MODE_INT
|
&& mode_width <= HOST_BITS_PER_WIDE_INT)
|
&& mode_width <= HOST_BITS_PER_WIDE_INT)
|
nonzero = STORE_FLAG_VALUE;
|
nonzero = STORE_FLAG_VALUE;
|
break;
|
break;
|
|
|
case NEG:
|
case NEG:
|
#if 0
|
#if 0
|
/* Disabled to avoid exponential mutual recursion between nonzero_bits
|
/* Disabled to avoid exponential mutual recursion between nonzero_bits
|
and num_sign_bit_copies. */
|
and num_sign_bit_copies. */
|
if (num_sign_bit_copies (XEXP (x, 0), GET_MODE (x))
|
if (num_sign_bit_copies (XEXP (x, 0), GET_MODE (x))
|
== GET_MODE_BITSIZE (GET_MODE (x)))
|
== GET_MODE_BITSIZE (GET_MODE (x)))
|
nonzero = 1;
|
nonzero = 1;
|
#endif
|
#endif
|
|
|
if (GET_MODE_SIZE (GET_MODE (x)) < mode_width)
|
if (GET_MODE_SIZE (GET_MODE (x)) < mode_width)
|
nonzero |= (GET_MODE_MASK (mode) & ~GET_MODE_MASK (GET_MODE (x)));
|
nonzero |= (GET_MODE_MASK (mode) & ~GET_MODE_MASK (GET_MODE (x)));
|
break;
|
break;
|
|
|
case ABS:
|
case ABS:
|
#if 0
|
#if 0
|
/* Disabled to avoid exponential mutual recursion between nonzero_bits
|
/* Disabled to avoid exponential mutual recursion between nonzero_bits
|
and num_sign_bit_copies. */
|
and num_sign_bit_copies. */
|
if (num_sign_bit_copies (XEXP (x, 0), GET_MODE (x))
|
if (num_sign_bit_copies (XEXP (x, 0), GET_MODE (x))
|
== GET_MODE_BITSIZE (GET_MODE (x)))
|
== GET_MODE_BITSIZE (GET_MODE (x)))
|
nonzero = 1;
|
nonzero = 1;
|
#endif
|
#endif
|
break;
|
break;
|
|
|
case TRUNCATE:
|
case TRUNCATE:
|
nonzero &= (cached_nonzero_bits (XEXP (x, 0), mode,
|
nonzero &= (cached_nonzero_bits (XEXP (x, 0), mode,
|
known_x, known_mode, known_ret)
|
known_x, known_mode, known_ret)
|
& GET_MODE_MASK (mode));
|
& GET_MODE_MASK (mode));
|
break;
|
break;
|
|
|
case ZERO_EXTEND:
|
case ZERO_EXTEND:
|
nonzero &= cached_nonzero_bits (XEXP (x, 0), mode,
|
nonzero &= cached_nonzero_bits (XEXP (x, 0), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
if (GET_MODE (XEXP (x, 0)) != VOIDmode)
|
if (GET_MODE (XEXP (x, 0)) != VOIDmode)
|
nonzero &= GET_MODE_MASK (GET_MODE (XEXP (x, 0)));
|
nonzero &= GET_MODE_MASK (GET_MODE (XEXP (x, 0)));
|
break;
|
break;
|
|
|
case SIGN_EXTEND:
|
case SIGN_EXTEND:
|
/* If the sign bit is known clear, this is the same as ZERO_EXTEND.
|
/* If the sign bit is known clear, this is the same as ZERO_EXTEND.
|
Otherwise, show all the bits in the outer mode but not the inner
|
Otherwise, show all the bits in the outer mode but not the inner
|
may be nonzero. */
|
may be nonzero. */
|
inner_nz = cached_nonzero_bits (XEXP (x, 0), mode,
|
inner_nz = cached_nonzero_bits (XEXP (x, 0), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
if (GET_MODE (XEXP (x, 0)) != VOIDmode)
|
if (GET_MODE (XEXP (x, 0)) != VOIDmode)
|
{
|
{
|
inner_nz &= GET_MODE_MASK (GET_MODE (XEXP (x, 0)));
|
inner_nz &= GET_MODE_MASK (GET_MODE (XEXP (x, 0)));
|
if (inner_nz
|
if (inner_nz
|
& (((HOST_WIDE_INT) 1
|
& (((HOST_WIDE_INT) 1
|
<< (GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0))) - 1))))
|
<< (GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0))) - 1))))
|
inner_nz |= (GET_MODE_MASK (mode)
|
inner_nz |= (GET_MODE_MASK (mode)
|
& ~GET_MODE_MASK (GET_MODE (XEXP (x, 0))));
|
& ~GET_MODE_MASK (GET_MODE (XEXP (x, 0))));
|
}
|
}
|
|
|
nonzero &= inner_nz;
|
nonzero &= inner_nz;
|
break;
|
break;
|
|
|
case AND:
|
case AND:
|
nonzero &= cached_nonzero_bits (XEXP (x, 0), mode,
|
nonzero &= cached_nonzero_bits (XEXP (x, 0), mode,
|
known_x, known_mode, known_ret)
|
known_x, known_mode, known_ret)
|
& cached_nonzero_bits (XEXP (x, 1), mode,
|
& cached_nonzero_bits (XEXP (x, 1), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
break;
|
break;
|
|
|
case XOR: case IOR:
|
case XOR: case IOR:
|
case UMIN: case UMAX: case SMIN: case SMAX:
|
case UMIN: case UMAX: case SMIN: case SMAX:
|
{
|
{
|
unsigned HOST_WIDE_INT nonzero0 =
|
unsigned HOST_WIDE_INT nonzero0 =
|
cached_nonzero_bits (XEXP (x, 0), mode,
|
cached_nonzero_bits (XEXP (x, 0), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
|
|
/* Don't call nonzero_bits for the second time if it cannot change
|
/* Don't call nonzero_bits for the second time if it cannot change
|
anything. */
|
anything. */
|
if ((nonzero & nonzero0) != nonzero)
|
if ((nonzero & nonzero0) != nonzero)
|
nonzero &= nonzero0
|
nonzero &= nonzero0
|
| cached_nonzero_bits (XEXP (x, 1), mode,
|
| cached_nonzero_bits (XEXP (x, 1), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
}
|
}
|
break;
|
break;
|
|
|
case PLUS: case MINUS:
|
case PLUS: case MINUS:
|
case MULT:
|
case MULT:
|
case DIV: case UDIV:
|
case DIV: case UDIV:
|
case MOD: case UMOD:
|
case MOD: case UMOD:
|
/* We can apply the rules of arithmetic to compute the number of
|
/* We can apply the rules of arithmetic to compute the number of
|
high- and low-order zero bits of these operations. We start by
|
high- and low-order zero bits of these operations. We start by
|
computing the width (position of the highest-order nonzero bit)
|
computing the width (position of the highest-order nonzero bit)
|
and the number of low-order zero bits for each value. */
|
and the number of low-order zero bits for each value. */
|
{
|
{
|
unsigned HOST_WIDE_INT nz0 =
|
unsigned HOST_WIDE_INT nz0 =
|
cached_nonzero_bits (XEXP (x, 0), mode,
|
cached_nonzero_bits (XEXP (x, 0), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
unsigned HOST_WIDE_INT nz1 =
|
unsigned HOST_WIDE_INT nz1 =
|
cached_nonzero_bits (XEXP (x, 1), mode,
|
cached_nonzero_bits (XEXP (x, 1), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
int sign_index = GET_MODE_BITSIZE (GET_MODE (x)) - 1;
|
int sign_index = GET_MODE_BITSIZE (GET_MODE (x)) - 1;
|
int width0 = floor_log2 (nz0) + 1;
|
int width0 = floor_log2 (nz0) + 1;
|
int width1 = floor_log2 (nz1) + 1;
|
int width1 = floor_log2 (nz1) + 1;
|
int low0 = floor_log2 (nz0 & -nz0);
|
int low0 = floor_log2 (nz0 & -nz0);
|
int low1 = floor_log2 (nz1 & -nz1);
|
int low1 = floor_log2 (nz1 & -nz1);
|
HOST_WIDE_INT op0_maybe_minusp
|
HOST_WIDE_INT op0_maybe_minusp
|
= (nz0 & ((HOST_WIDE_INT) 1 << sign_index));
|
= (nz0 & ((HOST_WIDE_INT) 1 << sign_index));
|
HOST_WIDE_INT op1_maybe_minusp
|
HOST_WIDE_INT op1_maybe_minusp
|
= (nz1 & ((HOST_WIDE_INT) 1 << sign_index));
|
= (nz1 & ((HOST_WIDE_INT) 1 << sign_index));
|
unsigned int result_width = mode_width;
|
unsigned int result_width = mode_width;
|
int result_low = 0;
|
int result_low = 0;
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case PLUS:
|
case PLUS:
|
result_width = MAX (width0, width1) + 1;
|
result_width = MAX (width0, width1) + 1;
|
result_low = MIN (low0, low1);
|
result_low = MIN (low0, low1);
|
break;
|
break;
|
case MINUS:
|
case MINUS:
|
result_low = MIN (low0, low1);
|
result_low = MIN (low0, low1);
|
break;
|
break;
|
case MULT:
|
case MULT:
|
result_width = width0 + width1;
|
result_width = width0 + width1;
|
result_low = low0 + low1;
|
result_low = low0 + low1;
|
break;
|
break;
|
case DIV:
|
case DIV:
|
if (width1 == 0)
|
if (width1 == 0)
|
break;
|
break;
|
if (! op0_maybe_minusp && ! op1_maybe_minusp)
|
if (! op0_maybe_minusp && ! op1_maybe_minusp)
|
result_width = width0;
|
result_width = width0;
|
break;
|
break;
|
case UDIV:
|
case UDIV:
|
if (width1 == 0)
|
if (width1 == 0)
|
break;
|
break;
|
result_width = width0;
|
result_width = width0;
|
break;
|
break;
|
case MOD:
|
case MOD:
|
if (width1 == 0)
|
if (width1 == 0)
|
break;
|
break;
|
if (! op0_maybe_minusp && ! op1_maybe_minusp)
|
if (! op0_maybe_minusp && ! op1_maybe_minusp)
|
result_width = MIN (width0, width1);
|
result_width = MIN (width0, width1);
|
result_low = MIN (low0, low1);
|
result_low = MIN (low0, low1);
|
break;
|
break;
|
case UMOD:
|
case UMOD:
|
if (width1 == 0)
|
if (width1 == 0)
|
break;
|
break;
|
result_width = MIN (width0, width1);
|
result_width = MIN (width0, width1);
|
result_low = MIN (low0, low1);
|
result_low = MIN (low0, low1);
|
break;
|
break;
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
if (result_width < mode_width)
|
if (result_width < mode_width)
|
nonzero &= ((HOST_WIDE_INT) 1 << result_width) - 1;
|
nonzero &= ((HOST_WIDE_INT) 1 << result_width) - 1;
|
|
|
if (result_low > 0)
|
if (result_low > 0)
|
nonzero &= ~(((HOST_WIDE_INT) 1 << result_low) - 1);
|
nonzero &= ~(((HOST_WIDE_INT) 1 << result_low) - 1);
|
|
|
#ifdef POINTERS_EXTEND_UNSIGNED
|
#ifdef POINTERS_EXTEND_UNSIGNED
|
/* If pointers extend unsigned and this is an addition or subtraction
|
/* If pointers extend unsigned and this is an addition or subtraction
|
to a pointer in Pmode, all the bits above ptr_mode are known to be
|
to a pointer in Pmode, all the bits above ptr_mode are known to be
|
zero. */
|
zero. */
|
if (POINTERS_EXTEND_UNSIGNED > 0 && GET_MODE (x) == Pmode
|
if (POINTERS_EXTEND_UNSIGNED > 0 && GET_MODE (x) == Pmode
|
&& (code == PLUS || code == MINUS)
|
&& (code == PLUS || code == MINUS)
|
&& REG_P (XEXP (x, 0)) && REG_POINTER (XEXP (x, 0)))
|
&& REG_P (XEXP (x, 0)) && REG_POINTER (XEXP (x, 0)))
|
nonzero &= GET_MODE_MASK (ptr_mode);
|
nonzero &= GET_MODE_MASK (ptr_mode);
|
#endif
|
#endif
|
}
|
}
|
break;
|
break;
|
|
|
case ZERO_EXTRACT:
|
case ZERO_EXTRACT:
|
if (GET_CODE (XEXP (x, 1)) == CONST_INT
|
if (GET_CODE (XEXP (x, 1)) == CONST_INT
|
&& INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT)
|
&& INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT)
|
nonzero &= ((HOST_WIDE_INT) 1 << INTVAL (XEXP (x, 1))) - 1;
|
nonzero &= ((HOST_WIDE_INT) 1 << INTVAL (XEXP (x, 1))) - 1;
|
break;
|
break;
|
|
|
case SUBREG:
|
case SUBREG:
|
/* If this is a SUBREG formed for a promoted variable that has
|
/* If this is a SUBREG formed for a promoted variable that has
|
been zero-extended, we know that at least the high-order bits
|
been zero-extended, we know that at least the high-order bits
|
are zero, though others might be too. */
|
are zero, though others might be too. */
|
|
|
if (SUBREG_PROMOTED_VAR_P (x) && SUBREG_PROMOTED_UNSIGNED_P (x) > 0)
|
if (SUBREG_PROMOTED_VAR_P (x) && SUBREG_PROMOTED_UNSIGNED_P (x) > 0)
|
nonzero = GET_MODE_MASK (GET_MODE (x))
|
nonzero = GET_MODE_MASK (GET_MODE (x))
|
& cached_nonzero_bits (SUBREG_REG (x), GET_MODE (x),
|
& cached_nonzero_bits (SUBREG_REG (x), GET_MODE (x),
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
|
|
/* If the inner mode is a single word for both the host and target
|
/* If the inner mode is a single word for both the host and target
|
machines, we can compute this from which bits of the inner
|
machines, we can compute this from which bits of the inner
|
object might be nonzero. */
|
object might be nonzero. */
|
if (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x))) <= BITS_PER_WORD
|
if (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x))) <= BITS_PER_WORD
|
&& (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x)))
|
&& (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x)))
|
<= HOST_BITS_PER_WIDE_INT))
|
<= HOST_BITS_PER_WIDE_INT))
|
{
|
{
|
nonzero &= cached_nonzero_bits (SUBREG_REG (x), mode,
|
nonzero &= cached_nonzero_bits (SUBREG_REG (x), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
|
|
#if defined (WORD_REGISTER_OPERATIONS) && defined (LOAD_EXTEND_OP)
|
#if defined (WORD_REGISTER_OPERATIONS) && defined (LOAD_EXTEND_OP)
|
/* If this is a typical RISC machine, we only have to worry
|
/* If this is a typical RISC machine, we only have to worry
|
about the way loads are extended. */
|
about the way loads are extended. */
|
if ((LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (x))) == SIGN_EXTEND
|
if ((LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (x))) == SIGN_EXTEND
|
? (((nonzero
|
? (((nonzero
|
& (((unsigned HOST_WIDE_INT) 1
|
& (((unsigned HOST_WIDE_INT) 1
|
<< (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x))) - 1))))
|
<< (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x))) - 1))))
|
!= 0))
|
!= 0))
|
: LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (x))) != ZERO_EXTEND)
|
: LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (x))) != ZERO_EXTEND)
|
|| !MEM_P (SUBREG_REG (x)))
|
|| !MEM_P (SUBREG_REG (x)))
|
#endif
|
#endif
|
{
|
{
|
/* On many CISC machines, accessing an object in a wider mode
|
/* On many CISC machines, accessing an object in a wider mode
|
causes the high-order bits to become undefined. So they are
|
causes the high-order bits to become undefined. So they are
|
not known to be zero. */
|
not known to be zero. */
|
if (GET_MODE_SIZE (GET_MODE (x))
|
if (GET_MODE_SIZE (GET_MODE (x))
|
> GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
|
> GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
|
nonzero |= (GET_MODE_MASK (GET_MODE (x))
|
nonzero |= (GET_MODE_MASK (GET_MODE (x))
|
& ~GET_MODE_MASK (GET_MODE (SUBREG_REG (x))));
|
& ~GET_MODE_MASK (GET_MODE (SUBREG_REG (x))));
|
}
|
}
|
}
|
}
|
break;
|
break;
|
|
|
case ASHIFTRT:
|
case ASHIFTRT:
|
case LSHIFTRT:
|
case LSHIFTRT:
|
case ASHIFT:
|
case ASHIFT:
|
case ROTATE:
|
case ROTATE:
|
/* The nonzero bits are in two classes: any bits within MODE
|
/* The nonzero bits are in two classes: any bits within MODE
|
that aren't in GET_MODE (x) are always significant. The rest of the
|
that aren't in GET_MODE (x) are always significant. The rest of the
|
nonzero bits are those that are significant in the operand of
|
nonzero bits are those that are significant in the operand of
|
the shift when shifted the appropriate number of bits. This
|
the shift when shifted the appropriate number of bits. This
|
shows that high-order bits are cleared by the right shift and
|
shows that high-order bits are cleared by the right shift and
|
low-order bits by left shifts. */
|
low-order bits by left shifts. */
|
if (GET_CODE (XEXP (x, 1)) == CONST_INT
|
if (GET_CODE (XEXP (x, 1)) == CONST_INT
|
&& INTVAL (XEXP (x, 1)) >= 0
|
&& INTVAL (XEXP (x, 1)) >= 0
|
&& INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT)
|
&& INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT)
|
{
|
{
|
enum machine_mode inner_mode = GET_MODE (x);
|
enum machine_mode inner_mode = GET_MODE (x);
|
unsigned int width = GET_MODE_BITSIZE (inner_mode);
|
unsigned int width = GET_MODE_BITSIZE (inner_mode);
|
int count = INTVAL (XEXP (x, 1));
|
int count = INTVAL (XEXP (x, 1));
|
unsigned HOST_WIDE_INT mode_mask = GET_MODE_MASK (inner_mode);
|
unsigned HOST_WIDE_INT mode_mask = GET_MODE_MASK (inner_mode);
|
unsigned HOST_WIDE_INT op_nonzero =
|
unsigned HOST_WIDE_INT op_nonzero =
|
cached_nonzero_bits (XEXP (x, 0), mode,
|
cached_nonzero_bits (XEXP (x, 0), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
unsigned HOST_WIDE_INT inner = op_nonzero & mode_mask;
|
unsigned HOST_WIDE_INT inner = op_nonzero & mode_mask;
|
unsigned HOST_WIDE_INT outer = 0;
|
unsigned HOST_WIDE_INT outer = 0;
|
|
|
if (mode_width > width)
|
if (mode_width > width)
|
outer = (op_nonzero & nonzero & ~mode_mask);
|
outer = (op_nonzero & nonzero & ~mode_mask);
|
|
|
if (code == LSHIFTRT)
|
if (code == LSHIFTRT)
|
inner >>= count;
|
inner >>= count;
|
else if (code == ASHIFTRT)
|
else if (code == ASHIFTRT)
|
{
|
{
|
inner >>= count;
|
inner >>= count;
|
|
|
/* If the sign bit may have been nonzero before the shift, we
|
/* If the sign bit may have been nonzero before the shift, we
|
need to mark all the places it could have been copied to
|
need to mark all the places it could have been copied to
|
by the shift as possibly nonzero. */
|
by the shift as possibly nonzero. */
|
if (inner & ((HOST_WIDE_INT) 1 << (width - 1 - count)))
|
if (inner & ((HOST_WIDE_INT) 1 << (width - 1 - count)))
|
inner |= (((HOST_WIDE_INT) 1 << count) - 1) << (width - count);
|
inner |= (((HOST_WIDE_INT) 1 << count) - 1) << (width - count);
|
}
|
}
|
else if (code == ASHIFT)
|
else if (code == ASHIFT)
|
inner <<= count;
|
inner <<= count;
|
else
|
else
|
inner = ((inner << (count % width)
|
inner = ((inner << (count % width)
|
| (inner >> (width - (count % width)))) & mode_mask);
|
| (inner >> (width - (count % width)))) & mode_mask);
|
|
|
nonzero &= (outer | inner);
|
nonzero &= (outer | inner);
|
}
|
}
|
break;
|
break;
|
|
|
case FFS:
|
case FFS:
|
case POPCOUNT:
|
case POPCOUNT:
|
/* This is at most the number of bits in the mode. */
|
/* This is at most the number of bits in the mode. */
|
nonzero = ((HOST_WIDE_INT) 2 << (floor_log2 (mode_width))) - 1;
|
nonzero = ((HOST_WIDE_INT) 2 << (floor_log2 (mode_width))) - 1;
|
break;
|
break;
|
|
|
case CLZ:
|
case CLZ:
|
/* If CLZ has a known value at zero, then the nonzero bits are
|
/* If CLZ has a known value at zero, then the nonzero bits are
|
that value, plus the number of bits in the mode minus one. */
|
that value, plus the number of bits in the mode minus one. */
|
if (CLZ_DEFINED_VALUE_AT_ZERO (mode, nonzero))
|
if (CLZ_DEFINED_VALUE_AT_ZERO (mode, nonzero))
|
nonzero |= ((HOST_WIDE_INT) 1 << (floor_log2 (mode_width))) - 1;
|
nonzero |= ((HOST_WIDE_INT) 1 << (floor_log2 (mode_width))) - 1;
|
else
|
else
|
nonzero = -1;
|
nonzero = -1;
|
break;
|
break;
|
|
|
case CTZ:
|
case CTZ:
|
/* If CTZ has a known value at zero, then the nonzero bits are
|
/* If CTZ has a known value at zero, then the nonzero bits are
|
that value, plus the number of bits in the mode minus one. */
|
that value, plus the number of bits in the mode minus one. */
|
if (CTZ_DEFINED_VALUE_AT_ZERO (mode, nonzero))
|
if (CTZ_DEFINED_VALUE_AT_ZERO (mode, nonzero))
|
nonzero |= ((HOST_WIDE_INT) 1 << (floor_log2 (mode_width))) - 1;
|
nonzero |= ((HOST_WIDE_INT) 1 << (floor_log2 (mode_width))) - 1;
|
else
|
else
|
nonzero = -1;
|
nonzero = -1;
|
break;
|
break;
|
|
|
case PARITY:
|
case PARITY:
|
nonzero = 1;
|
nonzero = 1;
|
break;
|
break;
|
|
|
case IF_THEN_ELSE:
|
case IF_THEN_ELSE:
|
{
|
{
|
unsigned HOST_WIDE_INT nonzero_true =
|
unsigned HOST_WIDE_INT nonzero_true =
|
cached_nonzero_bits (XEXP (x, 1), mode,
|
cached_nonzero_bits (XEXP (x, 1), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
|
|
/* Don't call nonzero_bits for the second time if it cannot change
|
/* Don't call nonzero_bits for the second time if it cannot change
|
anything. */
|
anything. */
|
if ((nonzero & nonzero_true) != nonzero)
|
if ((nonzero & nonzero_true) != nonzero)
|
nonzero &= nonzero_true
|
nonzero &= nonzero_true
|
| cached_nonzero_bits (XEXP (x, 2), mode,
|
| cached_nonzero_bits (XEXP (x, 2), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
}
|
}
|
break;
|
break;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
return nonzero;
|
return nonzero;
|
}
|
}
|
|
|
/* See the macro definition above. */
|
/* See the macro definition above. */
|
#undef cached_num_sign_bit_copies
|
#undef cached_num_sign_bit_copies
|
|
|
|
|
/* The function cached_num_sign_bit_copies is a wrapper around
|
/* The function cached_num_sign_bit_copies is a wrapper around
|
num_sign_bit_copies1. It avoids exponential behavior in
|
num_sign_bit_copies1. It avoids exponential behavior in
|
num_sign_bit_copies1 when X has identical subexpressions on the
|
num_sign_bit_copies1 when X has identical subexpressions on the
|
first or the second level. */
|
first or the second level. */
|
|
|
static unsigned int
|
static unsigned int
|
cached_num_sign_bit_copies (rtx x, enum machine_mode mode, rtx known_x,
|
cached_num_sign_bit_copies (rtx x, enum machine_mode mode, rtx known_x,
|
enum machine_mode known_mode,
|
enum machine_mode known_mode,
|
unsigned int known_ret)
|
unsigned int known_ret)
|
{
|
{
|
if (x == known_x && mode == known_mode)
|
if (x == known_x && mode == known_mode)
|
return known_ret;
|
return known_ret;
|
|
|
/* Try to find identical subexpressions. If found call
|
/* Try to find identical subexpressions. If found call
|
num_sign_bit_copies1 on X with the subexpressions as KNOWN_X and
|
num_sign_bit_copies1 on X with the subexpressions as KNOWN_X and
|
the precomputed value for the subexpression as KNOWN_RET. */
|
the precomputed value for the subexpression as KNOWN_RET. */
|
|
|
if (ARITHMETIC_P (x))
|
if (ARITHMETIC_P (x))
|
{
|
{
|
rtx x0 = XEXP (x, 0);
|
rtx x0 = XEXP (x, 0);
|
rtx x1 = XEXP (x, 1);
|
rtx x1 = XEXP (x, 1);
|
|
|
/* Check the first level. */
|
/* Check the first level. */
|
if (x0 == x1)
|
if (x0 == x1)
|
return
|
return
|
num_sign_bit_copies1 (x, mode, x0, mode,
|
num_sign_bit_copies1 (x, mode, x0, mode,
|
cached_num_sign_bit_copies (x0, mode, known_x,
|
cached_num_sign_bit_copies (x0, mode, known_x,
|
known_mode,
|
known_mode,
|
known_ret));
|
known_ret));
|
|
|
/* Check the second level. */
|
/* Check the second level. */
|
if (ARITHMETIC_P (x0)
|
if (ARITHMETIC_P (x0)
|
&& (x1 == XEXP (x0, 0) || x1 == XEXP (x0, 1)))
|
&& (x1 == XEXP (x0, 0) || x1 == XEXP (x0, 1)))
|
return
|
return
|
num_sign_bit_copies1 (x, mode, x1, mode,
|
num_sign_bit_copies1 (x, mode, x1, mode,
|
cached_num_sign_bit_copies (x1, mode, known_x,
|
cached_num_sign_bit_copies (x1, mode, known_x,
|
known_mode,
|
known_mode,
|
known_ret));
|
known_ret));
|
|
|
if (ARITHMETIC_P (x1)
|
if (ARITHMETIC_P (x1)
|
&& (x0 == XEXP (x1, 0) || x0 == XEXP (x1, 1)))
|
&& (x0 == XEXP (x1, 0) || x0 == XEXP (x1, 1)))
|
return
|
return
|
num_sign_bit_copies1 (x, mode, x0, mode,
|
num_sign_bit_copies1 (x, mode, x0, mode,
|
cached_num_sign_bit_copies (x0, mode, known_x,
|
cached_num_sign_bit_copies (x0, mode, known_x,
|
known_mode,
|
known_mode,
|
known_ret));
|
known_ret));
|
}
|
}
|
|
|
return num_sign_bit_copies1 (x, mode, known_x, known_mode, known_ret);
|
return num_sign_bit_copies1 (x, mode, known_x, known_mode, known_ret);
|
}
|
}
|
|
|
/* Return the number of bits at the high-order end of X that are known to
|
/* Return the number of bits at the high-order end of X that are known to
|
be equal to the sign bit. X will be used in mode MODE; if MODE is
|
be equal to the sign bit. X will be used in mode MODE; if MODE is
|
VOIDmode, X will be used in its own mode. The returned value will always
|
VOIDmode, X will be used in its own mode. The returned value will always
|
be between 1 and the number of bits in MODE. */
|
be between 1 and the number of bits in MODE. */
|
|
|
static unsigned int
|
static unsigned int
|
num_sign_bit_copies1 (rtx x, enum machine_mode mode, rtx known_x,
|
num_sign_bit_copies1 (rtx x, enum machine_mode mode, rtx known_x,
|
enum machine_mode known_mode,
|
enum machine_mode known_mode,
|
unsigned int known_ret)
|
unsigned int known_ret)
|
{
|
{
|
enum rtx_code code = GET_CODE (x);
|
enum rtx_code code = GET_CODE (x);
|
unsigned int bitwidth = GET_MODE_BITSIZE (mode);
|
unsigned int bitwidth = GET_MODE_BITSIZE (mode);
|
int num0, num1, result;
|
int num0, num1, result;
|
unsigned HOST_WIDE_INT nonzero;
|
unsigned HOST_WIDE_INT nonzero;
|
|
|
/* If we weren't given a mode, use the mode of X. If the mode is still
|
/* If we weren't given a mode, use the mode of X. If the mode is still
|
VOIDmode, we don't know anything. Likewise if one of the modes is
|
VOIDmode, we don't know anything. Likewise if one of the modes is
|
floating-point. */
|
floating-point. */
|
|
|
if (mode == VOIDmode)
|
if (mode == VOIDmode)
|
mode = GET_MODE (x);
|
mode = GET_MODE (x);
|
|
|
if (mode == VOIDmode || FLOAT_MODE_P (mode) || FLOAT_MODE_P (GET_MODE (x)))
|
if (mode == VOIDmode || FLOAT_MODE_P (mode) || FLOAT_MODE_P (GET_MODE (x)))
|
return 1;
|
return 1;
|
|
|
/* For a smaller object, just ignore the high bits. */
|
/* For a smaller object, just ignore the high bits. */
|
if (bitwidth < GET_MODE_BITSIZE (GET_MODE (x)))
|
if (bitwidth < GET_MODE_BITSIZE (GET_MODE (x)))
|
{
|
{
|
num0 = cached_num_sign_bit_copies (x, GET_MODE (x),
|
num0 = cached_num_sign_bit_copies (x, GET_MODE (x),
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
return MAX (1,
|
return MAX (1,
|
num0 - (int) (GET_MODE_BITSIZE (GET_MODE (x)) - bitwidth));
|
num0 - (int) (GET_MODE_BITSIZE (GET_MODE (x)) - bitwidth));
|
}
|
}
|
|
|
if (GET_MODE (x) != VOIDmode && bitwidth > GET_MODE_BITSIZE (GET_MODE (x)))
|
if (GET_MODE (x) != VOIDmode && bitwidth > GET_MODE_BITSIZE (GET_MODE (x)))
|
{
|
{
|
#ifndef WORD_REGISTER_OPERATIONS
|
#ifndef WORD_REGISTER_OPERATIONS
|
/* If this machine does not do all register operations on the entire
|
/* If this machine does not do all register operations on the entire
|
register and MODE is wider than the mode of X, we can say nothing
|
register and MODE is wider than the mode of X, we can say nothing
|
at all about the high-order bits. */
|
at all about the high-order bits. */
|
return 1;
|
return 1;
|
#else
|
#else
|
/* Likewise on machines that do, if the mode of the object is smaller
|
/* Likewise on machines that do, if the mode of the object is smaller
|
than a word and loads of that size don't sign extend, we can say
|
than a word and loads of that size don't sign extend, we can say
|
nothing about the high order bits. */
|
nothing about the high order bits. */
|
if (GET_MODE_BITSIZE (GET_MODE (x)) < BITS_PER_WORD
|
if (GET_MODE_BITSIZE (GET_MODE (x)) < BITS_PER_WORD
|
#ifdef LOAD_EXTEND_OP
|
#ifdef LOAD_EXTEND_OP
|
&& LOAD_EXTEND_OP (GET_MODE (x)) != SIGN_EXTEND
|
&& LOAD_EXTEND_OP (GET_MODE (x)) != SIGN_EXTEND
|
#endif
|
#endif
|
)
|
)
|
return 1;
|
return 1;
|
#endif
|
#endif
|
}
|
}
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case REG:
|
case REG:
|
|
|
#if defined(POINTERS_EXTEND_UNSIGNED) && !defined(HAVE_ptr_extend)
|
#if defined(POINTERS_EXTEND_UNSIGNED) && !defined(HAVE_ptr_extend)
|
/* If pointers extend signed and this is a pointer in Pmode, say that
|
/* If pointers extend signed and this is a pointer in Pmode, say that
|
all the bits above ptr_mode are known to be sign bit copies. */
|
all the bits above ptr_mode are known to be sign bit copies. */
|
if (! POINTERS_EXTEND_UNSIGNED && GET_MODE (x) == Pmode && mode == Pmode
|
if (! POINTERS_EXTEND_UNSIGNED && GET_MODE (x) == Pmode && mode == Pmode
|
&& REG_POINTER (x))
|
&& REG_POINTER (x))
|
return GET_MODE_BITSIZE (Pmode) - GET_MODE_BITSIZE (ptr_mode) + 1;
|
return GET_MODE_BITSIZE (Pmode) - GET_MODE_BITSIZE (ptr_mode) + 1;
|
#endif
|
#endif
|
|
|
{
|
{
|
unsigned int copies_for_hook = 1, copies = 1;
|
unsigned int copies_for_hook = 1, copies = 1;
|
rtx new = rtl_hooks.reg_num_sign_bit_copies (x, mode, known_x,
|
rtx new = rtl_hooks.reg_num_sign_bit_copies (x, mode, known_x,
|
known_mode, known_ret,
|
known_mode, known_ret,
|
&copies_for_hook);
|
&copies_for_hook);
|
|
|
if (new)
|
if (new)
|
copies = cached_num_sign_bit_copies (new, mode, known_x,
|
copies = cached_num_sign_bit_copies (new, mode, known_x,
|
known_mode, known_ret);
|
known_mode, known_ret);
|
|
|
if (copies > 1 || copies_for_hook > 1)
|
if (copies > 1 || copies_for_hook > 1)
|
return MAX (copies, copies_for_hook);
|
return MAX (copies, copies_for_hook);
|
|
|
/* Else, use nonzero_bits to guess num_sign_bit_copies (see below). */
|
/* Else, use nonzero_bits to guess num_sign_bit_copies (see below). */
|
}
|
}
|
break;
|
break;
|
|
|
case MEM:
|
case MEM:
|
#ifdef LOAD_EXTEND_OP
|
#ifdef LOAD_EXTEND_OP
|
/* Some RISC machines sign-extend all loads of smaller than a word. */
|
/* Some RISC machines sign-extend all loads of smaller than a word. */
|
if (LOAD_EXTEND_OP (GET_MODE (x)) == SIGN_EXTEND)
|
if (LOAD_EXTEND_OP (GET_MODE (x)) == SIGN_EXTEND)
|
return MAX (1, ((int) bitwidth
|
return MAX (1, ((int) bitwidth
|
- (int) GET_MODE_BITSIZE (GET_MODE (x)) + 1));
|
- (int) GET_MODE_BITSIZE (GET_MODE (x)) + 1));
|
#endif
|
#endif
|
break;
|
break;
|
|
|
case CONST_INT:
|
case CONST_INT:
|
/* If the constant is negative, take its 1's complement and remask.
|
/* If the constant is negative, take its 1's complement and remask.
|
Then see how many zero bits we have. */
|
Then see how many zero bits we have. */
|
nonzero = INTVAL (x) & GET_MODE_MASK (mode);
|
nonzero = INTVAL (x) & GET_MODE_MASK (mode);
|
if (bitwidth <= HOST_BITS_PER_WIDE_INT
|
if (bitwidth <= HOST_BITS_PER_WIDE_INT
|
&& (nonzero & ((HOST_WIDE_INT) 1 << (bitwidth - 1))) != 0)
|
&& (nonzero & ((HOST_WIDE_INT) 1 << (bitwidth - 1))) != 0)
|
nonzero = (~nonzero) & GET_MODE_MASK (mode);
|
nonzero = (~nonzero) & GET_MODE_MASK (mode);
|
|
|
return (nonzero == 0 ? bitwidth : bitwidth - floor_log2 (nonzero) - 1);
|
return (nonzero == 0 ? bitwidth : bitwidth - floor_log2 (nonzero) - 1);
|
|
|
case SUBREG:
|
case SUBREG:
|
/* If this is a SUBREG for a promoted object that is sign-extended
|
/* If this is a SUBREG for a promoted object that is sign-extended
|
and we are looking at it in a wider mode, we know that at least the
|
and we are looking at it in a wider mode, we know that at least the
|
high-order bits are known to be sign bit copies. */
|
high-order bits are known to be sign bit copies. */
|
|
|
if (SUBREG_PROMOTED_VAR_P (x) && ! SUBREG_PROMOTED_UNSIGNED_P (x))
|
if (SUBREG_PROMOTED_VAR_P (x) && ! SUBREG_PROMOTED_UNSIGNED_P (x))
|
{
|
{
|
num0 = cached_num_sign_bit_copies (SUBREG_REG (x), mode,
|
num0 = cached_num_sign_bit_copies (SUBREG_REG (x), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
return MAX ((int) bitwidth
|
return MAX ((int) bitwidth
|
- (int) GET_MODE_BITSIZE (GET_MODE (x)) + 1,
|
- (int) GET_MODE_BITSIZE (GET_MODE (x)) + 1,
|
num0);
|
num0);
|
}
|
}
|
|
|
/* For a smaller object, just ignore the high bits. */
|
/* For a smaller object, just ignore the high bits. */
|
if (bitwidth <= GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x))))
|
if (bitwidth <= GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x))))
|
{
|
{
|
num0 = cached_num_sign_bit_copies (SUBREG_REG (x), VOIDmode,
|
num0 = cached_num_sign_bit_copies (SUBREG_REG (x), VOIDmode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
return MAX (1, (num0
|
return MAX (1, (num0
|
- (int) (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x)))
|
- (int) (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x)))
|
- bitwidth)));
|
- bitwidth)));
|
}
|
}
|
|
|
#ifdef WORD_REGISTER_OPERATIONS
|
#ifdef WORD_REGISTER_OPERATIONS
|
#ifdef LOAD_EXTEND_OP
|
#ifdef LOAD_EXTEND_OP
|
/* For paradoxical SUBREGs on machines where all register operations
|
/* For paradoxical SUBREGs on machines where all register operations
|
affect the entire register, just look inside. Note that we are
|
affect the entire register, just look inside. Note that we are
|
passing MODE to the recursive call, so the number of sign bit copies
|
passing MODE to the recursive call, so the number of sign bit copies
|
will remain relative to that mode, not the inner mode. */
|
will remain relative to that mode, not the inner mode. */
|
|
|
/* This works only if loads sign extend. Otherwise, if we get a
|
/* This works only if loads sign extend. Otherwise, if we get a
|
reload for the inner part, it may be loaded from the stack, and
|
reload for the inner part, it may be loaded from the stack, and
|
then we lose all sign bit copies that existed before the store
|
then we lose all sign bit copies that existed before the store
|
to the stack. */
|
to the stack. */
|
|
|
if ((GET_MODE_SIZE (GET_MODE (x))
|
if ((GET_MODE_SIZE (GET_MODE (x))
|
> GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
|
> GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
|
&& LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (x))) == SIGN_EXTEND
|
&& LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (x))) == SIGN_EXTEND
|
&& MEM_P (SUBREG_REG (x)))
|
&& MEM_P (SUBREG_REG (x)))
|
return cached_num_sign_bit_copies (SUBREG_REG (x), mode,
|
return cached_num_sign_bit_copies (SUBREG_REG (x), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
#endif
|
#endif
|
#endif
|
#endif
|
break;
|
break;
|
|
|
case SIGN_EXTRACT:
|
case SIGN_EXTRACT:
|
if (GET_CODE (XEXP (x, 1)) == CONST_INT)
|
if (GET_CODE (XEXP (x, 1)) == CONST_INT)
|
return MAX (1, (int) bitwidth - INTVAL (XEXP (x, 1)));
|
return MAX (1, (int) bitwidth - INTVAL (XEXP (x, 1)));
|
break;
|
break;
|
|
|
case SIGN_EXTEND:
|
case SIGN_EXTEND:
|
return (bitwidth - GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)))
|
return (bitwidth - GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)))
|
+ cached_num_sign_bit_copies (XEXP (x, 0), VOIDmode,
|
+ cached_num_sign_bit_copies (XEXP (x, 0), VOIDmode,
|
known_x, known_mode, known_ret));
|
known_x, known_mode, known_ret));
|
|
|
case TRUNCATE:
|
case TRUNCATE:
|
/* For a smaller object, just ignore the high bits. */
|
/* For a smaller object, just ignore the high bits. */
|
num0 = cached_num_sign_bit_copies (XEXP (x, 0), VOIDmode,
|
num0 = cached_num_sign_bit_copies (XEXP (x, 0), VOIDmode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
return MAX (1, (num0 - (int) (GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)))
|
return MAX (1, (num0 - (int) (GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)))
|
- bitwidth)));
|
- bitwidth)));
|
|
|
case NOT:
|
case NOT:
|
return cached_num_sign_bit_copies (XEXP (x, 0), mode,
|
return cached_num_sign_bit_copies (XEXP (x, 0), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
|
|
case ROTATE: case ROTATERT:
|
case ROTATE: case ROTATERT:
|
/* If we are rotating left by a number of bits less than the number
|
/* If we are rotating left by a number of bits less than the number
|
of sign bit copies, we can just subtract that amount from the
|
of sign bit copies, we can just subtract that amount from the
|
number. */
|
number. */
|
if (GET_CODE (XEXP (x, 1)) == CONST_INT
|
if (GET_CODE (XEXP (x, 1)) == CONST_INT
|
&& INTVAL (XEXP (x, 1)) >= 0
|
&& INTVAL (XEXP (x, 1)) >= 0
|
&& INTVAL (XEXP (x, 1)) < (int) bitwidth)
|
&& INTVAL (XEXP (x, 1)) < (int) bitwidth)
|
{
|
{
|
num0 = cached_num_sign_bit_copies (XEXP (x, 0), mode,
|
num0 = cached_num_sign_bit_copies (XEXP (x, 0), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
return MAX (1, num0 - (code == ROTATE ? INTVAL (XEXP (x, 1))
|
return MAX (1, num0 - (code == ROTATE ? INTVAL (XEXP (x, 1))
|
: (int) bitwidth - INTVAL (XEXP (x, 1))));
|
: (int) bitwidth - INTVAL (XEXP (x, 1))));
|
}
|
}
|
break;
|
break;
|
|
|
case NEG:
|
case NEG:
|
/* In general, this subtracts one sign bit copy. But if the value
|
/* In general, this subtracts one sign bit copy. But if the value
|
is known to be positive, the number of sign bit copies is the
|
is known to be positive, the number of sign bit copies is the
|
same as that of the input. Finally, if the input has just one bit
|
same as that of the input. Finally, if the input has just one bit
|
that might be nonzero, all the bits are copies of the sign bit. */
|
that might be nonzero, all the bits are copies of the sign bit. */
|
num0 = cached_num_sign_bit_copies (XEXP (x, 0), mode,
|
num0 = cached_num_sign_bit_copies (XEXP (x, 0), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
if (bitwidth > HOST_BITS_PER_WIDE_INT)
|
if (bitwidth > HOST_BITS_PER_WIDE_INT)
|
return num0 > 1 ? num0 - 1 : 1;
|
return num0 > 1 ? num0 - 1 : 1;
|
|
|
nonzero = nonzero_bits (XEXP (x, 0), mode);
|
nonzero = nonzero_bits (XEXP (x, 0), mode);
|
if (nonzero == 1)
|
if (nonzero == 1)
|
return bitwidth;
|
return bitwidth;
|
|
|
if (num0 > 1
|
if (num0 > 1
|
&& (((HOST_WIDE_INT) 1 << (bitwidth - 1)) & nonzero))
|
&& (((HOST_WIDE_INT) 1 << (bitwidth - 1)) & nonzero))
|
num0--;
|
num0--;
|
|
|
return num0;
|
return num0;
|
|
|
case IOR: case AND: case XOR:
|
case IOR: case AND: case XOR:
|
case SMIN: case SMAX: case UMIN: case UMAX:
|
case SMIN: case SMAX: case UMIN: case UMAX:
|
/* Logical operations will preserve the number of sign-bit copies.
|
/* Logical operations will preserve the number of sign-bit copies.
|
MIN and MAX operations always return one of the operands. */
|
MIN and MAX operations always return one of the operands. */
|
num0 = cached_num_sign_bit_copies (XEXP (x, 0), mode,
|
num0 = cached_num_sign_bit_copies (XEXP (x, 0), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
num1 = cached_num_sign_bit_copies (XEXP (x, 1), mode,
|
num1 = cached_num_sign_bit_copies (XEXP (x, 1), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
return MIN (num0, num1);
|
return MIN (num0, num1);
|
|
|
case PLUS: case MINUS:
|
case PLUS: case MINUS:
|
/* For addition and subtraction, we can have a 1-bit carry. However,
|
/* For addition and subtraction, we can have a 1-bit carry. However,
|
if we are subtracting 1 from a positive number, there will not
|
if we are subtracting 1 from a positive number, there will not
|
be such a carry. Furthermore, if the positive number is known to
|
be such a carry. Furthermore, if the positive number is known to
|
be 0 or 1, we know the result is either -1 or 0. */
|
be 0 or 1, we know the result is either -1 or 0. */
|
|
|
if (code == PLUS && XEXP (x, 1) == constm1_rtx
|
if (code == PLUS && XEXP (x, 1) == constm1_rtx
|
&& bitwidth <= HOST_BITS_PER_WIDE_INT)
|
&& bitwidth <= HOST_BITS_PER_WIDE_INT)
|
{
|
{
|
nonzero = nonzero_bits (XEXP (x, 0), mode);
|
nonzero = nonzero_bits (XEXP (x, 0), mode);
|
if ((((HOST_WIDE_INT) 1 << (bitwidth - 1)) & nonzero) == 0)
|
if ((((HOST_WIDE_INT) 1 << (bitwidth - 1)) & nonzero) == 0)
|
return (nonzero == 1 || nonzero == 0 ? bitwidth
|
return (nonzero == 1 || nonzero == 0 ? bitwidth
|
: bitwidth - floor_log2 (nonzero) - 1);
|
: bitwidth - floor_log2 (nonzero) - 1);
|
}
|
}
|
|
|
num0 = cached_num_sign_bit_copies (XEXP (x, 0), mode,
|
num0 = cached_num_sign_bit_copies (XEXP (x, 0), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
num1 = cached_num_sign_bit_copies (XEXP (x, 1), mode,
|
num1 = cached_num_sign_bit_copies (XEXP (x, 1), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
result = MAX (1, MIN (num0, num1) - 1);
|
result = MAX (1, MIN (num0, num1) - 1);
|
|
|
#ifdef POINTERS_EXTEND_UNSIGNED
|
#ifdef POINTERS_EXTEND_UNSIGNED
|
/* If pointers extend signed and this is an addition or subtraction
|
/* If pointers extend signed and this is an addition or subtraction
|
to a pointer in Pmode, all the bits above ptr_mode are known to be
|
to a pointer in Pmode, all the bits above ptr_mode are known to be
|
sign bit copies. */
|
sign bit copies. */
|
if (! POINTERS_EXTEND_UNSIGNED && GET_MODE (x) == Pmode
|
if (! POINTERS_EXTEND_UNSIGNED && GET_MODE (x) == Pmode
|
&& (code == PLUS || code == MINUS)
|
&& (code == PLUS || code == MINUS)
|
&& REG_P (XEXP (x, 0)) && REG_POINTER (XEXP (x, 0)))
|
&& REG_P (XEXP (x, 0)) && REG_POINTER (XEXP (x, 0)))
|
result = MAX ((int) (GET_MODE_BITSIZE (Pmode)
|
result = MAX ((int) (GET_MODE_BITSIZE (Pmode)
|
- GET_MODE_BITSIZE (ptr_mode) + 1),
|
- GET_MODE_BITSIZE (ptr_mode) + 1),
|
result);
|
result);
|
#endif
|
#endif
|
return result;
|
return result;
|
|
|
case MULT:
|
case MULT:
|
/* The number of bits of the product is the sum of the number of
|
/* The number of bits of the product is the sum of the number of
|
bits of both terms. However, unless one of the terms if known
|
bits of both terms. However, unless one of the terms if known
|
to be positive, we must allow for an additional bit since negating
|
to be positive, we must allow for an additional bit since negating
|
a negative number can remove one sign bit copy. */
|
a negative number can remove one sign bit copy. */
|
|
|
num0 = cached_num_sign_bit_copies (XEXP (x, 0), mode,
|
num0 = cached_num_sign_bit_copies (XEXP (x, 0), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
num1 = cached_num_sign_bit_copies (XEXP (x, 1), mode,
|
num1 = cached_num_sign_bit_copies (XEXP (x, 1), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
|
|
result = bitwidth - (bitwidth - num0) - (bitwidth - num1);
|
result = bitwidth - (bitwidth - num0) - (bitwidth - num1);
|
if (result > 0
|
if (result > 0
|
&& (bitwidth > HOST_BITS_PER_WIDE_INT
|
&& (bitwidth > HOST_BITS_PER_WIDE_INT
|
|| (((nonzero_bits (XEXP (x, 0), mode)
|
|| (((nonzero_bits (XEXP (x, 0), mode)
|
& ((HOST_WIDE_INT) 1 << (bitwidth - 1))) != 0)
|
& ((HOST_WIDE_INT) 1 << (bitwidth - 1))) != 0)
|
&& ((nonzero_bits (XEXP (x, 1), mode)
|
&& ((nonzero_bits (XEXP (x, 1), mode)
|
& ((HOST_WIDE_INT) 1 << (bitwidth - 1))) != 0))))
|
& ((HOST_WIDE_INT) 1 << (bitwidth - 1))) != 0))))
|
result--;
|
result--;
|
|
|
return MAX (1, result);
|
return MAX (1, result);
|
|
|
case UDIV:
|
case UDIV:
|
/* The result must be <= the first operand. If the first operand
|
/* The result must be <= the first operand. If the first operand
|
has the high bit set, we know nothing about the number of sign
|
has the high bit set, we know nothing about the number of sign
|
bit copies. */
|
bit copies. */
|
if (bitwidth > HOST_BITS_PER_WIDE_INT)
|
if (bitwidth > HOST_BITS_PER_WIDE_INT)
|
return 1;
|
return 1;
|
else if ((nonzero_bits (XEXP (x, 0), mode)
|
else if ((nonzero_bits (XEXP (x, 0), mode)
|
& ((HOST_WIDE_INT) 1 << (bitwidth - 1))) != 0)
|
& ((HOST_WIDE_INT) 1 << (bitwidth - 1))) != 0)
|
return 1;
|
return 1;
|
else
|
else
|
return cached_num_sign_bit_copies (XEXP (x, 0), mode,
|
return cached_num_sign_bit_copies (XEXP (x, 0), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
|
|
case UMOD:
|
case UMOD:
|
/* The result must be <= the second operand. */
|
/* The result must be <= the second operand. */
|
return cached_num_sign_bit_copies (XEXP (x, 1), mode,
|
return cached_num_sign_bit_copies (XEXP (x, 1), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
|
|
case DIV:
|
case DIV:
|
/* Similar to unsigned division, except that we have to worry about
|
/* Similar to unsigned division, except that we have to worry about
|
the case where the divisor is negative, in which case we have
|
the case where the divisor is negative, in which case we have
|
to add 1. */
|
to add 1. */
|
result = cached_num_sign_bit_copies (XEXP (x, 0), mode,
|
result = cached_num_sign_bit_copies (XEXP (x, 0), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
if (result > 1
|
if (result > 1
|
&& (bitwidth > HOST_BITS_PER_WIDE_INT
|
&& (bitwidth > HOST_BITS_PER_WIDE_INT
|
|| (nonzero_bits (XEXP (x, 1), mode)
|
|| (nonzero_bits (XEXP (x, 1), mode)
|
& ((HOST_WIDE_INT) 1 << (bitwidth - 1))) != 0))
|
& ((HOST_WIDE_INT) 1 << (bitwidth - 1))) != 0))
|
result--;
|
result--;
|
|
|
return result;
|
return result;
|
|
|
case MOD:
|
case MOD:
|
result = cached_num_sign_bit_copies (XEXP (x, 1), mode,
|
result = cached_num_sign_bit_copies (XEXP (x, 1), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
if (result > 1
|
if (result > 1
|
&& (bitwidth > HOST_BITS_PER_WIDE_INT
|
&& (bitwidth > HOST_BITS_PER_WIDE_INT
|
|| (nonzero_bits (XEXP (x, 1), mode)
|
|| (nonzero_bits (XEXP (x, 1), mode)
|
& ((HOST_WIDE_INT) 1 << (bitwidth - 1))) != 0))
|
& ((HOST_WIDE_INT) 1 << (bitwidth - 1))) != 0))
|
result--;
|
result--;
|
|
|
return result;
|
return result;
|
|
|
case ASHIFTRT:
|
case ASHIFTRT:
|
/* Shifts by a constant add to the number of bits equal to the
|
/* Shifts by a constant add to the number of bits equal to the
|
sign bit. */
|
sign bit. */
|
num0 = cached_num_sign_bit_copies (XEXP (x, 0), mode,
|
num0 = cached_num_sign_bit_copies (XEXP (x, 0), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
if (GET_CODE (XEXP (x, 1)) == CONST_INT
|
if (GET_CODE (XEXP (x, 1)) == CONST_INT
|
&& INTVAL (XEXP (x, 1)) > 0)
|
&& INTVAL (XEXP (x, 1)) > 0)
|
num0 = MIN ((int) bitwidth, num0 + INTVAL (XEXP (x, 1)));
|
num0 = MIN ((int) bitwidth, num0 + INTVAL (XEXP (x, 1)));
|
|
|
return num0;
|
return num0;
|
|
|
case ASHIFT:
|
case ASHIFT:
|
/* Left shifts destroy copies. */
|
/* Left shifts destroy copies. */
|
if (GET_CODE (XEXP (x, 1)) != CONST_INT
|
if (GET_CODE (XEXP (x, 1)) != CONST_INT
|
|| INTVAL (XEXP (x, 1)) < 0
|
|| INTVAL (XEXP (x, 1)) < 0
|
|| INTVAL (XEXP (x, 1)) >= (int) bitwidth)
|
|| INTVAL (XEXP (x, 1)) >= (int) bitwidth)
|
return 1;
|
return 1;
|
|
|
num0 = cached_num_sign_bit_copies (XEXP (x, 0), mode,
|
num0 = cached_num_sign_bit_copies (XEXP (x, 0), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
return MAX (1, num0 - INTVAL (XEXP (x, 1)));
|
return MAX (1, num0 - INTVAL (XEXP (x, 1)));
|
|
|
case IF_THEN_ELSE:
|
case IF_THEN_ELSE:
|
num0 = cached_num_sign_bit_copies (XEXP (x, 1), mode,
|
num0 = cached_num_sign_bit_copies (XEXP (x, 1), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
num1 = cached_num_sign_bit_copies (XEXP (x, 2), mode,
|
num1 = cached_num_sign_bit_copies (XEXP (x, 2), mode,
|
known_x, known_mode, known_ret);
|
known_x, known_mode, known_ret);
|
return MIN (num0, num1);
|
return MIN (num0, num1);
|
|
|
case EQ: case NE: case GE: case GT: case LE: case LT:
|
case EQ: case NE: case GE: case GT: case LE: case LT:
|
case UNEQ: case LTGT: case UNGE: case UNGT: case UNLE: case UNLT:
|
case UNEQ: case LTGT: case UNGE: case UNGT: case UNLE: case UNLT:
|
case GEU: case GTU: case LEU: case LTU:
|
case GEU: case GTU: case LEU: case LTU:
|
case UNORDERED: case ORDERED:
|
case UNORDERED: case ORDERED:
|
/* If the constant is negative, take its 1's complement and remask.
|
/* If the constant is negative, take its 1's complement and remask.
|
Then see how many zero bits we have. */
|
Then see how many zero bits we have. */
|
nonzero = STORE_FLAG_VALUE;
|
nonzero = STORE_FLAG_VALUE;
|
if (bitwidth <= HOST_BITS_PER_WIDE_INT
|
if (bitwidth <= HOST_BITS_PER_WIDE_INT
|
&& (nonzero & ((HOST_WIDE_INT) 1 << (bitwidth - 1))) != 0)
|
&& (nonzero & ((HOST_WIDE_INT) 1 << (bitwidth - 1))) != 0)
|
nonzero = (~nonzero) & GET_MODE_MASK (mode);
|
nonzero = (~nonzero) & GET_MODE_MASK (mode);
|
|
|
return (nonzero == 0 ? bitwidth : bitwidth - floor_log2 (nonzero) - 1);
|
return (nonzero == 0 ? bitwidth : bitwidth - floor_log2 (nonzero) - 1);
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
/* If we haven't been able to figure it out by one of the above rules,
|
/* If we haven't been able to figure it out by one of the above rules,
|
see if some of the high-order bits are known to be zero. If so,
|
see if some of the high-order bits are known to be zero. If so,
|
count those bits and return one less than that amount. If we can't
|
count those bits and return one less than that amount. If we can't
|
safely compute the mask for this mode, always return BITWIDTH. */
|
safely compute the mask for this mode, always return BITWIDTH. */
|
|
|
bitwidth = GET_MODE_BITSIZE (mode);
|
bitwidth = GET_MODE_BITSIZE (mode);
|
if (bitwidth > HOST_BITS_PER_WIDE_INT)
|
if (bitwidth > HOST_BITS_PER_WIDE_INT)
|
return 1;
|
return 1;
|
|
|
nonzero = nonzero_bits (x, mode);
|
nonzero = nonzero_bits (x, mode);
|
return nonzero & ((HOST_WIDE_INT) 1 << (bitwidth - 1))
|
return nonzero & ((HOST_WIDE_INT) 1 << (bitwidth - 1))
|
? 1 : bitwidth - floor_log2 (nonzero) - 1;
|
? 1 : bitwidth - floor_log2 (nonzero) - 1;
|
}
|
}
|
|
|
/* Calculate the rtx_cost of a single instruction. A return value of
|
/* Calculate the rtx_cost of a single instruction. A return value of
|
zero indicates an instruction pattern without a known cost. */
|
zero indicates an instruction pattern without a known cost. */
|
|
|
int
|
int
|
insn_rtx_cost (rtx pat)
|
insn_rtx_cost (rtx pat)
|
{
|
{
|
int i, cost;
|
int i, cost;
|
rtx set;
|
rtx set;
|
|
|
/* Extract the single set rtx from the instruction pattern.
|
/* Extract the single set rtx from the instruction pattern.
|
We can't use single_set since we only have the pattern. */
|
We can't use single_set since we only have the pattern. */
|
if (GET_CODE (pat) == SET)
|
if (GET_CODE (pat) == SET)
|
set = pat;
|
set = pat;
|
else if (GET_CODE (pat) == PARALLEL)
|
else if (GET_CODE (pat) == PARALLEL)
|
{
|
{
|
set = NULL_RTX;
|
set = NULL_RTX;
|
for (i = 0; i < XVECLEN (pat, 0); i++)
|
for (i = 0; i < XVECLEN (pat, 0); i++)
|
{
|
{
|
rtx x = XVECEXP (pat, 0, i);
|
rtx x = XVECEXP (pat, 0, i);
|
if (GET_CODE (x) == SET)
|
if (GET_CODE (x) == SET)
|
{
|
{
|
if (set)
|
if (set)
|
return 0;
|
return 0;
|
set = x;
|
set = x;
|
}
|
}
|
}
|
}
|
if (!set)
|
if (!set)
|
return 0;
|
return 0;
|
}
|
}
|
else
|
else
|
return 0;
|
return 0;
|
|
|
cost = rtx_cost (SET_SRC (set), SET);
|
cost = rtx_cost (SET_SRC (set), SET);
|
return cost > 0 ? cost : COSTS_N_INSNS (1);
|
return cost > 0 ? cost : COSTS_N_INSNS (1);
|
}
|
}
|
|
|
/* Given an insn INSN and condition COND, return the condition in a
|
/* Given an insn INSN and condition COND, return the condition in a
|
canonical form to simplify testing by callers. Specifically:
|
canonical form to simplify testing by callers. Specifically:
|
|
|
(1) The code will always be a comparison operation (EQ, NE, GT, etc.).
|
(1) The code will always be a comparison operation (EQ, NE, GT, etc.).
|
(2) Both operands will be machine operands; (cc0) will have been replaced.
|
(2) Both operands will be machine operands; (cc0) will have been replaced.
|
(3) If an operand is a constant, it will be the second operand.
|
(3) If an operand is a constant, it will be the second operand.
|
(4) (LE x const) will be replaced with (LT x <const+1>) and similarly
|
(4) (LE x const) will be replaced with (LT x <const+1>) and similarly
|
for GE, GEU, and LEU.
|
for GE, GEU, and LEU.
|
|
|
If the condition cannot be understood, or is an inequality floating-point
|
If the condition cannot be understood, or is an inequality floating-point
|
comparison which needs to be reversed, 0 will be returned.
|
comparison which needs to be reversed, 0 will be returned.
|
|
|
If REVERSE is nonzero, then reverse the condition prior to canonizing it.
|
If REVERSE is nonzero, then reverse the condition prior to canonizing it.
|
|
|
If EARLIEST is nonzero, it is a pointer to a place where the earliest
|
If EARLIEST is nonzero, it is a pointer to a place where the earliest
|
insn used in locating the condition was found. If a replacement test
|
insn used in locating the condition was found. If a replacement test
|
of the condition is desired, it should be placed in front of that
|
of the condition is desired, it should be placed in front of that
|
insn and we will be sure that the inputs are still valid.
|
insn and we will be sure that the inputs are still valid.
|
|
|
If WANT_REG is nonzero, we wish the condition to be relative to that
|
If WANT_REG is nonzero, we wish the condition to be relative to that
|
register, if possible. Therefore, do not canonicalize the condition
|
register, if possible. Therefore, do not canonicalize the condition
|
further. If ALLOW_CC_MODE is nonzero, allow the condition returned
|
further. If ALLOW_CC_MODE is nonzero, allow the condition returned
|
to be a compare to a CC mode register.
|
to be a compare to a CC mode register.
|
|
|
If VALID_AT_INSN_P, the condition must be valid at both *EARLIEST
|
If VALID_AT_INSN_P, the condition must be valid at both *EARLIEST
|
and at INSN. */
|
and at INSN. */
|
|
|
rtx
|
rtx
|
canonicalize_condition (rtx insn, rtx cond, int reverse, rtx *earliest,
|
canonicalize_condition (rtx insn, rtx cond, int reverse, rtx *earliest,
|
rtx want_reg, int allow_cc_mode, int valid_at_insn_p)
|
rtx want_reg, int allow_cc_mode, int valid_at_insn_p)
|
{
|
{
|
enum rtx_code code;
|
enum rtx_code code;
|
rtx prev = insn;
|
rtx prev = insn;
|
rtx set;
|
rtx set;
|
rtx tem;
|
rtx tem;
|
rtx op0, op1;
|
rtx op0, op1;
|
int reverse_code = 0;
|
int reverse_code = 0;
|
enum machine_mode mode;
|
enum machine_mode mode;
|
basic_block bb = BLOCK_FOR_INSN (insn);
|
basic_block bb = BLOCK_FOR_INSN (insn);
|
|
|
code = GET_CODE (cond);
|
code = GET_CODE (cond);
|
mode = GET_MODE (cond);
|
mode = GET_MODE (cond);
|
op0 = XEXP (cond, 0);
|
op0 = XEXP (cond, 0);
|
op1 = XEXP (cond, 1);
|
op1 = XEXP (cond, 1);
|
|
|
if (reverse)
|
if (reverse)
|
code = reversed_comparison_code (cond, insn);
|
code = reversed_comparison_code (cond, insn);
|
if (code == UNKNOWN)
|
if (code == UNKNOWN)
|
return 0;
|
return 0;
|
|
|
if (earliest)
|
if (earliest)
|
*earliest = insn;
|
*earliest = insn;
|
|
|
/* If we are comparing a register with zero, see if the register is set
|
/* If we are comparing a register with zero, see if the register is set
|
in the previous insn to a COMPARE or a comparison operation. Perform
|
in the previous insn to a COMPARE or a comparison operation. Perform
|
the same tests as a function of STORE_FLAG_VALUE as find_comparison_args
|
the same tests as a function of STORE_FLAG_VALUE as find_comparison_args
|
in cse.c */
|
in cse.c */
|
|
|
while ((GET_RTX_CLASS (code) == RTX_COMPARE
|
while ((GET_RTX_CLASS (code) == RTX_COMPARE
|
|| GET_RTX_CLASS (code) == RTX_COMM_COMPARE)
|
|| GET_RTX_CLASS (code) == RTX_COMM_COMPARE)
|
&& op1 == CONST0_RTX (GET_MODE (op0))
|
&& op1 == CONST0_RTX (GET_MODE (op0))
|
&& op0 != want_reg)
|
&& op0 != want_reg)
|
{
|
{
|
/* Set nonzero when we find something of interest. */
|
/* Set nonzero when we find something of interest. */
|
rtx x = 0;
|
rtx x = 0;
|
|
|
#ifdef HAVE_cc0
|
#ifdef HAVE_cc0
|
/* If comparison with cc0, import actual comparison from compare
|
/* If comparison with cc0, import actual comparison from compare
|
insn. */
|
insn. */
|
if (op0 == cc0_rtx)
|
if (op0 == cc0_rtx)
|
{
|
{
|
if ((prev = prev_nonnote_insn (prev)) == 0
|
if ((prev = prev_nonnote_insn (prev)) == 0
|
|| !NONJUMP_INSN_P (prev)
|
|| !NONJUMP_INSN_P (prev)
|
|| (set = single_set (prev)) == 0
|
|| (set = single_set (prev)) == 0
|
|| SET_DEST (set) != cc0_rtx)
|
|| SET_DEST (set) != cc0_rtx)
|
return 0;
|
return 0;
|
|
|
op0 = SET_SRC (set);
|
op0 = SET_SRC (set);
|
op1 = CONST0_RTX (GET_MODE (op0));
|
op1 = CONST0_RTX (GET_MODE (op0));
|
if (earliest)
|
if (earliest)
|
*earliest = prev;
|
*earliest = prev;
|
}
|
}
|
#endif
|
#endif
|
|
|
/* If this is a COMPARE, pick up the two things being compared. */
|
/* If this is a COMPARE, pick up the two things being compared. */
|
if (GET_CODE (op0) == COMPARE)
|
if (GET_CODE (op0) == COMPARE)
|
{
|
{
|
op1 = XEXP (op0, 1);
|
op1 = XEXP (op0, 1);
|
op0 = XEXP (op0, 0);
|
op0 = XEXP (op0, 0);
|
continue;
|
continue;
|
}
|
}
|
else if (!REG_P (op0))
|
else if (!REG_P (op0))
|
break;
|
break;
|
|
|
/* Go back to the previous insn. Stop if it is not an INSN. We also
|
/* Go back to the previous insn. Stop if it is not an INSN. We also
|
stop if it isn't a single set or if it has a REG_INC note because
|
stop if it isn't a single set or if it has a REG_INC note because
|
we don't want to bother dealing with it. */
|
we don't want to bother dealing with it. */
|
|
|
if ((prev = prev_nonnote_insn (prev)) == 0
|
if ((prev = prev_nonnote_insn (prev)) == 0
|
|| !NONJUMP_INSN_P (prev)
|
|| !NONJUMP_INSN_P (prev)
|
|| FIND_REG_INC_NOTE (prev, NULL_RTX)
|
|| FIND_REG_INC_NOTE (prev, NULL_RTX)
|
/* In cfglayout mode, there do not have to be labels at the
|
/* In cfglayout mode, there do not have to be labels at the
|
beginning of a block, or jumps at the end, so the previous
|
beginning of a block, or jumps at the end, so the previous
|
conditions would not stop us when we reach bb boundary. */
|
conditions would not stop us when we reach bb boundary. */
|
|| BLOCK_FOR_INSN (prev) != bb)
|
|| BLOCK_FOR_INSN (prev) != bb)
|
break;
|
break;
|
|
|
set = set_of (op0, prev);
|
set = set_of (op0, prev);
|
|
|
if (set
|
if (set
|
&& (GET_CODE (set) != SET
|
&& (GET_CODE (set) != SET
|
|| !rtx_equal_p (SET_DEST (set), op0)))
|
|| !rtx_equal_p (SET_DEST (set), op0)))
|
break;
|
break;
|
|
|
/* If this is setting OP0, get what it sets it to if it looks
|
/* If this is setting OP0, get what it sets it to if it looks
|
relevant. */
|
relevant. */
|
if (set)
|
if (set)
|
{
|
{
|
enum machine_mode inner_mode = GET_MODE (SET_DEST (set));
|
enum machine_mode inner_mode = GET_MODE (SET_DEST (set));
|
#ifdef FLOAT_STORE_FLAG_VALUE
|
#ifdef FLOAT_STORE_FLAG_VALUE
|
REAL_VALUE_TYPE fsfv;
|
REAL_VALUE_TYPE fsfv;
|
#endif
|
#endif
|
|
|
/* ??? We may not combine comparisons done in a CCmode with
|
/* ??? We may not combine comparisons done in a CCmode with
|
comparisons not done in a CCmode. This is to aid targets
|
comparisons not done in a CCmode. This is to aid targets
|
like Alpha that have an IEEE compliant EQ instruction, and
|
like Alpha that have an IEEE compliant EQ instruction, and
|
a non-IEEE compliant BEQ instruction. The use of CCmode is
|
a non-IEEE compliant BEQ instruction. The use of CCmode is
|
actually artificial, simply to prevent the combination, but
|
actually artificial, simply to prevent the combination, but
|
should not affect other platforms.
|
should not affect other platforms.
|
|
|
However, we must allow VOIDmode comparisons to match either
|
However, we must allow VOIDmode comparisons to match either
|
CCmode or non-CCmode comparison, because some ports have
|
CCmode or non-CCmode comparison, because some ports have
|
modeless comparisons inside branch patterns.
|
modeless comparisons inside branch patterns.
|
|
|
??? This mode check should perhaps look more like the mode check
|
??? This mode check should perhaps look more like the mode check
|
in simplify_comparison in combine. */
|
in simplify_comparison in combine. */
|
|
|
if ((GET_CODE (SET_SRC (set)) == COMPARE
|
if ((GET_CODE (SET_SRC (set)) == COMPARE
|
|| (((code == NE
|
|| (((code == NE
|
|| (code == LT
|
|| (code == LT
|
&& GET_MODE_CLASS (inner_mode) == MODE_INT
|
&& GET_MODE_CLASS (inner_mode) == MODE_INT
|
&& (GET_MODE_BITSIZE (inner_mode)
|
&& (GET_MODE_BITSIZE (inner_mode)
|
<= HOST_BITS_PER_WIDE_INT)
|
<= HOST_BITS_PER_WIDE_INT)
|
&& (STORE_FLAG_VALUE
|
&& (STORE_FLAG_VALUE
|
& ((HOST_WIDE_INT) 1
|
& ((HOST_WIDE_INT) 1
|
<< (GET_MODE_BITSIZE (inner_mode) - 1))))
|
<< (GET_MODE_BITSIZE (inner_mode) - 1))))
|
#ifdef FLOAT_STORE_FLAG_VALUE
|
#ifdef FLOAT_STORE_FLAG_VALUE
|
|| (code == LT
|
|| (code == LT
|
&& SCALAR_FLOAT_MODE_P (inner_mode)
|
&& SCALAR_FLOAT_MODE_P (inner_mode)
|
&& (fsfv = FLOAT_STORE_FLAG_VALUE (inner_mode),
|
&& (fsfv = FLOAT_STORE_FLAG_VALUE (inner_mode),
|
REAL_VALUE_NEGATIVE (fsfv)))
|
REAL_VALUE_NEGATIVE (fsfv)))
|
#endif
|
#endif
|
))
|
))
|
&& COMPARISON_P (SET_SRC (set))))
|
&& COMPARISON_P (SET_SRC (set))))
|
&& (((GET_MODE_CLASS (mode) == MODE_CC)
|
&& (((GET_MODE_CLASS (mode) == MODE_CC)
|
== (GET_MODE_CLASS (inner_mode) == MODE_CC))
|
== (GET_MODE_CLASS (inner_mode) == MODE_CC))
|
|| mode == VOIDmode || inner_mode == VOIDmode))
|
|| mode == VOIDmode || inner_mode == VOIDmode))
|
x = SET_SRC (set);
|
x = SET_SRC (set);
|
else if (((code == EQ
|
else if (((code == EQ
|
|| (code == GE
|
|| (code == GE
|
&& (GET_MODE_BITSIZE (inner_mode)
|
&& (GET_MODE_BITSIZE (inner_mode)
|
<= HOST_BITS_PER_WIDE_INT)
|
<= HOST_BITS_PER_WIDE_INT)
|
&& GET_MODE_CLASS (inner_mode) == MODE_INT
|
&& GET_MODE_CLASS (inner_mode) == MODE_INT
|
&& (STORE_FLAG_VALUE
|
&& (STORE_FLAG_VALUE
|
& ((HOST_WIDE_INT) 1
|
& ((HOST_WIDE_INT) 1
|
<< (GET_MODE_BITSIZE (inner_mode) - 1))))
|
<< (GET_MODE_BITSIZE (inner_mode) - 1))))
|
#ifdef FLOAT_STORE_FLAG_VALUE
|
#ifdef FLOAT_STORE_FLAG_VALUE
|
|| (code == GE
|
|| (code == GE
|
&& SCALAR_FLOAT_MODE_P (inner_mode)
|
&& SCALAR_FLOAT_MODE_P (inner_mode)
|
&& (fsfv = FLOAT_STORE_FLAG_VALUE (inner_mode),
|
&& (fsfv = FLOAT_STORE_FLAG_VALUE (inner_mode),
|
REAL_VALUE_NEGATIVE (fsfv)))
|
REAL_VALUE_NEGATIVE (fsfv)))
|
#endif
|
#endif
|
))
|
))
|
&& COMPARISON_P (SET_SRC (set))
|
&& COMPARISON_P (SET_SRC (set))
|
&& (((GET_MODE_CLASS (mode) == MODE_CC)
|
&& (((GET_MODE_CLASS (mode) == MODE_CC)
|
== (GET_MODE_CLASS (inner_mode) == MODE_CC))
|
== (GET_MODE_CLASS (inner_mode) == MODE_CC))
|
|| mode == VOIDmode || inner_mode == VOIDmode))
|
|| mode == VOIDmode || inner_mode == VOIDmode))
|
|
|
{
|
{
|
reverse_code = 1;
|
reverse_code = 1;
|
x = SET_SRC (set);
|
x = SET_SRC (set);
|
}
|
}
|
else
|
else
|
break;
|
break;
|
}
|
}
|
|
|
else if (reg_set_p (op0, prev))
|
else if (reg_set_p (op0, prev))
|
/* If this sets OP0, but not directly, we have to give up. */
|
/* If this sets OP0, but not directly, we have to give up. */
|
break;
|
break;
|
|
|
if (x)
|
if (x)
|
{
|
{
|
/* If the caller is expecting the condition to be valid at INSN,
|
/* If the caller is expecting the condition to be valid at INSN,
|
make sure X doesn't change before INSN. */
|
make sure X doesn't change before INSN. */
|
if (valid_at_insn_p)
|
if (valid_at_insn_p)
|
if (modified_in_p (x, prev) || modified_between_p (x, prev, insn))
|
if (modified_in_p (x, prev) || modified_between_p (x, prev, insn))
|
break;
|
break;
|
if (COMPARISON_P (x))
|
if (COMPARISON_P (x))
|
code = GET_CODE (x);
|
code = GET_CODE (x);
|
if (reverse_code)
|
if (reverse_code)
|
{
|
{
|
code = reversed_comparison_code (x, prev);
|
code = reversed_comparison_code (x, prev);
|
if (code == UNKNOWN)
|
if (code == UNKNOWN)
|
return 0;
|
return 0;
|
reverse_code = 0;
|
reverse_code = 0;
|
}
|
}
|
|
|
op0 = XEXP (x, 0), op1 = XEXP (x, 1);
|
op0 = XEXP (x, 0), op1 = XEXP (x, 1);
|
if (earliest)
|
if (earliest)
|
*earliest = prev;
|
*earliest = prev;
|
}
|
}
|
}
|
}
|
|
|
/* If constant is first, put it last. */
|
/* If constant is first, put it last. */
|
if (CONSTANT_P (op0))
|
if (CONSTANT_P (op0))
|
code = swap_condition (code), tem = op0, op0 = op1, op1 = tem;
|
code = swap_condition (code), tem = op0, op0 = op1, op1 = tem;
|
|
|
/* If OP0 is the result of a comparison, we weren't able to find what
|
/* If OP0 is the result of a comparison, we weren't able to find what
|
was really being compared, so fail. */
|
was really being compared, so fail. */
|
if (!allow_cc_mode
|
if (!allow_cc_mode
|
&& GET_MODE_CLASS (GET_MODE (op0)) == MODE_CC)
|
&& GET_MODE_CLASS (GET_MODE (op0)) == MODE_CC)
|
return 0;
|
return 0;
|
|
|
/* Canonicalize any ordered comparison with integers involving equality
|
/* Canonicalize any ordered comparison with integers involving equality
|
if we can do computations in the relevant mode and we do not
|
if we can do computations in the relevant mode and we do not
|
overflow. */
|
overflow. */
|
|
|
if (GET_MODE_CLASS (GET_MODE (op0)) != MODE_CC
|
if (GET_MODE_CLASS (GET_MODE (op0)) != MODE_CC
|
&& GET_CODE (op1) == CONST_INT
|
&& GET_CODE (op1) == CONST_INT
|
&& GET_MODE (op0) != VOIDmode
|
&& GET_MODE (op0) != VOIDmode
|
&& GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT)
|
&& GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT)
|
{
|
{
|
HOST_WIDE_INT const_val = INTVAL (op1);
|
HOST_WIDE_INT const_val = INTVAL (op1);
|
unsigned HOST_WIDE_INT uconst_val = const_val;
|
unsigned HOST_WIDE_INT uconst_val = const_val;
|
unsigned HOST_WIDE_INT max_val
|
unsigned HOST_WIDE_INT max_val
|
= (unsigned HOST_WIDE_INT) GET_MODE_MASK (GET_MODE (op0));
|
= (unsigned HOST_WIDE_INT) GET_MODE_MASK (GET_MODE (op0));
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case LE:
|
case LE:
|
if ((unsigned HOST_WIDE_INT) const_val != max_val >> 1)
|
if ((unsigned HOST_WIDE_INT) const_val != max_val >> 1)
|
code = LT, op1 = gen_int_mode (const_val + 1, GET_MODE (op0));
|
code = LT, op1 = gen_int_mode (const_val + 1, GET_MODE (op0));
|
break;
|
break;
|
|
|
/* When cross-compiling, const_val might be sign-extended from
|
/* When cross-compiling, const_val might be sign-extended from
|
BITS_PER_WORD to HOST_BITS_PER_WIDE_INT */
|
BITS_PER_WORD to HOST_BITS_PER_WIDE_INT */
|
case GE:
|
case GE:
|
if ((HOST_WIDE_INT) (const_val & max_val)
|
if ((HOST_WIDE_INT) (const_val & max_val)
|
!= (((HOST_WIDE_INT) 1
|
!= (((HOST_WIDE_INT) 1
|
<< (GET_MODE_BITSIZE (GET_MODE (op0)) - 1))))
|
<< (GET_MODE_BITSIZE (GET_MODE (op0)) - 1))))
|
code = GT, op1 = gen_int_mode (const_val - 1, GET_MODE (op0));
|
code = GT, op1 = gen_int_mode (const_val - 1, GET_MODE (op0));
|
break;
|
break;
|
|
|
case LEU:
|
case LEU:
|
if (uconst_val < max_val)
|
if (uconst_val < max_val)
|
code = LTU, op1 = gen_int_mode (uconst_val + 1, GET_MODE (op0));
|
code = LTU, op1 = gen_int_mode (uconst_val + 1, GET_MODE (op0));
|
break;
|
break;
|
|
|
case GEU:
|
case GEU:
|
if (uconst_val != 0)
|
if (uconst_val != 0)
|
code = GTU, op1 = gen_int_mode (uconst_val - 1, GET_MODE (op0));
|
code = GTU, op1 = gen_int_mode (uconst_val - 1, GET_MODE (op0));
|
break;
|
break;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
/* Never return CC0; return zero instead. */
|
/* Never return CC0; return zero instead. */
|
if (CC0_P (op0))
|
if (CC0_P (op0))
|
return 0;
|
return 0;
|
|
|
return gen_rtx_fmt_ee (code, VOIDmode, op0, op1);
|
return gen_rtx_fmt_ee (code, VOIDmode, op0, op1);
|
}
|
}
|
|
|
/* Given a jump insn JUMP, return the condition that will cause it to branch
|
/* Given a jump insn JUMP, return the condition that will cause it to branch
|
to its JUMP_LABEL. If the condition cannot be understood, or is an
|
to its JUMP_LABEL. If the condition cannot be understood, or is an
|
inequality floating-point comparison which needs to be reversed, 0 will
|
inequality floating-point comparison which needs to be reversed, 0 will
|
be returned.
|
be returned.
|
|
|
If EARLIEST is nonzero, it is a pointer to a place where the earliest
|
If EARLIEST is nonzero, it is a pointer to a place where the earliest
|
insn used in locating the condition was found. If a replacement test
|
insn used in locating the condition was found. If a replacement test
|
of the condition is desired, it should be placed in front of that
|
of the condition is desired, it should be placed in front of that
|
insn and we will be sure that the inputs are still valid. If EARLIEST
|
insn and we will be sure that the inputs are still valid. If EARLIEST
|
is null, the returned condition will be valid at INSN.
|
is null, the returned condition will be valid at INSN.
|
|
|
If ALLOW_CC_MODE is nonzero, allow the condition returned to be a
|
If ALLOW_CC_MODE is nonzero, allow the condition returned to be a
|
compare CC mode register.
|
compare CC mode register.
|
|
|
VALID_AT_INSN_P is the same as for canonicalize_condition. */
|
VALID_AT_INSN_P is the same as for canonicalize_condition. */
|
|
|
rtx
|
rtx
|
get_condition (rtx jump, rtx *earliest, int allow_cc_mode, int valid_at_insn_p)
|
get_condition (rtx jump, rtx *earliest, int allow_cc_mode, int valid_at_insn_p)
|
{
|
{
|
rtx cond;
|
rtx cond;
|
int reverse;
|
int reverse;
|
rtx set;
|
rtx set;
|
|
|
/* If this is not a standard conditional jump, we can't parse it. */
|
/* If this is not a standard conditional jump, we can't parse it. */
|
if (!JUMP_P (jump)
|
if (!JUMP_P (jump)
|
|| ! any_condjump_p (jump))
|
|| ! any_condjump_p (jump))
|
return 0;
|
return 0;
|
set = pc_set (jump);
|
set = pc_set (jump);
|
|
|
cond = XEXP (SET_SRC (set), 0);
|
cond = XEXP (SET_SRC (set), 0);
|
|
|
/* If this branches to JUMP_LABEL when the condition is false, reverse
|
/* If this branches to JUMP_LABEL when the condition is false, reverse
|
the condition. */
|
the condition. */
|
reverse
|
reverse
|
= GET_CODE (XEXP (SET_SRC (set), 2)) == LABEL_REF
|
= GET_CODE (XEXP (SET_SRC (set), 2)) == LABEL_REF
|
&& XEXP (XEXP (SET_SRC (set), 2), 0) == JUMP_LABEL (jump);
|
&& XEXP (XEXP (SET_SRC (set), 2), 0) == JUMP_LABEL (jump);
|
|
|
return canonicalize_condition (jump, cond, reverse, earliest, NULL_RTX,
|
return canonicalize_condition (jump, cond, reverse, earliest, NULL_RTX,
|
allow_cc_mode, valid_at_insn_p);
|
allow_cc_mode, valid_at_insn_p);
|
}
|
}
|
|
|
/* Initialize the table NUM_SIGN_BIT_COPIES_IN_REP based on
|
/* Initialize the table NUM_SIGN_BIT_COPIES_IN_REP based on
|
TARGET_MODE_REP_EXTENDED.
|
TARGET_MODE_REP_EXTENDED.
|
|
|
Note that we assume that the property of
|
Note that we assume that the property of
|
TARGET_MODE_REP_EXTENDED(B, C) is sticky to the integral modes
|
TARGET_MODE_REP_EXTENDED(B, C) is sticky to the integral modes
|
narrower than mode B. I.e., if A is a mode narrower than B then in
|
narrower than mode B. I.e., if A is a mode narrower than B then in
|
order to be able to operate on it in mode B, mode A needs to
|
order to be able to operate on it in mode B, mode A needs to
|
satisfy the requirements set by the representation of mode B. */
|
satisfy the requirements set by the representation of mode B. */
|
|
|
static void
|
static void
|
init_num_sign_bit_copies_in_rep (void)
|
init_num_sign_bit_copies_in_rep (void)
|
{
|
{
|
enum machine_mode mode, in_mode;
|
enum machine_mode mode, in_mode;
|
|
|
for (in_mode = GET_CLASS_NARROWEST_MODE (MODE_INT); in_mode != VOIDmode;
|
for (in_mode = GET_CLASS_NARROWEST_MODE (MODE_INT); in_mode != VOIDmode;
|
in_mode = GET_MODE_WIDER_MODE (mode))
|
in_mode = GET_MODE_WIDER_MODE (mode))
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != in_mode;
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != in_mode;
|
mode = GET_MODE_WIDER_MODE (mode))
|
mode = GET_MODE_WIDER_MODE (mode))
|
{
|
{
|
enum machine_mode i;
|
enum machine_mode i;
|
|
|
/* Currently, it is assumed that TARGET_MODE_REP_EXTENDED
|
/* Currently, it is assumed that TARGET_MODE_REP_EXTENDED
|
extends to the next widest mode. */
|
extends to the next widest mode. */
|
gcc_assert (targetm.mode_rep_extended (mode, in_mode) == UNKNOWN
|
gcc_assert (targetm.mode_rep_extended (mode, in_mode) == UNKNOWN
|
|| GET_MODE_WIDER_MODE (mode) == in_mode);
|
|| GET_MODE_WIDER_MODE (mode) == in_mode);
|
|
|
/* We are in in_mode. Count how many bits outside of mode
|
/* We are in in_mode. Count how many bits outside of mode
|
have to be copies of the sign-bit. */
|
have to be copies of the sign-bit. */
|
for (i = mode; i != in_mode; i = GET_MODE_WIDER_MODE (i))
|
for (i = mode; i != in_mode; i = GET_MODE_WIDER_MODE (i))
|
{
|
{
|
enum machine_mode wider = GET_MODE_WIDER_MODE (i);
|
enum machine_mode wider = GET_MODE_WIDER_MODE (i);
|
|
|
if (targetm.mode_rep_extended (i, wider) == SIGN_EXTEND
|
if (targetm.mode_rep_extended (i, wider) == SIGN_EXTEND
|
/* We can only check sign-bit copies starting from the
|
/* We can only check sign-bit copies starting from the
|
top-bit. In order to be able to check the bits we
|
top-bit. In order to be able to check the bits we
|
have already seen we pretend that subsequent bits
|
have already seen we pretend that subsequent bits
|
have to be sign-bit copies too. */
|
have to be sign-bit copies too. */
|
|| num_sign_bit_copies_in_rep [in_mode][mode])
|
|| num_sign_bit_copies_in_rep [in_mode][mode])
|
num_sign_bit_copies_in_rep [in_mode][mode]
|
num_sign_bit_copies_in_rep [in_mode][mode]
|
+= GET_MODE_BITSIZE (wider) - GET_MODE_BITSIZE (i);
|
+= GET_MODE_BITSIZE (wider) - GET_MODE_BITSIZE (i);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Suppose that truncation from the machine mode of X to MODE is not a
|
/* Suppose that truncation from the machine mode of X to MODE is not a
|
no-op. See if there is anything special about X so that we can
|
no-op. See if there is anything special about X so that we can
|
assume it already contains a truncated value of MODE. */
|
assume it already contains a truncated value of MODE. */
|
|
|
bool
|
bool
|
truncated_to_mode (enum machine_mode mode, rtx x)
|
truncated_to_mode (enum machine_mode mode, rtx x)
|
{
|
{
|
/* This register has already been used in MODE without explicit
|
/* This register has already been used in MODE without explicit
|
truncation. */
|
truncation. */
|
if (REG_P (x) && rtl_hooks.reg_truncated_to_mode (mode, x))
|
if (REG_P (x) && rtl_hooks.reg_truncated_to_mode (mode, x))
|
return true;
|
return true;
|
|
|
/* See if we already satisfy the requirements of MODE. If yes we
|
/* See if we already satisfy the requirements of MODE. If yes we
|
can just switch to MODE. */
|
can just switch to MODE. */
|
if (num_sign_bit_copies_in_rep[GET_MODE (x)][mode]
|
if (num_sign_bit_copies_in_rep[GET_MODE (x)][mode]
|
&& (num_sign_bit_copies (x, GET_MODE (x))
|
&& (num_sign_bit_copies (x, GET_MODE (x))
|
>= num_sign_bit_copies_in_rep[GET_MODE (x)][mode] + 1))
|
>= num_sign_bit_copies_in_rep[GET_MODE (x)][mode] + 1))
|
return true;
|
return true;
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Initialize non_rtx_starting_operands, which is used to speed up
|
/* Initialize non_rtx_starting_operands, which is used to speed up
|
for_each_rtx. */
|
for_each_rtx. */
|
void
|
void
|
init_rtlanal (void)
|
init_rtlanal (void)
|
{
|
{
|
int i;
|
int i;
|
for (i = 0; i < NUM_RTX_CODE; i++)
|
for (i = 0; i < NUM_RTX_CODE; i++)
|
{
|
{
|
const char *format = GET_RTX_FORMAT (i);
|
const char *format = GET_RTX_FORMAT (i);
|
const char *first = strpbrk (format, "eEV");
|
const char *first = strpbrk (format, "eEV");
|
non_rtx_starting_operands[i] = first ? first - format : -1;
|
non_rtx_starting_operands[i] = first ? first - format : -1;
|
}
|
}
|
|
|
init_num_sign_bit_copies_in_rep ();
|
init_num_sign_bit_copies_in_rep ();
|
}
|
}
|
|
|
/* Check whether this is a constant pool constant. */
|
/* Check whether this is a constant pool constant. */
|
bool
|
bool
|
constant_pool_constant_p (rtx x)
|
constant_pool_constant_p (rtx x)
|
{
|
{
|
x = avoid_constant_pool_reference (x);
|
x = avoid_constant_pool_reference (x);
|
return GET_CODE (x) == CONST_DOUBLE;
|
return GET_CODE (x) == CONST_DOUBLE;
|
}
|
}
|
|
|
|
|
