RealView Compilation Tools

If you want the smallest, fastest code with all the features...

The RealView Compilation Tools (RVCT) is part of RVDS, and includes everything you need to build C and C++ applications for ARM processors. It includes the following:

• Optimising ANSI C Compiler - the best code density and performance available for ARM
• Optimising Embedded C++ Compiler (EC++) - full C++ implementation with efficient code
• Linker
• Assembler - macro capability
• Image Conversion Tool - for producing binaries for ROM, etc.
• ARM Object file Librarian/Archiver
• C Libraries
• RogueWave C++ Libraries

RVCT is available for Windows, Solaris, HP/UX and Red Hat Linux.

New features in RCVT 2.0 (since 1.2)

The major enhancements in RVCT 2.0 include

• Full ISO C++ support by way of the EDG (Edison Design Group) front-end (including namespaces, templates, intelligent implementation of Run-Time Type Information (RTTI), but excluding exceptions - this is planned for RVCT 2.1)
• Typically 5% performance improvement for ARM-state code (compiled with armcc --arm -Otime -cpu ARM9E)
• Typically 2% code size reduction for Thumb-state code (compiled with armcc --thumb -Ospace -cpu ARM9E)
• Support for ARM Architecture v6
• Compliance with the ARM C/C++ Embedded Application Binary Interface (EABI)
• ARM and Thumb compilation per-function (using "#pragma arm" and "#pragma thumb")
• Five floating-point models (selected with "--fpmode")
• Re-engineered Inline Assembler and new Embedded Assembler

C/C++ Compiler

• Overall the best code size and speed available for ARM - includes options for changing the trade-off between these
• Supports both ARM and Thumb instruction sets
• Supports all available ARM architectures
• Selectable debug and optimisation levels to trade off debuggability vs performance
• Supports processor-specific optimisations for ARM9, ARM10, XScale and StrongARM, providing even higher performance for particular targets, but without sacrificing binary compatibility
• Object files conform to industry standard ELF and DWARF formats
• Powerful macro assembler for ARM and Thumb instructions

The core compilers have been around for many years and have been progressively refined to offer the best available code size and speed characteristics for a wide range of user code. The compilers provide a full set of warnings and errors as required by ANSI, but also provide option to allow processing of 'old-style' C code which is useful for porting.

The compiler makes full use of the ARM register set, even using load/store multiple instructions where possible to optimise data throughput. The compilers produce images up to 25% smaller than other leading tool suites which translates into less ROM or flash space or more features.

Specific optimisations are provided for the various ARM architecture versions (v3, v4T, v5, v6) with further gains in code speed and size. ARM's detailed knowledge and understanding of the ARM architecture allows it to lead the field in this area. For example, some processors benefit from keeping loads as far after stores as possible. Others benefit from loading a register a few cycles before it us used. While code produced for one processor may not be optimal for another, it will still work (provided it is up to the same architecture level), preserving binary compatibilty.

Inline Assembler

The compiler's in-built assembler is a wonderful tool when you need it. It allows you to embed 'high-level' assembly code into your C program, and make use of C variables and expressions. The compiler takes care of converting your high-level code into real assembler as efficiently as possible.

Consider the following code fragment:

int start_dsp (dsp_info *area, int code, int x, int y, int z)
   {
   int status;

   __asm
      {
      mov   r6, code
      mov   r7, #area + x + y * 64
      mov   r8, #884392
      str      r0, [area, #0]
      str      r0, DSP_START
      ldr      status, DSP_STATUS
      orr     status, status, z << 8
      };
   return status;
   }

The compiler takes care of evaluation the expressions and accesses to C variables, as well as the large constant move into r8. It ensures that registers used in the function are saved and restored as required by the APCS.

A separate assembler tool is also provided with a more conventional feature set. This can still be useful where large amounts of assembler must be written. The assembler has a good range of high-level directives including declaring areas of memory, looping, powerful macros, variables and conditional statements.

Linker

The ARM linker is designed for embedded development. It uses the standard ELF and DWARF file formats for object files and debug information.

The linker provides a very flexible scatter-loading facility, allowing placement of code and data anyway in the target memory map on startup. The allows a program in a single ROM (for example) to copy code and/or data  to faster SRAM or SDRAM on startup automatically, just by specifying the relevant memory regions in the scatter loading definition.

The linker can remove unused code area and report those which were removed. This is useful for removing debug or performance testing code for final production builds. and can in some case reduce the resulting image dramatically with very little programmer effort.

Image Convertion Tool (fromelf)

Fromelf converts from its native ELF format to the following downloadable and ROMable formats:

• Binary
• Motorola 32-bit S record
• Intel Hex-32
• Byte oriented hex formats

Fromelf can also provide a disassembly or symbol listing for an input file.

ARM Object File Librarian

This allows groups of object files to be combined into libraries for easier use. Various operations are supported on libraries including adding and deleting members, and merging of libraries.

Semihosting

One of the really nice features of the ARM tools is full semi-hosting. Semi-hosting means that you get some of the host facilities on the target.

For example, if you are using Multi-ICE or a platform supported by uHAL, you can use printf() to output on the host computer, you can open files with fopen(), you can get input from the user with scanf() or even check the time. This allows standard C programs to run on target hardware without needing to be ported.

This can save huge amounts of time during development, as test suites and benchmark programs used on the host can run largely unmodified on the target.

Semihosting even works in the ARMulator simulator.

Of course in the final product, the code must be made stand-alone. uHAL actually provides a facility for printf() and scanf() to redirect to the serial port, for example. But in most cases this code would be taken out by means of '#ifdef DEVELOPMENT' or similar.

C and RogueWave C++ Libraries

The full ANSI standard C libraries consist of:

• Functions defined by the ISO C library standard
• Target-dependent functions used to implement the C library functions in the semi-hosted execution environment
• Helper functions used by the C and C++ compilers

Target-dependent C library functions can be re-implemented for any execution environment (see semi-hosting above). The floating-point library uses the ARM floating-point environment, which is an implementation of the IEEE 754 standard for binary floating-point arithmetic.

The C++ libraries include:

• ISO C++ Standard Template Libraries
• The RogueWave Standard C++ Library version 2.01.01

ARM C/C++ EABI

EABI is a cross-platform standard developed by ARM, in collaboration with major OS and tools vendors, which specifies how executables and shared objects work together for OS or other execution environments. This standard enables RealView Compilation Tools version 2.0 to be easily integrated with custom development environments and third-party tools that conform to the ARM C/C++ EABI standard. Library developers also benefit as they can create libraries that work with any ARM C/C++ EABI compliant compiler, so increasing the number of compatible standard libraries available for the ARM architecture for many application areas.