OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

optabs.h (optab_handler, [...]): Turn into inline functions that return an insn code. 

gcc/
	* optabs.h (optab_handler, convert_optab_handler): Turn into
	inline functions that return an insn code.
	(set_optab_handler, set_convert_optab_handler): New functions.
	* builtins.c: Replace optab_handler(X)->insn_code with
	optab_handler or set_optab_handler thoughout.  Likewise
	convert_optab_handler(X)->insn_code with convert_optab_handler
	and set_convert_optab_handler.
	* expmed.c, expr.c, genopinit.c, ifcvt.c, optabs.c, reload.c,
	reload1.c, stmt.c, targhooks.c, tree-ssa-loop-prefetch.c,
	tree-ssa-math-opts.c, tree-vect-data-refs.c, tree-vect-generic.c,
	tree-vect-loop.c, tree-vect-patterns.c, tree-vect-slp.c,
	tree-vect-stmts.c, config/m32c/m32c.c, config/rs6000/rs6000.c,
	config/spu/spu.c: Likewise.

From-SVN: r161808
This commit is contained in:
Richard Sandiford 2010-07-04 22:13:09 +00:00 committed by Richard Sandiford
parent 47e5ff44cc
commit 947131ba4e
23 changed files with 459 additions and 433 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
gcc/ChangeLog
View File

@ -1,3 +1,19 @@
2010-07-04 Richard Sandiford <rdsandiford@googlemail.com>
* optabs.h (optab_handler, convert_optab_handler): Turn into
inline functions that return an insn code.
(set_optab_handler, set_convert_optab_handler): New functions.
* builtins.c: Replace optab_handler(X)->insn_code with
optab_handler or set_optab_handler thoughout. Likewise
convert_optab_handler(X)->insn_code with convert_optab_handler
and set_convert_optab_handler.
* expmed.c, expr.c, genopinit.c, ifcvt.c, optabs.c, reload.c,
reload1.c, stmt.c, targhooks.c, tree-ssa-loop-prefetch.c,
tree-ssa-math-opts.c, tree-vect-data-refs.c, tree-vect-generic.c,
tree-vect-loop.c, tree-vect-patterns.c, tree-vect-slp.c,
tree-vect-stmts.c, config/m32c/m32c.c, config/rs6000/rs6000.c,
config/spu/spu.c: Likewise.
2010-07-04 Kaz Kojima <kkojima@gcc.gnu.org>
PR target/44531

21
gcc/builtins.c
View File

