ICC Ada Features

ICC's Ada compiler is tuned for fast, automated program builds and efficient and reliable target code. The runtime system is written in Ada and easily pared down for projects requiring runtime certification. Much of optional Annex C (Systems Programming) Annex D (Real-Time Systems), and Chapter 13 (Representation Issues) is supported, especially for embedded projects. Ada Generics are normally macro expanded, but can optionally use a single shared body to save memory when only Ada83 generic features are used. Various implementation-defined pragmas and attributes are supported, for portabililty and expressiveness.

The ICC Ada graphical debugger provides a nonintrusive debugging environment with both graphical and line-oriented interfaces. Both interfaces allow easy access to Ada variables, types, subprograms, and library units using Ada syntax. The graphical debugger also provides simple point-and-click access to values as well as simultaneous display of many different windows (including different source files) and a structure editor for complex Ada data structures.

ICC Ada uses a program library to keep track of dependencies between compilation units. This provides convenience and flexibility by allowing multiple compilation units in the same source file, and allowing the file name to be different from the unit name. Compiling a unit does not require recompiling anything that the unit depends on. Similarly, compiling an Ada subunit does not cause recompilation of the subunit's parent unit. ICC's Ada libraries can be linked to form a network of libraries, reflecting the high-level structure of a program's subsystems and the dependencies between them.

Ada 95 validated using ACVC 2.0.1. See our validation announcement.

• Support Tools
  • Source-level debugger with command-line-oriented and graphical user interface
  • Compilation unit manager and automatic build facility
  • IDE with language-sensitive editor
  • Profiling
  • Source-code formatting (pretty-printer)
• Language Features
  • 16, 32, and 64-bit signed and unsigned integers
  • 32 and 16-bit floats
  • user-selectable sizes for predefined numeric types
  • shared-body and macro-expanded generics
  • multiple compilation units per source file
  • flexible file naming
  • Easy interfacing to C and assembly
• Graphical Debugger
  • Non-intrusive access to registers, memory locations, and internal structures
  • Debug execution inside generics
  • Supports for breakpoints, conditional breakpoints, and watchpoints
  • Support for user-defined commands and function keys
• Optimizations
  • Value following
  • Common subexpression reduction
  • Redundant check elimination
  • Variable lifetiming
  • Unreferenced code elimination
  • Jump straightening
  • Constant folding
  • Algebraic simplification
  • Dead assignment and code elimination
  • loop optimizations
  • Options specifiable in Ada source or on command line
• Predefined Pragmas
  • Elaborate, Export, Inline, Interface, List, Optimize, Pack, Page, Priority, Pure, Suppress, Volatile
• ICC-Defined Pragmas
  • Interface_name, No_zero, Put, Put_line, and others
• Ada Runtime
  • written in Ada
  • royalty-free
  • can be pared down for projects requiring runtime certification
• Advisory Warnings
  • Missing return statements
  • Exceptions to be raised at run time
  • Variables never initialized or modified
  • Unused variable and parameters
  • Dead assignments
• Compilation Library System
  • Automatic build from Ada source files
  • Automatic recompilation from dependencies
  • no unnecessary recompilation
  • no recompilation of subunit parents or with'ed units
  • Support for non-Ada files
• Easy Integration with C
  • INTERFACE and EXPORT pragmas allow calls to C from Ada and to Ada from C
  • Supports passing of both scalar and structure parameters to C
  • Pragma FOREIGN for automatic import of C files and libraries
  • Compatible object file format