• Selecting the processor selects the appropriate architecture,Floating-Point Unit (FPU), and memory organization.

• The supported --cpu values include all current ARM product names or architecture versions.

  Other ARM architecture-based processors, such as the Marvell Feroceon and the Marvell XScale, are also supported.

• If you specify a processor for the --cpu option, the compiled code is optimized for that processor.
  This enables the compiler to use specific coprocessors or instruction scheduling for optimum performance.

• If you specify an architecture name for the --cpu option, the code is compiled to run on any processor supporting that architecture.
  For example, --cpu=5TE produces code that can be used by theARM926EJ-S^®.

• Some specifications of --cpu imply an --fpu selection.
  For example, when compiling with the --arm option, --cpu=ARM1136JF-S implies --fpu=vfpv2.
  Similarly, --cpu=Cortex-R4F implies --fpu=vfpv3_d16.

  Note

  Any explicit FPU, set with --fpu on the command line, overrides an implicit FPU.

• If no --fpu option is specified and no --cpu option is specified, --fpu=softvfp is used.

• Specifying a processor or architecture that supports Thumb instructions,
  such as --cpu=ARM7TDMI, does not make the compiler generate Thumb code.
  It only enables features of the processor to be used, such as long multiply.
  Use the --thumb option to generate Thumb code, unless the processor is a Thumb-only processor, for example Cortex-M4.
  In this case, --thumb is not required.

  Note

  Specifying the target processor or architecture might make the object code generated
  by the compiler incompatible with other ARM processors.
  For example, code compiled for architecture ARMv6 might not run on an ARM920T processor,
  if the compiled code includes instructions specific to ARMv6.
  Therefore, you must choose the lowest common denominator processor suited to your purpose.

• If you are compiling code that is intended for mixed ARM/Thumb systems for processors that support ARMv4T or ARMv5T,
  then you must specify the interworking option --apcs=/interwork.
  By default, this is enabled for processors that support ARMv5T or above.

• If you compile for Thumb, that is with the --thumb option on the command line,
  the compiler compiles as much of the code as possible using the Thumb instruction set.
  However, the compiler might generate ARM code for some parts of the compilation.
  For example, if you are compiling code for a Thumb-1 processor and using VFP,
  any function containing floating-point operations is compiled for ARM.

• If the architecture you are compiling code for only supports Thumb, there is no need to specify --thumb on the command line.
  For example, if compiling code for ARMv7-M with --cpu=7-M, you do not have to specify --thumb on the command line,
  because ARMv7-M only supports Thumb-2.
  Similarly, ARMv6-M and other Thumb-only architectures.

Note

If you enter armcc --thumb --fpu=vfpv2 on the command line,
the compiler compiles as much of the code using the Thumb instruction set as possible,
but hard floating-point sensitive functions are compiled to ARM code.
In this case, the value of the predefine __thumb is not correct.

• Compiling with --thumb behaves in a similar way to --fpu=softvfp
except that it links with floating-point libraries that use VFP instructions.

• Compiling with --arm behaves in a similar way to --fpu=vfpv2
except that all functions are given software floating-point linkage.
  This means that functions pass and return floating-point arguments and
  results in the same way as --fpu=softvfp, but use VFP instructions internally.

Note

If you specify softvfp+vfpv2 with the --arm or --thumb option for C code,
it ensures that your interworking floating-point code is compiled to use software floating-point linkage.