Skip to content

R
riscv-gcc-1
Commit 5d81dc5b by Richard Kenner
Options

(extendtab, fixtab, fixtrunctab, floattab): Not static. 

(init_extends, init_fixtab, init_floattab): Deleted.
(init_optabs): Move active stuff from above functions in.
Delete filling of optabs.
Call init_all_optabs.

From-SVN: r3925
parent 27b3f754
Showing with 97 additions and 2058 deletions
gcc/optabs.c
......@@ -82,6 +82,14 @@ optab tst_optab;
optab strlen_optab;
/* Tables of patterns for extending one integer mode to another. */
enum insn_code extendtab[MAX_MACHINE_MODE][MAX_MACHINE_MODE][2];
/* Tables of patterns for converting between fixed and floating point. */
enum insn_code fixtab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2];
enum insn_code fixtrunctab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2];
enum insn_code floattab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2];
/* SYMBOL_REF rtx's for the library functions that are called
implicitly and not via optabs. */
......@@ -196,7 +204,6 @@ enum insn_code setcc_gen_code[NUM_RTX_CODE];
static int add_equal_note PROTO((rtx, rtx, enum rtx_code, rtx, rtx));
static void emit_float_lib_cmp PROTO((rtx, rtx, enum rtx_code));
static void init_extends PROTO((void));
static enum insn_code can_fix_p PROTO((enum machine_mode, enum machine_mode,
int, int *));
static enum insn_code can_float_p PROTO((enum machine_mode, enum machine_mode,
......@@ -2683,9 +2690,6 @@ gen_move_insn (x, y)
return seq;
}
/* Tables of patterns for extending one integer mode to another. */
static enum insn_code extendtab[MAX_MACHINE_MODE][MAX_MACHINE_MODE][2];
/* Return the insn code used to extend FROM_MODE to TO_MODE.
UNSIGNEDP specifies zero-extension instead of sign-extension. If
no such operation exists, CODE_FOR_nothing will be returned. */
......@@ -2710,110 +2714,13 @@ gen_extend_insn (x, y, mto, mfrom, unsignedp)
return (GEN_FCN (extendtab[(int) mto][(int) mfrom][unsignedp]) (x, y));
}
static void
init_extends ()
{
enum insn_code *p;
for (p = extendtab[0][0];
p < extendtab[0][0] + sizeof extendtab / sizeof extendtab[0][0][0];
p++)
*p = CODE_FOR_nothing;
#ifdef HAVE_extendditi2
if (HAVE_extendditi2)
extendtab[(int) TImode][(int) DImode][0] = CODE_FOR_extendditi2;
#endif
#ifdef HAVE_extendsiti2
if (HAVE_extendsiti2)
extendtab[(int) TImode][(int) SImode][0] = CODE_FOR_extendsiti2;
#endif
#ifdef HAVE_extendhiti2
if (HAVE_extendhiti2)
extendtab[(int) TImode][(int) HImode][0] = CODE_FOR_extendhiti2;
#endif
#ifdef HAVE_extendqiti2
if (HAVE_extendqiti2)
extendtab[(int) TImode][(int) QImode][0] = CODE_FOR_extendqiti2;
#endif
#ifdef HAVE_extendsidi2
if (HAVE_extendsidi2)
extendtab[(int) DImode][(int) SImode][0] = CODE_FOR_extendsidi2;
#endif
#ifdef HAVE_extendhidi2
if (HAVE_extendhidi2)
extendtab[(int) DImode][(int) HImode][0] = CODE_FOR_extendhidi2;
#endif
#ifdef HAVE_extendqidi2
if (HAVE_extendqidi2)
extendtab[(int) DImode][(int) QImode][0] = CODE_FOR_extendqidi2;
#endif
#ifdef HAVE_extendhisi2
if (HAVE_extendhisi2)
extendtab[(int) SImode][(int) HImode][0] = CODE_FOR_extendhisi2;
#endif
#ifdef HAVE_extendqisi2
if (HAVE_extendqisi2)
extendtab[(int) SImode][(int) QImode][0] = CODE_FOR_extendqisi2;
#endif
#ifdef HAVE_extendqihi2
if (HAVE_extendqihi2)
extendtab[(int) HImode][(int) QImode][0] = CODE_FOR_extendqihi2;
#endif
#ifdef HAVE_zero_extendditi2
if (HAVE_zero_extendsiti2)
extendtab[(int) TImode][(int) DImode][1] = CODE_FOR_zero_extendditi2;
#endif
#ifdef HAVE_zero_extendsiti2
if (HAVE_zero_extendsiti2)
extendtab[(int) TImode][(int) SImode][1] = CODE_FOR_zero_extendsiti2;
#endif
#ifdef HAVE_zero_extendhiti2
if (HAVE_zero_extendhiti2)
extendtab[(int) TImode][(int) HImode][1] = CODE_FOR_zero_extendhiti2;
#endif
#ifdef HAVE_zero_extendqiti2
if (HAVE_zero_extendqiti2)
extendtab[(int) TImode][(int) QImode][1] = CODE_FOR_zero_extendqiti2;
#endif
#ifdef HAVE_zero_extendsidi2
if (HAVE_zero_extendsidi2)
extendtab[(int) DImode][(int) SImode][1] = CODE_FOR_zero_extendsidi2;
#endif
#ifdef HAVE_zero_extendhidi2
if (HAVE_zero_extendhidi2)
extendtab[(int) DImode][(int) HImode][1] = CODE_FOR_zero_extendhidi2;
#endif
#ifdef HAVE_zero_extendqidi2
if (HAVE_zero_extendqidi2)
extendtab[(int) DImode][(int) QImode][1] = CODE_FOR_zero_extendqidi2;
#endif
#ifdef HAVE_zero_extendhisi2
if (HAVE_zero_extendhisi2)
extendtab[(int) SImode][(int) HImode][1] = CODE_FOR_zero_extendhisi2;
#endif
#ifdef HAVE_zero_extendqisi2
if (HAVE_zero_extendqisi2)
extendtab[(int) SImode][(int) QImode][1] = CODE_FOR_zero_extendqisi2;
#endif
#ifdef HAVE_zero_extendqihi2
if (HAVE_zero_extendqihi2)
extendtab[(int) HImode][(int) QImode][1] = CODE_FOR_zero_extendqihi2;
#endif
}
/* can_fix_p and can_float_p say whether the target machine
can directly convert a given fixed point type to
a given floating point type, or vice versa.
The returned value is the CODE_FOR_... value to use,
or CODE_FOR_nothing if these modes cannot be directly converted. */
static enum insn_code fixtab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2];
static enum insn_code fixtrunctab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2];
static enum insn_code floattab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2];
or CODE_FOR_nothing if these modes cannot be directly converted.
/* *TRUNCP_PTR is set to 1 if it is necessary to output
*TRUNCP_PTR is set to 1 if it is necessary to output
an explicit FTRUNC insn before the fix insn; otherwise 0. */
static enum insn_code
......@@ -2842,663 +2749,6 @@ can_float_p (fltmode, fixmode, unsignedp)
return floattab[(int) fltmode][(int) fixmode][unsignedp];
}
void
init_fixtab ()
{
enum insn_code *p;
for (p = fixtab[0][0];
p < fixtab[0][0] + sizeof fixtab / sizeof (fixtab[0][0][0]);
p++)
*p = CODE_FOR_nothing;
for (p = fixtrunctab[0][0];
p < fixtrunctab[0][0] + sizeof fixtrunctab / sizeof (fixtrunctab[0][0][0]);
p++)
*p = CODE_FOR_nothing;
#ifdef HAVE_fixqfqi2
if (HAVE_fixqfqi2)
fixtab[(int) QFmode][(int) QImode][0] = CODE_FOR_fixqfqi2;
#endif
#ifdef HAVE_fixhfqi2
if (HAVE_fixhfqi2)
fixtab[(int) HFmode][(int) QImode][0] = CODE_FOR_fixhfqi2;
#endif
#ifdef HAVE_fixhfhi2
if (HAVE_fixhfhi2)
fixtab[(int) HFmode][(int) HImode][0] = CODE_FOR_fixhfhi2;
#endif
#ifdef HAVE_fixsfqi2
if (HAVE_fixsfqi2)
fixtab[(int) SFmode][(int) QImode][0] = CODE_FOR_fixsfqi2;
#endif
#ifdef HAVE_fixsfhi2
if (HAVE_fixsfhi2)
fixtab[(int) SFmode][(int) HImode][0] = CODE_FOR_fixsfhi2;
#endif
#ifdef HAVE_fixsfsi2
if (HAVE_fixsfsi2)
fixtab[(int) SFmode][(int) SImode][0] = CODE_FOR_fixsfsi2;
#endif
#ifdef HAVE_fixsfdi2
if (HAVE_fixsfdi2)
fixtab[(int) SFmode][(int) DImode][0] = CODE_FOR_fixsfdi2;
#endif
#ifdef HAVE_fixdfqi2
if (HAVE_fixdfqi2)
fixtab[(int) DFmode][(int) QImode][0] = CODE_FOR_fixdfqi2;
#endif
#ifdef HAVE_fixdfhi2
if (HAVE_fixdfhi2)
fixtab[(int) DFmode][(int) HImode][0] = CODE_FOR_fixdfhi2;
#endif
#ifdef HAVE_fixdfsi2
if (HAVE_fixdfsi2)
fixtab[(int) DFmode][(int) SImode][0] = CODE_FOR_fixdfsi2;
#endif
#ifdef HAVE_fixdfdi2
if (HAVE_fixdfdi2)
fixtab[(int) DFmode][(int) DImode][0] = CODE_FOR_fixdfdi2;
#endif
#ifdef HAVE_fixdfti2
if (HAVE_fixdfti2)
fixtab[(int) DFmode][(int) TImode][0] = CODE_FOR_fixdfti2;
#endif
#ifdef HAVE_fixxfqi2
if (HAVE_fixxfqi2)
fixtab[(int) XFmode][(int) QImode][0] = CODE_FOR_fixxfqi2;
#endif
#ifdef HAVE_fixxfhi2
if (HAVE_fixxfhi2)
fixtab[(int) XFmode][(int) HImode][0] = CODE_FOR_fixxfhi2;
#endif
#ifdef HAVE_fixxfsi2
if (HAVE_fixxfsi2)
fixtab[(int) XFmode][(int) SImode][0] = CODE_FOR_fixxfsi2;
#endif
#ifdef HAVE_fixxfdi2
if (HAVE_fixxfdi2)
fixtab[(int) XFmode][(int) DImode][0] = CODE_FOR_fixxfdi2;
#endif
#ifdef HAVE_fixxfti2
if (HAVE_fixxfti2)
fixtab[(int) XFmode][(int) TImode][0] = CODE_FOR_fixxfti2;
#endif
#ifdef HAVE_fixtfqi2
if (HAVE_fixtfqi2)
fixtab[(int) TFmode][(int) QImode][0] = CODE_FOR_fixtfqi2;
#endif
#ifdef HAVE_fixtfhi2
if (HAVE_fixtfhi2)
fixtab[(int) TFmode][(int) HImode][0] = CODE_FOR_fixtfhi2;
#endif
#ifdef HAVE_fixtfsi2
if (HAVE_fixtfsi2)
fixtab[(int) TFmode][(int) SImode][0] = CODE_FOR_fixtfsi2;
#endif
#ifdef HAVE_fixtfdi2
if (HAVE_fixtfdi2)
fixtab[(int) TFmode][(int) DImode][0] = CODE_FOR_fixtfdi2;
#endif
#ifdef HAVE_fixtfti2
if (HAVE_fixtfti2)
fixtab[(int) TFmode][(int) TImode][0] = CODE_FOR_fixtfti2;
#endif
#ifdef HAVE_fixunsqfqi2
if (HAVE_fixunsqfqi2)
fixtab[(int) QFmode][(int) QImode][1] = CODE_FOR_fixunsqfqi2;
#endif
#ifdef HAVE_fixunshfqi2
if (HAVE_fixunshfqi2)
fixtab[(int) HFmode][(int) QImode][1] = CODE_FOR_fixunshfqi2;
#endif
#ifdef HAVE_fixunshfhi2
if (HAVE_fixunshfhi2)
fixtab[(int) HFmode][(int) HImode][1] = CODE_FOR_fixunshfhi2;
#endif
#ifdef HAVE_fixunssfqi2
if (HAVE_fixunssfqi2)
fixtab[(int) SFmode][(int) QImode][1] = CODE_FOR_fixunssfqi2;
#endif
#ifdef HAVE_fixunssfhi2
if (HAVE_fixunssfhi2)
fixtab[(int) SFmode][(int) HImode][1] = CODE_FOR_fixunssfhi2;
#endif
#ifdef HAVE_fixunssfsi2
if (HAVE_fixunssfsi2)
fixtab[(int) SFmode][(int) SImode][1] = CODE_FOR_fixunssfsi2;
#endif
#ifdef HAVE_fixunssfdi2
if (HAVE_fixunssfdi2)
fixtab[(int) SFmode][(int) DImode][1] = CODE_FOR_fixunssfdi2;
#endif
#ifdef HAVE_fixunsdfqi2
if (HAVE_fixunsdfqi2)
fixtab[(int) DFmode][(int) QImode][1] = CODE_FOR_fixunsdfqi2;
#endif
#ifdef HAVE_fixunsdfhi2
if (HAVE_fixunsdfhi2)
fixtab[(int) DFmode][(int) HImode][1] = CODE_FOR_fixunsdfhi2;
#endif
#ifdef HAVE_fixunsdfsi2
if (HAVE_fixunsdfsi2)
fixtab[(int) DFmode][(int) SImode][1] = CODE_FOR_fixunsdfsi2;
#endif
#ifdef HAVE_fixunsdfdi2
if (HAVE_fixunsdfdi2)
fixtab[(int) DFmode][(int) DImode][1] = CODE_FOR_fixunsdfdi2;
#endif
#ifdef HAVE_fixunsdfti2
if (HAVE_fixunsdfti2)
fixtab[(int) DFmode][(int) TImode][1] = CODE_FOR_fixunsdfti2;
#endif
#ifdef HAVE_fixunsxfqi2
if (HAVE_fixunsxfqi2)
fixtab[(int) XFmode][(int) QImode][1] = CODE_FOR_fixunsxfqi2;
#endif
#ifdef HAVE_fixunsxfhi2
if (HAVE_fixunsxfhi2)
fixtab[(int) XFmode][(int) HImode][1] = CODE_FOR_fixunsxfhi2;
#endif
#ifdef HAVE_fixunsxfsi2
if (HAVE_fixunsxfsi2)
fixtab[(int) XFmode][(int) SImode][1] = CODE_FOR_fixunsxfsi2;
#endif
#ifdef HAVE_fixunsxfdi2
if (HAVE_fixunsxfdi2)
fixtab[(int) XFmode][(int) DImode][1] = CODE_FOR_fixunsxfdi2;
#endif
#ifdef HAVE_fixunsxfti2
if (HAVE_fixunsxfti2)
fixtab[(int) XFmode][(int) TImode][1] = CODE_FOR_fixunsxfti2;
#endif
#ifdef HAVE_fixunstfqi2
if (HAVE_fixunstfqi2)
fixtab[(int) TFmode][(int) QImode][1] = CODE_FOR_fixunstfqi2;
#endif
#ifdef HAVE_fixunstfhi2
if (HAVE_fixunstfhi2)
fixtab[(int) TFmode][(int) HImode][1] = CODE_FOR_fixunstfhi2;
#endif
#ifdef HAVE_fixunstfsi2
if (HAVE_fixunstfsi2)
fixtab[(int) TFmode][(int) SImode][1] = CODE_FOR_fixunstfsi2;
#endif
#ifdef HAVE_fixunstfdi2
if (HAVE_fixunstfdi2)
fixtab[(int) TFmode][(int) DImode][1] = CODE_FOR_fixunstfdi2;
#endif
#ifdef HAVE_fixunstfti2
if (HAVE_fixunstfti2)
fixtab[(int) TFmode][(int) TImode][1] = CODE_FOR_fixunstfti2;
#endif
#ifdef HAVE_fix_truncqfqi2
if (HAVE_fix_truncqfqi2)
fixtrunctab[(int) QFmode][(int) QImode][0] = CODE_FOR_fix_truncqfqi2;
#endif
#ifdef HAVE_fix_trunchfqi2
if (HAVE_fix_trunchfqi2)
fixtrunctab[(int) HFmode][(int) QImode][0] = CODE_FOR_fix_trunchfqi2;
#endif
#ifdef HAVE_fix_trunchfhi2
if (HAVE_fix_trunchfhi2)
fixtrunctab[(int) HFmode][(int) HImode][0] = CODE_FOR_fix_trunchfhi2;
#endif
#ifdef HAVE_fix_truncsfqi2
if (HAVE_fix_truncsfqi2)
fixtrunctab[(int) SFmode][(int) QImode][0] = CODE_FOR_fix_truncsfqi2;
#endif
#ifdef HAVE_fix_truncsfhi2
if (HAVE_fix_truncsfhi2)
fixtrunctab[(int) SFmode][(int) HImode][0] = CODE_FOR_fix_truncsfhi2;
#endif
#ifdef HAVE_fix_truncsfsi2
if (HAVE_fix_truncsfsi2)
fixtrunctab[(int) SFmode][(int) SImode][0] = CODE_FOR_fix_truncsfsi2;
#endif
#ifdef HAVE_fix_truncsfdi2
if (HAVE_fix_truncsfdi2)
fixtrunctab[(int) SFmode][(int) DImode][0] = CODE_FOR_fix_truncsfdi2;
#endif
#ifdef HAVE_fix_truncdfqi2
if (HAVE_fix_truncdfqi2)
fixtrunctab[(int) DFmode][(int) QImode][0] = CODE_FOR_fix_truncdfqi2;
#endif
#ifdef HAVE_fix_truncdfhi2
if (HAVE_fix_truncdfhi2)
fixtrunctab[(int) DFmode][(int) HImode][0] = CODE_FOR_fix_truncdfhi2;
#endif
#ifdef HAVE_fix_truncdfsi2
if (HAVE_fix_truncdfsi2)
fixtrunctab[(int) DFmode][(int) SImode][0] = CODE_FOR_fix_truncdfsi2;
#endif
#ifdef HAVE_fix_truncdfdi2
if (HAVE_fix_truncdfdi2)
fixtrunctab[(int) DFmode][(int) DImode][0] = CODE_FOR_fix_truncdfdi2;
#endif
#ifdef HAVE_fix_truncdfti2
if (HAVE_fix_truncdfti2)
fixtrunctab[(int) DFmode][(int) TImode][0] = CODE_FOR_fix_truncdfti2;
#endif
#ifdef HAVE_fix_truncxfqi2
if (HAVE_fix_truncxfqi2)
fixtrunctab[(int) XFmode][(int) QImode][0] = CODE_FOR_fix_truncxfqi2;
#endif
#ifdef HAVE_fix_truncxfhi2
if (HAVE_fix_truncxfhi2)
fixtrunctab[(int) XFmode][(int) HImode][0] = CODE_FOR_fix_truncxfhi2;
#endif
#ifdef HAVE_fix_truncxfsi2
if (HAVE_fix_truncxfsi2)
fixtrunctab[(int) XFmode][(int) SImode][0] = CODE_FOR_fix_truncxfsi2;
#endif
#ifdef HAVE_fix_truncxfdi2
if (HAVE_fix_truncxfdi2)
fixtrunctab[(int) XFmode][(int) DImode][0] = CODE_FOR_fix_truncxfdi2;
#endif
#ifdef HAVE_fix_truncxfti2
if (HAVE_fix_truncxfti2)
fixtrunctab[(int) XFmode][(int) TImode][0] = CODE_FOR_fix_truncxfti2;
#endif
#ifdef HAVE_fix_trunctfqi2
if (HAVE_fix_trunctfqi2)
fixtrunctab[(int) TFmode][(int) QImode][0] = CODE_FOR_fix_trunctfqi2;
#endif
#ifdef HAVE_fix_trunctfhi2
if (HAVE_fix_trunctfhi2)
fixtrunctab[(int) TFmode][(int) HImode][0] = CODE_FOR_fix_trunctfhi2;
#endif
#ifdef HAVE_fix_trunctfsi2
if (HAVE_fix_trunctfsi2)
fixtrunctab[(int) TFmode][(int) SImode][0] = CODE_FOR_fix_trunctfsi2;
#endif
#ifdef HAVE_fix_trunctfdi2
if (HAVE_fix_trunctfdi2)
fixtrunctab[(int) TFmode][(int) DImode][0] = CODE_FOR_fix_trunctfdi2;
#endif
#ifdef HAVE_fix_trunctfti2
if (HAVE_fix_trunctfti2)
fixtrunctab[(int) TFmode][(int) TImode][0] = CODE_FOR_fix_trunctfti2;
#endif
#ifdef HAVE_fixuns_truncqfqi2
if (HAVE_fixuns_truncqfqi2)
fixtrunctab[(int) QFmode][(int) QImode][1] = CODE_FOR_fixuns_truncqfqi2;
#endif
#ifdef HAVE_fixuns_trunchfqi2
if (HAVE_fixuns_trunchfqi2)
fixtrunctab[(int) HFmode][(int) QImode][1] = CODE_FOR_fixuns_trunchfqi2;
#endif
#ifdef HAVE_fixuns_trunchfhi2
if (HAVE_fixuns_trunchfhi2)
fixtrunctab[(int) HFmode][(int) HImode][1] = CODE_FOR_fixuns_trunchfhi2;
#endif
#ifdef HAVE_fixuns_truncsfqi2
if (HAVE_fixuns_truncsfqi2)
fixtrunctab[(int) SFmode][(int) QImode][1] = CODE_FOR_fixuns_truncsfqi2;
#endif
#ifdef HAVE_fixuns_truncsfhi2
if (HAVE_fixuns_truncsfhi2)
fixtrunctab[(int) SFmode][(int) HImode][1] = CODE_FOR_fixuns_truncsfhi2;
#endif
#ifdef HAVE_fixuns_truncsfsi2
if (HAVE_fixuns_truncsfsi2)
fixtrunctab[(int) SFmode][(int) SImode][1] = CODE_FOR_fixuns_truncsfsi2;
#endif
#ifdef HAVE_fixuns_truncsfdi2
if (HAVE_fixuns_truncsfdi2)
fixtrunctab[(int) SFmode][(int) DImode][1] = CODE_FOR_fixuns_truncsfdi2;
#endif
#ifdef HAVE_fixuns_truncdfqi2
if (HAVE_fixuns_truncdfqi2)
fixtrunctab[(int) DFmode][(int) QImode][1] = CODE_FOR_fixuns_truncdfqi2;
#endif
#ifdef HAVE_fixuns_truncdfhi2
if (HAVE_fixuns_truncdfhi2)
fixtrunctab[(int) DFmode][(int) HImode][1] = CODE_FOR_fixuns_truncdfhi2;
#endif
#ifdef HAVE_fixuns_truncdfsi2
if (HAVE_fixuns_truncdfsi2)
fixtrunctab[(int) DFmode][(int) SImode][1] = CODE_FOR_fixuns_truncdfsi2;
#endif
#ifdef HAVE_fixuns_truncdfdi2
if (HAVE_fixuns_truncdfdi2)
fixtrunctab[(int) DFmode][(int) DImode][1] = CODE_FOR_fixuns_truncdfdi2;
#endif
#ifdef HAVE_fixuns_truncdfti2
if (HAVE_fixuns_truncdfti2)
fixtrunctab[(int) DFmode][(int) TImode][1] = CODE_FOR_fixuns_truncdfti2;
#endif
#ifdef HAVE_fixuns_truncxfqi2
if (HAVE_fixuns_truncxfqi2)
fixtrunctab[(int) XFmode][(int) QImode][1] = CODE_FOR_fixuns_truncxfqi2;
#endif
#ifdef HAVE_fixuns_truncxfhi2
if (HAVE_fixuns_truncxfhi2)
fixtrunctab[(int) XFmode][(int) HImode][1] = CODE_FOR_fixuns_truncxfhi2;
#endif
#ifdef HAVE_fixuns_truncxfsi2
if (HAVE_fixuns_truncxfsi2)
fixtrunctab[(int) XFmode][(int) SImode][1] = CODE_FOR_fixuns_truncxfsi2;
#endif
#ifdef HAVE_fixuns_truncxfdi2
if (HAVE_fixuns_truncxfdi2)
fixtrunctab[(int) XFmode][(int) DImode][1] = CODE_FOR_fixuns_truncxfdi2;
#endif
#ifdef HAVE_fixuns_truncxfti2
if (HAVE_fixuns_truncxfti2)
fixtrunctab[(int) XFmode][(int) TImode][1] = CODE_FOR_fixuns_truncxfti2;
#endif
#ifdef HAVE_fixuns_trunctfqi2
if (HAVE_fixuns_trunctfqi2)
fixtrunctab[(int) TFmode][(int) QImode][1] = CODE_FOR_fixuns_trunctfqi2;
#endif
#ifdef HAVE_fixuns_trunctfhi2
if (HAVE_fixuns_trunctfhi2)
fixtrunctab[(int) TFmode][(int) HImode][1] = CODE_FOR_fixuns_trunctfhi2;
#endif
#ifdef HAVE_fixuns_trunctfsi2
if (HAVE_fixuns_trunctfsi2)
fixtrunctab[(int) TFmode][(int) SImode][1] = CODE_FOR_fixuns_trunctfsi2;
#endif
#ifdef HAVE_fixuns_trunctfdi2
if (HAVE_fixuns_trunctfdi2)
fixtrunctab[(int) TFmode][(int) DImode][1] = CODE_FOR_fixuns_trunctfdi2;
#endif
#ifdef HAVE_fixuns_trunctfti2
if (HAVE_fixuns_trunctfti2)
fixtrunctab[(int) TFmode][(int) TImode][1] = CODE_FOR_fixuns_trunctfti2;
#endif
#ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC
/* This flag says the same insns that convert to a signed fixnum
also convert validly to an unsigned one. */
{
int i;
int j;
for (i = 0; i < NUM_MACHINE_MODES; i++)
for (j = 0; j < NUM_MACHINE_MODES; j++)
fixtrunctab[i][j][1] = fixtrunctab[i][j][0];
}
#endif
}
void
init_floattab ()
{
enum insn_code *p;
for (p = floattab[0][0];
p < floattab[0][0] + sizeof floattab / sizeof (floattab[0][0][0]);
p++)
*p = CODE_FOR_nothing;
#ifdef HAVE_floatqiqf2
if (HAVE_floatqiqf2)
floattab[(int) QFmode][(int) QImode][0] = CODE_FOR_floatqiqf2;
#endif
#ifdef HAVE_floathiqf2
if (HAVE_floathiqf2)
floattab[(int) QFmode][(int) HImode][0] = CODE_FOR_floathiqf2;
#endif
#ifdef HAVE_floatsiqf2
if (HAVE_floatsiqf2)
floattab[(int) QFmode][(int) SImode][0] = CODE_FOR_floatsiqf2;
#endif
#ifdef HAVE_floatdiqf2
if (HAVE_floatdiqf2)
floattab[(int) QFmode][(int) DImode][0] = CODE_FOR_floatdiqf2;
#endif
#ifdef HAVE_floattiqf2
if (HAVE_floattiqf2)
floattab[(int) QFmode][(int) TImode][0] = CODE_FOR_floattiqf2;
#endif
#ifdef HAVE_floatqihf2
if (HAVE_floatqihf2)
floattab[(int) HFmode][(int) QImode][0] = CODE_FOR_floatqihf2;
#endif
#ifdef HAVE_floathihf2
if (HAVE_floathihf2)
floattab[(int) HFmode][(int) HImode][0] = CODE_FOR_floathihf2;
#endif
#ifdef HAVE_floatsihf2
if (HAVE_floatsihf2)
floattab[(int) HFmode][(int) SImode][0] = CODE_FOR_floatsihf2;
#endif
#ifdef HAVE_floatdihf2
if (HAVE_floatdihf2)
floattab[(int) HFmode][(int) DImode][0] = CODE_FOR_floatdihf2;
#endif
#ifdef HAVE_floattihf2
if (HAVE_floattihf2)
floattab[(int) HFmode][(int) TImode][0] = CODE_FOR_floattihf2;
#endif
#ifdef HAVE_floatqisf2
if (HAVE_floatqisf2)
floattab[(int) SFmode][(int) QImode][0] = CODE_FOR_floatqisf2;
#endif
#ifdef HAVE_floathisf2
if (HAVE_floathisf2)
floattab[(int) SFmode][(int) HImode][0] = CODE_FOR_floathisf2;
#endif
#ifdef HAVE_floatsisf2
if (HAVE_floatsisf2)
floattab[(int) SFmode][(int) SImode][0] = CODE_FOR_floatsisf2;
#endif
#ifdef HAVE_floatdisf2
if (HAVE_floatdisf2)
floattab[(int) SFmode][(int) DImode][0] = CODE_FOR_floatdisf2;
#endif
#ifdef HAVE_floattisf2
if (HAVE_floattisf2)
floattab[(int) SFmode][(int) TImode][0] = CODE_FOR_floattisf2;
#endif
#ifdef HAVE_floatqidf2
if (HAVE_floatqidf2)
floattab[(int) DFmode][(int) QImode][0] = CODE_FOR_floatqidf2;
#endif
#ifdef HAVE_floathidf2
if (HAVE_floathidf2)
floattab[(int) DFmode][(int) HImode][0] = CODE_FOR_floathidf2;
#endif
#ifdef HAVE_floatsidf2
if (HAVE_floatsidf2)
floattab[(int) DFmode][(int) SImode][0] = CODE_FOR_floatsidf2;
#endif
#ifdef HAVE_floatdidf2
if (HAVE_floatdidf2)
floattab[(int) DFmode][(int) DImode][0] = CODE_FOR_floatdidf2;
#endif
#ifdef HAVE_floattidf2
if (HAVE_floattidf2)
floattab[(int) DFmode][(int) TImode][0] = CODE_FOR_floattidf2;
#endif
#ifdef HAVE_floatqixf2
if (HAVE_floatqixf2)
floattab[(int) XFmode][(int) QImode][0] = CODE_FOR_floatqixf2;
#endif
#ifdef HAVE_floathixf2
if (HAVE_floathixf2)
floattab[(int) XFmode][(int) HImode][0] = CODE_FOR_floathixf2;
#endif
#ifdef HAVE_floatsixf2
if (HAVE_floatsixf2)
floattab[(int) XFmode][(int) SImode][0] = CODE_FOR_floatsixf2;
#endif
#ifdef HAVE_floatdixf2
if (HAVE_floatdixf2)
floattab[(int) XFmode][(int) DImode][0] = CODE_FOR_floatdixf2;
#endif
#ifdef HAVE_floattixf2
if (HAVE_floattixf2)
floattab[(int) XFmode][(int) TImode][0] = CODE_FOR_floattixf2;
#endif
#ifdef HAVE_floatqitf2
if (HAVE_floatqitf2)
floattab[(int) TFmode][(int) QImode][0] = CODE_FOR_floatqitf2;
#endif
#ifdef HAVE_floathitf2
if (HAVE_floathitf2)
floattab[(int) TFmode][(int) HImode][0] = CODE_FOR_floathitf2;
#endif
#ifdef HAVE_floatsitf2
if (HAVE_floatsitf2)
floattab[(int) TFmode][(int) SImode][0] = CODE_FOR_floatsitf2;
#endif
#ifdef HAVE_floatditf2
if (HAVE_floatditf2)
floattab[(int) TFmode][(int) DImode][0] = CODE_FOR_floatditf2;
#endif
#ifdef HAVE_floattitf2
if (HAVE_floattitf2)
floattab[(int) TFmode][(int) TImode][0] = CODE_FOR_floattitf2;
#endif
#ifdef HAVE_floatunsqiqf2
if (HAVE_floatunsqiqf2)
floattab[(int) QFmode][(int) QImode][1] = CODE_FOR_floatunsqiqf2;
#endif
#ifdef HAVE_floatunshiqf2
if (HAVE_floatunshiqf2)
floattab[(int) QFmode][(int) HImode][1] = CODE_FOR_floatunshiqf2;
#endif
#ifdef HAVE_floatunssiqf2
if (HAVE_floatunsqsiqf2)
floattab[(int) QFmode][(int) SImode][1] = CODE_FOR_floatunssiqf2;
#endif
#ifdef HAVE_floatunsdiqf2
if (HAVE_floatunsdiqf2)
floattab[(int) QFmode][(int) DImode][1] = CODE_FOR_floatunsdiqf2;
#endif
#ifdef HAVE_floatunstiqf2
if (HAVE_floatunstiqf2)
floattab[(int) QFmode][(int) TImode][1] = CODE_FOR_floatunstiqf2;
#endif
#ifdef HAVE_floatunsqihf2
if (HAVE_floatunsqihf2)
floattab[(int) HFmode][(int) QImode][1] = CODE_FOR_floatunsqihf2;
#endif
#ifdef HAVE_floatunshihf2
if (HAVE_floatunshihf2)
floattab[(int) HFmode][(int) HImode][1] = CODE_FOR_floatunshihf2;
#endif
#ifdef HAVE_floatunssihf2
if (HAVE_floatunssihf2)
floattab[(int) HFmode][(int) SImode][1] = CODE_FOR_floatunssihf2;
#endif
#ifdef HAVE_floatunsdihf2
if (HAVE_floatunsdihf2)
floattab[(int) HFmode][(int) DImode][1] = CODE_FOR_floatunsdihf2;
#endif
#ifdef HAVE_floatunstihf2
if (HAVE_floatunstihf2)
floattab[(int) HFmode][(int) TImode][1] = CODE_FOR_floatunstihf2;
#endif
#ifdef HAVE_floatqunsqisf2
if (HAVE_floatunsqisf2)
floattab[(int) SFmode][(int) QImode][1] = CODE_FOR_floatunsqisf2;
#endif
#ifdef HAVE_floatunshisf2
if (HAVE_floatunshisf2)
floattab[(int) SFmode][(int) HImode][1] = CODE_FOR_floatunshisf2;
#endif
#ifdef HAVE_floatunssisf2
if (HAVE_floatunssisf2)
floattab[(int) SFmode][(int) SImode][1] = CODE_FOR_floatunssisf2;
#endif
#ifdef HAVE_floatunsdisf2
if (HAVE_floatunsdisf2)
floattab[(int) SFmode][(int) DImode][1] = CODE_FOR_floatunsdisf2;
#endif
#ifdef HAVE_floatunstisf2
if (HAVE_floatunstisf2)
floattab[(int) SFmode][(int) TImode][1] = CODE_FOR_floatunstisf2;
#endif
#ifdef HAVE_floatunsqidf2
if (HAVE_floatunsqidf2)
floattab[(int) DFmode][(int) QImode][1] = CODE_FOR_floatunsqidf2;
#endif
#ifdef HAVE_floatunshidf2
if (HAVE_floatunshidf2)
floattab[(int) DFmode][(int) HImode][1] = CODE_FOR_floatunshidf2;
#endif
#ifdef HAVE_floatunssidf2
if (HAVE_floatunssidf2)
floattab[(int) DFmode][(int) SImode][1] = CODE_FOR_floatunssidf2;
#endif
#ifdef HAVE_floatunsdidf2
if (HAVE_floatunsdidf2)
floattab[(int) DFmode][(int) DImode][1] = CODE_FOR_floatunsdidf2;
#endif
#ifdef HAVE_floatunstidf2
if (HAVE_floatunstidf2)
floattab[(int) DFmode][(int) TImode][1] = CODE_FOR_floatunstidf2;
#endif
#ifdef HAVE_floatunsqixf2
if (HAVE_floatunsqixf2)
floattab[(int) XFmode][(int) QImode][1] = CODE_FOR_floatunsqixf2;
#endif
#ifdef HAVE_floatunshixf2
if (HAVE_floatunshixf2)
floattab[(int) XFmode][(int) HImode][1] = CODE_FOR_floatunshixf2;
#endif
#ifdef HAVE_floatunssixf2
if (HAVE_floatunssixf2)
floattab[(int) XFmode][(int) SImode][1] = CODE_FOR_floatunssixf2;
#endif
#ifdef HAVE_floatunsdixf2
if (HAVE_floatunsdixf2)
floattab[(int) XFmode][(int) DImode][1] = CODE_FOR_floatunsdixf2;
#endif
#ifdef HAVE_floatunstixf2
if (HAVE_floatunstixf2)
floattab[(int) XFmode][(int) TImode][1] = CODE_FOR_floatunstixf2;
#endif
#ifdef HAVE_floatunsqitf2
if (HAVE_floatunsqitf2)
floattab[(int) TFmode][(int) QImode][1] = CODE_FOR_floatunsqitf2;
#endif
#ifdef HAVE_floatunshitf2
if (HAVE_floatunshitf2)
floattab[(int) TFmode][(int) HImode][1] = CODE_FOR_floatunshitf2;
#endif
#ifdef HAVE_floatunssitf2
if (HAVE_floatunssitf2)
floattab[(int) TFmode][(int) SImode][1] = CODE_FOR_floatunssitf2;
#endif
#ifdef HAVE_floatunsditf2
if (HAVE_floatunsditf2)
floattab[(int) TFmode][(int) DImode][1] = CODE_FOR_floatunsditf2;
#endif
#ifdef HAVE_floatunstitf2
if (HAVE_floatunstitf2)
floattab[(int) TFmode][(int) TImode][1] = CODE_FOR_floatunstitf2;
#endif
}
/* Generate code to convert FROM to floating point
and store in TO. FROM must be fixed point and not VOIDmode.
UNSIGNEDP nonzero means regard FROM as unsigned.
......@@ -4032,18 +3282,40 @@ init_complex_libfuncs (optable, opname, suffix)
void
init_optabs ()
{
int i;
int i, j;
enum insn_code *p;
init_fixtab ();
init_floattab ();
init_extends ();
/* Start by initializing all tables to contain CODE_FOR_nothing. */
add_optab = init_optab (PLUS);
sub_optab = init_optab (MINUS);
smul_optab = init_optab (MULT);
smul_widen_optab = init_optab (UNKNOWN);
umul_widen_optab = init_optab (UNKNOWN);
sdiv_optab = init_optab (DIV);
for (p = fixtab[0][0];
p < fixtab[0][0] + sizeof fixtab / sizeof (fixtab[0][0][0]);
p++)
*p = CODE_FOR_nothing;
for (p = fixtrunctab[0][0];
p < fixtrunctab[0][0] + sizeof fixtrunctab / sizeof (fixtrunctab[0][0][0]);
p++)
*p = CODE_FOR_nothing;
for (p = floattab[0][0];
p < floattab[0][0] + sizeof floattab / sizeof (floattab[0][0][0]);
p++)
*p = CODE_FOR_nothing;
for (p = extendtab[0][0];
p < extendtab[0][0] + sizeof extendtab / sizeof extendtab[0][0][0];
p++)
*p = CODE_FOR_nothing;
for (i = 0; i < NUM_RTX_CODE; i++)
setcc_gen_code[i] = CODE_FOR_nothing;
add_optab = init_optab (PLUS);
sub_optab = init_optab (MINUS);
smul_optab = init_optab (MULT);
smul_widen_optab = init_optab (UNKNOWN);
umul_widen_optab = init_optab (UNKNOWN);
sdiv_optab = init_optab (DIV);
sdivmod_optab = init_optab (UNKNOWN);
udiv_optab = init_optab (UDIV);
udivmod_optab = init_optab (UNKNOWN);
......@@ -4078,158 +3350,69 @@ init_optabs ()
cos_optab = init_optab (UNKNOWN);
strlen_optab = init_optab (UNKNOWN);
#ifdef HAVE_addqi3
if (HAVE_addqi3)
add_optab->handlers[(int) QImode].insn_code = CODE_FOR_addqi3;
#endif
#ifdef HAVE_addhi3
if (HAVE_addhi3)
add_optab->handlers[(int) HImode].insn_code = CODE_FOR_addhi3;
#endif
#ifdef HAVE_addpsi3
if (HAVE_addpsi3)
add_optab->handlers[(int) PSImode].insn_code = CODE_FOR_addpsi3;
#endif
#ifdef HAVE_addsi3
if (HAVE_addsi3)
add_optab->handlers[(int) SImode].insn_code = CODE_FOR_addsi3;
#endif
#ifdef HAVE_adddi3
if (HAVE_adddi3)
add_optab->handlers[(int) DImode].insn_code = CODE_FOR_adddi3;
#endif
#ifdef HAVE_addti3
if (HAVE_addti3)
add_optab->handlers[(int) TImode].insn_code = CODE_FOR_addti3;
#endif
#ifdef HAVE_addqf3
if (HAVE_addqf3)
add_optab->handlers[(int) QFmode].insn_code = CODE_FOR_addqf3;
#endif
#ifdef HAVE_addhf3
if (HAVE_addhf3)
add_optab->handlers[(int) HFmode].insn_code = CODE_FOR_addhf3;
#endif
#ifdef HAVE_addsf3
if (HAVE_addsf3)
add_optab->handlers[(int) SFmode].insn_code = CODE_FOR_addsf3;
#endif
#ifdef HAVE_adddf3
if (HAVE_adddf3)
add_optab->handlers[(int) DFmode].insn_code = CODE_FOR_adddf3;
for (i = 0; i < NUM_MACHINE_MODES; i++)
{
movstr_optab[i] = CODE_FOR_nothing;
#ifdef HAVE_SECONDARY_RELOADS
reload_in_optab[i] = reload_out_optab[i] = CODE_FOR_nothing;
#endif
#ifdef HAVE_addxf3
if (HAVE_addxf3)
add_optab->handlers[(int) XFmode].insn_code = CODE_FOR_addxf3;
}
/* Fill in the optabs with the insns we support. */
init_all_optabs ();
#ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC
/* This flag says the same insns that convert to a signed fixnum
also convert validly to an unsigned one. */
for (i = 0; i < NUM_MACHINE_MODES; i++)
for (j = 0; j < NUM_MACHINE_MODES; j++)
fixtrunctab[i][j][1] = fixtrunctab[i][j][0];
#endif
#ifdef HAVE_addtf3
if (HAVE_addtf3)
add_optab->handlers[(int) TFmode].insn_code = CODE_FOR_addtf3;
#ifdef EXTRA_CC_MODES
init_mov_optab ();
#endif
/* Initialize the optabs with the names of the library functions. */
init_integral_libfuncs (add_optab, "add", '3');
init_floating_libfuncs (add_optab, "add", '3');
#ifdef HAVE_subqi3
if (HAVE_subqi3)
sub_optab->handlers[(int) QImode].insn_code = CODE_FOR_subqi3;
#endif
#ifdef HAVE_subhi3
if (HAVE_subhi3)
sub_optab->handlers[(int) HImode].insn_code = CODE_FOR_subhi3;
#endif
#ifdef HAVE_subpsi3
if (HAVE_subpsi3)
sub_optab->handlers[(int) PSImode].insn_code = CODE_FOR_subpsi3;
#endif
#ifdef HAVE_subsi3
if (HAVE_subsi3)
sub_optab->handlers[(int) SImode].insn_code = CODE_FOR_subsi3;
#endif
#ifdef HAVE_subdi3
if (HAVE_subdi3)
sub_optab->handlers[(int) DImode].insn_code = CODE_FOR_subdi3;
#endif
#ifdef HAVE_subti3
if (HAVE_subti3)
sub_optab->handlers[(int) TImode].insn_code = CODE_FOR_subti3;
#endif
#ifdef HAVE_subqf3
if (HAVE_subqf3)
sub_optab->handlers[(int) QFmode].insn_code = CODE_FOR_subqf3;
#endif
#ifdef HAVE_subhf3
if (HAVE_subhf3)
sub_optab->handlers[(int) HFmode].insn_code = CODE_FOR_subhf3;
#endif
#ifdef HAVE_subsf3
if (HAVE_subsf3)
sub_optab->handlers[(int) SFmode].insn_code = CODE_FOR_subsf3;
#endif
#ifdef HAVE_subdf3
if (HAVE_subdf3)
sub_optab->handlers[(int) DFmode].insn_code = CODE_FOR_subdf3;
#endif
#ifdef HAVE_subxf3
if (HAVE_subxf3)
sub_optab->handlers[(int) XFmode].insn_code = CODE_FOR_subxf3;
#endif
#ifdef HAVE_subtf3
if (HAVE_subtf3)
sub_optab->handlers[(int) TFmode].insn_code = CODE_FOR_subtf3;
#endif
init_integral_libfuncs (sub_optab, "sub", '3');
init_floating_libfuncs (sub_optab, "sub", '3');
#ifdef HAVE_mulqi3
if (HAVE_mulqi3)
smul_optab->handlers[(int) QImode].insn_code = CODE_FOR_mulqi3;
#endif
#ifdef HAVE_mulhi3
if (HAVE_mulhi3)
smul_optab->handlers[(int) HImode].insn_code = CODE_FOR_mulhi3;
#endif
#ifdef HAVE_mulpsi3
if (HAVE_mulpsi3)
smul_optab->handlers[(int) PSImode].insn_code = CODE_FOR_mulpsi3;
#endif
#ifdef HAVE_mulsi3
if (HAVE_mulsi3)
smul_optab->handlers[(int) SImode].insn_code = CODE_FOR_mulsi3;
#endif
#ifdef HAVE_muldi3
if (HAVE_muldi3)
smul_optab->handlers[(int) DImode].insn_code = CODE_FOR_muldi3;
#endif
#ifdef HAVE_multi3
if (HAVE_multi3)
smul_optab->handlers[(int) TImode].insn_code = CODE_FOR_multi3;
#endif
#ifdef HAVE_mulqf3
if (HAVE_mulqf3)
smul_optab->handlers[(int) QFmode].insn_code = CODE_FOR_mulqf3;
#endif
#ifdef HAVE_mulhf3
if (HAVE_mulhf3)
smul_optab->handlers[(int) HFmode].insn_code = CODE_FOR_mulhf3;
#endif
#ifdef HAVE_mulsf3
if (HAVE_mulsf3)
smul_optab->handlers[(int) SFmode].insn_code = CODE_FOR_mulsf3;
#endif
#ifdef HAVE_muldf3
if (HAVE_muldf3)
smul_optab->handlers[(int) DFmode].insn_code = CODE_FOR_muldf3;
#endif
#ifdef HAVE_mulxf3
if (HAVE_mulxf3)
smul_optab->handlers[(int) XFmode].insn_code = CODE_FOR_mulxf3;
#endif
#ifdef HAVE_multf3
if (HAVE_multf3)
smul_optab->handlers[(int) TFmode].insn_code = CODE_FOR_multf3;
#endif
init_integral_libfuncs (smul_optab, "mul", '3');
init_floating_libfuncs (smul_optab, "mul", '3');
init_integral_libfuncs (sdiv_optab, "div", '3');
init_integral_libfuncs (udiv_optab, "udiv", '3');
init_integral_libfuncs (sdivmod_optab, "divmod", '4');
init_integral_libfuncs (udivmod_optab, "udivmod", '4');
init_integral_libfuncs (smod_optab, "mod", '3');
init_integral_libfuncs (umod_optab, "umod", '3');
init_floating_libfuncs (flodiv_optab, "div", '3');
init_floating_libfuncs (ftrunc_optab, "ftrunc", '2');
init_integral_libfuncs (and_optab, "and", '3');
init_integral_libfuncs (ior_optab, "ior", '3');
init_integral_libfuncs (xor_optab, "xor", '3');
init_integral_libfuncs (ashl_optab, "ashl", '3');
init_integral_libfuncs (ashr_optab, "ashr", '3');
init_integral_libfuncs (lshl_optab, "lshl", '3');
init_integral_libfuncs (lshr_optab, "lshr", '3');
init_integral_libfuncs (rotl_optab, "rotl", '3');
init_integral_libfuncs (rotr_optab, "rotr", '3');
init_integral_libfuncs (smin_optab, "min", '3');
init_floating_libfuncs (smin_optab, "min", '3');
init_integral_libfuncs (smax_optab, "max", '3');
init_floating_libfuncs (smax_optab, "max", '3');
init_integral_libfuncs (umin_optab, "umin", '3');
init_integral_libfuncs (umax_optab, "umax", '3');
init_integral_libfuncs (neg_optab, "neg", '2');
init_floating_libfuncs (neg_optab, "neg", '2');
init_integral_libfuncs (one_cmpl_optab, "one_cmpl", '2');
init_integral_libfuncs (ffs_optab, "ffs", '2');
/* Comparison libcalls for integers MUST come in pairs, signed/unsigned. */
init_integral_libfuncs (cmp_optab, "cmp", '2');
init_integral_libfuncs (ucmp_optab, "ucmp", '2');
init_floating_libfuncs (cmp_optab, "cmp", '2');
#ifdef MULSI3_LIBCALL
smul_optab->handlers[(int) SImode].libfunc
......@@ -4244,66 +3427,6 @@ init_optabs ()
= gen_rtx (SYMBOL_REF, Pmode, MULTI3_LIBCALL);
#endif
#ifdef HAVE_mulqihi3
if (HAVE_mulqihi3)
smul_widen_optab->handlers[(int) HImode].insn_code = CODE_FOR_mulqihi3;
#endif
#ifdef HAVE_mulhisi3
if (HAVE_mulhisi3)
smul_widen_optab->handlers[(int) SImode].insn_code = CODE_FOR_mulhisi3;
#endif
#ifdef HAVE_mulsidi3
if (HAVE_mulsidi3)
smul_widen_optab->handlers[(int) DImode].insn_code = CODE_FOR_mulsidi3;
#endif
#ifdef HAVE_mulditi3
if (HAVE_mulditi3)
smul_widen_optab->handlers[(int) TImode].insn_code = CODE_FOR_mulditi3;
#endif
#ifdef HAVE_umulqihi3
if (HAVE_umulqihi3)
umul_widen_optab->handlers[(int) HImode].insn_code = CODE_FOR_umulqihi3;
#endif
#ifdef HAVE_umulhisi3
if (HAVE_umulhisi3)
umul_widen_optab->handlers[(int) SImode].insn_code = CODE_FOR_umulhisi3;
#endif
#ifdef HAVE_umulsidi3
if (HAVE_umulsidi3)
umul_widen_optab->handlers[(int) DImode].insn_code = CODE_FOR_umulsidi3;
#endif
#ifdef HAVE_umulditi3
if (HAVE_umulditi3)
umul_widen_optab->handlers[(int) TImode].insn_code = CODE_FOR_umulditi3;
#endif
#ifdef HAVE_divqi3
if (HAVE_divqi3)
sdiv_optab->handlers[(int) QImode].insn_code = CODE_FOR_divqi3;
#endif
#ifdef HAVE_divhi3
if (HAVE_divhi3)
sdiv_optab->handlers[(int) HImode].insn_code = CODE_FOR_divhi3;
#endif
#ifdef HAVE_divpsi3
if (HAVE_divpsi3)
sdiv_optab->handlers[(int) PSImode].insn_code = CODE_FOR_divpsi3;
#endif
#ifdef HAVE_divsi3
if (HAVE_divsi3)
sdiv_optab->handlers[(int) SImode].insn_code = CODE_FOR_divsi3;
#endif
#ifdef HAVE_divdi3
if (HAVE_divdi3)
sdiv_optab->handlers[(int) DImode].insn_code = CODE_FOR_divdi3;
#endif
#ifdef HAVE_divti3
if (HAVE_divti3)
sdiv_optab->handlers[(int) TImode].insn_code = CODE_FOR_divti3;
#endif
init_integral_libfuncs (sdiv_optab, "div", '3');
#ifdef DIVSI3_LIBCALL
sdiv_optab->handlers[(int) SImode].libfunc
= gen_rtx (SYMBOL_REF, Pmode, DIVSI3_LIBCALL);
......@@ -4317,32 +3440,6 @@ init_optabs ()
= gen_rtx (SYMBOL_REF, Pmode, DIVTI3_LIBCALL);
#endif
#ifdef HAVE_udivqi3
if (HAVE_udivqi3)
udiv_optab->handlers[(int) QImode].insn_code = CODE_FOR_udivqi3;
#endif
#ifdef HAVE_udivhi3
if (HAVE_udivhi3)
udiv_optab->handlers[(int) HImode].insn_code = CODE_FOR_udivhi3;
#endif
#ifdef HAVE_udivpsi3
if (HAVE_udivpsi3)
udiv_optab->handlers[(int) PSImode].insn_code = CODE_FOR_udivpsi3;
#endif
#ifdef HAVE_udivsi3
if (HAVE_udivsi3)
udiv_optab->handlers[(int) SImode].insn_code = CODE_FOR_udivsi3;
#endif
#ifdef HAVE_udivdi3
if (HAVE_udivdi3)
udiv_optab->handlers[(int) DImode].insn_code = CODE_FOR_udivdi3;
#endif
#ifdef HAVE_udivti3
if (HAVE_udivti3)
udiv_optab->handlers[(int) TImode].insn_code = CODE_FOR_udivti3;
#endif
init_integral_libfuncs (udiv_optab, "udiv", '3');
#ifdef UDIVSI3_LIBCALL
udiv_optab->handlers[(int) SImode].libfunc
= gen_rtx (SYMBOL_REF, Pmode, UDIVSI3_LIBCALL);
......@@ -4356,75 +3453,6 @@ init_optabs ()
= gen_rtx (SYMBOL_REF, Pmode, UDIVTI3_LIBCALL);
#endif
#ifdef HAVE_divmodqi4
if (HAVE_divmodqi4)
sdivmod_optab->handlers[(int) QImode].insn_code = CODE_FOR_divmodqi4;
#endif
#ifdef HAVE_divmodhi4
if (HAVE_divmodhi4)
sdivmod_optab->handlers[(int) HImode].insn_code = CODE_FOR_divmodhi4;
#endif
#ifdef HAVE_divmodsi4
if (HAVE_divmodsi4)
sdivmod_optab->handlers[(int) SImode].insn_code = CODE_FOR_divmodsi4;
#endif
#ifdef HAVE_divmoddi4
if (HAVE_divmoddi4)
sdivmod_optab->handlers[(int) DImode].insn_code = CODE_FOR_divmoddi4;
#endif
#ifdef HAVE_divmodti4
if (HAVE_divmodti4)
sdivmod_optab->handlers[(int) TImode].insn_code = CODE_FOR_divmodti4;
#endif
init_integral_libfuncs (sdivmod_optab, "divmod", '4');
#ifdef HAVE_udivmodqi4
if (HAVE_udivmodqi4)
udivmod_optab->handlers[(int) QImode].insn_code = CODE_FOR_udivmodqi4;
#endif
#ifdef HAVE_udivmodhi4
if (HAVE_udivmodhi4)
udivmod_optab->handlers[(int) HImode].insn_code = CODE_FOR_udivmodhi4;
#endif
#ifdef HAVE_udivmodsi4
if (HAVE_udivmodsi4)
udivmod_optab->handlers[(int) SImode].insn_code = CODE_FOR_udivmodsi4;
#endif
#ifdef HAVE_udivmoddi4
if (HAVE_udivmoddi4)
udivmod_optab->handlers[(int) DImode].insn_code = CODE_FOR_udivmoddi4;
#endif
#ifdef HAVE_udivmodti4
if (HAVE_udivmodti4)
udivmod_optab->handlers[(int) TImode].insn_code = CODE_FOR_udivmodti4;
#endif
init_integral_libfuncs (udivmod_optab, "udivmod", '4');
#ifdef HAVE_modqi3
if (HAVE_modqi3)
smod_optab->handlers[(int) QImode].insn_code = CODE_FOR_modqi3;
#endif
#ifdef HAVE_modhi3
if (HAVE_modhi3)
smod_optab->handlers[(int) HImode].insn_code = CODE_FOR_modhi3;
#endif
#ifdef HAVE_modpsi3
if (HAVE_modpsi3)
smod_optab->handlers[(int) PSImode].insn_code = CODE_FOR_modpsi3;
#endif
#ifdef HAVE_modsi3
if (HAVE_modsi3)
smod_optab->handlers[(int) SImode].insn_code = CODE_FOR_modsi3;
#endif
#ifdef HAVE_moddi3
if (HAVE_moddi3)
smod_optab->handlers[(int) DImode].insn_code = CODE_FOR_moddi3;
#endif
#ifdef HAVE_modti3
if (HAVE_modti3)
smod_optab->handlers[(int) TImode].insn_code = CODE_FOR_modti3;
#endif
init_integral_libfuncs (smod_optab, "mod", '3');
#ifdef MODSI3_LIBCALL
smod_optab->handlers[(int) SImode].libfunc
......@@ -4439,31 +3467,6 @@ init_optabs ()
= gen_rtx (SYMBOL_REF, Pmode, MODTI3_LIBCALL);
#endif
#ifdef HAVE_umodqi3
if (HAVE_umodqi3)
umod_optab->handlers[(int) QImode].insn_code = CODE_FOR_umodqi3;
#endif
#ifdef HAVE_umodhi3
if (HAVE_umodhi3)
umod_optab->handlers[(int) HImode].insn_code = CODE_FOR_umodhi3;
#endif
#ifdef HAVE_umodpsi3
if (HAVE_umodpsi3)
umod_optab->handlers[(int) PSImode].insn_code = CODE_FOR_umodpsi3;
#endif
#ifdef HAVE_umodsi3
if (HAVE_umodsi3)
umod_optab->handlers[(int) SImode].insn_code = CODE_FOR_umodsi3;
#endif
#ifdef HAVE_umoddi3
if (HAVE_umoddi3)
umod_optab->handlers[(int) DImode].insn_code = CODE_FOR_umoddi3;
#endif
#ifdef HAVE_umodti3
if (HAVE_umodti3)
umod_optab->handlers[(int) TImode].insn_code = CODE_FOR_umodti3;
#endif
init_integral_libfuncs (umod_optab, "umod", '3');
#ifdef UMODSI3_LIBCALL
umod_optab->handlers[(int) SImode].libfunc
......@@ -4478,978 +3481,14 @@ init_optabs ()
= gen_rtx (SYMBOL_REF, Pmode, UMODTI3_LIBCALL);
#endif
#ifdef HAVE_divqf3
if (HAVE_divqf3)
flodiv_optab->handlers[(int) QFmode].insn_code = CODE_FOR_divqf3;
#endif
#ifdef HAVE_divhf3
if (HAVE_divhf3)
flodiv_optab->handlers[(int) HFmode].insn_code = CODE_FOR_divhf3;
#endif
#ifdef HAVE_divsf3
if (HAVE_divsf3)
flodiv_optab->handlers[(int) SFmode].insn_code = CODE_FOR_divsf3;
#endif
#ifdef HAVE_divdf3
if (HAVE_divdf3)
flodiv_optab->handlers[(int) DFmode].insn_code = CODE_FOR_divdf3;
#endif
#ifdef HAVE_divxf3
if (HAVE_divxf3)
flodiv_optab->handlers[(int) XFmode].insn_code = CODE_FOR_divxf3;
#endif
#ifdef HAVE_divtf3
if (HAVE_divtf3)
flodiv_optab->handlers[(int) TFmode].insn_code = CODE_FOR_divtf3;
#endif
init_floating_libfuncs (flodiv_optab, "div", '3');
#ifdef HAVE_ftruncqf2
if (HAVE_ftruncqf2)
ftrunc_optab->handlers[(int) QFmode].insn_code = CODE_FOR_ftruncqf2;
#endif
#ifdef HAVE_ftrunchf2
if (HAVE_ftrunchf2)
ftrunc_optab->handlers[(int) HFmode].insn_code = CODE_FOR_ftrunchf3;
#endif
#ifdef HAVE_ftruncsf2
if (HAVE_ftruncsf2)
ftrunc_optab->handlers[(int) SFmode].insn_code = CODE_FOR_ftruncsf2;
#endif
#ifdef HAVE_ftruncdf2
if (HAVE_ftruncdf2)
ftrunc_optab->handlers[(int) DFmode].insn_code = CODE_FOR_ftruncdf2;
#endif
#ifdef HAVE_ftruncxf2
if (HAVE_ftruncxf2)
ftrunc_optab->handlers[(int) XFmode].insn_code = CODE_FOR_ftruncxf2;
#endif
#ifdef HAVE_ftrunctf2
if (HAVE_ftrunctf2)
ftrunc_optab->handlers[(int) TFmode].insn_code = CODE_FOR_ftrunctf2;
#endif
init_floating_libfuncs (ftrunc_optab, "ftrunc", '2');
#ifdef HAVE_andqi3
if (HAVE_andqi3)
and_optab->handlers[(int) QImode].insn_code = CODE_FOR_andqi3;
#endif
#ifdef HAVE_andhi3
if (HAVE_andhi3)
and_optab->handlers[(int) HImode].insn_code = CODE_FOR_andhi3;
#endif
#ifdef HAVE_andpsi3
if (HAVE_andpsi3)
and_optab->handlers[(int) PSImode].insn_code = CODE_FOR_andpsi3;
#endif
#ifdef HAVE_andsi3
if (HAVE_andsi3)
and_optab->handlers[(int) SImode].insn_code = CODE_FOR_andsi3;
#endif
#ifdef HAVE_anddi3
if (HAVE_anddi3)
and_optab->handlers[(int) DImode].insn_code = CODE_FOR_anddi3;
#endif
#ifdef HAVE_andti3
if (HAVE_andti3)
and_optab->handlers[(int) TImode].insn_code = CODE_FOR_andti3;
#endif
init_integral_libfuncs (and_optab, "and", '3');
#ifdef HAVE_iorqi3
if (HAVE_iorqi3)
ior_optab->handlers[(int) QImode].insn_code = CODE_FOR_iorqi3;
#endif
#ifdef HAVE_iorhi3
if (HAVE_iorhi3)
ior_optab->handlers[(int) HImode].insn_code = CODE_FOR_iorhi3;
#endif
#ifdef HAVE_iorpsi3
if (HAVE_iorpsi3)
ior_optab->handlers[(int) PSImode].insn_code = CODE_FOR_iorpsi3;
#endif
#ifdef HAVE_iorsi3
if (HAVE_iorsi3)
ior_optab->handlers[(int) SImode].insn_code = CODE_FOR_iorsi3;
#endif
#ifdef HAVE_iordi3
if (HAVE_iordi3)
ior_optab->handlers[(int) DImode].insn_code = CODE_FOR_iordi3;
#endif
#ifdef HAVE_iorti3
if (HAVE_iorti3)
ior_optab->handlers[(int) TImode].insn_code = CODE_FOR_iorti3;
#endif
init_integral_libfuncs (ior_optab, "ior", '3');
#ifdef HAVE_xorqi3
if (HAVE_xorqi3)
xor_optab->handlers[(int) QImode].insn_code = CODE_FOR_xorqi3;
#endif
#ifdef HAVE_xorhi3
if (HAVE_xorhi3)
xor_optab->handlers[(int) HImode].insn_code = CODE_FOR_xorhi3;
#endif
#ifdef HAVE_xorpsi3
if (HAVE_xorpsi3)
xor_optab->handlers[(int) PSImode].insn_code = CODE_FOR_xorpsi3;
#endif
#ifdef HAVE_xorsi3
if (HAVE_xorsi3)
xor_optab->handlers[(int) SImode].insn_code = CODE_FOR_xorsi3;
#endif
#ifdef HAVE_xordi3
if (HAVE_xordi3)
xor_optab->handlers[(int) DImode].insn_code = CODE_FOR_xordi3;
#endif
#ifdef HAVE_xorti3
if (HAVE_xorti3)
xor_optab->handlers[(int) TImode].insn_code = CODE_FOR_xorti3;
#endif
init_integral_libfuncs (xor_optab, "xor", '3');
#ifdef HAVE_ashlqi3
if (HAVE_ashlqi3)
ashl_optab->handlers[(int) QImode].insn_code = CODE_FOR_ashlqi3;
#endif
#ifdef HAVE_ashlhi3
if (HAVE_ashlhi3)
ashl_optab->handlers[(int) HImode].insn_code = CODE_FOR_ashlhi3;
#endif
#ifdef HAVE_ashlpsi3
if (HAVE_ashlpsi3)
ashl_optab->handlers[(int) PSImode].insn_code = CODE_FOR_ashlpsi3;
#endif
#ifdef HAVE_ashlsi3
if (HAVE_ashlsi3)
ashl_optab->handlers[(int) SImode].insn_code = CODE_FOR_ashlsi3;
#endif
#ifdef HAVE_ashldi3
if (HAVE_ashldi3)
ashl_optab->handlers[(int) DImode].insn_code = CODE_FOR_ashldi3;
#endif
#ifdef HAVE_ashlti3
if (HAVE_ashlti3)
ashl_optab->handlers[(int) TImode].insn_code = CODE_FOR_ashlti3;
#endif
init_integral_libfuncs (ashl_optab, "ashl", '3');
#ifdef HAVE_ashrqi3
if (HAVE_ashrqi3)
ashr_optab->handlers[(int) QImode].insn_code = CODE_FOR_ashrqi3;
#endif
#ifdef HAVE_ashrhi3
if (HAVE_ashrhi3)
ashr_optab->handlers[(int) HImode].insn_code = CODE_FOR_ashrhi3;
#endif
#ifdef HAVE_ashrpsi3
if (HAVE_ashrpsi3)
ashr_optab->handlers[(int) PSImode].insn_code = CODE_FOR_ashrpsi3;
#endif
#ifdef HAVE_ashrsi3
if (HAVE_ashrsi3)
ashr_optab->handlers[(int) SImode].insn_code = CODE_FOR_ashrsi3;
#endif
#ifdef HAVE_ashrdi3
if (HAVE_ashrdi3)
ashr_optab->handlers[(int) DImode].insn_code = CODE_FOR_ashrdi3;
#endif
#ifdef HAVE_ashrti3
if (HAVE_ashrti3)
ashr_optab->handlers[(int) TImode].insn_code = CODE_FOR_ashrti3;
#endif
init_integral_libfuncs (ashr_optab, "ashr", '3');
#ifdef HAVE_lshlqi3
if (HAVE_lshlqi3)
lshl_optab->handlers[(int) QImode].insn_code = CODE_FOR_lshlqi3;
#endif
#ifdef HAVE_lshlhi3
if (HAVE_lshlhi3)
lshl_optab->handlers[(int) HImode].insn_code = CODE_FOR_lshlhi3;
#endif
#ifdef HAVE_lshlpsi3
if (HAVE_lshlpsi3)
lshl_optab->handlers[(int) PSImode].insn_code = CODE_FOR_lshlpsi3;
#endif
#ifdef HAVE_lshlsi3
if (HAVE_lshlsi3)
lshl_optab->handlers[(int) SImode].insn_code = CODE_FOR_lshlsi3;
#endif
#ifdef HAVE_lshldi3
if (HAVE_lshldi3)
lshl_optab->handlers[(int) DImode].insn_code = CODE_FOR_lshldi3;
#endif
#ifdef HAVE_lshlti3
if (HAVE_lshlti3)
lshl_optab->handlers[(int) TImode].insn_code = CODE_FOR_lshlti3;
#endif
init_integral_libfuncs (lshl_optab, "lshl", '3');
#ifdef HAVE_lshrqi3
if (HAVE_lshrqi3)
lshr_optab->handlers[(int) QImode].insn_code = CODE_FOR_lshrqi3;
#endif
#ifdef HAVE_lshrhi3
if (HAVE_lshrhi3)
lshr_optab->handlers[(int) HImode].insn_code = CODE_FOR_lshrhi3;
#endif
#ifdef HAVE_lshrpsi3
if (HAVE_lshrpsi3)
lshr_optab->handlers[(int) PSImode].insn_code = CODE_FOR_lshrpsi3;
#endif
#ifdef HAVE_lshrsi3
if (HAVE_lshrsi3)
lshr_optab->handlers[(int) SImode].insn_code = CODE_FOR_lshrsi3;
#endif
#ifdef HAVE_lshrdi3
if (HAVE_lshrdi3)
lshr_optab->handlers[(int) DImode].insn_code = CODE_FOR_lshrdi3;
#endif
#ifdef HAVE_lshrti3
if (HAVE_lshrti3)
lshr_optab->handlers[(int) TImode].insn_code = CODE_FOR_lshrti3;
#endif
init_integral_libfuncs (lshr_optab, "lshr", '3');
#ifdef HAVE_rotlqi3
if (HAVE_rotlqi3)
rotl_optab->handlers[(int) QImode].insn_code = CODE_FOR_rotlqi3;
#endif
#ifdef HAVE_rotlhi3
if (HAVE_rotlhi3)
rotl_optab->handlers[(int) HImode].insn_code = CODE_FOR_rotlhi3;
#endif
#ifdef HAVE_rotlpsi3
if (HAVE_rotlpsi3)
rotl_optab->handlers[(int) PSImode].insn_code = CODE_FOR_rotlpsi3;
#endif
#ifdef HAVE_rotlsi3
if (HAVE_rotlsi3)
rotl_optab->handlers[(int) SImode].insn_code = CODE_FOR_rotlsi3;
#endif
#ifdef HAVE_rotldi3
if (HAVE_rotldi3)
rotl_optab->handlers[(int) DImode].insn_code = CODE_FOR_rotldi3;
#endif
#ifdef HAVE_rotlti3
if (HAVE_rotlti3)
rotl_optab->handlers[(int) TImode].insn_code = CODE_FOR_rotlti3;
#endif
init_integral_libfuncs (rotl_optab, "rotl", '3');
#ifdef HAVE_rotrqi3
if (HAVE_rotrqi3)
rotr_optab->handlers[(int) QImode].insn_code = CODE_FOR_rotrqi3;
#endif
#ifdef HAVE_rotrhi3
if (HAVE_rotrhi3)
rotr_optab->handlers[(int) HImode].insn_code = CODE_FOR_rotrhi3;
#endif
#ifdef HAVE_rotrpsi3
if (HAVE_rotrpsi3)
rotr_optab->handlers[(int) PSImode].insn_code = CODE_FOR_rotrpsi3;
#endif
#ifdef HAVE_rotrsi3
if (HAVE_rotrsi3)
rotr_optab->handlers[(int) SImode].insn_code = CODE_FOR_rotrsi3;
#endif
#ifdef HAVE_rotrdi3
if (HAVE_rotrdi3)
rotr_optab->handlers[(int) DImode].insn_code = CODE_FOR_rotrdi3;
#endif
#ifdef HAVE_rotrti3
if (HAVE_rotrti3)
rotr_optab->handlers[(int) TImode].insn_code = CODE_FOR_rotrti3;
#endif
init_integral_libfuncs (rotr_optab, "rotr", '3');
#ifdef HAVE_sminqi3
if (HAVE_sminqi3)
smin_optab->handlers[(int) QImode].insn_code = CODE_FOR_sminqi3;
#endif
#ifdef HAVE_sminhi3
if (HAVE_sminhi3)
smin_optab->handlers[(int) HImode].insn_code = CODE_FOR_sminhi3;
#endif
#ifdef HAVE_sminsi3
if (HAVE_sminsi3)
smin_optab->handlers[(int) SImode].insn_code = CODE_FOR_sminsi3;
#endif
#ifdef HAVE_smindi3
if (HAVE_smindi3)
smin_optab->handlers[(int) DImode].insn_code = CODE_FOR_smindi3;
#endif
#ifdef HAVE_sminti3
if (HAVE_sminti3)
smin_optab->handlers[(int) TImode].insn_code = CODE_FOR_sminti3;
#endif
#ifdef HAVE_minqf3
if (HAVE_minqf3)
smin_optab->handlers[(int) QFmode].insn_code = CODE_FOR_minqf3;
#endif
#ifdef HAVE_minhf3
if (HAVE_minhf3)
smin_optab->handlers[(int) HFmode].insn_code = CODE_FOR_minhf3;
#endif
#ifdef HAVE_minsf3
if (HAVE_minsf3)
smin_optab->handlers[(int) SFmode].insn_code = CODE_FOR_minsf3;
#endif
#ifdef HAVE_mindf3
if (HAVE_mindf3)
smin_optab->handlers[(int) DFmode].insn_code = CODE_FOR_mindf3;
#endif
#ifdef HAVE_minxf3
if (HAVE_minxf3)
smin_optab->handlers[(int) XFmode].insn_code = CODE_FOR_minxf3;
#endif
#ifdef HAVE_mintf3
if (HAVE_mintf3)
smin_optab->handlers[(int) TFmode].insn_code = CODE_FOR_mintf3;
#endif
init_integral_libfuncs (smin_optab, "min", '3');
init_floating_libfuncs (smin_optab, "min", '3');
#ifdef HAVE_smaxqi3
if (HAVE_smaxqi3)
smax_optab->handlers[(int) QImode].insn_code = CODE_FOR_smaxqi3;
#endif
#ifdef HAVE_smaxhi3
if (HAVE_smaxhi3)
smax_optab->handlers[(int) HImode].insn_code = CODE_FOR_smaxhi3;
#endif
#ifdef HAVE_smaxsi3
if (HAVE_smaxsi3)
smax_optab->handlers[(int) SImode].insn_code = CODE_FOR_smaxsi3;
#endif
#ifdef HAVE_smaxdi3
if (HAVE_smaxdi3)
smax_optab->handlers[(int) DImode].insn_code = CODE_FOR_smaxdi3;
#endif
#ifdef HAVE_smaxti3
if (HAVE_smaxti3)
smax_optab->handlers[(int) TImode].insn_code = CODE_FOR_smaxti3;
#endif
#ifdef HAVE_maxqf3
if (HAVE_maxqf3)
smax_optab->handlers[(int) QFmode].insn_code = CODE_FOR_maxqf3;
#endif
#ifdef HAVE_maxhf3
if (HAVE_maxhf3)
smax_optab->handlers[(int) HFmode].insn_code = CODE_FOR_maxhf3;
#endif
#ifdef HAVE_maxsf3
if (HAVE_maxsf3)
smax_optab->handlers[(int) SFmode].insn_code = CODE_FOR_maxsf3;
#endif
#ifdef HAVE_maxdf3
if (HAVE_maxdf3)
smax_optab->handlers[(int) DFmode].insn_code = CODE_FOR_maxdf3;
#endif
#ifdef HAVE_maxxf3
if (HAVE_maxxf3)
smax_optab->handlers[(int) XFmode].insn_code = CODE_FOR_maxxf3;
#endif
#ifdef HAVE_maxtf3
if (HAVE_maxtf3)
smax_optab->handlers[(int) TFmode].insn_code = CODE_FOR_maxtf3;
#endif
init_integral_libfuncs (smax_optab, "max", '3');
init_floating_libfuncs (smax_optab, "max", '3');
#ifdef HAVE_uminqi3
if (HAVE_uminqi3)
umin_optab->handlers[(int) QImode].insn_code = CODE_FOR_uminqi3;
#endif
#ifdef HAVE_uminhi3
if (HAVE_uminhi3)
umin_optab->handlers[(int) HImode].insn_code = CODE_FOR_uminhi3;
#endif
#ifdef HAVE_uminsi3
if (HAVE_uminsi3)
umin_optab->handlers[(int) SImode].insn_code = CODE_FOR_uminsi3;
#endif
#ifdef HAVE_umindi3
if (HAVE_umindi3)
umin_optab->handlers[(int) DImode].insn_code = CODE_FOR_umindi3;
#endif
#ifdef HAVE_uminti3
if (HAVE_uminti3)
umin_optab->handlers[(int) TImode].insn_code = CODE_FOR_uminti3;
#endif
init_integral_libfuncs (umin_optab, "umin", '3');
#ifdef HAVE_umaxqi3
if (HAVE_umaxqi3)
umax_optab->handlers[(int) QImode].insn_code = CODE_FOR_umaxqi3;
#endif
#ifdef HAVE_umaxhi3
if (HAVE_umaxhi3)
umax_optab->handlers[(int) HImode].insn_code = CODE_FOR_umaxhi3;
#endif
#ifdef HAVE_umaxsi3
if (HAVE_umaxsi3)
umax_optab->handlers[(int) SImode].insn_code = CODE_FOR_umaxsi3;
#endif
#ifdef HAVE_umaxdi3
if (HAVE_umaxdi3)
umax_optab->handlers[(int) DImode].insn_code = CODE_FOR_umaxdi3;
#endif
#ifdef HAVE_umaxti3
if (HAVE_umaxti3)
umax_optab->handlers[(int) TImode].insn_code = CODE_FOR_umaxti3;
#endif
init_integral_libfuncs (umax_optab, "umax", '3');
#ifdef HAVE_negqi2
if (HAVE_negqi2)
neg_optab->handlers[(int) QImode].insn_code = CODE_FOR_negqi2;
#endif
#ifdef HAVE_neghi2
if (HAVE_neghi2)
neg_optab->handlers[(int) HImode].insn_code = CODE_FOR_neghi2;
#endif
#ifdef HAVE_negpsi2
if (HAVE_negpsi2)
neg_optab->handlers[(int) PSImode].insn_code = CODE_FOR_negpsi2;
#endif
#ifdef HAVE_negsi2
if (HAVE_negsi2)
neg_optab->handlers[(int) SImode].insn_code = CODE_FOR_negsi2;
#endif
#ifdef HAVE_negdi2
if (HAVE_negdi2)
neg_optab->handlers[(int) DImode].insn_code = CODE_FOR_negdi2;
#endif
#ifdef HAVE_negti2
if (HAVE_negti2)
neg_optab->handlers[(int) TImode].insn_code = CODE_FOR_negti2;
#endif
#ifdef HAVE_negqf2
if (HAVE_negqf2)
neg_optab->handlers[(int) QFmode].insn_code = CODE_FOR_negqf2;
#endif
#ifdef HAVE_neghf2
if (HAVE_neghf2)
neg_optab->handlers[(int) HFmode].insn_code = CODE_FOR_neghf2;
#endif
#ifdef HAVE_negsf2
if (HAVE_negsf2)
neg_optab->handlers[(int) SFmode].insn_code = CODE_FOR_negsf2;
#endif
#ifdef HAVE_negdf2
if (HAVE_negdf2)
neg_optab->handlers[(int) DFmode].insn_code = CODE_FOR_negdf2;
#endif
#ifdef HAVE_negxf2
if (HAVE_negxf2)
neg_optab->handlers[(int) XFmode].insn_code = CODE_FOR_negxf2;
#endif
#ifdef HAVE_negtf2
if (HAVE_negtf2)
neg_optab->handlers[(int) TFmode].insn_code = CODE_FOR_negtf2;
#endif
init_integral_libfuncs (neg_optab, "neg", '2');
init_floating_libfuncs (neg_optab, "neg", '2');
#ifdef HAVE_absqi2
if (HAVE_absqi2)
abs_optab->handlers[(int) QImode].insn_code = CODE_FOR_absqi2;
#endif
#ifdef HAVE_abshi2
if (HAVE_abshi2)
abs_optab->handlers[(int) HImode].insn_code = CODE_FOR_abshi2;
#endif
#ifdef HAVE_abspsi2
if (HAVE_abspsi2)
abs_optab->handlers[(int) PSImode].insn_code = CODE_FOR_abspsi2;
#endif
#ifdef HAVE_abssi2
if (HAVE_abssi2)
abs_optab->handlers[(int) SImode].insn_code = CODE_FOR_abssi2;
#endif
#ifdef HAVE_absdi2
if (HAVE_absdi2)
abs_optab->handlers[(int) DImode].insn_code = CODE_FOR_absdi2;
#endif
#ifdef HAVE_absti2
if (HAVE_absti2)
abs_optab->handlers[(int) TImode].insn_code = CODE_FOR_absti2;
#endif
#ifdef HAVE_absqf2
if (HAVE_absqf2)
abs_optab->handlers[(int) QFmode].insn_code = CODE_FOR_absqf2;
#endif
#ifdef HAVE_abshf2
if (HAVE_abshf2)
abs_optab->handlers[(int) HFmode].insn_code = CODE_FOR_abshf2;
#endif
#ifdef HAVE_abssf2
if (HAVE_abssf2)
abs_optab->handlers[(int) SFmode].insn_code = CODE_FOR_abssf2;
#endif
#ifdef HAVE_absdf2
if (HAVE_absdf2)
abs_optab->handlers[(int) DFmode].insn_code = CODE_FOR_absdf2;
#endif
#ifdef HAVE_absxf2
if (HAVE_absxf2)
abs_optab->handlers[(int) XFmode].insn_code = CODE_FOR_absxf2;
#endif
#ifdef HAVE_abstf2
if (HAVE_abstf2)
abs_optab->handlers[(int) TFmode].insn_code = CODE_FOR_abstf2;
#endif
/* Use cabs for DC complex abs, since systems generally have cabs.
Don't define any libcall for SCmode, so that cabs will be used. */
abs_optab->handlers[(int) DCmode].libfunc
= gen_rtx (SYMBOL_REF, Pmode, "cabs");
#ifdef HAVE_sqrtqi2
if (HAVE_sqrtqi2)
sqrt_optab->handlers[(int) QImode].insn_code = CODE_FOR_sqrtqi2;
#endif
#ifdef HAVE_sqrthi2
if (HAVE_sqrthi2)
sqrt_optab->handlers[(int) HImode].insn_code = CODE_FOR_sqrthi2;
#endif
#ifdef HAVE_sqrtpsi2
if (HAVE_sqrtpsi2)
sqrt_optab->handlers[(int) PSImode].insn_code = CODE_FOR_sqrtpsi2;
#endif
#ifdef HAVE_sqrtsi2
if (HAVE_sqrtsi2)
sqrt_optab->handlers[(int) SImode].insn_code = CODE_FOR_sqrtsi2;
#endif
#ifdef HAVE_sqrtdi2
if (HAVE_sqrtdi2)
sqrt_optab->handlers[(int) DImode].insn_code = CODE_FOR_sqrtdi2;
#endif
#ifdef HAVE_sqrtti2
if (HAVE_sqrtti2)
sqrt_optab->handlers[(int) TImode].insn_code = CODE_FOR_sqrtti2;
#endif
#ifdef HAVE_sqrtqf2
if (HAVE_sqrtqf2)
sqrt_optab->handlers[(int) QFmode].insn_code = CODE_FOR_sqrtqf2;
#endif
#ifdef HAVE_sqrthf2
if (HAVE_sqrthf2)
sqrt_optab->handlers[(int) HFmode].insn_code = CODE_FOR_sqrthf2;
#endif
#ifdef HAVE_sqrtsf2
if (HAVE_sqrtsf2)
sqrt_optab->handlers[(int) SFmode].insn_code = CODE_FOR_sqrtsf2;
#endif
#ifdef HAVE_sqrtdf2
if (HAVE_sqrtdf2)
sqrt_optab->handlers[(int) DFmode].insn_code = CODE_FOR_sqrtdf2;
#endif
#ifdef HAVE_sqrttf2
if (HAVE_sqrttf2)
sqrt_optab->handlers[(int) TFmode].insn_code = CODE_FOR_sqrttf2;
#endif
/* No library calls here! If there is no sqrt instruction expand_builtin
should force the library call. */
#ifdef HAVE_sinqf2
if (HAVE_sinqf2)
sin_optab->handlers[(int) QFmode].insn_code = CODE_FOR_sinqf2;
#endif
#ifdef HAVE_sinhf2
if (HAVE_sinhf2)
sin_optab->handlers[(int) HFmode].insn_code = CODE_FOR_sinhf2;
#endif
#ifdef HAVE_sinsf2
if (HAVE_sinsf2)
sin_optab->handlers[(int) SFmode].insn_code = CODE_FOR_sinsf2;
#endif
#ifdef HAVE_sindf2
if (HAVE_sindf2)
sin_optab->handlers[(int) DFmode].insn_code = CODE_FOR_sindf2;
#endif
#ifdef HAVE_sintf2
if (HAVE_sintf2)
sin_optab->handlers[(int) TFmode].insn_code = CODE_FOR_sintf2;
#endif
/* No library calls here! If there is no sin instruction expand_builtin
should force the library call. */
#ifdef HAVE_cosqf2
if (HAVE_cosqf2)
cos_optab->handlers[(int) QFmode].insn_code = CODE_FOR_cosqf2;
#endif
#ifdef HAVE_coshf2
if (HAVE_coshf2)
cos_optab->handlers[(int) HFmode].insn_code = CODE_FOR_coshf2;
#endif
#ifdef HAVE_cossf2
if (HAVE_cossf2)
cos_optab->handlers[(int) SFmode].insn_code = CODE_FOR_cossf2;
#endif
#ifdef HAVE_cosdf2
if (HAVE_cosdf2)
cos_optab->handlers[(int) DFmode].insn_code = CODE_FOR_cosdf2;
#endif
#ifdef HAVE_costf2
if (HAVE_costf2)
cos_optab->handlers[(int) TFmode].insn_code = CODE_FOR_costf2;
#endif
/* No library calls here! If there is no cos instruction expand_builtin
should force the library call. */
#ifdef HAVE_strlenqi
if (HAVE_strlenqi)
strlen_optab->handlers[(int) QImode].insn_code = CODE_FOR_strlenqi;
#endif
#ifdef HAVE_strlenhi
if (HAVE_strlenhi)
strlen_optab->handlers[(int) HImode].insn_code = CODE_FOR_strlenhi;
#endif
#ifdef HAVE_strlenpsi
if (HAVE_strlenpsi)
strlen_optab->handlers[(int) PSImode].insn_code = CODE_FOR_strlenpsi;
#endif
#ifdef HAVE_strlensi
if (HAVE_strlensi)
strlen_optab->handlers[(int) SImode].insn_code = CODE_FOR_strlensi;
#endif
#ifdef HAVE_strlendi
if (HAVE_strlendi)
strlen_optab->handlers[(int) DImode].insn_code = CODE_FOR_strlendi;
#endif
#ifdef HAVE_strlenti
if (HAVE_strlenti)
strlen_optab->handlers[(int) TImode].insn_code = CODE_FOR_strlenti;
#endif
/* No library calls here! If there is no strlen instruction expand_builtin
should force the library call. */
#ifdef HAVE_one_cmplqi2
if (HAVE_one_cmplqi2)
one_cmpl_optab->handlers[(int) QImode].insn_code = CODE_FOR_one_cmplqi2;
#endif
#ifdef HAVE_one_cmplhi2
if (HAVE_one_cmplhi2)
one_cmpl_optab->handlers[(int) HImode].insn_code = CODE_FOR_one_cmplhi2;
#endif
#ifdef HAVE_one_cmplpsi2
if (HAVE_one_cmplpsi2)
one_cmpl_optab->handlers[(int) PSImode].insn_code = CODE_FOR_one_cmplpsi2;
#endif
#ifdef HAVE_one_cmplsi2
if (HAVE_one_cmplsi2)
one_cmpl_optab->handlers[(int) SImode].insn_code = CODE_FOR_one_cmplsi2;
#endif
#ifdef HAVE_one_cmpldi2
if (HAVE_one_cmpldi2)
one_cmpl_optab->handlers[(int) DImode].insn_code = CODE_FOR_one_cmpldi2;
#endif
#ifdef HAVE_one_cmplti2
if (HAVE_one_cmplti2)
one_cmpl_optab->handlers[(int) TImode].insn_code = CODE_FOR_one_cmplti2;
#endif
init_integral_libfuncs (one_cmpl_optab, "one_cmpl", '2');
#ifdef HAVE_ffsqi2
if (HAVE_ffsqi2)
ffs_optab->handlers[(int) QImode].insn_code = CODE_FOR_ffsqi2;
#endif
#ifdef HAVE_ffshi2
if (HAVE_ffshi2)
ffs_optab->handlers[(int) HImode].insn_code = CODE_FOR_ffshi2;
#endif
#ifdef HAVE_ffspsi2
if (HAVE_ffspsi2)
ffs_optab->handlers[(int) PSImode].insn_code = CODE_FOR_ffspsi2;
#endif
#ifdef HAVE_ffssi2
if (HAVE_ffssi2)
ffs_optab->handlers[(int) SImode].insn_code = CODE_FOR_ffssi2;
#endif
#ifdef HAVE_ffsdi2
if (HAVE_ffsdi2)
ffs_optab->handlers[(int) DImode].insn_code = CODE_FOR_ffsdi2;
#endif
#ifdef HAVE_ffsti2
if (HAVE_ffsti2)
ffs_optab->handlers[(int) TImode].insn_code = CODE_FOR_ffsti2;
#endif
init_integral_libfuncs (ffs_optab, "ffs", '2');
ffs_optab->handlers[(int) SImode].libfunc
ffs_optab->handlers[(int) mode_for_size (BITS_PER_WORD, MODE_INT, 0)] .libfunc
= gen_rtx (SYMBOL_REF, Pmode, "ffs");
#ifdef HAVE_movqi
if (HAVE_movqi)
mov_optab->handlers[(int) QImode].insn_code = CODE_FOR_movqi;
#endif
#ifdef HAVE_movhi
if (HAVE_movhi)
mov_optab->handlers[(int) HImode].insn_code = CODE_FOR_movhi;
#endif
#ifdef HAVE_movpsi
if (HAVE_movpsi)
mov_optab->handlers[(int) PSImode].insn_code = CODE_FOR_movpsi;
#endif
#ifdef HAVE_movsi
if (HAVE_movsi)
mov_optab->handlers[(int) SImode].insn_code = CODE_FOR_movsi;
#endif
#ifdef HAVE_movdi
if (HAVE_movdi)
mov_optab->handlers[(int) DImode].insn_code = CODE_FOR_movdi;
#endif
#ifdef HAVE_movti
if (HAVE_movti)
mov_optab->handlers[(int) TImode].insn_code = CODE_FOR_movti;
#endif
#ifdef HAVE_movqf
if (HAVE_movqf)
mov_optab->handlers[(int) QFmode].insn_code = CODE_FOR_movqf;
#endif
#ifdef HAVE_movhf
if (HAVE_movhf)
mov_optab->handlers[(int) HFmode].insn_code = CODE_FOR_movhf;
#endif
#ifdef HAVE_movsf
if (HAVE_movsf)
mov_optab->handlers[(int) SFmode].insn_code = CODE_FOR_movsf;
#endif
#ifdef HAVE_movdf
if (HAVE_movdf)
mov_optab->handlers[(int) DFmode].insn_code = CODE_FOR_movdf;
#endif
#ifdef HAVE_movxf
if (HAVE_movxf)
mov_optab->handlers[(int) XFmode].insn_code = CODE_FOR_movxf;
#endif
#ifdef HAVE_movtf
if (HAVE_movtf)
mov_optab->handlers[(int) TFmode].insn_code = CODE_FOR_movtf;
#endif
#ifdef HAVE_movcc
if (HAVE_movcc)
mov_optab->handlers[(int) CCmode].insn_code = CODE_FOR_movcc;
#endif
#ifdef EXTRA_CC_MODES
init_mov_optab ();
#endif
#ifdef HAVE_movstrictqi
if (HAVE_movstrictqi)
movstrict_optab->handlers[(int) QImode].insn_code = CODE_FOR_movstrictqi;
#endif
#ifdef HAVE_movstricthi
if (HAVE_movstricthi)
movstrict_optab->handlers[(int) HImode].insn_code = CODE_FOR_movstricthi;
#endif
#ifdef HAVE_movstrictpsi
if (HAVE_movstrictpsi)
movstrict_optab->handlers[(int) PSImode].insn_code = CODE_FOR_movstrictpsi;
#endif
#ifdef HAVE_movstrictsi
if (HAVE_movstrictsi)
movstrict_optab->handlers[(int) SImode].insn_code = CODE_FOR_movstrictsi;
#endif
#ifdef HAVE_movstrictdi
if (HAVE_movstrictdi)
movstrict_optab->handlers[(int) DImode].insn_code = CODE_FOR_movstrictdi;
#endif
#ifdef HAVE_movstrictti
if (HAVE_movstrictti)
movstrict_optab->handlers[(int) TImode].insn_code = CODE_FOR_movstrictti;
#endif
#ifdef HAVE_cmpqi
if (HAVE_cmpqi)
cmp_optab->handlers[(int) QImode].insn_code = CODE_FOR_cmpqi;
#endif
#ifdef HAVE_cmphi
if (HAVE_cmphi)
cmp_optab->handlers[(int) HImode].insn_code = CODE_FOR_cmphi;
#endif
#ifdef HAVE_cmppsi
if (HAVE_cmppsi)
cmp_optab->handlers[(int) PSImode].insn_code = CODE_FOR_cmppsi;
#endif
#ifdef HAVE_cmpsi
if (HAVE_cmpsi)
cmp_optab->handlers[(int) SImode].insn_code = CODE_FOR_cmpsi;
#endif
#ifdef HAVE_cmpdi
if (HAVE_cmpdi)
cmp_optab->handlers[(int) DImode].insn_code = CODE_FOR_cmpdi;
#endif
#ifdef HAVE_cmpti
if (HAVE_cmpti)
cmp_optab->handlers[(int) TImode].insn_code = CODE_FOR_cmpti;
#endif
#ifdef HAVE_cmpqf
if (HAVE_cmpqf)
cmp_optab->handlers[(int) QFmode].insn_code = CODE_FOR_cmpqf;
#endif
#ifdef HAVE_cmphf
if (HAVE_cmphf)
cmp_optab->handlers[(int) HFmode].insn_code = CODE_FOR_cmphf;
#endif
#ifdef HAVE_cmpsf
if (HAVE_cmpsf)
cmp_optab->handlers[(int) SFmode].insn_code = CODE_FOR_cmpsf;
#endif
#ifdef HAVE_cmpdf
if (HAVE_cmpdf)
cmp_optab->handlers[(int) DFmode].insn_code = CODE_FOR_cmpdf;
#endif
#ifdef HAVE_cmpxf
if (HAVE_cmpxf)
cmp_optab->handlers[(int) XFmode].insn_code = CODE_FOR_cmpxf;
#endif
#ifdef HAVE_cmptf
if (HAVE_cmptf)
cmp_optab->handlers[(int) TFmode].insn_code = CODE_FOR_cmptf;
#endif
/* Comparison libcalls for integers MUST come in pairs, signed/unsigned. */
init_integral_libfuncs (cmp_optab, "cmp", '2');
init_integral_libfuncs (ucmp_optab, "ucmp", '2');
init_floating_libfuncs (cmp_optab, "cmp", '2');
#ifdef HAVE_tstqi
if (HAVE_tstqi)
tst_optab->handlers[(int) QImode].insn_code = CODE_FOR_tstqi;
#endif
#ifdef HAVE_tsthi
if (HAVE_tsthi)
tst_optab->handlers[(int) HImode].insn_code = CODE_FOR_tsthi;
#endif
#ifdef HAVE_tstpsi
if (HAVE_tstpsi)
tst_optab->handlers[(int) PSImode].insn_code = CODE_FOR_tstpsi;
#endif
#ifdef HAVE_tstsi
if (HAVE_tstsi)
tst_optab->handlers[(int) SImode].insn_code = CODE_FOR_tstsi;
#endif
#ifdef HAVE_tstdi
if (HAVE_tstdi)
tst_optab->handlers[(int) DImode].insn_code = CODE_FOR_tstdi;
#endif
#ifdef HAVE_tstti
if (HAVE_tstti)
tst_optab->handlers[(int) TImode].insn_code = CODE_FOR_tstti;
#endif
#ifdef HAVE_tstqf
if (HAVE_tstqf)
tst_optab->handlers[(int) QFmode].insn_code = CODE_FOR_tstqf;
#endif
#ifdef HAVE_tsthf
if (HAVE_tsthf)
tst_optab->handlers[(int) HFmode].insn_code = CODE_FOR_tsthf;
#endif
#ifdef HAVE_tstsf
if (HAVE_tstsf)
tst_optab->handlers[(int) SFmode].insn_code = CODE_FOR_tstsf;
#endif
#ifdef HAVE_tstdf
if (HAVE_tstdf)
tst_optab->handlers[(int) DFmode].insn_code = CODE_FOR_tstdf;
#endif
#ifdef HAVE_tstxf
if (HAVE_tstxf)
tst_optab->handlers[(int) XFmode].insn_code = CODE_FOR_tstxf;
#endif
#ifdef HAVE_tsttf
if (HAVE_tsttf)
tst_optab->handlers[(int) TFmode].insn_code = CODE_FOR_tsttf;
#endif
#ifdef HAVE_beq
if (HAVE_beq)
bcc_gen_fctn[(int) EQ] = gen_beq;
#endif
#ifdef HAVE_bne
if (HAVE_bne)
bcc_gen_fctn[(int) NE] = gen_bne;
#endif
#ifdef HAVE_bgt
if (HAVE_bgt)
bcc_gen_fctn[(int) GT] = gen_bgt;
#endif
#ifdef HAVE_bge
if (HAVE_bge)
bcc_gen_fctn[(int) GE] = gen_bge;
#endif
#ifdef HAVE_bgtu
if (HAVE_bgtu)
bcc_gen_fctn[(int) GTU] = gen_bgtu;
#endif
#ifdef HAVE_bgeu
if (HAVE_bgeu)
bcc_gen_fctn[(int) GEU] = gen_bgeu;
#endif
#ifdef HAVE_blt
if (HAVE_blt)
bcc_gen_fctn[(int) LT] = gen_blt;
#endif
#ifdef HAVE_ble
if (HAVE_ble)
bcc_gen_fctn[(int) LE] = gen_ble;
#endif
#ifdef HAVE_bltu
if (HAVE_bltu)
bcc_gen_fctn[(int) LTU] = gen_bltu;
#endif
#ifdef HAVE_bleu
if (HAVE_bleu)
bcc_gen_fctn[(int) LEU] = gen_bleu;
#endif
for (i = 0; i < NUM_RTX_CODE; i++)
setcc_gen_code[i] = CODE_FOR_nothing;
#ifdef HAVE_seq
if (HAVE_seq)
setcc_gen_code[(int) EQ] = CODE_FOR_seq;
#endif
#ifdef HAVE_sne
if (HAVE_sne)
setcc_gen_code[(int) NE] = CODE_FOR_sne;
#endif
#ifdef HAVE_sgt
if (HAVE_sgt)
setcc_gen_code[(int) GT] = CODE_FOR_sgt;
#endif
#ifdef HAVE_sge
if (HAVE_sge)
setcc_gen_code[(int) GE] = CODE_FOR_sge;
#endif
#ifdef HAVE_sgtu
if (HAVE_sgtu)
setcc_gen_code[(int) GTU] = CODE_FOR_sgtu;
#endif
#ifdef HAVE_sgeu
if (HAVE_sgeu)
setcc_gen_code[(int) GEU] = CODE_FOR_sgeu;
#endif
#ifdef HAVE_slt
if (HAVE_slt)
setcc_gen_code[(int) LT] = CODE_FOR_slt;
#endif
#ifdef HAVE_sle
if (HAVE_sle)
setcc_gen_code[(int) LE] = CODE_FOR_sle;
#endif
#ifdef HAVE_sltu
if (HAVE_sltu)
setcc_gen_code[(int) LTU] = CODE_FOR_sltu;
#endif
#ifdef HAVE_sleu
if (HAVE_sleu)
setcc_gen_code[(int) LEU] = CODE_FOR_sleu;
#endif
extendsfdf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__extendsfdf2");
extendsfxf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__extendsfxf2");
extendsftf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__extendsftf2");
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment