ARM Cortex-M4F sqrtf uses double

Question

I am working on code for a arm Cortex-M4F with a fpv4-sp-d16 and ABI=hard.

As i was looking with Ozone into my elf file I found that my code uses some double precision functions: eg. __aeabi_dmul

If I don't use sqrtf or use the -ffast-math option, the double support function are no longer linked. Since I do not know what other implications the -ffast-math option introduces, I would like to not use that option.

Are there any other option to get a float sqrt function?

Using ARM-GCC 10 2021.10 with -mcpu=cortex-m4 -mthumb -mfloat-abi=hard -mfpu=fpv4-sp-d16 -Os -fsingle-precision-constant -Wfloat-equal -Wdouble-promotion

I found in the Disassembly that inside of sqrtf the __aeabi_ddiv is called.

The suggested solution:

float sqrtf_wrap(float x) __attribute__((optimize("fast-math")));
float sqrtf_wrap(float x)
{
    if(x >= 0.0f)
        return __builtin_sqrtf(x);
    else
       return NAN;
}

does not change the build result: __aeabi_ddiv is still used.

Update/Solution

I found a question where one had the same problem: Double division in sqrtf? [UPDATE]

His solution: Directly calling __ieee754_sqrtf works(there is directly the VSQRT.F32 instruction) for me as well.

Further more I found that sqrtf with -fno-math-errno also works .

Unfortunately a wrapper with local optimization options does Not work - seems that the optimization is not applied to the called math function.

Therefore I will use __ieee754_sqrtf instead of sqrtf

Answer 1

You need to use sqrtf otherwise it will have to convert it to double and call the sqrt.

-ffast-math is not needed to compile correctly - but it enables more optimizations and breaks strict IEEE conformance (https://simonbyrne.github.io/notes/fastmath/)

Example:

float mysqrtf(float x)
{
    return sqrtf(x);
}

Resulting code:

• Without -ffast-math

mysqrtf:
        vcmp.f32        s0, #0
        vmrs    APSR_nzcv, FPSCR
        vmov.f32        s15, s0
        bmi     .L10    //call sqrtf if parameter is negative
        vsqrt.f32       s0, s15
        bx      lr
.L10:
        b       sqrtf

• With -ffast-math

mysqrtf:
        vsqrt.f32       s0, s0  //no checks is parameter is negative. If it is it will generate the exception (Invalid Operation or Inexact exceptions)
        bx      lr

Command line options: -O2 -mcpu=cortex-m4 -mthumb <-ffast-math> -mfloat-abi=hard -mfpu=fpv4-sp-d16

Answer 2

Here is a code snippet which I feel is a good fit to your question.

#include <math.h>

#ifdef __GNUC__
# ifdef __OPTIMIZE__
float sqrtf_wrap(float x) __attribute__((optimize("fast-math")));
# else
float sqrtf_wrap(float x) __attribute__((optimize("1"), optimize("fast-math")));
# endif
float sqrtf_wrap(float x)
{
    if(x >= 0.0f)
      return __builtin_sqrtf(x);
    else 
     return NAN;  
}
#else
 /* ??? link error at least ??? */
#endif

This avoids the call to the internal library 'sqrtf()' which is possibly responsible for the use of double utility functions (such as __aeabi_dmul) needed for a 'single precision' floating point unit.

The wrapper is,

1. Fairly efficient
2. Avoids linking sqrtf() and any dependant calls.
3. It will return 'NAN' when called with in-appropriate arguments.
4. Does not enable fast-math globally.
5. errno is not set on abnormal arguments.

It is dependant on gcc features and is not as maintainable as just a standard sqrtf() call. The main benefit is less code linked in the binary. The presence of functions such as __aeabi_dmul often indicate unintended use of doubles, which is important on a single precision FPU for both code density and speed (accepting less precision). That is to say, it can be an important maintenance feature to examine the lack of double support functions in a linked object or map file and so the wrapper might be an necessary evil.

Also, it is beneficial to use -Wdouble-promotion on a CPU like this especially to determine that float constants have a trailing 'f' to specify single precision (or float versus double constant).