GCC provides three basic options for compiling floating-point code:
-mfloat-abi=softfp
option.
When you select this variant,
the compiler generates VFP floating-point instructions, but the
resulting code uses the same call and return conventions as
code compiled with software floating point.
-mfloat-abi=hard
.
You can freely mix code compiled with either of the first two variants in the same program, as they both use the same soft-float ABI. However, code compiled with the VFP ABI is not link-compatible with either of the other two options. If you use the VFP ABI, you must use this option to compile your entire program, and link with libraries that have also been compiled with the VFP ABI. For example, you may need to use the VFP ABI in order to link your program with other code compiled by the ARM RealView® compiler, which uses this ABI.
Sourcery CodeBench Lite for ARM EABI includes libraries built with software floating point, which are compatible with VFP code compiled using the soft-float ABI. While the compiler is capable of generating code using the VFP ABI, no compatible runtime libraries are provided in Sourcery CodeBench Lite. However, VFP hard-float libraries built with both ABIs are available to Sourcery CodeBench Standard and Professional Edition subscribers.
Note that, in addition to selecting hard/soft float and the ABI
via the -mfloat-abi
option,
you can also compile for a particular FPU using
the -mfpu
option.
For example, -mfpu=neon
selects VFPv3 with NEON
coprocessor extensions.
Sourcery CodeBench includes support for automatic generation of NEON SIMD vector code. Autovectorization is a compiler optimization in which loops involving normal integer or floating-point code are transformed to use NEON SIMD instructions to process several data elements at once.
To enable generation of NEON vector code, use the command-line options
-ftree-vectorize -mfpu=neon -mfloat-abi=softfp
.
The -mfpu=neon
option
also enables generation of VFPv3 scalar floating-point code.
Sourcery CodeBench also includes support for manual generation
of NEON SIMD code using C intrinsic functions. These intrinsics,
the same as those supported by the ARM
RealView® compiler, are defined
in the arm_neon.h
header
and are documented in the 'ARM NEON Intrinsics' section of the GCC
manual. The command-line options -mfpu=neon
-mfloat-abi=softfp
must be specified to use these
intrinsics; -ftree-vectorize
is not required.
Sourcery CodeBench for ARM EABI includes support for half-precision
(16-bit) floating point, including the new __fp16
data
type in C and C++, support for generating conversion instructions when
compiling for processors that support them, and library functions for
use in other cases.
To use half-precision floating point, you must explicitly enable it
via the -mfp16-format
command-line option to the
compiler. For more information about __fp16
representations
and usage from C and C++, refer to the GCC manual.