|
|||
| Products Download Events Support Videos | |||
Technical Support
On-Line Manuals
Compiler User Guide
Conventions and Feedback
Overview of the Compiler
Getting Started with the Compiler
Compiler Features
Compiler Coding Practices
The compiler as an optimizing compiler
Compiler optimization for code size versus speed
Compiler optimization levels and the debug view
Selecting the target CPU at compile time
Optimization of loop termination in C code
Loop unrolling in C code
Compiler optimization and the volatile keyword
Code metrics
Code metrics for measurement of code size and data
Stack use in C and C++
Benefits of reducing debug information in objects
Methods of reducing debug information in objects a
Guarding against multiple inclusion of header file
Methods of minimizing function parameter passing o
Functions that return multiple values through regi
Functions that return the same result when called
Comparison of pure and impure functions
Recommendation of postfix syntax when qualifying f
Inline functions
Compiler decisions on function inlining
Automatic function inlining and static functions
Inline functions and removal of unused out-of-line
Automatic function inlining and multifile compilat
Restriction on overriding compiler decisions about
Compiler modes and inline functions
Inline functions in C++ and C90 mode
Inline functions in C99 mode
Inline functions and debugging
Types of data alignment
Advantages of natural data alignment
Compiler storage of data objects by natural byte a
Relevance of natural data alignment at compile tim
Unaligned data access in C and C++ code
The __packed qualifier and unaligned data access i
Unaligned fields in structures
Performance penalty associated with marking whole
Unaligned pointers in C and C++ code
Unaligned Load Register (LDR) instructions generat
Comparisons of an unpacked struct, a __packed stru
Compiler support for floating-point arithmetic
Default selection of hardware or software floating
Example of hardware and software support differenc
Vector Floating-Point (VFP) architectures
Limitations on hardware handling of floating-point
Implementation of Vector Floating-Point (VFP) supp
Compiler and library support for half-precision fl
Half-precision floating-point number format
Compiler support for floating-point computations a
Types of floating-point linkage
Compiler options for floating-point linkage and co
Floating-point linkage and computational requireme
Processors and their implicit Floating-Point Units
Integer division-by-zero errors in C code
About trapping integer division-by-zero errors wit
About trapping integer division-by-zero errors wit
Identification of integer division-by-zero errors
Examining parameters when integer division-by-zero
Software floating-point division-by-zero errors in
About trapping software floating-point division-by
Identification of software floating-point division
Software floating-point division-by-zero debugging
New language features of C99
New library features of C99
// comments in C99 and C90
Compound literals in C99
Designated initializers in C99
Hexadecimal floating-point numbers in C99
Flexible array members in C99
__func__ predefined identifier in C99
inline functions in C99
long long data type in C99 and C90
Macros with a variable number of arguments in C99
Mixed declarations and statements in C99
New block scopes for selection and iteration state
_Pragma preprocessing operator in C99
Restricted pointers in C99
Additional <math.h> library functions in C99
Complex numbers in C99
Boolean type and <stdbool.h> in C99
Extended integer types and functions in <inttyp
<fenv.h> floating-point environment access i
<stdio.h> snprintf family of functions in C9
<tgmath.h> type-generic math macros in C99
<wchar.h> wide character I/O functions in C9
How to prevent uninitialized data from being initi
Compiler Diagnostic Messages
Using the Inline and Embedded Assemblers of the AR
Compiler User Guide
Compiler options for floating-point linkage and computations
| |||
| Home > Compiler Coding Practices > Compiler options for floating-point linkage and computations | |||
By specifying the type of floating-point linkage and floating-point computations you require, you can determine, from Table 15, the associated compiler command-line options that are available.
Table 15. Compiler options for floating-point linkage and floating-point computations
| Linkage | Computations | ||||
|---|---|---|---|---|---|
| Hardware FP linkage | Software FP linkage | Hardware FP coprocessor | Software FP library (fplib) | Compiler options | |
| No | Yes | No | Yes |
|
|
| No | Yes | Yes | No |
|
|
| Yes | No | Yes | No |
|
|
softvfp specifies software floating-point
linkage. When software floating-point linkage is used, either:
the calling function and the called function must be compiled using one of the options
--softvfp,--fpu softvfp+vfpv2, --fpu softvfp+vfpv3,--fpu softvfp+vfpv3_fp16,softvfp+vfpv3_d16,softvfp+vfpv3_d16_fp16,softvfp+vfpv4,softvfp+vfpv4_d16, orsoftvfp+fpv4-spthe calling function and the called function must be declared using the
__softfpkeyword.
Each of the options --fpu softvfp, --fpu
softvfp+vfpv2,--fpu softvfp+vfpv3, --fpu softvfp+vfpv3_fp16, --fpu
softvfpv3_d16, --fpu softvfpv3_d16_fp16, --fpu
softvfp+vfpv4, softvfp+vfpv4_d16 and softvfp+fpv4-sp specify
software floating-point linkage across the whole file. In contrast,
the __softfp keyword enables software floating-point
linkage to be specified on a function by function basis.
Note
Rather than having separate compiler options to select the
type of floating-point linkage you require and the type of floating-point
computations you require, you use one compiler option, --fpu,
to select both. (See Table 15.)
For example, --fpu=softvfp+vfpv2 selects software floating-point
linkage, and a hardware coprocessor for the
computations. Whenever you use softvfp, you are
specifying software floating-point linkage.
If you use the --fpu option, you need to
know the VFP architecture version implemented in the target core.
An alternative to --fpu=softvfp+... is --apcs=/softfp.
This gives software linkage with whatever VFP architecture version
is implied by --cpu. --apcs=/softfp and --apcs=/hardfp are
alternative ways of requesting the integer or floating-point variant
of the Procedure Call Standard for the ARM Architecture (AAPCS).
See also- Concepts
- Reference
| Copyright © 2007-2008, 2011-2012 ARM. All rights reserved. | ARM DUI 0375D |
| Non-Confidential | ID062912 |
 PDF version | |
| Home > Compiler Coding Practices > Compiler options for floating-point linkage and computations |
ProductsDevelopment Tools |
Hardware & Collateral |
Downloads |
Support |
Buy |
|
 |
|||
