2.4.5. Float vs. double¶
On C2000 devices without FPU64 hardware support, there is significant overhead when application compiled for EABI performs operations on double types.
In EABI, the double type is mapped to 64-bit double-precision floating point. Refer to Application Binary Interface (ABI) for details. An application compiled for EABI (--abi=eabi
) can introduce double precision floating point operations in the following ways:
Explicit use of the
double
type. Avoid using thedouble
type unless the additional accuracy/range is required by the application.Implicitly via floating point constants. Use the
f
suffix when the constant can be treated as a single precision floating point constant.Floating point constants without the
f
suffix are treated as double-precision by the compiler. This behavior is mandated by the C standard. This can lead to unexpected introduction of double precision operations in the application. Table 2.10 illustrates this inefficiency - the constant is treated as double precision, leading to conversion ofx
from float to double precision. The multiply is a double precision operation and the result is converted back to single precision.Table 2.9 Single and double-precision floating point constants¶ Constant (treated as double)
Constant with
f
suffix (treated as float)float foo1(float x) { return x * 42.2; }
float foo2(float x) { return x * 42.2f; }
Table 2.10 Comparison of generated assembly¶ Operations performed in double precision
Operations performed in single precision
||foo1||: ADDB SP,#8 MOVZ AR4,SP SUBB XAR4,#8 MOVZ AR6,AR4 LCR #||__c28xabi_ftod|| ; call occurs [#||__c28xabi_ftod||] MOVZ AR4,SP MOVZ AR6,SP MOVL XAR5,#$C$FL1 SUBB XAR4,#8 SUBB XAR6,#4 MOVZ AR4,AR4 MOVZ AR6,AR6 LCR #||__c28xabi_mpyd|| ; call occurs [#||__c28xabi_mpyd||] MOVZ AR4,SP SUBB XAR4,#4 MOVZ AR4,AR4 LCR #||__c28xabi_dtof|| ; call occurs [#||__c28xabi_dtof||] SUBB SP,#8 LRETR ; return occurs
||foo2||: MOVIZ R1H,#16936 MOVXI R1H,#52429 MPYF32 R0H,R1H,R0H LRETR ; return occurs
Math routines such as
sqrt
from the C Standard Library. In COFF, sincefloat
anddouble
are both 32-bit single precision, there is no distinction betweensqrt
andsqrtf
. However, with EABI,sqrtf
operates on afloat
argument,sqrt
operates ondouble
.
Detecting double precision operations
The compiler option --float_operations_allowed=32
can be used to detect if an application is inadvertently using double precision operations.
This option restricts the type of floating point operations allowed in the
application. The default is all. If set to none, 32, or 64, the application
is checked for operations that will be performed at runtime. For
example, if --float_operations_allowed=32
is specified on the
command line, the compiler issues an error if the application contains double precision operations. For details, refer to TMS320C28x Optimizing C/C++ Compiler User’s Guide.