3.2 Switches for gcc

The gcc command accepts switches that control the compilation process. These switches are fully described in this section. First we briefly list all the switches, in alphabetical order, then we describe the switches in more detail in functionally grouped sections.

More switches exist for GCC than those documented here, especially for specific targets. However, their use is not recommended as they may change code generation in ways that are incompatible with the Ada run-time library, or can cause inconsistencies between compilation units.

• Output and Error Message Control
• Warning Message Control
• Debugging and Assertion Control
• Validity Checking
• Style Checking
• Run-Time Checks
• Using gcc for Syntax Checking
• Using gcc for Semantic Checking
• Compiling Different Versions of Ada
• Character Set Control
• File Naming Control
• Subprogram Inlining Control
• Auxiliary Output Control
• Debugging Control
• Exception Handling Control
• Units to Sources Mapping Files
• Integrated Preprocessing
• Code Generation Control

-b target

Compile your program to run on target, which is the name of a system configuration. You must have a GNAT cross-compiler built if target is not the same as your host system.

-Bdir

Load compiler executables (for example, gnat1, the Ada compiler) from dir instead of the default location. Only use this switch when multiple versions of the GNAT compiler are available. See Options for Directory Search, for further details. You would normally use the -b or -V switch instead.

-c

Compile. Always use this switch when compiling Ada programs.

Note: for some other languages when using gcc, notably in the case of C and C++, it is possible to use use gcc without a -c switch to compile and link in one step. In the case of GNAT, you cannot use this approach, because the binder must be run and gcc cannot be used to run the GNAT binder.

-fno-inline

Suppresses all back-end inlining, even if other optimization or inlining switches are set. This includes suppression of inlining that results from the use of the pragma Inline_Always. Any occurrences of pragma Inline or Inline_Always are ignored, and -gnatn and -gnatN have no effect if this switch is present.

-fno-inline-functions

Suppresses automatic inlining of subprograms, which is enabled if -O3 is used.

-fno-inline-small-functions

Suppresses automatic inlining of small subprograms, which is enabled if -O2 is used.

-fno-inline-functions-called-once

Suppresses inlining of subprograms local to the unit and called once from within it, which is enabled if -O1 is used.

-fno-ivopts

Suppresses high-level loop induction variable optimizations, which are enabled if -O1 is used. These optimizations are generally profitable but, for some specific cases of loops with numerous uses of the iteration variable that follow a common pattern, they may end up destroying the regularity that could be exploited at a lower level and thus producing inferior code.

-fno-strict-aliasing

Causes the compiler to avoid assumptions regarding non-aliasing of objects of different types. See Optimization and Strict Aliasing for details.

-fstack-check

Activates stack checking. See Stack Overflow Checking for details.

-fstack-usage

Makes the compiler output stack usage information for the program, on a per-function basis. See Static Stack Usage Analysis for details.

-fcallgraph-info[=su]

Makes the compiler output callgraph information for the program, on a per-file basis. The information is generated in the VCG format. It can be decorated with stack-usage per-node information.

-g

Generate debugging information. This information is stored in the object file and copied from there to the final executable file by the linker, where it can be read by the debugger. You must use the -g switch if you plan on using the debugger.

-gnat83

Enforce Ada 83 restrictions.

-gnat95

Enforce Ada 95 restrictions.

-gnat05

Allow full Ada 2005 features.

-gnat2005

Allow full Ada 2005 features (same as -gnat05)

-gnat12

-gnat2012

Allow full Ada 2012 features (same as -gnat12)

-gnata

Assertions enabled. Pragma Assert and pragma Debug to be activated. Note that these pragmas can also be controlled using the configuration pragmas Assertion_Policy and Debug_Policy. It also activates pragmas Check, Precondition, and Postcondition. Note that these pragmas can also be controlled using the configuration pragma Check_Policy.

-gnatA

Avoid processing gnat.adc. If a gnat.adc file is present, it will be ignored.

-gnatb

Generate brief messages to stderr even if verbose mode set.

-gnatB

Assume no invalid (bad) values except for 'Valid attribute use (see Validity Checking).

-gnatc

Check syntax and semantics only (no code generation attempted).

-gnatC

Generate CodePeer information (no code generation attempted). This switch will generate an intermediate representation suitable for use by CodePeer (.scil files). This switch is not compatible with code generation (it will, among other things, disable some switches such as -gnatn, and enable others such as -gnata).

-gnatd

Specify debug options for the compiler. The string of characters after the -gnatd specify the specific debug options. The possible characters are 0-9, a-z, A-Z, optionally preceded by a dot. See compiler source file debug.adb for details of the implemented debug options. Certain debug options are relevant to applications programmers, and these are documented at appropriate points in this users guide.

