4.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 pre-defined macro symbols 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 by the tiarmclang compiler, there are ways one can successfully transition the use of such a pre-defined symbol to be compatible with the tiarmclang compiler.

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.

A 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 lists 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 details about macro symbols that are pre-defined by the tiarmclang compiler, see Generic Compiler Pre-Defined Macro Symbols.

For more details on the Arm C Language Extensions, these documents may prove useful:

• Arm C Language Extensions - Release ACLE Q2 2018

• Arm Optimizing C/C++ Compiler User’s Guide - v18.12.0.LTS or later of literature number spnu151 - Summary of ACLE Pre-Defined Macros - Table 2-30

4.3.1. Pre-Defined Macro Symbols that are Available in Both armcl and tiarmclang

Some pre-defined macro symbols supported by the armcl compiler are also supported by 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 the armcl -fg option or the tiarmclang -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.
_INLINE	Defined if some level of optimization is specified when the compiler is invoked. The armcl compiler allows C/C++ source code to undefine the _INLINE symbol to disable some optimization while processing C/C++ source. The tiarmclang compiler does not support turning off inlining by undefining macros. The tiarmclang compiler additionally supports the the __GNUC_GNU_INLINE__, __GNUC_STDC_INLINE__, and __NO_INLINE__ macros, so that code can test to see what type of inlining is enabled.
__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 TI 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_HOSTED__	The __STDC_HOSTED__ macro symbol is always defined to 1 to indicate that the target is a hosted environment, meaning the standard C library is available.
__STDC_NO_THREADS__	The __STDC_NO_THREADS__ macro symbol is not defined. The compiler does not support C11 threads and does not provide the threads.h file.
__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.

4.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__)

The armcl __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__)

The armcl __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
__big_endian__	defined(__ARM_BIG_ENDIAN)

The armcl compiler 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)

The armcl compiler 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 -me option can be used to select little-endian mode during compilation. The tiarmclang compiler assumes little-endian mode by default.

armcl Macro Symbol	tiarmclang Equivalent
__signed_chars__	!defined(__CHAR_UNSIGNED__)

The armcl __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__)

The armcl __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 the armcl __unsigned_chars__ macro symbol. 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
__PTRDIFF_T_TYPE__	__PTRDIFF_TYPE__

The armcl compiler defines the __PTRDIFF_T_TYPE__ macro symbol to indicate the equivalent base type associated with the ptrdiff_t type.

The tiarmclang compiler defines __PTRDIFF_TYPE__ to reflect the underlying type for the ptrdiff_t typedef.

armcl Macro Symbol	tiarmclang Equivalent
__SIZE_T_TYPE__	__SIZE_TYPE__

The armcl compiler defines the __SIZE_T_TYPE__ macro symbol to indicate the equivalent base type associated with the size_t type.

The tiarmclang compiler defines __SIZE_TYPE__ to reflect the underlying type for the size_t typedef.

armcl Macro Symbol	tiarmclang Equivalent
__TI_ARM__	defined(__ARM_ARCH)

The armcl __TI_ARM__ macro symbol is defined for all Arm architectures.

References to __TI_ARM__ can be safely replaced by __ARM_ARCH in C/C++ source code that can then be compiled with either the armcl or tiarmclang compiler, since both support the ACLE macro symbol. The values of __ARM_ARCH are described in TI Arm-Specific Pre-Defined Macro Symbols.

armcl Macro Symbol	tiarmclang Equivalent
__TI_ARM_V6__	(__ARM_ARCH == 6)

The armcl __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 the armcl __TI_ARM_V6M0__ macro symbol 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)

The armcl __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 the armcl __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 the armcl __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 the armcl __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 the armcl __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_COMPILER_VERSION__	__ti_version__

The armcl compiler defines the __TI_COMPILER_VERSION__ macro symbol to a 7-9 digit integer, depending on if X has 1, 2, or 3 digits. The number does not contain a decimal. For example, version 3.2.1 is represented as 3002001. The leading zeros are dropped to prevent the number being interpreted as an octal.

The tiarmclang compiler defines __ti_version__ to encode the major, minor, and patch version number values associated with the current release, where:

<encoding> = <major> * 10000
             <minor> * 100
             <patch>

For 3.2.1.LTS, for example, the value of <encoding> would be 30201.

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 __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_FPV4SPD16_SUPPORT__	defined(__ARM_FP) && (__ARM_FP == 6) && (__ARM_ARCH_PROFILE == ‘M’)

References to the armcl __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
__TI_GNU_ATTRIBUTE_SUPPORT__	defined(__clang__)

The armcl compiler 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_STRICT_ANSI_MODE__	__STRICT_ANSI__

The armcl compiler defines the __TI_STRICT_ANSI_MODE__ macro symbol to 1 if the armcl compiler is invoked with the --strict_ansi option. The armcl compiler defines __TI_STRICT_ANSI_MODE__ with a value of 0 by default to indicate that the compiler does not enforce strict conformance to the ANSI C standard.

The tiarmclang compiler defines the __STRICT_ANSI__ macro symbol if 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).

armcl Macro Symbol	tiarmclang Equivalent
__TI_VFP_SUPPORT__	defined(__ARM_FP)

The armcl compiler 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)

The armcl compiler 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 the armcl __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_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.

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	tiarmclang Equivalent
__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 to indicate the underlying type for the wchar_t typedef.

4.3.3. Pre-Defined Macro Symbols in armcl 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__	The armcl __TI_ARM_V4__ macro symbol is not applicable since tiarmclang does not support the Arm v4 architecture.
__TI_ARM_V5__	The armcl __TI_ARM_V5__ macro symbol is not applicable since tiarmclang does not support the Arm v5 architecture.
__TI_ARM_V7A8__	The armcl __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_FP_MODE__	The armcl __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__	The armcl __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.

4.3.4. Additional Pre-Defined Macro Symbols Supported in tiarmclang

The following pre-defined macro symbols are provided by the tiarmclang but not by the armcl compiler.

The tiarmclang compiler defines specific GNU macro symbols that are included in the table below. These macro symbols are not meant to distinguish GCC as a compiler; instead, they indicate code compatibility with GCC.

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.
__UINTMAX_TYPE__	The tiarmclang compiler defines __UINTMAX_TYPE__ to reflect the underlying type for the uintmax_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.

4.3.5. 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.