@ -1994,7 +1994,7 @@ expand_builtin_mathfn (tree exp, rtx target, rtx subtarget)
errno_set = false;
/* Before working hard, check whether the instruction is available. */
if (optab_handler (builtin_optab, mode)->insn_code != CODE_FOR_nothing)
if (optab_handler (builtin_optab, mode) != CODE_FOR_nothing)
{
target = gen_reg_rtx (mode);
@ -2096,7 +2096,7 @@ expand_builtin_mathfn_2 (tree exp, rtx target, rtx subtarget)
mode = TYPE_MODE (TREE_TYPE (exp));
/* Before working hard, check whether the instruction is available. */
if (optab_handler (builtin_optab, mode)->insn_code == CODE_FOR_nothing)
if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
return NULL_RTX;
target = gen_reg_rtx (mode);
@ -2173,7 +2173,7 @@ expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget)
/* Check if sincos insn is available, otherwise fallback
to sin or cos insn. */
if (optab_handler (builtin_optab, mode)->insn_code == CODE_FOR_nothing)
if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
switch (DECL_FUNCTION_CODE (fndecl))
{
CASE_FLT_FN (BUILT_IN_SIN):
@ -2185,7 +2185,7 @@ expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget)
}
/* Before working hard, check whether the instruction is available. */
if (optab_handler (builtin_optab, mode)->insn_code != CODE_FOR_nothing)
if (optab_handler (builtin_optab, mode) != CODE_FOR_nothing)
{
target = gen_reg_rtx (mode);
@ -2282,7 +2282,7 @@ interclass_mathfn_icode (tree arg, tree fndecl)
mode = TYPE_MODE (TREE_TYPE (arg));
if (builtin_optab)
return optab_handler (builtin_optab, mode)->insn_code;
return optab_handler (builtin_optab, mode);
return CODE_FOR_nothing;
}
@ -2370,7 +2370,7 @@ expand_builtin_sincos (tree exp)
mode = TYPE_MODE (TREE_TYPE (arg));
/* Check if sincos insn is available, otherwise emit the call. */
if (optab_handler (sincos_optab, mode)->insn_code == CODE_FOR_nothing)
if (optab_handler (sincos_optab, mode) == CODE_FOR_nothing)
return NULL_RTX;
target1 = gen_reg_rtx (mode);
@ -2417,7 +2417,7 @@ expand_builtin_cexpi (tree exp, rtx target, rtx subtarget)
/* Try expanding via a sincos optab, fall back to emitting a libcall
to sincos or cexp. We are sure we have sincos or cexp because cexpi
is only generated from sincos, cexp or if we have either of them. */
if (optab_handler (sincos_optab, mode)->insn_code != CODE_FOR_nothing)
if (optab_handler (sincos_optab, mode) != CODE_FOR_nothing)
{
op1 = gen_reg_rtx (mode);
op2 = gen_reg_rtx (mode);
@ -3080,8 +3080,7 @@ expand_builtin_pow (tree exp, rtx target, rtx subtarget)
smaller than pow (x, 1.5) if sqrt will not be expanded
as a call. */
|| (n == 3
&& (optab_handler (sqrt_optab, mode)->insn_code
!= CODE_FOR_nothing))))
&& optab_handler (sqrt_optab, mode) != CODE_FOR_nothing)))
{
tree call_expr = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 1,
narg0);
@ -3272,7 +3271,7 @@ expand_builtin_strlen (tree exp, rtx target,
/* Bail out if we can't compute strlen in the right mode. */
while (insn_mode != VOIDmode)
{
icode = optab_handler (strlen_optab, insn_mode)->insn_code;
icode = optab_handler (strlen_optab, insn_mode);
if (icode != CODE_FOR_nothing)
break;
@ -5308,7 +5307,7 @@ expand_builtin_signbit (tree exp, rtx target)
/* Check if the back end provides an insn that handles signbit for the
argument's mode. */
icode = signbit_optab->handlers [(int) fmode].insn_code;
icode = optab_handler (signbit_optab, fmode);
if (icode != CODE_FOR_nothing)
{
rtx last = get_last_insn ();

6
gcc/config/m32c/m32c.c
View File

@ -1789,9 +1789,9 @@ m32c_init_libfuncs (void)
the right modes are found. */
if (TARGET_A24)
{
optab_handler (cstore_optab, QImode)->insn_code = CODE_FOR_cstoreqi4_24;
optab_handler (cstore_optab, HImode)->insn_code = CODE_FOR_cstorehi4_24;
optab_handler (cstore_optab, PSImode)->insn_code = CODE_FOR_cstorepsi4_24;
set_optab_handler (cstore_optab, QImode, CODE_FOR_cstoreqi4_24);
set_optab_handler (cstore_optab, HImode, CODE_FOR_cstorehi4_24);
set_optab_handler (cstore_optab, PSImode, CODE_FOR_cstorepsi4_24);
}
}

25
gcc/config/rs6000/rs6000.c
View File

@ -3332,8 +3332,7 @@ rs6000_builtin_support_vector_misalignment (enum machine_mode mode,
if (TARGET_VSX)
{
/* Return if movmisalign pattern is not supported for this mode. */
if (optab_handler (movmisalign_optab, mode)->insn_code ==
CODE_FOR_nothing)
if (optab_handler (movmisalign_optab, mode) == CODE_FOR_nothing)
return false;
if (misalignment == -1)
@ -16355,7 +16354,7 @@ rs6000_emit_vector_compare (enum rtx_code rcode,
if (rev_code == UNKNOWN)
return NULL_RTX;
nor_code = optab_handler (one_cmpl_optab, (int)dmode)->insn_code;
nor_code = optab_handler (one_cmpl_optab, dmode);
if (nor_code == CODE_FOR_nothing)
return NULL_RTX;
@ -16400,7 +16399,7 @@ rs6000_emit_vector_compare (enum rtx_code rcode,
gcc_unreachable ();
}
ior_code = optab_handler (ior_optab, (int)dmode)->insn_code;
ior_code = optab_handler (ior_optab, dmode);
if (ior_code == CODE_FOR_nothing)
return NULL_RTX;
@ -25753,8 +25752,8 @@ rs6000_emit_madd (rtx dst, rtx m1, rtx m2, rtx a)
{
/* For the simple ops, use the generator function, rather than assuming
that the RTL is standard. */
enum insn_code mcode = optab_handler (smul_optab, mode)->insn_code;
enum insn_code acode = optab_handler (add_optab, mode)->insn_code;
enum insn_code mcode = optab_handler (smul_optab, mode);
enum insn_code acode = optab_handler (add_optab, mode);
gen_2arg_fn_t gen_mul = (gen_2arg_fn_t) GEN_FCN (mcode);
gen_2arg_fn_t gen_add = (gen_2arg_fn_t) GEN_FCN (acode);
rtx mreg = gen_reg_rtx (mode);
@ -25786,8 +25785,8 @@ rs6000_emit_msub (rtx dst, rtx m1, rtx m2, rtx a)
{
/* For the simple ops, use the generator function, rather than assuming
that the RTL is standard. */
enum insn_code mcode = optab_handler (smul_optab, mode)->insn_code;
enum insn_code scode = optab_handler (add_optab, mode)->insn_code;
enum insn_code mcode = optab_handler (smul_optab, mode);
enum insn_code scode = optab_handler (add_optab, mode);
gen_2arg_fn_t gen_mul = (gen_2arg_fn_t) GEN_FCN (mcode);
gen_2arg_fn_t gen_sub = (gen_2arg_fn_t) GEN_FCN (scode);
rtx mreg = gen_reg_rtx (mode);
@ -25822,8 +25821,8 @@ rs6000_emit_nmsub (rtx dst, rtx m1, rtx m2, rtx a)
{
/* For the simple ops, use the generator function, rather than assuming
that the RTL is standard. */
enum insn_code mcode = optab_handler (smul_optab, mode)->insn_code;
enum insn_code scode = optab_handler (sub_optab, mode)->insn_code;
enum insn_code mcode = optab_handler (smul_optab, mode);
enum insn_code scode = optab_handler (sub_optab, mode);
gen_2arg_fn_t gen_mul = (gen_2arg_fn_t) GEN_FCN (mcode);
gen_2arg_fn_t gen_sub = (gen_2arg_fn_t) GEN_FCN (scode);
rtx mreg = gen_reg_rtx (mode);
@ -25857,7 +25856,7 @@ rs6000_emit_swdiv_high_precision (rtx dst, rtx n, rtx d)
{
enum machine_mode mode = GET_MODE (dst);
rtx x0, e0, e1, y1, u0, v0;
enum insn_code code = optab_handler (smul_optab, mode)->insn_code;
enum insn_code code = optab_handler (smul_optab, mode);
gen_2arg_fn_t gen_mul = (gen_2arg_fn_t) GEN_FCN (code);
rtx one = rs6000_load_constant_and_splat (mode, dconst1);
@ -25895,7 +25894,7 @@ rs6000_emit_swdiv_low_precision (rtx dst, rtx n, rtx d)
{
enum machine_mode mode = GET_MODE (dst);
rtx x0, e0, e1, e2, y1, y2, y3, u0, v0, one;
enum insn_code code = optab_handler (smul_optab, mode)->insn_code;
enum insn_code code = optab_handler (smul_optab, mode);
gen_2arg_fn_t gen_mul = (gen_2arg_fn_t) GEN_FCN (code);
gcc_assert (code != CODE_FOR_nothing);
@ -25966,7 +25965,7 @@ rs6000_emit_swrsqrt (rtx dst, rtx src)
REAL_VALUE_TYPE dconst3_2;
int i;
rtx halfthree;
enum insn_code code = optab_handler (smul_optab, mode)->insn_code;
enum insn_code code = optab_handler (smul_optab, mode);
gen_2arg_fn_t gen_mul = (gen_2arg_fn_t) GEN_FCN (code);
gcc_assert (code != CODE_FOR_nothing);

9
gcc/config/spu/spu.c
View File

@ -1139,7 +1139,7 @@ spu_emit_branch_or_set (int is_set, rtx cmp, rtx operands[])
if (eq_rtx == 0)
abort ();
emit_insn (eq_rtx);
ior_code = ior_optab->handlers[(int)comp_mode].insn_code;
ior_code = optab_handler (ior_optab, comp_mode);
gcc_assert (ior_code != CODE_FOR_nothing);
emit_insn (GEN_FCN (ior_code)
(compare_result, compare_result, eq_result));
@ -4588,7 +4588,8 @@ spu_expand_mov (rtx * ops, enum machine_mode mode)
if (GET_MODE_SIZE (mode) < GET_MODE_SIZE (imode))
{
enum insn_code icode = convert_optab_handler (trunc_optab, mode, imode)->insn_code;
enum insn_code icode = convert_optab_handler (trunc_optab,
mode, imode);
emit_insn (GEN_FCN (icode) (ops[0], from));
}
else
@ -6251,7 +6252,7 @@ spu_emit_vector_compare (enum rtx_code rcode,
{
enum insn_code nor_code;
rtx eq_rtx = spu_emit_vector_compare (EQ, op0, op1, dest_mode);
nor_code = optab_handler (one_cmpl_optab, (int)dest_mode)->insn_code;
nor_code = optab_handler (one_cmpl_optab, dest_mode);
gcc_assert (nor_code != CODE_FOR_nothing);
emit_insn (GEN_FCN (nor_code) (mask, eq_rtx));
if (dmode != dest_mode)
@ -6286,7 +6287,7 @@ spu_emit_vector_compare (enum rtx_code rcode,
c_rtx = spu_emit_vector_compare (new_code, op0, op1, dest_mode);
eq_rtx = spu_emit_vector_compare (EQ, op0, op1, dest_mode);
ior_code = optab_handler (ior_optab, (int)dest_mode)->insn_code;
ior_code = optab_handler (ior_optab, dest_mode);
gcc_assert (ior_code != CODE_FOR_nothing);
emit_insn (GEN_FCN (ior_code) (mask, c_rtx, eq_rtx));
if (dmode != dest_mode)

51
gcc/expmed.c
View File

@ -419,15 +419,14 @@ store_bit_field_1 (rtx str_rtx, unsigned HOST_WIDE_INT bitsize,
available. */
if (VECTOR_MODE_P (GET_MODE (op0))
&& !MEM_P (op0)
&& (optab_handler (vec_set_optab, GET_MODE (op0))->insn_code
!= CODE_FOR_nothing)
&& optab_handler (vec_set_optab, GET_MODE (op0)) != CODE_FOR_nothing
&& fieldmode == GET_MODE_INNER (GET_MODE (op0))
&& bitsize == GET_MODE_BITSIZE (GET_MODE_INNER (GET_MODE (op0)))
&& !(bitnum % GET_MODE_BITSIZE (GET_MODE_INNER (GET_MODE (op0)))))
{
enum machine_mode outermode = GET_MODE (op0);
enum machine_mode innermode = GET_MODE_INNER (outermode);
int icode = (int) optab_handler (vec_set_optab, outermode)->insn_code;
int icode = (int) optab_handler (vec_set_optab, outermode);
int pos = bitnum / GET_MODE_BITSIZE (innermode);
rtx rtxpos = GEN_INT (pos);
rtx src = value;
@ -533,10 +532,9 @@ store_bit_field_1 (rtx str_rtx, unsigned HOST_WIDE_INT bitsize,
if (!MEM_P (op0)
&& (BYTES_BIG_ENDIAN ? bitpos + bitsize == unit : bitpos == 0)
&& bitsize == GET_MODE_BITSIZE (fieldmode)
&& (optab_handler (movstrict_optab, fieldmode)->insn_code
!= CODE_FOR_nothing))
&& optab_handler (movstrict_optab, fieldmode) != CODE_FOR_nothing)
{
int icode = optab_handler (movstrict_optab, fieldmode)->insn_code;
int icode = optab_handler (movstrict_optab, fieldmode);
rtx insn;
rtx start = get_last_insn ();
rtx arg0 = op0;
@ -1253,14 +1251,13 @@ extract_bit_field_1 (rtx str_rtx, unsigned HOST_WIDE_INT bitsize,
available. */
if (VECTOR_MODE_P (GET_MODE (op0))
&& !MEM_P (op0)
&& (optab_handler (vec_extract_optab, GET_MODE (op0))->insn_code
!= CODE_FOR_nothing)
&& optab_handler (vec_extract_optab, GET_MODE (op0)) != CODE_FOR_nothing
&& ((bitnum + bitsize - 1) / GET_MODE_BITSIZE (GET_MODE_INNER (GET_MODE (op0)))
== bitnum / GET_MODE_BITSIZE (GET_MODE_INNER (GET_MODE (op0)))))
{
enum machine_mode outermode = GET_MODE (op0);
enum machine_mode innermode = GET_MODE_INNER (outermode);
int icode = (int) optab_handler (vec_extract_optab, outermode)->insn_code;
int icode = (int) optab_handler (vec_extract_optab, outermode);
unsigned HOST_WIDE_INT pos = bitnum / GET_MODE_BITSIZE (innermode);
rtx rtxpos = GEN_INT (pos);
rtx src = op0;
@ -3567,7 +3564,7 @@ expand_mult_highpart_optab (enum machine_mode mode, rtx op0, rtx op1,
/* Try widening multiplication. */
moptab = unsignedp ? umul_widen_optab : smul_widen_optab;
if (optab_handler (moptab, wider_mode)->insn_code != CODE_FOR_nothing
if (optab_handler (moptab, wider_mode) != CODE_FOR_nothing
&& mul_widen_cost[speed][wider_mode] < max_cost)
{
tem = expand_binop (wider_mode, moptab, op0, narrow_op1, 0,
@ -3577,7 +3574,7 @@ expand_mult_highpart_optab (enum machine_mode mode, rtx op0, rtx op1,
}
/* Try widening the mode and perform a non-widening multiplication. */
if (optab_handler (smul_optab, wider_mode)->insn_code != CODE_FOR_nothing
if (optab_handler (smul_optab, wider_mode) != CODE_FOR_nothing
&& size - 1 < BITS_PER_WORD
&& mul_cost[speed][wider_mode] + shift_cost[speed][mode][size-1] < max_cost)
{
@ -3604,7 +3601,7 @@ expand_mult_highpart_optab (enum machine_mode mode, rtx op0, rtx op1,
/* Try widening multiplication of opposite signedness, and adjust. */
moptab = unsignedp ? smul_widen_optab : umul_widen_optab;
if (optab_handler (moptab, wider_mode)->insn_code != CODE_FOR_nothing
if (optab_handler (moptab, wider_mode) != CODE_FOR_nothing
&& size - 1 < BITS_PER_WORD
&& (mul_widen_cost[speed][wider_mode] + 2 * shift_cost[speed][mode][size-1]
+ 4 * add_cost[speed][mode] < max_cost))
@ -3726,7 +3723,7 @@ expand_smod_pow2 (enum machine_mode mode, rtx op0, HOST_WIDE_INT d)
use a LSHIFTRT, 1 ADD, 1 SUB and an AND. */
temp = gen_rtx_LSHIFTRT (mode, result, shift);
if (optab_handler (lshr_optab, mode)->insn_code == CODE_FOR_nothing
if (optab_handler (lshr_optab, mode) == CODE_FOR_nothing
|| rtx_cost (temp, SET, optimize_insn_for_speed_p ()) > COSTS_N_INSNS (2))
{
temp = expand_binop (mode, xor_optab, op0, signmask,
@ -4030,8 +4027,8 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode,
for (compute_mode = mode; compute_mode != VOIDmode;
compute_mode = GET_MODE_WIDER_MODE (compute_mode))
if (optab_handler (optab1, compute_mode)->insn_code != CODE_FOR_nothing
|| optab_handler (optab2, compute_mode)->insn_code != CODE_FOR_nothing)
if (optab_handler (optab1, compute_mode) != CODE_FOR_nothing
|| optab_handler (optab2, compute_mode) != CODE_FOR_nothing)
break;
if (compute_mode == VOIDmode)
@ -4286,11 +4283,11 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode,
optab has an expander for this mode. */
&& ((optab_handler ((rem_flag ? smod_optab
: sdiv_optab),
compute_mode)->insn_code
compute_mode)
!= CODE_FOR_nothing)
|| (optab_handler(sdivmod_optab,
compute_mode)
->insn_code != CODE_FOR_nothing)))
|| (optab_handler (sdivmod_optab,
compute_mode)
!= CODE_FOR_nothing)))
;
else if (EXACT_POWER_OF_2_OR_ZERO_P (abs_d))
{
@ -4302,9 +4299,9 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode,
}
if (sdiv_pow2_cheap[speed][compute_mode]
&& ((optab_handler (sdiv_optab, compute_mode)->insn_code
&& ((optab_handler (sdiv_optab, compute_mode)
!= CODE_FOR_nothing)
|| (optab_handler (sdivmod_optab, compute_mode)->insn_code
|| (optab_handler (sdivmod_optab, compute_mode)
!= CODE_FOR_nothing)))
quotient = expand_divmod (0, TRUNC_DIV_EXPR,
compute_mode, op0,
@ -4952,7 +4949,7 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode,
= sign_expand_binop (compute_mode, umod_optab, smod_optab,
op0, op1, target,
unsignedp,
((optab_handler (optab2, compute_mode)->insn_code
((optab_handler (optab2, compute_mode)
!= CODE_FOR_nothing)
? OPTAB_DIRECT : OPTAB_WIDEN));
if (remainder == 0)
@ -4980,7 +4977,7 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode,
= sign_expand_binop (compute_mode, udiv_optab, sdiv_optab,
op0, op1, rem_flag ? NULL_RTX : target,
unsignedp,
((optab_handler (optab2, compute_mode)->insn_code
((optab_handler (optab2, compute_mode)
!= CODE_FOR_nothing)
? OPTAB_DIRECT : OPTAB_WIDEN));
@ -5479,7 +5476,7 @@ emit_store_flag_1 (rtx target, enum rtx_code code, rtx op0, rtx op1,
compare_mode = GET_MODE_WIDER_MODE (compare_mode))
{
enum machine_mode optab_mode = mclass == MODE_CC ? CCmode : compare_mode;
icode = optab_handler (cstore_optab, optab_mode)->insn_code;
icode = optab_handler (cstore_optab, optab_mode);
if (icode != CODE_FOR_nothing)
{
do_pending_stack_adjust ();
@ -5674,7 +5671,7 @@ emit_store_flag (rtx target, enum rtx_code code, rtx op0, rtx op1,
as "-(int)X >> 31" is still cheaper than inverting "(int)X == 0". */
rcode = reverse_condition (code);
if (can_compare_p (rcode, mode, ccp_store_flag)
&& ! (optab_handler (cstore_optab, mode)->insn_code == CODE_FOR_nothing
&& ! (optab_handler (cstore_optab, mode) == CODE_FOR_nothing
&& code == NE
&& GET_MODE_SIZE (mode) < UNITS_PER_WORD
&& op1 == const0_rtx))
@ -5773,9 +5770,9 @@ emit_store_flag (rtx target, enum rtx_code code, rtx op0, rtx op1,
that is compensated by the subsequent overflow when subtracting
one / negating. */
if (optab_handler (abs_optab, mode)->insn_code != CODE_FOR_nothing)
if (optab_handler (abs_optab, mode) != CODE_FOR_nothing)
tem = expand_unop (mode, abs_optab, op0, subtarget, 1);
else if (optab_handler (ffs_optab, mode)->insn_code != CODE_FOR_nothing)
else if (optab_handler (ffs_optab, mode) != CODE_FOR_nothing)
tem = expand_unop (mode, ffs_optab, op0, subtarget, 1);
else if (GET_MODE_SIZE (mode) < UNITS_PER_WORD)
{

50
gcc/expr.c
View File

@ -434,7 +434,7 @@ convert_move (rtx to, rtx from, int unsignedp)
/* Try converting directly if the insn is supported. */
code = convert_optab_handler (tab, to_mode, from_mode)->insn_code;
code = convert_optab_handler (tab, to_mode, from_mode);
if (code != CODE_FOR_nothing)
{
emit_unop_insn (code, to, from,
@ -468,12 +468,12 @@ convert_move (rtx to, rtx from, int unsignedp)
enum machine_mode full_mode
= smallest_mode_for_size (GET_MODE_BITSIZE (to_mode), MODE_INT);
gcc_assert (convert_optab_handler (trunc_optab, to_mode, full_mode)->insn_code
gcc_assert (convert_optab_handler (trunc_optab, to_mode, full_mode)
!= CODE_FOR_nothing);
if (full_mode != from_mode)
from = convert_to_mode (full_mode, from, unsignedp);
emit_unop_insn (convert_optab_handler (trunc_optab, to_mode, full_mode)->insn_code,
emit_unop_insn (convert_optab_handler (trunc_optab, to_mode, full_mode),
to, from, UNKNOWN);
return;
}
@ -483,18 +483,19 @@ convert_move (rtx to, rtx from, int unsignedp)
enum machine_mode full_mode
= smallest_mode_for_size (GET_MODE_BITSIZE (from_mode), MODE_INT);
gcc_assert (convert_optab_handler (sext_optab, full_mode, from_mode)->insn_code
gcc_assert (convert_optab_handler (sext_optab, full_mode, from_mode)
!= CODE_FOR_nothing);
if (to_mode == full_mode)
{
emit_unop_insn (convert_optab_handler (sext_optab, full_mode, from_mode)->insn_code,
emit_unop_insn (convert_optab_handler (sext_optab, full_mode,
from_mode),
to, from, UNKNOWN);
return;
}
new_from = gen_reg_rtx (full_mode);
emit_unop_insn (convert_optab_handler (sext_optab, full_mode, from_mode)->insn_code,
emit_unop_insn (convert_optab_handler (sext_optab, full_mode, from_mode),
new_from, from, UNKNOWN);
/* else proceed to integer conversions below. */
@ -695,9 +696,10 @@ convert_move (rtx to, rtx from, int unsignedp)
}
/* Support special truncate insns for certain modes. */
if (convert_optab_handler (trunc_optab, to_mode, from_mode)->insn_code != CODE_FOR_nothing)
if (convert_optab_handler (trunc_optab, to_mode,
from_mode) != CODE_FOR_nothing)
{
emit_unop_insn (convert_optab_handler (trunc_optab, to_mode, from_mode)->insn_code,
emit_unop_insn (convert_optab_handler (trunc_optab, to_mode, from_mode),
to, from, UNKNOWN);
return;
}
@ -990,7 +992,7 @@ move_by_pieces (rtx to, rtx from, unsigned HOST_WIDE_INT len,
if (mode == VOIDmode)
break;
icode = optab_handler (mov_optab, mode)->insn_code;
icode = optab_handler (mov_optab, mode);
if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
move_by_pieces_1 (GEN_FCN (icode), mode, &data);
@ -1071,7 +1073,7 @@ move_by_pieces_ninsns (unsigned HOST_WIDE_INT l, unsigned int align,
if (mode == VOIDmode)
break;
icode = optab_handler (mov_optab, mode)->insn_code;
icode = optab_handler (mov_optab, mode);
if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
n_insns += l / GET_MODE_SIZE (mode), l %= GET_MODE_SIZE (mode);
@ -2352,7 +2354,7 @@ can_store_by_pieces (unsigned HOST_WIDE_INT len,
if (mode == VOIDmode)
break;
icode = optab_handler (mov_optab, mode)->insn_code;
icode = optab_handler (mov_optab, mode);
if (icode != CODE_FOR_nothing
&& align >= GET_MODE_ALIGNMENT (mode))
{
@ -2565,7 +2567,7 @@ store_by_pieces_1 (struct store_by_pieces_d *data ATTRIBUTE_UNUSED,
if (mode == VOIDmode)
break;
icode = optab_handler (mov_optab, mode)->insn_code;
icode = optab_handler (mov_optab, mode);
if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
store_by_pieces_2 (GEN_FCN (icode), mode, data);
@ -3034,7 +3036,7 @@ emit_move_via_integer (enum machine_mode mode, rtx x, rtx y, bool force)
return NULL_RTX;
/* The target must support moves in this mode. */
code = optab_handler (mov_optab, imode)->insn_code;
code = optab_handler (mov_optab, imode);
if (code == CODE_FOR_nothing)
return NULL_RTX;
@ -3184,7 +3186,7 @@ emit_move_complex (enum machine_mode mode, rtx x, rtx y)
/* Move floating point as parts. */
if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
&& optab_handler (mov_optab, GET_MODE_INNER (mode))->insn_code != CODE_FOR_nothing)
&& optab_handler (mov_optab, GET_MODE_INNER (mode)) != CODE_FOR_nothing)
try_int = false;
/* Not possible if the values are inherently not adjacent. */
else if (GET_CODE (x) == CONCAT || GET_CODE (y) == CONCAT)
@ -3235,7 +3237,7 @@ emit_move_ccmode (enum machine_mode mode, rtx x, rtx y)
/* Assume all MODE_CC modes are equivalent; if we have movcc, use it. */
if (mode != CCmode)
{
enum insn_code code = optab_handler (mov_optab, CCmode)->insn_code;
enum insn_code code = optab_handler (mov_optab, CCmode);
if (code != CODE_FOR_nothing)
{
x = emit_move_change_mode (CCmode, mode, x, true);
@ -3375,7 +3377,7 @@ emit_move_insn_1 (rtx x, rtx y)
gcc_assert ((unsigned int) mode < (unsigned int) MAX_MACHINE_MODE);
code = optab_handler (mov_optab, mode)->insn_code;
code = optab_handler (mov_optab, mode);
if (code != CODE_FOR_nothing)
return emit_insn (GEN_FCN (code) (x, y));
@ -3627,7 +3629,7 @@ emit_single_push_insn (enum machine_mode mode, rtx x, tree type)
stack_pointer_delta += PUSH_ROUNDING (GET_MODE_SIZE (mode));
/* If there is push pattern, use it. Otherwise try old way of throwing
MEM representing push operation to move expander. */
icode = optab_handler (push_optab, mode)->insn_code;
icode = optab_handler (push_optab, mode);
if (icode != CODE_FOR_nothing)
{
if (((pred = insn_data[(int) icode].operand[0].predicate)
@ -4363,7 +4365,7 @@ expand_assignment (tree to, tree from, bool nontemporal)
set_mem_attributes (mem, to, 0);
set_mem_addr_space (mem, as);
icode = movmisalign_optab->handlers[mode].insn_code;
icode = optab_handler (movmisalign_optab, mode);
gcc_assert (icode != CODE_FOR_nothing);
op_mode1 = insn_data[icode].operand[1].mode;
@ -4496,7 +4498,7 @@ bool
emit_storent_insn (rtx to, rtx from)
{
enum machine_mode mode = GET_MODE (to), imode;
enum insn_code code = optab_handler (storent_optab, mode)->insn_code;
enum insn_code code = optab_handler (storent_optab, mode);
rtx pattern;
if (code == CODE_FOR_nothing)
@ -5703,7 +5705,7 @@ store_constructor (tree exp, rtx target, int cleared, HOST_WIDE_INT size)
{
enum machine_mode mode = GET_MODE (target);
icode = (int) optab_handler (vec_init_optab, mode)->insn_code;
icode = (int) optab_handler (vec_init_optab, mode);
if (icode != CODE_FOR_nothing)
{
unsigned int i;
@ -7704,7 +7706,7 @@ expand_expr_real_2 (sepops ops, rtx target, enum machine_mode tmode,
this_optab = usmul_widen_optab;
if (mode == GET_MODE_2XWIDER_MODE (innermode))
{
if (optab_handler (this_optab, mode)->insn_code != CODE_FOR_nothing)
if (optab_handler (this_optab, mode) != CODE_FOR_nothing)
{
if (TYPE_UNSIGNED (TREE_TYPE (treeop0)))
expand_operands (treeop0, treeop1, subtarget, &op0, &op1,
@ -7730,7 +7732,7 @@ expand_expr_real_2 (sepops ops, rtx target, enum machine_mode tmode,
if (mode == GET_MODE_2XWIDER_MODE (innermode))
{
if (optab_handler (this_optab, mode)->insn_code != CODE_FOR_nothing)
if (optab_handler (this_optab, mode) != CODE_FOR_nothing)
{
expand_operands (treeop0, treeop1, NULL_RTX, &op0, &op1,
EXPAND_NORMAL);
@ -7738,7 +7740,7 @@ expand_expr_real_2 (sepops ops, rtx target, enum machine_mode tmode,
unsignedp, this_optab);
return REDUCE_BIT_FIELD (temp);
}
if (optab_handler (other_optab, mode)->insn_code != CODE_FOR_nothing
if (optab_handler (other_optab, mode) != CODE_FOR_nothing
&& innermode == word_mode)
{
rtx htem, hipart;
@ -8727,7 +8729,7 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
|| modifier == EXPAND_STACK_PARM);
/* The vectorizer should have already checked the mode. */
icode = optab_handler (movmisalign_optab, mode)->insn_code;
icode = optab_handler (movmisalign_optab, mode);
gcc_assert (icode != CODE_FOR_nothing);
/* We've already validated the memory, and we're creating a

369
gcc/genopinit.c
View File

@ -60,152 +60,152 @@ along with GCC; see the file COPYING3. If not see
upper-case forms of the comparison, respectively. */
static const char * const optabs[] =
{ "convert_optab_handler (sext_optab, $B, $A)->insn_code = CODE_FOR_$(extend$a$b2$)",
"convert_optab_handler (zext_optab, $B, $A)->insn_code = CODE_FOR_$(zero_extend$a$b2$)",
"convert_optab_handler (sfix_optab, $B, $A)->insn_code = CODE_FOR_$(fix$F$a$I$b2$)",
"convert_optab_handler (ufix_optab, $B, $A)->insn_code = CODE_FOR_$(fixuns$F$a$b2$)",
"convert_optab_handler (sfixtrunc_optab, $B, $A)->insn_code = CODE_FOR_$(fix_trunc$F$a$I$b2$)",
"convert_optab_handler (ufixtrunc_optab, $B, $A)->insn_code = CODE_FOR_$(fixuns_trunc$F$a$I$b2$)",
"convert_optab_handler (sfloat_optab, $B, $A)->insn_code = CODE_FOR_$(float$I$a$F$b2$)",
"convert_optab_handler (ufloat_optab, $B, $A)->insn_code = CODE_FOR_$(floatuns$I$a$F$b2$)",
"convert_optab_handler (trunc_optab, $B, $A)->insn_code = CODE_FOR_$(trunc$a$b2$)",
"convert_optab_handler (fract_optab, $B, $A)->insn_code = CODE_FOR_$(fract$a$b2$)",
"convert_optab_handler (fractuns_optab, $B, $A)->insn_code = CODE_FOR_$(fractuns$I$a$Q$b2$)",
"convert_optab_handler (fractuns_optab, $B, $A)->insn_code = CODE_FOR_$(fractuns$Q$a$I$b2$)",
"convert_optab_handler (satfract_optab, $B, $A)->insn_code = CODE_FOR_$(satfract$a$Q$b2$)",
"convert_optab_handler (satfractuns_optab, $B, $A)->insn_code = CODE_FOR_$(satfractuns$I$a$Q$b2$)",
"optab_handler (add_optab, $A)->insn_code = CODE_FOR_$(add$P$a3$)",
"optab_handler (addv_optab, $A)->insn_code =\n\
optab_handler (add_optab, $A)->insn_code = CODE_FOR_$(add$F$a3$)",
"optab_handler (addv_optab, $A)->insn_code = CODE_FOR_$(addv$I$a3$)",
"optab_handler (add_optab, $A)->insn_code = CODE_FOR_$(add$Q$a3$)",
"optab_handler (ssadd_optab, $A)->insn_code = CODE_FOR_$(ssadd$Q$a3$)",
"optab_handler (usadd_optab, $A)->insn_code = CODE_FOR_$(usadd$Q$a3$)",
"optab_handler (sub_optab, $A)->insn_code = CODE_FOR_$(sub$P$a3$)",
"optab_handler (subv_optab, $A)->insn_code =\n\
optab_handler (sub_optab, $A)->insn_code = CODE_FOR_$(sub$F$a3$)",
"optab_handler (subv_optab, $A)->insn_code = CODE_FOR_$(subv$I$a3$)",
"optab_handler (sub_optab, $A)->insn_code = CODE_FOR_$(sub$Q$a3$)",
"optab_handler (sssub_optab, $A)->insn_code = CODE_FOR_$(sssub$Q$a3$)",
"optab_handler (ussub_optab, $A)->insn_code = CODE_FOR_$(ussub$Q$a3$)",
"optab_handler (smul_optab, $A)->insn_code = CODE_FOR_$(mul$Q$a3$)",
"optab_handler (ssmul_optab, $A)->insn_code = CODE_FOR_$(ssmul$Q$a3$)",
"optab_handler (usmul_optab, $A)->insn_code = CODE_FOR_$(usmul$Q$a3$)",
"optab_handler (smul_optab, $A)->insn_code = CODE_FOR_$(mul$P$a3$)",
"optab_handler (smulv_optab, $A)->insn_code =\n\
optab_handler (smul_optab, $A)->insn_code = CODE_FOR_$(mul$F$a3$)",
"optab_handler (smulv_optab, $A)->insn_code = CODE_FOR_$(mulv$I$a3$)",
"optab_handler (umul_highpart_optab, $A)->insn_code = CODE_FOR_$(umul$a3_highpart$)",
"optab_handler (smul_highpart_optab, $A)->insn_code = CODE_FOR_$(smul$a3_highpart$)",
"optab_handler (smul_widen_optab, $B)->insn_code = CODE_FOR_$(mul$a$b3$)$N",
"optab_handler (umul_widen_optab, $B)->insn_code = CODE_FOR_$(umul$a$b3$)$N",
"optab_handler (usmul_widen_optab, $B)->insn_code = CODE_FOR_$(usmul$a$b3$)$N",
"optab_handler (smadd_widen_optab, $B)->insn_code = CODE_FOR_$(madd$a$b4$)$N",
"optab_handler (umadd_widen_optab, $B)->insn_code = CODE_FOR_$(umadd$a$b4$)$N",
"optab_handler (ssmadd_widen_optab, $B)->insn_code = CODE_FOR_$(ssmadd$a$b4$)$N",
"optab_handler (usmadd_widen_optab, $B)->insn_code = CODE_FOR_$(usmadd$a$b4$)$N",
"optab_handler (smsub_widen_optab, $B)->insn_code = CODE_FOR_$(msub$a$b4$)$N",
"optab_handler (umsub_widen_optab, $B)->insn_code = CODE_FOR_$(umsub$a$b4$)$N",
"optab_handler (ssmsub_widen_optab, $B)->insn_code = CODE_FOR_$(ssmsub$a$b4$)$N",
"optab_handler (usmsub_widen_optab, $B)->insn_code = CODE_FOR_$(usmsub$a$b4$)$N",
"optab_handler (sdiv_optab, $A)->insn_code = CODE_FOR_$(div$a3$)",
"optab_handler (ssdiv_optab, $A)->insn_code = CODE_FOR_$(ssdiv$Q$a3$)",
"optab_handler (sdivv_optab, $A)->insn_code = CODE_FOR_$(div$V$I$a3$)",
"optab_handler (udiv_optab, $A)->insn_code = CODE_FOR_$(udiv$I$a3$)",
"optab_handler (udiv_optab, $A)->insn_code = CODE_FOR_$(udiv$Q$a3$)",
"optab_handler (usdiv_optab, $A)->insn_code = CODE_FOR_$(usdiv$Q$a3$)",
"optab_handler (sdivmod_optab, $A)->insn_code = CODE_FOR_$(divmod$a4$)",
"optab_handler (udivmod_optab, $A)->insn_code = CODE_FOR_$(udivmod$a4$)",
"optab_handler (smod_optab, $A)->insn_code = CODE_FOR_$(mod$a3$)",
"optab_handler (umod_optab, $A)->insn_code = CODE_FOR_$(umod$a3$)",
"optab_handler (fmod_optab, $A)->insn_code = CODE_FOR_$(fmod$a3$)",
"optab_handler (remainder_optab, $A)->insn_code = CODE_FOR_$(remainder$a3$)",
"optab_handler (ftrunc_optab, $A)->insn_code = CODE_FOR_$(ftrunc$F$a2$)",
"optab_handler (and_optab, $A)->insn_code = CODE_FOR_$(and$a3$)",
"optab_handler (ior_optab, $A)->insn_code = CODE_FOR_$(ior$a3$)",
"optab_handler (xor_optab, $A)->insn_code = CODE_FOR_$(xor$a3$)",
"optab_handler (ashl_optab, $A)->insn_code = CODE_FOR_$(ashl$a3$)",
"optab_handler (ssashl_optab, $A)->insn_code = CODE_FOR_$(ssashl$Q$a3$)",
"optab_handler (usashl_optab, $A)->insn_code = CODE_FOR_$(usashl$Q$a3$)",
"optab_handler (ashr_optab, $A)->insn_code = CODE_FOR_$(ashr$a3$)",
"optab_handler (lshr_optab, $A)->insn_code = CODE_FOR_$(lshr$a3$)",
"optab_handler (rotl_optab, $A)->insn_code = CODE_FOR_$(rotl$a3$)",
"optab_handler (rotr_optab, $A)->insn_code = CODE_FOR_$(rotr$a3$)",
"optab_handler (vashr_optab, $A)->insn_code = CODE_FOR_$(vashr$a3$)",
"optab_handler (vlshr_optab, $A)->insn_code = CODE_FOR_$(vlshr$a3$)",
"optab_handler (vashl_optab, $A)->insn_code = CODE_FOR_$(vashl$a3$)",
"optab_handler (vrotl_optab, $A)->insn_code = CODE_FOR_$(vrotl$a3$)",
"optab_handler (vrotr_optab, $A)->insn_code = CODE_FOR_$(vrotr$a3$)",
"optab_handler (smin_optab, $A)->insn_code = CODE_FOR_$(smin$a3$)",
"optab_handler (smax_optab, $A)->insn_code = CODE_FOR_$(smax$a3$)",
"optab_handler (umin_optab, $A)->insn_code = CODE_FOR_$(umin$I$a3$)",
"optab_handler (umax_optab, $A)->insn_code = CODE_FOR_$(umax$I$a3$)",
"optab_handler (pow_optab, $A)->insn_code = CODE_FOR_$(pow$a3$)",
"optab_handler (atan2_optab, $A)->insn_code = CODE_FOR_$(atan2$a3$)",
"optab_handler (neg_optab, $A)->insn_code = CODE_FOR_$(neg$P$a2$)",
"optab_handler (negv_optab, $A)->insn_code =\n\
optab_handler (neg_optab, $A)->insn_code = CODE_FOR_$(neg$F$a2$)",
"optab_handler (negv_optab, $A)->insn_code = CODE_FOR_$(negv$I$a2$)",
"optab_handler (neg_optab, $A)->insn_code = CODE_FOR_$(neg$Q$a2$)",
"optab_handler (ssneg_optab, $A)->insn_code = CODE_FOR_$(ssneg$Q$a2$)",
"optab_handler (usneg_optab, $A)->insn_code = CODE_FOR_$(usneg$Q$a2$)",
"optab_handler (abs_optab, $A)->insn_code = CODE_FOR_$(abs$P$a2$)",
"optab_handler (absv_optab, $A)->insn_code =\n\
optab_handler (abs_optab, $A)->insn_code = CODE_FOR_$(abs$F$a2$)",
"optab_handler (absv_optab, $A)->insn_code = CODE_FOR_$(absv$I$a2$)",
"optab_handler (copysign_optab, $A)->insn_code = CODE_FOR_$(copysign$F$a3$)",
"optab_handler (signbit_optab, $A)->insn_code = CODE_FOR_$(signbit$F$a2$)",
"optab_handler (isinf_optab, $A)->insn_code = CODE_FOR_$(isinf$a2$)",
"optab_handler (sqrt_optab, $A)->insn_code = CODE_FOR_$(sqrt$a2$)",
"optab_handler (floor_optab, $A)->insn_code = CODE_FOR_$(floor$a2$)",
"convert_optab_handler (lfloor_optab, $B, $A)->insn_code = CODE_FOR_$(lfloor$F$a$I$b2$)",
"optab_handler (ceil_optab, $A)->insn_code = CODE_FOR_$(ceil$a2$)",
"convert_optab_handler (lceil_optab, $B, $A)->insn_code = CODE_FOR_$(lceil$F$a$I$b2$)",
"optab_handler (round_optab, $A)->insn_code = CODE_FOR_$(round$a2$)",
"optab_handler (btrunc_optab, $A)->insn_code = CODE_FOR_$(btrunc$a2$)",
"optab_handler (nearbyint_optab, $A)->insn_code = CODE_FOR_$(nearbyint$a2$)",
"optab_handler (rint_optab, $A)->insn_code = CODE_FOR_$(rint$a2$)",
"convert_optab_handler (lrint_optab, $B, $A)->insn_code = CODE_FOR_$(lrint$F$a$I$b2$)",
"convert_optab_handler (lround_optab, $B, $A)->insn_code = CODE_FOR_$(lround$F$a$I$b2$)",
"optab_handler (sincos_optab, $A)->insn_code = CODE_FOR_$(sincos$a3$)",
"optab_handler (sin_optab, $A)->insn_code = CODE_FOR_$(sin$a2$)",
"optab_handler (asin_optab, $A)->insn_code = CODE_FOR_$(asin$a2$)",
"optab_handler (cos_optab, $A)->insn_code = CODE_FOR_$(cos$a2$)",
"optab_handler (acos_optab, $A)->insn_code = CODE_FOR_$(acos$a2$)",
"optab_handler (exp_optab, $A)->insn_code = CODE_FOR_$(exp$a2$)",
"optab_handler (exp10_optab, $A)->insn_code = CODE_FOR_$(exp10$a2$)",
"optab_handler (exp2_optab, $A)->insn_code = CODE_FOR_$(exp2$a2$)",
"optab_handler (expm1_optab, $A)->insn_code = CODE_FOR_$(expm1$a2$)",
"optab_handler (ldexp_optab, $A)->insn_code = CODE_FOR_$(ldexp$a3$)",
"optab_handler (scalb_optab, $A)->insn_code = CODE_FOR_$(scalb$a3$)",
"optab_handler (significand_optab, $A)->insn_code = CODE_FOR_$(significand$a2$)",
"optab_handler (logb_optab, $A)->insn_code = CODE_FOR_$(logb$a2$)",
"optab_handler (ilogb_optab, $A)->insn_code = CODE_FOR_$(ilogb$a2$)",
"optab_handler (log_optab, $A)->insn_code = CODE_FOR_$(log$a2$)",
"optab_handler (log10_optab, $A)->insn_code = CODE_FOR_$(log10$a2$)",
"optab_handler (log2_optab, $A)->insn_code = CODE_FOR_$(log2$a2$)",
"optab_handler (log1p_optab, $A)->insn_code = CODE_FOR_$(log1p$a2$)",
"optab_handler (tan_optab, $A)->insn_code = CODE_FOR_$(tan$a2$)",
"optab_handler (atan_optab, $A)->insn_code = CODE_FOR_$(atan$a2$)",
"optab_handler (strlen_optab, $A)->insn_code = CODE_FOR_$(strlen$a$)",
"optab_handler (one_cmpl_optab, $A)->insn_code = CODE_FOR_$(one_cmpl$a2$)",
"optab_handler (bswap_optab, $A)->insn_code = CODE_FOR_$(bswap$a2$)",
"optab_handler (ffs_optab, $A)->insn_code = CODE_FOR_$(ffs$a2$)",
"optab_handler (clz_optab, $A)->insn_code = CODE_FOR_$(clz$a2$)",
"optab_handler (ctz_optab, $A)->insn_code = CODE_FOR_$(ctz$a2$)",
"optab_handler (popcount_optab, $A)->insn_code = CODE_FOR_$(popcount$a2$)",
"optab_handler (parity_optab, $A)->insn_code = CODE_FOR_$(parity$a2$)",
"optab_handler (mov_optab, $A)->insn_code = CODE_FOR_$(mov$a$)",
"optab_handler (movstrict_optab, $A)->insn_code = CODE_FOR_$(movstrict$a$)",
"optab_handler (movmisalign_optab, $A)->insn_code = CODE_FOR_$(movmisalign$a$)",
"optab_handler (storent_optab, $A)->insn_code = CODE_FOR_$(storent$a$)",
"optab_handler (addcc_optab, $A)->insn_code = CODE_FOR_$(add$acc$)",
{ "set_convert_optab_handler (sext_optab, $B, $A, CODE_FOR_$(extend$a$b2$))",
"set_convert_optab_handler (zext_optab, $B, $A, CODE_FOR_$(zero_extend$a$b2$))",
"set_convert_optab_handler (sfix_optab, $B, $A, CODE_FOR_$(fix$F$a$I$b2$))",
"set_convert_optab_handler (ufix_optab, $B, $A, CODE_FOR_$(fixuns$F$a$b2$))",
"set_convert_optab_handler (sfixtrunc_optab, $B, $A, CODE_FOR_$(fix_trunc$F$a$I$b2$))",
"set_convert_optab_handler (ufixtrunc_optab, $B, $A, CODE_FOR_$(fixuns_trunc$F$a$I$b2$))",
"set_convert_optab_handler (sfloat_optab, $B, $A, CODE_FOR_$(float$I$a$F$b2$))",
"set_convert_optab_handler (ufloat_optab, $B, $A, CODE_FOR_$(floatuns$I$a$F$b2$))",
"set_convert_optab_handler (trunc_optab, $B, $A, CODE_FOR_$(trunc$a$b2$))",
"set_convert_optab_handler (fract_optab, $B, $A, CODE_FOR_$(fract$a$b2$))",
"set_convert_optab_handler (fractuns_optab, $B, $A, CODE_FOR_$(fractuns$I$a$Q$b2$))",
"set_convert_optab_handler (fractuns_optab, $B, $A, CODE_FOR_$(fractuns$Q$a$I$b2$))",
"set_convert_optab_handler (satfract_optab, $B, $A, CODE_FOR_$(satfract$a$Q$b2$))",
"set_convert_optab_handler (satfractuns_optab, $B, $A, CODE_FOR_$(satfractuns$I$a$Q$b2$))",
"set_optab_handler (add_optab, $A, CODE_FOR_$(add$P$a3$))",
"set_optab_handler (addv_optab, $A, CODE_FOR_$(add$F$a3$)),\n\
set_optab_handler (add_optab, $A, CODE_FOR_$(add$F$a3$))",
"set_optab_handler (addv_optab, $A, CODE_FOR_$(addv$I$a3$))",
"set_optab_handler (add_optab, $A, CODE_FOR_$(add$Q$a3$))",
"set_optab_handler (ssadd_optab, $A, CODE_FOR_$(ssadd$Q$a3$))",
"set_optab_handler (usadd_optab, $A, CODE_FOR_$(usadd$Q$a3$))",
"set_optab_handler (sub_optab, $A, CODE_FOR_$(sub$P$a3$))",
"set_optab_handler (subv_optab, $A, CODE_FOR_$(sub$F$a3$)),\n\
set_optab_handler (sub_optab, $A, CODE_FOR_$(sub$F$a3$))",
"set_optab_handler (subv_optab, $A, CODE_FOR_$(subv$I$a3$))",
"set_optab_handler (sub_optab, $A, CODE_FOR_$(sub$Q$a3$))",
"set_optab_handler (sssub_optab, $A, CODE_FOR_$(sssub$Q$a3$))",
"set_optab_handler (ussub_optab, $A, CODE_FOR_$(ussub$Q$a3$))",
"set_optab_handler (smul_optab, $A, CODE_FOR_$(mul$Q$a3$))",
"set_optab_handler (ssmul_optab, $A, CODE_FOR_$(ssmul$Q$a3$))",
"set_optab_handler (usmul_optab, $A, CODE_FOR_$(usmul$Q$a3$))",
"set_optab_handler (smul_optab, $A, CODE_FOR_$(mul$P$a3$))",
"set_optab_handler (smulv_optab, $A, CODE_FOR_$(mul$F$a3$)),\n\
set_optab_handler (smul_optab, $A, CODE_FOR_$(mul$F$a3$))",
"set_optab_handler (smulv_optab, $A, CODE_FOR_$(mulv$I$a3$))",
"set_optab_handler (umul_highpart_optab, $A, CODE_FOR_$(umul$a3_highpart$))",
"set_optab_handler (smul_highpart_optab, $A, CODE_FOR_$(smul$a3_highpart$))",
"set_optab_handler (smul_widen_optab, $B, CODE_FOR_$(mul$a$b3$)$N)",
"set_optab_handler (umul_widen_optab, $B, CODE_FOR_$(umul$a$b3$)$N)",
"set_optab_handler (usmul_widen_optab, $B, CODE_FOR_$(usmul$a$b3$)$N)",
"set_optab_handler (smadd_widen_optab, $B, CODE_FOR_$(madd$a$b4$)$N)",
"set_optab_handler (umadd_widen_optab, $B, CODE_FOR_$(umadd$a$b4$)$N)",
"set_optab_handler (ssmadd_widen_optab, $B, CODE_FOR_$(ssmadd$a$b4$)$N)",
"set_optab_handler (usmadd_widen_optab, $B, CODE_FOR_$(usmadd$a$b4$)$N)",
"set_optab_handler (smsub_widen_optab, $B, CODE_FOR_$(msub$a$b4$)$N)",
"set_optab_handler (umsub_widen_optab, $B, CODE_FOR_$(umsub$a$b4$)$N)",
"set_optab_handler (ssmsub_widen_optab, $B, CODE_FOR_$(ssmsub$a$b4$)$N)",
"set_optab_handler (usmsub_widen_optab, $B, CODE_FOR_$(usmsub$a$b4$)$N)",
"set_optab_handler (sdiv_optab, $A, CODE_FOR_$(div$a3$))",
"set_optab_handler (ssdiv_optab, $A, CODE_FOR_$(ssdiv$Q$a3$))",
"set_optab_handler (sdivv_optab, $A, CODE_FOR_$(div$V$I$a3$))",
"set_optab_handler (udiv_optab, $A, CODE_FOR_$(udiv$I$a3$))",
"set_optab_handler (udiv_optab, $A, CODE_FOR_$(udiv$Q$a3$))",
"set_optab_handler (usdiv_optab, $A, CODE_FOR_$(usdiv$Q$a3$))",
"set_optab_handler (sdivmod_optab, $A, CODE_FOR_$(divmod$a4$))",
"set_optab_handler (udivmod_optab, $A, CODE_FOR_$(udivmod$a4$))",
"set_optab_handler (smod_optab, $A, CODE_FOR_$(mod$a3$))",
"set_optab_handler (umod_optab, $A, CODE_FOR_$(umod$a3$))",
"set_optab_handler (fmod_optab, $A, CODE_FOR_$(fmod$a3$))",
"set_optab_handler (remainder_optab, $A, CODE_FOR_$(remainder$a3$))",
"set_optab_handler (ftrunc_optab, $A, CODE_FOR_$(ftrunc$F$a2$))",
"set_optab_handler (and_optab, $A, CODE_FOR_$(and$a3$))",
"set_optab_handler (ior_optab, $A, CODE_FOR_$(ior$a3$))",
"set_optab_handler (xor_optab, $A, CODE_FOR_$(xor$a3$))",
"set_optab_handler (ashl_optab, $A, CODE_FOR_$(ashl$a3$))",
"set_optab_handler (ssashl_optab, $A, CODE_FOR_$(ssashl$Q$a3$))",
"set_optab_handler (usashl_optab, $A, CODE_FOR_$(usashl$Q$a3$))",
"set_optab_handler (ashr_optab, $A, CODE_FOR_$(ashr$a3$))",
"set_optab_handler (lshr_optab, $A, CODE_FOR_$(lshr$a3$))",
"set_optab_handler (rotl_optab, $A, CODE_FOR_$(rotl$a3$))",
"set_optab_handler (rotr_optab, $A, CODE_FOR_$(rotr$a3$))",
"set_optab_handler (vashr_optab, $A, CODE_FOR_$(vashr$a3$))",
"set_optab_handler (vlshr_optab, $A, CODE_FOR_$(vlshr$a3$))",
"set_optab_handler (vashl_optab, $A, CODE_FOR_$(vashl$a3$))",
"set_optab_handler (vrotl_optab, $A, CODE_FOR_$(vrotl$a3$))",
"set_optab_handler (vrotr_optab, $A, CODE_FOR_$(vrotr$a3$))",
"set_optab_handler (smin_optab, $A, CODE_FOR_$(smin$a3$))",
"set_optab_handler (smax_optab, $A, CODE_FOR_$(smax$a3$))",
"set_optab_handler (umin_optab, $A, CODE_FOR_$(umin$I$a3$))",
"set_optab_handler (umax_optab, $A, CODE_FOR_$(umax$I$a3$))",
"set_optab_handler (pow_optab, $A, CODE_FOR_$(pow$a3$))",
"set_optab_handler (atan2_optab, $A, CODE_FOR_$(atan2$a3$))",
"set_optab_handler (neg_optab, $A, CODE_FOR_$(neg$P$a2$))",
"set_optab_handler (negv_optab, $A, CODE_FOR_$(neg$F$a2$)),\n\
set_optab_handler (neg_optab, $A, CODE_FOR_$(neg$F$a2$))",
"set_optab_handler (negv_optab, $A, CODE_FOR_$(negv$I$a2$))",
"set_optab_handler (neg_optab, $A, CODE_FOR_$(neg$Q$a2$))",
"set_optab_handler (ssneg_optab, $A, CODE_FOR_$(ssneg$Q$a2$))",
"set_optab_handler (usneg_optab, $A, CODE_FOR_$(usneg$Q$a2$))",
"set_optab_handler (abs_optab, $A, CODE_FOR_$(abs$P$a2$))",
"set_optab_handler (absv_optab, $A, CODE_FOR_$(abs$F$a2$)),\n\
set_optab_handler (abs_optab, $A, CODE_FOR_$(abs$F$a2$))",
"set_optab_handler (absv_optab, $A, CODE_FOR_$(absv$I$a2$))",
"set_optab_handler (copysign_optab, $A, CODE_FOR_$(copysign$F$a3$))",
"set_optab_handler (signbit_optab, $A, CODE_FOR_$(signbit$F$a2$))",
"set_optab_handler (isinf_optab, $A, CODE_FOR_$(isinf$a2$))",
"set_optab_handler (sqrt_optab, $A, CODE_FOR_$(sqrt$a2$))",
"set_optab_handler (floor_optab, $A, CODE_FOR_$(floor$a2$))",
"set_convert_optab_handler (lfloor_optab, $B, $A, CODE_FOR_$(lfloor$F$a$I$b2$))",
"set_optab_handler (ceil_optab, $A, CODE_FOR_$(ceil$a2$))",
"set_convert_optab_handler (lceil_optab, $B, $A, CODE_FOR_$(lceil$F$a$I$b2$))",
"set_optab_handler (round_optab, $A, CODE_FOR_$(round$a2$))",
"set_optab_handler (btrunc_optab, $A, CODE_FOR_$(btrunc$a2$))",
"set_optab_handler (nearbyint_optab, $A, CODE_FOR_$(nearbyint$a2$))",
"set_optab_handler (rint_optab, $A, CODE_FOR_$(rint$a2$))",
"set_convert_optab_handler (lrint_optab, $B, $A, CODE_FOR_$(lrint$F$a$I$b2$))",
"set_convert_optab_handler (lround_optab, $B, $A, CODE_FOR_$(lround$F$a$I$b2$))",
"set_optab_handler (sincos_optab, $A, CODE_FOR_$(sincos$a3$))",
"set_optab_handler (sin_optab, $A, CODE_FOR_$(sin$a2$))",
"set_optab_handler (asin_optab, $A, CODE_FOR_$(asin$a2$))",
"set_optab_handler (cos_optab, $A, CODE_FOR_$(cos$a2$))",
"set_optab_handler (acos_optab, $A, CODE_FOR_$(acos$a2$))",
"set_optab_handler (exp_optab, $A, CODE_FOR_$(exp$a2$))",
"set_optab_handler (exp10_optab, $A, CODE_FOR_$(exp10$a2$))",
"set_optab_handler (exp2_optab, $A, CODE_FOR_$(exp2$a2$))",
"set_optab_handler (expm1_optab, $A, CODE_FOR_$(expm1$a2$))",
"set_optab_handler (ldexp_optab, $A, CODE_FOR_$(ldexp$a3$))",
"set_optab_handler (scalb_optab, $A, CODE_FOR_$(scalb$a3$))",
"set_optab_handler (significand_optab, $A, CODE_FOR_$(significand$a2$))",
"set_optab_handler (logb_optab, $A, CODE_FOR_$(logb$a2$))",
"set_optab_handler (ilogb_optab, $A, CODE_FOR_$(ilogb$a2$))",
"set_optab_handler (log_optab, $A, CODE_FOR_$(log$a2$))",
"set_optab_handler (log10_optab, $A, CODE_FOR_$(log10$a2$))",
"set_optab_handler (log2_optab, $A, CODE_FOR_$(log2$a2$))",
"set_optab_handler (log1p_optab, $A, CODE_FOR_$(log1p$a2$))",
"set_optab_handler (tan_optab, $A, CODE_FOR_$(tan$a2$))",
"set_optab_handler (atan_optab, $A, CODE_FOR_$(atan$a2$))",
"set_optab_handler (strlen_optab, $A, CODE_FOR_$(strlen$a$))",
"set_optab_handler (one_cmpl_optab, $A, CODE_FOR_$(one_cmpl$a2$))",
"set_optab_handler (bswap_optab, $A, CODE_FOR_$(bswap$a2$))",
"set_optab_handler (ffs_optab, $A, CODE_FOR_$(ffs$a2$))",
"set_optab_handler (clz_optab, $A, CODE_FOR_$(clz$a2$))",
"set_optab_handler (ctz_optab, $A, CODE_FOR_$(ctz$a2$))",
"set_optab_handler (popcount_optab, $A, CODE_FOR_$(popcount$a2$))",
"set_optab_handler (parity_optab, $A, CODE_FOR_$(parity$a2$))",
"set_optab_handler (mov_optab, $A, CODE_FOR_$(mov$a$))",
"set_optab_handler (movstrict_optab, $A, CODE_FOR_$(movstrict$a$))",
"set_optab_handler (movmisalign_optab, $A, CODE_FOR_$(movmisalign$a$))",
"set_optab_handler (storent_optab, $A, CODE_FOR_$(storent$a$))",
"set_optab_handler (addcc_optab, $A, CODE_FOR_$(add$acc$))",
"movcc_gen_code[$A] = CODE_FOR_$(mov$acc$)",
"optab_handler (cbranch_optab, $A)->insn_code = CODE_FOR_$(cbranch$a4$)",
"optab_handler (cmov_optab, $A)->insn_code = CODE_FOR_$(cmov$a6$)",
"optab_handler (cstore_optab, $A)->insn_code = CODE_FOR_$(cstore$a4$)",
"optab_handler (ctrap_optab, $A)->insn_code = CODE_FOR_$(ctrap$a4$)",
"optab_handler (push_optab, $A)->insn_code = CODE_FOR_$(push$a1$)",
"set_optab_handler (cbranch_optab, $A, CODE_FOR_$(cbranch$a4$))",
"set_optab_handler (cmov_optab, $A, CODE_FOR_$(cmov$a6$))",
"set_optab_handler (cstore_optab, $A, CODE_FOR_$(cstore$a4$))",
"set_optab_handler (ctrap_optab, $A, CODE_FOR_$(ctrap$a4$))",
"set_optab_handler (push_optab, $A, CODE_FOR_$(push$a1$))",
"reload_in_optab[$A] = CODE_FOR_$(reload_in$a$)",
"reload_out_optab[$A] = CODE_FOR_$(reload_out$a$)",
"movmem_optab[$A] = CODE_FOR_$(movmem$a$)",
@ -234,45 +234,45 @@ static const char * const optabs[] =
"sync_compare_and_swap[$A] = CODE_FOR_$(sync_compare_and_swap$I$a$)",
"sync_lock_test_and_set[$A] = CODE_FOR_$(sync_lock_test_and_set$I$a$)",
"sync_lock_release[$A] = CODE_FOR_$(sync_lock_release$I$a$)",
"optab_handler (vec_set_optab, $A)->insn_code = CODE_FOR_$(vec_set$a$)",
"optab_handler (vec_extract_optab, $A)->insn_code = CODE_FOR_$(vec_extract$a$)",
"optab_handler (vec_extract_even_optab, $A)->insn_code = CODE_FOR_$(vec_extract_even$a$)",
"optab_handler (vec_extract_odd_optab, $A)->insn_code = CODE_FOR_$(vec_extract_odd$a$)",
"optab_handler (vec_interleave_high_optab, $A)->insn_code = CODE_FOR_$(vec_interleave_high$a$)",
"optab_handler (vec_interleave_low_optab, $A)->insn_code = CODE_FOR_$(vec_interleave_low$a$)",
"optab_handler (vec_init_optab, $A)->insn_code = CODE_FOR_$(vec_init$a$)",
"optab_handler (vec_shl_optab, $A)->insn_code = CODE_FOR_$(vec_shl_$a$)",
"optab_handler (vec_shr_optab, $A)->insn_code = CODE_FOR_$(vec_shr_$a$)",
"optab_handler (vec_realign_load_optab, $A)->insn_code = CODE_FOR_$(vec_realign_load_$a$)",
"set_optab_handler (vec_set_optab, $A, CODE_FOR_$(vec_set$a$))",
"set_optab_handler (vec_extract_optab, $A, CODE_FOR_$(vec_extract$a$))",
"set_optab_handler (vec_extract_even_optab, $A, CODE_FOR_$(vec_extract_even$a$))",
"set_optab_handler (vec_extract_odd_optab, $A, CODE_FOR_$(vec_extract_odd$a$))",
"set_optab_handler (vec_interleave_high_optab, $A, CODE_FOR_$(vec_interleave_high$a$))",
"set_optab_handler (vec_interleave_low_optab, $A, CODE_FOR_$(vec_interleave_low$a$))",
"set_optab_handler (vec_init_optab, $A, CODE_FOR_$(vec_init$a$))",
"set_optab_handler (vec_shl_optab, $A, CODE_FOR_$(vec_shl_$a$))",
"set_optab_handler (vec_shr_optab, $A, CODE_FOR_$(vec_shr_$a$))",
"set_optab_handler (vec_realign_load_optab, $A, CODE_FOR_$(vec_realign_load_$a$))",
"vcond_gen_code[$A] = CODE_FOR_$(vcond$a$)",
"vcondu_gen_code[$A] = CODE_FOR_$(vcondu$a$)",
"optab_handler (ssum_widen_optab, $A)->insn_code = CODE_FOR_$(widen_ssum$I$a3$)",
"optab_handler (usum_widen_optab, $A)->insn_code = CODE_FOR_$(widen_usum$I$a3$)",
"optab_handler (udot_prod_optab, $A)->insn_code = CODE_FOR_$(udot_prod$I$a$)",
"optab_handler (sdot_prod_optab, $A)->insn_code = CODE_FOR_$(sdot_prod$I$a$)",
"optab_handler (reduc_smax_optab, $A)->insn_code = CODE_FOR_$(reduc_smax_$a$)",
"optab_handler (reduc_umax_optab, $A)->insn_code = CODE_FOR_$(reduc_umax_$a$)",
"optab_handler (reduc_smin_optab, $A)->insn_code = CODE_FOR_$(reduc_smin_$a$)",
"optab_handler (reduc_umin_optab, $A)->insn_code = CODE_FOR_$(reduc_umin_$a$)",
"optab_handler (reduc_splus_optab, $A)->insn_code = CODE_FOR_$(reduc_splus_$a$)" ,
"optab_handler (reduc_uplus_optab, $A)->insn_code = CODE_FOR_$(reduc_uplus_$a$)",
"optab_handler (vec_widen_umult_hi_optab, $A)->insn_code = CODE_FOR_$(vec_widen_umult_hi_$a$)",
"optab_handler (vec_widen_umult_lo_optab, $A)->insn_code = CODE_FOR_$(vec_widen_umult_lo_$a$)",
"optab_handler (vec_widen_smult_hi_optab, $A)->insn_code = CODE_FOR_$(vec_widen_smult_hi_$a$)",
"optab_handler (vec_widen_smult_lo_optab, $A)->insn_code = CODE_FOR_$(vec_widen_smult_lo_$a$)",
"optab_handler (vec_unpacks_hi_optab, $A)->insn_code = CODE_FOR_$(vec_unpacks_hi_$a$)",
"optab_handler (vec_unpacks_lo_optab, $A)->insn_code = CODE_FOR_$(vec_unpacks_lo_$a$)",
"optab_handler (vec_unpacku_hi_optab, $A)->insn_code = CODE_FOR_$(vec_unpacku_hi_$a$)",
"optab_handler (vec_unpacku_lo_optab, $A)->insn_code = CODE_FOR_$(vec_unpacku_lo_$a$)",
"optab_handler (vec_unpacks_float_hi_optab, $A)->insn_code = CODE_FOR_$(vec_unpacks_float_hi_$a$)",
"optab_handler (vec_unpacks_float_lo_optab, $A)->insn_code = CODE_FOR_$(vec_unpacks_float_lo_$a$)",
"optab_handler (vec_unpacku_float_hi_optab, $A)->insn_code = CODE_FOR_$(vec_unpacku_float_hi_$a$)",
"optab_handler (vec_unpacku_float_lo_optab, $A)->insn_code = CODE_FOR_$(vec_unpacku_float_lo_$a$)",
"optab_handler (vec_pack_trunc_optab, $A)->insn_code = CODE_FOR_$(vec_pack_trunc_$a$)",
"optab_handler (vec_pack_ssat_optab, $A)->insn_code = CODE_FOR_$(vec_pack_ssat_$a$)",
"optab_handler (vec_pack_usat_optab, $A)->insn_code = CODE_FOR_$(vec_pack_usat_$a$)",
"optab_handler (vec_pack_sfix_trunc_optab, $A)->insn_code = CODE_FOR_$(vec_pack_sfix_trunc_$a$)",
"optab_handler (vec_pack_ufix_trunc_optab, $A)->insn_code = CODE_FOR_$(vec_pack_ufix_trunc_$a$)"
"set_optab_handler (ssum_widen_optab, $A, CODE_FOR_$(widen_ssum$I$a3$))",
"set_optab_handler (usum_widen_optab, $A, CODE_FOR_$(widen_usum$I$a3$))",
"set_optab_handler (udot_prod_optab, $A, CODE_FOR_$(udot_prod$I$a$))",
"set_optab_handler (sdot_prod_optab, $A, CODE_FOR_$(sdot_prod$I$a$))",
"set_optab_handler (reduc_smax_optab, $A, CODE_FOR_$(reduc_smax_$a$))",
"set_optab_handler (reduc_umax_optab, $A, CODE_FOR_$(reduc_umax_$a$))",
"set_optab_handler (reduc_smin_optab, $A, CODE_FOR_$(reduc_smin_$a$))",
"set_optab_handler (reduc_umin_optab, $A, CODE_FOR_$(reduc_umin_$a$))",
"set_optab_handler (reduc_splus_optab, $A, CODE_FOR_$(reduc_splus_$a$))" ,
"set_optab_handler (reduc_uplus_optab, $A, CODE_FOR_$(reduc_uplus_$a$))",
"set_optab_handler (vec_widen_umult_hi_optab, $A, CODE_FOR_$(vec_widen_umult_hi_$a$))",
"set_optab_handler (vec_widen_umult_lo_optab, $A, CODE_FOR_$(vec_widen_umult_lo_$a$))",
"set_optab_handler (vec_widen_smult_hi_optab, $A, CODE_FOR_$(vec_widen_smult_hi_$a$))",
"set_optab_handler (vec_widen_smult_lo_optab, $A, CODE_FOR_$(vec_widen_smult_lo_$a$))",
"set_optab_handler (vec_unpacks_hi_optab, $A, CODE_FOR_$(vec_unpacks_hi_$a$))",
"set_optab_handler (vec_unpacks_lo_optab, $A, CODE_FOR_$(vec_unpacks_lo_$a$))",
"set_optab_handler (vec_unpacku_hi_optab, $A, CODE_FOR_$(vec_unpacku_hi_$a$))",
"set_optab_handler (vec_unpacku_lo_optab, $A, CODE_FOR_$(vec_unpacku_lo_$a$))",
"set_optab_handler (vec_unpacks_float_hi_optab, $A, CODE_FOR_$(vec_unpacks_float_hi_$a$))",
"set_optab_handler (vec_unpacks_float_lo_optab, $A, CODE_FOR_$(vec_unpacks_float_lo_$a$))",
"set_optab_handler (vec_unpacku_float_hi_optab, $A, CODE_FOR_$(vec_unpacku_float_hi_$a$))",
"set_optab_handler (vec_unpacku_float_lo_optab, $A, CODE_FOR_$(vec_unpacku_float_lo_$a$))",
"set_optab_handler (vec_pack_trunc_optab, $A, CODE_FOR_$(vec_pack_trunc_$a$))",
"set_optab_handler (vec_pack_ssat_optab, $A, CODE_FOR_$(vec_pack_ssat_$a$))",
"set_optab_handler (vec_pack_usat_optab, $A, CODE_FOR_$(vec_pack_usat_$a$))",
"set_optab_handler (vec_pack_sfix_trunc_optab, $A, CODE_FOR_$(vec_pack_sfix_trunc_$a$))",
"set_optab_handler (vec_pack_ufix_trunc_optab, $A, CODE_FOR_$(vec_pack_ufix_trunc_$a$))"
};
static void gen_insn (rtx);
@ -519,8 +519,9 @@ from the machine description file `md'. */\n\n");
also convert validly to an unsigned one. */\n\
for (i = 0; i < NUM_MACHINE_MODES; i++)\n\
for (j = 0; j < NUM_MACHINE_MODES; j++)\n\
convert_optab_handler (ufixtrunc_optab, i, j)->insn_code\n\
= convert_optab_handler (sfixtrunc_optab, i, j)->insn_code;\n\
set_convert_optab_handler\n\
(ufixtrunc_optab, i, j,\n\
convert_optab_handler (sfixtrunc_optab, i, j));\n\
#endif\n\
}");

2
gcc/ifcvt.c
View File

@ -3156,7 +3156,7 @@ find_if_header (basic_block test_bb, int pass)
goto success;
if (HAVE_trap
&& optab_handler (ctrap_optab, word_mode)->insn_code != CODE_FOR_nothing
&& optab_handler (ctrap_optab, word_mode) != CODE_FOR_nothing
&& find_cond_trap (test_bb, then_edge, else_edge))
goto success;

173
gcc/optabs.c
View File

@ -563,9 +563,9 @@ expand_widen_pattern_expr (sepops ops, rtx op0, rtx op1, rtx wide_op,
if (ops->code == WIDEN_MULT_PLUS_EXPR
|| ops->code == WIDEN_MULT_MINUS_EXPR)
icode = (int) optab_handler (widen_pattern_optab,
TYPE_MODE (TREE_TYPE (ops->op2)))->insn_code;
TYPE_MODE (TREE_TYPE (ops->op2)));
else
icode = (int) optab_handler (widen_pattern_optab, tmode0)->insn_code;
icode = (int) optab_handler (widen_pattern_optab, tmode0);
gcc_assert (icode != CODE_FOR_nothing);
xmode0 = insn_data[icode].operand[1].mode;
@ -690,7 +690,7 @@ rtx
expand_ternary_op (enum machine_mode mode, optab ternary_optab, rtx op0,
rtx op1, rtx op2, rtx target, int unsignedp)
{
int icode = (int) optab_handler (ternary_optab, mode)->insn_code;
int icode = (int) optab_handler (ternary_optab, mode);
enum machine_mode mode0 = insn_data[icode].operand[1].mode;
enum machine_mode mode1 = insn_data[icode].operand[2].mode;
enum machine_mode mode2 = insn_data[icode].operand[3].mode;
@ -698,8 +698,7 @@ expand_ternary_op (enum machine_mode mode, optab ternary_optab, rtx op0,
rtx pat;
rtx xop0 = op0, xop1 = op1, xop2 = op2;
gcc_assert (optab_handler (ternary_optab, mode)->insn_code
!= CODE_FOR_nothing);
gcc_assert (optab_handler (ternary_optab, mode) != CODE_FOR_nothing);
if (!target || !insn_data[icode].operand[0].predicate (target, mode))
temp = gen_reg_rtx (mode);
@ -819,7 +818,7 @@ expand_vec_shift_expr (sepops ops, rtx target)
gcc_unreachable ();
}
icode = optab_handler (shift_optab, mode)->insn_code;
icode = optab_handler (shift_optab, mode);
gcc_assert (icode != CODE_FOR_nothing);
mode1 = insn_data[icode].operand[1].mode;
@ -1436,7 +1435,7 @@ expand_binop_directly (enum machine_mode mode, optab binoptab,
rtx target, int unsignedp, enum optab_methods methods,
rtx last)
{
int icode = (int) optab_handler (binoptab, mode)->insn_code;
int icode = (int) optab_handler (binoptab, mode);
enum machine_mode mode0 = insn_data[icode].operand[1].mode;
enum machine_mode mode1 = insn_data[icode].operand[2].mode;
enum machine_mode tmp_mode;
@ -1593,7 +1592,7 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1,
/* If we can do it with a three-operand insn, do so. */
if (methods != OPTAB_MUST_WIDEN
&& optab_handler (binoptab, mode)->insn_code != CODE_FOR_nothing)
&& optab_handler (binoptab, mode) != CODE_FOR_nothing)
{
temp = expand_binop_directly (mode, binoptab, op0, op1, target,
unsignedp, methods, last);
@ -1604,9 +1603,9 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1,
/* If we were trying to rotate, and that didn't work, try rotating
the other direction before falling back to shifts and bitwise-or. */
if (((binoptab == rotl_optab
&& optab_handler (rotr_optab, mode)->insn_code != CODE_FOR_nothing)
&& optab_handler (rotr_optab, mode) != CODE_FOR_nothing)
|| (binoptab == rotr_optab
&& optab_handler (rotl_optab, mode)->insn_code != CODE_FOR_nothing))
&& optab_handler (rotl_optab, mode) != CODE_FOR_nothing))
&& mclass == MODE_INT)
{
optab otheroptab = (binoptab == rotl_optab ? rotr_optab : rotl_optab);
@ -1633,8 +1632,8 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1,
if (binoptab == smul_optab
&& GET_MODE_WIDER_MODE (mode) != VOIDmode
&& ((optab_handler ((unsignedp ? umul_widen_optab : smul_widen_optab),
GET_MODE_WIDER_MODE (mode))->insn_code)
&& (optab_handler ((unsignedp ? umul_widen_optab : smul_widen_optab),
GET_MODE_WIDER_MODE (mode))
!= CODE_FOR_nothing))
{
temp = expand_binop (GET_MODE_WIDER_MODE (mode),
@ -1662,12 +1661,12 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1,
wider_mode != VOIDmode;
wider_mode = GET_MODE_WIDER_MODE (wider_mode))
{
if (optab_handler (binoptab, wider_mode)->insn_code != CODE_FOR_nothing
if (optab_handler (binoptab, wider_mode) != CODE_FOR_nothing
|| (binoptab == smul_optab
&& GET_MODE_WIDER_MODE (wider_mode) != VOIDmode
&& ((optab_handler ((unsignedp ? umul_widen_optab
: smul_widen_optab),
GET_MODE_WIDER_MODE (wider_mode))->insn_code)
&& (optab_handler ((unsignedp ? umul_widen_optab
: smul_widen_optab),
GET_MODE_WIDER_MODE (wider_mode))
!= CODE_FOR_nothing)))
{
rtx xop0 = op0, xop1 = op1;
@ -1734,7 +1733,7 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1,
if ((binoptab == and_optab || binoptab == ior_optab || binoptab == xor_optab)
&& mclass == MODE_INT
&& GET_MODE_SIZE (mode) > UNITS_PER_WORD
&& optab_handler (binoptab, word_mode)->insn_code != CODE_FOR_nothing)
&& optab_handler (binoptab, word_mode) != CODE_FOR_nothing)
{
int i;
rtx insns;
@ -1778,9 +1777,9 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1,
&& mclass == MODE_INT
&& (CONST_INT_P (op1) || optimize_insn_for_speed_p ())
&& GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
&& optab_handler (binoptab, word_mode)->insn_code != CODE_FOR_nothing
&& optab_handler (ashl_optab, word_mode)->insn_code != CODE_FOR_nothing
&& optab_handler (lshr_optab, word_mode)->insn_code != CODE_FOR_nothing)
&& optab_handler (binoptab, word_mode) != CODE_FOR_nothing
&& optab_handler (ashl_optab, word_mode) != CODE_FOR_nothing
&& optab_handler (lshr_optab, word_mode) != CODE_FOR_nothing)
{
unsigned HOST_WIDE_INT shift_mask, double_shift_mask;
enum machine_mode op1_mode;
@ -1848,8 +1847,8 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1,
&& mclass == MODE_INT
&& CONST_INT_P (op1)
&& GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
&& optab_handler (ashl_optab, word_mode)->insn_code != CODE_FOR_nothing
&& optab_handler (lshr_optab, word_mode)->insn_code != CODE_FOR_nothing)
&& optab_handler (ashl_optab, word_mode) != CODE_FOR_nothing
&& optab_handler (lshr_optab, word_mode) != CODE_FOR_nothing)
{
rtx insns;
rtx into_target, outof_target;
@ -1960,7 +1959,7 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1,
if ((binoptab == add_optab || binoptab == sub_optab)
&& mclass == MODE_INT
&& GET_MODE_SIZE (mode) >= 2 * UNITS_PER_WORD
&& optab_handler (binoptab, word_mode)->insn_code != CODE_FOR_nothing)
&& optab_handler (binoptab, word_mode) != CODE_FOR_nothing)
{
unsigned int i;
optab otheroptab = binoptab == add_optab ? sub_optab : add_optab;
@ -2057,7 +2056,7 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1,
if (i == GET_MODE_BITSIZE (mode) / (unsigned) BITS_PER_WORD)
{
if (optab_handler (mov_optab, mode)->insn_code != CODE_FOR_nothing
if (optab_handler (mov_optab, mode) != CODE_FOR_nothing
|| ! rtx_equal_p (target, xtarget))
{
rtx temp = emit_move_insn (target, xtarget);
@ -2086,13 +2085,12 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1,
if (binoptab == smul_optab
&& mclass == MODE_INT
&& GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
&& optab_handler (smul_optab, word_mode)->insn_code != CODE_FOR_nothing
&& optab_handler (add_optab, word_mode)->insn_code != CODE_FOR_nothing)
&& optab_handler (smul_optab, word_mode) != CODE_FOR_nothing
&& optab_handler (add_optab, word_mode) != CODE_FOR_nothing)
{
rtx product = NULL_RTX;
if (optab_handler (umul_widen_optab, mode)->insn_code
!= CODE_FOR_nothing)
if (optab_handler (umul_widen_optab, mode) != CODE_FOR_nothing)
{
product = expand_doubleword_mult (mode, op0, op1, target,
true, methods);
@ -2101,8 +2099,7 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1,
}
if (product == NULL_RTX
&& optab_handler (smul_widen_optab, mode)->insn_code
!= CODE_FOR_nothing)
&& optab_handler (smul_widen_optab, mode) != CODE_FOR_nothing)
{
product = expand_doubleword_mult (mode, op0, op1, target,
false, methods);
@ -2112,7 +2109,7 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1,
if (product != NULL_RTX)
{
if (optab_handler (mov_optab, mode)->insn_code != CODE_FOR_nothing)
if (optab_handler (mov_optab, mode) != CODE_FOR_nothing)
{
temp = emit_move_insn (target ? target : product, product);
set_unique_reg_note (temp,
@ -2193,8 +2190,7 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1,
wider_mode != VOIDmode;
wider_mode = GET_MODE_WIDER_MODE (wider_mode))
{
if ((optab_handler (binoptab, wider_mode)->insn_code
!= CODE_FOR_nothing)
if (optab_handler (binoptab, wider_mode) != CODE_FOR_nothing
|| (methods == OPTAB_LIB
&& optab_libfunc (binoptab, wider_mode)))
{
@ -2270,7 +2266,7 @@ sign_expand_binop (enum machine_mode mode, optab uoptab, optab soptab,
/* Try widening to a signed int. Make a fake signed optab that
hides any signed insn for direct use. */
wide_soptab = *soptab;
optab_handler (&wide_soptab, mode)->insn_code = CODE_FOR_nothing;
set_optab_handler (&wide_soptab, mode, CODE_FOR_nothing);
/* We don't want to generate new hash table entries from this fake
optab. */
wide_soptab.libcall_gen = NULL;
@ -2332,9 +2328,9 @@ expand_twoval_unop (optab unoptab, rtx op0, rtx targ0, rtx targ1,
/* Record where to go back to if we fail. */
last = get_last_insn ();
if (optab_handler (unoptab, mode)->insn_code != CODE_FOR_nothing)
if (optab_handler (unoptab, mode) != CODE_FOR_nothing)
{
int icode = (int) optab_handler (unoptab, mode)->insn_code;
int icode = (int) optab_handler (unoptab, mode);
enum machine_mode mode0 = insn_data[icode].operand[2].mode;
rtx pat;
rtx xop0 = op0;
@ -2370,8 +2366,7 @@ expand_twoval_unop (optab unoptab, rtx op0, rtx targ0, rtx targ1,
wider_mode != VOIDmode;
wider_mode = GET_MODE_WIDER_MODE (wider_mode))
{
if (optab_handler (unoptab, wider_mode)->insn_code
!= CODE_FOR_nothing)
if (optab_handler (unoptab, wider_mode) != CODE_FOR_nothing)
{
rtx t0 = gen_reg_rtx (wider_mode);
rtx t1 = gen_reg_rtx (wider_mode);
@ -2425,9 +2420,9 @@ expand_twoval_binop (optab binoptab, rtx op0, rtx op1, rtx targ0, rtx targ1,
/* Record where to go back to if we fail. */
last = get_last_insn ();
if (optab_handler (binoptab, mode)->insn_code != CODE_FOR_nothing)
if (optab_handler (binoptab, mode) != CODE_FOR_nothing)
{
int icode = (int) optab_handler (binoptab, mode)->insn_code;
int icode = (int) optab_handler (binoptab, mode);
enum machine_mode mode0 = insn_data[icode].operand[1].mode;
enum machine_mode mode1 = insn_data[icode].operand[2].mode;
rtx pat;
@ -2487,8 +2482,7 @@ expand_twoval_binop (optab binoptab, rtx op0, rtx op1, rtx targ0, rtx targ1,
wider_mode != VOIDmode;
wider_mode = GET_MODE_WIDER_MODE (wider_mode))
{
if (optab_handler (binoptab, wider_mode)->insn_code
!= CODE_FOR_nothing)
if (optab_handler (binoptab, wider_mode) != CODE_FOR_nothing)
{
rtx t0 = gen_reg_rtx (wider_mode);
rtx t1 = gen_reg_rtx (wider_mode);
@ -2589,8 +2583,7 @@ widen_clz (enum machine_mode mode, rtx op0, rtx target)
wider_mode != VOIDmode;
wider_mode = GET_MODE_WIDER_MODE (wider_mode))
{
if (optab_handler (clz_optab, wider_mode)->insn_code
!= CODE_FOR_nothing)
if (optab_handler (clz_optab, wider_mode) != CODE_FOR_nothing)
{
rtx xop0, temp, last;
@ -2702,7 +2695,7 @@ widen_bswap (enum machine_mode mode, rtx op0, rtx target)
for (wider_mode = GET_MODE_WIDER_MODE (mode);
wider_mode != VOIDmode;
wider_mode = GET_MODE_WIDER_MODE (wider_mode))
if (optab_handler (bswap_optab, wider_mode)->insn_code != CODE_FOR_nothing)
if (optab_handler (bswap_optab, wider_mode) != CODE_FOR_nothing)
goto found;
return NULL_RTX;
@ -2764,8 +2757,7 @@ expand_parity (enum machine_mode mode, rtx op0, rtx target)
for (wider_mode = mode; wider_mode != VOIDmode;
wider_mode = GET_MODE_WIDER_MODE (wider_mode))
{
if (optab_handler (popcount_optab, wider_mode)->insn_code
!= CODE_FOR_nothing)
if (optab_handler (popcount_optab, wider_mode) != CODE_FOR_nothing)
{
rtx xop0, temp, last;
@ -2806,7 +2798,7 @@ expand_ctz (enum machine_mode mode, rtx op0, rtx target)
{
rtx seq, temp;
if (optab_handler (clz_optab, mode)->insn_code == CODE_FOR_nothing)
if (optab_handler (clz_optab, mode) == CODE_FOR_nothing)
return 0;
start_sequence ();
@ -2849,7 +2841,7 @@ expand_ffs (enum machine_mode mode, rtx op0, rtx target)
bool defined_at_zero = false;
rtx temp, seq;
if (optab_handler (ctz_optab, mode)->insn_code != CODE_FOR_nothing)
if (optab_handler (ctz_optab, mode) != CODE_FOR_nothing)
{
start_sequence ();
@ -2859,7 +2851,7 @@ expand_ffs (enum machine_mode mode, rtx op0, rtx target)
defined_at_zero = (CTZ_DEFINED_VALUE_AT_ZERO (mode, val) == 2);
}
else if (optab_handler (clz_optab, mode)->insn_code != CODE_FOR_nothing)
else if (optab_handler (clz_optab, mode) != CODE_FOR_nothing)
{
start_sequence ();
temp = expand_ctz (mode, op0, 0);
@ -3037,9 +3029,9 @@ static rtx
expand_unop_direct (enum machine_mode mode, optab unoptab, rtx op0, rtx target,
int unsignedp)
{
if (optab_handler (unoptab, mode)->insn_code != CODE_FOR_nothing)
if (optab_handler (unoptab, mode) != CODE_FOR_nothing)
{
int icode = (int) optab_handler (unoptab, mode)->insn_code;
int icode = (int) optab_handler (unoptab, mode);
enum machine_mode mode0 = insn_data[icode].operand[1].mode;
rtx xop0 = op0;
rtx last = get_last_insn ();
@ -3116,7 +3108,7 @@ expand_unop (enum machine_mode mode, optab unoptab, rtx op0, rtx target,
return temp;
if (GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
&& optab_handler (unoptab, word_mode)->insn_code != CODE_FOR_nothing)
&& optab_handler (unoptab, word_mode) != CODE_FOR_nothing)
{
temp = expand_doubleword_clz (mode, op0, target);
if (temp)
@ -3134,7 +3126,7 @@ expand_unop (enum machine_mode mode, optab unoptab, rtx op0, rtx target,
return temp;
if (GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
&& optab_handler (unoptab, word_mode)->insn_code != CODE_FOR_nothing)
&& optab_handler (unoptab, word_mode) != CODE_FOR_nothing)
{
temp = expand_doubleword_bswap (mode, op0, target);
if (temp)
@ -3149,7 +3141,7 @@ expand_unop (enum machine_mode mode, optab unoptab, rtx op0, rtx target,
wider_mode != VOIDmode;
wider_mode = GET_MODE_WIDER_MODE (wider_mode))
{
if (optab_handler (unoptab, wider_mode)->insn_code != CODE_FOR_nothing)
if (optab_handler (unoptab, wider_mode) != CODE_FOR_nothing)
{
rtx xop0 = op0;
rtx last = get_last_insn ();
@ -3189,7 +3181,7 @@ expand_unop (enum machine_mode mode, optab unoptab, rtx op0, rtx target,
if (unoptab == one_cmpl_optab
&& mclass == MODE_INT
&& GET_MODE_SIZE (mode) > UNITS_PER_WORD
&& optab_handler (unoptab, word_mode)->insn_code != CODE_FOR_nothing)
&& optab_handler (unoptab, word_mode) != CODE_FOR_nothing)
{
int i;
rtx insns;
@ -3311,8 +3303,7 @@ expand_unop (enum machine_mode mode, optab unoptab, rtx op0, rtx target,
wider_mode != VOIDmode;
wider_mode = GET_MODE_WIDER_MODE (wider_mode))
{
if ((optab_handler (unoptab, wider_mode)->insn_code
!= CODE_FOR_nothing)
if (optab_handler (unoptab, wider_mode) != CODE_FOR_nothing
|| optab_libfunc (unoptab, wider_mode))
{
rtx xop0 = op0;
@ -3405,7 +3396,7 @@ expand_abs_nojump (enum machine_mode mode, rtx op0, rtx target,
}
/* If we have a MAX insn, we can do this as MAX (x, -x). */
if (optab_handler (smax_optab, mode)->insn_code != CODE_FOR_nothing
if (optab_handler (smax_optab, mode) != CODE_FOR_nothing
&& !HONOR_SIGNED_ZEROS (mode))
{
rtx last = get_last_insn ();
@ -3508,7 +3499,7 @@ expand_one_cmpl_abs_nojump (enum machine_mode mode, rtx op0, rtx target)
return NULL_RTX;
/* If we have a MAX insn, we can do this as MAX (x, ~x). */
if (optab_handler (smax_optab, mode)->insn_code != CODE_FOR_nothing)
if (optab_handler (smax_optab, mode) != CODE_FOR_nothing)
{
rtx last = get_last_insn ();
@ -3562,7 +3553,7 @@ expand_copysign_absneg (enum machine_mode mode, rtx op0, rtx op1, rtx target,
/* Check if the back end provides an insn that handles signbit for the
argument's mode. */
icode = (int) signbit_optab->handlers [(int) mode].insn_code;
icode = (int) optab_handler (signbit_optab, mode);
if (icode != CODE_FOR_nothing)
{
imode = insn_data[icode].operand[0].mode;
@ -3762,8 +3753,8 @@ expand_copysign (rtx op0, rtx op1, rtx target)
if (fmt->signbit_ro >= 0
&& (GET_CODE (op0) == CONST_DOUBLE
|| (optab_handler (neg_optab, mode)->insn_code != CODE_FOR_nothing
&& optab_handler (abs_optab, mode)->insn_code != CODE_FOR_nothing)))
|| (optab_handler (neg_optab, mode) != CODE_FOR_nothing
&& optab_handler (abs_optab, mode) != CODE_FOR_nothing)))
{
temp = expand_copysign_absneg (mode, op0, op1, target,
fmt->signbit_ro, op0_is_abs);
@ -3975,8 +3966,7 @@ emit_libcall_block (rtx insns, rtx target, rtx result, rtx equiv)
}
last = emit_move_insn (target, result);
if (optab_handler (mov_optab, GET_MODE (target))->insn_code
!= CODE_FOR_nothing)
if (optab_handler (mov_optab, GET_MODE (target)) != CODE_FOR_nothing)
set_unique_reg_note (last, REG_EQUAL, copy_rtx (equiv));
if (final_dest != target)
@ -4002,15 +3992,15 @@ can_compare_p (enum rtx_code code, enum machine_mode mode,
int icode;
if (purpose == ccp_jump
&& (icode = optab_handler (cbranch_optab, mode)->insn_code) != CODE_FOR_nothing
&& (icode = optab_handler (cbranch_optab, mode)) != CODE_FOR_nothing
&& insn_data[icode].operand[0].predicate (test, mode))
return 1;
if (purpose == ccp_store_flag
&& (icode = optab_handler (cstore_optab, mode)->insn_code) != CODE_FOR_nothing
&& (icode = optab_handler (cstore_optab, mode)) != CODE_FOR_nothing
&& insn_data[icode].operand[1].predicate (test, mode))
return 1;
if (purpose == ccp_cmov
&& optab_handler (cmov_optab, mode)->insn_code != CODE_FOR_nothing)
&& optab_handler (cmov_optab, mode) != CODE_FOR_nothing)
return 1;
mode = GET_MODE_WIDER_MODE (mode);
@ -4166,7 +4156,7 @@ prepare_cmp_insn (rtx x, rtx y, enum rtx_code comparison, rtx size,
do
{
enum insn_code icode;
icode = optab_handler (cbranch_optab, cmp_mode)->insn_code;
icode = optab_handler (cbranch_optab, cmp_mode);
if (icode != CODE_FOR_nothing
&& insn_data[icode].operand[0].predicate (test, VOIDmode))
{
@ -4285,7 +4275,7 @@ emit_cmp_and_jump_insn_1 (rtx test, enum machine_mode mode, rtx label)
mclass = GET_MODE_CLASS (mode);
optab_mode = (mclass == MODE_CC) ? CCmode : mode;
icode = optab_handler (cbranch_optab, optab_mode)->insn_code;
icode = optab_handler (cbranch_optab, optab_mode);
gcc_assert (icode != CODE_FOR_nothing);
gcc_assert (insn_data[icode].operand[0].predicate (test, VOIDmode));
@ -4684,7 +4674,7 @@ emit_conditional_add (rtx target, enum rtx_code code, rtx op0, rtx op1,
if (mode == VOIDmode)
mode = GET_MODE (op2);
icode = optab_handler (addcc_optab, mode)->insn_code;
icode = optab_handler (addcc_optab, mode);
if (icode == CODE_FOR_nothing)
return 0;
@ -4755,7 +4745,7 @@ emit_conditional_add (rtx target, enum rtx_code code, rtx op0, rtx op1,
rtx
gen_add2_insn (rtx x, rtx y)
{
int icode = (int) optab_handler (add_optab, GET_MODE (x))->insn_code;
int icode = (int) optab_handler (add_optab, GET_MODE (x));
gcc_assert (insn_data[icode].operand[0].predicate
(x, insn_data[icode].operand[0].mode));
@ -4773,7 +4763,7 @@ gen_add2_insn (rtx x, rtx y)
rtx
gen_add3_insn (rtx r0, rtx r1, rtx c)
{
int icode = (int) optab_handler (add_optab, GET_MODE (r0))->insn_code;
int icode = (int) optab_handler (add_optab, GET_MODE (r0));
if (icode == CODE_FOR_nothing
|| !(insn_data[icode].operand[0].predicate
@ -4794,7 +4784,7 @@ have_add2_insn (rtx x, rtx y)
gcc_assert (GET_MODE (x) != VOIDmode);
icode = (int) optab_handler (add_optab, GET_MODE (x))->insn_code;
icode = (int) optab_handler (add_optab, GET_MODE (x));
if (icode == CODE_FOR_nothing)
return 0;
@ -4815,7 +4805,7 @@ have_add2_insn (rtx x, rtx y)
rtx
gen_sub2_insn (rtx x, rtx y)
{
int icode = (int) optab_handler (sub_optab, GET_MODE (x))->insn_code;
int icode = (int) optab_handler (sub_optab, GET_MODE (x));
gcc_assert (insn_data[icode].operand[0].predicate
(x, insn_data[icode].operand[0].mode));
@ -4833,7 +4823,7 @@ gen_sub2_insn (rtx x, rtx y)
rtx
gen_sub3_insn (rtx r0, rtx r1, rtx c)
{
int icode = (int) optab_handler (sub_optab, GET_MODE (r0))->insn_code;
int icode = (int) optab_handler (sub_optab, GET_MODE (r0));
if (icode == CODE_FOR_nothing
|| !(insn_data[icode].operand[0].predicate
@ -4854,7 +4844,7 @@ have_sub2_insn (rtx x, rtx y)
gcc_assert (GET_MODE (x) != VOIDmode);
icode = (int) optab_handler (sub_optab, GET_MODE (x))->insn_code;
icode = (int) optab_handler (sub_optab, GET_MODE (x));
if (icode == CODE_FOR_nothing)
return 0;
@ -4900,7 +4890,7 @@ can_extend_p (enum machine_mode to_mode, enum machine_mode from_mode,
#endif
tab = unsignedp ? zext_optab : sext_optab;
return convert_optab_handler (tab, to_mode, from_mode)->insn_code;
return convert_optab_handler (tab, to_mode, from_mode);
}
/* Generate the body of an insn to extend Y (with mode MFROM)
@ -4931,7 +4921,7 @@ can_fix_p (enum machine_mode fixmode, enum machine_mode fltmode,
enum insn_code icode;
tab = unsignedp ? ufixtrunc_optab : sfixtrunc_optab;
icode = convert_optab_handler (tab, fixmode, fltmode)->insn_code;
icode = convert_optab_handler (tab, fixmode, fltmode);
if (icode != CODE_FOR_nothing)
{
*truncp_ptr = 0;
@ -4942,9 +4932,9 @@ can_fix_p (enum machine_mode fixmode, enum machine_mode fltmode,
for this to work. We need to rework the fix* and ftrunc* patterns
and documentation. */
tab = unsignedp ? ufix_optab : sfix_optab;
icode = convert_optab_handler (tab, fixmode, fltmode)->insn_code;
icode = convert_optab_handler (tab, fixmode, fltmode);
if (icode != CODE_FOR_nothing
&& optab_handler (ftrunc_optab, fltmode)->insn_code != CODE_FOR_nothing)
&& optab_handler (ftrunc_optab, fltmode) != CODE_FOR_nothing)
{
*truncp_ptr = 1;
return icode;
@ -4961,7 +4951,7 @@ can_float_p (enum machine_mode fltmode, enum machine_mode fixmode,
convert_optab tab;
tab = unsignedp ? ufloat_optab : sfloat_optab;
return convert_optab_handler (tab, fltmode, fixmode)->insn_code;
return convert_optab_handler (tab, fltmode, fixmode);
}
/* Generate code to convert FROM to floating point
@ -5295,8 +5285,7 @@ expand_fix (rtx to, rtx from, int unsignedp)
emit_label (lab2);
if (optab_handler (mov_optab, GET_MODE (to))->insn_code
!= CODE_FOR_nothing)
if (optab_handler (mov_optab, GET_MODE (to)) != CODE_FOR_nothing)
{
/* Make a place for a REG_NOTE and add it. */
insn = emit_move_insn (to, to);
@ -5383,7 +5372,7 @@ expand_fixed_convert (rtx to, rtx from, int uintp, int satp)
tab = satp ? satfract_optab : fract_optab;
this_code = satp ? SAT_FRACT : FRACT_CONVERT;
}
code = tab->handlers[to_mode][from_mode].insn_code;
code = convert_optab_handler (tab, to_mode, from_mode);
if (code != CODE_FOR_nothing)
{
emit_unop_insn (code, to, from, this_code);
@ -5424,7 +5413,7 @@ expand_sfix_optab (rtx to, rtx from, convert_optab tab)
for (imode = GET_MODE (to); imode != VOIDmode;
imode = GET_MODE_WIDER_MODE (imode))
{
icode = convert_optab_handler (tab, imode, fmode)->insn_code;
icode = convert_optab_handler (tab, imode, fmode);
if (icode != CODE_FOR_nothing)
{
rtx last = get_last_insn ();
@ -5454,7 +5443,7 @@ int
have_insn_for (enum rtx_code code, enum machine_mode mode)
{
return (code_to_optab[(int) code] != 0
&& (optab_handler (code_to_optab[(int) code], mode)->insn_code
&& (optab_handler (code_to_optab[(int) code], mode)
!= CODE_FOR_nothing));
}
@ -5472,7 +5461,7 @@ init_insn_codes (void)
op = &optab_table[i];
for (j = 0; j < NUM_MACHINE_MODES; j++)
optab_handler (op, j)->insn_code = CODE_FOR_nothing;
set_optab_handler (op, (enum machine_mode) j, CODE_FOR_nothing);
}
for (i = 0; i < (unsigned int) COI_MAX; i++)
{
@ -5482,7 +5471,8 @@ init_insn_codes (void)
op = &convert_optab_table[i];
for (j = 0; j < NUM_MACHINE_MODES; j++)
for (k = 0; k < NUM_MACHINE_MODES; k++)
convert_optab_handler (op, j, k)->insn_code = CODE_FOR_nothing;
set_convert_optab_handler (op, (enum machine_mode) j,
(enum machine_mode) k, CODE_FOR_nothing);
}
}
@ -6211,7 +6201,8 @@ init_optabs (void)
}
#if GCC_VERSION >= 4000 && HAVE_DESIGNATED_INITIALIZERS
/* We statically initialize the insn_codes with CODE_FOR_nothing. */
/* We statically initialize the insn_codes with the equivalent of
CODE_FOR_nothing. */
if (reinit)
init_insn_codes ();
#else
@ -6763,7 +6754,7 @@ gen_cond_trap (enum rtx_code code, rtx op1, rtx op2, rtx tcode)
if (mode == VOIDmode)
return 0;
icode = optab_handler (ctrap_optab, mode)->insn_code;
icode = optab_handler (ctrap_optab, mode);
if (icode == CODE_FOR_nothing)
return 0;

40
gcc/optabs.h
View File

@ -782,9 +782,43 @@ extern rtx expand_vec_cond_expr (tree, tree, tree, tree, rtx);
/* Generate code for VEC_LSHIFT_EXPR and VEC_RSHIFT_EXPR. */
extern rtx expand_vec_shift_expr (sepops, rtx);
#define optab_handler(optab,mode) (&(optab)->handlers[(int) (mode)])
#define convert_optab_handler(optab,mode,mode2) \
(&(optab)->handlers[(int) (mode)][(int) (mode2)])
/* Return the insn used to implement mode MODE of OP, or CODE_FOR_nothing
if the target does not have such an insn. */
static inline enum insn_code
optab_handler (optab op, enum machine_mode mode)
{
return op->handlers[(int) mode].insn_code;
}
/* Record that insn CODE should be used to implement mode MODE of OP. */
static inline void
set_optab_handler (optab op, enum machine_mode mode, enum insn_code code)
{
op->handlers[(int) mode].insn_code = code;
}
/* Return the insn used to perform conversion OP from mode FROM_MODE
to mode TO_MODE; return CODE_FOR_nothing if the target does not have
such an insn. */
static inline enum insn_code
convert_optab_handler (convert_optab op, enum machine_mode to_mode,
enum machine_mode from_mode)
{
return op->handlers[(int) to_mode][(int) from_mode].insn_code;
}
/* Record that insn CODE should be used to perform conversion OP
from mode FROM_MODE to mode TO_MODE. */
static inline void
set_convert_optab_handler (convert_optab op, enum machine_mode to_mode,
enum machine_mode from_mode, enum insn_code code)
{
op->handlers[(int) to_mode][(int) from_mode].insn_code = code;
}
extern rtx optab_libfunc (optab optab, enum machine_mode mode);
extern rtx convert_optab_libfunc (convert_optab optab, enum machine_mode mode1,

3
gcc/reload.c
View File

@ -5834,8 +5834,7 @@ find_reloads_address_1 (enum machine_mode mode, rtx x, int context,
rtx equiv = (MEM_P (XEXP (x, 0))
? XEXP (x, 0)
: reg_equiv_mem[regno]);
int icode
= (int) optab_handler (add_optab, GET_MODE (x))->insn_code;
int icode = (int) optab_handler (add_optab, GET_MODE (x));
if (insn && NONJUMP_INSN_P (insn) && equiv
&& memory_operand (equiv, GET_MODE (equiv))
#ifdef HAVE_cc0

2
gcc/reload1.c
View File

@ -8680,7 +8680,7 @@ gen_reload (rtx out, rtx in, int opnum, enum reload_type type)
DEFINE_PEEPHOLE should be specified that recognizes the sequence
we emit below. */
code = (int) optab_handler (add_optab, GET_MODE (out))->insn_code;
code = (int) optab_handler (add_optab, GET_MODE (out));
if (CONSTANT_P (op1) || MEM_P (op1) || GET_CODE (op1) == SUBREG
|| (REG_P (op1)

2
gcc/stmt.c
View File

@ -2071,7 +2071,7 @@ add_case_node (struct case_node *head, tree type, tree low, tree high,
/* By default, enable case bit tests on targets with ashlsi3. */
#ifndef CASE_USE_BIT_TESTS
#define CASE_USE_BIT_TESTS (optab_handler (ashl_optab, word_mode)->insn_code \
#define CASE_USE_BIT_TESTS (optab_handler (ashl_optab, word_mode) \
!= CODE_FOR_nothing)
#endif

2
gcc/targhooks.c
View File

@ -974,7 +974,7 @@ default_builtin_support_vector_misalignment (enum machine_mode mode,
bool is_packed
ATTRIBUTE_UNUSED)
{
if (optab_handler (movmisalign_optab, mode)->insn_code != CODE_FOR_nothing)
if (optab_handler (movmisalign_optab, mode) != CODE_FOR_nothing)
return true;
return false;
}

2
gcc/tree-ssa-loop-prefetch.c
View File

@ -1136,7 +1136,7 @@ nontemporal_store_p (struct mem_ref *ref)
if (mode == BLKmode)
return false;
code = optab_handler (storent_optab, mode)->insn_code;
code = optab_handler (storent_optab, mode);
return code != CODE_FOR_nothing;
}

15
gcc/tree-ssa-math-opts.c
View File

@ -1113,11 +1113,9 @@ execute_optimize_bswap (void)
return 0;
bswap32_p = (built_in_decls[BUILT_IN_BSWAP32]
&& optab_handler (bswap_optab, SImode)->insn_code !=
CODE_FOR_nothing);
&& optab_handler (bswap_optab, SImode) != CODE_FOR_nothing);
bswap64_p = (built_in_decls[BUILT_IN_BSWAP64]
&& (optab_handler (bswap_optab, DImode)->insn_code !=
CODE_FOR_nothing
&& (optab_handler (bswap_optab, DImode) != CODE_FOR_nothing
|| (bswap32_p && word_mode == SImode)));
if (!bswap32_p && !bswap64_p)
@ -1324,17 +1322,17 @@ convert_mult_to_widen (gimple stmt)
if ((rhs1_stmt == NULL || TYPE_UNSIGNED (type1))
&& (rhs2_stmt == NULL || TYPE_UNSIGNED (type2))
&& (optab_handler (umul_widen_optab, TYPE_MODE (type))
->insn_code == CODE_FOR_nothing))
== CODE_FOR_nothing))
return false;
else if ((rhs1_stmt == NULL || !TYPE_UNSIGNED (type1))
&& (rhs2_stmt == NULL || !TYPE_UNSIGNED (type2))
&& (optab_handler (smul_widen_optab, TYPE_MODE (type))
->insn_code == CODE_FOR_nothing))
== CODE_FOR_nothing))
return false;
else if (rhs1_stmt != NULL && rhs2_stmt != NULL
&& (TYPE_UNSIGNED (type1) != TYPE_UNSIGNED (type2))
&& (optab_handler (usmul_widen_optab, TYPE_MODE (type))
->insn_code == CODE_FOR_nothing))
== CODE_FOR_nothing))
return false;
if ((rhs1_stmt == NULL && !int_fits_type_p (rhs1, type2))
@ -1385,8 +1383,7 @@ convert_plusminus_to_widen (gimple_stmt_iterator *gsi, gimple stmt,
accumulate in this mode/signedness combination, otherwise
this transformation is likely to pessimize code. */
this_optab = optab_for_tree_code (wmult_code, type, optab_default);
if (optab_handler (this_optab, TYPE_MODE (type))->insn_code
== CODE_FOR_nothing)
if (optab_handler (this_optab, TYPE_MODE (type)) == CODE_FOR_nothing)
return false;
rhs1 = gimple_assign_rhs1 (stmt);

21
gcc/tree-vect-data-refs.c
View File

@ -3243,9 +3243,9 @@ bool
vect_strided_store_supported (tree vectype)
{
optab interleave_high_optab, interleave_low_optab;
int mode;
enum machine_mode mode;
mode = (int) TYPE_MODE (vectype);
mode = TYPE_MODE (vectype);
/* Check that the operation is supported. */
interleave_high_optab = optab_for_tree_code (VEC_INTERLEAVE_HIGH_EXPR,
@ -3259,10 +3259,8 @@ vect_strided_store_supported (tree vectype)
return false;
}
if (optab_handler (interleave_high_optab, mode)->insn_code
== CODE_FOR_nothing
|| optab_handler (interleave_low_optab, mode)->insn_code
== CODE_FOR_nothing)
if (optab_handler (interleave_high_optab, mode) == CODE_FOR_nothing
|| optab_handler (interleave_low_optab, mode) == CODE_FOR_nothing)
{
if (vect_print_dump_info (REPORT_DETAILS))
fprintf (vect_dump, "interleave op not supported by target.");
@ -3655,9 +3653,9 @@ bool
vect_strided_load_supported (tree vectype)
{
optab perm_even_optab, perm_odd_optab;
int mode;
enum machine_mode mode;
mode = (int) TYPE_MODE (vectype);
mode = TYPE_MODE (vectype);
perm_even_optab = optab_for_tree_code (VEC_EXTRACT_EVEN_EXPR, vectype,
optab_default);
@ -3668,7 +3666,7 @@ vect_strided_load_supported (tree vectype)
return false;
}
if (optab_handler (perm_even_optab, mode)->insn_code == CODE_FOR_nothing)
if (optab_handler (perm_even_optab, mode) == CODE_FOR_nothing)
{
if (vect_print_dump_info (REPORT_DETAILS))
fprintf (vect_dump, "perm_even op not supported by target.");
@ -3684,7 +3682,7 @@ vect_strided_load_supported (tree vectype)
return false;
}
if (optab_handler (perm_odd_optab, mode)->insn_code == CODE_FOR_nothing)
if (optab_handler (perm_odd_optab, mode) == CODE_FOR_nothing)
{
if (vect_print_dump_info (REPORT_DETAILS))
fprintf (vect_dump, "perm_odd op not supported by target.");
@ -4044,8 +4042,7 @@ vect_supportable_dr_alignment (struct data_reference *dr,
bool is_packed = false;
tree type = (TREE_TYPE (DR_REF (dr)));
if (optab_handler (vec_realign_load_optab, mode)->insn_code !=
CODE_FOR_nothing
if (optab_handler (vec_realign_load_optab, mode) != CODE_FOR_nothing
&& (!targetm.vectorize.builtin_mask_for_load
|| targetm.vectorize.builtin_mask_for_load ()))
{

7
gcc/tree-vect-generic.c
View File

@ -368,7 +368,7 @@ type_for_widest_vector_mode (enum machine_mode inner_mode, optab op, int satp)
for (; mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode))
if (GET_MODE_INNER (mode) == inner_mode
&& GET_MODE_NUNITS (mode) > best_nunits
&& optab_handler (op, mode)->insn_code != CODE_FOR_nothing)
&& optab_handler (op, mode) != CODE_FOR_nothing)
best_mode = mode, best_nunits = GET_MODE_NUNITS (mode);
if (best_mode == VOIDmode)
@ -443,8 +443,7 @@ expand_vector_operations_1 (gimple_stmt_iterator *gsi)
have a vector/vector shift */
op = optab_for_tree_code (code, type, optab_scalar);
if (!op
|| (op->handlers[(int) TYPE_MODE (type)].insn_code
== CODE_FOR_nothing))
|| optab_handler (op, TYPE_MODE (type)) == CODE_FOR_nothing)
op = optab_for_tree_code (code, type, optab_vector);
}
}
@ -498,7 +497,7 @@ expand_vector_operations_1 (gimple_stmt_iterator *gsi)
|| GET_MODE_CLASS (compute_mode) == MODE_VECTOR_ACCUM
|| GET_MODE_CLASS (compute_mode) == MODE_VECTOR_UACCUM)
&& op != NULL
&& optab_handler (op, compute_mode)->insn_code != CODE_FOR_nothing)
&& optab_handler (op, compute_mode) != CODE_FOR_nothing)
return;
else
/* There is no operation in hardware, so fall back to scalars. */

20
gcc/tree-vect-loop.c
View File

@ -132,7 +132,7 @@ along with GCC; see the file COPYING3. If not see
Since we only vectorize operations which vector form can be
expressed using existing tree codes, to verify that an operation is
supported, the vectorizer checks the relevant optab at the relevant
machine_mode (e.g, optab_handler (add_optab, V8HImode)->insn_code). If
machine_mode (e.g, optab_handler (add_optab, V8HImode)). If
the value found is CODE_FOR_nothing, then there's no target support, and
we can't vectorize the stmt.
@ -2490,8 +2490,8 @@ vect_model_reduction_cost (stmt_vec_info stmt_info, enum tree_code reduc_code,
/* We have a whole vector shift available. */
if (VECTOR_MODE_P (mode)
&& optab_handler (optab, mode)->insn_code != CODE_FOR_nothing
&& optab_handler (vec_shr_optab, mode)->insn_code != CODE_FOR_nothing)
&& optab_handler (optab, mode) != CODE_FOR_nothing
&& optab_handler (vec_shr_optab, mode) != CODE_FOR_nothing)
/* Final reduction via vector shifts and the reduction operator. Also
requires scalar extract. */
outer_cost += ((exact_log2(nelements) * 2)
@ -3333,7 +3333,7 @@ vect_create_epilog_for_reduction (VEC (tree, heap) *vect_defs, gimple stmt,
int vec_size_in_bits = tree_low_cst (TYPE_SIZE (vectype), 1);
tree vec_temp;
if (optab_handler (vec_shr_optab, mode)->insn_code != CODE_FOR_nothing)
if (optab_handler (vec_shr_optab, mode) != CODE_FOR_nothing)
shift_code = VEC_RSHIFT_EXPR;
else
have_whole_vector_shift = false;
@ -3349,7 +3349,7 @@ vect_create_epilog_for_reduction (VEC (tree, heap) *vect_defs, gimple stmt,
else
{
optab optab = optab_for_tree_code (code, vectype, optab_default);
if (optab_handler (optab, mode)->insn_code == CODE_FOR_nothing)
if (optab_handler (optab, mode) == CODE_FOR_nothing)
have_whole_vector_shift = false;
}
@ -4008,7 +4008,7 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi,
return false;
}
if (optab_handler (optab, vec_mode)->insn_code == CODE_FOR_nothing)
if (optab_handler (optab, vec_mode) == CODE_FOR_nothing)
{
if (vect_print_dump_info (REPORT_DETAILS))
fprintf (vect_dump, "op not supported by target.");
@ -4056,11 +4056,12 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi,
2. The type (mode) we use to check available target support
for the vector operation to be created in the *epilog*, is
determined by the type of the reduction variable (in the example
above we'd check this: plus_optab[vect_int_mode]).
above we'd check this: optab_handler (plus_optab, vect_int_mode])).
However the type (mode) we use to check available target support
for the vector operation to be created *inside the loop*, is
determined by the type of the other arguments to STMT (in the
example we'd check this: widen_sum_optab[vect_short_mode]).
example we'd check this: optab_handler (widen_sum_optab,
vect_short_mode)).
This is contrary to "regular" reductions, in which the types of all
the arguments are the same as the type of the reduction variable.
@ -4113,8 +4114,7 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi,
}
if (reduc_optab
&& optab_handler (reduc_optab, vec_mode)->insn_code
== CODE_FOR_nothing)
&& optab_handler (reduc_optab, vec_mode) == CODE_FOR_nothing)
{
if (vect_print_dump_info (REPORT_DETAILS))
fprintf (vect_dump, "reduc op not supported by target.");

3
gcc/tree-vect-patterns.c
View File

@ -714,8 +714,7 @@ vect_pattern_recog_1 (
optab = optab_for_tree_code (code, type_in, optab_default);
vec_mode = TYPE_MODE (type_in);
if (!optab
|| (icode = optab_handler (optab, vec_mode)->insn_code) ==
CODE_FOR_nothing
|| (icode = optab_handler (optab, vec_mode)) == CODE_FOR_nothing
|| (insn_data[icode].operand[0].mode != TYPE_MODE (type_out)))
return;
}

5
gcc/tree-vect-slp.c
View File

@ -421,8 +421,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
optab_vector);
if (!optab
|| (optab->handlers[(int) vec_mode].insn_code
== CODE_FOR_nothing))
|| optab_handler (optab, vec_mode) == CODE_FOR_nothing)
{
/* No vector/vector shift, try for a vector/scalar shift. */
optab = optab_for_tree_code (rhs_code, vectype,
@ -434,7 +433,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
fprintf (vect_dump, "Build SLP failed: no optab.");
return false;
}
icode = (int) optab->handlers[(int) vec_mode].insn_code;
icode = (int) optab_handler (optab, vec_mode);
if (icode == CODE_FOR_nothing)
{
if (vect_print_dump_info (REPORT_SLP))

48
gcc/tree-vect-stmts.c
View File

@ -2181,8 +2181,7 @@ vectorizable_operation (gimple stmt, gimple_stmt_iterator *gsi,
{
optab = optab_for_tree_code (code, vectype, optab_scalar);
if (optab
&& (optab_handler (optab, TYPE_MODE (vectype))->insn_code
!= CODE_FOR_nothing))
&& optab_handler (optab, TYPE_MODE (vectype)) != CODE_FOR_nothing)
{
scalar_shift_arg = true;
if (vect_print_dump_info (REPORT_DETAILS))
@ -2192,7 +2191,7 @@ vectorizable_operation (gimple stmt, gimple_stmt_iterator *gsi,
{
optab = optab_for_tree_code (code, vectype, optab_vector);
if (optab
&& (optab_handler (optab, TYPE_MODE (vectype))->insn_code
&& (optab_handler (optab, TYPE_MODE (vectype))
!= CODE_FOR_nothing))
{
if (vect_print_dump_info (REPORT_DETAILS))
@ -2226,7 +2225,7 @@ vectorizable_operation (gimple stmt, gimple_stmt_iterator *gsi,
return false;
}
vec_mode = TYPE_MODE (vectype);
icode = (int) optab_handler (optab, vec_mode)->insn_code;
icode = (int) optab_handler (optab, vec_mode);
if (icode == CODE_FOR_nothing)
{
if (vect_print_dump_info (REPORT_DETAILS))
@ -3128,7 +3127,7 @@ vectorizable_store (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
vec_mode = TYPE_MODE (vectype);
/* FORNOW. In some cases can vectorize even if data-type not supported
(e.g. - array initialization with 0). */
if (optab_handler (mov_optab, (int)vec_mode)->insn_code == CODE_FOR_nothing)
if (optab_handler (mov_optab, vec_mode) == CODE_FOR_nothing)
return false;
if (!STMT_VINFO_DATA_REF (stmt_info))
@ -3426,7 +3425,7 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
struct data_reference *dr = STMT_VINFO_DATA_REF (stmt_info), *first_dr;
tree vectype = STMT_VINFO_VECTYPE (stmt_info);
tree new_temp;
int mode;
enum machine_mode mode;
gimple new_stmt = NULL;
tree dummy;
enum dr_alignment_support alignment_support_scheme;
@ -3507,11 +3506,11 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
return false;
scalar_type = TREE_TYPE (DR_REF (dr));
mode = (int) TYPE_MODE (vectype);
mode = TYPE_MODE (vectype);
/* FORNOW. In some cases can vectorize even if data-type not supported
(e.g. - data copies). */
if (optab_handler (mov_optab, mode)->insn_code == CODE_FOR_nothing)
if (optab_handler (mov_optab, mode) == CODE_FOR_nothing)
{
if (vect_print_dump_info (REPORT_DETAILS))
fprintf (vect_dump, "Aligned load, but unsupported type.");
@ -4963,9 +4962,8 @@ supportable_widening_operation (enum tree_code code, gimple stmt,
return false;
vec_mode = TYPE_MODE (vectype);
if ((icode1 = optab_handler (optab1, vec_mode)->insn_code) == CODE_FOR_nothing
|| (icode2 = optab_handler (optab2, vec_mode)->insn_code)
== CODE_FOR_nothing)
if ((icode1 = optab_handler (optab1, vec_mode)) == CODE_FOR_nothing
|| (icode2 = optab_handler (optab2, vec_mode)) == CODE_FOR_nothing)
return false;
/* Check if it's a multi-step conversion that can be done using intermediate
@ -4997,16 +4995,16 @@ supportable_widening_operation (enum tree_code code, gimple stmt,
optab4 = optab_for_tree_code (c2, intermediate_type, optab_default);
if (!optab3 || !optab4
|| (icode1 = optab1->handlers[(int) prev_mode].insn_code)
== CODE_FOR_nothing
|| ((icode1 = optab_handler (optab1, prev_mode))
== CODE_FOR_nothing)
|| insn_data[icode1].operand[0].mode != intermediate_mode
|| (icode2 = optab2->handlers[(int) prev_mode].insn_code)
== CODE_FOR_nothing
|| ((icode2 = optab_handler (optab2, prev_mode))
== CODE_FOR_nothing)
|| insn_data[icode2].operand[0].mode != intermediate_mode
|| (icode1 = optab3->handlers[(int) intermediate_mode].insn_code)
== CODE_FOR_nothing
|| (icode2 = optab4->handlers[(int) intermediate_mode].insn_code)
== CODE_FOR_nothing)
|| ((icode1 = optab_handler (optab3, intermediate_mode))
== CODE_FOR_nothing)
|| ((icode2 = optab_handler (optab4, intermediate_mode))
== CODE_FOR_nothing))
return false;
VEC_quick_push (tree, *interm_types, intermediate_type);
@ -5093,8 +5091,7 @@ supportable_narrowing_operation (enum tree_code code,
return false;
vec_mode = TYPE_MODE (vectype);
if ((icode1 = optab_handler (optab1, vec_mode)->insn_code)
== CODE_FOR_nothing)
if ((icode1 = optab_handler (optab1, vec_mode)) == CODE_FOR_nothing)
return false;
/* Check if it's a multi-step conversion that can be done using intermediate
@ -5117,12 +5114,11 @@ supportable_narrowing_operation (enum tree_code code,
interm_optab = optab_for_tree_code (c1, intermediate_type,
optab_default);
if (!interm_optab
|| (icode1 = optab1->handlers[(int) prev_mode].insn_code)
== CODE_FOR_nothing
|| ((icode1 = optab_handler (optab1, prev_mode))
== CODE_FOR_nothing)
|| insn_data[icode1].operand[0].mode != intermediate_mode
|| (icode1
= interm_optab->handlers[(int) intermediate_mode].insn_code)
== CODE_FOR_nothing)
|| ((icode1 = optab_handler (interm_optab, intermediate_mode))
== CODE_FOR_nothing))
return false;
VEC_quick_push (tree, *interm_types, intermediate_type);