Soft float library routines (GNU Compiler Collection (GCC) Internals)

### 3.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 Implicit Calls to Library Routines). In this section, the default names are used.

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

#### 3.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.

#### 3.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.

Runtime Function: `void` __fixsfbitint `(`UBILtype` *r, int32_t rprec, float a)` ¶
Runtime Function: `void` __fixdfbitint `(`UBILtype` *r, int32_t rprec, double a)` ¶
Runtime Function: `void` __fixxfbitint `(`UBILtype` *r, int32_t rprec, __float80 a)` ¶
Runtime Function: `void` __fixtfbitint `(`UBILtype` *r, int32_t rprec, _Float128 a)` ¶

  These functions convert a to bit-precise integer r, rounding toward zero. If rprec is positive, it converts to unsigned bit-precise integer and negative values all become zero, if rprec is negative, it converts to signed bit-precise integer.

Runtime Function: `float` __floatbitintsf `(`UBILtype` *i, int32_t iprec)` ¶
Runtime Function: `double` __floatbitintdf `(`UBILtype` *i, int32_t iprec)` ¶
Runtime Function: `__float80` __floatbitintxf `(`UBILtype` *i, int32_t iprec)` ¶
Runtime Function: `_Float128` __floatbitinttf `(`UBILtype` *i, int32_t iprec)` ¶
Runtime Function: `_Float16` __floatbitinthf `(`UBILtype` *i, int32_t iprec)` ¶
Runtime Function: `__bf16` __floatbitintbf `(`UBILtype` *i, int32_t iprec)` ¶

  These functions convert bit-precise integer i to floating point. If iprec is positive, it is conversion from unsigned bit-precise integer, otherwise from signed bit-precise integer.

#### 3.2.3 Comparison functions ¶

There are two sets of basic comparison functions.

Runtime Function: `CMPtype` __cmpsf2 `(float a, float b)` ¶
Runtime Function: `CMPtype` __cmpdf2 `(double a, double b)` ¶
Runtime Function: `CMPtype` __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: `CMPtype` __unordsf2 `(float a, float b)` ¶
Runtime Function: `CMPtype` __unorddf2 `(double a, double b)` ¶
Runtime Function: `CMPtype` __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: `CMPtype` __eqsf2 `(float a, float b)` ¶
Runtime Function: `CMPtype` __eqdf2 `(double a, double b)` ¶
Runtime Function: `CMPtype` __eqtf2 `(long double a, long double b)` ¶

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

Runtime Function: `CMPtype` __nesf2 `(float a, float b)` ¶
Runtime Function: `CMPtype` __nedf2 `(double a, double b)` ¶
Runtime Function: `CMPtype` __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: `CMPtype` __gesf2 `(float a, float b)` ¶
Runtime Function: `CMPtype` __gedf2 `(double a, double b)` ¶
Runtime Function: `CMPtype` __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: `CMPtype` __ltsf2 `(float a, float b)` ¶
Runtime Function: `CMPtype` __ltdf2 `(double a, double b)` ¶
Runtime Function: `CMPtype` __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: `CMPtype` __lesf2 `(float a, float b)` ¶
Runtime Function: `CMPtype` __ledf2 `(double a, double b)` ¶
Runtime Function: `CMPtype` __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: `CMPtype` __gtsf2 `(float a, float b)` ¶
Runtime Function: `CMPtype` __gtdf2 `(double a, double b)` ¶
Runtime Function: `CMPtype` __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.

Comparison functions return a `CMPtype` which is a signed integer of target-dependent size. Typically `CMPtype` will be word-sized, but other backends may override this with the `TARGET_LIBGCC_CMP_RETURN_MODE` hook. Of note, AArch64 uses an single-int as the return type, and AVR uses a quarter-int.

#### 3.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.