4.2 Routines for floating point emulation

The software floating point library is used on machines which do not have hardware support for floating point. It is also used whenever -msoft-float is used to disable generation of floating point instructions. (Not all targets support this switch.)

For compatibility with other compilers, the floating point emulation routines can be renamed with the DECLARE_LIBRARY_RENAMES macro (see Library Calls). In this section, the default names are used.

Presently the library does not support XFmode, which is used for long double on some architectures.

4.2.1 Arithmetic functions

— Runtime Function: float __addsf3 (float a, float b)
— Runtime Function: double __adddf3 (double a, double b)
— Runtime Function: long double __addtf3 (long double a, long double b)
— Runtime Function: long double __addxf3 (long double a, long double b)

These functions return the sum of a and b.

— Runtime Function: float __subsf3 (float a, float b)
— Runtime Function: double __subdf3 (double a, double b)
— Runtime Function: long double __subtf3 (long double a, long double b)
— Runtime Function: long double __subxf3 (long double a, long double b)

These functions return the difference between b and a; that is, a - b.

— Runtime Function: float __mulsf3 (float a, float b)
— Runtime Function: double __muldf3 (double a, double b)
— Runtime Function: long double __multf3 (long double a, long double b)
— Runtime Function: long double __mulxf3 (long double a, long double b)

These functions return the product of a and b.

— Runtime Function: float __divsf3 (float a, float b)
— Runtime Function: double __divdf3 (double a, double b)
— Runtime Function: long double __divtf3 (long double a, long double b)
— Runtime Function: long double __divxf3 (long double a, long double b)

These functions return the quotient of a and b; that is, a / b.

— Runtime Function: float __negsf2 (float a)
— Runtime Function: double __negdf2 (double a)
— Runtime Function: long double __negtf2 (long double a)
— Runtime Function: long double __negxf2 (long double a)

These functions return the negation of a. They simply flip the sign bit, so they can produce negative zero and negative NaN.

4.2.2 Conversion functions

— Runtime Function: double __extendsfdf2 (float a)
— Runtime Function: long double __extendsftf2 (float a)
— Runtime Function: long double __extendsfxf2 (float a)
— Runtime Function: long double __extenddftf2 (double a)
— Runtime Function: long double __extenddfxf2 (double a)

These functions extend a to the wider mode of their return type.

— Runtime Function: double __truncxfdf2 (long double a)
— Runtime Function: double __trunctfdf2 (long double a)
— Runtime Function: float __truncxfsf2 (long double a)
— Runtime Function: float __trunctfsf2 (long double a)
— Runtime Function: float __truncdfsf2 (double a)

These functions truncate a to the narrower mode of their return type, rounding toward zero.

— Runtime Function: int __fixsfsi (float a)
— Runtime Function: int __fixdfsi (double a)
— Runtime Function: int __fixtfsi (long double a)
— Runtime Function: int __fixxfsi (long double a)

These functions convert a to a signed integer, rounding toward zero.

— Runtime Function: long __fixsfdi (float a)
— Runtime Function: long __fixdfdi (double a)
— Runtime Function: long __fixtfdi (long double a)
— Runtime Function: long __fixxfdi (long double a)

These functions convert a to a signed long, rounding toward zero.

— Runtime Function: long long __fixsfti (float a)
— Runtime Function: long long __fixdfti (double a)
— Runtime Function: long long __fixtfti (long double a)
— Runtime Function: long long __fixxfti (long double a)

These functions convert a to a signed long long, rounding toward zero.

— Runtime Function: unsigned int __fixunssfsi (float a)
— Runtime Function: unsigned int __fixunsdfsi (double a)
— Runtime Function: unsigned int __fixunstfsi (long double a)
— Runtime Function: unsigned int __fixunsxfsi (long double a)

These functions convert a to an unsigned integer, rounding toward zero. Negative values all become zero.

— Runtime Function: unsigned long __fixunssfdi (float a)
— Runtime Function: unsigned long __fixunsdfdi (double a)
— Runtime Function: unsigned long __fixunstfdi (long double a)
— Runtime Function: unsigned long __fixunsxfdi (long double a)

These functions convert a to an unsigned long, rounding toward zero. Negative values all become zero.

— Runtime Function: unsigned long long __fixunssfti (float a)
— Runtime Function: unsigned long long __fixunsdfti (double a)
— Runtime Function: unsigned long long __fixunstfti (long double a)
— Runtime Function: unsigned long long __fixunsxfti (long double a)

These functions convert a to an unsigned long long, rounding toward zero. Negative values all become zero.

— Runtime Function: float __floatsisf (int i)
— Runtime Function: double __floatsidf (int i)
— Runtime Function: long double __floatsitf (int i)
— Runtime Function: long double __floatsixf (int i)

These functions convert i, a signed integer, to floating point.

— Runtime Function: float __floatdisf (long i)
— Runtime Function: double __floatdidf (long i)
— Runtime Function: long double __floatditf (long i)
— Runtime Function: long double __floatdixf (long i)

These functions convert i, a signed long, to floating point.

