rtl.h (struct rtx_def): Update comments.
* rtl.h (struct rtx_def): Update comments. (RTL_FLAG_CHECK[12345678]): New. (rtl_check_failed_flag): Declare. (RTL_FLAG): New. (CLEAR_RTX_FLAGS): New. (flag access macros): Use RTL_FLAG_CHECK macros with list of expected RTL codes. * rtl.c (copy_rtx, shallow_copy_rtx): Use RTX_FLAG macro. (rtl_check_failed_flag): New. * reload1.c (reload): Use REG macro before changing rtx to MEM. (reload_cse_noop_set_p): Check rtx code before using access macro. * config/ia64/ia64.c (process_for_unwind_directive): Check rtx code before using access macro. From-SVN: r53245
This commit is contained in:
Janis Johnson
Janis Johnson
parent
4afe395245
commit
5a63e06940
5 changed files with 211 additions and 71 deletions
|
|
@ -1,3 +1,16 @@
|
|||
2002-05-06 Janis Johnson <janis187@us.ibm.com>
|
||||
|
||||
* rtl.h (struct rtx_def): Update comments.
|
||||
(RTL_FLAG_CHECK[12345678]): New. (rtl_check_failed_flag): Declare.
|
||||
(RTL_FLAG): New. (CLEAR_RTX_FLAGS): New. (flag access macros): Use
|
||||
RTL_FLAG_CHECK macros with list of expected RTL codes.
|
||||
* rtl.c (copy_rtx, shallow_copy_rtx): Use RTX_FLAG macro.
|
||||
(rtl_check_failed_flag): New.
|
||||
* reload1.c (reload): Use REG macro before changing rtx to MEM.
|
||||
(reload_cse_noop_set_p): Check rtx code before using access macro.
|
||||
* config/ia64/ia64.c (process_for_unwind_directive): Check rtx code
|
||||
before using access macro.
|
||||
|
||||
2002-05-06 Janis Johnson <janis187@us.ibm.com>
|
||||
|
||||
* doc/rtl.texi (Flags): Update to reflect current usage.
|
||||
|
|
|
|||
|
|
@ -7225,7 +7225,7 @@ process_for_unwind_directive (asm_out_file, insn)
|
|||
}
|
||||
}
|
||||
|
||||
if (! RTX_FRAME_RELATED_P (insn))
|
||||
if (GET_CODE (insn) == NOTE || ! RTX_FRAME_RELATED_P (insn))
|
||||
return;
|
||||
|
||||
pat = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
|
||||
|
|
|
|||
|
|
@ -1160,9 +1160,9 @@ reload (first, global)
|
|||
{
|
||||
rtx reg = regno_reg_rtx[i];
|
||||
|
||||
REG_USERVAR_P (reg) = 0;
|
||||
PUT_CODE (reg, MEM);
|
||||
XEXP (reg, 0) = addr;
|
||||
REG_USERVAR_P (reg) = 0;
|
||||
if (reg_equiv_memory_loc[i])
|
||||
MEM_COPY_ATTRIBUTES (reg, reg_equiv_memory_loc[i]);
|
||||
else
|
||||
|
|
@ -8079,7 +8079,8 @@ reload_cse_simplify (insn)
|
|||
if (!count && reload_cse_noop_set_p (body))
|
||||
{
|
||||
rtx value = SET_DEST (body);
|
||||
if (! REG_FUNCTION_VALUE_P (SET_DEST (body)))
|
||||
if (GET_CODE (body) == REG
|
||||
&& ! REG_FUNCTION_VALUE_P (SET_DEST (body)))
|
||||
value = 0;
|
||||
reload_cse_delete_noop_set (insn, value);
|
||||
return;
|
||||
|
|
|
|||
32
gcc/rtl.c
32
gcc/rtl.c
|
|
@ -331,13 +331,13 @@ copy_rtx (orig)
|
|||
|
||||
/* We do not copy the USED flag, which is used as a mark bit during
|
||||
walks over the RTL. */
|
||||
copy->used = 0;
|
||||
RTX_FLAG (copy, used) = 0;
|
||||
|
||||
/* We do not copy FRAME_RELATED for INSNs. */
|
||||
if (GET_RTX_CLASS (code) == 'i')
|
||||
copy->frame_related = 0;
|
||||
copy->jump = orig->jump;
|
||||
copy->call = orig->call;
|
||||
RTX_FLAG (copy, frame_related) = 0;
|
||||
RTX_FLAG (copy, jump) = RTX_FLAG (orig, jump);
|
||||
RTX_FLAG (copy, call) = RTX_FLAG (orig, call);
|
||||
|
||||
format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
|
||||
|
||||
|
|
@ -390,11 +390,11 @@ shallow_copy_rtx (orig)
|
|||
rtx copy = rtx_alloc (code);
|
||||
|
||||
PUT_MODE (copy, GET_MODE (orig));
|
||||
copy->in_struct = orig->in_struct;
|
||||
copy->volatil = orig->volatil;
|
||||
copy->unchanging = orig->unchanging;
|
||||
copy->integrated = orig->integrated;
|
||||
copy->frame_related = orig->frame_related;
|
||||
RTX_FLAG (copy, in_struct) = RTX_FLAG (orig, in_struct);
|
||||
RTX_FLAG (copy, volatil) = RTX_FLAG (orig, volatil);
|
||||
RTX_FLAG (copy, unchanging) = RTX_FLAG (orig, unchanging);
|
||||
RTX_FLAG (copy, integrated) = RTX_FLAG (orig, integrated);
|
||||
RTX_FLAG (copy, frame_related) = RTX_FLAG (orig, frame_related);
|
||||
|
||||
for (i = 0; i < GET_RTX_LENGTH (code); i++)
|
||||
copy->fld[i] = orig->fld[i];
|
||||
|
|
@ -637,3 +637,17 @@ rtvec_check_failed_bounds (r, n, file, line, func)
|
|||
n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
|
||||
}
|
||||
#endif /* ENABLE_RTL_CHECKING */
|
||||
|
||||
#if defined ENABLE_RTL_FLAG_CHECKING
|
||||
void
|
||||
rtl_check_failed_flag (r, file, line, func)
|
||||
rtx r;
|
||||
const char *file;
|
||||
int line;
|
||||
const char *func;
|
||||
{
|
||||
internal_error
|
||||
("RTL flag check: access macro used with unexpected rtx code `%s' in %s, at %s:%d",
|
||||
GET_RTX_NAME (GET_CODE (r)), func, trim_filename (file), line);
|
||||
}
|
||||
#endif /* ENABLE_RTL_FLAG_CHECKING */
|
||||
|
|
|
|||
230
gcc/rtl.h
230
gcc/rtl.h
|
|
@ -127,31 +127,30 @@ struct rtx_def
|
|||
/* The kind of value the expression has. */
|
||||
ENUM_BITFIELD(machine_mode) mode : 8;
|
||||
|
||||
/* 1 in an INSN if it can alter flow of control
|
||||
within this function.
|
||||
MEM_KEEP_ALIAS_SET_P in a MEM.
|
||||
SET_IS_RETURN_P in a SET. */
|
||||
/* 1 in a MEM if we should keep the alias set for this mem unchanged
|
||||
when we access a component.
|
||||
1 in a CALL_INSN if it is a sibling call.
|
||||
1 in a SET that is for a return. */
|
||||
unsigned int jump : 1;
|
||||
/* 1 in an INSN if it can call another function. */
|
||||
/* This flag is currently unused. */
|
||||
unsigned int call : 1;
|
||||
/* 1 in a REG if value of this expression will never change during
|
||||
the current function, even though it is not manifestly constant.
|
||||
1 in a MEM if contents of memory are constant. This does not
|
||||
necessarily mean that the value of this expression is constant.
|
||||
1 in a SUBREG if it is from a promoted variable that is unsigned.
|
||||
/* 1 in a REG, MEM, or CONCAT if the value is set at most once, anywhere.
|
||||
1 in a SUBREG if it references an unsigned object whose mode has been
|
||||
from a promoted to a wider mode.
|
||||
1 in a SYMBOL_REF if it addresses something in the per-function
|
||||
constants pool.
|
||||
1 in a CALL_INSN if it is a const call.
|
||||
1 in a JUMP_INSN if it is a branch that should be annulled. Valid from
|
||||
reorg until end of compilation; cleared before used. */
|
||||
1 in a CALL_INSN, NOTE, or EXPR_LIST for a const or pure call.
|
||||
1 in an INSN in the delay slot of a branch insn if an annulling branch
|
||||
should be used. */
|
||||
unsigned int unchanging : 1;
|
||||
/* 1 in a MEM expression if contents of memory are volatile.
|
||||
1 in an INSN, CALL_INSN, JUMP_INSN, CODE_LABEL or BARRIER
|
||||
if it is deleted.
|
||||
1 in a REG expression if corresponds to a variable declared by the user.
|
||||
/* 1 in a MEM or ASM_OPERANDS expression if the memory reference is volatile.
|
||||
1 in an INSN, CALL_INSN, JUMP_INSN, CODE_LABEL, BARRIER, or NOTE
|
||||
if it has been deleted.
|
||||
1 in a REG expression if corresponds to a variable declared by the user,
|
||||
0 for an internally generated temporary.
|
||||
In a SYMBOL_REF, this flag is used for machine-specific purposes.
|
||||
In a LABEL_REF or in a REG_LABEL note, this is LABEL_REF_NONLOCAL_P. */
|
||||
1 in a SUBREG with a negative value.
|
||||
1 in a LABEL_REF or in a REG_LABEL note for a non-local label.
|
||||
In a SYMBOL_REF, this flag is used for machine-specific purposes. */
|
||||
unsigned int volatil : 1;
|
||||
/* 1 in a MEM referring to a field of an aggregate.
|
||||
0 if the MEM was a variable or the result of a * operator in C;
|
||||
|
|
@ -163,23 +162,25 @@ struct rtx_def
|
|||
and must not be deleted even if its count is zero.
|
||||
1 in a LABEL_REF if this is a reference to a label outside the
|
||||
current loop.
|
||||
1 in an INSN, JUMP_INSN, or CALL_INSN if this insn must be scheduled
|
||||
together with the preceding insn. Valid only within sched.
|
||||
1 in an INSN, JUMP_INSN, CALL_INSN, CODE_LABEL, BARRIER, or NOTE if
|
||||
this insn must be scheduled together with the preceding insn. Valid
|
||||
only within sched.
|
||||
1 in an INSN, JUMP_INSN, or CALL_INSN if insn is in a delay slot and
|
||||
from the target of a branch. Valid from reorg until end of compilation;
|
||||
cleared before used.
|
||||
1 in an INSN if this insn is dead code. Valid only during
|
||||
1 in an INSN in a delay slot that is the target of a branch, during reorg.
|
||||
1 in an INSN or related rtx if this insn is dead code. Valid only during
|
||||
dead-code elimination phase; cleared before use. */
|
||||
unsigned int in_struct : 1;
|
||||
/* 1 if this rtx is used. This is used for copying shared structure.
|
||||
See `unshare_all_rtl'.
|
||||
/* At the end of RTL generation, 1 if this rtx is used. This is used for
|
||||
copying shared structure. See `unshare_all_rtl'.
|
||||
In a REG, this is not needed for that purpose, and used instead
|
||||
in `leaf_renumber_regs_insn'.
|
||||
In a SYMBOL_REF, means that emit_library_call
|
||||
1 in a SYMBOL_REF, means that emit_library_call
|
||||
has used it as the function. */
|
||||
unsigned int used : 1;
|
||||
/* Nonzero if this rtx came from procedure integration.
|
||||
In a REG, nonzero means this reg refers to the return value
|
||||
1 in a REG means this reg refers to the return value
|
||||
of the current function.
|
||||
1 in a SYMBOL_REF if the symbol is weak. */
|
||||
unsigned integrated : 1;
|
||||
|
|
@ -209,11 +210,6 @@ struct rtx_def
|
|||
#define GET_MODE(RTX) ((enum machine_mode) (RTX)->mode)
|
||||
#define PUT_MODE(RTX, MODE) ((RTX)->mode = (ENUM_BITFIELD(machine_mode)) (MODE))
|
||||
|
||||
#define RTX_FLAG(RTX,FLAG) ((RTX)->FLAG)
|
||||
#define RTX_INTEGRATED_P(RTX) ((RTX)->integrated)
|
||||
#define RTX_UNCHANGING_P(RTX) ((RTX)->unchanging)
|
||||
#define RTX_FRAME_RELATED_P(RTX) ((RTX)->frame_related)
|
||||
|
||||
/* RTL vector. These appear inside RTX's when there is a need
|
||||
for a variable number of things. The principle use is inside
|
||||
PARALLEL expressions. */
|
||||
|
|
@ -336,6 +332,102 @@ extern void rtvec_check_failed_bounds PARAMS ((rtvec, int,
|
|||
|
||||
#endif
|
||||
|
||||
/* General accessor macros for accessing the flags of an rtx. */
|
||||
|
||||
/* Access an individual rtx flag, with no checking of any kind. */
|
||||
#define RTX_FLAG(RTX, FLAG) ((RTX)->FLAG)
|
||||
|
||||
#if defined ENABLE_RTL_FLAG_CHECKING
|
||||
#define RTL_FLAG_CHECK1(RTX, C1) __extension__ \
|
||||
({ rtx const _rtx = (RTX); \
|
||||
if (GET_CODE(_rtx) != C1) \
|
||||
rtl_check_failed_flag (_rtx, __FILE__, __LINE__, __FUNCTION__); \
|
||||
_rtx; })
|
||||
|
||||
#define RTL_FLAG_CHECK2(RTX, C1, C2) __extension__ \
|
||||
({ rtx const _rtx = (RTX); \
|
||||
if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2) \
|
||||
rtl_check_failed_flag (_rtx, __FILE__, __LINE__, __FUNCTION__); \
|
||||
_rtx; })
|
||||
|
||||
#define RTL_FLAG_CHECK3(RTX, C1, C2, C3) __extension__ \
|
||||
({ rtx const _rtx = (RTX); \
|
||||
if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \
|
||||
&& GET_CODE(_rtx) != C3) \
|
||||
rtl_check_failed_flag (_rtx, __FILE__, __LINE__, __FUNCTION__); \
|
||||
_rtx; })
|
||||
|
||||
#define RTL_FLAG_CHECK4(RTX, C1, C2, C3, C4) __extension__ \
|
||||
({ rtx const _rtx = (RTX); \
|
||||
if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \
|
||||
&& GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4) \
|
||||
rtl_check_failed_flag (_rtx, __FILE__, __LINE__, __FUNCTION__); \
|
||||
_rtx; })
|
||||
|
||||
#define RTL_FLAG_CHECK5(RTX, C1, C2, C3, C4, C5) __extension__ \
|
||||
({ rtx const _rtx = (RTX); \
|
||||
if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \
|
||||
&& GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4 \
|
||||
&& GET_CODE(_rtx) != C5) \
|
||||
rtl_check_failed_flag (_rtx, __FILE__, __LINE__, __FUNCTION__); \
|
||||
_rtx; })
|
||||
|
||||
#define RTL_FLAG_CHECK6(RTX, C1, C2, C3, C4, C5, C6) __extension__ \
|
||||
({ rtx const _rtx = (RTX); \
|
||||
if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \
|
||||
&& GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4 \
|
||||
&& GET_CODE(_rtx) != C5 && GET_CODE(_rtx) != C6) \
|
||||
rtl_check_failed_flag (_rtx, __FILE__, __LINE__, __FUNCTION__); \
|
||||
_rtx; })
|
||||
|
||||
#define RTL_FLAG_CHECK7(RTX, C1, C2, C3, C4, C5, C6, C7) __extension__ \
|
||||
({ rtx const _rtx = (RTX); \
|
||||
if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \
|
||||
&& GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4 \
|
||||
&& GET_CODE(_rtx) != C5 && GET_CODE(_rtx) != C6 \
|
||||
&& GET_CODE(_rtx) != C7) \
|
||||
rtl_check_failed_flag (_rtx, __FILE__, __LINE__, __FUNCTION__); \
|
||||
_rtx; })
|
||||
|
||||
#define RTL_FLAG_CHECK8(RTX, C1, C2, C3, C4, C5, C6, C7, C8) __extension__ \
|
||||
({ rtx const _rtx = (RTX); \
|
||||
if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \
|
||||
&& GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4 \
|
||||
&& GET_CODE(_rtx) != C5 && GET_CODE(_rtx) != C6 \
|
||||
&& GET_CODE(_rtx) != C7 && GET_CODE(_rtx) != C8) \
|
||||
rtl_check_failed_flag (_rtx, __FILE__, __LINE__, __FUNCTION__); \
|
||||
_rtx; })
|
||||
|
||||
extern void rtl_check_failed_flag PARAMS ((rtx, const char *, int,
|
||||
const char *))
|
||||
ATTRIBUTE_NORETURN
|
||||
;
|
||||
|
||||
#else /* not ENABLE_RTL_FLAG_CHECKING */
|
||||
|
||||
#define RTL_FLAG_CHECK1(RTX, C1) (RTX)
|
||||
#define RTL_FLAG_CHECK2(RTX, C1, C2) (RTX)
|
||||
#define RTL_FLAG_CHECK3(RTX, C1, C2, C3) (RTX)
|
||||
#define RTL_FLAG_CHECK4(RTX, C1, C2, C3, C4) (RTX)
|
||||
#define RTL_FLAG_CHECK5(RTX, C1, C2, C3, C4, C5) (RTX)
|
||||
#define RTL_FLAG_CHECK6(RTX, C1, C2, C3, C4, C5, C6) (RTX)
|
||||
#define RTL_FLAG_CHECK7(RTX, C1, C2, C3, C4, C5, C6, C7) (RTX)
|
||||
#define RTL_FLAG_CHECK8(RTX, C1, C2, C3, C4, C5, C6, C7, C8) (RTX)
|
||||
#endif
|
||||
|
||||
#define CLEAR_RTX_FLAGS(RTX) \
|
||||
do { \
|
||||
rtx const _rtx = (RTX); \
|
||||
_rtx->call = 0; \
|
||||
_rtx->frame_related = 0; \
|
||||
_rtx->in_struct = 0; \
|
||||
_rtx->integrated = 0; \
|
||||
_rtx->jump = 0; \
|
||||
_rtx->unchanging = 0; \
|
||||
_rtx->used = 0; \
|
||||
_rtx->volatil = 0; \
|
||||
} while (0)
|
||||
|
||||
#define XWINT(RTX, N) (RTL_CHECK1 (RTX, N, 'w').rtwint)
|
||||
#define XINT(RTX, N) (RTL_CHECK2 (RTX, N, 'i', 'n').rtint)
|
||||
#define XSTR(RTX, N) (RTL_CHECK2 (RTX, N, 's', 'S').rtstr)
|
||||
|
|
@ -412,27 +504,39 @@ extern void rtvec_check_failed_bounds PARAMS ((rtvec, int,
|
|||
They are always in the same basic block as this insn. */
|
||||
#define LOG_LINKS(INSN) XEXP(INSN, 5)
|
||||
|
||||
#define RTX_INTEGRATED_P(RTX) \
|
||||
(RTL_FLAG_CHECK8((RTX), INSN, CALL_INSN, JUMP_INSN, INSN_LIST, \
|
||||
BARRIER, CODE_LABEL, CONST, NOTE)->integrated)
|
||||
#define RTX_UNCHANGING_P(RTX) \
|
||||
(RTL_FLAG_CHECK3((RTX), REG, MEM, CONCAT)->unchanging)
|
||||
#define RTX_FRAME_RELATED_P(RTX) \
|
||||
(RTL_FLAG_CHECK5((RTX), INSN, CALL_INSN, JUMP_INSN, BARRIER, \
|
||||
SET)->frame_related)
|
||||
|
||||
/* 1 if insn has been deleted. */
|
||||
#define INSN_DELETED_P(INSN) ((INSN)->volatil)
|
||||
#define INSN_DELETED_P(RTX) \
|
||||
(RTL_FLAG_CHECK6((RTX), INSN, CALL_INSN, JUMP_INSN, CODE_LABEL, \
|
||||
BARRIER, NOTE)->volatil)
|
||||
|
||||
/* 1 if insn is a call to a const or pure function. */
|
||||
#define CONST_OR_PURE_CALL_P(INSN) ((INSN)->unchanging)
|
||||
#define CONST_OR_PURE_CALL_P(RTX) \
|
||||
(RTL_FLAG_CHECK3((RTX), CALL_INSN, NOTE, EXPR_LIST)->unchanging)
|
||||
|
||||
/* 1 if insn (assumed to be a CALL_INSN) is a sibling call. */
|
||||
#define SIBLING_CALL_P(INSN) ((INSN)->jump)
|
||||
#define SIBLING_CALL_P(INSN) (RTL_FLAG_CHECK1((INSN), CALL_INSN)->jump)
|
||||
|
||||
/* 1 if insn is a branch that should not unconditionally execute its
|
||||
delay slots, i.e., it is an annulled branch. */
|
||||
#define INSN_ANNULLED_BRANCH_P(INSN) ((INSN)->unchanging)
|
||||
/* 1 in an INSN in the delay slot of a branch insn if an annulling branch
|
||||
should be used. */
|
||||
#define INSN_ANNULLED_BRANCH_P(RTX) (RTL_FLAG_CHECK1((RTX), INSN)->unchanging)
|
||||
|
||||
/* 1 if insn is a dead code. Valid only for dead-code elimination phase. */
|
||||
#define INSN_DEAD_CODE_P(INSN) ((INSN)->in_struct)
|
||||
#define INSN_DEAD_CODE_P(RTX) (RTL_FLAG_CHECK1((RTX), INSN)->in_struct)
|
||||
|
||||
/* 1 if insn is in a delay slot and is from the target of the branch. If
|
||||
the branch insn has INSN_ANNULLED_BRANCH_P set, this insn should only be
|
||||
executed if the branch is taken. For annulled branches with this bit
|
||||
clear, the insn should be executed only if the branch is not taken. */
|
||||
#define INSN_FROM_TARGET_P(INSN) ((INSN)->in_struct)
|
||||
#define INSN_FROM_TARGET_P(RTX) (RTL_FLAG_CHECK1((RTX), INSN)->in_struct)
|
||||
|
||||
#define ADDR_DIFF_VEC_FLAGS(RTX) X0ADVFLAGS(RTX, 4)
|
||||
|
||||
|
|
@ -792,13 +896,13 @@ extern const char * const note_insn_name[NOTE_INSN_MAX - NOTE_INSN_BIAS];
|
|||
/* For a REG rtx, REG_FUNCTION_VALUE_P is nonzero if the reg
|
||||
is the current function's return value. */
|
||||
|
||||
#define REG_FUNCTION_VALUE_P(RTX) ((RTX)->integrated)
|
||||
#define REG_FUNCTION_VALUE_P(RTX) (RTL_FLAG_CHECK1((RTX), REG)->integrated)
|
||||
|
||||
/* 1 in a REG rtx if it corresponds to a variable declared by the user. */
|
||||
#define REG_USERVAR_P(RTX) ((RTX)->volatil)
|
||||
#define REG_USERVAR_P(RTX) (RTL_FLAG_CHECK1((RTX), REG)->volatil)
|
||||
|
||||
/* 1 in a REG rtx if the register is a pointer. */
|
||||
#define REG_POINTER(RTX) ((RTX)->frame_related)
|
||||
#define REG_POINTER(RTX) (RTL_FLAG_CHECK1((RTX), REG)->frame_related)
|
||||
|
||||
/* 1 if the given register REG corresponds to a hard register. */
|
||||
#define HARD_REGISTER_P(REG) (HARD_REGISTER_NUM_P (REGNO (REG)))
|
||||
|
|
@ -851,9 +955,10 @@ extern unsigned int subreg_regno PARAMS ((rtx));
|
|||
When used as a LHS, is means that this extension must be done
|
||||
when assigning to SUBREG_REG. */
|
||||
|
||||
#define SUBREG_PROMOTED_VAR_P(RTX) ((RTX)->in_struct)
|
||||
#define SUBREG_PROMOTED_VAR_P(RTX) (RTL_FLAG_CHECK1((RTX), SUBREG)->in_struct)
|
||||
#define SUBREG_PROMOTED_UNSIGNED_SET(RTX, VAL) \
|
||||
do { \
|
||||
RTL_FLAG_CHECK1((RTX), SUBREG); \
|
||||
if ((VAL) < 0) \
|
||||
(RTX)->volatil = 1; \
|
||||
else { \
|
||||
|
|
@ -861,7 +966,8 @@ do { \
|
|||
(RTX)->unchanging = (VAL); \
|
||||
} \
|
||||
} while (0)
|
||||
#define SUBREG_PROMOTED_UNSIGNED_P(RTX) ((RTX)->volatil ? -1 : (RTX)->unchanging)
|
||||
#define SUBREG_PROMOTED_UNSIGNED_P(RTX) \
|
||||
((RTL_FLAG_CHECK1((RTX), SUBREG)->volatil) ? -1 : (RTX)->unchanging)
|
||||
|
||||
/* Access various components of an ASM_OPERANDS rtx. */
|
||||
|
||||
|
|
@ -884,20 +990,20 @@ do { \
|
|||
/* For a MEM RTX, 1 if we should keep the alias set for this mem
|
||||
unchanged when we access a component. Set to 1, or example, when we
|
||||
are already in a non-addressable component of an aggregate. */
|
||||
#define MEM_KEEP_ALIAS_SET_P(RTX) ((RTX)->jump)
|
||||
#define MEM_KEEP_ALIAS_SET_P(RTX) (RTL_FLAG_CHECK1((RTX), MEM)->jump)
|
||||
|
||||
/* For a MEM rtx, 1 if it's a volatile reference.
|
||||
Also in an ASM_OPERANDS rtx. */
|
||||
#define MEM_VOLATILE_P(RTX) ((RTX)->volatil)
|
||||
#define MEM_VOLATILE_P(RTX) (RTL_FLAG_CHECK2((RTX), MEM, ASM_OPERANDS)->volatil)
|
||||
|
||||
/* For a MEM rtx, 1 if it refers to an aggregate, either to the
|
||||
aggregate itself of to a field of the aggregate. If zero, RTX may
|
||||
or may not be such a reference. */
|
||||
#define MEM_IN_STRUCT_P(RTX) ((RTX)->in_struct)
|
||||
#define MEM_IN_STRUCT_P(RTX) (RTL_FLAG_CHECK1((RTX), MEM)->in_struct)
|
||||
|
||||
/* For a MEM rtx, 1 if it refers to a scalar. If zero, RTX may or may
|
||||
not refer to a scalar. */
|
||||
#define MEM_SCALAR_P(RTX) ((RTX)->frame_related)
|
||||
#define MEM_SCALAR_P(RTX) (RTL_FLAG_CHECK1((RTX), MEM)->frame_related)
|
||||
|
||||
/* If VAL is non-zero, set MEM_IN_STRUCT_P and clear MEM_SCALAR_P in
|
||||
RTX. Otherwise, vice versa. Use this macro only when you are
|
||||
|
|
@ -965,27 +1071,31 @@ do { \
|
|||
|
||||
/* For a LABEL_REF, 1 means that this reference is to a label outside the
|
||||
loop containing the reference. */
|
||||
#define LABEL_OUTSIDE_LOOP_P(RTX) ((RTX)->in_struct)
|
||||
#define LABEL_OUTSIDE_LOOP_P(RTX) (RTL_FLAG_CHECK1((RTX), LABEL_REF)->in_struct)
|
||||
|
||||
/* For a LABEL_REF, 1 means it is for a nonlocal label. */
|
||||
/* Likewise in an EXPR_LIST for a REG_LABEL note. */
|
||||
#define LABEL_REF_NONLOCAL_P(RTX) ((RTX)->volatil)
|
||||
#define LABEL_REF_NONLOCAL_P(RTX) \
|
||||
(RTL_FLAG_CHECK2((RTX), LABEL_REF, REG_LABEL)->volatil)
|
||||
|
||||
/* For a CODE_LABEL, 1 means always consider this label to be needed. */
|
||||
#define LABEL_PRESERVE_P(RTX) ((RTX)->in_struct)
|
||||
#define LABEL_PRESERVE_P(RTX) \
|
||||
(RTL_FLAG_CHECK2((RTX), CODE_LABEL, NOTE)->in_struct)
|
||||
|
||||
/* For a REG, 1 means the register is used only in an exit test of a loop. */
|
||||
#define REG_LOOP_TEST_P(RTX) ((RTX)->in_struct)
|
||||
#define REG_LOOP_TEST_P(RTX) (RTL_FLAG_CHECK1((RTX), REG)->in_struct)
|
||||
|
||||
/* During sched, for an insn, 1 means that the insn must be scheduled together
|
||||
with the preceding insn. */
|
||||
#define SCHED_GROUP_P(INSN) ((INSN)->in_struct)
|
||||
#define SCHED_GROUP_P(RTX) \
|
||||
(RTL_FLAG_CHECK6((RTX), INSN, JUMP_INSN, CALL_INSN, CODE_LABEL, \
|
||||
BARRIER, NOTE)->in_struct)
|
||||
|
||||
/* For a SET rtx, SET_DEST is the place that is set
|
||||
and SET_SRC is the value it is set to. */
|
||||
#define SET_DEST(RTX) XC2EXP(RTX, 0, SET, CLOBBER)
|
||||
#define SET_SRC(RTX) XCEXP(RTX, 1, SET)
|
||||
#define SET_IS_RETURN_P(RTX) ((RTX)->jump)
|
||||
#define SET_IS_RETURN_P(RTX) (RTL_FLAG_CHECK1((RTX), SET)->jump)
|
||||
|
||||
/* For a TRAP_IF rtx, TRAP_CONDITION is an expression. */
|
||||
#define TRAP_CONDITION(RTX) XCEXP (RTX, 0, TRAP_IF)
|
||||
|
|
@ -998,19 +1108,21 @@ do { \
|
|||
#define COND_EXEC_CODE(RTX) XCEXP (RTX, 1, COND_EXEC)
|
||||
|
||||
/* 1 in a SYMBOL_REF if it addresses this function's constants pool. */
|
||||
#define CONSTANT_POOL_ADDRESS_P(RTX) ((RTX)->unchanging)
|
||||
#define CONSTANT_POOL_ADDRESS_P(RTX) \
|
||||
(RTL_FLAG_CHECK1((RTX), SYMBOL_REF)->unchanging)
|
||||
|
||||
/* 1 in a SYMBOL_REF if it addresses this function's string constant pool. */
|
||||
#define STRING_POOL_ADDRESS_P(RTX) ((RTX)->frame_related)
|
||||
#define STRING_POOL_ADDRESS_P(RTX) \
|
||||
(RTL_FLAG_CHECK1((RTX), SYMBOL_REF)->frame_related)
|
||||
|
||||
/* Flag in a SYMBOL_REF for machine-specific purposes. */
|
||||
#define SYMBOL_REF_FLAG(RTX) ((RTX)->volatil)
|
||||
#define SYMBOL_REF_FLAG(RTX) (RTL_FLAG_CHECK1((RTX), SYMBOL_REF)->volatil)
|
||||
|
||||
/* 1 means a SYMBOL_REF has been the library function in emit_library_call. */
|
||||
#define SYMBOL_REF_USED(RTX) ((RTX)->used)
|
||||
#define SYMBOL_REF_USED(RTX) (RTL_FLAG_CHECK1((RTX), SYMBOL_REF)->used)
|
||||
|
||||
/* 1 means a SYMBOL_REF is weak. */
|
||||
#define SYMBOL_REF_WEAK(RTX) ((RTX)->integrated)
|
||||
#define SYMBOL_REF_WEAK(RTX) (RTL_FLAG_CHECK1((RTX), SYMBOL_REF)->integrated)
|
||||
|
||||
/* Define a macro to look for REG_INC notes,
|
||||
but save time on machines where they never exist. */
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue