Tools Brochure

We also have a printable brochure listing the available development tools

» Find Out More

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:

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

C/C++ Compiler

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:

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:

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:

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.