— Runtime Function: float __floattisf (long long i)
— Runtime Function: double __floattidf (long long i)
— Runtime Function: long double __floattitf (long long i)
— Runtime Function: long double __floattixf (long long i)

These functions convert i, a signed long long, to floating point.

— Runtime Function: float __floatunsisf (unsigned int i)
— Runtime Function: double __floatunsidf (unsigned int i)
— Runtime Function: long double __floatunsitf (unsigned int i)
— Runtime Function: long double __floatunsixf (unsigned int i)

These functions convert i, an unsigned integer, to floating point.

— Runtime Function: float __floatundisf (unsigned long i)
— Runtime Function: double __floatundidf (unsigned long i)
— Runtime Function: long double __floatunditf (unsigned long i)
— Runtime Function: long double __floatundixf (unsigned long i)

These functions convert i, an unsigned long, to floating point.

— Runtime Function: float __floatuntisf (unsigned long long i)
— Runtime Function: double __floatuntidf (unsigned long long i)
— Runtime Function: long double __floatuntitf (unsigned long long i)
— Runtime Function: long double __floatuntixf (unsigned long long i)

These functions convert i, an unsigned long long, to floating point.

4.2.3 Comparison functions

There are two sets of basic comparison functions.

— Runtime Function: int __cmpsf2 (float a, float b)
— Runtime Function: int __cmpdf2 (double a, double b)
— Runtime Function: int __cmptf2 (long double a, long double b)

These functions calculate a <=> b. That is, if a is less than b, they return −1; if a is greater than b, they return 1; and if a and b are equal they return 0. If either argument is NaN they return 1, but you should not rely on this; if NaN is a possibility, use one of the higher-level comparison functions.

— Runtime Function: int __unordsf2 (float a, float b)
— Runtime Function: int __unorddf2 (double a, double b)
— Runtime Function: int __unordtf2 (long double a, long double b)

These functions return a nonzero value if either argument is NaN, otherwise 0.

There is also a complete group of higher level functions which correspond directly to comparison operators. They implement the ISO C semantics for floating-point comparisons, taking NaN into account. Pay careful attention to the return values defined for each set. Under the hood, all of these routines are implemented as

       if (__unordXf2 (a, b))
         return E;
       return __cmpXf2 (a, b);

where E is a constant chosen to give the proper behavior for NaN. Thus, the meaning of the return value is different for each set. Do not rely on this implementation; only the semantics documented below are guaranteed.

— Runtime Function: int __eqsf2 (float a, float b)
— Runtime Function: int __eqdf2 (double a, double b)
— Runtime Function: int __eqtf2 (long double a, long double b)

These functions return zero if neither argument is NaN, and a and b are equal.

— Runtime Function: int __nesf2 (float a, float b)
— Runtime Function: int __nedf2 (double a, double b)
— Runtime Function: int __netf2 (long double a, long double b)

These functions return a nonzero value if either argument is NaN, or if a and b are unequal.

— Runtime Function: int __gesf2 (float a, float b)
— Runtime Function: int __gedf2 (double a, double b)
— Runtime Function: int __getf2 (long double a, long double b)

These functions return a value greater than or equal to zero if neither argument is NaN, and a is greater than or equal to b.

— Runtime Function: int __ltsf2 (float a, float b)
— Runtime Function: int __ltdf2 (double a, double b)
— Runtime Function: int __lttf2 (long double a, long double b)

These functions return a value less than zero if neither argument is NaN, and a is strictly less than b.

— Runtime Function: int __lesf2 (float a, float b)
— Runtime Function: int __ledf2 (double a, double b)
— Runtime Function: int __letf2 (long double a, long double b)

These functions return a value less than or equal to zero if neither argument is NaN, and a is less than or equal to b.

— Runtime Function: int __gtsf2 (float a, float b)
— Runtime Function: int __gtdf2 (double a, double b)
— Runtime Function: int __gttf2 (long double a, long double b)

These functions return a value greater than zero if neither argument is NaN, and a is strictly greater than b.

4.2.4 Other floating-point functions

— Runtime Function: float __powisf2 (float a, int b)
— Runtime Function: double __powidf2 (double a, int b)
— Runtime Function: long double __powitf2 (long double a, int b)
— Runtime Function: long double __powixf2 (long double a, int b)

These functions convert raise a to the power b.

— Runtime Function: complex float __mulsc3 (float a, float b, float c, float d)
— Runtime Function: complex double __muldc3 (double a, double b, double c, double d)
— Runtime Function: complex long double __multc3 (long double a, long double b, long double c, long double d)
— Runtime Function: complex long double __mulxc3 (long double a, long double b, long double c, long double d)

These functions return the product of a + ib and c + id, following the rules of C99 Annex G.

— Runtime Function: complex float __divsc3 (float a, float b, float c, float d)
— Runtime Function: complex double __divdc3 (double a, double b, double c, double d)
— Runtime Function: complex long double __divtc3 (long double a, long double b, long double c, long double d)
— Runtime Function: complex long double __divxc3 (long double a, long double b, long double c, long double d)

These functions return the quotient of a + ib and c + id (i.e., (a + ib) / (c + id)), following the rules of C99 Annex G.