float to double conversion in sqrtf

I can reproduce what you reported. The sqrt takes double type as argument, that's why there is float/double conversion functions. The sqrtf takes float type. But there is no fpu instruction even when use sqrtf. I am looking into this.

I am a little bit wrong about "But there is no fpu instruction even when use sqrtf". Indeed there is fsqrts instruction when you call sqrtf rather than sqrt. You may also notice that there is still call to library function sqrtf in code after the fsqrts instruction. This is to ensure the final code is IEEE compatible. To be IEEE compatible, one should check the fpu status register and set errno if there is problem after execution of fsqrts instruction. That's why we call lib function sqrtf.
 If everything is ok, the lib function won't be called. To not generate such call, you need option like "-fno-math-errno" or "-ffast-math".

Some conclusions are:

1). lib function sqrt takes double type arguments and return double type result.
2). lib function sqrtf takes float type arguments and return float type result.
3). those lib functions strictly follow the IEEE and maintain consistent behavior in different platforms.
4). if there is math error during the operation, the ERRNO should be set to be IEEE compatible. The lib function will do it while the fsqrts won't do this.

thanks you for investigating this.

Adding a call to sqrtf in my code increases the program size by 2520 bytes (even with -ffast-math). It's huge when you know that the FPU can do this operation by its own.

In fact, calling sqrtf will use at least these functions (I didn't check the all arm-none-eabi-nm output) :
__aeabi_d2f
 __truncdfsf2
__aeabi_ddiv
__divdf3
__aeabi_dmul
__muldf3
 __adddf3
__aeabi_dadd
__aeabi_dsub
__subdf3

I don't understand is why doubles are used inside sqrtf which deals with floats.

The C code below uses only 54 bytes of flash memory with no call to other functions and no float/double conversions :

float vsqrtf(float op1) {
 if(op1 <= 0.f)
  return 0.f;

 float result;
 __ASM volatile ("vsqrt.f32 %0, %1" : "=w" (result) : "w" (op1) );
 return (result);
}

I don't know how to manage errno but I don't think it will use much more space.

I am kind of confused. If you compile below small case:

terguo01@terry-pc01:tmp$ /work/terguo01/tools/gcc-arm-none-eabi-4_8-2014q1/bin/arm-none-eabi-gcc -mthumb -mcpu=cortex-m4 -mfloat-abi=hard -mfpu=fpv4-sp-d16 -O2 -S y.c -ffast-math
terguo01@terry-pc01:tmp$ vi y.s
terguo01@terry-pc01:tmp$ cat y.c
#include<math.h>

float
mysqrt (float f)
{
  return sqrtf(f);
}

The generated assembly code will be:
mysqrt:
        @ args = 0, pretend = 0, frame = 0
        @ frame_needed = 0, uses_anonymous_args = 0
        @ link register save eliminated.
        fsqrts s0, s0
        bx lr
        .size mysqrt, .-mysqrt

The fsqrts instruction will be used and no need of extra libraries. What kind of options are you using?

this is the list of options I have for GCC (quite the same for G++) :

-O0 -g3 -Wall -ffunction-sections -fdata-sections -Wall -std=gnu99 -Wa,-adhlns="$@.lst" -c -fmessage-length=0 -mcpu=cortex-m4 -mthumb -mfloat-abi=softfp -mfpu=fpv4-sp-d16 -g -ggdb

I don't use optimizations because sometimes weird behaviors happen if I do, and I don't know why (I'm really not an expert of compilers nor assembly)

I just did a quick test and in fact, optimizations need to be turned to use the FPU instruction. The exact same code without optimizations call the sqrtf function in the library

I noticed the same behavior (float/double conversions) in expf function. So a call to expf will add these functions (and maybe some others) :

__aeabi_d2f
__truncdfsf2
__adddf3
__aeabi_dadd
__aeabi_dsub
__subdf3

Since the exponential can't be calculated with the FPU directly, the library functions has be to called and I am okay with that but, why uses doubles inside single precision functions?

Maybe on a Cortex-M4 is not a big deal considering the memory available but on a smaller MCU (Cortex-M0 for example), adding all these unnecessary functions will consume a lot of useful memory.

Is there a good reason to use doubles inside sqrtf and expf? Maybe there is a reason for that but I would like to know it

Okay, thanks you for the clear explanation, the link and the optimization advice.

I was very instructive

Thanks Joey Ye, that solved my question.

Well, just to know, is there a solution to skip the error handling part without recompiling newlib?

As it is in the same function. I cannot think of a way to skip it without recompilation.

Ok, and is it complex to recompile newlib?

Please follow How-to-build-tools.pdf in the release website.