You copied the Doc URL to your clipboard.

Migration of compiler command-line options from Arm® Compiler 5 to Arm® Compiler 6

Arm® Compiler 6 provides many command-line options, including most Clang command-line options and several Arm-specific options.

Note

This topic includes descriptions of [COMMUNITY] features. See Support level definitions.

The following table describes the most common Arm Compiler 5 command-line options, and shows the equivalent options for Arm Compiler 6.

More information about command-line options is available:

  • The armclang Reference Guide provides more information about the supported command-line options. The options described are fully supported, unless the level of support is indicated.
  • For a full list of Clang command-line options, see the Clang and LLVM documentation.

Table 3-1 Comparison of compiler command-line options in Arm Compiler 5 and Arm Compiler 6

Arm Compiler 5 option Arm Compiler 6 option Description

--allow_fpreg_for_nonfpdata, --no_allow_fpreg_for_nonfpdata

-mimplicit-float, -mno-implicit-float [COMMUNITY]

Enables or disables the use of VFP and SIMD registers and data transfer instructions for non-VFP and non-SIMD data.

--apcs=/nointerwork No equivalent. Disables interworking between A32 and T32 code. Interworking is always enabled in Arm Compiler 6.

--apcs=/ropi

--apcs=/noropi

-fropi

-fno-ropi

Enables or disables the generation of Read-Only Position Independent (ROPI) code.

--apcs=/rwpi

--apcs=/norwpi

-frwpi

-fno-rwpi

Enables or disables the generation of Read Write Position Independent (RWPI) code.

--arm -marm Targets the A32 instruction set. The compiler is permitted to generate both A32 and T32 code, but recognizes that A32 code is preferred.
--arm_only No equivalent. Enforces A32 instructions only. The compiler does not generate T32 instructions.
--asm -save-temps Instructs the compiler to generate intermediate assembly files as well as object files.
--bigend -mbig-endian Generates code for big-endian data.
-c -c Performs the compilation step, but not the link step.
--c90 -xc -std=c90

Enables the compilation of C90 source code.

-xc is a positional argument and only affects subsequent input files on the command-line. It is also only required if the input files do not have the appropriate file extension.

--c90 --gnu -xc -std=gnu90

Enables the compilation of C90 source code with additional GNU extensions.

-xc is a positional argument and only affects subsequent input files on the command-line. It is also only required if the input files do not have the appropriate file extension.

--c99 -xc -std=c99

Enables the compilation of C99 source code.

-xc is a positional argument and only affects subsequent input files on the command-line. It is also only required if the input files do not have the appropriate file extension.

--c99 --gnu -xc -std=gnu99

Enables the compilation of C99 source code with additional GNU extensions.

-xc is a positional argument and only affects subsequent input files on the command-line. It is also only required if the input files do not have the appropriate file extension.

--cpp -xc++ -std=c++03

Enables the compilation of C++03 source code.

-xc++ is a positional argument and only affects subsequent input files on the command-line. It is also only required if the input files do not have the appropriate file extension.

The default C++ language standard is different between Arm Compiler 5 and Arm Compiler 6.

--cpp --gnu -xc++ -std=gnu++03

Enables the compilation of C++03 source code with additional GNU extensions.

-xc++ is a positional argument and only affects subsequent input files on the command-line. It is also only required if the input files do not have the appropriate file extension.

The default C++ language standard is different between Arm Compiler 5 and Arm Compiler 6.

--cpp11 -xc++ -std=c++11

Enables the compilation of C++11 source code.

-xc++ is a positional argument and only affects subsequent input files on the command-line. It is also only required if the input files do not have the appropriate file extension.

The default C++ language standard is different between Arm Compiler 5 and Arm Compiler 6.

--cpp11 --gnu -xc++ -std=gnu++11

Enables the compilation of C++11 source code with additional GNU extensions.

-xc++ is a positional argument and only affects subsequent input files on the command-line. It is also only required if the input files do not have the appropriate file extension.

The default C++ language standard is different between Arm Compiler 5 and Arm Compiler 6.

--cpp_compat No equivalent.

Compiles C++ code to maximize binary compatibility.

--cpu=8-A.32 --target=arm-arm-none-eabi -march=armv8-a

Targets Armv8‑A and AArch32 state.

--cpu 8-A.64 --target=aarch64-arm-none-eabi

Targets Armv8‑A and AArch64 state. (Implies -march=armv8-a if -mcpu is not specified.)

--cpu=7-A --target=arm-arm-none-eabi -march=armv7-a

Targets the Armv7‑A architecture.

