From b092b4717cb4f5345447ac9c4f0a362fb50df7cd Mon Sep 17 00:00:00 2001 From: Jim Wilson Date: Mon, 22 Jun 1992 17:28:39 -0700 Subject: [PATCH] *** empty log message *** From-SVN: r1237 --- gcc/expr.c | 101 +++++++- gcc/expr.h | 66 ++++- gcc/optabs.c | 676 ++++++++++++++++++++++++++++++++++++++++++--------- 3 files changed, 723 insertions(+), 120 deletions(-) diff --git a/gcc/expr.c b/gcc/expr.c index 4cdbd76cd9b..eadbccac7ad 100644 --- a/gcc/expr.c +++ b/gcc/expr.c @@ -355,6 +355,13 @@ convert_move (to, from, unsignedp) return; } #endif +#ifdef HAVE_extendsfxf2 + if (HAVE_extendsfxf2 && from_mode == SFmode && to_mode == XFmode) + { + emit_unop_insn (CODE_FOR_extendsfxf2, to, from, UNKNOWN); + return; + } +#endif #ifdef HAVE_extendsftf2 if (HAVE_extendsftf2 && from_mode == SFmode && to_mode == TFmode) { @@ -362,6 +369,13 @@ convert_move (to, from, unsignedp) return; } #endif +#ifdef HAVE_extenddfxf2 + if (HAVE_extenddfxf2 && from_mode == DFmode && to_mode == XFmode) + { + emit_unop_insn (CODE_FOR_extenddfxf2, to, from, UNKNOWN); + return; + } +#endif #ifdef HAVE_extenddftf2 if (HAVE_extenddftf2 && from_mode == DFmode && to_mode == TFmode) { @@ -376,6 +390,13 @@ convert_move (to, from, unsignedp) return; } #endif +#ifdef HAVE_truncxfsf2 + if (HAVE_truncxfsf2 && from_mode == XFmode && to_mode == SFmode) + { + emit_unop_insn (CODE_FOR_truncxfsf2, to, from, UNKNOWN); + return; + } +#endif #ifdef HAVE_trunctfsf2 if (HAVE_trunctfsf2 && from_mode == TFmode && to_mode == SFmode) { @@ -383,6 +404,13 @@ convert_move (to, from, unsignedp) return; } #endif +#ifdef HAVE_truncxfdf2 + if (HAVE_truncxfdf2 && from_mode == XFmode && to_mode == DFmode) + { + emit_unop_insn (CODE_FOR_truncxfdf2, to, from, UNKNOWN); + return; + } +#endif #ifdef HAVE_trunctfdf2 if (HAVE_trunctfdf2 && from_mode == TFmode && to_mode == DFmode) { @@ -391,13 +419,72 @@ convert_move (to, from, unsignedp) } #endif - if (from_mode == SFmode && to_mode == DFmode) - libcall = extendsfdf2_libfunc; - else if (from_mode == DFmode && to_mode == SFmode) - libcall = truncdfsf2_libfunc; - else - /* This conversion is not implemented yet. There aren't any TFmode - library calls. */ + libcall = (rtx) 0; + switch (from_mode) + { + case SFmode: + switch (to_mode) + { + case DFmode: + libcall = extendsfdf2_libfunc; + break; + + case XFmode: + libcall = extendsfxf2_libfunc; + break; + + case TFmode: + libcall = extendsftf2_libfunc; + break; + } + break; + + case DFmode: + switch (to_mode) + { + case SFmode: + libcall = truncdfsf2_libfunc; + break; + + case XFmode: + libcall = extenddfxf2_libfunc; + break; + + case TFmode: + libcall = extenddftf2_libfunc; + break; + } + break; + + case XFmode: + switch (to_mode) + { + case SFmode: + libcall = truncxfsf2_libfunc; + break; + + case DFmode: + libcall = truncxfdf2_libfunc; + break; + } + break; + + case TFmode: + switch (to_mode) + { + case SFmode: + libcall = trunctfsf2_libfunc; + break; + + case DFmode: + libcall = trunctfdf2_libfunc; + break; + } + break; + } + + if (libcall == (rtx) 0) + /* This conversion is not implemented yet. */ abort (); emit_library_call (libcall, 1, to_mode, 1, from, from_mode); diff --git a/gcc/expr.h b/gcc/expr.h index da440ec3472..2e5ae99c6bf 100644 --- a/gcc/expr.h +++ b/gcc/expr.h @@ -341,37 +341,99 @@ enum optab_methods implicitly and not via optabs. */ extern rtx extendsfdf2_libfunc; +extern rtx extendsfxf2_libfunc; +extern rtx extendsftf2_libfunc; +extern rtx extenddfxf2_libfunc; +extern rtx extenddftf2_libfunc; + extern rtx truncdfsf2_libfunc; +extern rtx truncxfsf2_libfunc; +extern rtx trunctfsf2_libfunc; +extern rtx truncxfdf2_libfunc; +extern rtx trunctfdf2_libfunc; + extern rtx memcpy_libfunc; extern rtx bcopy_libfunc; extern rtx memcmp_libfunc; extern rtx bcmp_libfunc; extern rtx memset_libfunc; extern rtx bzero_libfunc; + extern rtx eqsf2_libfunc; extern rtx nesf2_libfunc; extern rtx gtsf2_libfunc; extern rtx gesf2_libfunc; extern rtx ltsf2_libfunc; extern rtx lesf2_libfunc; + extern rtx eqdf2_libfunc; extern rtx nedf2_libfunc; extern rtx gtdf2_libfunc; extern rtx gedf2_libfunc; extern rtx ltdf2_libfunc; extern rtx ledf2_libfunc; -extern rtx floatdisf_libfunc; + +extern rtx eqxf2_libfunc; +extern rtx nexf2_libfunc; +extern rtx gtxf2_libfunc; +extern rtx gexf2_libfunc; +extern rtx ltxf2_libfunc; +extern rtx lexf2_libfunc; + +extern rtx eqtf2_libfunc; +extern rtx netf2_libfunc; +extern rtx gttf2_libfunc; +extern rtx getf2_libfunc; +extern rtx lttf2_libfunc; +extern rtx letf2_libfunc; + extern rtx floatsisf_libfunc; -extern rtx floatdidf_libfunc; +extern rtx floatdisf_libfunc; +extern rtx floattisf_libfunc; + extern rtx floatsidf_libfunc; +extern rtx floatdidf_libfunc; +extern rtx floattidf_libfunc; + +extern rtx floatsixf_libfunc; +extern rtx floatdixf_libfunc; +extern rtx floattixf_libfunc; + +extern rtx floatsitf_libfunc; +extern rtx floatditf_libfunc; +extern rtx floattitf_libfunc; + extern rtx fixsfsi_libfunc; extern rtx fixsfdi_libfunc; +extern rtx fixsfti_libfunc; + extern rtx fixdfsi_libfunc; extern rtx fixdfdi_libfunc; +extern rtx fixdfti_libfunc; + +extern rtx fixxfsi_libfunc; +extern rtx fixxfdi_libfunc; +extern rtx fixxfti_libfunc; + +extern rtx fixtfsi_libfunc; +extern rtx fixtfdi_libfunc; +extern rtx fixtfti_libfunc; + extern rtx fixunssfsi_libfunc; extern rtx fixunssfdi_libfunc; +extern rtx fixunssfti_libfunc; + extern rtx fixunsdfsi_libfunc; extern rtx fixunsdfdi_libfunc; +extern rtx fixunsdfti_libfunc; + +extern rtx fixunsxfsi_libfunc; +extern rtx fixunsxfdi_libfunc; +extern rtx fixunsxfti_libfunc; + +extern rtx fixunstfsi_libfunc; +extern rtx fixunstfdi_libfunc; +extern rtx fixunstfti_libfunc; typedef rtx (*rtxfun) (); diff --git a/gcc/optabs.c b/gcc/optabs.c index 0acabde6be2..509ee18c45d 100644 --- a/gcc/optabs.c +++ b/gcc/optabs.c @@ -83,37 +83,99 @@ optab strlen_optab; implicitly and not via optabs. */ rtx extendsfdf2_libfunc; +rtx extendsfxf2_libfunc; +rtx extendsftf2_libfunc; +rtx extenddfxf2_libfunc; +rtx extenddftf2_libfunc; + rtx truncdfsf2_libfunc; +rtx truncxfsf2_libfunc; +rtx trunctfsf2_libfunc; +rtx truncxfdf2_libfunc; +rtx trunctfdf2_libfunc; + rtx memcpy_libfunc; rtx bcopy_libfunc; rtx memcmp_libfunc; rtx bcmp_libfunc; rtx memset_libfunc; rtx bzero_libfunc; + rtx eqsf2_libfunc; rtx nesf2_libfunc; rtx gtsf2_libfunc; rtx gesf2_libfunc; rtx ltsf2_libfunc; rtx lesf2_libfunc; + rtx eqdf2_libfunc; rtx nedf2_libfunc; rtx gtdf2_libfunc; rtx gedf2_libfunc; rtx ltdf2_libfunc; rtx ledf2_libfunc; -rtx floatdisf_libfunc; + +rtx eqxf2_libfunc; +rtx nexf2_libfunc; +rtx gtxf2_libfunc; +rtx gexf2_libfunc; +rtx ltxf2_libfunc; +rtx lexf2_libfunc; + +rtx eqtf2_libfunc; +rtx netf2_libfunc; +rtx gttf2_libfunc; +rtx getf2_libfunc; +rtx lttf2_libfunc; +rtx letf2_libfunc; + rtx floatsisf_libfunc; -rtx floatdidf_libfunc; +rtx floatdisf_libfunc; +rtx floattisf_libfunc; + rtx floatsidf_libfunc; +rtx floatdidf_libfunc; +rtx floattidf_libfunc; + +rtx floatsixf_libfunc; +rtx floatdixf_libfunc; +rtx floattixf_libfunc; + +rtx floatsitf_libfunc; +rtx floatditf_libfunc; +rtx floattitf_libfunc; + rtx fixsfsi_libfunc; rtx fixsfdi_libfunc; +rtx fixsfti_libfunc; + rtx fixdfsi_libfunc; rtx fixdfdi_libfunc; +rtx fixdfti_libfunc; + +rtx fixxfsi_libfunc; +rtx fixxfdi_libfunc; +rtx fixxfti_libfunc; + +rtx fixtfsi_libfunc; +rtx fixtfdi_libfunc; +rtx fixtfti_libfunc; + rtx fixunssfsi_libfunc; rtx fixunssfdi_libfunc; +rtx fixunssfti_libfunc; + rtx fixunsdfsi_libfunc; rtx fixunsdfdi_libfunc; +rtx fixunsdfti_libfunc; + +rtx fixunsxfsi_libfunc; +rtx fixunsxfdi_libfunc; +rtx fixunsxfti_libfunc; + +rtx fixunstfsi_libfunc; +rtx fixunstfdi_libfunc; +rtx fixunstfti_libfunc; /* Indexed by the rtx-code for a conditional (eg. EQ, LT,...) gives the gen_function to make a branch to test that condition. */ @@ -1709,6 +1771,60 @@ emit_float_lib_cmp (x, y, comparison) libfunc = ledf2_libfunc; break; } + else if (mode == XFmode) + switch (comparison) + { + case EQ: + libfunc = eqxf2_libfunc; + break; + + case NE: + libfunc = nexf2_libfunc; + break; + + case GT: + libfunc = gtxf2_libfunc; + break; + + case GE: + libfunc = gexf2_libfunc; + break; + + case LT: + libfunc = ltxf2_libfunc; + break; + + case LE: + libfunc = lexf2_libfunc; + break; + } + else if (mode == TFmode) + switch (comparison) + { + case EQ: + libfunc = eqtf2_libfunc; + break; + + case NE: + libfunc = netf2_libfunc; + break; + + case GT: + libfunc = gttf2_libfunc; + break; + + case GE: + libfunc = getf2_libfunc; + break; + + case LT: + libfunc = lttf2_libfunc; + break; + + case LE: + libfunc = letf2_libfunc; + break; + } else { enum machine_mode wider_mode; @@ -2090,6 +2206,27 @@ init_fixtab () 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; @@ -2149,6 +2286,27 @@ init_fixtab () 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; @@ -2208,6 +2366,27 @@ init_fixtab () 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; @@ -2267,6 +2446,27 @@ init_fixtab () 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; @@ -2352,6 +2552,27 @@ init_floattab () 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; @@ -2415,6 +2636,27 @@ init_floattab () 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; @@ -2541,8 +2783,8 @@ expand_float (to, from, unsignedp) else #endif - /* No hardware instruction available; call a library - to convert from SImode or DImode into SFmode or DFmode. */ + /* No hardware instruction available; call a library rotine to convert from + SImode, DImode, or TImode into SFmode, DFmode, XFmode, or TFmode. */ { rtx libfcn; rtx insns; @@ -2563,6 +2805,8 @@ expand_float (to, from, unsignedp) libfcn = floatsisf_libfunc; else if (GET_MODE (from) == DImode) libfcn = floatdisf_libfunc; + else if (GET_MODE (from) == TImode) + libfcn = floattisf_libfunc; else abort (); } @@ -2572,6 +2816,30 @@ expand_float (to, from, unsignedp) libfcn = floatsidf_libfunc; else if (GET_MODE (from) == DImode) libfcn = floatdidf_libfunc; + else if (GET_MODE (from) == TImode) + libfcn = floattidf_libfunc; + else + abort (); + } + else if (GET_MODE (to) == XFmode) + { + if (GET_MODE (from) == SImode) + libfcn = floatsixf_libfunc; + else if (GET_MODE (from) == DImode) + libfcn = floatdixf_libfunc; + else if (GET_MODE (from) == TImode) + libfcn = floattixf_libfunc; + else + abort (); + } + else if (GET_MODE (to) == TFmode) + { + if (GET_MODE (from) == SImode) + libfcn = floatsitf_libfunc; + else if (GET_MODE (from) == DImode) + libfcn = floatditf_libfunc; + else if (GET_MODE (from) == TImode) + libfcn = floattitf_libfunc; else abort (); } @@ -2749,6 +3017,8 @@ expand_fix (to, from, unsignedp) libfcn = unsignedp ? fixunssfsi_libfunc : fixsfsi_libfunc; else if (GET_MODE (to) == DImode) libfcn = unsignedp ? fixunssfdi_libfunc : fixsfdi_libfunc; + else if (GET_MODE (to) == TImode) + libfcn = unsignedp ? fixunssfti_libfunc : fixsfti_libfunc; else abort (); } @@ -2758,6 +3028,30 @@ expand_fix (to, from, unsignedp) libfcn = unsignedp ? fixunsdfsi_libfunc : fixdfsi_libfunc; else if (GET_MODE (to) == DImode) libfcn = unsignedp ? fixunsdfdi_libfunc : fixdfdi_libfunc; + else if (GET_MODE (to) == TImode) + libfcn = unsignedp ? fixunsdfti_libfunc : fixdfti_libfunc; + else + abort (); + } + else if (GET_MODE (from) == XFmode) + { + if (GET_MODE (to) == SImode) + libfcn = unsignedp ? fixunsxfsi_libfunc : fixxfsi_libfunc; + else if (GET_MODE (to) == DImode) + libfcn = unsignedp ? fixunsxfdi_libfunc : fixxfdi_libfunc; + else if (GET_MODE (to) == TImode) + libfcn = unsignedp ? fixunsxfti_libfunc : fixxfti_libfunc; + else + abort (); + } + else if (GET_MODE (from) == TFmode) + { + if (GET_MODE (to) == SImode) + libfcn = unsignedp ? fixunstfsi_libfunc : fixtfsi_libfunc; + else if (GET_MODE (to) == DImode) + libfcn = unsignedp ? fixunstfdi_libfunc : fixtfdi_libfunc; + else if (GET_MODE (to) == TImode) + libfcn = unsignedp ? fixunstfti_libfunc : fixtfti_libfunc; else abort (); } @@ -2806,6 +3100,85 @@ init_optab (code) return op; } +/* Initialize the libfunc fields of an entire group of entries in some + optab. Each entry is set equal to a string consisting of a leading + pair of underscores followed by a generic operation name followed by + a mode name (downshifted to lower case) followed by a single character + representing the number of operands for the given operation (which is + usually one of the characters '2', '3', or '4'). + + OPTABLE is the table in which libfunc fields are to be initialized. + FIRST_MODE is the first machine mode index in the given optab to + initialize. + LAST_MODE is the last machine mode index in the given optab to + initialize. + OPNAME is the generic (string) name of the operation. + SUFFIX is the character which specifies the number of operands for + the given generic operation. +*/ + +static void +init_libfuncs (optable, first_mode, last_mode, opname, suffix) + register optab optable; + register char *opname; + register enum machine_mode first_mode; + register enum machine_mode last_mode; + register char suffix; +{ + register enum machine_mode mode; + register unsigned opname_len = strlen (opname); + + for (mode = first_mode; mode <= last_mode; mode++) + { + register char *mname = mode_name[(int) mode]; + register unsigned mname_len = strlen (mname); + register char *libfunc_name + = (char *) xmalloc (2 + opname_len + mname_len + 1 + 1); + register char *p; + register char *q; + + p = libfunc_name; + *p++ = '_'; + *p++ = '_'; + for (q = opname; *q; ) + *p++ = *q++; + for (q = mname; *q; q++) + *p++ = tolower (*q); + *p++ = suffix; + *p++ = '\0'; + optable->handlers[(int) mode].libfunc + = gen_rtx (SYMBOL_REF, Pmode, libfunc_name); + } +} + +/* Initialize the libfunc fields of an entire group of entries in some + optab which correspond to all integer mode operations. The parameters + have the same meaning as similarly named ones for the `init_libfuncs' + routine. (See above). */ + +static void +init_integral_libfuncs (optable, opname, suffix) + register optab optable; + register char *opname; + register char suffix; +{ + init_libfuncs (optable, SImode, TImode, opname, suffix); +} + +/* Initialize the libfunc fields of an entire group of entries in some + optab which correspond to all real mode operations. The parameters + have the same meaning as similarly named ones for the `init_libfuncs' + routine. (See above). */ + +static void +init_floating_libfuncs (optable, opname, suffix) + register optab optable; + register char *opname; + register char suffix; +{ + init_libfuncs (optable, SFmode, TFmode, opname, suffix); +} + /* Call this once to initialize the contents of the optabs appropriately for the current target machine. */ @@ -2888,14 +3261,16 @@ init_optabs () if (HAVE_adddf3) add_optab->handlers[(int) DFmode].insn_code = CODE_FOR_adddf3; #endif +#ifdef HAVE_addxf3 + if (HAVE_addxf3) + add_optab->handlers[(int) XFmode].insn_code = CODE_FOR_addxf3; +#endif #ifdef HAVE_addtf3 if (HAVE_addtf3) add_optab->handlers[(int) TFmode].insn_code = CODE_FOR_addtf3; #endif - add_optab->handlers[(int) SFmode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__addsf3"); - add_optab->handlers[(int) DFmode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__adddf3"); + init_integral_libfuncs (add_optab, "add", '3'); + init_floating_libfuncs (add_optab, "add", '3'); #ifdef HAVE_subqi3 if (HAVE_subqi3) @@ -2929,14 +3304,16 @@ init_optabs () 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 - sub_optab->handlers[(int) SFmode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__subsf3"); - sub_optab->handlers[(int) DFmode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__subdf3"); + init_integral_libfuncs (sub_optab, "sub", '3'); + init_floating_libfuncs (sub_optab, "sub", '3'); #ifdef HAVE_mulqi3 if (HAVE_mulqi3) @@ -2970,29 +3347,29 @@ init_optabs () 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'); #ifdef MULSI3_LIBCALL smul_optab->handlers[(int) SImode].libfunc = gen_rtx (SYMBOL_REF, Pmode, MULSI3_LIBCALL); -#else - smul_optab->handlers[(int) SImode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__mulsi3"); #endif #ifdef MULDI3_LIBCALL smul_optab->handlers[(int) DImode].libfunc = gen_rtx (SYMBOL_REF, Pmode, MULDI3_LIBCALL); -#else - smul_optab->handlers[(int) DImode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__muldi3"); #endif - smul_optab->handlers[(int) SFmode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__mulsf3"); - smul_optab->handlers[(int) DFmode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__muldf3"); +#ifdef MULTI3_LIBCALL + smul_optab->handlers[(int) TImode].libfunc + = gen_rtx (SYMBOL_REF, Pmode, MULTI3_LIBCALL); +#endif #ifdef HAVE_mulqihi3 if (HAVE_mulqihi3) @@ -3052,20 +3429,19 @@ init_optabs () 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); -#else - sdiv_optab->handlers[(int) SImode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__divsi3"); #endif #ifdef DIVDI3_LIBCALL sdiv_optab->handlers[(int) DImode].libfunc = gen_rtx (SYMBOL_REF, Pmode, DIVDI3_LIBCALL); -#else - sdiv_optab->handlers[(int) DImode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__divdi3"); +#endif +#ifdef DIVTI3_LIBCALL + sdiv_optab->handlers[(int) TImode].libfunc + = gen_rtx (SYMBOL_REF, Pmode, DIVTI3_LIBCALL); #endif #ifdef HAVE_udivqi3 @@ -3092,20 +3468,19 @@ init_optabs () 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); -#else - udiv_optab->handlers[(int) SImode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__udivsi3"); #endif #ifdef UDIVDI3_LIBCALL udiv_optab->handlers[(int) DImode].libfunc = gen_rtx (SYMBOL_REF, Pmode, UDIVDI3_LIBCALL); -#else - udiv_optab->handlers[(int) DImode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__udivdi3"); +#endif +#ifdef UDIVTI3_LIBCALL + udiv_optab->handlers[(int) TImode].libfunc + = gen_rtx (SYMBOL_REF, Pmode, UDIVTI3_LIBCALL); #endif #ifdef HAVE_divmodqi4 @@ -3128,6 +3503,7 @@ init_optabs () 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) @@ -3149,6 +3525,7 @@ init_optabs () 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) @@ -3174,20 +3551,19 @@ init_optabs () 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 = gen_rtx (SYMBOL_REF, Pmode, MODSI3_LIBCALL); -#else - smod_optab->handlers[(int) SImode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__modsi3"); #endif #ifdef MODDI3_LIBCALL smod_optab->handlers[(int) DImode].libfunc = gen_rtx (SYMBOL_REF, Pmode, MODDI3_LIBCALL); -#else - smod_optab->handlers[(int) DImode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__moddi3"); +#endif +#ifdef MODTI3_LIBCALL + smod_optab->handlers[(int) TImode].libfunc + = gen_rtx (SYMBOL_REF, Pmode, MODTI3_LIBCALL); #endif #ifdef HAVE_umodqi3 @@ -3214,20 +3590,19 @@ init_optabs () 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 = gen_rtx (SYMBOL_REF, Pmode, UMODSI3_LIBCALL); -#else - umod_optab->handlers[(int) SImode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__umodsi3"); #endif #ifdef UMODDI3_LIBCALL umod_optab->handlers[(int) DImode].libfunc = gen_rtx (SYMBOL_REF, Pmode, UMODDI3_LIBCALL); -#else - umod_optab->handlers[(int) DImode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__umoddi3"); +#endif +#ifdef UMODTI3_LIBCALL + umod_optab->handlers[(int) TImode].libfunc + = gen_rtx (SYMBOL_REF, Pmode, UMODTI3_LIBCALL); #endif #ifdef HAVE_divsf3 @@ -3238,14 +3613,15 @@ init_optabs () 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 - flodiv_optab->handlers[(int) SFmode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__divsf3"); - flodiv_optab->handlers[(int) DFmode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__divdf3"); + init_floating_libfuncs (flodiv_optab, "div", '3'); #ifdef HAVE_ftruncsf2 if (HAVE_ftruncsf2) @@ -3255,10 +3631,15 @@ init_optabs () 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) @@ -3284,6 +3665,7 @@ init_optabs () 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) @@ -3309,6 +3691,7 @@ init_optabs () 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) @@ -3334,6 +3717,7 @@ init_optabs () 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) @@ -3359,10 +3743,7 @@ init_optabs () if (HAVE_ashlti3) ashl_optab->handlers[(int) TImode].insn_code = CODE_FOR_ashlti3; #endif - ashl_optab->handlers[(int) SImode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__ashlsi3"); - ashl_optab->handlers[(int) DImode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__ashldi3"); + init_integral_libfuncs (ashl_optab, "ashl", '3'); #ifdef HAVE_ashrqi3 if (HAVE_ashrqi3) @@ -3388,10 +3769,7 @@ init_optabs () if (HAVE_ashrti3) ashr_optab->handlers[(int) TImode].insn_code = CODE_FOR_ashrti3; #endif - ashr_optab->handlers[(int) SImode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__ashrsi3"); - ashr_optab->handlers[(int) DImode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__ashrdi3"); + init_integral_libfuncs (ashr_optab, "ashr", '3'); #ifdef HAVE_lshlqi3 if (HAVE_lshlqi3) @@ -3417,10 +3795,7 @@ init_optabs () if (HAVE_lshlti3) lshl_optab->handlers[(int) TImode].insn_code = CODE_FOR_lshlti3; #endif - lshl_optab->handlers[(int) SImode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__lshlsi3"); - lshl_optab->handlers[(int) DImode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__lshldi3"); + init_integral_libfuncs (lshl_optab, "lshl", '3'); #ifdef HAVE_lshrqi3 if (HAVE_lshrqi3) @@ -3446,10 +3821,7 @@ init_optabs () if (HAVE_lshrti3) lshr_optab->handlers[(int) TImode].insn_code = CODE_FOR_lshrti3; #endif - lshr_optab->handlers[(int) SImode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__lshrsi3"); - lshr_optab->handlers[(int) DImode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__lshrdi3"); + init_integral_libfuncs (lshr_optab, "lshr", '3'); #ifdef HAVE_rotlqi3 if (HAVE_rotlqi3) @@ -3475,10 +3847,7 @@ init_optabs () if (HAVE_rotlti3) rotl_optab->handlers[(int) TImode].insn_code = CODE_FOR_rotlti3; #endif - rotl_optab->handlers[(int) SImode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__rotlsi3"); - rotl_optab->handlers[(int) DImode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__rotldi3"); + init_integral_libfuncs (rotl_optab, "rotl", '3'); #ifdef HAVE_rotrqi3 if (HAVE_rotrqi3) @@ -3504,10 +3873,7 @@ init_optabs () if (HAVE_rotrti3) rotr_optab->handlers[(int) TImode].insn_code = CODE_FOR_rotrti3; #endif - rotr_optab->handlers[(int) SImode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__rotrsi3"); - rotr_optab->handlers[(int) DImode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__rotrdi3"); + init_integral_libfuncs (rotr_optab, "rotr", '3'); #ifdef HAVE_sminqi3 if (HAVE_sminqi3) @@ -3529,18 +3895,24 @@ init_optabs () if (HAVE_sminti3) smin_optab->handlers[(int) TImode].insn_code = CODE_FOR_sminti3; #endif -#ifdef HAVE_sminsf3 - if (HAVE_sminsf3) - smin_optab->handlers[(int) SFmode].insn_code = CODE_FOR_sminsf3; +#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_smindf3 - if (HAVE_smindf3) - smin_optab->handlers[(int) DFmode].insn_code = CODE_FOR_smindf3; +#ifdef HAVE_minxf3 + if (HAVE_minxf3) + smin_optab->handlers[(int) XFmode].insn_code = CODE_FOR_minxf3; #endif -#ifdef HAVE_smintf3 - if (HAVE_smintf3) - smin_optab->handlers[(int) TFmode].insn_code = CODE_FOR_smintf3; +#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) @@ -3562,18 +3934,24 @@ init_optabs () if (HAVE_smaxti3) smax_optab->handlers[(int) TImode].insn_code = CODE_FOR_smaxti3; #endif -#ifdef HAVE_smaxsf3 - if (HAVE_smaxsf3) - smax_optab->handlers[(int) SFmode].insn_code = CODE_FOR_smaxsf3; +#ifdef HAVE_maxsf3 + if (HAVE_maxsf3) + smax_optab->handlers[(int) SFmode].insn_code = CODE_FOR_maxsf3; #endif -#ifdef HAVE_smaxdf3 - if (HAVE_smaxdf3) - smax_optab->handlers[(int) DFmode].insn_code = CODE_FOR_smaxdf3; +#ifdef HAVE_maxdf3 + if (HAVE_maxdf3) + smax_optab->handlers[(int) DFmode].insn_code = CODE_FOR_maxdf3; #endif -#ifdef HAVE_smaxtf3 - if (HAVE_smaxtf3) - smax_optab->handlers[(int) TFmode].insn_code = CODE_FOR_smaxtf3; +#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) @@ -3595,6 +3973,7 @@ init_optabs () 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) @@ -3616,6 +3995,7 @@ init_optabs () 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) @@ -3649,18 +4029,16 @@ init_optabs () 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 - neg_optab->handlers[(int) SImode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__negsi2"); - neg_optab->handlers[(int) DImode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__negdi2"); - neg_optab->handlers[(int) SFmode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__negsf2"); - neg_optab->handlers[(int) DFmode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__negdf2"); + init_integral_libfuncs (neg_optab, "neg", '2'); + init_floating_libfuncs (neg_optab, "neg", '2'); #ifdef HAVE_absqi2 if (HAVE_absqi2) @@ -3694,6 +4072,10 @@ init_optabs () 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; @@ -3791,8 +4173,7 @@ init_optabs () if (HAVE_one_cmplti2) one_cmpl_optab->handlers[(int) TImode].insn_code = CODE_FOR_one_cmplti2; #endif - one_cmpl_optab->handlers[(int) SImode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__one_cmplsi2"); + init_integral_libfuncs (one_cmpl_optab, "one_cmpl", '2'); #ifdef HAVE_ffsqi2 if (HAVE_ffsqi2) @@ -3818,8 +4199,7 @@ init_optabs () if (HAVE_ffsti2) ffs_optab->handlers[(int) TImode].insn_code = CODE_FOR_ffsti2; #endif - ffs_optab->handlers[(int) SImode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "ffs"); + init_integral_libfuncs (ffs_optab, "ffs", '2'); #ifdef HAVE_movqi if (HAVE_movqi) @@ -3853,6 +4233,10 @@ init_optabs () 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; @@ -3923,10 +4307,19 @@ init_optabs () 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; @@ -3959,15 +4352,14 @@ init_optabs () 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 - /* Comparison libcalls for integers MUST come in pairs, signed/unsigned. */ - cmp_optab->handlers[(int) DImode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__cmpdi2"); - ucmp_optab->handlers[(int) DImode].libfunc - = gen_rtx (SYMBOL_REF, Pmode, "__ucmpdi2"); #ifdef HAVE_beq if (HAVE_beq) @@ -4055,37 +4447,99 @@ init_optabs () #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"); + extenddfxf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__extenddfxf2"); + extenddftf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__extenddftf2"); + truncdfsf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__truncdfsf2"); + truncxfsf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__truncxfsf2"); + trunctfsf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__trunctfsf2"); + truncxfdf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__truncxfdf2"); + trunctfdf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__trunctfdf2"); + memcpy_libfunc = gen_rtx (SYMBOL_REF, Pmode, "memcpy"); bcopy_libfunc = gen_rtx (SYMBOL_REF, Pmode, "bcopy"); memcmp_libfunc = gen_rtx (SYMBOL_REF, Pmode, "memcmp"); bcmp_libfunc = gen_rtx (SYMBOL_REF, Pmode, "bcmp"); memset_libfunc = gen_rtx (SYMBOL_REF, Pmode, "memset"); bzero_libfunc = gen_rtx (SYMBOL_REF, Pmode, "bzero"); + eqsf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__eqsf2"); nesf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__nesf2"); gtsf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__gtsf2"); gesf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__gesf2"); ltsf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__ltsf2"); lesf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__lesf2"); + eqdf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__eqdf2"); nedf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__nedf2"); gtdf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__gtdf2"); gedf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__gedf2"); ltdf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__ltdf2"); ledf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__ledf2"); - floatdisf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floatdisf"); + + eqxf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__eqxf2"); + nexf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__nexf2"); + gtxf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__gtxf2"); + gexf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__gexf2"); + ltxf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__ltxf2"); + lexf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__lexf2"); + + eqtf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__eqtf2"); + netf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__netf2"); + gttf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__gttf2"); + getf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__getf2"); + lttf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__lttf2"); + letf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__letf2"); + floatsisf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floatsisf"); - floatdidf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floatdidf"); + floatdisf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floatdisf"); + floattisf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floattisf"); + floatsidf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floatsidf"); + floatdidf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floatdidf"); + floattidf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floattidf"); + + floatsixf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floatsixf"); + floatdixf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floatdixf"); + floattixf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floattixf"); + + floatsitf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floatsitf"); + floatditf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floatditf"); + floattitf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floattitf"); + fixsfsi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixsfsi"); fixsfdi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixsfdi"); + fixsfti_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixsfti"); + fixdfsi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixdfsi"); fixdfdi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixdfdi"); + fixdfti_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixdfti"); + + fixxfsi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixxfsi"); + fixxfdi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixxfdi"); + fixxfti_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixxfti"); + + fixtfsi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixtfsi"); + fixtfdi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixtfdi"); + fixtfti_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixtfti"); + fixunssfsi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunssfsi"); fixunssfdi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunssfdi"); + fixunssfti_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunssfti"); + fixunsdfsi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunsdfsi"); fixunsdfdi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunsdfdi"); + fixunsdfti_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunsdfti"); + + fixunsxfsi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunsxfsi"); + fixunsxfdi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunsxfdi"); + fixunsxfti_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunsxfti"); + + fixunstfsi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunstfsi"); + fixunstfdi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunstfdi"); + fixunstfti_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunstfti"); } #ifdef BROKEN_LDEXP -- 2.30.2