Compiler Models

An object-code compiler is represented in CodeSonar by a compiler model.

• Available Compiler Models
• Model Interfaces
• ABI Keys
• Predefined Macros
• Include Directories
• Notes

CodeSonar emulates the interface of a set of standard C compilers for two reasons:

• It is convenient to be able to build the CodeSonar project using syntax that is similar to the syntax expected by the "real" compiler used to build the software project. This is especially true if there is already a makefile or similar system for building the "real" executable. In most cases, the same makefile can be used with minimal changes, assuming a similar compiler model is selected.
• A particular compiler may define its own preprocessor symbols and include directories on which your program may rely in order to build correctly.

Note that it is not essential to use a compiler model specific to your object-code compiler. You only need to use a compatible model: one that processes command lines and defines preprocessor symbols in an adequate way for your program.

Available Compiler Models

The compiler models available on your CodeSonar system will be a combination of pre-installed models and custom models (if any).

• Pre-installed Compiler/Driver Models
• Supported Without Compiler Models
• Custom Compiler Models

Pre-installed Compiler/Driver Models

CodeSonar comes with a number of pre-installed compiler and compiler driver models:

Source files for these models are provided in $CSONAR/csurf/include.

Additional aliases for compiler models are specific to the operating system on which CodeSonar is installed:

For full details of all native compilers and drivers that CodeSonar recognizes and maps to compiler models by default, see section Compilers Recognized by CodeSonar.

Supported Without Compiler Models

(Windows Only) CodeSonar provides special handling for builds with CodeWarrior installations that use DLLs: see Using CodeSonar With CodeWarrior for details.

Custom Compiler Models

If none of the available compiler models are suitable, a custom model will be required. For more information, see section Authoring Compiler Models.

Model Interfaces

The following sections describe the compiler models.

ABI Keys

CodeSonar allows users to associate compilation units with ABI keys.

• CodeSonar will prefer to link compilation units with the same ABI key when constructing the CodeSonar project.
• When a single source file is compiled multiple times with different ABI keys, one instance will be kept for each key.

Associating an ABI Key with a Compilation Unit

CodeSonar provides three mechanisms for associating ABI keys with compilation units. In most cases, the COMPILER_MODELS mechanism (described first in the following list) will be the most suitable one.

• To associate an ABI key with all compilation units resulting from a particular compiler-to-model mapping, use a COMPILER_MODELS rule. For example, to specify that invocations of path/to/mycompiler should be modeled with the gcc compiler model and that ABI key mykey should be associated with the resulting compilation units, specify the following configuration file rule.

  COMPILER_MODELS += path/to/mycompiler -> gcc:mykey
  

  When COMPILER_MODELS mappings include an ABI key in this way, the corresponding project-compiler configuration file name will include the key. This allows users to specify different configuration settings for different ABIs.
• To associate an ABI key with all compilation units governed by a particular configuration file, use EDG_FRONTEND_OPTIONS_APPEND or EDG_FRONTEND_OPTIONS_PREPEND to specify a value for front end option --cs_user_abi_key in that file. For example, to specify that all compilation units in a particular project should be associated with ABI key myprojkey, specify the following in the general project configuration file.

  EDG_FRONTEND_OPTIONS_APPEND += --cs_user_abi_key myprojkey
  

  Note that this will not cause CodeSonar to generate or use a project-compiler configuration file whose name includes myprojkey. Only ABI keys specified with COMPILER_MODELS rules have this effect.
• If you write a custom compiler model, you can have the model specify front end option --cs_model_abi_key K to associate ABI key K with compilation units produced by that model.

  Note that this will not cause CodeSonar to generate or use a project-compiler configuration file whose name includes K. Only ABI keys specified with COMPILER_MODELS rules have this effect.

ABI Key Formats

ABI keys fall into two classes.

• Keys that conform to a special, model-specific format.
  These keys are used both to correlate different compilation units and to and convey explicit configuration information to the compiler model.

  The following compiler models provide model-specific ABI key formats. Note that all model-specific ABI key formats allow for optional, user-specified suffixes: this permits ABIs to be distinguished (and therefore have different project-compiler configuration files) even if they do not differ in the tuple of parameters specified by the key format.

  See individual compiler model manual pages for further details, including annotated examples.

  Compiler Model	Model-Specific ABI Key Format	Example
  ch38, shc, shcpp	<Hitachi_version>.<Renesas_version>.<forceC> or <Hitachi_version>.<Renesas_version>.<forceC>.<user_string>	0x602.0x602.1 0x602.0x602.1.abi1 0x602.0x602.1.abi2
  cl	<build_target>.<cl_version>.<cl_build> or <build_target>.<cl_version>.<cl_build>.<user_string>	x64.1600.40219 x64.1600.40219.thisABI x64.1600.40219.thatABI
  dcc	<c_compiler>.<cpp_compiler>.<assembler> or <c_compiler>.<cpp_compiler>.<assembler>.<user_string>	ctoa.etoa.das ctoa.etoa.das.yourABI ctoa.etoa.das.myABI
  gcc, gpp	<pointer_size>.<gcc_version>.<gnu_mode>.<gcc_invoke> or <pointer_size>.<gcc_version>.<gnu_mode>.<gcc_invoke>.<user_string>	32.30303.1.0 32.30303.1.0.abiA 32.30303.1.0.abiB

• Arbitrary, user-selected keys.
  These are used only to correlate different compilation units: they convey no additional information. Arbitrary keys can be used with any compiler model, but make sure that their formats are clearly distinguished from those used by model-specific keys, and that the keys are distinct from the names of compiler models. The former can be achieved by, for example, avoiding the use of the '.' character in arbitrary keys.

Predefined Macros

CodeSonar predefines some macros. They can be divided into two categories: those that are always defined, and those that are defined for a particular compiler model. The following table shows the macros that are always defined.

Include Directories

The set of include directories for a modeled compilation will be those that are:

• specified by command arguments (see individual compiler model documentation pages for details),
  or
• determined by invoking the underlying compiler (if the compiler model uses this technique),
  or
• one of the following:
  • $CSHOME/csurf/csinclude
  • $CSHOME/csurf/csinclude/mingw32
  • $CSHOME/csurf/csinclude/mingw
  • $CSHOME/csurf/csinclude/gcc
  (where $CSHOME is the CodeSonar installation directory).

Notes

In previous releases, CodeSonar has transitioned to using compiler models implemented in C++, where previously the models were implemented in STk. STk compiler models are no longer supported. If you have previously implemented a custom STk compiler model and need assistance converting it to C++ or Python, contact CodeSecure.