On 10/5/19 9:24 AM, Jakub Jelinek wrote:
> On Sat, Oct 05, 2019 at 06:12:37AM +0000, Bernd Edlinger wrote:
>> On 10/3/19 5:25 PM, Jakub Jelinek wrote:
>>> Does this affect debuggability of --enable-checking=yes,rtl compilers?
>>> I mean, often when we replace some macros with inlines step in GDB
>>> becomes a bigger nightmare, having to go through tons of inline frames.
>>> gdbinit.in has a lengthy list of inlines to skip in rtl.h, shouldn't this be
>>> added to that list? Not 100% sure how well it will work on rtl checking
>>> vs. non-rtl checking builds.
>>>
>>
>> I don't see a big problem here. If I type "s" in gdb it jumps to the check
>> function and the next s jumps back, adding skip instructions in gdbinit.in
>> does not seem to have any effect for me, but the debug is not that
>> uncomfortable
>> anyway.
>>
>> Interesting is that gdb also jumps in the check function when I press n.
>> That is also Independent of the gdbinit.in, seems to be a bug due to inlining
>> code from another line than the original macro, but nothing terrilby bad.
>
> Unfortunately, for me the above two counts as terribly bad, show
> stopper here. A lot of function calls in RTL are like:
> rtx_equal_for_memref_p (XEXP (x, 0), XEXP (y, 0))
> rtx_equal_p (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y))
> force_operand (XEXP (dest_mem, 0), target)
> etc. (just random examples), during debugging one is absolutely
> uninterested in stepping into the implementation of XEXP, you know what it
> means, you want to go stright into the rtx_equal_for_memref_p etc. call.
> It is already bad that one has to step through the poly_int* stuff or
> rhs_regno for REGNO (we should add rhs_regno to gdbinit.in and some of the
> poly_int* stuff too). And no, one can't use n instead of s, because then
> the whole call is skipped. b rtx_equal_for_memref_p; n works, but it is
> time consuming and one needs to delete the breakpoint again.
>
Okay, I think I have fixed both the "s" ignoring the skip status on inlined
subroutines, with a gdb-patch I posted here:
http://sourceware.org/ml/gdb-patches/2019-10/msg00685.html
And the "n" jumping in the bottom half if the inlined template, will be fixed
by the patch "Fix dwarf-lineinfo inconsistency of inlined subroutines"
which I posted here:
https://gcc.gnu.org/ml/gcc-patches/2019-10/msg01459.html
Those only affect optimized code, and are already there with the tree.h
as you will probably know.
With those two patches the rtl-checking patch creates both on non-optimized
stage-1 compiler and an optimized stage-3 compiler a very consistent debug
impression.
I have cleaned up the rtl checking patch once more, removed the no longer used
RTL_CHECKC3, XC3EXP macros, and found a way to suppress a template
specialization
in gdbinit.in using a regular expression matching syntax, instead of suppressing
all of rtl.h, that might be more specific than suppressing per file.
Suppressing all of rtl.h would work as well, if that is considered a better
approach.
Now I think the show-stoppers, regarding debuggability of the template-driven
rtl-checking macros are no longer an issue, right?
Also performance-wise it is better than what we had before, IMHO.
Bootstrapped and reg-tested on x86_64-pc-linux-gnu.
Is it OK for trunk?
Thanks
Bernd.
2019-10-04 Bernd Edlinger <bernd.edlin...@hotmail.de>
* gdbinit.in: Add skip for the new rtl checking templates.
* rtl.h (RTL_CHECK1, RTL_CHECK2, RTL_CHECKC1, RTL_CHECKC2
RTVEC_ELT): Reimplement with inline functions.
(RTL_CHECKC3, XC3EXP): Remove.
(RTL_FLAG_CHECK): New variadic macro.
(RTL_FLAG_CHECK1-6): Use RTL_FLAG_CHECK.
(RTL_FLAG_CHECK7): Remove.
(rtvec_check): New helper function.
(rtl_check_bounds, rtl_check_code,
rtl_flag_check): New helper templates.
* rtl.c (rtl_check_failed_code3): Remove.
Index: gcc/gdbinit.in
===================================================================
--- gcc/gdbinit.in (revision 277155)
+++ gcc/gdbinit.in (working copy)
@@ -299,6 +299,10 @@ skip PATTERN
skip INSN_LOCATION
skip INSN_HAS_LOCATION
skip JUMP_LABEL_AS_INSN
+skip rtvec_check
+skip -rfunction rtl_check_bounds<.*>
+skip -rfunction rtl_check_code<.*>
+skip -rfunction rtl_flag_check<.*>
# Restore pagination to the previous state.
python if __gcc_prev_pagination: gdb.execute("set pagination on")
Index: gcc/rtl.c
===================================================================
--- gcc/rtl.c (revision 277155)
+++ gcc/rtl.c (working copy)
@@ -892,17 +892,6 @@ rtl_check_failed_code2 (const_rtx r, enum rtx_code
}
void
-rtl_check_failed_code3 (const_rtx r, enum rtx_code code1, enum rtx_code code2,
- enum rtx_code code3, const char *file, int line,
- const char *func)
-{
- internal_error
- ("RTL check: expected code '%s', '%s' or '%s', have '%s' in %s, at %s:%d",
- GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (code3),
- GET_RTX_NAME (GET_CODE (r)), func, trim_filename (file), line);
-}
-
-void
rtl_check_failed_code_mode (const_rtx r, enum rtx_code code, machine_mode mode,
bool not_mode, const char *file, int line,
const char *func)
Index: gcc/rtl.h
===================================================================
--- gcc/rtl.h (revision 277155)
+++ gcc/rtl.h (working copy)
@@ -1070,59 +1070,21 @@ is_a_helper <rtx_note *>::test (rtx_insn *insn)
#if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
/* The bit with a star outside the statement expr and an & inside is
so that N can be evaluated only once. */
-#define RTL_CHECK1(RTX, N, C1) __extension__ \
-(*({ __typeof (RTX) const _rtx = (RTX); const int _n = (N); \
- const enum rtx_code _code = GET_CODE (_rtx); \
- if (_n < 0 || _n >= GET_RTX_LENGTH (_code)) \
- rtl_check_failed_bounds (_rtx, _n, __FILE__, __LINE__, \
- __FUNCTION__); \
- if (GET_RTX_FORMAT (_code)[_n] != C1) \
- rtl_check_failed_type1 (_rtx, _n, C1, __FILE__, __LINE__, \
- __FUNCTION__); \
- &_rtx->u.fld[_n]; }))
+#define RTL_CHECK1(RTX, N, C1) \
+ rtl_check_bounds<C1> (RTX, N, __FILE__, __LINE__, __FUNCTION__)
-#define RTL_CHECK2(RTX, N, C1, C2) __extension__ \
-(*({ __typeof (RTX) const _rtx = (RTX); const int _n = (N); \
- const enum rtx_code _code = GET_CODE (_rtx); \
- if (_n < 0 || _n >= GET_RTX_LENGTH (_code)) \
- rtl_check_failed_bounds (_rtx, _n, __FILE__, __LINE__, \
- __FUNCTION__); \
- if (GET_RTX_FORMAT (_code)[_n] != C1 \
- && GET_RTX_FORMAT (_code)[_n] != C2) \
- rtl_check_failed_type2 (_rtx, _n, C1, C2, __FILE__, __LINE__, \
- __FUNCTION__); \
- &_rtx->u.fld[_n]; }))
+#define RTL_CHECK2(RTX, N, C1, C2) \
+ rtl_check_bounds<C1, C2> (RTX, N, __FILE__, __LINE__, __FUNCTION__)
-#define RTL_CHECKC1(RTX, N, C) __extension__ \
-(*({ __typeof (RTX) const _rtx = (RTX); const int _n = (N); \
- if (GET_CODE (_rtx) != (C)) \
- rtl_check_failed_code1 (_rtx, (C), __FILE__, __LINE__, \
- __FUNCTION__); \
- &_rtx->u.fld[_n]; }))
+#define RTL_CHECKC1(RTX, N, C1) \
+ rtl_check_code<C1> (RTX, N, __FILE__, __LINE__, __FUNCTION__)
-#define RTL_CHECKC2(RTX, N, C1, C2) __extension__ \
-(*({ __typeof (RTX) const _rtx = (RTX); const int _n = (N); \
- const enum rtx_code _code = GET_CODE (_rtx); \
- if (_code != (C1) && _code != (C2)) \
- rtl_check_failed_code2 (_rtx, (C1), (C2), __FILE__, __LINE__, \
- __FUNCTION__); \
- &_rtx->u.fld[_n]; }))
+#define RTL_CHECKC2(RTX, N, C1, C2) \
+ rtl_check_code<C1, C2> (RTX, N, __FILE__, __LINE__, __FUNCTION__)
-#define RTL_CHECKC3(RTX, N, C1, C2, C3) __extension__ \
-(*({ __typeof (RTX) const _rtx = (RTX); const int _n = (N); \
- const enum rtx_code _code = GET_CODE (_rtx); \
- if (_code != (C1) && _code != (C2) && _code != (C3)) \
- rtl_check_failed_code3 (_rtx, (C1), (C2), (C3), __FILE__, \
- __LINE__, __FUNCTION__); \
- &_rtx->u.fld[_n]; }))
+#define RTVEC_ELT(RTVEC, I) \
+ rtvec_check (RTVEC, I, __FILE__, __LINE__, __FUNCTION__)
-#define RTVEC_ELT(RTVEC, I) __extension__ \
-(*({ __typeof (RTVEC) const _rtvec = (RTVEC); const int _i = (I); \
- if (_i < 0 || _i >= GET_NUM_ELEM (_rtvec)) \
- rtvec_check_failed_bounds (_rtvec, _i, __FILE__, __LINE__, \
- __FUNCTION__); \
- &_rtvec->elem[_i]; }))
-
#define XWINT(RTX, N) __extension__ \
(*({ __typeof (RTX) const _rtx = (RTX); const int _n = (N); \
const enum rtx_code _code = GET_CODE (_rtx); \
@@ -1206,10 +1168,6 @@ extern void rtl_check_failed_code1 (const_rtx, enu
extern void rtl_check_failed_code2 (const_rtx, enum rtx_code, enum rtx_code,
const char *, int, const char *)
ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
-extern void rtl_check_failed_code3 (const_rtx, enum rtx_code, enum rtx_code,
- enum rtx_code, const char *, int,
- const char *)
- ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
extern void rtl_check_failed_code_mode (const_rtx, enum rtx_code, machine_mode,
bool, const char *, int, const char *)
ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
@@ -1222,6 +1180,120 @@ extern void rtvec_check_failed_bounds (const_rtvec
const char *)
ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
+static inline rtx const&
+rtvec_check (const_rtvec vec, int i,
+ const char *file, int line, const char *func)
+{
+ if (i < 0 || i >= GET_NUM_ELEM (vec))
+ rtvec_check_failed_bounds (vec, i, file, line, func);
+ return vec->elem[i];
+}
+
+static inline rtx&
+rtvec_check (rtvec vec, int i,
+ const char *file, int line, const char *func)
+{
+ if (i < 0 || i >= GET_NUM_ELEM (vec))
+ rtvec_check_failed_bounds (vec, i, file, line, func);
+ return vec->elem[i];
+}
+
+template<char C1>
+inline const rtunion&
+rtl_check_bounds (const_rtx rtl, int n,
+ const char *file, int line, const char *function)
+{
+ const enum rtx_code code = GET_CODE (rtl);
+ if (n < 0 || n >= GET_RTX_LENGTH (code))
+ rtl_check_failed_bounds (rtl, n, file, line, function);
+ if (GET_RTX_FORMAT (code)[n] != C1)
+ rtl_check_failed_type1 (rtl, n, C1, file, line, function);
+ return rtl->u.fld[n];
+}
+
+template<char C1>
+inline rtunion&
+rtl_check_bounds (rtx rtl, int n,
+ const char *file, int line, const char *function)
+{
+ const enum rtx_code code = GET_CODE (rtl);
+ if (n < 0 || n >= GET_RTX_LENGTH (code))
+ rtl_check_failed_bounds (rtl, n, file, line, function);
+ if (GET_RTX_FORMAT (code)[n] != C1)
+ rtl_check_failed_type1 (rtl, n, C1, file, line, function);
+ return rtl->u.fld[n];
+}
+
+template<char C1, char C2>
+inline const rtunion&
+rtl_check_bounds (const_rtx rtl, int n,
+ const char *file, int line, const char *function)
+{
+ const enum rtx_code code = GET_CODE (rtl);
+ if (n < 0 || n >= GET_RTX_LENGTH (code))
+ rtl_check_failed_bounds (rtl, n, file, line, function);
+ if (GET_RTX_FORMAT (code)[n] != C1
+ && GET_RTX_FORMAT (code)[n] != C2)
+ rtl_check_failed_type2 (rtl, n, C1, C2, file, line, function);
+ return rtl->u.fld[n];
+}
+
+template<char C1, char C2>
+inline rtunion&
+rtl_check_bounds (rtx rtl, int n,
+ const char *file, int line, const char *function)
+{
+ const enum rtx_code code = GET_CODE (rtl);
+ if (n < 0 || n >= GET_RTX_LENGTH (code))
+ rtl_check_failed_bounds (rtl, n, file, line, function);
+ if (GET_RTX_FORMAT (code)[n] != C1
+ && GET_RTX_FORMAT (code)[n] != C2)
+ rtl_check_failed_type2 (rtl, n, C1, C2, file, line, function);
+ return rtl->u.fld[n];
+}
+
+template<RTX_CODE C1>
+inline const rtunion&
+rtl_check_code (const_rtx rtl, int n,
+ const char *file, int line, const char *function)
+{
+ if (GET_CODE (rtl) != C1)
+ rtl_check_failed_code1 (rtl, C1, file, line, function);
+ return rtl->u.fld[n];
+}
+
+template<RTX_CODE C1>
+inline rtunion&
+rtl_check_code (rtx rtl, int n,
+ const char *file, int line, const char *function)
+{
+ if (GET_CODE (rtl) != C1)
+ rtl_check_failed_code1 (rtl, C1, file, line, function);
+ return rtl->u.fld[n];
+}
+
+template<RTX_CODE C1, RTX_CODE C2>
+inline const rtunion&
+rtl_check_code (const_rtx rtl, int n,
+ const char *file, int line, const char *function)
+{
+ if (GET_CODE (rtl) != C1
+ && GET_CODE (rtl) != C2)
+ rtl_check_failed_code2 (rtl, C1, C2, file, line, function);
+ return rtl->u.fld[n];
+}
+
+template<RTX_CODE C1, RTX_CODE C2>
+inline rtunion&
+rtl_check_code (rtx rtl, int n,
+ const char *file, int line, const char *function)
+{
+ if (GET_CODE (rtl) != C1
+ && GET_CODE (rtl) != C2)
+ rtl_check_failed_code2 (rtl, C1, C2, file, line, function);
+ return rtl->u.fld[n];
+}
+
#else /* not ENABLE_RTL_CHECKING */
#define RTL_CHECK1(RTX, N, C1) ((RTX)->u.fld[N])
@@ -1228,7 +1300,6 @@ extern void rtvec_check_failed_bounds (const_rtvec
#define RTL_CHECK2(RTX, N, C1, C2) ((RTX)->u.fld[N])
#define RTL_CHECKC1(RTX, N, C) ((RTX)->u.fld[N])
#define RTL_CHECKC2(RTX, N, C1, C2) ((RTX)->u.fld[N])
-#define RTL_CHECKC3(RTX, N, C1, C2, C3) ((RTX)->u.fld[N])
#define RTVEC_ELT(RTVEC, I) ((RTVEC)->elem[I])
#define XWINT(RTX, N) ((RTX)->u.hwint[N])
#define CWI_ELT(RTX, I) ((RTX)->u.hwiv.elem[I])
@@ -1249,66 +1320,17 @@ extern void rtvec_check_failed_bounds (const_rtvec
#define RTX_FLAG(RTX, FLAG) ((RTX)->FLAG)
#if defined ENABLE_RTL_FLAG_CHECKING && (GCC_VERSION >= 2007)
-#define RTL_FLAG_CHECK1(NAME, RTX, C1) __extension__ \
-({ __typeof (RTX) const _rtx = (RTX); \
- if (GET_CODE (_rtx) != C1) \
- rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \
- __FUNCTION__); \
- _rtx; })
+#define RTL_FLAG_CHECK(NAME, RTX, ...) \
+ rtl_flag_check<__VA_ARGS__> (NAME, RTX, __FILE__, __LINE__, \
+ __FUNCTION__)
-#define RTL_FLAG_CHECK2(NAME, RTX, C1, C2) __extension__ \
-({ __typeof (RTX) const _rtx = (RTX); \
- if (GET_CODE (_rtx) != C1 && GET_CODE(_rtx) != C2) \
- rtl_check_failed_flag (NAME,_rtx, __FILE__, __LINE__, \
- __FUNCTION__); \
- _rtx; })
+#define RTL_FLAG_CHECK1 RTL_FLAG_CHECK
+#define RTL_FLAG_CHECK2 RTL_FLAG_CHECK
+#define RTL_FLAG_CHECK3 RTL_FLAG_CHECK
+#define RTL_FLAG_CHECK4 RTL_FLAG_CHECK
+#define RTL_FLAG_CHECK5 RTL_FLAG_CHECK
+#define RTL_FLAG_CHECK6 RTL_FLAG_CHECK
-#define RTL_FLAG_CHECK3(NAME, RTX, C1, C2, C3) __extension__ \
-({ __typeof (RTX) const _rtx = (RTX); \
- if (GET_CODE (_rtx) != C1 && GET_CODE(_rtx) != C2 \
- && GET_CODE (_rtx) != C3) \
- rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \
- __FUNCTION__); \
- _rtx; })
-
-#define RTL_FLAG_CHECK4(NAME, RTX, C1, C2, C3, C4) __extension__ \
-({ __typeof (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 (NAME, _rtx, __FILE__, __LINE__, \
- __FUNCTION__); \
- _rtx; })
-
-#define RTL_FLAG_CHECK5(NAME, RTX, C1, C2, C3, C4, C5) __extension__ \
-({ __typeof (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 (NAME, _rtx, __FILE__, __LINE__, \
- __FUNCTION__); \
- _rtx; })
-
-#define RTL_FLAG_CHECK6(NAME, RTX, C1, C2, C3, C4, C5, C6) \
- __extension__ \
-({ __typeof (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 (NAME,_rtx, __FILE__, __LINE__, \
- __FUNCTION__); \
- _rtx; })
-
-#define RTL_FLAG_CHECK7(NAME, RTX, C1, C2, C3, C4, C5, C6, C7) \
- __extension__ \
-({ __typeof (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 (NAME, _rtx, __FILE__, __LINE__, \
- __FUNCTION__); \
- _rtx; })
-
#define RTL_INSN_CHAIN_FLAG_CHECK(NAME, RTX) \
__extension__ \
({ __typeof (RTX) const _rtx = (RTX); \
@@ -1322,6 +1344,75 @@ extern void rtl_check_failed_flag (const char *, c
ATTRIBUTE_NORETURN ATTRIBUTE_COLD
;
+template<RTX_CODE C1, typename T>
+inline T
+rtl_flag_check (const char *name, T rtl,
+ const char *file, int line, const char *func)
+{
+ if (GET_CODE (rtl) != C1)
+ rtl_check_failed_flag (name, rtl, file, line, func);
+ return rtl;
+}
+
+template<RTX_CODE C1, RTX_CODE C2, typename T>
+inline T
+rtl_flag_check (const char *name, T rtl,
+ const char *file, int line, const char *func)
+{
+ if (GET_CODE (rtl) != C1 && GET_CODE (rtl) != C2)
+ rtl_check_failed_flag (name, rtl, file, line, func);
+ return rtl;
+}
+
+template<RTX_CODE C1, RTX_CODE C2, RTX_CODE C3, typename T>
+inline T
+rtl_flag_check (const char *name, T rtl,
+ const char *file, int line, const char *func)
+{
+ if (GET_CODE (rtl) != C1 && GET_CODE (rtl) != C2
+ && GET_CODE (rtl) != C3)
+ rtl_check_failed_flag (name, rtl, file, line, func);
+ return rtl;
+}
+
+template<RTX_CODE C1, RTX_CODE C2, RTX_CODE C3,
+ RTX_CODE C4, typename T>
+inline T
+rtl_flag_check (const char *name, T rtl,
+ const char *file, int line, const char *func)
+{
+ if (GET_CODE (rtl) != C1 && GET_CODE (rtl) != C2
+ && GET_CODE (rtl) != C3 && GET_CODE (rtl) != C4)
+ rtl_check_failed_flag (name, rtl, file, line, func);
+ return rtl;
+}
+
+template<RTX_CODE C1, RTX_CODE C2, RTX_CODE C3,
+ RTX_CODE C4, RTX_CODE C5, typename T>
+inline T
+rtl_flag_check (const char *name, T rtl,
+ const char *file, int line, const char *func)
+{
+ if (GET_CODE (rtl) != C1 && GET_CODE (rtl) != C2
+ && GET_CODE (rtl) != C3 && GET_CODE (rtl) != C4
+ && GET_CODE (rtl) != C5)
+ rtl_check_failed_flag (name, rtl, file, line, func);
+ return rtl;
+}
+
+template<RTX_CODE C1, RTX_CODE C2, RTX_CODE C3,
+ RTX_CODE C4, RTX_CODE C5, RTX_CODE C6, typename T>
+inline T
+rtl_flag_check (const char *name, T rtl,
+ const char *file, int line, const char *func)
+{
+ if (GET_CODE (rtl) != C1 && GET_CODE (rtl) != C2
+ && GET_CODE (rtl) != C3 && GET_CODE (rtl) != C4
+ && GET_CODE (rtl) != C5 && GET_CODE (rtl) != C6)
+ rtl_check_failed_flag (name, rtl, file, line, func);
+ return rtl;
+}
+
#else /* not ENABLE_RTL_FLAG_CHECKING */
#define RTL_FLAG_CHECK1(NAME, RTX, C1) (RTX)
@@ -1330,7 +1421,6 @@ extern void rtl_check_failed_flag (const char *, c
#define RTL_FLAG_CHECK4(NAME, RTX, C1, C2, C3, C4) (RTX)
#define RTL_FLAG_CHECK5(NAME, RTX, C1, C2, C3, C4, C5) (RTX)
#define RTL_FLAG_CHECK6(NAME, RTX, C1, C2, C3, C4, C5, C6) (RTX)
-#define RTL_FLAG_CHECK7(NAME, RTX, C1, C2, C3, C4, C5, C6, C7) (RTX)
#define RTL_INSN_CHAIN_FLAG_CHECK(NAME, RTX) (RTX)
#endif
@@ -1383,7 +1473,6 @@ extern void rtl_check_failed_flag (const char *, c
#define XCVECLEN(RTX, N, C) GET_NUM_ELEM (XCVEC (RTX, N, C))
#define XC2EXP(RTX, N, C1, C2) (RTL_CHECKC2 (RTX, N, C1, C2).rt_rtx)
-#define XC3EXP(RTX, N, C1, C2, C3) (RTL_CHECKC3 (RTX, N, C1, C2, C3).rt_rtx)
/* Methods of rtx_expr_list. */