--cpu=Cortex-M4 --target=arm-arm-none-eabi -mcpu=cortex-m4 Targets the Cortex®-M4 processor.
--cpu=Cortex-A15 --target=arm-arm-none-eabi -mcpu=cortex-a15 Targets the Cortex‑A15 processor.
-D -D Defines a preprocessing macro.
--depend -MF Specifies a filename for the makefile dependency rules.
--depend_dir No equivalent. Use -MF to specify each dependency file individually. Specifies the directory for dependency output files.
--depend_format=unix_escaped   Dependency file entries use UNIX-style path separators and escapes spaces with \. This is the default in Arm Compiler 6.
--depend_target -MT Changes the target name for the makefile dependency rule.
--diag_error -Werror Turn compiler warnings into errors.
--diag_suppress=foo -Wno-foo Suppress warning message foo. The error or warning codes might be different between Arm Compiler 5 and Arm Compiler 6.
-E -E Executes only the preprocessor step.
--enum_is_int -fno-short-enums, -fshort-enums Sets the minimum size of an enumeration type.

By default Arm Compiler 5 does not set a minimum size. By default Arm Compiler 6 uses -fno-short-enums to set the minimum size to 32-bit.

--forceline No equivalent. Forces aggressive inlining of functions. Arm Compiler 6 automatically decides whether to inline functions depending on the optimization level.
--fpmode=std -ffp-mode=std Provides IEEE-compliant code with no IEEE exceptions, NaNs, and Infinities. Denormals are sign preserving. This is the default.
--fpmode=fast -ffp-mode=fast Similar to the default behavior, but also performs aggressive floating-point optimizations and therefore it is not IEEE-compliant.
--fpmode=ieee_full -ffp-mode=full Provides full IEEE support, including exceptions.

--fpmode=ieee_fixed

--fpmode=ieee_no_fenv

There are no supported equivalent options. There might be community features that provide these IEEE floating-point modes.

--fpu

For example, --fpu=fpv5_d16

-mfpu

For example, -mfpu=fpv5-d16

Specifies the target FPU architecture.

Note

--fpu=none checks the source code for floating-point operations, and if any are found it produces an error. -mfpu=none prevents the compiler from using hardware-based floating-point functions. If the compiler encounters floating-point types in the source code, it uses software-based floating-point library functions.

The option values might be different. For example fpv5_d16 in Arm Compiler 5 is equivalent to fpv5-d16 in Arm Compiler 6, and targets the FPv5-D16 floating-point extension.

-I -I Adds the specified directories to the list of places that are searched to find included files.
--global_reg=reg_name -ffixed-rN

Prevents the compiler from using the specified core register, unless the use is required for Arm ABI compliance.

In Arm Compiler 5, reg_name is an integer starting from 1 to 8, which maps to registers R4 to R11.

In Arm Compiler 6, N is an integer starting from 5 to 11, which maps to registers R5 to R11.

--ignore_missing_headers -MG Prints dependency lines for header files even if the header files are missing.
--inline Default at -O2 and -O3. There is no equivalent of the --inline option. Arm Compiler 6 automatically decides whether to inline functions at optimization levels -O2 and -O3.
-J -isystem Adds the specified directories to the list of places that are searched to find included system header files.
-L -Xlinker Specifies command-line options to pass to the linker when a link step is being performed after compilation.

--library_interface=armcc

This is the default.

Arm Compiler 6 by default uses the Arm standard C library.

--library_interface=lib

Where lib is one of:

  • aeabi_clib
  • aeabi_clib90
  • aeabi_clib99

-nostdlib -nostdlibinc -fno-builtin

Specifies that the compiler output works with any ISO C library compliant with the Arm Embedded Application Binary Interface (AEABI).

--library_interface=lib

Where lib is not one of:

  • aeabi_clib
  • aeabi_clib90
  • aeabi_clib99
  • armcc

No equivalent.

Arm Compiler 6 assumes the use of an AEABI compliant library.

--licretry No equivalent. There is no equivalent of the --licretry option. The Arm Compiler 6 tools automatically retry failed attempts to obtain a license.
--list_macros -E -dM List all the macros that are defined at the end of the translation unit, including the predefined macros.
--littleend -mlittle-endian Generates code for little-endian data.

--lower_ropi, --no_lower_ropi

-fropi-lowering, -fno-ropi-lowering

Enables or disables less restrictive C when generating Read-Only Position Independent (ROPI) code.

Note

In Arm Compiler 5, when--acps=/ropi is specified, --lower_ropi is not switched on by default. In Arm Compiler 6, when -fropi is specified, -fropi-lowering is switched on by default.

--lower_rwpi, --no_lower_rwpi

-frwpi-lowering, -fno-rwpi-lowering

Enables or disables less restrictive C when generating Read Write Position Independent (RWPI) code.