-gnatD

Create expanded source files for source level debugging. This switch also suppress generation of cross-reference information (see -gnatx).

-gnatec=path

Specify a configuration pragma file (the equal sign is optional) (see The Configuration Pragmas Files).

-gnateDsymbol[=value]

Defines a symbol, associated with value, for preprocessing. (see Integrated Preprocessing).

-gnateE

Generate extra information in exception messages, in particular display extra column information and the value and range associated with index and range check failures, and extra column information for access checks.

-gnatef

Display full source path name in brief error messages.

-gnateG

Save result of preprocessing in a text file.

-gnatem=path

Specify a mapping file (the equal sign is optional) (see Units to Sources Mapping Files).

-gnatep=file

Specify a preprocessing data file (the equal sign is optional) (see Integrated Preprocessing).

-gnateP

Turn categorization dependency errors into warnings. Ada requires that units that WITH one another have compatible categories, for example a Pure unit cannto WITH a Preelaborate unit. If this switch is used, these errors become warnings (which can be ignored, or suppressed in the usual manner). This can be useful in some specialized circumstances such as the temporary use of special test software.

-gnateS

Generate SCO (Source Coverage Obligation) information in the ALI file. This information is used by advanced coverage tools. See unit SCOs in the compiler sources for details in files scos.ads and scos.adb.

-gnatE

Full dynamic elaboration checks.

-gnatf

Full errors. Multiple errors per line, all undefined references, do not attempt to suppress cascaded errors.

-gnatF

Externals names are folded to all uppercase.

-gnatg

Internal GNAT implementation mode. This should not be used for applications programs, it is intended only for use by the compiler and its run-time library. For documentation, see the GNAT sources. Note that -gnatg implies -gnatwae and -gnatyg so that all standard warnings and all standard style options are turned on. All warnings and style messages are treated as errors.

-gnatG=nn

List generated expanded code in source form.

-gnath

Output usage information. The output is written to stdout.

-gnatic

Identifier character set (c=1/2/3/4/8/9/p/f/n/w). For details of the possible selections for c, see Character Set Control.

-gnatI

Ignore representation clauses. When this switch is used, representation clauses are treated as comments. This is useful when initially porting code where you want to ignore rep clause problems, and also for compiling foreign code (particularly for use with ASIS). The representation clauses that are ignored are: enumeration_representation_clause, record_representation_clause, and attribute_definition_clause for the following attributes: Address, Alignment, Bit_Order, Component_Size, Machine_Radix, Object_Size, Size, Small, Stream_Size, and Value_Size. Note that this option should be used only for compiling – the code is likely to malfunction at run time.

-gnatjnn

Reformat error messages to fit on nn character lines

-gnatk=n

Limit file names to n (1-999) characters (k = krunch).

-gnatl

Output full source listing with embedded error messages.

-gnatL

Used in conjunction with -gnatG or -gnatD to intersperse original source lines (as comment lines with line numbers) in the expanded source output.

-gnatm=n

Limit number of detected error or warning messages to n where n is in the range 1..999999. The default setting if no switch is given is 9999. If the number of warnings reaches this limit, then a message is output and further warnings are suppressed, but the compilation is continued. If the number of error messages reaches this limit, then a message is output and the compilation is abandoned. The equal sign here is optional. A value of zero means that no limit applies.

-gnatn

Activate inlining for subprograms for which pragma Inline is specified. This inlining is performed by the GCC back-end.

-gnatN

Activate front end inlining for subprograms for which pragma Inline is specified. This inlining is performed by the front end and will be visible in the -gnatG output.

When using a gcc-based back end (in practice this means using any version of GNAT other than the JGNAT, .NET or GNAAMP versions), then the use of -gnatN is deprecated, and the use of -gnatn is preferred. Historically front end inlining was more extensive than the gcc back end inlining, but that is no longer the case.

-gnato

Enable numeric overflow checking (which is not normally enabled by default). Note that division by zero is a separate check that is not controlled by this switch (division by zero checking is on by default).

-gnatp

Suppress all checks. See Run-Time Checks for details. This switch has no effect if cancelled by a subsequent -gnat-p switch.

-gnat-p

Cancel effect of previous -gnatp switch.

-gnatP

Enable polling. This is required on some systems (notably Windows NT) to obtain asynchronous abort and asynchronous transfer of control capability. See Pragma Polling, for full details.

-gnatq

Don't quit. Try semantics, even if parse errors.

