mirror of
git://gcc.gnu.org/git/gcc.git
synced 2025-03-09 07:26:45 +08:00
optabs.c: Use gen_rtx_FOO (...) instead of gen_rtx (FOO, ...).
* optabs.c: Use gen_rtx_FOO (...) instead of gen_rtx (FOO, ...). * expr.c: Likewise. * explow.c: Likewise. * combine.c: Likewise. * reload1.c: Likewise. * gcse.c: Likewise. From-SVN: r20701
This commit is contained in:
John Carr
John Carr
parent
55a6ba9ff3
commit
9e6a570365
@ -6,6 +6,13 @@ Wed Jun 24 16:27:23 1998 John Carr <jfc@mit.edu>
|
||||
|
||||
* expmed.c (init_expmed): Initialize all elements of *_cost arrays.
|
||||
|
||||
* optabs.c: Use gen_rtx_FOO (...) instead of gen_rtx (FOO, ...).
|
||||
* expr.c: Likewise.
|
||||
* explow.c: Likewise.
|
||||
* combine.c: Likewise.
|
||||
* reload1.c: Likewise.
|
||||
* gcse.c: Likewise.
|
||||
|
||||
Wed Jun 24 15:13:01 1998 Dave Brolley <brolley@cygnus.com>
|
||||
|
||||
* README.gnat: Add patch for new lang_decode_options interface.
|
||||
|
||||
@ -11552,8 +11552,9 @@ distribute_notes (notes, from_insn, i3, i2, elim_i2, elim_i1)
|
||||
if (! find_regno_note (tem, REG_UNUSED,
|
||||
REGNO (XEXP (note, 0))))
|
||||
REG_NOTES (tem)
|
||||
= gen_rtx (EXPR_LIST, REG_UNUSED, XEXP (note, 0),
|
||||
REG_NOTES (tem));
|
||||
= gen_rtx_EXPR_LIST (REG_UNUSED,
|
||||
XEXP (note, 0),
|
||||
REG_NOTES (tem));
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
@ -1258,9 +1258,9 @@ allocate_dynamic_stack_space (size, target, known_align)
|
||||
{
|
||||
rtx note_target = get_last_insn ();
|
||||
|
||||
REG_NOTES (note_target) = gen_rtx (EXPR_LIST, REG_SAVE_AREA,
|
||||
setjmpless_size,
|
||||
REG_NOTES (note_target));
|
||||
REG_NOTES (note_target)
|
||||
= gen_rtx_EXPR_LIST (REG_SAVE_AREA, setjmpless_size,
|
||||
REG_NOTES (note_target));
|
||||
}
|
||||
#endif /* SETJMP_VIA_SAVE_AREA */
|
||||
#ifdef STACK_GROWS_DOWNWARD
|
||||
|
||||
@ -2289,7 +2289,7 @@ emit_move_insn_1 (x, y)
|
||||
{
|
||||
/* Show the output dies here. */
|
||||
if (x != y)
|
||||
emit_insn (gen_rtx (CLOBBER, VOIDmode, x));
|
||||
emit_insn (gen_rtx_CLOBBER (VOIDmode, x));
|
||||
|
||||
emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
|
||||
(gen_realpart (submode, x), gen_realpart (submode, y)));
|
||||
@ -2639,7 +2639,7 @@ emit_push_insn (x, mode, type, size, align, partial, reg, extra,
|
||||
{
|
||||
rtx opalign = GEN_INT (align);
|
||||
enum machine_mode mode;
|
||||
rtx target = gen_rtx (MEM, BLKmode, temp);
|
||||
rtx target = gen_rtx_MEM (BLKmode, temp);
|
||||
|
||||
for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
|
||||
mode != VOIDmode;
|
||||
|
||||
13
gcc/gcse.c
13
gcc/gcse.c
@ -805,8 +805,8 @@ compute_can_copy ()
|
||||
#ifdef AVOID_CCMODE_COPIES
|
||||
can_copy_p[i] = 0;
|
||||
#else
|
||||
reg = gen_rtx (REG, (enum machine_mode) i, LAST_VIRTUAL_REGISTER + 1);
|
||||
insn = emit_insn (gen_rtx (SET, VOIDmode, reg, reg));
|
||||
reg = gen_rtx_REG ((enum machine_mode) i, LAST_VIRTUAL_REGISTER + 1);
|
||||
insn = emit_insn (gen_rtx_SET (VOIDmode, reg, reg));
|
||||
if (recog (PATTERN (insn), insn, NULL_PTR) >= 0)
|
||||
can_copy_p[i] = 1;
|
||||
#endif
|
||||
@ -3139,8 +3139,9 @@ handle_avail_expr (insn, expr)
|
||||
/* Generate the new insn. */
|
||||
/* ??? If the change fails, we return 0, even though we created
|
||||
an insn. I think this is ok. */
|
||||
new_insn = emit_insn_after (gen_rtx (SET, VOIDmode, to,
|
||||
SET_DEST (PATTERN (insn_computes_expr))),
|
||||
new_insn
|
||||
= emit_insn_after (gen_rtx_SET (VOIDmode, to,
|
||||
SET_DEST (PATTERN (insn_computes_expr))),
|
||||
insn_computes_expr);
|
||||
/* Keep block number table up to date. */
|
||||
set_block_num (new_insn, BLOCK_NUM (insn_computes_expr));
|
||||
@ -4321,7 +4322,7 @@ pre_insert_insn (expr, bb)
|
||||
int regno = REGNO (reg);
|
||||
rtx pat;
|
||||
|
||||
pat = gen_rtx (SET, VOIDmode, reg, copy_rtx (expr->expr));
|
||||
pat = gen_rtx_SET (VOIDmode, reg, copy_rtx (expr->expr));
|
||||
|
||||
/* If the last insn is a jump, insert EXPR in front [taking care to
|
||||
handle cc0, etc. properly]. */
|
||||
@ -4443,7 +4444,7 @@ pre_insert_copy_insn (expr, insn)
|
||||
|
||||
if (!set)
|
||||
abort ();
|
||||
new_insn = emit_insn_after (gen_rtx (SET, VOIDmode, reg, SET_DEST (set)),
|
||||
new_insn = emit_insn_after (gen_rtx_SET (VOIDmode, reg, SET_DEST (set)),
|
||||
insn);
|
||||
/* Keep block number table up to date. */
|
||||
set_block_num (new_insn, BLOCK_NUM (insn));
|
||||
|
||||
322
gcc/optabs.c
322
gcc/optabs.c
@ -293,13 +293,13 @@ add_equal_note (seq, target, code, op0, op1)
|
||||
return 0;
|
||||
|
||||
if (GET_RTX_CLASS (code) == '1')
|
||||
note = gen_rtx (code, GET_MODE (target), copy_rtx (op0));
|
||||
note = gen_rtx_fmt_e (code, GET_MODE (target), copy_rtx (op0));
|
||||
else
|
||||
note = gen_rtx (code, GET_MODE (target), copy_rtx (op0), copy_rtx (op1));
|
||||
note = gen_rtx_fmt_ee (code, GET_MODE (target), copy_rtx (op0), copy_rtx (op1));
|
||||
|
||||
REG_NOTES (XVECEXP (seq, 0, XVECLEN (seq, 0) - 1))
|
||||
= gen_rtx (EXPR_LIST, REG_EQUAL, note,
|
||||
REG_NOTES (XVECEXP (seq, 0, XVECLEN (seq, 0) - 1)));
|
||||
= gen_rtx_EXPR_LIST (REG_EQUAL, note,
|
||||
REG_NOTES (XVECEXP (seq, 0, XVECLEN (seq, 0) - 1)));
|
||||
|
||||
return 1;
|
||||
}
|
||||
@ -330,13 +330,13 @@ widen_operand (op, mode, oldmode, unsignedp, no_extend)
|
||||
/* If MODE is no wider than a single word, we return a paradoxical
|
||||
SUBREG. */
|
||||
if (GET_MODE_SIZE (mode) <= UNITS_PER_WORD)
|
||||
return gen_rtx (SUBREG, mode, force_reg (GET_MODE (op), op), 0);
|
||||
return gen_rtx_SUBREG (mode, force_reg (GET_MODE (op), op), 0);
|
||||
|
||||
/* Otherwise, get an object of MODE, clobber it, and set the low-order
|
||||
part to OP. */
|
||||
|
||||
result = gen_reg_rtx (mode);
|
||||
emit_insn (gen_rtx (CLOBBER, VOIDmode, result));
|
||||
emit_insn (gen_rtx_CLOBBER (VOIDmode, result));
|
||||
emit_move_insn (gen_lowpart (GET_MODE (op), result), op);
|
||||
return result;
|
||||
}
|
||||
@ -630,7 +630,8 @@ expand_binop (mode, binoptab, op0, op1, target, unsignedp, methods)
|
||||
{
|
||||
if (binoptab->code != UNKNOWN)
|
||||
equiv_value
|
||||
= gen_rtx (binoptab->code, mode, copy_rtx (op0), copy_rtx (op1));
|
||||
= gen_rtx_fmt_ee (binoptab->code, mode,
|
||||
copy_rtx (op0), copy_rtx (op1));
|
||||
else
|
||||
equiv_value = 0;
|
||||
|
||||
@ -749,7 +750,7 @@ expand_binop (mode, binoptab, op0, op1, target, unsignedp, methods)
|
||||
if (inter != 0)
|
||||
{
|
||||
if (binoptab->code != UNKNOWN)
|
||||
equiv_value = gen_rtx (binoptab->code, mode, op0, op1);
|
||||
equiv_value = gen_rtx_fmt_ee (binoptab->code, mode, op0, op1);
|
||||
else
|
||||
equiv_value = 0;
|
||||
|
||||
@ -863,7 +864,7 @@ expand_binop (mode, binoptab, op0, op1, target, unsignedp, methods)
|
||||
if (inter != 0)
|
||||
{
|
||||
if (binoptab->code != UNKNOWN)
|
||||
equiv_value = gen_rtx (binoptab->code, mode, op0, op1);
|
||||
equiv_value = gen_rtx_fmt_ee (binoptab->code, mode, op0, op1);
|
||||
else
|
||||
equiv_value = 0;
|
||||
|
||||
@ -912,7 +913,7 @@ expand_binop (mode, binoptab, op0, op1, target, unsignedp, methods)
|
||||
|
||||
/* Indicate for flow that the entire target reg is being set. */
|
||||
if (GET_CODE (target) == REG)
|
||||
emit_insn (gen_rtx (CLOBBER, VOIDmode, target));
|
||||
emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
|
||||
|
||||
/* Do the actual arithmetic. */
|
||||
for (i = 0; i < nwords; i++)
|
||||
@ -981,11 +982,12 @@ expand_binop (mode, binoptab, op0, op1, target, unsignedp, methods)
|
||||
{
|
||||
rtx temp = emit_move_insn (target, target);
|
||||
|
||||
REG_NOTES (temp) = gen_rtx (EXPR_LIST, REG_EQUAL,
|
||||
gen_rtx (binoptab->code, mode,
|
||||
copy_rtx (xop0),
|
||||
copy_rtx (xop1)),
|
||||
REG_NOTES (temp));
|
||||
REG_NOTES (temp)
|
||||
= gen_rtx_EXPR_LIST (REG_EQUAL,
|
||||
gen_rtx_fmt_ee (binoptab->code, mode,
|
||||
copy_rtx (xop0),
|
||||
copy_rtx (xop1)),
|
||||
REG_NOTES (temp));
|
||||
}
|
||||
return target;
|
||||
}
|
||||
@ -1163,11 +1165,12 @@ expand_binop (mode, binoptab, op0, op1, target, unsignedp, methods)
|
||||
if (mov_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
|
||||
{
|
||||
temp = emit_move_insn (product, product);
|
||||
REG_NOTES (temp) = gen_rtx (EXPR_LIST, REG_EQUAL,
|
||||
gen_rtx (MULT, mode,
|
||||
copy_rtx (op0),
|
||||
copy_rtx (op1)),
|
||||
REG_NOTES (temp));
|
||||
REG_NOTES (temp)
|
||||
= gen_rtx_EXPR_LIST (REG_EQUAL,
|
||||
gen_rtx_fmt_ee (MULT, mode,
|
||||
copy_rtx (op0),
|
||||
copy_rtx (op1)),
|
||||
REG_NOTES (temp));
|
||||
}
|
||||
return product;
|
||||
}
|
||||
@ -1501,7 +1504,8 @@ expand_binop (mode, binoptab, op0, op1, target, unsignedp, methods)
|
||||
{
|
||||
if (binoptab->code != UNKNOWN)
|
||||
equiv_value
|
||||
= gen_rtx (binoptab->code, mode, copy_rtx (op0), copy_rtx (op1));
|
||||
= gen_rtx_fmt_ee (binoptab->code, mode,
|
||||
copy_rtx (op0), copy_rtx (op1));
|
||||
else
|
||||
equiv_value = 0;
|
||||
|
||||
@ -1547,7 +1551,7 @@ expand_binop (mode, binoptab, op0, op1, target, unsignedp, methods)
|
||||
|
||||
target = gen_reg_rtx (mode);
|
||||
emit_libcall_block (insns, target, value,
|
||||
gen_rtx (binoptab->code, mode, op0, op1));
|
||||
gen_rtx_fmt_ee (binoptab->code, mode, op0, op1));
|
||||
|
||||
return target;
|
||||
}
|
||||
@ -1961,7 +1965,8 @@ expand_unop (mode, unoptab, op0, target, unsignedp)
|
||||
end_sequence ();
|
||||
|
||||
emit_no_conflict_block (insns, target, op0, NULL_RTX,
|
||||
gen_rtx (unoptab->code, mode, copy_rtx (op0)));
|
||||
gen_rtx_fmt_e (unoptab->code, mode,
|
||||
copy_rtx (op0)));
|
||||
return target;
|
||||
}
|
||||
|
||||
@ -2005,7 +2010,8 @@ expand_unop (mode, unoptab, op0, target, unsignedp)
|
||||
end_sequence ();
|
||||
|
||||
emit_no_conflict_block (seq, target, op0, 0,
|
||||
gen_rtx (unoptab->code, mode, copy_rtx (op0)));
|
||||
gen_rtx_fmt_e (unoptab->code, mode,
|
||||
copy_rtx (op0)));
|
||||
return target;
|
||||
}
|
||||
|
||||
@ -2026,7 +2032,7 @@ expand_unop (mode, unoptab, op0, target, unsignedp)
|
||||
|
||||
target = gen_reg_rtx (mode);
|
||||
emit_libcall_block (insns, target, value,
|
||||
gen_rtx (unoptab->code, mode, op0));
|
||||
gen_rtx_fmt_e (unoptab->code, mode, op0));
|
||||
|
||||
return target;
|
||||
}
|
||||
@ -2335,7 +2341,7 @@ expand_complex_abs (mode, op0, target, unsignedp)
|
||||
|
||||
target = gen_reg_rtx (submode);
|
||||
emit_libcall_block (insns, target, value,
|
||||
gen_rtx (abs_optab->code, mode, op0));
|
||||
gen_rtx_fmt_e (abs_optab->code, mode, op0));
|
||||
|
||||
return target;
|
||||
}
|
||||
@ -2511,7 +2517,7 @@ emit_no_conflict_block (insns, target, op0, op1, equiv)
|
||||
/* Now write the CLOBBER of the output, followed by the setting of each
|
||||
of the words, followed by the final copy. */
|
||||
if (target != op0 && target != op1)
|
||||
emit_insn (gen_rtx (CLOBBER, VOIDmode, target));
|
||||
emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
|
||||
|
||||
for (insn = insns; insn; insn = next)
|
||||
{
|
||||
@ -2519,12 +2525,12 @@ emit_no_conflict_block (insns, target, op0, op1, equiv)
|
||||
add_insn (insn);
|
||||
|
||||
if (op1 && GET_CODE (op1) == REG)
|
||||
REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_NO_CONFLICT, op1,
|
||||
REG_NOTES (insn));
|
||||
REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_NO_CONFLICT, op1,
|
||||
REG_NOTES (insn));
|
||||
|
||||
if (op0 && GET_CODE (op0) == REG)
|
||||
REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_NO_CONFLICT, op0,
|
||||
REG_NOTES (insn));
|
||||
REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_NO_CONFLICT, op0,
|
||||
REG_NOTES (insn));
|
||||
}
|
||||
|
||||
if (mov_optab->handlers[(int) GET_MODE (target)].insn_code
|
||||
@ -2533,7 +2539,7 @@ emit_no_conflict_block (insns, target, op0, op1, equiv)
|
||||
last = emit_move_insn (target, target);
|
||||
if (equiv)
|
||||
REG_NOTES (last)
|
||||
= gen_rtx (EXPR_LIST, REG_EQUAL, equiv, REG_NOTES (last));
|
||||
= gen_rtx_EXPR_LIST (REG_EQUAL, equiv, REG_NOTES (last));
|
||||
}
|
||||
else
|
||||
last = get_last_insn ();
|
||||
@ -2544,9 +2550,9 @@ emit_no_conflict_block (insns, target, op0, op1, equiv)
|
||||
first = NEXT_INSN (prev);
|
||||
|
||||
/* Encapsulate the block so it gets manipulated as a unit. */
|
||||
REG_NOTES (first) = gen_rtx (INSN_LIST, REG_LIBCALL, last,
|
||||
REG_NOTES (first));
|
||||
REG_NOTES (last) = gen_rtx (INSN_LIST, REG_RETVAL, first, REG_NOTES (last));
|
||||
REG_NOTES (first) = gen_rtx_INSN_LIST (REG_LIBCALL, last,
|
||||
REG_NOTES (first));
|
||||
REG_NOTES (last) = gen_rtx_INSN_LIST (REG_RETVAL, first, REG_NOTES (last));
|
||||
|
||||
return last;
|
||||
}
|
||||
@ -2631,8 +2637,8 @@ emit_libcall_block (insns, target, result, equiv)
|
||||
last = emit_move_insn (target, result);
|
||||
if (mov_optab->handlers[(int) GET_MODE (target)].insn_code
|
||||
!= CODE_FOR_nothing)
|
||||
REG_NOTES (last) = gen_rtx (EXPR_LIST,
|
||||
REG_EQUAL, copy_rtx (equiv), REG_NOTES (last));
|
||||
REG_NOTES (last) = gen_rtx_EXPR_LIST (REG_EQUAL, copy_rtx (equiv),
|
||||
REG_NOTES (last));
|
||||
|
||||
if (prev == 0)
|
||||
first = get_insns ();
|
||||
@ -2640,9 +2646,9 @@ emit_libcall_block (insns, target, result, equiv)
|
||||
first = NEXT_INSN (prev);
|
||||
|
||||
/* Encapsulate the block so it gets manipulated as a unit. */
|
||||
REG_NOTES (first) = gen_rtx (INSN_LIST, REG_LIBCALL, last,
|
||||
REG_NOTES (first));
|
||||
REG_NOTES (last) = gen_rtx (INSN_LIST, REG_RETVAL, first, REG_NOTES (last));
|
||||
REG_NOTES (first) = gen_rtx_INSN_LIST (REG_LIBCALL, last,
|
||||
REG_NOTES (first));
|
||||
REG_NOTES (last) = gen_rtx_INSN_LIST (REG_RETVAL, first, REG_NOTES (last));
|
||||
}
|
||||
|
||||
/* Generate code to store zero in X. */
|
||||
@ -3376,7 +3382,7 @@ gen_move_insn (x, y)
|
||||
x = gen_lowpart_common (tmode, x1);
|
||||
if (x == 0 && GET_CODE (x1) == MEM)
|
||||
{
|
||||
x = gen_rtx (MEM, tmode, XEXP (x1, 0));
|
||||
x = gen_rtx_MEM (tmode, XEXP (x1, 0));
|
||||
RTX_UNCHANGING_P (x) = RTX_UNCHANGING_P (x1);
|
||||
MEM_IN_STRUCT_P (x) = MEM_IN_STRUCT_P (x1);
|
||||
MEM_VOLATILE_P (x) = MEM_VOLATILE_P (x1);
|
||||
@ -3386,7 +3392,7 @@ gen_move_insn (x, y)
|
||||
y = gen_lowpart_common (tmode, y1);
|
||||
if (y == 0 && GET_CODE (y1) == MEM)
|
||||
{
|
||||
y = gen_rtx (MEM, tmode, XEXP (y1, 0));
|
||||
y = gen_rtx_MEM (tmode, XEXP (y1, 0));
|
||||
RTX_UNCHANGING_P (y) = RTX_UNCHANGING_P (y1);
|
||||
MEM_IN_STRUCT_P (y) = MEM_IN_STRUCT_P (y1);
|
||||
MEM_VOLATILE_P (y) = MEM_VOLATILE_P (y1);
|
||||
@ -3714,7 +3720,7 @@ expand_float (to, from, unsignedp)
|
||||
end_sequence ();
|
||||
|
||||
emit_libcall_block (insns, target, value,
|
||||
gen_rtx (FLOAT, GET_MODE (to), from));
|
||||
gen_rtx_FLOAT (GET_MODE (to), from));
|
||||
}
|
||||
|
||||
done:
|
||||
@ -3860,10 +3866,12 @@ expand_fix (to, from, unsignedp)
|
||||
{
|
||||
/* Make a place for a REG_NOTE and add it. */
|
||||
insn = emit_move_insn (to, to);
|
||||
REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_EQUAL,
|
||||
gen_rtx (UNSIGNED_FIX, GET_MODE (to),
|
||||
copy_rtx (from)),
|
||||
REG_NOTES (insn));
|
||||
REG_NOTES (insn)
|
||||
= gen_rtx_EXPR_LIST (REG_EQUAL,
|
||||
gen_rtx_fmt_e (UNSIGNED_FIX,
|
||||
GET_MODE (to),
|
||||
copy_rtx (from)),
|
||||
REG_NOTES (insn));
|
||||
}
|
||||
return;
|
||||
}
|
||||
@ -3946,8 +3954,8 @@ expand_fix (to, from, unsignedp)
|
||||
end_sequence ();
|
||||
|
||||
emit_libcall_block (insns, target, value,
|
||||
gen_rtx (unsignedp ? UNSIGNED_FIX : FIX,
|
||||
GET_MODE (to), from));
|
||||
gen_rtx_fmt_e (unsignedp ? UNSIGNED_FIX : FIX,
|
||||
GET_MODE (to), from));
|
||||
}
|
||||
|
||||
if (target != to)
|
||||
@ -4026,7 +4034,7 @@ init_libfuncs (optable, first_mode, last_mode, opname, suffix)
|
||||
*p++ = suffix;
|
||||
*p++ = '\0';
|
||||
optable->handlers[(int) mode].libfunc
|
||||
= gen_rtx (SYMBOL_REF, Pmode, libfunc_name);
|
||||
= gen_rtx_SYMBOL_REF (Pmode, libfunc_name);
|
||||
}
|
||||
}
|
||||
|
||||
@ -4207,181 +4215,181 @@ init_optabs ()
|
||||
|
||||
#ifdef MULSI3_LIBCALL
|
||||
smul_optab->handlers[(int) SImode].libfunc
|
||||
= gen_rtx (SYMBOL_REF, Pmode, MULSI3_LIBCALL);
|
||||
= gen_rtx_SYMBOL_REF (Pmode, MULSI3_LIBCALL);
|
||||
#endif
|
||||
#ifdef MULDI3_LIBCALL
|
||||
smul_optab->handlers[(int) DImode].libfunc
|
||||
= gen_rtx (SYMBOL_REF, Pmode, MULDI3_LIBCALL);
|
||||
= gen_rtx_SYMBOL_REF (Pmode, MULDI3_LIBCALL);
|
||||
#endif
|
||||
|
||||
#ifdef DIVSI3_LIBCALL
|
||||
sdiv_optab->handlers[(int) SImode].libfunc
|
||||
= gen_rtx (SYMBOL_REF, Pmode, DIVSI3_LIBCALL);
|
||||
= gen_rtx_SYMBOL_REF (Pmode, DIVSI3_LIBCALL);
|
||||
#endif
|
||||
#ifdef DIVDI3_LIBCALL
|
||||
sdiv_optab->handlers[(int) DImode].libfunc
|
||||
= gen_rtx (SYMBOL_REF, Pmode, DIVDI3_LIBCALL);
|
||||
= gen_rtx_SYMBOL_REF (Pmode, DIVDI3_LIBCALL);
|
||||
#endif
|
||||
|
||||
#ifdef UDIVSI3_LIBCALL
|
||||
udiv_optab->handlers[(int) SImode].libfunc
|
||||
= gen_rtx (SYMBOL_REF, Pmode, UDIVSI3_LIBCALL);
|
||||
= gen_rtx_SYMBOL_REF (Pmode, UDIVSI3_LIBCALL);
|
||||
#endif
|
||||
#ifdef UDIVDI3_LIBCALL
|
||||
udiv_optab->handlers[(int) DImode].libfunc
|
||||
= gen_rtx (SYMBOL_REF, Pmode, UDIVDI3_LIBCALL);
|
||||
= gen_rtx_SYMBOL_REF (Pmode, UDIVDI3_LIBCALL);
|
||||
#endif
|
||||
|
||||
#ifdef MODSI3_LIBCALL
|
||||
smod_optab->handlers[(int) SImode].libfunc
|
||||
= gen_rtx (SYMBOL_REF, Pmode, MODSI3_LIBCALL);
|
||||
= gen_rtx_SYMBOL_REF (Pmode, MODSI3_LIBCALL);
|
||||
#endif
|
||||
#ifdef MODDI3_LIBCALL
|
||||
smod_optab->handlers[(int) DImode].libfunc
|
||||
= gen_rtx (SYMBOL_REF, Pmode, MODDI3_LIBCALL);
|
||||
= gen_rtx_SYMBOL_REF (Pmode, MODDI3_LIBCALL);
|
||||
#endif
|
||||
|
||||
#ifdef UMODSI3_LIBCALL
|
||||
umod_optab->handlers[(int) SImode].libfunc
|
||||
= gen_rtx (SYMBOL_REF, Pmode, UMODSI3_LIBCALL);
|
||||
= gen_rtx_SYMBOL_REF (Pmode, UMODSI3_LIBCALL);
|
||||
#endif
|
||||
#ifdef UMODDI3_LIBCALL
|
||||
umod_optab->handlers[(int) DImode].libfunc
|
||||
= gen_rtx (SYMBOL_REF, Pmode, UMODDI3_LIBCALL);
|
||||
= gen_rtx_SYMBOL_REF (Pmode, UMODDI3_LIBCALL);
|
||||
#endif
|
||||
|
||||
/* Use cabs for DC complex abs, since systems generally have cabs.
|
||||
Don't define any libcall for SCmode, so that cabs will be used. */
|
||||
abs_optab->handlers[(int) DCmode].libfunc
|
||||
= gen_rtx (SYMBOL_REF, Pmode, "cabs");
|
||||
= gen_rtx_SYMBOL_REF (Pmode, "cabs");
|
||||
|
||||
/* The ffs function operates on `int'. */
|
||||
#ifndef INT_TYPE_SIZE
|
||||
#define INT_TYPE_SIZE BITS_PER_WORD
|
||||
#endif
|
||||
ffs_optab->handlers[(int) mode_for_size (INT_TYPE_SIZE, MODE_INT, 0)] .libfunc
|
||||
= gen_rtx (SYMBOL_REF, Pmode, "ffs");
|
||||
= gen_rtx_SYMBOL_REF (Pmode, "ffs");
|
||||
|
||||
extendsfdf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__extendsfdf2");
|
||||
extendsfxf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__extendsfxf2");
|
||||
extendsftf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__extendsftf2");
|
||||
extenddfxf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__extenddfxf2");
|
||||
extenddftf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__extenddftf2");
|
||||
extendsfdf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__extendsfdf2");
|
||||
extendsfxf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__extendsfxf2");
|
||||
extendsftf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__extendsftf2");
|
||||
extenddfxf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__extenddfxf2");
|
||||
extenddftf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__extenddftf2");
|
||||
|
||||
truncdfsf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__truncdfsf2");
|
||||
truncxfsf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__truncxfsf2");
|
||||
trunctfsf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__trunctfsf2");
|
||||
truncxfdf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__truncxfdf2");
|
||||
trunctfdf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__trunctfdf2");
|
||||
truncdfsf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__truncdfsf2");
|
||||
truncxfsf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__truncxfsf2");
|
||||
trunctfsf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__trunctfsf2");
|
||||
truncxfdf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__truncxfdf2");
|
||||
trunctfdf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__trunctfdf2");
|
||||
|
||||
memcpy_libfunc = gen_rtx (SYMBOL_REF, Pmode, "memcpy");
|
||||
bcopy_libfunc = gen_rtx (SYMBOL_REF, Pmode, "bcopy");
|
||||
memcmp_libfunc = gen_rtx (SYMBOL_REF, Pmode, "memcmp");
|
||||
bcmp_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__gcc_bcmp");
|
||||
memset_libfunc = gen_rtx (SYMBOL_REF, Pmode, "memset");
|
||||
bzero_libfunc = gen_rtx (SYMBOL_REF, Pmode, "bzero");
|
||||
memcpy_libfunc = gen_rtx_SYMBOL_REF (Pmode, "memcpy");
|
||||
bcopy_libfunc = gen_rtx_SYMBOL_REF (Pmode, "bcopy");
|
||||
memcmp_libfunc = gen_rtx_SYMBOL_REF (Pmode, "memcmp");
|
||||
bcmp_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__gcc_bcmp");
|
||||
memset_libfunc = gen_rtx_SYMBOL_REF (Pmode, "memset");
|
||||
bzero_libfunc = gen_rtx_SYMBOL_REF (Pmode, "bzero");
|
||||
|
||||
throw_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__throw");
|
||||
sjthrow_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__sjthrow");
|
||||
sjpopnthrow_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__sjpopnthrow");
|
||||
terminate_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__terminate");
|
||||
throw_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__throw");
|
||||
sjthrow_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__sjthrow");
|
||||
sjpopnthrow_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__sjpopnthrow");
|
||||
terminate_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__terminate");
|
||||
#ifndef DONT_USE_BUILTIN_SETJMP
|
||||
setjmp_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__builtin_setjmp");
|
||||
longjmp_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__builtin_longjmp");
|
||||
setjmp_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__builtin_setjmp");
|
||||
longjmp_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__builtin_longjmp");
|
||||
#else
|
||||
setjmp_libfunc = gen_rtx (SYMBOL_REF, Pmode, "setjmp");
|
||||
longjmp_libfunc = gen_rtx (SYMBOL_REF, Pmode, "longjmp");
|
||||
setjmp_libfunc = gen_rtx_SYMBOL_REF (Pmode, "setjmp");
|
||||
longjmp_libfunc = gen_rtx_SYMBOL_REF (Pmode, "longjmp");
|
||||
#endif
|
||||
|
||||
eqhf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__eqhf2");
|
||||
nehf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__nehf2");
|
||||
gthf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__gthf2");
|
||||
gehf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__gehf2");
|
||||
lthf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__lthf2");
|
||||
lehf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__lehf2");
|
||||
eqhf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__eqhf2");
|
||||
nehf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__nehf2");
|
||||
gthf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__gthf2");
|
||||
gehf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__gehf2");
|
||||
lthf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__lthf2");
|
||||
lehf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__lehf2");
|
||||
|
||||
eqsf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__eqsf2");
|
||||
nesf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__nesf2");
|
||||
gtsf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__gtsf2");
|
||||
gesf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__gesf2");
|
||||
ltsf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__ltsf2");
|
||||
lesf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__lesf2");
|
||||
eqsf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__eqsf2");
|
||||
nesf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__nesf2");
|
||||
gtsf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__gtsf2");
|
||||
gesf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__gesf2");
|
||||
ltsf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__ltsf2");
|
||||
lesf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__lesf2");
|
||||
|
||||
eqdf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__eqdf2");
|
||||
nedf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__nedf2");
|
||||
gtdf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__gtdf2");
|
||||
gedf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__gedf2");
|
||||
ltdf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__ltdf2");
|
||||
ledf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__ledf2");
|
||||
eqdf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__eqdf2");
|
||||
nedf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__nedf2");
|
||||
gtdf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__gtdf2");
|
||||
gedf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__gedf2");
|
||||
ltdf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__ltdf2");
|
||||
ledf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__ledf2");
|
||||
|
||||
eqxf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__eqxf2");
|
||||
nexf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__nexf2");
|
||||
gtxf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__gtxf2");
|
||||
gexf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__gexf2");
|
||||
ltxf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__ltxf2");
|
||||
lexf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__lexf2");
|
||||
eqxf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__eqxf2");
|
||||
nexf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__nexf2");
|
||||
gtxf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__gtxf2");
|
||||
gexf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__gexf2");
|
||||
ltxf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__ltxf2");
|
||||
lexf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__lexf2");
|
||||
|
||||
eqtf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__eqtf2");
|
||||
netf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__netf2");
|
||||
gttf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__gttf2");
|
||||
getf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__getf2");
|
||||
lttf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__lttf2");
|
||||
letf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__letf2");
|
||||
eqtf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__eqtf2");
|
||||
netf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__netf2");
|
||||
gttf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__gttf2");
|
||||
getf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__getf2");
|
||||
lttf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__lttf2");
|
||||
letf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__letf2");
|
||||
|
||||
floatsisf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floatsisf");
|
||||
floatdisf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floatdisf");
|
||||
floattisf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floattisf");
|
||||
floatsisf_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__floatsisf");
|
||||
floatdisf_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__floatdisf");
|
||||
floattisf_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__floattisf");
|
||||
|
||||
floatsidf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floatsidf");
|
||||
floatdidf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floatdidf");
|
||||
floattidf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floattidf");
|
||||
floatsidf_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__floatsidf");
|
||||
floatdidf_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__floatdidf");
|
||||
floattidf_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__floattidf");
|
||||
|
||||
floatsixf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floatsixf");
|
||||
floatdixf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floatdixf");
|
||||
floattixf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floattixf");
|
||||
floatsixf_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__floatsixf");
|
||||
floatdixf_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__floatdixf");
|
||||
floattixf_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__floattixf");
|
||||
|
||||
floatsitf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floatsitf");
|
||||
floatditf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floatditf");
|
||||
floattitf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floattitf");
|
||||
floatsitf_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__floatsitf");
|
||||
floatditf_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__floatditf");
|
||||
floattitf_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__floattitf");
|
||||
|
||||
fixsfsi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixsfsi");
|
||||
fixsfdi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixsfdi");
|
||||
fixsfti_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixsfti");
|
||||
fixsfsi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixsfsi");
|
||||
fixsfdi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixsfdi");
|
||||
fixsfti_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixsfti");
|
||||
|
||||
fixdfsi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixdfsi");
|
||||
fixdfdi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixdfdi");
|
||||
fixdfti_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixdfti");
|
||||
fixdfsi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixdfsi");
|
||||
fixdfdi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixdfdi");
|
||||
fixdfti_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixdfti");
|
||||
|
||||
fixxfsi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixxfsi");
|
||||
fixxfdi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixxfdi");
|
||||
fixxfti_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixxfti");
|
||||
fixxfsi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixxfsi");
|
||||
fixxfdi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixxfdi");
|
||||
fixxfti_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixxfti");
|
||||
|
||||
fixtfsi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixtfsi");
|
||||
fixtfdi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixtfdi");
|
||||
fixtfti_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixtfti");
|
||||
fixtfsi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixtfsi");
|
||||
fixtfdi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixtfdi");
|
||||
fixtfti_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixtfti");
|
||||
|
||||
fixunssfsi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunssfsi");
|
||||
fixunssfdi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunssfdi");
|
||||
fixunssfti_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunssfti");
|
||||
fixunssfsi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixunssfsi");
|
||||
fixunssfdi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixunssfdi");
|
||||
fixunssfti_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixunssfti");
|
||||
|
||||
fixunsdfsi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunsdfsi");
|
||||
fixunsdfdi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunsdfdi");
|
||||
fixunsdfti_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunsdfti");
|
||||
fixunsdfsi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixunsdfsi");
|
||||
fixunsdfdi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixunsdfdi");
|
||||
fixunsdfti_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixunsdfti");
|
||||
|
||||
fixunsxfsi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunsxfsi");
|
||||
fixunsxfdi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunsxfdi");
|
||||
fixunsxfti_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunsxfti");
|
||||
fixunsxfsi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixunsxfsi");
|
||||
fixunsxfdi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixunsxfdi");
|
||||
fixunsxfti_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixunsxfti");
|
||||
|
||||
fixunstfsi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunstfsi");
|
||||
fixunstfdi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunstfdi");
|
||||
fixunstfti_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunstfti");
|
||||
fixunstfsi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixunstfsi");
|
||||
fixunstfdi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixunstfdi");
|
||||
fixunstfti_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixunstfti");
|
||||
|
||||
/* For check-memory-usage. */
|
||||
chkr_check_addr_libfunc = gen_rtx (SYMBOL_REF, VOIDmode, "chkr_check_addr");
|
||||
chkr_set_right_libfunc = gen_rtx (SYMBOL_REF, VOIDmode, "chkr_set_right");
|
||||
chkr_copy_bitmap_libfunc = gen_rtx (SYMBOL_REF, VOIDmode, "chkr_copy_bitmap");
|
||||
chkr_check_exec_libfunc = gen_rtx (SYMBOL_REF, VOIDmode, "chkr_check_exec");
|
||||
chkr_check_str_libfunc = gen_rtx (SYMBOL_REF, VOIDmode, "chkr_check_str");
|
||||
chkr_check_addr_libfunc = gen_rtx_SYMBOL_REF (VOIDmode, "chkr_check_addr");
|
||||
chkr_set_right_libfunc = gen_rtx_SYMBOL_REF (VOIDmode, "chkr_set_right");
|
||||
chkr_copy_bitmap_libfunc = gen_rtx_SYMBOL_REF (VOIDmode, "chkr_copy_bitmap");
|
||||
chkr_check_exec_libfunc = gen_rtx_SYMBOL_REF (VOIDmode, "chkr_check_exec");
|
||||
chkr_check_str_libfunc = gen_rtx_SYMBOL_REF (VOIDmode, "chkr_check_str");
|
||||
|
||||
#ifdef HAVE_conditional_trap
|
||||
init_traps ();
|
||||
|
||||
@ -7478,7 +7478,7 @@ gen_reload (out, in, opnum, type)
|
||||
{
|
||||
/* Add a REG_EQUIV note so that find_equiv_reg can find it. */
|
||||
REG_NOTES (insn)
|
||||
= gen_rtx (EXPR_LIST, REG_EQUIV, in, REG_NOTES (insn));
|
||||
= gen_rtx_EXPR_LIST (REG_EQUIV, in, REG_NOTES (insn));
|
||||
return insn;
|
||||
}
|
||||
}
|
||||
@ -7487,7 +7487,7 @@ gen_reload (out, in, opnum, type)
|
||||
|
||||
gen_reload (out, op1, opnum, type);
|
||||
insn = emit_insn (gen_add2_insn (out, op0));
|
||||
REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_EQUIV, in, REG_NOTES (insn));
|
||||
REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_EQUIV, in, REG_NOTES (insn));
|
||||
}
|
||||
|
||||
#ifdef SECONDARY_MEMORY_NEEDED
|
||||
|
||||
Loading…
Reference in New Issue
Block a user