3.3. Pre-Defined Macro Symbols¶
Many applications support a variety of configurations that are often administered via the use of pre-defined macro symbols. For example, an application may want to initialize a particular global variable differently based on which Arm processor variant the application is being built for. armcl supports several TI-specific pre-defined macro names that help with this:
While several of the pre-defined macro symbols that are supported by the armcl compiler are also supported by the tiarmclang compiler, many are not. For a given armcl pre-defined macro symbol that is not supported in the tiarmclang compiler, there are a couple different ways that one can successfully transition the use of such a pre-defined symbol to be compatible with the tiarmclang compiler. First, if there exists a functionally equivalent means of representing the symbol’s use with an Arm C Language Extension (ACLE) pre-defined symbol, then the developer is encouraged to perform this conversion on their original source code since both the armcl and tiarmclang compilers fully support ACLE pre-defined macro symbols. Using ACLE pre-defined macro symbols in your C/C++ source code improves the portability of your code. For example, the above configuration of the proc_id_string value can be re-written using ACLE pre-defined macro symbols as follows:
A second way to “transition” C/C++ source code that makes use of armcl pre-defined macro symbols that are not supported in the tiarmclang compiler is to include the ti_compatibility.h header file in the source file before any of the relevant armcl pre-defined macro symbols are referenced.
This section of the “Migrating C and C++ Source Code” chapter of the migration guide walks through each of the pre-defined macro symbols that are supported in the armcl compiler and, if conversion is needed, explains how to modify the C/C++ source to make it compatible with the tiarmclang compiler.
For more details on the Arm C Language Extensions, these documents may prove useful:
3.3.1. Pre-Defined Macro Symbols that are Available in Both armcl and tiarmclang¶
Some pre-defined macro symbols that are supported by the armcl compiler are also supported in the tiarmclang compiler. The following table identifies those pre-defined macro symbols that are supported by both compilers and require no conversion when migrating an application from armcl to tiarmclang:
Macro Symbol |
Description / Comments |
|---|---|
__COUNTER__ |
References to the __COUNTER__ macro symbol expand to an integer value starting from 0. This symbol can be used in conjunction with a “##” operator in C/C++ source code to create unique symbol names. |
__cplusplus |
The __cplusplus symbol is defined if the armcl or tiarmclang compiler is invoked to process a C++ source file. If the source file in question is an obvious C++ source file with a .cpp extension, then both compilers define __cplusplus when processing such a file. The user can also force __cplusplus to be defined via armcl’s -fg option or tiarmclang’s -x c++ option. These instruct the compiler to process a source file, whether it is a C++ or C file, as a C++ file. |
__DATE__ |
References to the __DATE__ macro symbol expand to a string representing the date on which the compiler was invoked. The date is displayed in the form: mmm dd yyyy. |
__ELF__ |
The __ELF__ macro symbol is defined by both the armcl and tiarmclang compilers since both generate ELF object format. |
__FILE__ |
References to the __FILE__ macro symbol expand to a string representation of the name of the source file being compiled. |
__LINE__ |
References to the __LINE__ macro symbol expand to an integer constant indicating the current source line in the source file. The value of the integer constant depends on which source line the macro symbol is referenced. |
__STDC__ |
Both the armcl and tiarmclang compilers define the __STDC__ macro symbol to indicate compliance with the ISO C standard. Please refer to the Arm Optimizing C/C++ Compiler User’s Guide for exceptions to ISO C compliance that apply to the armcl compiler. Exceptions to ISO C compliance in the tiarmclang compiler can be found in the TI Arm Clang Compiler User Guide. |
__STDC_VERSION__ |
The __STDC_VERSION__ macro symbol expands to an integer constant that indicates the ISO C standard that the compiler conforms to. |
__TIME__ |
References to the __TIME__ macro symbol expand to a string representation of the time at which the compiler is invoked. The time is displayed in the form: hh:mm:ss. |
__TIMESTAMP__ |
References to the __TIMESTAMP__ macro symbol expand to a string representation of the date and time at which the compiler was invoked. The date and time are displayed in the form: dow mmm dd hh:mm:ss yyyy (dow is “day of the week”). |
__VERSION__ |
The __VERSION__ macro symbol provides information about which version of the C/C++ parser is used by the compiler. The armcl compiler uses some version of the EDG gcc-compatible parser, whereas the tiarmclang compiler’s parser uses a version of the LLVM and Clang source base. |
3.3.2. Converting armcl Pre-Defined Macro Symbols to tiarmclang Compatible Form¶
Several armcl pre-defined macro symbols are not supported by tiarmclang, but these macro symbols can often be re-written in terms of ACLE or GCC pre-defined macro symbols that tiarmclang does support. The following table lists armcl pre-defined macro symbols that are not supported by the tiarmclang compiler, and how they may be converted to a form that is supported by tiarmclang:
armcl Macro Symbol |
tiarmclang Equivalent |
|---|---|
__16bis__ |
defined(__thumb__) |
armcl’s __16bis__ macro symbol is defined if the selected instruction set (via the --code_state option) is 16-bit. This is the default for the cortex-m0, cortex-m3, and cortex-m4 processor variants. However, it is also possible to specify --code_state=16 in combination with the cortex-r4 and cortex-r5 processor variants, in which case, __16bis__ will also be defined.
tiarmclang supports the __thumb__ macro symbol that can be used as indicated, checking that __thumb__ is defined, in place of references to __16bis__ in C/C++ source code. To explicitly select the 16-bit instruction set from the tiarmclang command-line, use the -mthumb option.
armcl Macro Symbol |
tiarmclang Equivalent |
|---|---|
__32bis__ |
!defined(__thumb__) |
armcl’s __32bis__ macro symbol is defined if the selected instruction set (via the --code_state option) is 32-bit. This is the default when the cortex-r4 or cortex-r5 processor variant is selected.
tiarmclang supports the __thumb__ macro symbol that can be used as indicated, checking that __thumb__ is not defined, in place of references to __32bis__ in C/C++ source code.
armcl Macro Symbol |
tiarmclang Equivalent |
|---|---|
__signed_chars__ |
!defined(__CHAR_UNSIGNED__) |
armcl’s __signed_chars__ macro symbol is defined if the plain char type is interpreted as signed. That is, if the char type name is specified without a “signed” or “unsigned” qualifier is interpreted as signed, then __signed_chars__ is defined.
tiarmclang supports the GCC macro symbol __CHAR_UNSIGNED__ which can be used in place of references to __signed_chars__ using the transformation: “__signed_chars__” -> “!defined(__CHAR_UNSIGNED)”
The default behavior for both armcl and tiarmclang is that the plain char type is interpreted as unsigned. To change this default behavior, the armcl compiler supports the --plain_char=signed option and the tiarmclang compiler supports the -fsigned-char option.
armcl Macro Symbol |
tiarmclang Equivalent |
|---|---|
__unsigned_chars__ |
defined(__CHAR_UNSIGNED__) |
armcl’s __unsigned_chars__ macro symbol is defined if the plain char type is interpreted as unsigned. That is, if the char type name is specified without a “signed” or “unsigned” qualifier is interpreted as unsigned, then __unsigned_chars__ is defined.
tiarmclang supports the GCC pre-defined macro symbol __CHAR_UNSIGNED__ which has the same meaning as armcl’s __unsigned_chars__. All references to __unsigned_chars__ can be replaced by __CHAR_UNSIGNED__ in the C/C++ source that is to be built with tiarmclang.
The default behavior for both armcl and tiarmclang is that the plain char type is interpreted as unsigned.
armcl Macro Symbol |
tiarmclang Equivalent |
|---|---|
__TI_EABI_SUPPORT__ |
defined(__ELF__) |
Both the armcl and tiarmclang compilers support the generation of ELF object format code only. Consequently, the armcl’s __TI_EABI_SUPPORT__ macro symbol is always defined when the armcl compiler is invoked.
tiarmclang does not support __TI_EABI_SUPPORT__, but it does support the __ELF__ macro symbol which is also supported by armcl. Therefore, references to __TI_EABI_SUPPORT__ in the C/C++ source can be safely replaced by __ELF__.
armcl Macro Symbol |
tiarmclang Equivalent |
|---|---|
__TI_GNU_ATTRIBUTE_SUPPORT__ |
defined(__clang__) |
armcl defines the __TI_GNU_ATTRIBUTE_SUPPORT__ macro symbol to indicate that a C/C++ dialect mode where generic attributes is supported. tiarmclang does not support an analogous macro symbol, but generic attributes are supported by tiarmclang, nonetheless.
armcl Macro Symbol |
tiarmclang Equivalent |
|---|---|
__TI_ARM_V6__ |
(__ARM_ARCH == 6) |
armcl’s __TI_ARM_V6__ macro symbol is defined when the -mv6 or -mv6M0 is specified on the armcl command-line. This symbol is analogous to a check of ACLE’s __ARM_ARCH macro symbol. References to __TI_ARM_V6__ can be safely replaced by “(__ARM_ARCH == 6)” in C/C++ source code that can then be compiled with either the armcl or tiarmclang compiler since both support the ACLE macro symbol.
When compiling with tiarmclang, only the cortex-m0 argument to the -mcpu option selects v6 of the Arm architecture, setting the value of __ARM_ARCH to 6.
armcl Macro Symbol |
tiarmclang Equivalent |
|---|---|
__TI_ARM_V6M0__ |
(__ARM_ARCH == 6) && (__ARM_ARCH_PROFILE == ‘M’) |
When armcl’s __TI_ARM_V6M0__ is defined, it indicates that the compiler has been invoked to generate code for the cortex-m0 processor variant. References to __TI_ARM_V6M0__ can be replaced with the expression “(__ARM_ARCH == 6) && (__ARM_ARCH_PROFILE == ‘M’)” in C/C++ source that can then be compiled with either the armcl or tiarmclang compiler.
armcl Macro Symbol |
tiarmclang Equivalent |
|---|---|
__TI_ARM_V7__ |
(__ARM_ARCH == 7) |
armcl’s __TI_ARM_V7__ macro symbol is defined when the -mv7m3, -mv7m4, -mv7a8, -mv7r4, or -mv7r5 options are specified on the armcl command- line. This symbol is analogous to a check of ACLE’s __ARM_ARCH macro symbol. References to __TI_ARM_V7__ can be safely replaced by “(__ARM_ARCH == 7)” in C/C++ source code that can then be compiled with either the armcl or tiarmclang compiler since both support the ACLE macro symbol.
When compiling with tiarmclang, specifying cortex-m3, cortex-m4, cortex-r4, or cortex-r5 as the argument for the -mcpu option selects v7 of the Arm architecture, setting the value of __ARM_ARCH to 7.
armcl Macro Symbol |
tiarmclang Equivalent |
|---|---|
__TI_ARM_V7M3__ |
(__ARM_ARCH == 7) && (__ARM_ARCH_PROFILE == ‘M’) && !defined(__ARM_FEATURE_SIMD32) |
References to armcl’s __TI_ARM_V7M3__ macro symbol can be replaced with a combination of the ACLE’s __ARM_ARCH, __ARM_ARCH_PROFILE, and __ARM_FEATURE_SIMD32 macro symbols. The __ARM_FEATURE_SIMD32 macro symbol indicates that the processor that the source code is being compiled for supports 32-bit SIMD instructions. This feature is supported on the cortex-m4, but not on the cortex-m3. Thus, checking that __ARM_FEATURE_SIMD32 is not defined can be used to distinguish the cortex-m3 from the cortex-m4 processor variant.
armcl Macro Symbol |
tiarmclang Equivalent |
|---|---|
__TI_ARM_V7M4__ |
(__ARM_ARCH == 7) && (__ARM_ARCH_PROFILE == ‘M’) && defined(__ARM_FEATURE_SIMD32) |
References to armcl’s __TI_ARM_V7M4__ macro symbol can be replaced with a combination of the ACLE’s __ARM_ARCH, __ARM_ARCH_PROFILE, and __ARM_FEATURE_SIMD32 macro symbols as indicated. The __ARM_FEATURE_SIMD32 macro symbol indicates that the processor that the source code is being compiled for supports 32-bit SIMD instructions. This feature is supported on the cortex-m4, but not on the cortex-m3. Thus, checking that __ARM_FEATURE_SIMD32 is defined can be used to distinguish the cortex-m4 from the cortex-m3 processor variant.
armcl Macro Symbol |
tiarmclang Equivalent |
|---|---|
__TI_ARM_V7R4__ |
(__ARM_ARCH == 7) && (__ARM_ARCH_PROFILE == ‘R’) && !defined(__ARM_FEATURE_IDIV) |
References to armcl’s __TI_ARM_V7R4__ macro symbol can be replaced with a combination of the ACLE’s __ARM_ARCH, __ARM_ARCH_PROFILE, and __ARM_FEATURE_IDIV macro symbols as indicated. The __ARM_FEATURE_IDIV macro symbol indicates that hardware support for 32-bit integer divide is available. This is not the case for cortex-r4, but it is true for cortex-r5. Thus, checking that __ARM_FEATURE_IDIV is not defined can be used to distinguish the cortex-r4 from the cortex-r5 processor.
armcl Macro Symbol |
tiarmclang Equivalent |
|---|---|
__TI_ARM_V7R5__ |
(__ARM_ARCH == 7) && (__ARM_ARCH_PROFILE == ‘R’) && defined(__ARM_FEATURE_IDIV) |
References to armcl’s __TI_ARM_V7R4__ macro symbol can be replaced with a combination of the ACLE’s __ARM_ARCH, __ARM_ARCH_PROFILE, and __ARM_FEATURE_IDIV macro symbols as indicated. The __ARM_FEATURE_IDIV macro symbol indicates that hardware support for 32-bit integer divide is available. This is the case for cortex-r5, but not for cortex-r4. Thus, checking that __ARM_FEATURE_IDIV is defined can be used to distinguish the cortex-r5 from the cortex-r4 processor.
armcl Macro Symbol |
tiarmclang Equivalent |
|---|---|
__TI_VFP_SUPPORT__ |
defined(__ARM_FP) |
armcl defines the __TI_VFP_SUPPORT__ macro symbol to indicate that the compiler assumes that floating-point hardware is available. References to __TI_VFP_SUPPORT__ can safely be replaced with a test that the ACLE’s __ARM_FP macro symbol is defined.
armcl Macro Symbol |
tiarmclang Equivalent |
|---|---|
__TI_VFPLIB_SUPPORT__ |
!defined(__ARM_FP) |
armcl defines the __TI_VFPLIB_SUPPORT__ macro symbol to indicate that the compiler assumes that floating-point arithmetic will be performed using software and floating-point math helper functions that do not use floating-point hardware instructions. References to __TI_VFPLIB_SUPPORT__ can safely be replaced with a test that the ACLE’s __ARM_FP macro symbol is not defined.
armcl Macro Symbol |
tiarmclang Equivalent |
|---|---|
__TI_VFPV3D16_SUPPORT__ |
defined(__ARM_FP) && (__ARM_FP == 12) && (__ARM_ARCH_PROFILE == ‘R’) |
References to armcl’s __TI_VFPV3D16_SUPPORT__ macro symbol can be replaced with a combination test of the ACLE’s __ARM_FP macro symbol as indicated. A definition of __ARM_FP indicates the availability of floating-point hardware instructions, and then the value assigned to __ARM_FP can be used to distinguish one variant of floating-point hardware from another.
In the case of the VFPv3D16 floating-point hardware that is available when cortex-r4 is the selected core processor variant, the value for __ARM_FP is 12. Please see section 6.5.1 of the Arm C Language Extensions - Release 2.1 (3/24/2016) specification for more details on values that may be assigned to the __ARM_FP macro symbol.
armcl Macro Symbol |
tiarmclang Equivalent |
|---|---|
__TI_FPV4SPD16_SUPPORT__ |
defined(__ARM_FP) && (__ARM_FP == 6) && (__ARM_ARCH_PROFILE == ‘M’) |
References to armcl’s __TI_FPV4SPD16_SUPPORT__ macro symbol can be replaced with a combination test of the ACLE’s __ARM_FP macro symbol as indicated. A definition of __ARM_FP indicates the availability of floating-point hardware instructions, and then the value assigned to __ARM_FP can be used to distinguish one variant of floating-point hardware from another.
In the case of the FPv4SPD16 floating-point hardware that is available when cortex-m4 is the selected core processor variant, the value for __ARM_FP is 6. Please see section 6.5.1 of the Arm C Language Extensions - Release 2.1 (3/24/2016) specification for more details on values that may be assigned to the __ARM_FP macro symbol.
armcl Macro Symbol |
tiarmclang Equivalent |
|---|---|
__big_endian__ |
defined(__ARM_BIG_ENDIAN) |
armcl defines the __big_endian__ macro symbol to indicate that the compiler assumes big-endian mode for the current compilation. References to __big_endian__ can safely be replaced with a test that the ACLE’s __ARM_BIG_ENDIAN macro symbol is defined.
The armcl compiler assumes big-endian mode by default. The tiarmclang compiler assumes little-endian mode by default. The tiarmclang’s -mbig-endian option can be used to make the tiarmclang compiler assume big-endian mode during compilation.
armcl Macro Symbol |
tiarmclang Equivalent |
|---|---|
__little_endian__ |
!defined(__ARM_BIG_ENDIAN) |
armcl defines the __little_endian__ macro symbol to indicate that the compiler assumes little-endian mode for the current compilation. References to __little_endian__ can safely be replaced with a test that the ACLE’s __ARM_BIG_ENDIAN macro symbol is not defined.
While the armcl compiler assumes big-endian mode by default, the armcl’s -me option can be used to select little-endian mode during compilation. The tiarmclang compiler assumes little-endian mode by default.
3.3.3. Pre-Defined Macro Symbols Associated with wchar_t Type¶
Code that involves the use of pre-defined macro symbols that are associated with the wchar_t type may need some special attention when migrating an application from armcl to tiarmclang. The size of the wchar_t type is different on the armcl compiler than it is on the tiarmclang compiler. In armcl, the wchar_t type is 16-bits wide and is equivalent to the uint16_t type (unsigned short). However, in the tiarmclang compiler, the wchar_t type is 32-bits wide and is equivalent to the uint32_t type (unsigned int). Thus, when converting code that refers to __TI_WCHAR_T_BITS__ or __WCHAR_T_TYPE__, the developer must take the difference in compiler assumptions about the size of the wchar_t type into consideration as well as just replacing the references to the armcl macro symbols.
armcl Macro Symbol |
Analogous tiarmclang Macro Symbol Expression |
|---|---|
__TI_WCHAR_T_BITS__ |
(__ARM_SIZEOF_WCHAR_T << 3) |
The armcl compiler defines the __TI_WCHAR_T_BITS__ macro symbol to indicate the size of the wchar_t type. The analogous expression that the tiarmclang compiler supports involves the use of the ACLE __ARM_SIZEOF_WCHAR_T macro symbol as indicated.
armcl Macro Symbol |
Analogous tiarmclang Macro Symbol Expression |
|---|---|
__WCHAR_T_TYPE__ |
__WCHAR_TYPE__ |
The armcl compiler defines the __WCHAR_T_TYPE__ macro symbol to indicate the equivalent base type associated with the wchar_t type. The tiarmclang compiler supports the analogous GCC __WCHAR_TYPE__ macro symbol.
3.3.4. armcl Pre-Defined Macro Symbols that are Not Applicable in tiarmclang¶
There are several pre-defined macro symbols that are supported by the armcl compiler that are either not applicable for tiarmclang or are simply not supported. For example, the __TI_ARM_V4__ pre-defined macro symbol indicates support for version 4 of the Arm architecture in the armcl compiler, but this version of the Arm architecture is not supported by the tiarmclang compiler.
armcl Macro Symbol |
Description / Comments |
|---|---|
__TI_ARM_V4__ |
armcl’s __TI_ARM_V4__ macro symbol is not applicable since tiarmclang does not support the Arm v4 architecture. |
__TI_ARM_V5__ |
armcl’s __TI_ARM_V5__ macro symbol is not applicable since tiarmclang does not support the Arm v5 architecture. |
__TI_ARM_V7A8__ |
armcl’s __TI_ARM_V7A8__ macro symbol is not applicable since tiarmclang does not support the cortex-a8 processor variant. |
__TI_FPALIB_SUPPORT__ |
The --float_support=fpalib option has been deprecated. The __TI_FPALIB_SUPPORT__ macro symbol is no longer defined by the armcl compiler. |
__TI_NEON_SUPPORT__ |
The --float_support=fpalib option has been deprecated. The __TI_FPALIB_SUPPORT__ macro symbol is no longer defined by the armcl compiler. |
__TI_STRICT_ANSI_MODE__ |
armcl’s __TI_STRICT_ANSI_MODE__ macro symbol is defined to 1 if the armcl compiler is invoked with the --strict_ansi option. The armcl compiler will define __TI_STRUCT_ANSI_MODE__ with a value of 0 by default to indicate that the compiler does not enforce strict conformance to the ANSI C standard. |
__TI_STRICT_FP_MODE__ |
armcl’s __TI_STRICT_FP_MODE__ macro symbol is defined to 1 by default to indicate that the compiler is to be strict about floating-point math (adherence to the IEEE-754 standard for floating-point arithmetic). This reflects the default argument for the --fp_mode option (i.e. --fp_mode=strict). To instruct the compiler to be more relaxed about floating-point math, the --fp_mode=relaxed option can be specified, which will cause __TI_STRICT_FP_MODE__ to be defined with a value of 0. |
__TI_VFPV3_SUPPORT__ |
armcl’s __TI_VFPV3_SUPPORT__ macro symbol is not applicable since tiarmclang does not support the cortex-a8 processor variant and VFPv3 floating- point hardware is only available with cortex-a8. |
_INLINE |
The armcl compiler defines the _INLINE macro symbol to indicate that some level of optimization is specified (-O or --opt_level option) when the compiler is invoked. The C/C++ source code can then undefine the _INLINE symbol to disable some types of optimization while processing the C/C++ source (i.e. inlining). |
3.3.5. Additional Pre-Defined Macro Symbols Supported in tiarmclang¶
Need intro paragraph here
tiarmclang Macro Symbol |
Description / Comments |
|---|---|
__ARM_FP_FAST |
The tiarmclang compiler defines the __ARM_FP_FAST macro symbol if the -ffast-math option is specified on the tiarmclang command-line. |
__clang__ |
An invocation of tiarmclang will always define the __clang__ macro symbol. |
__EXCEPTIONS |
The tiarmclang compiler defines the __EXCEPTIONS macro symbol if -fexceptions is specified when compiling a C++ source file. Exceptions are disabled by default when compiling with the tiarmclang compiler. |
__GNUC__ |
The __GNUC__ macro symbol indicates that the compiler’s C pre-processor is compatible with a major version of the GNU C pre-processor. The tiarmclang compiler’s C pre-processor is compatible with version 3 of the GNU C pre-processor. |
__GNUC_GNU_INLINE__ |
The tiarmclang compiler defines the __GNUC_GNU_INLINE__ macro symbol if optimization is turned on and functions declared inline are handled in GCC’s traditional gnu90 mode. Object files will contain externally visible definitions of all functions declared inline without extern or static. They will not contain any definitions of any functions declared extern inline. |
__GNUC_STDC_INLINE__ |
The tiarmclang compiler defines the __GNUC_STDC_INLINE__ macro symbol if optimization is turned on and functions that are declared inline are handled according to the ISO C99 (or later) C language standard. Object files will contain externally visible definitions of all functions declared extern inline. They will not contain definitions of any functions declared inline without extern. |
__INCLUDE_LEVEL__ |
The tiarmclang compiler defines the __INCLUDE_LEVEL__ macro symbol as an integer constant indicating the current include level. For example, if file f1.c includes f2.h and f2.h contains a reference to __INCLUDE_LEVEL__, then that reference to __INCLUDE_LEVEL__ would evaluate to 1. |
__INTMAX_TYPE__ |
The tiarmclang compiler defines __INTMAX_TYPE__ to reflect the underlying type for the intmax_t typedef. |
__NO_INLINE__ |
If no optimization level is specified on the tiarmclang command-line, then tiarmclang defines the __NO_INLINE__ macro symbol to indicate that compilation mode. |
__OPTIMIZE__ |
If an optimization level is specified via the -O option on the tiarmclang command-line, then tiarmclang defines the __OPTIMIZE__ macro symbol to indicate that optimization is enabled for the current compilation. |
__OPTIMIZE_SIZE__ |
If the -Os or -Oz option is specified on the tiarmclang command-line, then tiarmclang defines the __OPTIMIZE_SIZE__ macro symbol to indicate that optimizations that do not typically increase code size and optimizations that are designed to reduce code size are enabled for the current compilation. |
__PTRDIFF_TYPE__ |
The tiarmclang compiler defines __PTRDIFF_TYPE__ to reflect the underlying type for the ptrdiff_t typedef. |
__SIZE_TYPE__ |
The tiarmclang compiler defines __SIZE_TYPE__ to reflect the underlying type for the size_t typedef. |
__STRICT_ANSI__ |
The tiarmclang compiler defines the __STRICT_ANSI__ macro symbol if the -ansi, or any of the --std=<spec> options are specified on the tiarmclang command-line (where spec indicates the identity of a C or C++ language standard). |
__UINTMAX_TYPE__ |
The tiarmclang compiler defines __UINTMAX_TYPE__ to reflect the underlying type for the uintmax_t typedef. |
__WCHAR_TYPE__ |
The tiarmclang compiler defines __WCHAR_TYPE__ to reflect the underlying type for the wchar_t typedef. |
__WCHAR_UNSIGNED__ |
The tiarmclang compiler defined the __WCHAR_UNSIGNED__ macro symbol to indicate that the wchar_t type assumed when compiling a C++ source file is unsigned. |
__WINT_TYPE__ |
The tiarmclang compiler defines __WINT_TYPE__ to reflect the underlying type for the wint_t typedef. |
3.3.6. The _AEABI_PORTABILITY_LEVEL Pre-Defined Macro Symbol¶
To enable full object file portability when header files are included, the _AEABI_PORTABILITY_LEVEL symbol can be defined to 1. If the symbol is defined with a value of 0, then this implies a requirement that the C source code be fully compliant with the C language standard.
For more detailed information about the meaning and purpose of the _AEABI_PORTABILITY_LEVEL macro symbol, please see the C Library ABI for the Arm Architecture.