-gnatQ

Don't quit. Generate ALI and tree files even if illegalities.

-gnatr

Treat pragma Restrictions as Restriction_Warnings.

-gnatR[0/1/2/3[s]]

Output representation information for declared types and objects.

-gnats

Syntax check only.

-gnatS

Print package Standard.

-gnatt

Generate tree output file.

-gnatTnnn

All compiler tables start at nnn times usual starting size.

-gnatu

List units for this compilation.

-gnatU

Tag all error messages with the unique string “error:”

-gnatv

Verbose mode. Full error output with source lines to stdout.

-gnatV

Control level of validity checking (see Validity Checking).

-gnatwxxx

Warning mode where xxx is a string of option letters that denotes the exact warnings that are enabled or disabled (see Warning Message Control).

-gnatWe

Wide character encoding method (e=n/h/u/s/e/8).

-gnatx

Suppress generation of cross-reference information.

-gnatX

Enable GNAT implementation extensions and latest Ada version.

-gnaty

Enable built-in style checks (see Style Checking).

-gnatzm

Distribution stub generation and compilation (m=r/c for receiver/caller stubs).

-Idir

Direct GNAT to search the dir directory for source files needed by the current compilation (see Search Paths and the Run-Time Library (RTL)).

-I-

Except for the source file named in the command line, do not look for source files in the directory containing the source file named in the command line (see Search Paths and the Run-Time Library (RTL)).

-mbig-switch

This standard gcc switch causes the compiler to use larger offsets in its jump table representation for case statements. This may result in less efficient code, but is sometimes necessary (for example on HP-UX targets) in order to compile large and/or nested case statements.

-o file

This switch is used in gcc to redirect the generated object file and its associated ALI file. Beware of this switch with GNAT, because it may cause the object file and ALI file to have different names which in turn may confuse the binder and the linker.

-nostdinc

Inhibit the search of the default location for the GNAT Run Time Library (RTL) source files.

-nostdlib

Inhibit the search of the default location for the GNAT Run Time Library (RTL) ALI files.

-O[n]

n controls the optimization level.

n = 0

No optimization, the default setting if no -O appears

n = 1

Normal optimization, the default if you specify -O without an operand. A good compromise between code quality and compilation time.

n = 2

Extensive optimization, may improve execution time, possibly at the cost of substantially increased compilation time.

n = 3

Same as -O2, and also includes inline expansion for small subprograms in the same unit.

n = s

Optimize space usage

See also Optimization Levels.

-pass-exit-codes

Catch exit codes from the compiler and use the most meaningful as exit status.

--RTS=rts-path

Specifies the default location of the runtime library. Same meaning as the equivalent gnatmake flag (see Switches for gnatmake).

-S

Used in place of -c to cause the assembler source file to be generated, using .s as the extension, instead of the object file. This may be useful if you need to examine the generated assembly code.

-fverbose-asm

Used in conjunction with -S to cause the generated assembly code file to be annotated with variable names, making it significantly easier to follow.

-v

Show commands generated by the gcc driver. Normally used only for debugging purposes or if you need to be sure what version of the compiler you are executing.

-V ver

Execute ver version of the compiler. This is the gcc version, not the GNAT version.

-w

Turn off warnings generated by the back end of the compiler. Use of this switch also causes the default for front end warnings to be set to suppress (as though -gnatws had appeared at the start of the options).

You may combine a sequence of GNAT switches into a single switch. For example, the combined switch

     -gnatofi3

is equivalent to specifying the following sequence of switches:

     -gnato -gnatf -gnati3

The following restrictions apply to the combination of switches in this manner:

• The switch -gnatc if combined with other switches must come first in the string.
• The switch -gnats if combined with other switches must come first in the string.
• The switches

  -gnatzc and -gnatzr may not be combined with any other switches, and only one of them may appear in the command line.

• The switch -gnat-p may not be combined with any other switch.
• Once a “y” appears in the string (that is a use of the -gnaty switch), then all further characters in the switch are interpreted as style modifiers (see description of -gnaty).
• Once a “d” appears in the string (that is a use of the -gnatd switch), then all further characters in the switch are interpreted as debug flags (see description of -gnatd).
• Once a “w” appears in the string (that is a use of the -gnatw switch), then all further characters in the switch are interpreted as warning mode modifiers (see description of -gnatw).
• Once a “V” appears in the string (that is a use of the -gnatV switch), then all further characters in the switch are interpreted as validity checking options (see Validity Checking).
• Option “em”, “ec”, “ep”, “l=” and “R” must be the last options in a combined list of options.