Alphabetical List of All Switches (GNAT User’s Guide for Native Platforms)

#### 4.3.1 Alphabetical List of All Switches ¶

`-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.

`-B`dir'`

  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 the “Options for Directory Search” section in the Using the GNU Compiler Collection (GCC) manual 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.

`-fcallgraph-info[=su,da]`

  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 additional, per-node and/or per-edge information, if a list of comma-separated markers is additionally specified. When the `su` marker is specified, the callgraph is decorated with stack usage information; it is equivalent to `-fstack-usage`. When the `da` marker is specified, the callgraph is decorated with information about dynamically allocated objects.

`-fdiagnostics-format=json`

  Makes GNAT emit warning and error messages as JSON. Inhibits printing of text warning and errors messages except if `-gnatv` or `-gnatl` are present. Uses absolute file paths when used along `-gnatef`.

`-fdump-scos`

  Generates 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`.

`-fgnat-encodings=[all|gdb|minimal]`

  This switch controls the balance between GNAT encodings and standard DWARF emitted in the debug information.

`-flto[=`n']`

  Enables Link Time Optimization. This switch must be used in conjunction with the `-Ox` switches (but not with the `-gnatn` switch since it is a full replacement for the latter) and instructs the compiler to defer most optimizations until the link stage. The advantage of this approach is that the compiler can do a whole-program analysis and choose the best interprocedural optimization strategy based on a complete view of the program, instead of a fragmentary view with the usual approach. This can also speed up the compilation of big programs and reduce the size of the executable, compared with a traditional per-unit compilation with inlining across units enabled by the `-gnatn` switch. The drawback of this approach is that it may require more memory and that the debugging information generated by `-g` with it might be hardly usable. The switch, as well as the accompanying `-Ox` switches, must be specified both for the compilation and the link phases. If the `n` parameter is specified, the optimization and final code generation at link time are executed using `n` parallel jobs by means of an installed `make` program.

`-fno-inline`

  Suppresses all inlining, unless requested with pragma `Inline_Always`. The effect is enforced regardless of other optimization or inlining switches. Note that inlining can also be suppressed on a finer-grained basis with pragma `No_Inline`.

`-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.

`-fno-strict-overflow`

  Causes the compiler to avoid assumptions regarding the rules of signed integer overflow. These rules specify that signed integer overflow will result in a Constraint_Error exception at run time and are enforced in default mode by the compiler, so this switch should not be necessary in normal operating mode. It might be useful in conjunction with `-gnato0` for very peculiar cases of low-level programming.

`-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-subprogram basis. See Static Stack Usage Analysis for details.

`-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.

`-gnat05`

  Allow full Ada 2005 features.

`-gnat12`

  Allow full Ada 2012 features.

`-gnat2005`

  Allow full Ada 2005 features (same as `-gnat05`)

`-gnat2012`

  Allow full Ada 2012 features (same as `-gnat12`)

`-gnat2022`

  Allow full Ada 2022 features

`-gnat83`

  Enforce Ada 83 restrictions.

`-gnat95`

  Enforce Ada 95 restrictions.

  Note: for compatibility with some Ada 95 compilers which support only the `overriding` keyword of Ada 2005, the `-gnatd.D` switch can be used along with `-gnat95` to achieve a similar effect with GNAT.

  `-gnatd.D` instructs GNAT to consider `overriding` as a keyword and handle its associated semantic checks, even in Ada 95 mode.

`-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`. In Ada 2012, it also activates all assertions defined in the RM as aspects: preconditions, postconditions, type invariants and (sub)type predicates. In all Ada modes, corresponding pragmas for type invariants and (sub)type predicates are also activated. The default is that all these assertions are disabled, and have no effect, other than being checked for syntactic validity, and in the case of subtype predicates, constructions such as membership tests still test predicates even if assertions are turned off.

`-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 (Validity Checking).

`-gnatc`

  Check syntax and semantics only (no code generation attempted). When the compiler is invoked by `gnatmake`, if the switch `-gnatc` is only given to the compiler (after `-cargs` or in package Compiler of the project file), `gnatmake` will fail because it will not find the object file after compilation. If `gnatmake` is called with `-gnatc` as a builder switch (before `-cargs` or in package Builder of the project file) then `gnatmake` will not fail because it will not look for the object files after compilation, and it will not try to build and link.

`-gnatC`

  Generate CodePeer intermediate format (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` specifies the specific debug options. The possible characters are 0-9, a-z, A-Z, optionally preceded by a dot or underscore. See compiler source file `debug.adb` for details of the implemented debug options. Certain debug options are relevant to application programmers, and these are documented at appropriate points in this user’s guide.

`-gnatD`

  Create expanded source files for source level debugging. This switch also suppresses generation of cross-reference information (see `-gnatx`). Note that this switch is not allowed if a previous `-gnatR` switch has been given, since these two switches are not compatible.

`-gnateA`

  Check that the actual parameters of a subprogram call are not aliases of one another. To qualify as aliasing, their memory locations must be identical or overlapping, at least one of the corresponding formal parameters must be of mode OUT or IN OUT, and at least one of the corresponding formal parameters must have its parameter passing mechanism not specified.

      type Rec_Typ is record
         Data : Integer := 0;
      end record;

      function Self (Val : Rec_Typ) return Rec_Typ is
      begin
         return Val;
      end Self;

      procedure Detect_Aliasing (Val_1 : in out Rec_Typ; Val_2 : Rec_Typ) is
      begin
         null;
      end Detect_Aliasing;

      Obj : Rec_Typ;

      Detect_Aliasing (Obj, Obj);
      Detect_Aliasing (Obj, Self (Obj));

  In the example above, the first call to `Detect_Aliasing` fails with a `Program_Error` at run time because the actuals for `Val_1` and `Val_2` denote the same object. The second call executes without raising an exception because `Self(Obj)` produces an anonymous object which does not share the memory location of `Obj`.

`-gnateb`

  Store configuration files by their basename in ALI files. This switch is used for instance by gprbuild for distributed builds in order to prevent issues where machine-specific absolute paths could end up being stored in ALI files.

`-gnatec=`path'`

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

`-gnateC`

  Generate CodePeer messages in a compiler-like format. This switch is only effective if `-gnatcC` is also specified and requires an installation of CodePeer.

`-gnated`

  Disable atomic synchronization

`-gnateDsymbol[=`value']`

  Defines a symbol, associated with `value`, for preprocessing. (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. In cases where the compiler is able to determine at compile time that a check will fail, it gives a warning, and the extra information is not produced at run time.

`-gnatef`

  Display full source path name in brief error messages and absolute paths in `-fdiagnostics-format=json`’s output.

`-gnateF`

  Check for overflow on all floating-point operations, including those for unconstrained predefined types. See description of pragma `Check_Float_Overflow` in GNAT RM.

`-gnateg` `-gnatceg`

> The `-gnatc` switch must always be specified before this switch, e.g. `-gnatceg`. Generate a C header from the Ada input file. See Generating C Headers for Ada Specifications for more information.

`-gnateG[bce]`

  Save result of preprocessing in a text file. An optional character (b, c, or e) can be appended to indicate that filtered lines are to be replaced by blank lines, comment lines that include the filtered line, or empty comment lines (”–!”), respectively. The default is to replace filtered lines with blank lines.

`-gnateH`

  Set the threshold from which the RM 13.5.1(13.3/2) clause applies to 64. This is useful only on 64-bit platforms where this threshold is 128, but used to be 64 in earlier versions of the compiler.

`-gnatei`nnn'`

  Set maximum number of instantiations during compilation of a single unit to `nnn`. This may be useful in increasing the default maximum of 8000 for the rare case when a single unit legitimately exceeds this limit.

`-gnateI`nnn'`

  Indicates that the source is a multi-unit source and that the index of the unit to compile is `nnn`. `nnn` needs to be a positive number and need to be a valid index in the multi-unit source.

`-gnatel`

  This switch can be used with the static elaboration model to issue info messages showing where implicit `pragma Elaborate` and `pragma Elaborate_All` are generated. This is useful in diagnosing elaboration circularities caused by these implicit pragmas when using the static elaboration model. See the section in this guide on elaboration checking for further details. These messages are not generated by default, and are intended only for temporary use when debugging circularity problems.

`-gnateL`

  This switch turns off the info messages about implicit elaboration pragmas.

`-gnatem=`path'`

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

`-gnatep=`file'`

  Specify a preprocessing data file (the equal sign is optional) (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 cannot 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`

  Synonym of `-fdump-scos`, kept for backwards compatibility.

`-gnatet=`path'`

  Generate target dependent information. The format of the output file is described in the section about switch `-gnateT`.

`-gnateT=`path'`

  Read target dependent information, such as endianness or sizes and alignments of base type. If this switch is passed, the default target dependent information of the compiler is replaced by the one read from the input file. This is used by tools other than the compiler, e.g. to do semantic analysis of programs that will run on some other target than the machine on which the tool is run.

  The following target dependent values should be defined, where `Nat` denotes a natural integer value, `Pos` denotes a positive integer value, and fields marked with a question mark are boolean fields, where a value of 0 is False, and a value of 1 is True:

      Bits_BE                    : Nat; -- Bits stored big-endian?
      Bits_Per_Unit              : Pos; -- Bits in a storage unit
      Bits_Per_Word              : Pos; -- Bits in a word
      Bytes_BE                   : Nat; -- Bytes stored big-endian?
      Char_Size                  : Pos; -- Standard.Character'Size
      Double_Float_Alignment     : Nat; -- Alignment of double float
      Double_Scalar_Alignment    : Nat; -- Alignment of double length scalar
      Double_Size                : Pos; -- Standard.Long_Float'Size
      Float_Size                 : Pos; -- Standard.Float'Size
      Float_Words_BE             : Nat; -- Float words stored big-endian?
      Int_Size                   : Pos; -- Standard.Integer'Size
      Long_Double_Size           : Pos; -- Standard.Long_Long_Float'Size
      Long_Long_Long_Size        : Pos; -- Standard.Long_Long_Long_Integer'Size
      Long_Long_Size             : Pos; -- Standard.Long_Long_Integer'Size
      Long_Size                  : Pos; -- Standard.Long_Integer'Size
      Maximum_Alignment          : Pos; -- Maximum permitted alignment
      Max_Unaligned_Field        : Pos; -- Maximum size for unaligned bit field
      Pointer_Size               : Pos; -- System.Address'Size
      Short_Enums                : Nat; -- Foreign enums use short size?
      Short_Size                 : Pos; -- Standard.Short_Integer'Size
      Strict_Alignment           : Nat; -- Strict alignment?
      System_Allocator_Alignment : Nat; -- Alignment for malloc calls
      Wchar_T_Size               : Pos; -- Interfaces.C.wchar_t'Size
      Words_BE                   : Nat; -- Words stored big-endian?

  `Bits_Per_Unit` is the number of bits in a storage unit, the equivalent of GCC macro `BITS_PER_UNIT` documented as follows: Define this macro to be the number of bits in an addressable storage unit (byte); normally 8.

  `Bits_Per_Word` is the number of bits in a machine word, the equivalent of GCC macro `BITS_PER_WORD` documented as follows: Number of bits in a word; normally 32.

  `Double_Float_Alignment`, if not zero, is the maximum alignment that the compiler can choose by default for a 64-bit floating-point type or object.

  `Double_Scalar_Alignment`, if not zero, is the maximum alignment that the compiler can choose by default for a 64-bit or larger scalar type or object.

  `Maximum_Alignment` is the maximum alignment that the compiler can choose by default for a type or object, which is also the maximum alignment that can be specified in GNAT. It is computed for GCC back ends as `BIGGEST_ALIGNMENT / BITS_PER_UNIT` where GCC macro `BIGGEST_ALIGNMENT` is documented as follows: Biggest alignment that any data type can require on this machine, in bits.

  `Max_Unaligned_Field` is the maximum size for unaligned bit field, which is 64 for the majority of GCC targets (but can be different on some targets).

  `Strict_Alignment` is the equivalent of GCC macro `STRICT_ALIGNMENT` documented as follows: Define this macro to be the value 1 if instructions will fail to work if given data not on the nominal alignment. If instructions will merely go slower in that case, define this macro as 0.

  `System_Allocator_Alignment` is the guaranteed alignment of data returned by calls to `malloc`.

  The format of the input file is as follows. First come the values of the variables defined above, with one line per value:

      name  value

  where `name` is the name of the parameter, spelled out in full, and cased as in the above list, and `value` is an unsigned decimal integer. Two or more blanks separates the name from the value.

  All the variables must be present, in alphabetical order (i.e. the same order as the list above).

  Then there is a blank line to separate the two parts of the file. Then come the lines showing the floating-point types to be registered, with one line per registered mode:

      name  digs float_rep size alignment

  where `name` is the string name of the type (which can have single spaces embedded in the name, e.g. long double), `digs` is the number of digits for the floating-point type, `float_rep` is the float representation (I for IEEE-754-Binary, which is the only one supported at this time), `size` is the size in bits, `alignment` is the alignment in bits. The name is followed by at least two blanks, fields are separated by at least one blank, and a LF character immediately follows the alignment field.

  Here is an example of a target parameterization file:

      Bits_BE                       0
      Bits_Per_Unit                 8
      Bits_Per_Word                64
      Bytes_BE                      0
      Char_Size                     8
      Double_Float_Alignment        0
      Double_Scalar_Alignment       0
      Double_Size                  64
      Float_Size                   32
      Float_Words_BE                0
      Int_Size                     64
      Long_Double_Size            128
      Long_Long_Long_Size         128
      Long_Long_Size               64
      Long_Size                    64
      Maximum_Alignment            16
      Max_Unaligned_Field          64
      Pointer_Size                 64
      Short_Size                   16
      Strict_Alignment              0
      System_Allocator_Alignment   16
      Wchar_T_Size                 32
      Words_BE                      0

      float         15  I  64  64
      double        15  I  64  64
      long double   18  I  80 128
      TF            33  I 128 128

`-gnateu`

  Ignore unrecognized validity, warning, and style switches that appear after this switch is given. This may be useful when compiling sources developed on a later version of the compiler with an earlier version. Of course the earlier version must support this switch.

`-gnateV`

  Check that all actual parameters of a subprogram call are valid according to the rules of validity checking (Validity Checking).

`-gnateY`

  Ignore all STYLE_CHECKS pragmas. Full legality checks are still carried out, but the pragmas have no effect on what style checks are active. This allows all style checking options to be controlled from the command line.

`-gnatE`

  Dynamic elaboration checking mode enabled. For further details see Elaboration Order Handling in GNAT.

`-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 `-gnatw.ge` 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`.

`-gnatH`

  Legacy elaboration-checking mode enabled. When this switch is in effect, the pre-18.x access-before-elaboration model becomes the de facto model. For further details see Elaboration Order Handling in GNAT.

`-gnati`c'`

  Identifier character set (`c` = 1/2/3/4/5/9/p/8/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. 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, Scalar_Storage_Order, Size, Small, Stream_Size, and Value_Size. Pragma Default_Scalar_Storage_Order is also ignored. Note that this option should be used only for compiling – the code is likely to malfunction at run time.

`-gnatj`nn'`

  Reformat error messages to fit on `nn` character lines

`-gnatJ`

  Permissive elaboration-checking mode enabled. When this switch is in effect, the post-18.x access-before-elaboration model ignores potential issues with:

  - Accept statements
  - Activations of tasks defined in instances
  - Assertion pragmas
  - Calls from within an instance to its enclosing context
  - Calls through generic formal parameters
  - Calls to subprograms defined in instances
  - Entry calls
  - Indirect calls using ‘Access
  - Requeue statements
  - Select statements
  - Synchronous task suspension

  and does not emit compile-time diagnostics or run-time checks. For further details see Elaboration Order Handling in GNAT.

`-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[12]`

  Activate inlining across units for subprograms for which pragma `Inline` is specified. This inlining is performed by the GCC back end. An optional digit sets the inlining level: 1 for moderate inlining across units or 2 for full inlining across units. If no inlining level is specified, the compiler will pick it based on the optimization level.

`-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, 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.

`-gnato0`

  Suppresses overflow checking. This causes the behavior of the compiler to match the default for older versions where overflow checking was suppressed by default. This is equivalent to having `pragma Suppress (Overflow_Check)` in a configuration pragma file.

`-gnato??`

  Set default mode for handling generation of code to avoid intermediate arithmetic overflow. Here `??` is two digits, a single digit, or nothing. Each digit is one of the digits `1` through `3`:

  Digit | Interpretation
  ‘1’ | All intermediate overflows checked against base type (`STRICT`)
  ‘2’ | Minimize intermediate overflows (`MINIMIZED`)
  ‘3’ | Eliminate intermediate overflows (`ELIMINATED`)

  If only one digit appears, then it applies to all cases; if two digits are given, then the first applies outside assertions, pre/postconditions, and type invariants, and the second applies within assertions, pre/postconditions, and type invariants.

  If no digits follow the `-gnato`, then it is equivalent to `-gnato11`, causing all intermediate overflows to be handled in strict mode.

  This switch also causes arithmetic overflow checking to be performed (as though `pragma Unsuppress (Overflow_Check)` had been specified).

  The default if no option `-gnato` is given is that overflow handling is in `STRICT` mode (computations done using the base type), and that overflow checking is enabled.

  Note that division by zero is a separate check that is not controlled by this switch (divide-by-zero checking is on by default).

  See also Specifying the Desired Mode.

`-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.

`-gnatq`

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

`-gnatQ`

  Don’t quit. Generate `ALI` and tree files even if illegalities. Note that code generation is still suppressed in the presence of any errors, so even with `-gnatQ` no object file is generated.

`-gnatr`

  Treat pragma Restrictions as Restriction_Warnings.

`-gnatR[0|1|2|3|4][e][h][m][j][s]`

  Output representation information for declared types, objects and subprograms. Note that this switch is not allowed if a previous `-gnatD` switch has been given, since these two switches are not compatible.

`-gnats`

  Syntax check only.

`-gnatS`

  Print package Standard.

`-gnatT`nnn'`

  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 (Validity Checking).

`-gnatw`xxx'`

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

`-gnatW`e'`

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

`-gnatx`

  Suppress generation of cross-reference information.

`-gnatX`

  Enable core GNAT implementation extensions and latest Ada version.

`-gnatX0`

  Enable all GNAT implementation extensions and latest Ada version.

`-gnaty`

  Enable built-in style checks (Style Checking).

`-gnatz`m'`

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

`-I`dir'`

  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)).

`-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’ | Effect
  ‘0’ | No optimization, the default setting if no `-O` appears.
  ‘1’ | Moderate optimization, same as `-O` without an operand. A good compromise between code quality and compilation time.
  ‘2’ | Extensive optimization, should improve execution time, possibly at the cost of substantially increased compilation time.
  ‘3’ | Full optimization, may further improve execution time, possibly at the cost of substantially larger generated code.
  ‘s’ | Optimize for size (code and data) rather than speed.
  ‘z’ | Optimize aggressively for size (code and data) rather than speed.
  ‘g’ | Optimize for debugging experience rather than speed.

  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 run-time library. Same meaning as the equivalent `gnatmake` flag (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 (Validity Checking).
- Option ‘em’, ‘ec’, ‘ep’, ‘l=’ and ‘R’ must be the last options in a combined list of options.