-M -M Instructs the compiler to produce a list of makefile dependency lines suitable for use by a make utility.
--md -MD Creates makefile dependency files, including the system header files. In Arm Compiler 5, this is equivalent to --md --depend_system_headers.
--md --no_depend_system_headers -MMD Creates makefile dependency files, without the system header files.
--mm -MM Creates a single makefile dependency file, without the system header files. In Arm Compiler 5, this is equivalent to -M --no_depend_system_headers.
--no_comment_section -fno-ident Removes the .comment section from object files.
--no_exceptions -fno-exceptions Disables the generation of code needed to support C++ exceptions.
--no_hide_all -fvisibility=default

Sets the default visibility of ELF symbols to the specified option, unless overridden in the source with the __attribute__((visibility("visibility_type"))) attribute. The default is -fvisibility=hidden.

Note

The behavior of armclang -fvisibility=hidden is different from that of the armcc --hide-all option. With armclang -fvisibility=hidden, extern declarations are visible, and all other symbols are hidden. With armcc --hide-all, all symbols are hidden.
--no_protect_stack -fno-stack-protector Explicitly disables stack protection. See Arm® Compiler 5 and Arm® Compiler 6 stack protection behavior for more information.
-no_rtti, -no_rtti_data

-fno-rtti [ALPHA]

C++ only. -fno-rtti [ALPHA] disables the generation of code that is needed to support Run Time Type Information (RTTI) features.

-o -o Specifies the name of the output file.
-Onum -Onum

Specifies the level of optimization to be used when compiling source files.

The default for Arm Compiler 5 is -O2. The default for Arm Compiler 6 is -O0. For Arm Compiler 6, Arm recommends -O1 rather than -O0 for best trade-off between debug view, code size, and performance. For more information, see Optimization differences.

-Ospace -Oz / -Os

Performs optimizations to reduce image size at the expense of a possible increase in execution time.

-Otime This is the default.

Performs optimizations to reduce execution time at the expense of a possible increase in image size.

There is no equivalent of the -Otime option. Arm Compiler 6 optimizes for execution time by default, unless you specify the -Os or -Oz options.

--phony_targets -MP Emits dummy makefile rules.
--preinclude -include Include the source code of a specified file at the beginning of the compilation.
--protect_stack -fstack-protector,-fstack-protector-strong Enables stack protection on vulnerable functions. See Arm® Compiler 5 and Arm® Compiler 6 stack protection behavior for more information.
--protect_stack_all -fstack-protector-all Enables stack protection on all functions. See Arm® Compiler 5 and Arm® Compiler 6 stack protection behavior for more information.
--relaxed_ref_def -fcommon Places zero-initialized definitions in a common block.
-S -S

Outputs the disassembly of the machine code that the compiler generates.

The output from this option differs between releases. Arm Compiler 5 produces output with armasm syntax while Arm Compiler 6 produces output with GNU syntax.

--show_cmdline -v Shows how the compiler processes the command-line. The commands are shown normalized, and the contents of any via files are expanded.
--split_ldm -fno-ldm-stm

Disables the generation of LDM and STM instructions.

Note that while the armcc --split_ldm option limits the size of generated LDM/STM instructions, the armclang -fno-ldm-stm option disables the generation of LDM and STM instructions altogether.

--split_sections -ffunction-sections

Generates one ELF section for each function in the source file.

In Arm Compiler 6, -ffunction-sections is the default. Therefore, the merging of identical constants cannot be done by armclang. Instead, the merging is done by armlink. See Merging identical constants in the Arm® Compiler armlink User Guide for more information.

--strict -pedantic-errors Generate errors if code violates strict ISO C and ISO C++.
--strict_warnings -pedantic Generate warnings if code violates strict ISO C and ISO C++.
--thumb -mthumb Targets the T32 instruction set.
--no_unaligned_access, --unaligned_access -mno-unaligned-access, -munaligned-access Enables or disables unaligned accesses to data on Arm processors.
--use_frame_pointer, --no_use_frame_pointer -fno-omit-frame-pointer, -fomit-frame-pointer Controls whether a register is reserved for storing the stack frame pointer.

--vectorize

--no_vectorize

-fvectorize

-fno-vectorize

Enables or disables the generation of Advanced SIMD vector instructions directly from C or C++ code.
--via @file Reads an additional list of compiler options from a file.
--vla No equivalent. Support for variable length arrays. Arm Compiler 6 automatically supports variable length arrays in accordance with the language standard.
--vsn --version Displays version information and license details. In Arm Compiler 6 you can also use --vsn.
--wchar16, --wchar32 -fshort-wchar, -fno-short-wchar Sets the size of wchar_t type.

The default for Arm Compiler 5 is --wchar16. The default for Arm Compiler 6 is -fno-short-wchar.