APOGEE'S OPTIMIZING COMPILERS

Apogee's C/C++ optimizing compilers offer outstanding features, rich selection of compiler options, and high run-time performance of generated code.

Designed specifically for RISC processors, the compilers performs many optimizations that utilize the high-performance features of such processors, such as small sets of fast multiply-issued instructions, multi-stage pipelines, large sets of hardware registers, and multiple functional units. For example, each compiler performs extensive instruction scheduling to maximize the number of hardware instructions executed in each machine cycle, and efficiently assigns hardware registers to minimize the number of memory accesses.

Each compiler also performs many hardware-independent optimizations that aggressively transform compiled programs to minimize the number of computations each such program must execute when running on a target processor.

The compilers are available in form of cross-compilers hosted on Solaris/SPARC, Windows/x86, and Linux/x86 development platforms and targeted at various types of embedded processors.

In addition, Apogee markets the Solaris/SPARC-hosted and targeted C/C++ and FORTRAN77/90 "native" compilers.

Features of C/C++ Compilers

• The C/C++ cross-compilers for embedded systems are available in "generic" assembler-code-generating configurations, one configuration per each RISC architecture supported by Apogee. (The currently supported architectures are: PowerPC, MIPS32/64, ARM32, ARM16 (Thumb), StrongARM, XScale, and SPARC). The assembler code files produced by each generic compiler conform to the most popular ABI (Application Binary Interface) defined for the architecture targeted by this compiler, for example IBM/Motorola ELF-DWAF2 EABI (Embedded ABI) in case of the PowerPC architecture.


• Each generic cross-compiler can be adapted by Apogee (or, with Apogee's help, by a source-code licensee of Apogee's compiler technology) for specific implementations of the targeted RISC architecture. For example, the generic PowerPC compiler has been adapted for various implementations of the PowerPC architecture utilized in IBM's and Motorola' processors.


• Each generic cross-compiler can also be adapted to produce assembler code file conforming to a customer-requested ABI. For example, the generic ARM compiler has been adapted to produce assembler code files acceptable to the ARM-targeted GNU assembler, or to the assembler from ARM Ltd.'s toolset, each of which can be requested by a compiler option.


• The C/C++ native compiler for Solaris/SPARC platforms is compatible with Sun's C/C++ compiler, conforms to Sun's Solaris ABI, and produces the assembler code files acceptable to Sun's Solaris assembler.


• Each C/C++ cross-compiler (as well as the native SPARC compiler) accepts source code programs written in ANSI/ISO standard C or C++. Also, if instructed by a compiler option, it accepts the programs written in K&R C, Cfront 2.1/3.0, Microsoft Visual C/C++, or GNU C/C++. In addition, each compiler can be used in a "mixed" mode, in which it accepts any legacy C or C++ source code program, attempts to generate correct assembler code files for it, and issues warning messages about any non-standard uses of the C or C++ languages. This allows the use of each compiler as a tool for converting legacy C or C++ programs to programs that are compliant with the C or C++ ANSI standards.


• Each compiler performs extensive optimizations at local, global, and inter-procedural levels, and fully optimizes all types of programs irrespective of their complexities and sizes. In addition, some optimizations are repeated several times because subsequent optimizations may create additional opportunities for the optimizations already done. This results in each compiler producing faster code than the compilers from other vendors not only for popular benchmarks but, more importantly, for "real-life" programs.


• Unlike most optimizing compilers that tend to be significantly slower at high optimization levels, Apogee compilers are surprisingly fast even at the highest optimization level.


• Each compiler allows a high degree of control over the compilation process. For example, there are compiler options that permit a fine degree of control over various optimizations (runtime footprint, runtime speed, scope and type of optimizations, etc.), or an option allowing the user to specify the "endiannes". Each option can be defined (or its value set) in the compiler invocation command. Some option can also be defined (or their values set) by pragma statements placed in source code programs.


• The "front-end" (FE) of each compiler includes the FE from Edison Design Group (EDG), which is widely recognized as the best C/C++ FE in the industry. (Note that Apogee was the very first licensee of this FE.)


• The "back-end" (BE) of each compiler is based on the Apogee-invented table-driven code generation technology that uses a set of "target machine description" tables produced by special Apogee's tool to obtain needed information about a given target processor (the machine instructions and their latencies, registers, pipeline stages, functional units, cache organization, etc.). This allows fine tuning of hardware-specific optimizations performed by the BE of each compiler for various implementations of the targeted RISC architecture.


• The Compiler Core of each compiler (the "middle part" between the FE and BE) includes Apogee-invented global optimization and global register allocation technologies that are considered to be the best in the industry.


• All compilers share a common code base and key technologies. Specifically, each compiler includes practically all of the FE code, about 95% of the Compiler Core code, and about 70% of the BE code. This means that source code licensees of Apogee's compilers find these compilers relatively easy to maintain, update, and enhance in spite of their complexity and advanced technologies used in them.


• Each compiler can be built in a self-checking configuration that includes many assertion checks placed in the source code of all main compiler phases. These checks are quite helpful in isolating a portion of the source code of a given compiler phase that has a user-reported bug or other problem. In fact, a large majority of bugs reported by users of Apogee's compilers thus far showed-up as failures of assertion checks in the self-checking configurations of the compilers we have at Apogee. This often results in Apogee being able to isolate a given bug or other problem and devise a fix or, at the least, a temporary work-around for it in a few hours.

Home | Corporate Info | Products | Download | Order | News | Resellers