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 103 additions and 2064 deletions
gcc/optabs.c
...@@ -82,6 +82,14 @@ optab tst_optab; ...@@ -82,6 +82,14 @@ optab tst_optab;
optab strlen_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 /* SYMBOL_REF rtx's for the library functions that are called
implicitly and not via optabs. */ implicitly and not via optabs. */
...@@ -196,7 +204,6 @@ enum insn_code setcc_gen_code[NUM_RTX_CODE]; ...@@ -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 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 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, static enum insn_code can_fix_p PROTO((enum machine_mode, enum machine_mode,
int, int *)); int, int *));
static enum insn_code can_float_p PROTO((enum machine_mode, enum machine_mode, static enum insn_code can_float_p PROTO((enum machine_mode, enum machine_mode,
...@@ -2683,9 +2690,6 @@ gen_move_insn (x, y) ...@@ -2683,9 +2690,6 @@ gen_move_insn (x, y)
return seq; 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. /* Return the insn code used to extend FROM_MODE to TO_MODE.
UNSIGNEDP specifies zero-extension instead of sign-extension. If UNSIGNEDP specifies zero-extension instead of sign-extension. If
no such operation exists, CODE_FOR_nothing will be returned. */ no such operation exists, CODE_FOR_nothing will be returned. */
...@@ -2709,111 +2713,14 @@ gen_extend_insn (x, y, mto, mfrom, unsignedp) ...@@ -2709,111 +2713,14 @@ gen_extend_insn (x, y, mto, mfrom, unsignedp)
{ {
return (GEN_FCN (extendtab[(int) mto][(int) mfrom][unsignedp]) (x, y)); 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_fix_p and can_float_p say whether the target machine
can directly convert a given fixed point type to can directly convert a given fixed point type to
a given floating point type, or vice versa. a given floating point type, or vice versa.
The returned value is the CODE_FOR_... value to use, The returned value is the CODE_FOR_... value to use,
or CODE_FOR_nothing if these modes cannot be directly converted. */ 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];
/* *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. */ an explicit FTRUNC insn before the fix insn; otherwise 0. */
static enum insn_code static enum insn_code
...@@ -2841,663 +2748,6 @@ can_float_p (fltmode, fixmode, unsignedp) ...@@ -2841,663 +2748,6 @@ can_float_p (fltmode, fixmode, unsignedp)
{ {
return floattab[(int) fltmode][(int) 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 /* Generate code to convert FROM to floating point
and store in TO. FROM must be fixed point and not VOIDmode. and store in TO. FROM must be fixed point and not VOIDmode.
...@@ -4032,24 +3282,46 @@ init_complex_libfuncs (optable, opname, suffix) ...@@ -4032,24 +3282,46 @@ init_complex_libfuncs (optable, opname, suffix)
void void
init_optabs () init_optabs ()
{ {
int i; int i, j;
enum insn_code *p;
init_fixtab (); /* Start by initializing all tables to contain CODE_FOR_nothing. */
init_floattab ();
init_extends ();
add_optab = init_optab (PLUS); for (p = fixtab[0][0];
sub_optab = init_optab (MINUS); p < fixtab[0][0] + sizeof fixtab / sizeof (fixtab[0][0][0]);
smul_optab = init_optab (MULT); p++)
smul_widen_optab = init_optab (UNKNOWN); *p = CODE_FOR_nothing;
umul_widen_optab = init_optab (UNKNOWN);
sdiv_optab = init_optab (DIV); for (p = fixtrunctab[0][0];
sdivmod_optab = init_optab (UNKNOWN); p < fixtrunctab[0][0] + sizeof fixtrunctab / sizeof (fixtrunctab[0][0][0]);
udiv_optab = init_optab (UDIV); p++)
udivmod_optab = init_optab (UNKNOWN); *p = CODE_FOR_nothing;
smod_optab = init_optab (MOD);
umod_optab = init_optab (UMOD); for (p = floattab[0][0];
flodiv_optab = init_optab (DIV); 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);
smod_optab = init_optab (MOD);
umod_optab = init_optab (UMOD);
flodiv_optab = init_optab (DIV);
ftrunc_optab = init_optab (UNKNOWN); ftrunc_optab = init_optab (UNKNOWN);
and_optab = init_optab (AND); and_optab = init_optab (AND);
ior_optab = init_optab (IOR); ior_optab = init_optab (IOR);
...@@ -4078,158 +3350,69 @@ init_optabs () ...@@ -4078,158 +3350,69 @@ init_optabs ()
cos_optab = init_optab (UNKNOWN); cos_optab = init_optab (UNKNOWN);
strlen_optab = init_optab (UNKNOWN); strlen_optab = init_optab (UNKNOWN);
#ifdef HAVE_addqi3 for (i = 0; i < NUM_MACHINE_MODES; i++)
if (HAVE_addqi3) {
add_optab->handlers[(int) QImode].insn_code = CODE_FOR_addqi3; movstr_optab[i] = CODE_FOR_nothing;
#endif
#ifdef HAVE_addhi3 #ifdef HAVE_SECONDARY_RELOADS
if (HAVE_addhi3) reload_in_optab[i] = reload_out_optab[i] = CODE_FOR_nothing;
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;
#endif #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 #endif
#ifdef HAVE_addtf3
if (HAVE_addtf3) #ifdef EXTRA_CC_MODES
add_optab->handlers[(int) TFmode].insn_code = CODE_FOR_addtf3; init_mov_optab ();
#endif #endif
/* Initialize the optabs with the names of the library functions. */
init_integral_libfuncs (add_optab, "add", '3'); init_integral_libfuncs (add_optab, "add", '3');
init_floating_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_integral_libfuncs (sub_optab, "sub", '3');
init_floating_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_integral_libfuncs (smul_optab, "mul", '3');
init_floating_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 #ifdef MULSI3_LIBCALL
smul_optab->handlers[(int) SImode].libfunc smul_optab->handlers[(int) SImode].libfunc
...@@ -4244,66 +3427,6 @@ init_optabs () ...@@ -4244,66 +3427,6 @@ init_optabs ()
= gen_rtx (SYMBOL_REF, Pmode, MULTI3_LIBCALL); = gen_rtx (SYMBOL_REF, Pmode, MULTI3_LIBCALL);
#endif #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 #ifdef DIVSI3_LIBCALL
sdiv_optab->handlers[(int) SImode].libfunc sdiv_optab->handlers[(int) SImode].libfunc
= gen_rtx (SYMBOL_REF, Pmode, DIVSI3_LIBCALL); = gen_rtx (SYMBOL_REF, Pmode, DIVSI3_LIBCALL);
...@@ -4317,32 +3440,6 @@ init_optabs () ...@@ -4317,32 +3440,6 @@ init_optabs ()
= gen_rtx (SYMBOL_REF, Pmode, DIVTI3_LIBCALL); = gen_rtx (SYMBOL_REF, Pmode, DIVTI3_LIBCALL);
#endif #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 #ifdef UDIVSI3_LIBCALL
udiv_optab->handlers[(int) SImode].libfunc udiv_optab->handlers[(int) SImode].libfunc
= gen_rtx (SYMBOL_REF, Pmode, UDIVSI3_LIBCALL); = gen_rtx (SYMBOL_REF, Pmode, UDIVSI3_LIBCALL);
...@@ -4356,75 +3453,6 @@ init_optabs () ...@@ -4356,75 +3453,6 @@ init_optabs ()
= gen_rtx (SYMBOL_REF, Pmode, UDIVTI3_LIBCALL); = gen_rtx (SYMBOL_REF, Pmode, UDIVTI3_LIBCALL);
#endif #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 #ifdef MODSI3_LIBCALL
smod_optab->handlers[(int) SImode].libfunc smod_optab->handlers[(int) SImode].libfunc
...@@ -4439,31 +3467,6 @@ init_optabs () ...@@ -4439,31 +3467,6 @@ init_optabs ()
= gen_rtx (SYMBOL_REF, Pmode, MODTI3_LIBCALL); = gen_rtx (SYMBOL_REF, Pmode, MODTI3_LIBCALL);
#endif #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 #ifdef UMODSI3_LIBCALL
umod_optab->handlers[(int) SImode].libfunc umod_optab->handlers[(int) SImode].libfunc
...@@ -4478,978 +3481,14 @@ init_optabs () ...@@ -4478,978 +3481,14 @@ init_optabs ()
= gen_rtx (SYMBOL_REF, Pmode, UMODTI3_LIBCALL); = gen_rtx (SYMBOL_REF, Pmode, UMODTI3_LIBCALL);
#endif #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. /* Use cabs for DC complex abs, since systems generally have cabs.
Don't define any libcall for SCmode, so that cabs will be used. */ Don't define any libcall for SCmode, so that cabs will be used. */
abs_optab->handlers[(int) DCmode].libfunc abs_optab->handlers[(int) DCmode].libfunc
= gen_rtx (SYMBOL_REF, Pmode, "cabs"); = gen_rtx (SYMBOL_REF, Pmode, "cabs");
#ifdef HAVE_sqrtqi2 ffs_optab->handlers[(int) mode_for_size (BITS_PER_WORD, MODE_INT, 0)] .libfunc
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
= gen_rtx (SYMBOL_REF, Pmode, "ffs"); = 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"); extendsfdf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__extendsfdf2");
extendsfxf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__extendsfxf2"); extendsfxf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__extendsfxf2");
extendsftf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__extendsftf2"); 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