static void df_ref_record (struct df_collection_rec *,
rtx, rtx *,
basic_block, rtx, enum df_ref_type,
- enum df_ref_flags, int, int);
+ enum df_ref_flags, int, int, enum machine_mode);
static void df_def_record_1 (struct df_collection_rec *,
rtx, basic_block, rtx,
enum df_ref_flags);
enum df_ref_flags);
static void df_uses_record (struct df_collection_rec *,
rtx *, enum df_ref_type,
- basic_block, rtx, enum df_ref_flags, int, int);
+ basic_block, rtx, enum df_ref_flags,
+ int, int, enum machine_mode);
static struct df_ref *df_ref_create_structure (struct df_collection_rec *, rtx, rtx *,
basic_block, rtx, enum df_ref_type,
- enum df_ref_flags, int, int);
+ enum df_ref_flags,
+ int, int, enum machine_mode);
static void df_insn_refs_collect (struct df_collection_rec*,
basic_block, rtx);
LOC within INSN of BB. This function is only used externally.
If the REF_FLAGS field contain DF_REF_SIGN_EXTRACT or
- DF_REF_ZERO_EXTRACT. WIDTH and OFFSET are used to access the fields
- if they were constants. Otherwise they should be -1 if those flags
- were set. */
+ DF_REF_ZERO_EXTRACT. WIDTH, OFFSET and MODE are used to access the
+ fields if they were constants. Otherwise they should be -1 if
+ those flags were set. */
struct df_ref *
df_ref_create (rtx reg, rtx *loc, rtx insn,
basic_block bb,
enum df_ref_type ref_type,
enum df_ref_flags ref_flags,
- int width, int offset)
+ int width, int offset, enum machine_mode mode)
{
struct df_ref *ref;
struct df_reg_info **reg_info;
/* You cannot hack artificial refs. */
gcc_assert (insn);
ref = df_ref_create_structure (NULL, reg, loc, bb, insn,
- ref_type, ref_flags, width, offset);
+ ref_type, ref_flags,
+ width, offset, mode);
if (DF_REF_TYPE (ref) == DF_REF_REG_DEF)
{
case REG_EQUAL:
df_uses_record (&collection_rec,
&XEXP (note, 0), DF_REF_REG_USE,
- bb, insn, DF_REF_IN_NOTE, -1, -1);
+ bb, insn, DF_REF_IN_NOTE, -1, -1, 0);
default:
break;
}
compared in the next set of tests. */
if ((DF_REF_FLAGS_IS_SET (ref1, DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT))
&& (DF_REF_FLAGS_IS_SET (ref2, DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT))
- && ((DF_REF_OFFSET (ref1) != DF_REF_OFFSET (ref2))
- || (DF_REF_WIDTH (ref1) != DF_REF_WIDTH (ref2))))
+ && ((DF_REF_EXTRACT_OFFSET (ref1) != DF_REF_EXTRACT_OFFSET (ref2))
+ || (DF_REF_EXTRACT_WIDTH (ref1) != DF_REF_EXTRACT_WIDTH (ref2))
+ || (DF_REF_EXTRACT_MODE (ref1) != DF_REF_EXTRACT_MODE (ref2))))
return false;
return (ref1 == ref2) ||
at ref1. */
if (DF_REF_FLAGS_IS_SET (ref1, DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT))
{
- if (DF_REF_OFFSET (ref1) != DF_REF_OFFSET (ref2))
- return DF_REF_OFFSET (ref1) - DF_REF_OFFSET (ref2);
- if (DF_REF_WIDTH (ref1) != DF_REF_WIDTH (ref2))
- return DF_REF_WIDTH (ref1) - DF_REF_WIDTH (ref2);
+ if (DF_REF_EXTRACT_OFFSET (ref1) != DF_REF_EXTRACT_OFFSET (ref2))
+ return DF_REF_EXTRACT_OFFSET (ref1) - DF_REF_EXTRACT_OFFSET (ref2);
+ if (DF_REF_EXTRACT_WIDTH (ref1) != DF_REF_EXTRACT_WIDTH (ref2))
+ return DF_REF_EXTRACT_WIDTH (ref1) - DF_REF_EXTRACT_WIDTH (ref2);
+ if (DF_REF_EXTRACT_MODE (ref1) != DF_REF_EXTRACT_MODE (ref2))
+ return DF_REF_EXTRACT_MODE (ref1) - DF_REF_EXTRACT_MODE (ref2);
}
return 0;
}
/* Allocate a ref and initialize its fields.
If the REF_FLAGS field contain DF_REF_SIGN_EXTRACT or
- DF_REF_ZERO_EXTRACT. WIDTH and OFFSET are used to access the fields
+ DF_REF_ZERO_EXTRACT. WIDTH, OFFSET and MODE are used to access the fields
if they were constants. Otherwise they should be -1 if those flags
were set. */
basic_block bb, rtx insn,
enum df_ref_type ref_type,
enum df_ref_flags ref_flags,
- int width, int offset)
+ int width, int offset, enum machine_mode mode)
{
struct df_ref *this_ref;
int regno = REGNO (GET_CODE (reg) == SUBREG ? SUBREG_REG (reg) : reg);
if (ref_flags & (DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT))
{
this_ref = pool_alloc (problem_data->ref_extract_pool);
- DF_REF_WIDTH (this_ref) = width;
- DF_REF_OFFSET (this_ref) = offset;
+ DF_REF_EXTRACT_WIDTH (this_ref) = width;
+ DF_REF_EXTRACT_OFFSET (this_ref) = offset;
+ DF_REF_EXTRACT_MODE (this_ref) = mode;
}
else
this_ref = pool_alloc (problem_data->ref_pool);
at address LOC within INSN of BB.
If the REF_FLAGS field contain DF_REF_SIGN_EXTRACT or
- DF_REF_ZERO_EXTRACT. WIDTH and OFFSET are used to access the fields
- if they were constants. Otherwise they should be -1 if those flags
- were set. */
+ DF_REF_ZERO_EXTRACT. WIDTH, OFFSET and MODE are used to access the
+ fields if they were constants. Otherwise they should be -1 if
+ those flags were set. */
static void
basic_block bb, rtx insn,
enum df_ref_type ref_type,
enum df_ref_flags ref_flags,
- int width, int offset)
+ int width, int offset, enum machine_mode mode)
{
unsigned int regno;
for (i = regno; i < endregno; i++)
{
ref = df_ref_create_structure (collection_rec, regno_reg_rtx[i], loc,
- bb, insn, ref_type, ref_flags, width, offset);
+ bb, insn, ref_type, ref_flags,
+ width, offset, mode);
gcc_assert (ORIGINAL_REGNO (DF_REF_REG (ref)) == i);
}
{
struct df_ref *ref;
ref = df_ref_create_structure (collection_rec, reg, loc, bb, insn,
- ref_type, ref_flags, width, offset);
+ ref_type, ref_flags, width, offset, mode);
}
}
rtx dst;
int offset = -1;
int width = -1;
+ enum machine_mode mode = 0;
/* We may recursively call ourselves on EXPR_LIST when dealing with PARALLEL
construct. */
{
width = INTVAL (XEXP (dst, 1));
offset = INTVAL (XEXP (dst, 2));
+ mode = GET_MODE (dst);
}
loc = &XEXP (dst, 0);
if (REG_P (dst))
{
df_ref_record (collection_rec,
- dst, loc, bb, insn, DF_REF_REG_DEF, flags, width, offset);
+ dst, loc, bb, insn, DF_REF_REG_DEF, flags,
+ width, offset, mode);
/* We want to keep sp alive everywhere - by making all
writes to sp also use of sp. */
if (REGNO (dst) == STACK_POINTER_REGNUM)
df_ref_record (collection_rec,
- dst, NULL, bb, insn, DF_REF_REG_USE, flags, width, offset);
+ dst, NULL, bb, insn, DF_REF_REG_USE, flags,
+ width, offset, mode);
}
else if (GET_CODE (dst) == SUBREG && REG_P (SUBREG_REG (dst)))
{
flags |= DF_REF_SUBREG;
df_ref_record (collection_rec,
- dst, loc, bb, insn, DF_REF_REG_DEF, flags, width, offset);
+ dst, loc, bb, insn, DF_REF_REG_DEF, flags,
+ width, offset, mode);
}
}
/* Process all the registers used in the rtx at address LOC.
If the REF_FLAGS field contain DF_REF_SIGN_EXTRACT or
- DF_REF_ZERO_EXTRACT. WIDTH and LOWER are used to access the fields
- if they were constants. Otherwise they should be -1 if those flags
- were set. */
+ DF_REF_ZERO_EXTRACT. WIDTH, OFFSET and MODE are used to access the
+ fields if they were constants. Otherwise they should be -1 if
+ those flags were set. */
static void
df_uses_record (struct df_collection_rec *collection_rec,
rtx *loc, enum df_ref_type ref_type,
basic_block bb, rtx insn, enum df_ref_flags flags,
- int width, int offset)
+ int width, int offset, enum machine_mode mode)
{
RTX_CODE code;
rtx x;
if (MEM_P (XEXP (x, 0)))
df_uses_record (collection_rec,
&XEXP (XEXP (x, 0), 0),
- DF_REF_REG_MEM_STORE, bb, insn, flags, width, offset);
+ DF_REF_REG_MEM_STORE, bb, insn, flags,
+ width, offset, mode);
/* If we're clobbering a REG then we have a def so ignore. */
return;
case MEM:
df_uses_record (collection_rec,
&XEXP (x, 0), DF_REF_REG_MEM_LOAD,
- bb, insn, flags & DF_REF_IN_NOTE, width, offset);
+ bb, insn, flags & DF_REF_IN_NOTE,
+ width, offset, mode);
return;
case SUBREG:
if (!REG_P (SUBREG_REG (x)))
{
loc = &SUBREG_REG (x);
- df_uses_record (collection_rec, loc, ref_type, bb, insn, flags, width, offset);
+ df_uses_record (collection_rec, loc, ref_type, bb, insn, flags,
+ width, offset, mode);
return;
}
/* ... Fall through ... */
case REG:
df_ref_record (collection_rec,
- x, loc, bb, insn, ref_type, flags, width, offset);
+ x, loc, bb, insn, ref_type, flags,
+ width, offset, mode);
return;
case SIGN_EXTRACT:
{
width = INTVAL (XEXP (x, 1));
offset = INTVAL (XEXP (x, 2));
+ mode = GET_MODE (x);
if (code == ZERO_EXTRACT)
flags |= DF_REF_ZERO_EXTRACT;
flags |= DF_REF_SIGN_EXTRACT;
df_uses_record (collection_rec,
- &XEXP (x, 0), ref_type, bb, insn, flags, width, offset);
+ &XEXP (x, 0), ref_type, bb, insn, flags,
+ width, offset, mode);
return;
}
}
rtx dst = SET_DEST (x);
gcc_assert (!(flags & DF_REF_IN_NOTE));
df_uses_record (collection_rec,
- &SET_SRC (x), DF_REF_REG_USE, bb, insn, flags, width, offset);
+ &SET_SRC (x), DF_REF_REG_USE, bb, insn, flags,
+ width, offset, mode);
switch (GET_CODE (dst))
{
{
df_uses_record (collection_rec, &SUBREG_REG (dst),
DF_REF_REG_USE, bb, insn,
- flags | DF_REF_READ_WRITE | DF_REF_SUBREG, width, offset);
+ flags | DF_REF_READ_WRITE | DF_REF_SUBREG,
+ width, offset, mode);
break;
}
/* Fall through. */
break;
case MEM:
df_uses_record (collection_rec, &XEXP (dst, 0),
- DF_REF_REG_MEM_STORE, bb, insn, flags, width, offset);
+ DF_REF_REG_MEM_STORE, bb, insn, flags,
+ width, offset, mode);
break;
case STRICT_LOW_PART:
{
df_uses_record (collection_rec,
(GET_CODE (dst) == SUBREG) ? &SUBREG_REG (dst) : temp,
DF_REF_REG_USE, bb, insn,
- DF_REF_READ_WRITE | DF_REF_STRICT_LOW_PART, width, offset);
+ DF_REF_READ_WRITE | DF_REF_STRICT_LOW_PART,
+ width, offset, mode);
}
break;
case ZERO_EXTRACT:
{
width = INTVAL (XEXP (dst, 1));
offset = INTVAL (XEXP (dst, 2));
+ mode = GET_MODE (dst);
}
else
{
df_uses_record (collection_rec, &XEXP (dst, 1),
- DF_REF_REG_USE, bb, insn, flags, width, offset);
+ DF_REF_REG_USE, bb, insn, flags,
+ width, offset, mode);
df_uses_record (collection_rec, &XEXP (dst, 2),
- DF_REF_REG_USE, bb, insn, flags, width, offset);
+ DF_REF_REG_USE, bb, insn, flags,
+ width, offset, mode);
}
df_uses_record (collection_rec, &XEXP (dst, 0),
DF_REF_REG_USE, bb, insn,
- DF_REF_READ_WRITE | DF_REF_ZERO_EXTRACT, width, offset);
+ DF_REF_READ_WRITE | DF_REF_ZERO_EXTRACT,
+ width, offset, mode);
}
break;
for (j = 0; j < ASM_OPERANDS_INPUT_LENGTH (x); j++)
df_uses_record (collection_rec, &ASM_OPERANDS_INPUT (x, j),
- DF_REF_REG_USE, bb, insn, flags, width, offset);
+ DF_REF_REG_USE, bb, insn, flags,
+ width, offset, mode);
return;
}
break;
/* Catch the def of the register being modified. */
df_ref_record (collection_rec, XEXP (x, 0), &XEXP (x, 0), bb, insn,
DF_REF_REG_DEF,
- flags | DF_REF_READ_WRITE | DF_REF_PRE_POST_MODIFY, width, offset);
+ flags | DF_REF_READ_WRITE | DF_REF_PRE_POST_MODIFY,
+ width, offset, mode);
/* ... Fall through to handle uses ... */
goto retry;
}
df_uses_record (collection_rec, &XEXP (x, i), ref_type,
- bb, insn, flags, width, offset);
+ bb, insn, flags,
+ width, offset, mode);
}
else if (fmt[i] == 'E')
{
for (j = 0; j < XVECLEN (x, i); j++)
df_uses_record (collection_rec,
&XVECEXP (x, i, j), ref_type,
- bb, insn, flags, width, offset);
+ bb, insn, flags,
+ width, offset, mode);
}
}
}
{
int width = -1;
int offset = -1;
+ enum machine_mode mode = 0;
struct df_ref *use;
if (DF_REF_FLAGS_IS_SET (ref, DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT))
{
- width = DF_REF_WIDTH (ref);
- offset = DF_REF_OFFSET (ref);
+ width = DF_REF_EXTRACT_WIDTH (ref);
+ offset = DF_REF_EXTRACT_OFFSET (ref);
+ mode = DF_REF_EXTRACT_MODE (ref);
}
use = df_ref_create_structure (collection_rec, DF_REF_REG (ref),
DF_REF_LOC (ref), DF_REF_BB (ref),
DF_REF_INSN (ref), DF_REF_REG_USE,
DF_REF_FLAGS (ref) & ~DF_REF_CONDITIONAL,
- width, offset);
+ width, offset, mode);
DF_REF_REGNO (use) = DF_REF_REGNO (ref);
}
}
{
if (GET_CODE (XEXP (note, 0)) == USE)
df_uses_record (collection_rec, &XEXP (XEXP (note, 0), 0),
- DF_REF_REG_USE, bb, insn, flags, -1, -1);
+ DF_REF_REG_USE, bb, insn, flags, -1, -1, 0);
else if (GET_CODE (XEXP (note, 0)) == CLOBBER)
{
if (REG_P (XEXP (XEXP (note, 0), 0)))
}
else
df_uses_record (collection_rec, &XEXP (note, 0),
- DF_REF_REG_USE, bb, insn, flags, -1, -1);
+ DF_REF_REG_USE, bb, insn, flags, -1, -1, 0);
}
}
/* The stack ptr is used (honorarily) by a CALL insn. */
df_ref_record (collection_rec, regno_reg_rtx[STACK_POINTER_REGNUM],
- NULL, bb, insn, DF_REF_REG_USE, DF_REF_CALL_STACK_USAGE | flags, -1, -1);
+ NULL, bb, insn, DF_REF_REG_USE, DF_REF_CALL_STACK_USAGE | flags,
+ -1, -1, 0);
/* Calls may also reference any of the global registers,
so they are recorded as used. */
if (global_regs[i])
{
df_ref_record (collection_rec, regno_reg_rtx[i],
- NULL, bb, insn, DF_REF_REG_USE, flags, -1, -1);
+ NULL, bb, insn, DF_REF_REG_USE, flags, -1, -1, 0);
df_ref_record (collection_rec, regno_reg_rtx[i],
- NULL, bb, insn, DF_REF_REG_DEF, flags, -1, -1);
+ NULL, bb, insn, DF_REF_REG_DEF, flags, -1, -1, 0);
}
is_sibling_call = SIBLING_CALL_P (insn);
|| refers_to_regno_p (ui, ui+1,
crtl->return_rtx, NULL)))
df_ref_record (collection_rec, regno_reg_rtx[ui],
- NULL, bb, insn, DF_REF_REG_DEF, DF_REF_MAY_CLOBBER | flags, -1, -1);
+ NULL, bb, insn, DF_REF_REG_DEF, DF_REF_MAY_CLOBBER | flags,
+ -1, -1, 0);
}
BITMAP_FREE (defs_generated);
case REG_EQUAL:
df_uses_record (collection_rec,
&XEXP (note, 0), DF_REF_REG_USE,
- bb, insn, DF_REF_IN_NOTE, -1, -1);
+ bb, insn, DF_REF_IN_NOTE, -1, -1, 0);
break;
case REG_NON_LOCAL_GOTO:
/* The frame ptr is used by a non-local goto. */
regno_reg_rtx[FRAME_POINTER_REGNUM],
NULL,
bb, insn,
- DF_REF_REG_USE, 0, -1, -1);
+ DF_REF_REG_USE, 0, -1, -1, 0);
#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
df_ref_record (collection_rec,
regno_reg_rtx[HARD_FRAME_POINTER_REGNUM],
NULL,
bb, insn,
- DF_REF_REG_USE, 0, -1, -1);
+ DF_REF_REG_USE, 0, -1, -1, 0);
#endif
break;
default:
/* Record the register uses. */
df_uses_record (collection_rec,
- &PATTERN (insn), DF_REF_REG_USE, bb, insn, 0, -1, -1);
+ &PATTERN (insn), DF_REF_REG_USE, bb, insn, 0,
+ -1, -1, 0);
/* DF_REF_CONDITIONAL needs corresponding USES. */
if (is_cond_exec)
if (regno == INVALID_REGNUM)
break;
df_ref_record (collection_rec, regno_reg_rtx[regno], NULL,
- bb, NULL, DF_REF_REG_DEF, DF_REF_AT_TOP, -1, -1);
+ bb, NULL, DF_REF_REG_DEF, DF_REF_AT_TOP, -1, -1, 0);
}
}
#endif
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
if (EH_USES (i))
df_ref_record (collection_rec, regno_reg_rtx[i], NULL,
- bb, NULL, DF_REF_REG_USE, DF_REF_AT_TOP, -1, -1);
+ bb, NULL, DF_REF_REG_USE, DF_REF_AT_TOP, -1, -1, 0);
}
#endif
non-local goto. */
if (bb->flags & BB_NON_LOCAL_GOTO_TARGET)
df_ref_record (collection_rec, hard_frame_pointer_rtx, NULL,
- bb, NULL, DF_REF_REG_DEF, DF_REF_AT_TOP, -1, -1);
+ bb, NULL, DF_REF_REG_DEF, DF_REF_AT_TOP, -1, -1, 0);
/* Add the artificial uses. */
if (bb->index >= NUM_FIXED_BLOCKS)
EXECUTE_IF_SET_IN_BITMAP (au, 0, regno, bi)
{
df_ref_record (collection_rec, regno_reg_rtx[regno], NULL,
- bb, NULL, DF_REF_REG_USE, 0, -1, -1);
+ bb, NULL, DF_REF_REG_USE, 0, -1, -1, 0);
}
}
EXECUTE_IF_SET_IN_BITMAP (entry_block_defs, 0, i, bi)
{
df_ref_record (collection_rec, regno_reg_rtx[i], NULL,
- ENTRY_BLOCK_PTR, NULL, DF_REF_REG_DEF, 0, -1, -1);
+ ENTRY_BLOCK_PTR, NULL, DF_REF_REG_DEF, 0, -1, -1, 0);
}
df_canonize_collection_rec (collection_rec);
EXECUTE_IF_SET_IN_BITMAP (exit_block_uses, 0, i, bi)
df_ref_record (collection_rec, regno_reg_rtx[i], NULL,
- EXIT_BLOCK_PTR, NULL, DF_REF_REG_USE, 0, -1, -1);
+ EXIT_BLOCK_PTR, NULL, DF_REF_REG_USE, 0, -1, -1, 0);
#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
/* It is deliberate that this is not put in the exit block uses but
&& bb_has_eh_pred (EXIT_BLOCK_PTR)
&& fixed_regs[ARG_POINTER_REGNUM])
df_ref_record (collection_rec, regno_reg_rtx[ARG_POINTER_REGNUM], NULL,
- EXIT_BLOCK_PTR, NULL, DF_REF_REG_USE, 0, -1, -1);
+ EXIT_BLOCK_PTR, NULL, DF_REF_REG_USE, 0, -1, -1, 0);
#endif
df_canonize_collection_rec (collection_rec);
}
-/* Return true if df_ref information for all insns in all BLOCKS are
- correct and complete. If BLOCKS is null, all blocks are
- checked. */
+/* Return true if df_ref information for all insns in all blocks are
+ correct and complete. */
void
df_scan_verify (void)
OSDN Git Service
