CbC/CbC_gcc: gcc/ada/gnat_ugn.texi comparison

comparison gcc/ada/gnat_ugn.texi @ 131:84e7813d76e9

gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 07:37:49 +0900
parents	04ced10e8804
children	1830386684a0

comparison

equal deleted inserted replaced

-:04ced10e8804
+:84e7813d76e9
 @definfoenclose emph,`,'
 @c %**end of header
 @copying
 @quotation
-GNAT User's Guide for Native Platforms , Oct 20, 2017
+GNAT User's Guide for Native Platforms , Aug 20, 2018
 AdaCore
-Copyright @copyright{} 2008-2017, Free Software Foundation
+Copyright @copyright{} 2008-2018, Free Software Foundation
 @end quotation
 @end copying
 @titlepage
 * Installing gnathtml::
 GNAT and Program Execution
 * Running and Debugging Ada Programs::
-* Code Coverage and Profiling::
+* Profiling::
 * Improving Performance::
 * Overflow Check Handling in GNAT::
 * Performing Dimensionality Analysis in GNAT::
 * Stack Related Facilities::
 * Memory Management Issues::
 Stack Traceback
 * Non-Symbolic Traceback::
 * Symbolic Traceback::
-Code Coverage and Profiling
+Profiling
-* Code Coverage of Ada Programs with gcov::
 * Profiling an Ada Program with gprof::
-Code Coverage of Ada Programs with gcov
-* Quick startup guide::
-* GNAT specifics::
 Profiling an Ada Program with gprof
 * Compilation for profiling::
 * Program execution::
 Platform-Specific Information
 * Run-Time Libraries::
 * Specifying a Run-Time Library::
+* GNU/Linux Topics::
 * Microsoft Windows Topics::
 * Mac OS Topics::
 Run-Time Libraries
 * Summary of Run-Time Configurations::
 Specifying a Run-Time Library
 * Choosing the Scheduling Policy::
+GNU/Linux Topics
+* Required Packages on GNU/Linux::
 Microsoft Windows Topics
 * Using GNAT on Windows::
 * Using a network installation of GNAT::
 * Controlling the Elaboration Order in GNAT::
 * Common Elaboration-model Traits::
 * Dynamic Elaboration Model in GNAT::
 * Static Elaboration Model in GNAT::
 * SPARK Elaboration Model in GNAT::
+* Legacy Elaboration Model in GNAT::
 * Mixing Elaboration Models::
 * Elaboration Circularities::
 * Resolving Elaboration Circularities::
 * Resolving Task Issues::
 * Elaboration-related Compiler Switches::
 @item
 @ref{24,,Running and Debugging Ada Programs}
 @item
-@ref{25,,Code Coverage and Profiling}
+@ref{25,,Profiling}
 @item
 @ref{26,,Improving Performance}
 @item
 pragma CPP_Constructor (New_Animal);
 pragma Import (CPP, New_Animal, "_ZN6AnimalC1Ev");
 type Dog is new Animal and Carnivore and Domestic with record
 Tooth_Count : Natural;
-Owner       : String (1 .. 30);
+Owner       : Chars_Ptr;
 end record;
 pragma Import (C_Plus_Plus, Dog);
 function Number_Of_Teeth (A : Dog) return Natural;
 pragma Import (C_Plus_Plus, Number_Of_Teeth);
 @table @asis
 @item @code{--RTS=@emph{rts-path}}
-Specifies the default location of the runtime library. GNAT looks for the
+Specifies the default location of the run-time library. GNAT looks for the
-runtime
+run-time
-in the following directories, and stops as soon as a valid runtime is found
+in the following directories, and stops as soon as a valid run-time is found
 (@code{adainclude} or @code{ada_source_path}, and @code{adalib} or
 @code{ada_object_path} present):
 @itemize *
 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 modules enabled by the @code{-gnatn} switch.
+with inlining across units enabled by the @code{-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 @code{-Ox} switches, must be
 specified both for the compilation and the link phases.
 If the @code{n} parameter is specified, the optimization and final code
 Detect_Aliasing (Obj, Obj);
 Detect_Aliasing (Obj, Self (Obj));
 @end example
 In the example above, the first call to @code{Detect_Aliasing} fails with a
-@code{Program_Error} at runtime because the actuals for @code{Val_1} and
+@code{Program_Error} at run time because the actuals for @code{Val_1} and
 @code{Val_2} denote the same object. The second call executes without raising
 an exception because @code{Self(Obj)} produces an anonymous object which does
 not share the memory location of @code{Obj}.
 @end table
 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; -- Short foreign convention enums?
+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?
 @end example
+@code{Bits_Per_Unit} is the number of bits in a storage unit, the equivalent of
+GCC macro @code{BITS_PER_UNIT} documented as follows: @cite{Define this macro to be the number of bits in an addressable storage unit (byte); normally 8.}
+@code{Bits_Per_Word} is the number of bits in a machine word, the equivalent of
+GCC macro @code{BITS_PER_WORD} documented as follows: @cite{Number of bits in a word; normally 32.}
+@code{Double_Scalar_Alignment} is the alignment for a scalar whose size is two
+machine words. It should be the same as the alignment for C @code{long_long} on
+most targets.
+@code{Maximum_Alignment} is the maximum alignment that the compiler might 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 backends as @code{BIGGEST_ALIGNMENT
+/ BITS_PER_UNIT} where GCC macro @code{BIGGEST_ALIGNMENT} is documented as
+follows: @cite{Biggest alignment that any data type can require on this machine@comma{} in bits.}
+@code{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 like
+AAMP).
+@code{Strict_Alignment} is the equivalent of GCC macro @code{STRICT_ALIGNMENT}
+documented as follows: @cite{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@comma{} define this macro as 0.}
+@code{System_Allocator_Alignment} is the guaranteed alignment of data returned
+by calls to @code{malloc}.
 The format of the input file is as follows. First come the values of
 the variables defined above, with one line per value:
 @example
 @table @asis
 @item @code{-gnatg}
-Internal GNAT implementation mode. This should not be used for
+Internal GNAT implementation mode. This should not be used for applications
-applications programs, it is intended only for use by the compiler
+programs, it is intended only for use by the compiler and its run-time
-and its run-time library. For documentation, see the GNAT sources.
+library. For documentation, see the GNAT sources. Note that @code{-gnatg}
-Note that @code{-gnatg} implies
+implies @code{-gnatw.ge} and @code{-gnatyg} so that all standard
-@code{-gnatw.ge} and
+warnings and all standard style options are turned on. All warnings and style
-@code{-gnatyg}
+messages are treated as errors.
-so that all standard warnings and all standard style options are turned on.
-All warnings and style messages are treated as errors.
 @end table
 @geindex -gnatG[nn] (gcc)
 @table @asis
 @item @code{-gnath}
 Output usage information. The output is written to @code{stdout}.
+@end table
+@geindex -gnatH (gcc)
+@table @asis
+@item @code{-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.
 @end table
 @geindex -gnati (gcc)
 @item @code{-gnatj@emph{nn}}
 Reformat error messages to fit on @code{nn} character lines
 @end table
+@geindex -gnatJ (gcc)
+@table @asis
+@item @code{-gnatJ}
+Permissive elaboration-checking mode enabled. When this switch is in effect,
+the post-18.x access-before-elaboration model ignores potential issues with:
+@itemize -
+@item
+Accept statements
+@item
+Activations of tasks defined in instances
+@item
+Assertion pragmas
+@item
+Calls from within an instance to its enclosing context
+@item
+Calls through generic formal parameters
+@item
+Calls to subprograms defined in instances
+@item
+Entry calls
+@item
+Indirect calls using 'Access
+@item
+Requeue statements
+@item
+Select statements
+@item
+Synchronous task suspension
+@end itemize
+and does not emit compile-time diagnostics or run-time checks.
+@end table
 @geindex -gnatk (gcc)
 @table @asis
 @table @asis
 @item @code{-gnatn[12]}
-Activate inlining across modules for subprograms for which pragma @code{Inline}
+Activate inlining across units for subprograms for which pragma @code{Inline}
 is specified. This inlining is performed by the GCC back-end. An optional
-digit sets the inlining level: 1 for moderate inlining across modules
+digit sets the inlining level: 1 for moderate inlining across units
-or 2 for full inlining across modules. If no inlining level is specified,
+or 2 for full inlining across units. If no inlining level is specified,
 the compiler will pick it based on the optimization level.
 @end table
 @geindex -gnatN (gcc)
 @geindex -gnatR (gcc)
 @table @asis
-@item @code{-gnatR[0/1/2/3][e][m][s]}
+@item @code{-gnatR[0|1|2|3][e][j][m][s]}
 Output representation information for declared types, objects and
 subprograms. Note that this switch is not allowed if a previous
 @code{-gnatD} switch has been given, since these two switches
 are not compatible.
 @table @asis
 @item @code{--RTS=@emph{rts-path}}
-Specifies the default location of the runtime library. Same meaning as the
+Specifies the default location of the run-time library. Same meaning as the
 equivalent @code{gnatmake} flag (@ref{dc,,Switches for gnatmake}).
 @end table
 @geindex -S (gcc)
 @item
 @code{-gnatwD}
 @item
+@code{-gnatw.D}
+@item
 @code{-gnatwF}
 @item
+@code{-gnatw.F}
+@item
 @code{-gnatwg}
 @item
 @code{-gnatwH}
 @item
+@code{-gnatw.H}
+@item
 @code{-gnatwi}
 @item
-@code{-gnatw.I}
-@item
 @code{-gnatwJ}
 @item
+@code{-gnatw.J}
+@item
 @code{-gnatwK}
 @item
+@code{-gnatw.K}
+@item
 @code{-gnatwL}
 @item
 @code{-gnatw.L}
 @item
 @code{-gnatwn}
 @item
+@code{-gnatw.N}
+@item
 @code{-gnatwo}
 @item
 @code{-gnatw.O}
 @item
 @code{-gnatwT}
 @item
-@code{-gnatw.T}
+@code{-gnatw.t}
 @item
 @code{-gnatwU}
 @item
+@code{-gnatw.U}
+@item
 @code{-gnatwv}
 @item
+@code{-gnatw.v}
+@item
 @code{-gnatww}
 @item
 @code{-gnatw.W}
 @item
 @code{-gnatwy}
 @item
+@code{-gnatw.Y}
+@item
 @code{-gnatwz}
+@item
+@code{-gnatw.z}
 @end itemize
 @end quotation
 @node Debugging and Assertion Control,Validity Checking,Warning Message Control,Compiler Switches
 @anchor{gnat_ugn/building_executable_programs_with_gnat debugging-and-assertion-control}@anchor{100}@anchor{gnat_ugn/building_executable_programs_with_gnat id16}@anchor{101}
 checking code is zero or near-zero, the compiler will generate it even
 if checks are suppressed. In particular, if the compiler can prove
 that a certain check will necessarily fail, it will generate code to
 do an unconditional 'raise', even if checks are suppressed. The
 compiler warns in this case. Another case in which checks may not be
-eliminated is when they are embedded in certain run time routines such
+eliminated is when they are embedded in certain run-time routines such
 as math library routines.
 Of course, run-time checks are omitted whenever the compiler can prove
 that they will not fail, whether or not checks are suppressed.
 @item @code{-gnatn[12]}
 The @code{n} here is intended to suggest the first syllable of the word 'inline'.
 GNAT recognizes and processes @code{Inline} pragmas. However, for inlining to
 actually occur, optimization must be enabled and, by default, inlining of
-subprograms across modules is not performed. If you want to additionally
+subprograms across units is not performed. If you want to additionally
-enable inlining of subprograms specified by pragma @code{Inline} across modules,
+enable inlining of subprograms specified by pragma @code{Inline} across units,
 you must also specify this switch.
-In the absence of this switch, GNAT does not attempt inlining across modules
+In the absence of this switch, GNAT does not attempt inlining across units
 and does not access the bodies of subprograms for which @code{pragma Inline} is
 specified if they are not in the current unit.
 You can optionally specify the inlining level: 1 for moderate inlining across
-modules, which is a good compromise between compilation times and performances
+units, which is a good compromise between compilation times and performances
-at run time, or 2 for full inlining across modules, which may bring about
+at run time, or 2 for full inlining across units, which may bring about
 longer compilation times. If no inlining level is specified, the compiler will
 pick it based on the optimization level: 1 for @code{-O1}, @code{-O2} or
 @code{-Os} and 2 for @code{-O3}.
 If you specify this switch the compiler will access these bodies,
 @geindex -gnatR (gcc)
 @table @asis
-@item @code{-gnatR[0|1|2|3][e][m][s]}
+@item @code{-gnatR[0|1|2|3][e][j][m][s]}
 This switch controls output from the compiler of a listing showing
 representation information for declared types, objects and subprograms.
 For @code{-gnatR0}, no information is output (equivalent to omitting
 the @code{-gnatR} switch). For @code{-gnatR1} (which is the default,
 If the switch is followed by an @code{m} (e.g. @code{-gnatRm}), then
 subprogram conventions and parameter passing mechanisms for all the
 subprograms are included.
+If the switch is followed by a @code{j} (e.g., @code{-gnatRj}), then
+the output is in the JSON data interchange format specified by the
+ECMA-404 standard. The semantic description of this JSON output is
+available in the specification of the Repinfo unit present in the
+compiler sources.
 If the switch is followed by an @code{s} (e.g., @code{-gnatR3s}), then
 the output is to a file with the name @code{file.rep} where file is
-the name of the corresponding source file.
+the name of the corresponding source file, except if @cite{j`} is also
+specified, in which case the file name is @code{file.json}.
 Note that it is possible for record components to have zero size. In
 this case, the component clause uses an obvious extension of permitted
 Ada syntax, for example @code{at 0 range 0 .. -1}.
 @end table
 @node Exception Handling Control,Units to Sources Mapping Files,Debugging Control,Compiler Switches
 @anchor{gnat_ugn/building_executable_programs_with_gnat id28}@anchor{114}@anchor{gnat_ugn/building_executable_programs_with_gnat exception-handling-control}@anchor{115}
 @subsection Exception Handling Control
-GNAT uses two methods for handling exceptions at run-time. The
+GNAT uses two methods for handling exceptions at run time. The
 @code{setjmp/longjmp} method saves the context when entering
 a frame with an exception handler. Then when an exception is
 raised, the context can be restored immediately, without the
 need for tracing stack frames. This method provides very fast
 exception propagation, but introduces significant overhead for
 @table @asis
 @item @code{-D@emph{nn}[k|m]}
-This switch can be used to change the default secondary stack size value
+Set the default secondary stack size to @code{nn}. The suffix indicates whether
-to a specified size @code{nn}, which is expressed in bytes by default, or
+the size is in bytes (no suffix), kilobytes (@code{k} suffix) or megabytes
-in kilobytes when suffixed with @code{k} or in megabytes when suffixed
+(@code{m} suffix).
-with @code{m}.
+The secondary stack holds objects of unconstrained types that are returned by
-The secondary stack is used to deal with functions that return a variable
+functions, for example unconstrained Strings. The size of the secondary stack
-sized result, for example a function returning an unconstrained
+can be dynamic or fixed depending on the target.
-String. There are two ways in which this secondary stack is allocated.
+For most targets, the secondary stack grows on demand and is implemented as
-For most targets, the secondary stack grows on demand and is allocated
+a chain of blocks in the heap. In this case, the default secondary stack size
-as a chain of blocks in the heap. The -D option is not very
+determines the initial size of the secondary stack for each task and the
-relevant. It only give some control over the size of the allocated
+smallest amount the secondary stack can grow by.
-blocks (whose size is the minimum of the default secondary stack size value,
-and the actual size needed for the current allocation request).
+For Ravenscar, ZFP, and Cert run-times the size of the secondary stack is
+fixed. This switch can be used to change the default size of these stacks.
-For certain targets, notably VxWorks 653 and bare board targets,
+The default secondary stack size can be overridden on a per-task basis if
-the secondary stack is allocated by carving off a chunk of the primary task
+individual tasks have different secondary stack requirements. This is
-stack. By default this is a fixed percentage of the primary task stack as
+achieved through the Secondary_Stack_Size aspect that takes the size of the
-defined by System.Parameter.Sec_Stack_Percentage. This can be overridden per
+secondary stack in bytes.
-task using the Secondary_Stack_Size pragma/aspect. The -D option is used to
-define the size of the environment task's secondary stack.
 @end table
 @geindex -e (gnatbind)
 @geindex --RTS (gnatbind)
 @item @code{--RTS=@emph{rts-path}}
-Specifies the default location of the runtime library. Same meaning as the
+Specifies the default location of the run-time library. Same meaning as the
 equivalent @code{gnatmake} flag (@ref{dc,,Switches for gnatmake}).
 @geindex -o (gnatbind)
 @item @code{-o @emph{file}}
 @table @asis
 @item @code{-static}
-Link against a static GNAT run time.
+Link against a static GNAT run-time.
 @geindex -shared (gnatbind)
 @item @code{-shared}
-Link against a shared GNAT run time when available.
+Link against a shared GNAT run-time when available.
 @geindex -t (gnatbind)
 @item @code{-t}
 is used. If the system does not support specific time slice values, but
 does support some general notion of round-robin scheduling, then any
 nonzero value will activate round-robin scheduling.
 A value of zero is treated specially. It turns off time
-slicing, and in addition, indicates to the tasking run time that the
+slicing, and in addition, indicates to the tasking run-time that the
 semantics should match as closely as possible the Annex D
 requirements of the Ada RM, and in particular sets the default
 scheduling policy to @code{FIFO_Within_Priorities}.
 @geindex -u (gnatbind)
 The output is an Ada unit in source form that can be compiled with GNAT.
 This compilation occurs automatically as part of the @code{gnatlink}
 processing.
-Currently the GNAT run time requires a FPU using 80 bits mode
+Currently the GNAT run-time requires a FPU using 80 bits mode
 precision. Under targets where this is not the default it is required to
 call GNAT.Float_Control.Reset before using floating point numbers (this
 include float computation, float input and output) in the Ada code. A
 side effect is that this could be the wrong mode for the foreign code
 where floating point computation could be broken after this call.
 of GNAT).
 @item
 The content of the @code{ada_object_path} file which is part of the GNAT
 installation tree and is used to store standard libraries such as the
-GNAT Run Time Library (RTL) unless the switch @code{-nostdlib} is
+GNAT Run-Time Library (RTL) unless the switch @code{-nostdlib} is
 specified. See @ref{87,,Installing a library}
 @end itemize
 @geindex -I (gnatbind)
 @code{exec-name} specifies an alternate name for the generated
 executable program. If this switch is omitted, the executable has the same
 name as the main unit. For example, @code{gnatlink try.ali} creates
 an executable called @code{try}.
-@end table
-@geindex -b (gnatlink)
-@table @asis
-@item @code{-b @emph{target}}
-Compile your program to run on @code{target}, which is the name of a
-system configuration. You must have a GNAT cross-compiler built if
-@code{target} is not the same as your host system.
 @end table
 @geindex -B (gnatlink)
 @item @code{--ext=@emph{extension}}
 Specify an alternate ali file extension. The default is @code{ali} and other
 extensions (e.g. @code{gli} for C/C++ sources) may be specified via this switch.
-Note that if this switch overrides the default, which means that only the
+Note that if this switch overrides the default, only the new extension will
-new extension will be considered.
+be considered.
 @end table
 @geindex --RTS (gnatxref)
 @table @asis
 @item @code{--ext=@emph{extension}}
 Specify an alternate ali file extension. The default is @code{ali} and other
-extensions (e.g. @code{gli} for C/C++ sources when using @code{-fdump-xref})
+extensions may be specified via this switch. Note that if this switch
-may be specified via this switch. Note that if this switch overrides the
+overrides the default, only the new extension will be considered.
-default, which means that only the new extension will be considered.
 @end table
 @geindex --RTS (gnatfind)
 @c -- Example: A |withing| unit has a |with| clause, it |withs| a |withed| unit
 @node GNAT and Program Execution,Platform-Specific Information,GNAT Utility Programs,Top
 @anchor{gnat_ugn/gnat_and_program_execution gnat-and-program-execution}@anchor{c}@anchor{gnat_ugn/gnat_and_program_execution doc}@anchor{165}@anchor{gnat_ugn/gnat_and_program_execution id1}@anchor{166}
 @chapter GNAT and Program Execution
 @item
 @ref{167,,Running and Debugging Ada Programs}
 @item
-@ref{168,,Code Coverage and Profiling}
+@ref{25,,Profiling}
 @item
-@ref{169,,Improving Performance}
+@ref{168,,Improving Performance}
 @item
-@ref{16a,,Overflow Check Handling in GNAT}
+@ref{169,,Overflow Check Handling in GNAT}
 @item
-@ref{16b,,Performing Dimensionality Analysis in GNAT}
+@ref{16a,,Performing Dimensionality Analysis in GNAT}
 @item
-@ref{16c,,Stack Related Facilities}
+@ref{16b,,Stack Related Facilities}
 @item
-@ref{16d,,Memory Management Issues}
+@ref{16c,,Memory Management Issues}
 @end itemize
 @menu
 * Running and Debugging Ada Programs::
-* Code Coverage and Profiling::
+* Profiling::
 * Improving Performance::
 * Overflow Check Handling in GNAT::
 * Performing Dimensionality Analysis in GNAT::
 * Stack Related Facilities::
 * Memory Management Issues::
 @end menu
-@node Running and Debugging Ada Programs,Code Coverage and Profiling,,GNAT and Program Execution
+@node Running and Debugging Ada Programs,Profiling,,GNAT and Program Execution
 @anchor{gnat_ugn/gnat_and_program_execution id2}@anchor{167}@anchor{gnat_ugn/gnat_and_program_execution running-and-debugging-ada-programs}@anchor{24}
 @section Running and Debugging Ada Programs
 @geindex Debugging
 * Pretty-Printers for the GNAT runtime::
 @end menu
 @node The GNAT Debugger GDB,Running GDB,,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution the-gnat-debugger-gdb}@anchor{16e}@anchor{gnat_ugn/gnat_and_program_execution id3}@anchor{16f}
+@anchor{gnat_ugn/gnat_and_program_execution the-gnat-debugger-gdb}@anchor{16d}@anchor{gnat_ugn/gnat_and_program_execution id3}@anchor{16e}
 @subsection The GNAT Debugger GDB
 @code{GDB} is a general purpose, platform-independent debugger that
 can be used to debug mixed-language programs compiled with @code{gcc},
 debugger were present. When a breakpoint is hit, @code{GDB} accesses
 the debugging information and can respond to user commands to inspect
 variables, and more generally to report on the state of execution.
 @node Running GDB,Introduction to GDB Commands,The GNAT Debugger GDB,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution id4}@anchor{170}@anchor{gnat_ugn/gnat_and_program_execution running-gdb}@anchor{171}
+@anchor{gnat_ugn/gnat_and_program_execution id4}@anchor{16f}@anchor{gnat_ugn/gnat_and_program_execution running-gdb}@anchor{170}
 @subsection Running GDB
 This section describes how to initiate the debugger.
 The simplest command is simply @code{run}, which causes the program to run
 exactly as if the debugger were not present. The following section
 describes some of the additional commands that can be given to @code{GDB}.
 @node Introduction to GDB Commands,Using Ada Expressions,Running GDB,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution introduction-to-gdb-commands}@anchor{172}@anchor{gnat_ugn/gnat_and_program_execution id5}@anchor{173}
+@anchor{gnat_ugn/gnat_and_program_execution introduction-to-gdb-commands}@anchor{171}@anchor{gnat_ugn/gnat_and_program_execution id5}@anchor{172}
 @subsection Introduction to GDB Commands
 @code{GDB} contains a large repertoire of commands.
 See @cite{Debugging with GDB} for extensive documentation on the use
 features are described in detail in @cite{Debugging with GDB}.
 Note that most commands can be abbreviated
 (for example, c for continue, bt for backtrace).
 @node Using Ada Expressions,Calling User-Defined Subprograms,Introduction to GDB Commands,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution id6}@anchor{174}@anchor{gnat_ugn/gnat_and_program_execution using-ada-expressions}@anchor{175}
+@anchor{gnat_ugn/gnat_and_program_execution id6}@anchor{173}@anchor{gnat_ugn/gnat_and_program_execution using-ada-expressions}@anchor{174}
 @subsection Using Ada Expressions
 @geindex Ada expressions (in gdb)
 @code{GDB} asks the user's intent.
 For details on the supported Ada syntax, see @cite{Debugging with GDB}.
 @node Calling User-Defined Subprograms,Using the next Command in a Function,Using Ada Expressions,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution id7}@anchor{176}@anchor{gnat_ugn/gnat_and_program_execution calling-user-defined-subprograms}@anchor{177}
+@anchor{gnat_ugn/gnat_and_program_execution id7}@anchor{175}@anchor{gnat_ugn/gnat_and_program_execution calling-user-defined-subprograms}@anchor{176}
 @subsection Calling User-Defined Subprograms
 An important capability of @code{GDB} is the ability to call user-defined
 subprograms while debugging. This is achieved simply by entering
 address the array elements. In such a case, instead of trying to print the
 elements directly from GDB, you can write a callable procedure that prints
 the elements in the desired format.
 @node Using the next Command in a Function,Stopping When Ada Exceptions Are Raised,Calling User-Defined Subprograms,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution using-the-next-command-in-a-function}@anchor{178}@anchor{gnat_ugn/gnat_and_program_execution id8}@anchor{179}
+@anchor{gnat_ugn/gnat_and_program_execution using-the-next-command-in-a-function}@anchor{177}@anchor{gnat_ugn/gnat_and_program_execution id8}@anchor{178}
 @subsection Using the @emph{next} Command in a Function
 When you use the @code{next} command in a function, the current source
 location will advance to the next statement as usual. A special case
 the start of the function. You should simply ignore this odd jump.
 The value returned is always that from the first return statement
 that was stepped through.
 @node Stopping When Ada Exceptions Are Raised,Ada Tasks,Using the next Command in a Function,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution stopping-when-ada-exceptions-are-raised}@anchor{17a}@anchor{gnat_ugn/gnat_and_program_execution id9}@anchor{17b}
+@anchor{gnat_ugn/gnat_and_program_execution stopping-when-ada-exceptions-are-raised}@anchor{179}@anchor{gnat_ugn/gnat_and_program_execution id9}@anchor{17a}
 @subsection Stopping When Ada Exceptions Are Raised
 @geindex Exceptions (in gdb)
 @end itemize
 @geindex Tasks (in gdb)
 @node Ada Tasks,Debugging Generic Units,Stopping When Ada Exceptions Are Raised,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution ada-tasks}@anchor{17c}@anchor{gnat_ugn/gnat_and_program_execution id10}@anchor{17d}
+@anchor{gnat_ugn/gnat_and_program_execution ada-tasks}@anchor{17b}@anchor{gnat_ugn/gnat_and_program_execution id10}@anchor{17c}
 @subsection Ada Tasks
 @code{GDB} allows the following task-related commands:
 @geindex Debugging Generic Units
 @geindex Generics
 @node Debugging Generic Units,Remote Debugging with gdbserver,Ada Tasks,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution debugging-generic-units}@anchor{17e}@anchor{gnat_ugn/gnat_and_program_execution id11}@anchor{17f}
+@anchor{gnat_ugn/gnat_and_program_execution debugging-generic-units}@anchor{17d}@anchor{gnat_ugn/gnat_and_program_execution id11}@anchor{17e}
 @subsection Debugging Generic Units
 GNAT always uses code expansion for generic instantiation. This means that
 each time an instantiation occurs, a complete copy of the original code is
 other units.
 @geindex Remote Debugging with gdbserver
 @node Remote Debugging with gdbserver,GNAT Abnormal Termination or Failure to Terminate,Debugging Generic Units,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution remote-debugging-with-gdbserver}@anchor{180}@anchor{gnat_ugn/gnat_and_program_execution id12}@anchor{181}
+@anchor{gnat_ugn/gnat_and_program_execution remote-debugging-with-gdbserver}@anchor{17f}@anchor{gnat_ugn/gnat_and_program_execution id12}@anchor{180}
 @subsection Remote Debugging with gdbserver
 On platforms where gdbserver is supported, it is possible to use this tool
 to debug your application remotely.  This can be useful in situations
 GNAT provides support for gdbserver on x86-linux, x86-windows and x86_64-linux.
 @geindex Abnormal Termination or Failure to Terminate
 @node GNAT Abnormal Termination or Failure to Terminate,Naming Conventions for GNAT Source Files,Remote Debugging with gdbserver,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution gnat-abnormal-termination-or-failure-to-terminate}@anchor{182}@anchor{gnat_ugn/gnat_and_program_execution id13}@anchor{183}
+@anchor{gnat_ugn/gnat_and_program_execution gnat-abnormal-termination-or-failure-to-terminate}@anchor{181}@anchor{gnat_ugn/gnat_and_program_execution id13}@anchor{182}
 @subsection GNAT Abnormal Termination or Failure to Terminate
 When presented with programs that contain serious errors in syntax
 or semantics,
 @item
 Finally, you can start
 @code{gdb} directly on the @code{gnat1} executable. @code{gnat1} is the
 front-end of GNAT, and can be run independently (normally it is just
 called from @code{gcc}). You can use @code{gdb} on @code{gnat1} as you
-would on a C program (but @ref{16e,,The GNAT Debugger GDB} for caveats). The
+would on a C program (but @ref{16d,,The GNAT Debugger GDB} for caveats). The
 @code{where} command is the first line of attack; the variable
 @code{lineno} (seen by @code{print lineno}), used by the second phase of
 @code{gnat1} and by the @code{gcc} backend, indicates the source line at
 which the execution stopped, and @code{input_file name} indicates the name of
 the source file.
 @end itemize
 @node Naming Conventions for GNAT Source Files,Getting Internal Debugging Information,GNAT Abnormal Termination or Failure to Terminate,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution naming-conventions-for-gnat-source-files}@anchor{184}@anchor{gnat_ugn/gnat_and_program_execution id14}@anchor{185}
+@anchor{gnat_ugn/gnat_and_program_execution naming-conventions-for-gnat-source-files}@anchor{183}@anchor{gnat_ugn/gnat_and_program_execution id14}@anchor{184}
 @subsection Naming Conventions for GNAT Source Files
 In order to examine the workings of the GNAT system, the following
 brief description of its organization may be helpful:
 general-purpose packages, fully documented in their specs. All
 the other @code{.c} files are modifications of common @code{gcc} files.
 @end itemize
 @node Getting Internal Debugging Information,Stack Traceback,Naming Conventions for GNAT Source Files,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution id15}@anchor{186}@anchor{gnat_ugn/gnat_and_program_execution getting-internal-debugging-information}@anchor{187}
+@anchor{gnat_ugn/gnat_and_program_execution id15}@anchor{185}@anchor{gnat_ugn/gnat_and_program_execution getting-internal-debugging-information}@anchor{186}
 @subsection Getting Internal Debugging Information
 Most compilers have internal debugging switches and modes. GNAT
 does also, except GNAT internal debugging switches and modes are not
 @geindex stack traceback
 @geindex stack unwinding
 @node Stack Traceback,Pretty-Printers for the GNAT runtime,Getting Internal Debugging Information,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution stack-traceback}@anchor{188}@anchor{gnat_ugn/gnat_and_program_execution id16}@anchor{189}
+@anchor{gnat_ugn/gnat_and_program_execution stack-traceback}@anchor{187}@anchor{gnat_ugn/gnat_and_program_execution id16}@anchor{188}
 @subsection Stack Traceback
 Traceback is a mechanism to display the sequence of subprogram calls that
 leads to a specified execution point in a program. Often (but not always)
 * Symbolic Traceback::
 @end menu
 @node Non-Symbolic Traceback,Symbolic Traceback,,Stack Traceback
-@anchor{gnat_ugn/gnat_and_program_execution non-symbolic-traceback}@anchor{18a}@anchor{gnat_ugn/gnat_and_program_execution id17}@anchor{18b}
+@anchor{gnat_ugn/gnat_and_program_execution non-symbolic-traceback}@anchor{189}@anchor{gnat_ugn/gnat_and_program_execution id17}@anchor{18a}
 @subsubsection Non-Symbolic Traceback
 Note: this feature is not supported on all platforms. See
 @code{GNAT.Traceback} spec in @code{g-traceb.ads}
 @geindex traceback
 @geindex symbolic
 @node Symbolic Traceback,,Non-Symbolic Traceback,Stack Traceback
-@anchor{gnat_ugn/gnat_and_program_execution id18}@anchor{18c}@anchor{gnat_ugn/gnat_and_program_execution symbolic-traceback}@anchor{18d}
+@anchor{gnat_ugn/gnat_and_program_execution id18}@anchor{18b}@anchor{gnat_ugn/gnat_and_program_execution symbolic-traceback}@anchor{18c}
 @subsubsection Symbolic Traceback
 A symbolic traceback is a stack traceback in which procedure names are
 associated with each code location.
 This will cause the Exception_Information to contain a symbolic traceback,
 which will also be printed if an unhandled exception terminates the
 program.
 @node Pretty-Printers for the GNAT runtime,,Stack Traceback,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution id19}@anchor{18e}@anchor{gnat_ugn/gnat_and_program_execution pretty-printers-for-the-gnat-runtime}@anchor{18f}
+@anchor{gnat_ugn/gnat_and_program_execution id19}@anchor{18d}@anchor{gnat_ugn/gnat_and_program_execution pretty-printers-for-the-gnat-runtime}@anchor{18e}
 @subsection Pretty-Printers for the GNAT runtime
 As discussed in @cite{Calling User-Defined Subprograms}, GDB's
 @code{print} command only knows about the physical layout of program data
 @end quotation
 Finer control of pretty-printers is also possible: see GDB's online documentation@footnote{http://docs.adacore.com/gdb-docs/html/gdb.html#Pretty_002dPrinter-Commands}
 for more information.
-@geindex Code Coverage
 @geindex Profiling
-@node Code Coverage and Profiling,Improving Performance,Running and Debugging Ada Programs,GNAT and Program Execution
+@node Profiling,Improving Performance,Running and Debugging Ada Programs,GNAT and Program Execution
-@anchor{gnat_ugn/gnat_and_program_execution id20}@anchor{168}@anchor{gnat_ugn/gnat_and_program_execution code-coverage-and-profiling}@anchor{25}
+@anchor{gnat_ugn/gnat_and_program_execution profiling}@anchor{25}@anchor{gnat_ugn/gnat_and_program_execution id20}@anchor{18f}
-@section Code Coverage and Profiling
+@section Profiling
-This section describes how to use the @code{gcov} coverage testing tool and
+This section describes how to use the the @code{gprof} profiler tool on Ada
-the @code{gprof} profiler tool on Ada programs.
+programs.
-@geindex gcov
+@geindex gprof
+@geindex Profiling
 @menu
-* Code Coverage of Ada Programs with gcov::
 * Profiling an Ada Program with gprof::
 @end menu
-@node Code Coverage of Ada Programs with gcov,Profiling an Ada Program with gprof,,Code Coverage and Profiling
+@node Profiling an Ada Program with gprof,,,Profiling
-@anchor{gnat_ugn/gnat_and_program_execution id21}@anchor{190}@anchor{gnat_ugn/gnat_and_program_execution code-coverage-of-ada-programs-with-gcov}@anchor{191}
+@anchor{gnat_ugn/gnat_and_program_execution id21}@anchor{190}@anchor{gnat_ugn/gnat_and_program_execution profiling-an-ada-program-with-gprof}@anchor{191}
-@subsection Code Coverage of Ada Programs with gcov
-@code{gcov} is a test coverage program: it analyzes the execution of a given
-program on selected tests, to help you determine the portions of the program
-that are still untested.
-@code{gcov} is part of the GCC suite, and is described in detail in the GCC
-User's Guide. You can refer to this documentation for a more complete
-description.
-This chapter provides a quick startup guide, and
-details some GNAT-specific features.
-@menu
-* Quick startup guide::
-* GNAT specifics::
-@end menu
-@node Quick startup guide,GNAT specifics,,Code Coverage of Ada Programs with gcov
-@anchor{gnat_ugn/gnat_and_program_execution id22}@anchor{192}@anchor{gnat_ugn/gnat_and_program_execution quick-startup-guide}@anchor{193}
-@subsubsection Quick startup guide
-In order to perform coverage analysis of a program using @code{gcov}, several
-steps are needed:
-@enumerate
-@item
-Instrument the code during the compilation process,
-@item
-Execute the instrumented program, and
-@item
-Invoke the @code{gcov} tool to generate the coverage results.
-@end enumerate
-@geindex -fprofile-arcs (gcc)
-@geindex -ftest-coverage (gcc
-@geindex -fprofile-arcs (gnatbind)
-The code instrumentation needed by gcov is created at the object level.
-The source code is not modified in any way, because the instrumentation code is
-inserted by gcc during the compilation process. To compile your code with code
-coverage activated, you need to recompile your whole project using the
-switches
-@code{-fprofile-arcs} and @code{-ftest-coverage}, and link it using
-@code{-fprofile-arcs}.
-@quotation
-@example
-$ gnatmake -P my_project.gpr -f -cargs -fprofile-arcs -ftest-coverage \\
--largs -fprofile-arcs
-@end example
-@end quotation
-This compilation process will create @code{.gcno} files together with
-the usual object files.
-Once the program is compiled with coverage instrumentation, you can
-run it as many times as needed -- on portions of a test suite for
-example. The first execution will produce @code{.gcda} files at the
-same location as the @code{.gcno} files.  Subsequent executions
-will update those files, so that a cumulative result of the covered
-portions of the program is generated.
-Finally, you need to call the @code{gcov} tool. The different options of
-@code{gcov} are described in the GCC User's Guide, section @emph{Invoking gcov}.
-This will create annotated source files with a @code{.gcov} extension:
-@code{my_main.adb} file will be analyzed in @code{my_main.adb.gcov}.
-@node GNAT specifics,,Quick startup guide,Code Coverage of Ada Programs with gcov
-@anchor{gnat_ugn/gnat_and_program_execution gnat-specifics}@anchor{194}@anchor{gnat_ugn/gnat_and_program_execution id23}@anchor{195}
-@subsubsection GNAT specifics
-Because of Ada semantics, portions of the source code may be shared among
-several object files. This is the case for example when generics are
-involved, when inlining is active  or when declarations generate  initialisation
-calls. In order to take
-into account this shared code, you need to call @code{gcov} on all
-source files of the tested program at once.
-The list of source files might exceed the system's maximum command line
-length. In order to bypass this limitation, a new mechanism has been
-implemented in @code{gcov}: you can now list all your project's files into a
-text file, and provide this file to gcov as a parameter,  preceded by a @code{@@}
-(e.g. @code{gcov @@mysrclist.txt}).
-Note that on AIX compiling a static library with @code{-fprofile-arcs} is
-not supported as there can be unresolved symbols during the final link.
-@geindex gprof
-@geindex Profiling
-@node Profiling an Ada Program with gprof,,Code Coverage of Ada Programs with gcov,Code Coverage and Profiling
-@anchor{gnat_ugn/gnat_and_program_execution profiling-an-ada-program-with-gprof}@anchor{196}@anchor{gnat_ugn/gnat_and_program_execution id24}@anchor{197}
 @subsection Profiling an Ada Program with gprof
 This section is not meant to be an exhaustive documentation of @code{gprof}.
 Full documentation for it can be found in the @cite{GNU Profiler User's Guide}
 @itemize *
 @item
 linux x86/x86_64
-@item
-solaris sparc/sparc64/x86
 @item
 windows x86
 @end itemize
 * Interpretation of profiling results::
 @end menu
 @node Compilation for profiling,Program execution,,Profiling an Ada Program with gprof
-@anchor{gnat_ugn/gnat_and_program_execution id25}@anchor{198}@anchor{gnat_ugn/gnat_and_program_execution compilation-for-profiling}@anchor{199}
+@anchor{gnat_ugn/gnat_and_program_execution id22}@anchor{192}@anchor{gnat_ugn/gnat_and_program_execution compilation-for-profiling}@anchor{193}
 @subsubsection Compilation for profiling
 @geindex -pg (gcc)
 @geindex for profiling
 Note that only the objects that were compiled with the @code{-pg} switch will
 be profiled; if you need to profile your whole project, use the @code{-f}
 gnatmake switch to force full recompilation.
 @node Program execution,Running gprof,Compilation for profiling,Profiling an Ada Program with gprof
-@anchor{gnat_ugn/gnat_and_program_execution program-execution}@anchor{19a}@anchor{gnat_ugn/gnat_and_program_execution id26}@anchor{19b}
+@anchor{gnat_ugn/gnat_and_program_execution program-execution}@anchor{194}@anchor{gnat_ugn/gnat_and_program_execution id23}@anchor{195}
 @subsubsection Program execution
 Once the program has been compiled for profiling, you can run it as usual.
 Once the program completes execution, a data file called @code{gmon.out} is
 generated in the directory where the program was launched from. If this file
 already exists, it will be overwritten.
 @node Running gprof,Interpretation of profiling results,Program execution,Profiling an Ada Program with gprof
-@anchor{gnat_ugn/gnat_and_program_execution running-gprof}@anchor{19c}@anchor{gnat_ugn/gnat_and_program_execution id27}@anchor{19d}
+@anchor{gnat_ugn/gnat_and_program_execution running-gprof}@anchor{196}@anchor{gnat_ugn/gnat_and_program_execution id24}@anchor{197}
 @subsubsection Running gprof
 The @code{gprof} tool is called as follow:
 may be given; only one @code{function_name} may be indicated with each
 @code{-F} option.  The @code{-F} option overrides the @code{-E} option.
 @end table
 @node Interpretation of profiling results,,Running gprof,Profiling an Ada Program with gprof
-@anchor{gnat_ugn/gnat_and_program_execution id28}@anchor{19e}@anchor{gnat_ugn/gnat_and_program_execution interpretation-of-profiling-results}@anchor{19f}
+@anchor{gnat_ugn/gnat_and_program_execution id25}@anchor{198}@anchor{gnat_ugn/gnat_and_program_execution interpretation-of-profiling-results}@anchor{199}
 @subsubsection Interpretation of profiling results
 The results of the profiling analysis are represented by two arrays: the
 'flat profile' and the 'call graph'. Full documentation of those outputs
 The call graph shows, for each subprogram, the subprograms that call it,
 and the subprograms that it calls. It also provides an estimate of the time
 spent in each of those callers/called subprograms.
-@node Improving Performance,Overflow Check Handling in GNAT,Code Coverage and Profiling,GNAT and Program Execution
+@node Improving Performance,Overflow Check Handling in GNAT,Profiling,GNAT and Program Execution
-@anchor{gnat_ugn/gnat_and_program_execution id29}@anchor{169}@anchor{gnat_ugn/gnat_and_program_execution improving-performance}@anchor{26}
+@anchor{gnat_ugn/gnat_and_program_execution improving-performance}@anchor{26}@anchor{gnat_ugn/gnat_and_program_execution id26}@anchor{168}
 @section Improving Performance
 @geindex Improving performance
 * Reducing Size of Executables with Unused Subprogram/Data Elimination::
 @end menu
 @node Performance Considerations,Text_IO Suggestions,,Improving Performance
-@anchor{gnat_ugn/gnat_and_program_execution performance-considerations}@anchor{1a0}@anchor{gnat_ugn/gnat_and_program_execution id30}@anchor{1a1}
+@anchor{gnat_ugn/gnat_and_program_execution performance-considerations}@anchor{19a}@anchor{gnat_ugn/gnat_and_program_execution id27}@anchor{19b}
 @subsection Performance Considerations
 The GNAT system provides a number of options that allow a trade-off
 between
 * Passive Task Optimization::
 @end menu
 @node Controlling Run-Time Checks,Use of Restrictions,,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution controlling-run-time-checks}@anchor{1a2}@anchor{gnat_ugn/gnat_and_program_execution id31}@anchor{1a3}
+@anchor{gnat_ugn/gnat_and_program_execution id28}@anchor{19c}@anchor{gnat_ugn/gnat_and_program_execution controlling-run-time-checks}@anchor{19d}
 @subsubsection Controlling Run-Time Checks
 By default, GNAT generates all run-time checks, except stack overflow
 checks, and checks for access before elaboration on subprogram
 the checks. They may be modified using either @code{pragma Suppress} (to
 remove checks) or @code{pragma Unsuppress} (to add back suppressed
 checks) in the program source.
 @node Use of Restrictions,Optimization Levels,Controlling Run-Time Checks,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution id32}@anchor{1a4}@anchor{gnat_ugn/gnat_and_program_execution use-of-restrictions}@anchor{1a5}
+@anchor{gnat_ugn/gnat_and_program_execution id29}@anchor{19e}@anchor{gnat_ugn/gnat_and_program_execution use-of-restrictions}@anchor{19f}
 @subsubsection Use of Restrictions
 The use of pragma Restrictions allows you to control which features are
 permitted in your program. Apart from the obvious point that if you avoid
 It is recommended that these restriction pragmas be used if possible. Note
 that this also means that you can write code without worrying about the
 possibility of an immediate abort at any point.
 @node Optimization Levels,Debugging Optimized Code,Use of Restrictions,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution id33}@anchor{1a6}@anchor{gnat_ugn/gnat_and_program_execution optimization-levels}@anchor{fc}
+@anchor{gnat_ugn/gnat_and_program_execution id30}@anchor{1a0}@anchor{gnat_ugn/gnat_and_program_execution optimization-levels}@anchor{fc}
 @subsubsection Optimization Levels
 @geindex -O (gcc)
 ought not to be automatically preferred over that of level @code{-O2},
 since it often results in larger executables which may run more slowly.
 See further discussion of this point in @ref{10f,,Inlining of Subprograms}.
 @node Debugging Optimized Code,Inlining of Subprograms,Optimization Levels,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution id34}@anchor{1a7}@anchor{gnat_ugn/gnat_and_program_execution debugging-optimized-code}@anchor{1a8}
+@anchor{gnat_ugn/gnat_and_program_execution debugging-optimized-code}@anchor{1a1}@anchor{gnat_ugn/gnat_and_program_execution id31}@anchor{1a2}
 @subsubsection Debugging Optimized Code
 @geindex Debugging optimized code
 Note that if you use @code{-g} you can then use the @code{strip} program
 on the resulting executable,
 which removes both debugging information and global symbols.
 @node Inlining of Subprograms,Floating_Point_Operations,Debugging Optimized Code,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution id35}@anchor{1a9}@anchor{gnat_ugn/gnat_and_program_execution inlining-of-subprograms}@anchor{10f}
+@anchor{gnat_ugn/gnat_and_program_execution id32}@anchor{1a3}@anchor{gnat_ugn/gnat_and_program_execution inlining-of-subprograms}@anchor{10f}
 @subsubsection Inlining of Subprograms
 A call to a subprogram in the current unit is inlined if all the
 following conditions are met:
 automatically assume that @code{-O3} is better than @code{-O2}, and
 indeed you should use @code{-O3} only if tests show that it actually
 improves performance for your program.
 @node Floating_Point_Operations,Vectorization of loops,Inlining of Subprograms,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution id36}@anchor{1aa}@anchor{gnat_ugn/gnat_and_program_execution floating-point-operations}@anchor{1ab}
+@anchor{gnat_ugn/gnat_and_program_execution floating-point-operations}@anchor{1a4}@anchor{gnat_ugn/gnat_and_program_execution id33}@anchor{1a5}
 @subsubsection Floating_Point_Operations
 @geindex Floating-Point Operations
 Note that the ABI has the same form for both floating-point models,
 so it is permissible to mix units compiled with and without these
 switches.
 @node Vectorization of loops,Other Optimization Switches,Floating_Point_Operations,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution id37}@anchor{1ac}@anchor{gnat_ugn/gnat_and_program_execution vectorization-of-loops}@anchor{1ad}
+@anchor{gnat_ugn/gnat_and_program_execution id34}@anchor{1a6}@anchor{gnat_ugn/gnat_and_program_execution vectorization-of-loops}@anchor{1a7}
 @subsubsection Vectorization of loops
 @geindex Optimization Switches
 placed immediately within the loop will tell the compiler that it can safely
 omit the non-vectorized version of the loop as well as the run-time test.
 @node Other Optimization Switches,Optimization and Strict Aliasing,Vectorization of loops,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution other-optimization-switches}@anchor{1ae}@anchor{gnat_ugn/gnat_and_program_execution id38}@anchor{1af}
+@anchor{gnat_ugn/gnat_and_program_execution other-optimization-switches}@anchor{1a8}@anchor{gnat_ugn/gnat_and_program_execution id35}@anchor{1a9}
 @subsubsection Other Optimization Switches
 @geindex Optimization Switches
 on appropriate machines). For full details of these switches, see
 the @emph{Submodel Options} section in the @emph{Hardware Models and Configurations}
 chapter of @cite{Using the GNU Compiler Collection (GCC)}.
 @node Optimization and Strict Aliasing,Aliased Variables and Optimization,Other Optimization Switches,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution optimization-and-strict-aliasing}@anchor{f3}@anchor{gnat_ugn/gnat_and_program_execution id39}@anchor{1b0}
+@anchor{gnat_ugn/gnat_and_program_execution optimization-and-strict-aliasing}@anchor{f3}@anchor{gnat_ugn/gnat_and_program_execution id36}@anchor{1aa}
 @subsubsection Optimization and Strict Aliasing
 @geindex Aliasing
 @code{-O2} with strict aliasing in effect, then you should
 review any uses of unchecked conversion of access types,
 particularly if you are getting the warnings described above.
 @node Aliased Variables and Optimization,Atomic Variables and Optimization,Optimization and Strict Aliasing,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution aliased-variables-and-optimization}@anchor{1b1}@anchor{gnat_ugn/gnat_and_program_execution id40}@anchor{1b2}
+@anchor{gnat_ugn/gnat_and_program_execution id37}@anchor{1ab}@anchor{gnat_ugn/gnat_and_program_execution aliased-variables-and-optimization}@anchor{1ac}
 @subsubsection Aliased Variables and Optimization
 @geindex Aliasing
 inhibits optimizations that assume the value cannot be assigned.
 This means that the above example will in fact "work" reliably,
 that is, it will produce the expected results.
 @node Atomic Variables and Optimization,Passive Task Optimization,Aliased Variables and Optimization,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution atomic-variables-and-optimization}@anchor{1b3}@anchor{gnat_ugn/gnat_and_program_execution id41}@anchor{1b4}
+@anchor{gnat_ugn/gnat_and_program_execution atomic-variables-and-optimization}@anchor{1ad}@anchor{gnat_ugn/gnat_and_program_execution id38}@anchor{1ae}
 @subsubsection Atomic Variables and Optimization
 @geindex Atomic
 GNAT Reference Manual. If performance is critical, and
 such synchronization code is not required, it may be
 useful to disable it.
 @node Passive Task Optimization,,Atomic Variables and Optimization,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution id42}@anchor{1b5}@anchor{gnat_ugn/gnat_and_program_execution passive-task-optimization}@anchor{1b6}
+@anchor{gnat_ugn/gnat_and_program_execution passive-task-optimization}@anchor{1af}@anchor{gnat_ugn/gnat_and_program_execution id39}@anchor{1b0}
 @subsubsection Passive Task Optimization
 @geindex Passive Task
 arise, and update those particular tasks to be protected types. Note
 that typically clients of the tasks who call entries, will not have
 to be modified, only the task definition itself.
 @node Text_IO Suggestions,Reducing Size of Executables with Unused Subprogram/Data Elimination,Performance Considerations,Improving Performance
-@anchor{gnat_ugn/gnat_and_program_execution text-io-suggestions}@anchor{1b7}@anchor{gnat_ugn/gnat_and_program_execution id43}@anchor{1b8}
+@anchor{gnat_ugn/gnat_and_program_execution text-io-suggestions}@anchor{1b1}@anchor{gnat_ugn/gnat_and_program_execution id40}@anchor{1b2}
 @subsection @code{Text_IO} Suggestions
 @geindex Text_IO and performance
 performance is an important factor, use a designated file instead
 of the standard output file, or change the standard output file to
 be buffered using @code{Interfaces.C_Streams.setvbuf}.
 @node Reducing Size of Executables with Unused Subprogram/Data Elimination,,Text_IO Suggestions,Improving Performance
-@anchor{gnat_ugn/gnat_and_program_execution id44}@anchor{1b9}@anchor{gnat_ugn/gnat_and_program_execution reducing-size-of-executables-with-unused-subprogram-data-elimination}@anchor{1ba}
+@anchor{gnat_ugn/gnat_and_program_execution id41}@anchor{1b3}@anchor{gnat_ugn/gnat_and_program_execution reducing-size-of-executables-with-unused-subprogram-data-elimination}@anchor{1b4}
 @subsection Reducing Size of Executables with Unused Subprogram/Data Elimination
 @geindex Uunused subprogram/data elimination
 * Example of unused subprogram/data elimination::
 @end menu
 @node About unused subprogram/data elimination,Compilation options,,Reducing Size of Executables with Unused Subprogram/Data Elimination
-@anchor{gnat_ugn/gnat_and_program_execution id45}@anchor{1bb}@anchor{gnat_ugn/gnat_and_program_execution about-unused-subprogram-data-elimination}@anchor{1bc}
+@anchor{gnat_ugn/gnat_and_program_execution id42}@anchor{1b5}@anchor{gnat_ugn/gnat_and_program_execution about-unused-subprogram-data-elimination}@anchor{1b6}
 @subsubsection About unused subprogram/data elimination
 By default, an executable contains all code and data of its composing objects
 (directly linked or coming from statically linked libraries), even data or code
 This functionality is available on all Linux platforms except for the IA-64
 architecture and on all cross platforms using the ELF binary file format.
 In both cases GNU binutils version 2.16 or later are required to enable it.
 @node Compilation options,Example of unused subprogram/data elimination,About unused subprogram/data elimination,Reducing Size of Executables with Unused Subprogram/Data Elimination
-@anchor{gnat_ugn/gnat_and_program_execution id46}@anchor{1bd}@anchor{gnat_ugn/gnat_and_program_execution compilation-options}@anchor{1be}
+@anchor{gnat_ugn/gnat_and_program_execution id43}@anchor{1b7}@anchor{gnat_ugn/gnat_and_program_execution compilation-options}@anchor{1b8}
 @subsubsection Compilation options
 The operation of eliminating the unused code and data from the final executable
 is directly performed by the linker.
 The GNAT static library is now compiled with -ffunction-sections and
 -fdata-sections on some platforms. This allows you to eliminate the unused code
 and data of the GNAT library from your executable.
 @node Example of unused subprogram/data elimination,,Compilation options,Reducing Size of Executables with Unused Subprogram/Data Elimination
-@anchor{gnat_ugn/gnat_and_program_execution id47}@anchor{1bf}@anchor{gnat_ugn/gnat_and_program_execution example-of-unused-subprogram-data-elimination}@anchor{1c0}
+@anchor{gnat_ugn/gnat_and_program_execution example-of-unused-subprogram-data-elimination}@anchor{1b9}@anchor{gnat_ugn/gnat_and_program_execution id44}@anchor{1ba}
 @subsubsection Example of unused subprogram/data elimination
 Here is a simple example:
 @geindex Checks (overflow)
 @node Overflow Check Handling in GNAT,Performing Dimensionality Analysis in GNAT,Improving Performance,GNAT and Program Execution
-@anchor{gnat_ugn/gnat_and_program_execution id55}@anchor{16a}@anchor{gnat_ugn/gnat_and_program_execution overflow-check-handling-in-gnat}@anchor{27}
+@anchor{gnat_ugn/gnat_and_program_execution id50}@anchor{169}@anchor{gnat_ugn/gnat_and_program_execution overflow-check-handling-in-gnat}@anchor{27}
 @section Overflow Check Handling in GNAT
 This section explains how to control the handling of overflow checks.
 * Implementation Notes::
 @end menu
 @node Background,Management of Overflows in GNAT,,Overflow Check Handling in GNAT
-@anchor{gnat_ugn/gnat_and_program_execution id56}@anchor{1c1}@anchor{gnat_ugn/gnat_and_program_execution background}@anchor{1c2}
+@anchor{gnat_ugn/gnat_and_program_execution id51}@anchor{1bb}@anchor{gnat_ugn/gnat_and_program_execution background}@anchor{1bc}
 @subsection Background
 Overflow checks are checks that the compiler may make to ensure
 that intermediate results are not out of range. For example:
 is True, but at run time we may (but are not guaranteed to) get an
 exception raised because of the intermediate overflow (and we really
 would prefer this precondition to be considered True at run time).
 @node Management of Overflows in GNAT,Specifying the Desired Mode,Background,Overflow Check Handling in GNAT
-@anchor{gnat_ugn/gnat_and_program_execution id57}@anchor{1c3}@anchor{gnat_ugn/gnat_and_program_execution management-of-overflows-in-gnat}@anchor{1c4}
+@anchor{gnat_ugn/gnat_and_program_execution management-of-overflows-in-gnat}@anchor{1bd}@anchor{gnat_ugn/gnat_and_program_execution id52}@anchor{1be}
 @subsection Management of Overflows in GNAT
 To deal with the portability issue, and with the problem of
 mathematical versus run-time interpretation of the expressions in
 constrained floating-point type, and range checks will be carried
 out in the normal manner (with infinite values always failing all
 range checks).
 @node Specifying the Desired Mode,Default Settings,Management of Overflows in GNAT,Overflow Check Handling in GNAT
-@anchor{gnat_ugn/gnat_and_program_execution specifying-the-desired-mode}@anchor{f8}@anchor{gnat_ugn/gnat_and_program_execution id58}@anchor{1c5}
+@anchor{gnat_ugn/gnat_and_program_execution specifying-the-desired-mode}@anchor{f8}@anchor{gnat_ugn/gnat_and_program_execution id53}@anchor{1bf}
 @subsection Specifying the Desired Mode
 @geindex pragma Overflow_Mode
 @code{-gnato11},
 causing all intermediate operations to be computed using the base
 type (@code{STRICT} mode).
 @node Default Settings,Implementation Notes,Specifying the Desired Mode,Overflow Check Handling in GNAT
-@anchor{gnat_ugn/gnat_and_program_execution id59}@anchor{1c6}@anchor{gnat_ugn/gnat_and_program_execution default-settings}@anchor{1c7}
+@anchor{gnat_ugn/gnat_and_program_execution id54}@anchor{1c0}@anchor{gnat_ugn/gnat_and_program_execution default-settings}@anchor{1c1}
 @subsection Default Settings
 The default mode for overflow checks is
 The pragma @code{Unsuppress (Overflow_Check)} enables overflow
 checking, but it has no effect on the method used for computing
 intermediate results.
 @node Implementation Notes,,Default Settings,Overflow Check Handling in GNAT
-@anchor{gnat_ugn/gnat_and_program_execution implementation-notes}@anchor{1c8}@anchor{gnat_ugn/gnat_and_program_execution id60}@anchor{1c9}
+@anchor{gnat_ugn/gnat_and_program_execution id55}@anchor{1c2}@anchor{gnat_ugn/gnat_and_program_execution implementation-notes}@anchor{1c3}
 @subsection Implementation Notes
 In practice on typical 64-bit machines, the @code{MINIMIZED} mode is
 reasonably efficient, and can be generally used. It also helps
 Currently, the @code{ELIMINATED} mode is only available on target
 platforms for which @code{Long_Long_Integer} is 64-bits (nearly all GNAT
 platforms).
 @node Performing Dimensionality Analysis in GNAT,Stack Related Facilities,Overflow Check Handling in GNAT,GNAT and Program Execution
-@anchor{gnat_ugn/gnat_and_program_execution id61}@anchor{16b}@anchor{gnat_ugn/gnat_and_program_execution performing-dimensionality-analysis-in-gnat}@anchor{28}
+@anchor{gnat_ugn/gnat_and_program_execution id56}@anchor{16a}@anchor{gnat_ugn/gnat_and_program_execution performing-dimensionality-analysis-in-gnat}@anchor{28}
 @section Performing Dimensionality Analysis in GNAT
 @geindex Dimensionality analysis
 @geindex System.Dim.Mks package (GNAT library)
 @geindex MKS_Type type
 The simplest way to impose dimensionality checking on a computation is to make
-use of the package @code{System.Dim.Mks},
+use of one of the instantiations of the package @code{System.Dim.Generic_Mks}, which
-which is part of the GNAT library. This
+are part of the GNAT library. This generic package defines a floating-point
-package defines a floating-point type @code{MKS_Type},
+type @code{MKS_Type}, for which a sequence of dimension names are specified,
-for which a sequence of
+together with their conventional abbreviations.  The following should be read
-dimension names are specified, together with their conventional abbreviations.
+together with the full specification of the package, in file
-The following should be read together with the full specification of the
+@code{s-digemk.ads}.
-package, in file @code{s-dimmks.ads}.
 @quotation
-@geindex s-dimmks.ads file
+@geindex s-digemk.ads file
 @example
-type Mks_Type is new Long_Long_Float
+type Mks_Type is new Float_Type
 with
 Dimension_System => (
 (Unit_Name => Meter,    Unit_Symbol => 'm',   Dim_Symbol => 'L'),
 (Unit_Name => Kilogram, Unit_Symbol => "kg",  Dim_Symbol => 'M'),
 (Unit_Name => Second,   Unit_Symbol => 's',   Dim_Symbol => 'T'),
 day : constant Time   := 60.0 * 24.0 * min;
 ...
 @end example
 @end quotation
-Using this package, you can then define a derived unit by
+There are three instantiations of @code{System.Dim.Generic_Mks} defined in the
-providing the aspect that
+GNAT library:
-specifies its dimensions within the MKS system, as well as the string to
-be used for output of a value of that unit:
+@itemize *
+@item
+@code{System.Dim.Float_Mks} based on @code{Float} defined in @code{s-diflmk.ads}.
+@item
+@code{System.Dim.Long_Mks} based on @code{Long_Float} defined in @code{s-dilomk.ads}.
+@item
+@code{System.Dim.Mks} based on @code{Long_Long_Float} defined in @code{s-dimmks.ads}.
+@end itemize
+Using one of these packages, you can then define a derived unit by providing
+the aspect that specifies its dimensions within the MKS system, as well as the
+string to be used for output of a value of that unit:
 @quotation
 @example
 subtype Acceleration is Mks_Type
 requires @code{DV(Source)} = @code{DV(Target)}, and analogously for parameter
 passing (the dimension vector for the actual parameter must be equal to the
 dimension vector for the formal parameter).
 @node Stack Related Facilities,Memory Management Issues,Performing Dimensionality Analysis in GNAT,GNAT and Program Execution
-@anchor{gnat_ugn/gnat_and_program_execution stack-related-facilities}@anchor{29}@anchor{gnat_ugn/gnat_and_program_execution id62}@anchor{16c}
+@anchor{gnat_ugn/gnat_and_program_execution id57}@anchor{16b}@anchor{gnat_ugn/gnat_and_program_execution stack-related-facilities}@anchor{29}
 @section Stack Related Facilities
 This section describes some useful tools associated with stack
 checking and analysis. In
 * Dynamic Stack Usage Analysis::
 @end menu
 @node Stack Overflow Checking,Static Stack Usage Analysis,,Stack Related Facilities
-@anchor{gnat_ugn/gnat_and_program_execution id63}@anchor{1ca}@anchor{gnat_ugn/gnat_and_program_execution stack-overflow-checking}@anchor{f4}
+@anchor{gnat_ugn/gnat_and_program_execution id58}@anchor{1c4}@anchor{gnat_ugn/gnat_and_program_execution stack-overflow-checking}@anchor{f4}
 @subsection Stack Overflow Checking
 @geindex Stack Overflow Checking
 Units compiled with this option will generate extra instructions to check
 that any use of the stack (for procedure calls or for declaring local
 variables in declare blocks) does not exceed the available stack space.
 If the space is exceeded, then a @code{Storage_Error} exception is raised.
-For declared tasks, the stack size is controlled by the size
+For declared tasks, the default stack size is defined by the GNAT runtime,
-given in an applicable @code{Storage_Size} pragma or by the value specified
+whose size may be modified at bind time through the @code{-d} bind switch
-at bind time with @code{-d} (@ref{11f,,Switches for gnatbind}) or is set to
+(@ref{11f,,Switches for gnatbind}). Task specific stack sizes may be set using the
-the default size as defined in the GNAT runtime otherwise.
+@code{Storage_Size} pragma.
-@geindex GNAT_STACK_LIMIT
+For the environment task, the stack size is determined by the operating system.
+Consequently, to modify the size of the environment task please refer to your
-For the environment task, the stack size depends on
+operating system documentation.
-system defaults and is unknown to the compiler. Stack checking
-may still work correctly if a fixed
-size stack is allocated, but this cannot be guaranteed.
-To ensure that a clean exception is signalled for stack
-overflow, set the environment variable
-@geindex GNAT_STACK_LIMIT
-@geindex environment variable; GNAT_STACK_LIMIT
-@code{GNAT_STACK_LIMIT} to indicate the maximum
-stack area that can be used, as in:
-@quotation
-@example
-$ SET GNAT_STACK_LIMIT 1600
-@end example
-@end quotation
-The limit is given in kilobytes, so the above declaration would
-set the stack limit of the environment task to 1.6 megabytes.
-Note that the only purpose of this usage is to limit the amount
-of stack used by the environment task. If it is necessary to
-increase the amount of stack for the environment task, then this
-is an operating systems issue, and must be addressed with the
-appropriate operating systems commands.
 @node Static Stack Usage Analysis,Dynamic Stack Usage Analysis,Stack Overflow Checking,Stack Related Facilities
-@anchor{gnat_ugn/gnat_and_program_execution id64}@anchor{1cb}@anchor{gnat_ugn/gnat_and_program_execution static-stack-usage-analysis}@anchor{f5}
+@anchor{gnat_ugn/gnat_and_program_execution static-stack-usage-analysis}@anchor{f5}@anchor{gnat_ugn/gnat_and_program_execution id59}@anchor{1c5}
 @subsection Static Stack Usage Analysis
 @geindex Static Stack Usage Analysis
 A unit compiled with @code{-Wstack-usage} will issue a warning for each
 subprogram whose stack usage might be larger than the specified amount of
 bytes.  The wording is in keeping with the qualifier documented above.
 @node Dynamic Stack Usage Analysis,,Static Stack Usage Analysis,Stack Related Facilities
-@anchor{gnat_ugn/gnat_and_program_execution id65}@anchor{1cc}@anchor{gnat_ugn/gnat_and_program_execution dynamic-stack-usage-analysis}@anchor{121}
+@anchor{gnat_ugn/gnat_and_program_execution dynamic-stack-usage-analysis}@anchor{121}@anchor{gnat_ugn/gnat_and_program_execution id60}@anchor{1c6}
 @subsection Dynamic Stack Usage Analysis
 It is possible to measure the maximum amount of stack used by a task, by
 adding a switch to @code{gnatbind}, as:
 In order to prevent overflow, the stack
 is not entirely analyzed, and it's not possible to know exactly how
 much has actually been used.
 @end itemize
-The environment task stack, e.g., the stack that contains the main unit, is
+By default the environment task stack, the stack that contains the main unit,
-only processed when the environment variable GNAT_STACK_LIMIT is set.
+is not processed. To enable processing of the environment task stack, the
+environment variable GNAT_STACK_LIMIT needs to be set to the maximum size of
+the environment task stack. This amount is given in kilobytes. For example:
+@quotation
+@example
+$ set GNAT_STACK_LIMIT 1600
+@end example
+@end quotation
+would specify to the analyzer that the environment task stack has a limit
+of 1.6 megabytes. Any stack usage beyond this will be ignored by the analysis.
 The package @code{GNAT.Task_Stack_Usage} provides facilities to get
-stack usage reports at run-time. See its body for the details.
+stack-usage reports at run time. See its body for the details.
 @node Memory Management Issues,,Stack Related Facilities,GNAT and Program Execution
-@anchor{gnat_ugn/gnat_and_program_execution id66}@anchor{16d}@anchor{gnat_ugn/gnat_and_program_execution memory-management-issues}@anchor{2a}
+@anchor{gnat_ugn/gnat_and_program_execution id61}@anchor{16c}@anchor{gnat_ugn/gnat_and_program_execution memory-management-issues}@anchor{2a}
 @section Memory Management Issues
 This section describes some useful memory pools provided in the GNAT library
 and in particular the GNAT Debug Pool facility, which can be used to detect
 * The GNAT Debug Pool Facility::
 @end menu
 @node Some Useful Memory Pools,The GNAT Debug Pool Facility,,Memory Management Issues
-@anchor{gnat_ugn/gnat_and_program_execution id67}@anchor{1cd}@anchor{gnat_ugn/gnat_and_program_execution some-useful-memory-pools}@anchor{1ce}
+@anchor{gnat_ugn/gnat_and_program_execution id62}@anchor{1c7}@anchor{gnat_ugn/gnat_and_program_execution some-useful-memory-pools}@anchor{1c8}
 @subsection Some Useful Memory Pools
 @geindex Memory Pool
 for T1'Storage_Size use 10_000;
 @end example
 @end quotation
 @node The GNAT Debug Pool Facility,,Some Useful Memory Pools,Memory Management Issues
-@anchor{gnat_ugn/gnat_and_program_execution id68}@anchor{1cf}@anchor{gnat_ugn/gnat_and_program_execution the-gnat-debug-pool-facility}@anchor{1d0}
+@anchor{gnat_ugn/gnat_and_program_execution id63}@anchor{1c9}@anchor{gnat_ugn/gnat_and_program_execution the-gnat-debug-pool-facility}@anchor{1ca}
 @subsection The GNAT Debug Pool Facility
 @geindex Debug Pool
 @c -- Non-breaking space in running text
 @c -- E.g. Ada |nbsp| 95
 @node Platform-Specific Information,Example of Binder Output File,GNAT and Program Execution,Top
-@anchor{gnat_ugn/platform_specific_information platform-specific-information}@anchor{d}@anchor{gnat_ugn/platform_specific_information doc}@anchor{1d1}@anchor{gnat_ugn/platform_specific_information id1}@anchor{1d2}
+@anchor{gnat_ugn/platform_specific_information platform-specific-information}@anchor{d}@anchor{gnat_ugn/platform_specific_information doc}@anchor{1cb}@anchor{gnat_ugn/platform_specific_information id1}@anchor{1cc}
 @chapter Platform-Specific Information
 This appendix contains information relating to the implementation
 of run-time libraries on various platforms and also covers
 topics related to the GNAT implementation on Windows and Mac OS.
 @menu
 * Run-Time Libraries::
 * Specifying a Run-Time Library::
+* GNU/Linux Topics::
 * Microsoft Windows Topics::
 * Mac OS Topics::
 @end menu
 @node Run-Time Libraries,Specifying a Run-Time Library,,Platform-Specific Information
-@anchor{gnat_ugn/platform_specific_information id2}@anchor{1d3}@anchor{gnat_ugn/platform_specific_information run-time-libraries}@anchor{2b}
+@anchor{gnat_ugn/platform_specific_information id2}@anchor{1cd}@anchor{gnat_ugn/platform_specific_information run-time-libraries}@anchor{2b}
 @section Run-Time Libraries
 @geindex Tasking and threads libraries
 * Summary of Run-Time Configurations::
 @end menu
 @node Summary of Run-Time Configurations,,,Run-Time Libraries
-@anchor{gnat_ugn/platform_specific_information summary-of-run-time-configurations}@anchor{1d4}@anchor{gnat_ugn/platform_specific_information id3}@anchor{1d5}
+@anchor{gnat_ugn/platform_specific_information summary-of-run-time-configurations}@anchor{1ce}@anchor{gnat_ugn/platform_specific_information id3}@anchor{1cf}
 @subsection Summary of Run-Time Configurations
 @multitable {xxxxxxxxxxxxxxxxxxx} {xxxxxxxxxxxxxxxx} {xxxxxxxxxxxxxxxxxxxxxxxxxxx} {xxxxxxxxxxxxxx}
 ZCX
 @end multitable
-@node Specifying a Run-Time Library,Microsoft Windows Topics,Run-Time Libraries,Platform-Specific Information
+@node Specifying a Run-Time Library,GNU/Linux Topics,Run-Time Libraries,Platform-Specific Information
-@anchor{gnat_ugn/platform_specific_information specifying-a-run-time-library}@anchor{1d6}@anchor{gnat_ugn/platform_specific_information id4}@anchor{1d7}
+@anchor{gnat_ugn/platform_specific_information specifying-a-run-time-library}@anchor{1d0}@anchor{gnat_ugn/platform_specific_information id4}@anchor{1d1}
 @section Specifying a Run-Time Library
 The @code{adainclude} subdirectory containing the sources of the GNAT
 run-time library, and the @code{adalib} subdirectory containing the
 @geindex --RTS option
 Selecting another run-time library temporarily can be
 achieved by using the @code{--RTS} switch, e.g., @code{--RTS=sjlj}
-@anchor{gnat_ugn/platform_specific_information choosing-the-scheduling-policy}@anchor{1d8}
+@anchor{gnat_ugn/platform_specific_information choosing-the-scheduling-policy}@anchor{1d2}
 @geindex SCHED_FIFO scheduling policy
 @geindex SCHED_RR scheduling policy
 @geindex SCHED_OTHER scheduling policy
 * Choosing the Scheduling Policy::
 @end menu
 @node Choosing the Scheduling Policy,,,Specifying a Run-Time Library
-@anchor{gnat_ugn/platform_specific_information id5}@anchor{1d9}
+@anchor{gnat_ugn/platform_specific_information id5}@anchor{1d3}
 @subsection Choosing the Scheduling Policy
 When using a POSIX threads implementation, you have a choice of several
 scheduling policies: @code{SCHED_FIFO}, @code{SCHED_RR} and @code{SCHED_OTHER}.
 @end quotation
 It gets the effective user id, and if it's not 0 (i.e. root), it raises
 Program_Error.
+@geindex Linux
+@geindex GNU/Linux
+@node GNU/Linux Topics,Microsoft Windows Topics,Specifying a Run-Time Library,Platform-Specific Information
+@anchor{gnat_ugn/platform_specific_information id6}@anchor{1d4}@anchor{gnat_ugn/platform_specific_information gnu-linux-topics}@anchor{1d5}
+@section GNU/Linux Topics
+This section describes topics that are specific to GNU/Linux platforms.
+@menu
+* Required Packages on GNU/Linux::
+@end menu
+@node Required Packages on GNU/Linux,,,GNU/Linux Topics
+@anchor{gnat_ugn/platform_specific_information id7}@anchor{1d6}@anchor{gnat_ugn/platform_specific_information required-packages-on-gnu-linux}@anchor{1d7}
+@subsection Required Packages on GNU/Linux
+GNAT requires the C library developer's package to be installed.
+The name of of that package depends on your GNU/Linux distribution:
+@itemize *
+@item
+RedHat, SUSE: @code{glibc-devel};
+@item
+Debian, Ubuntu: @code{libc6-dev} (normally installed by default).
+@end itemize
+If using the 32-bit version of GNAT on a 64-bit version of GNU/Linux,
+you'll need the 32-bit version of the following packages:
+@itemize *
+@item
+RedHat, SUSE: @code{glibc.i686}, @code{glibc-devel.i686}, @code{ncurses-libs.i686}
+@item
+Debian, Ubuntu: @code{libc6:i386}, @code{libc6-dev:i386}, @code{lib32ncursesw5}
+@end itemize
+Other GNU/Linux distributions might be choosing a different name
+for those packages.
 @geindex Windows
-@node Microsoft Windows Topics,Mac OS Topics,Specifying a Run-Time Library,Platform-Specific Information
+@node Microsoft Windows Topics,Mac OS Topics,GNU/Linux Topics,Platform-Specific Information
-@anchor{gnat_ugn/platform_specific_information id6}@anchor{1da}@anchor{gnat_ugn/platform_specific_information microsoft-windows-topics}@anchor{2c}
+@anchor{gnat_ugn/platform_specific_information microsoft-windows-topics}@anchor{2c}@anchor{gnat_ugn/platform_specific_information id8}@anchor{1d8}
 @section Microsoft Windows Topics
 This section describes topics that are specific to the Microsoft Windows
 platforms.
 * Windows Specific Add-Ons::
 @end menu
 @node Using GNAT on Windows,Using a network installation of GNAT,,Microsoft Windows Topics
-@anchor{gnat_ugn/platform_specific_information using-gnat-on-windows}@anchor{1db}@anchor{gnat_ugn/platform_specific_information id7}@anchor{1dc}
+@anchor{gnat_ugn/platform_specific_information using-gnat-on-windows}@anchor{1d9}@anchor{gnat_ugn/platform_specific_information id9}@anchor{1da}
 @subsection Using GNAT on Windows
 One of the strengths of the GNAT technology is that its tool set
 (@code{gcc}, @code{gnatbind}, @code{gnatlink}, @code{gnatmake}, the
 time, as well as some minimal book-keeping information needed to correctly
 uninstall or integrate different GNAT products.
 @end itemize
 @node Using a network installation of GNAT,CONSOLE and WINDOWS subsystems,Using GNAT on Windows,Microsoft Windows Topics
-@anchor{gnat_ugn/platform_specific_information id8}@anchor{1dd}@anchor{gnat_ugn/platform_specific_information using-a-network-installation-of-gnat}@anchor{1de}
+@anchor{gnat_ugn/platform_specific_information id10}@anchor{1db}@anchor{gnat_ugn/platform_specific_information using-a-network-installation-of-gnat}@anchor{1dc}
 @subsection Using a network installation of GNAT
 Make sure the system on which GNAT is installed is accessible from the
 current machine, i.e., the install location is shared over the network.
 Be aware that every compilation using the network installation results in the
 transfer of large amounts of data across the network and will likely cause
 serious performance penalty.
 @node CONSOLE and WINDOWS subsystems,Temporary Files,Using a network installation of GNAT,Microsoft Windows Topics
-@anchor{gnat_ugn/platform_specific_information console-and-windows-subsystems}@anchor{1df}@anchor{gnat_ugn/platform_specific_information id9}@anchor{1e0}
+@anchor{gnat_ugn/platform_specific_information id11}@anchor{1dd}@anchor{gnat_ugn/platform_specific_information console-and-windows-subsystems}@anchor{1de}
 @subsection CONSOLE and WINDOWS subsystems
 @geindex CONSOLE Subsystem
 $ gnatmake winprog -largs -mwindows
 @end example
 @end quotation
 @node Temporary Files,Disabling Command Line Argument Expansion,CONSOLE and WINDOWS subsystems,Microsoft Windows Topics
-@anchor{gnat_ugn/platform_specific_information id10}@anchor{1e1}@anchor{gnat_ugn/platform_specific_information temporary-files}@anchor{1e2}
+@anchor{gnat_ugn/platform_specific_information id12}@anchor{1df}@anchor{gnat_ugn/platform_specific_information temporary-files}@anchor{1e0}
 @subsection Temporary Files
 @geindex Temporary files
 file will be created. This is particularly useful in networked
 environments where you may not have write access to some
 directories.
 @node Disabling Command Line Argument Expansion,Mixed-Language Programming on Windows,Temporary Files,Microsoft Windows Topics
-@anchor{gnat_ugn/platform_specific_information disabling-command-line-argument-expansion}@anchor{1e3}
+@anchor{gnat_ugn/platform_specific_information disabling-command-line-argument-expansion}@anchor{1e1}
 @subsection Disabling Command Line Argument Expansion
 @geindex Command Line Argument Expansion
 @example
 Ada.Command_Line.Argument (1) -> "'*.txt'"
 @end example
 @node Mixed-Language Programming on Windows,Windows Specific Add-Ons,Disabling Command Line Argument Expansion,Microsoft Windows Topics
-@anchor{gnat_ugn/platform_specific_information id11}@anchor{1e4}@anchor{gnat_ugn/platform_specific_information mixed-language-programming-on-windows}@anchor{1e5}
+@anchor{gnat_ugn/platform_specific_information id13}@anchor{1e2}@anchor{gnat_ugn/platform_specific_information mixed-language-programming-on-windows}@anchor{1e3}
 @subsection Mixed-Language Programming on Windows
 Developing pure Ada applications on Windows is no different than on
 other GNAT-supported platforms. However, when developing or porting an
 @item
 Encapsulate your C++ code in a DLL to be linked with your Ada
 application. In this case, use the Microsoft or whatever environment to
 build the DLL and use GNAT to build your executable
-(@ref{1e6,,Using DLLs with GNAT}).
+(@ref{1e4,,Using DLLs with GNAT}).
 @item
 Or you can encapsulate your Ada code in a DLL to be linked with the
 other part of your application. In this case, use GNAT to build the DLL
-(@ref{1e7,,Building DLLs with GNAT Project files}) and use the Microsoft
+(@ref{1e5,,Building DLLs with GNAT Project files}) and use the Microsoft
 or whatever environment to build your executable.
 @end itemize
 In addition to the description about C main in
 @ref{44,,Mixed Language Programming} section, if the C main uses a
 * Setting Heap Size from gnatlink::
 @end menu
 @node Windows Calling Conventions,Introduction to Dynamic Link Libraries DLLs,,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information windows-calling-conventions}@anchor{1e8}@anchor{gnat_ugn/platform_specific_information id12}@anchor{1e9}
+@anchor{gnat_ugn/platform_specific_information windows-calling-conventions}@anchor{1e6}@anchor{gnat_ugn/platform_specific_information id14}@anchor{1e7}
 @subsubsection Windows Calling Conventions
 @geindex Stdcall
 * DLL Calling Convention::
 @end menu
 @node C Calling Convention,Stdcall Calling Convention,,Windows Calling Conventions
-@anchor{gnat_ugn/platform_specific_information c-calling-convention}@anchor{1ea}@anchor{gnat_ugn/platform_specific_information id13}@anchor{1eb}
+@anchor{gnat_ugn/platform_specific_information c-calling-convention}@anchor{1e8}@anchor{gnat_ugn/platform_specific_information id15}@anchor{1e9}
 @subsubsection @code{C} Calling Convention
 This is the default calling convention used when interfacing to C/C++
 routines compiled with either @code{gcc} or Microsoft Visual C++.
 @code{External_Name} with a leading underscore.
 When importing a variable defined in C, you should always use the @code{C}
 calling convention unless the object containing the variable is part of a
 DLL (in which case you should use the @code{Stdcall} calling
-convention, @ref{1ec,,Stdcall Calling Convention}).
+convention, @ref{1ea,,Stdcall Calling Convention}).
 @node Stdcall Calling Convention,Win32 Calling Convention,C Calling Convention,Windows Calling Conventions
-@anchor{gnat_ugn/platform_specific_information stdcall-calling-convention}@anchor{1ec}@anchor{gnat_ugn/platform_specific_information id14}@anchor{1ed}
+@anchor{gnat_ugn/platform_specific_information stdcall-calling-convention}@anchor{1ea}@anchor{gnat_ugn/platform_specific_information id16}@anchor{1eb}
 @subsubsection @code{Stdcall} Calling Convention
 This convention, which was the calling convention used for Pascal
 programs, is used by Microsoft for all the routines in the Win32 API for
 Note that to ease building cross-platform bindings this convention
 will be handled as a @code{C} calling convention on non-Windows platforms.
 @node Win32 Calling Convention,DLL Calling Convention,Stdcall Calling Convention,Windows Calling Conventions
-@anchor{gnat_ugn/platform_specific_information win32-calling-convention}@anchor{1ee}@anchor{gnat_ugn/platform_specific_information id15}@anchor{1ef}
+@anchor{gnat_ugn/platform_specific_information win32-calling-convention}@anchor{1ec}@anchor{gnat_ugn/platform_specific_information id17}@anchor{1ed}
 @subsubsection @code{Win32} Calling Convention
 This convention, which is GNAT-specific is fully equivalent to the
 @code{Stdcall} calling convention described above.
 @node DLL Calling Convention,,Win32 Calling Convention,Windows Calling Conventions
-@anchor{gnat_ugn/platform_specific_information dll-calling-convention}@anchor{1f0}@anchor{gnat_ugn/platform_specific_information id16}@anchor{1f1}
+@anchor{gnat_ugn/platform_specific_information id18}@anchor{1ee}@anchor{gnat_ugn/platform_specific_information dll-calling-convention}@anchor{1ef}
 @subsubsection @code{DLL} Calling Convention
 This convention, which is GNAT-specific is fully equivalent to the
 @code{Stdcall} calling convention described above.
 @node Introduction to Dynamic Link Libraries DLLs,Using DLLs with GNAT,Windows Calling Conventions,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information introduction-to-dynamic-link-libraries-dlls}@anchor{1f2}@anchor{gnat_ugn/platform_specific_information id17}@anchor{1f3}
+@anchor{gnat_ugn/platform_specific_information id19}@anchor{1f0}@anchor{gnat_ugn/platform_specific_information introduction-to-dynamic-link-libraries-dlls}@anchor{1f1}
 @subsubsection Introduction to Dynamic Link Libraries (DLLs)
 @geindex DLL
 As a side note, an interesting difference between Microsoft DLLs and
 Unix shared libraries, is the fact that on most Unix systems all public
 routines are exported by default in a Unix shared library, while under
 Windows it is possible (but not required) to list exported routines in
-a definition file (see @ref{1f4,,The Definition File}).
+a definition file (see @ref{1f2,,The Definition File}).
 @node Using DLLs with GNAT,Building DLLs with GNAT Project files,Introduction to Dynamic Link Libraries DLLs,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information id18}@anchor{1f5}@anchor{gnat_ugn/platform_specific_information using-dlls-with-gnat}@anchor{1e6}
+@anchor{gnat_ugn/platform_specific_information id20}@anchor{1f3}@anchor{gnat_ugn/platform_specific_information using-dlls-with-gnat}@anchor{1e4}
 @subsubsection Using DLLs with GNAT
 To use the services of a DLL, say @code{API.dll}, in your Ada application
 you must have:
 * Creating an Import Library::
 @end menu
 @node Creating an Ada Spec for the DLL Services,Creating an Import Library,,Using DLLs with GNAT
-@anchor{gnat_ugn/platform_specific_information creating-an-ada-spec-for-the-dll-services}@anchor{1f6}@anchor{gnat_ugn/platform_specific_information id19}@anchor{1f7}
+@anchor{gnat_ugn/platform_specific_information id21}@anchor{1f4}@anchor{gnat_ugn/platform_specific_information creating-an-ada-spec-for-the-dll-services}@anchor{1f5}
 @subsubsection Creating an Ada Spec for the DLL Services
 A DLL typically comes with a C/C++ header file which provides the
 definitions of the routines and variables exported by the DLL. The Ada
 end API;
 @end example
 @end quotation
 @node Creating an Import Library,,Creating an Ada Spec for the DLL Services,Using DLLs with GNAT
-@anchor{gnat_ugn/platform_specific_information id20}@anchor{1f8}@anchor{gnat_ugn/platform_specific_information creating-an-import-library}@anchor{1f9}
+@anchor{gnat_ugn/platform_specific_information id22}@anchor{1f6}@anchor{gnat_ugn/platform_specific_information creating-an-import-library}@anchor{1f7}
 @subsubsection Creating an Import Library
 @geindex Import library
 section if @code{API.dll} or @code{libAPI.dll} is built with GNU tools
 as in this case it is possible to link directly against the
 DLL. Otherwise read on.
 @geindex Definition file
-@anchor{gnat_ugn/platform_specific_information the-definition-file}@anchor{1f4}
+@anchor{gnat_ugn/platform_specific_information the-definition-file}@anchor{1f2}
 @subsubheading The Definition File
 As previously mentioned, and unlike Unix systems, the list of symbols
 that are exported from a DLL must be provided explicitly in Windows.
 get
 @end example
 @end table
 Note that you must specify the correct suffix (@code{@@@emph{nn}})
-(see @ref{1e8,,Windows Calling Conventions}) for a Stdcall
+(see @ref{1e6,,Windows Calling Conventions}) for a Stdcall
 calling convention function in the exported symbols list.
 There can actually be other sections in a definition file, but these
 sections are not relevant to the discussion at hand.
-@anchor{gnat_ugn/platform_specific_information create-def-file-automatically}@anchor{1fa}
+@anchor{gnat_ugn/platform_specific_information create-def-file-automatically}@anchor{1f8}
 @subsubheading Creating a Definition File Automatically
 You can automatically create the definition file @code{API.def}
-(see @ref{1f4,,The Definition File}) from a DLL.
+(see @ref{1f2,,The Definition File}) from a DLL.
 For that use the @code{dlltool} program as follows:
 @quotation
 @example
 $ dlltool API.dll -z API.def --export-all-symbols
 @end example
 Note that if some routines in the DLL have the @code{Stdcall} convention
-(@ref{1e8,,Windows Calling Conventions}) with stripped @code{@@@emph{nn}}
+(@ref{1e6,,Windows Calling Conventions}) with stripped @code{@@@emph{nn}}
 suffix then you'll have to edit @code{api.def} to add it, and specify
 @code{-k} to @code{gnatdll} when creating the import library.
 Here are some hints to find the right @code{@@@emph{nn}} suffix.
 If you have a message about a missing symbol at link time the compiler
 tells you what symbol is expected. You just have to go back to the
 definition file and add the right suffix.
 @end itemize
 @end quotation
-@anchor{gnat_ugn/platform_specific_information gnat-style-import-library}@anchor{1fb}
+@anchor{gnat_ugn/platform_specific_information gnat-style-import-library}@anchor{1f9}
 @subsubheading GNAT-Style Import Library
 To create a static import library from @code{API.dll} with the GNAT tools
 you should create the .def file, then use @code{gnatdll} tool
-(see @ref{1fc,,Using gnatdll}) as follows:
+(see @ref{1fa,,Using gnatdll}) as follows:
 @quotation
 @example
 $ gnatdll -e API.def -d API.dll
 computed from the name of the definition file as follows: if the
 definition file name is @code{xyz.def}, the import library name will
 be @code{libxyz.a}. Note that in the previous example option
 @code{-e} could have been removed because the name of the definition
 file (before the @code{.def} suffix) is the same as the name of the
-DLL (@ref{1fc,,Using gnatdll} for more information about @code{gnatdll}).
+DLL (@ref{1fa,,Using gnatdll} for more information about @code{gnatdll}).
 @end quotation
-@anchor{gnat_ugn/platform_specific_information msvs-style-import-library}@anchor{1fd}
+@anchor{gnat_ugn/platform_specific_information msvs-style-import-library}@anchor{1fb}
 @subsubheading Microsoft-Style Import Library
 A Microsoft import library is needed only if you plan to make an
 Ada DLL available to applications developed with Microsoft
-tools (@ref{1e5,,Mixed-Language Programming on Windows}).
+tools (@ref{1e3,,Mixed-Language Programming on Windows}).
 To create a Microsoft-style import library for @code{API.dll} you
 should create the .def file, then build the actual import library using
 Microsoft's @code{lib} utility:
 See the Microsoft documentation for further details about the usage of
 @code{lib}.
 @end quotation
 @node Building DLLs with GNAT Project files,Building DLLs with GNAT,Using DLLs with GNAT,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information id21}@anchor{1fe}@anchor{gnat_ugn/platform_specific_information building-dlls-with-gnat-project-files}@anchor{1e7}
+@anchor{gnat_ugn/platform_specific_information id23}@anchor{1fc}@anchor{gnat_ugn/platform_specific_information building-dlls-with-gnat-project-files}@anchor{1e5}
 @subsubsection Building DLLs with GNAT Project files
 @geindex DLLs
 @geindex building
 Due to a system limitation, it is not possible under Windows to create threads
 when inside the @code{DllMain} routine which is used for auto-initialization
 of shared libraries, so it is not possible to have library level tasks in SALs.
 @node Building DLLs with GNAT,Building DLLs with gnatdll,Building DLLs with GNAT Project files,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information building-dlls-with-gnat}@anchor{1ff}@anchor{gnat_ugn/platform_specific_information id22}@anchor{200}
+@anchor{gnat_ugn/platform_specific_information building-dlls-with-gnat}@anchor{1fd}@anchor{gnat_ugn/platform_specific_information id24}@anchor{1fe}
 @subsubsection Building DLLs with GNAT
 @geindex DLLs
 @geindex building
 @end example
 It is important to note that in this case all symbols found in the
 object files are automatically exported. It is possible to restrict
 the set of symbols to export by passing to @code{gcc} a definition
-file (see @ref{1f4,,The Definition File}).
+file (see @ref{1f2,,The Definition File}).
 For example:
 @example
 $ gcc -shared -shared-libgcc -o api.dll api.def obj1.o obj2.o ...
 @end example
 $ gnatmake main -Iapilib -bargs -shared -largs -Lapilib -lAPI
 @end example
 @end quotation
 @node Building DLLs with gnatdll,Ada DLLs and Finalization,Building DLLs with GNAT,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information building-dlls-with-gnatdll}@anchor{201}@anchor{gnat_ugn/platform_specific_information id23}@anchor{202}
+@anchor{gnat_ugn/platform_specific_information building-dlls-with-gnatdll}@anchor{1ff}@anchor{gnat_ugn/platform_specific_information id25}@anchor{200}
 @subsubsection Building DLLs with gnatdll
 @geindex DLLs
 @geindex building
 Note that it is preferred to use GNAT Project files
-(@ref{1e7,,Building DLLs with GNAT Project files}) or the built-in GNAT
+(@ref{1e5,,Building DLLs with GNAT Project files}) or the built-in GNAT
-DLL support (@ref{1ff,,Building DLLs with GNAT}) or to build DLLs.
+DLL support (@ref{1fd,,Building DLLs with GNAT}) or to build DLLs.
 This section explains how to build DLLs containing Ada code using
 @code{gnatdll}. These DLLs will be referred to as Ada DLLs in the
 remainder of this section.
 @item
 You need to mark each Ada entity exported by the DLL with a @code{C} or
 @code{Stdcall} calling convention to avoid any Ada name mangling for the
 entities exported by the DLL
-(see @ref{203,,Exporting Ada Entities}). You can
+(see @ref{201,,Exporting Ada Entities}). You can
 skip this step if you plan to use the Ada DLL only from Ada applications.
 @item
 Your Ada code must export an initialization routine which calls the routine
 @code{adainit} generated by @code{gnatbind} to perform the elaboration of
-the Ada code in the DLL (@ref{204,,Ada DLLs and Elaboration}). The initialization
+the Ada code in the DLL (@ref{202,,Ada DLLs and Elaboration}). The initialization
 routine exported by the Ada DLL must be invoked by the clients of the DLL
 to initialize the DLL.
 @item
 When useful, the DLL should also export a finalization routine which calls
 routine @code{adafinal} generated by @code{gnatbind} to perform the
-finalization of the Ada code in the DLL (@ref{205,,Ada DLLs and Finalization}).
+finalization of the Ada code in the DLL (@ref{203,,Ada DLLs and Finalization}).
 The finalization routine exported by the Ada DLL must be invoked by the
 clients of the DLL when the DLL services are no further needed.
 @item
 You must provide a spec for the services exported by the Ada DLL in each
 of the programming languages to which you plan to make the DLL available.
 @item
 You must provide a definition file listing the exported entities
-(@ref{1f4,,The Definition File}).
+(@ref{1f2,,The Definition File}).
 @item
 Finally you must use @code{gnatdll} to produce the DLL and the import
-library (@ref{1fc,,Using gnatdll}).
+library (@ref{1fa,,Using gnatdll}).
 @end itemize
 Note that a relocatable DLL stripped using the @code{strip}
 binutils tool will not be relocatable anymore. To build a DLL without
 debug information pass @code{-largs -s} to @code{gnatdll}. This
 * Ada DLLs and Elaboration::
 @end menu
 @node Limitations When Using Ada DLLs from Ada,Exporting Ada Entities,,Building DLLs with gnatdll
-@anchor{gnat_ugn/platform_specific_information limitations-when-using-ada-dlls-from-ada}@anchor{206}
+@anchor{gnat_ugn/platform_specific_information limitations-when-using-ada-dlls-from-ada}@anchor{204}
 @subsubsection Limitations When Using Ada DLLs from Ada
 When using Ada DLLs from Ada applications there is a limitation users
 should be aware of. Because on Windows the GNAT run-time is not in a DLL of
 It is completely safe to exchange plain elementary, array or record types,
 Windows object handles, etc.
 @node Exporting Ada Entities,Ada DLLs and Elaboration,Limitations When Using Ada DLLs from Ada,Building DLLs with gnatdll
-@anchor{gnat_ugn/platform_specific_information exporting-ada-entities}@anchor{203}@anchor{gnat_ugn/platform_specific_information id24}@anchor{207}
+@anchor{gnat_ugn/platform_specific_information exporting-ada-entities}@anchor{201}@anchor{gnat_ugn/platform_specific_information id26}@anchor{205}
 @subsubsection Exporting Ada Entities
 @geindex Export table
 @end quotation
 Note that if you do not export the Ada entities with a @code{C} or
 @code{Stdcall} convention you will have to provide the mangled Ada names
 in the definition file of the Ada DLL
-(@ref{208,,Creating the Definition File}).
+(@ref{206,,Creating the Definition File}).
 @node Ada DLLs and Elaboration,,Exporting Ada Entities,Building DLLs with gnatdll
-@anchor{gnat_ugn/platform_specific_information ada-dlls-and-elaboration}@anchor{204}@anchor{gnat_ugn/platform_specific_information id25}@anchor{209}
+@anchor{gnat_ugn/platform_specific_information ada-dlls-and-elaboration}@anchor{202}@anchor{gnat_ugn/platform_specific_information id27}@anchor{207}
 @subsubsection Ada DLLs and Elaboration
 @geindex DLLs and elaboration
 before using any of the DLL services. This elaboration routine must call
 the Ada elaboration routine @code{adainit} generated by the GNAT binder
 (@ref{b4,,Binding with Non-Ada Main Programs}). See the body of
 @code{Initialize_Api} for an example. Note that the GNAT binder is
 automatically invoked during the DLL build process by the @code{gnatdll}
-tool (@ref{1fc,,Using gnatdll}).
+tool (@ref{1fa,,Using gnatdll}).
 When a DLL is loaded, Windows systematically invokes a routine called
 @code{DllMain}. It would therefore be possible to call @code{adainit}
 directly from @code{DllMain} without having to provide an explicit
 initialization routine. Unfortunately, it is not possible to call
 the system (that is, only a single thread can execute 'through' it at a
 time), which means that the GNAT run-time will deadlock waiting for the
 newly created task to complete its initialization.
 @node Ada DLLs and Finalization,Creating a Spec for Ada DLLs,Building DLLs with gnatdll,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information ada-dlls-and-finalization}@anchor{205}@anchor{gnat_ugn/platform_specific_information id26}@anchor{20a}
+@anchor{gnat_ugn/platform_specific_information id28}@anchor{208}@anchor{gnat_ugn/platform_specific_information ada-dlls-and-finalization}@anchor{203}
 @subsubsection Ada DLLs and Finalization
 @geindex DLLs and finalization
 routine @code{adafinal} generated by the GNAT binder
 (@ref{b4,,Binding with Non-Ada Main Programs}).
 See the body of @code{Finalize_Api} for an
 example. As already pointed out the GNAT binder is automatically invoked
 during the DLL build process by the @code{gnatdll} tool
-(@ref{1fc,,Using gnatdll}).
+(@ref{1fa,,Using gnatdll}).
 @node Creating a Spec for Ada DLLs,GNAT and Windows Resources,Ada DLLs and Finalization,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information id27}@anchor{20b}@anchor{gnat_ugn/platform_specific_information creating-a-spec-for-ada-dlls}@anchor{20c}
+@anchor{gnat_ugn/platform_specific_information id29}@anchor{209}@anchor{gnat_ugn/platform_specific_information creating-a-spec-for-ada-dlls}@anchor{20a}
 @subsubsection Creating a Spec for Ada DLLs
 To use the services exported by the Ada DLL from another programming
 language (e.g., C), you have to translate the specs of the exported Ada
 * Using gnatdll::
 @end menu
 @node Creating the Definition File,Using gnatdll,,Creating a Spec for Ada DLLs
-@anchor{gnat_ugn/platform_specific_information id28}@anchor{20d}@anchor{gnat_ugn/platform_specific_information creating-the-definition-file}@anchor{208}
+@anchor{gnat_ugn/platform_specific_information creating-the-definition-file}@anchor{206}@anchor{gnat_ugn/platform_specific_information id30}@anchor{20b}
 @subsubsection Creating the Definition File
 The definition file is the last file needed to build the DLL. It lists
 the exported symbols. As an example, the definition file for a DLL
 api__initialize_api
 @end example
 @end quotation
 @node Using gnatdll,,Creating the Definition File,Creating a Spec for Ada DLLs
-@anchor{gnat_ugn/platform_specific_information id29}@anchor{20e}@anchor{gnat_ugn/platform_specific_information using-gnatdll}@anchor{1fc}
+@anchor{gnat_ugn/platform_specific_information using-gnatdll}@anchor{1fa}@anchor{gnat_ugn/platform_specific_information id31}@anchor{20c}
 @subsubsection Using @code{gnatdll}
 @geindex gnatdll
 asks @code{gnatlink} to generate the routines @code{DllMain} and
 @code{DllMainCRTStartup} that are called by the Windows loader when the DLL
 is loaded into memory.
 @item
-@code{gnatdll} uses @code{dlltool} (see @ref{20f,,Using dlltool}) to build the
+@code{gnatdll} uses @code{dlltool} (see @ref{20d,,Using dlltool}) to build the
 export table (@code{api.exp}). The export table contains the relocation
 information in a form which can be used during the final link to ensure
 that the Windows loader is able to place the DLL anywhere in memory.
 @example
 @example
 $ gnatbind -n api
 $ gnatlink api api.exp -o api.dll -mdll
 @end example
 @end itemize
-@anchor{gnat_ugn/platform_specific_information using-dlltool}@anchor{20f}
+@anchor{gnat_ugn/platform_specific_information using-dlltool}@anchor{20d}
 @subsubheading Using @code{dlltool}
 @code{dlltool} is the low-level tool used by @code{gnatdll} to build
 DLLs and static import libraries. This section summarizes the most
 @table @asis
 @item @code{-k}
 Kill @code{@@@emph{nn}} from exported names
-(@ref{1e8,,Windows Calling Conventions}
+(@ref{1e6,,Windows Calling Conventions}
 for a discussion about @code{Stdcall}-style symbols.
 @end table
 @geindex --help (dlltool)
 Use @code{assembler-name} as the assembler. The default is @code{as}.
 @end table
 @node GNAT and Windows Resources,Using GNAT DLLs from Microsoft Visual Studio Applications,Creating a Spec for Ada DLLs,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information gnat-and-windows-resources}@anchor{210}@anchor{gnat_ugn/platform_specific_information id30}@anchor{211}
+@anchor{gnat_ugn/platform_specific_information gnat-and-windows-resources}@anchor{20e}@anchor{gnat_ugn/platform_specific_information id32}@anchor{20f}
 @subsubsection GNAT and Windows Resources
 @geindex Resources
 @geindex windows
 * Using Resources::
 @end menu
 @node Building Resources,Compiling Resources,,GNAT and Windows Resources
-@anchor{gnat_ugn/platform_specific_information building-resources}@anchor{212}@anchor{gnat_ugn/platform_specific_information id31}@anchor{213}
+@anchor{gnat_ugn/platform_specific_information building-resources}@anchor{210}@anchor{gnat_ugn/platform_specific_information id33}@anchor{211}
 @subsubsection Building Resources
 @geindex Resources
 @geindex building
 It is not our objective to explain how to write a resource file. A
 complete description of the resource script language can be found in the
 Microsoft documentation.
 @node Compiling Resources,Using Resources,Building Resources,GNAT and Windows Resources
-@anchor{gnat_ugn/platform_specific_information compiling-resources}@anchor{214}@anchor{gnat_ugn/platform_specific_information id32}@anchor{215}
+@anchor{gnat_ugn/platform_specific_information compiling-resources}@anchor{212}@anchor{gnat_ugn/platform_specific_information id34}@anchor{213}
 @subsubsection Compiling Resources
 @geindex rc
 $ windres -i myres.res -o myres.o
 @end example
 @end quotation
 @node Using Resources,,Compiling Resources,GNAT and Windows Resources
-@anchor{gnat_ugn/platform_specific_information using-resources}@anchor{216}@anchor{gnat_ugn/platform_specific_information id33}@anchor{217}
+@anchor{gnat_ugn/platform_specific_information using-resources}@anchor{214}@anchor{gnat_ugn/platform_specific_information id35}@anchor{215}
 @subsubsection Using Resources
 @geindex Resources
 @geindex using
 $ gnatmake myprog -largs myres.o
 @end example
 @end quotation
 @node Using GNAT DLLs from Microsoft Visual Studio Applications,Debugging a DLL,GNAT and Windows Resources,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information using-gnat-dll-from-msvs}@anchor{218}@anchor{gnat_ugn/platform_specific_information using-gnat-dlls-from-microsoft-visual-studio-applications}@anchor{219}
+@anchor{gnat_ugn/platform_specific_information using-gnat-dll-from-msvs}@anchor{216}@anchor{gnat_ugn/platform_specific_information using-gnat-dlls-from-microsoft-visual-studio-applications}@anchor{217}
 @subsubsection Using GNAT DLLs from Microsoft Visual Studio Applications
 @geindex Microsoft Visual Studio
 @geindex use with GNAT DLLs
 @enumerate 2
 @item
 Produce a .def file for the symbols you need to interface with, either by
 hand or automatically with possibly some manual adjustments
-(see @ref{1fa,,Creating Definition File Automatically}):
+(see @ref{1f8,,Creating Definition File Automatically}):
 @end enumerate
 @quotation
 @example
 @item
 Make sure that MSVS command-line tools are accessible on the path.
 @item
-Create the Microsoft-style import library (see @ref{1fd,,MSVS-Style Import Library}):
+Create the Microsoft-style import library (see @ref{1fb,,MSVS-Style Import Library}):
 @end enumerate
 @quotation
 @example
 Before running the executable, make sure you have set the PATH to the DLL,
 or copy the DLL into into the directory containing the .exe.
 @end enumerate
 @node Debugging a DLL,Setting Stack Size from gnatlink,Using GNAT DLLs from Microsoft Visual Studio Applications,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information id34}@anchor{21a}@anchor{gnat_ugn/platform_specific_information debugging-a-dll}@anchor{21b}
+@anchor{gnat_ugn/platform_specific_information id36}@anchor{218}@anchor{gnat_ugn/platform_specific_information debugging-a-dll}@anchor{219}
 @subsubsection Debugging a DLL
 @geindex DLL debugging
 * Program Built with Foreign Tools and DLL Built with GCC/GNAT::
 @end menu
 @node Program and DLL Both Built with GCC/GNAT,Program Built with Foreign Tools and DLL Built with GCC/GNAT,,Debugging a DLL
-@anchor{gnat_ugn/platform_specific_information program-and-dll-both-built-with-gcc-gnat}@anchor{21c}@anchor{gnat_ugn/platform_specific_information id35}@anchor{21d}
+@anchor{gnat_ugn/platform_specific_information id37}@anchor{21a}@anchor{gnat_ugn/platform_specific_information program-and-dll-both-built-with-gcc-gnat}@anchor{21b}
 @subsubsection Program and DLL Both Built with GCC/GNAT
 This is the simplest case. Both the DLL and the program have @code{GDB}
 compatible debugging information. It is then possible to break anywhere in
 the process. Let's suppose here that the main procedure is named
 @code{ada_main} and that in the DLL there is an entry point named
 @code{ada_dll}.
-The DLL (@ref{1f2,,Introduction to Dynamic Link Libraries (DLLs)}) and
+The DLL (@ref{1f1,,Introduction to Dynamic Link Libraries (DLLs)}) and
 program must have been built with the debugging information (see GNAT -g
 switch). Here are the step-by-step instructions for debugging it:
 @itemize *
 At this stage a breakpoint is set inside the DLL. From there on
 you can use the standard approach to debug the whole program
 (@ref{24,,Running and Debugging Ada Programs}).
 @node Program Built with Foreign Tools and DLL Built with GCC/GNAT,,Program and DLL Both Built with GCC/GNAT,Debugging a DLL
-@anchor{gnat_ugn/platform_specific_information id36}@anchor{21e}@anchor{gnat_ugn/platform_specific_information program-built-with-foreign-tools-and-dll-built-with-gcc-gnat}@anchor{21f}
+@anchor{gnat_ugn/platform_specific_information program-built-with-foreign-tools-and-dll-built-with-gcc-gnat}@anchor{21c}@anchor{gnat_ugn/platform_specific_information id38}@anchor{21d}
 @subsubsection Program Built with Foreign Tools and DLL Built with GCC/GNAT
 In this case things are slightly more complex because it is not possible to
 start the main program and then break at the beginning to load the DLL and the
 First suppose that the main procedure is named @code{main} (this is for
 example some C code built with Microsoft Visual C) and that there is a
 DLL named @code{test.dll} containing an Ada entry point named
 @code{ada_dll}.
-The DLL (see @ref{1f2,,Introduction to Dynamic Link Libraries (DLLs)}) must have
+The DLL (see @ref{1f1,,Introduction to Dynamic Link Libraries (DLLs)}) must have
 been built with debugging information (see the GNAT @code{-g} option).
 @subsubheading Debugging the DLL Directly
 the breakpoint we have set. From there you can use the standard
 approach to debug a program as described in
 @ref{24,,Running and Debugging Ada Programs}.
 @node Setting Stack Size from gnatlink,Setting Heap Size from gnatlink,Debugging a DLL,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information id37}@anchor{220}@anchor{gnat_ugn/platform_specific_information setting-stack-size-from-gnatlink}@anchor{136}
+@anchor{gnat_ugn/platform_specific_information setting-stack-size-from-gnatlink}@anchor{136}@anchor{gnat_ugn/platform_specific_information id39}@anchor{21e}
 @subsubsection Setting Stack Size from @code{gnatlink}
 It is possible to specify the program stack size at link time. On modern
 versions of Windows, starting with XP, this is mostly useful to set the size of
 @code{-Wl} option it is not possible to set the stack commit size
 because the comma is a separator for this option.
 @end itemize
 @node Setting Heap Size from gnatlink,,Setting Stack Size from gnatlink,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information setting-heap-size-from-gnatlink}@anchor{137}@anchor{gnat_ugn/platform_specific_information id38}@anchor{221}
+@anchor{gnat_ugn/platform_specific_information setting-heap-size-from-gnatlink}@anchor{137}@anchor{gnat_ugn/platform_specific_information id40}@anchor{21f}
 @subsubsection Setting Heap Size from @code{gnatlink}
 Under Windows systems, it is possible to specify the program heap size from
 @code{gnatlink} using either of the following:
 @code{-Wl} option it is not possible to set the heap commit size
 because the comma is a separator for this option.
 @end itemize
 @node Windows Specific Add-Ons,,Mixed-Language Programming on Windows,Microsoft Windows Topics
-@anchor{gnat_ugn/platform_specific_information windows-specific-add-ons}@anchor{222}@anchor{gnat_ugn/platform_specific_information win32-specific-addons}@anchor{223}
+@anchor{gnat_ugn/platform_specific_information windows-specific-add-ons}@anchor{220}@anchor{gnat_ugn/platform_specific_information win32-specific-addons}@anchor{221}
 @subsection Windows Specific Add-Ons
 This section describes the Windows specific add-ons.
 * wPOSIX::
 @end menu
 @node Win32Ada,wPOSIX,,Windows Specific Add-Ons
-@anchor{gnat_ugn/platform_specific_information win32ada}@anchor{224}@anchor{gnat_ugn/platform_specific_information id39}@anchor{225}
+@anchor{gnat_ugn/platform_specific_information win32ada}@anchor{222}@anchor{gnat_ugn/platform_specific_information id41}@anchor{223}
 @subsubsection Win32Ada
 Win32Ada is a binding for the Microsoft Win32 API. This binding can be
 easily installed from the provided installer. To use the Win32Ada
 gprbuild p.gpr
 @end example
 @end quotation
 @node wPOSIX,,Win32Ada,Windows Specific Add-Ons
-@anchor{gnat_ugn/platform_specific_information wposix}@anchor{226}@anchor{gnat_ugn/platform_specific_information id40}@anchor{227}
+@anchor{gnat_ugn/platform_specific_information id42}@anchor{224}@anchor{gnat_ugn/platform_specific_information wposix}@anchor{225}
 @subsubsection wPOSIX
 wPOSIX is a minimal POSIX binding whose goal is to help with building
 cross-platforms applications. This binding is not complete though, as
 gprbuild p.gpr
 @end example
 @end quotation
 @node Mac OS Topics,,Microsoft Windows Topics,Platform-Specific Information
-@anchor{gnat_ugn/platform_specific_information mac-os-topics}@anchor{2d}@anchor{gnat_ugn/platform_specific_information id41}@anchor{228}
+@anchor{gnat_ugn/platform_specific_information mac-os-topics}@anchor{2d}@anchor{gnat_ugn/platform_specific_information id43}@anchor{226}
 @section Mac OS Topics
 @geindex OS X
 * Codesigning the Debugger::
 @end menu
 @node Codesigning the Debugger,,,Mac OS Topics
-@anchor{gnat_ugn/platform_specific_information codesigning-the-debugger}@anchor{229}
+@anchor{gnat_ugn/platform_specific_information codesigning-the-debugger}@anchor{227}
 @subsection Codesigning the Debugger
 The Darwin Kernel requires the debugger to have special permissions
 before it is allowed to control other processes. These permissions
 name chosen above, and <gnat_install_prefix> should be replaced by
 the location where you installed GNAT.  Also, be sure that users are
 in the Unix group @code{_developer}.
 @node Example of Binder Output File,Elaboration Order Handling in GNAT,Platform-Specific Information,Top
-@anchor{gnat_ugn/example_of_binder_output example-of-binder-output-file}@anchor{e}@anchor{gnat_ugn/example_of_binder_output doc}@anchor{22a}@anchor{gnat_ugn/example_of_binder_output id1}@anchor{22b}
+@anchor{gnat_ugn/example_of_binder_output example-of-binder-output-file}@anchor{e}@anchor{gnat_ugn/example_of_binder_output doc}@anchor{228}@anchor{gnat_ugn/example_of_binder_output id1}@anchor{229}
 @chapter Example of Binder Output File
 @geindex Binder output (example)
 elaboration code in your own application).
 @c -- Example: A |withing| unit has a |with| clause, it |withs| a |withed| unit
 @node Elaboration Order Handling in GNAT,Inline Assembler,Example of Binder Output File,Top
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-order-handling-in-gnat}@anchor{f}@anchor{gnat_ugn/elaboration_order_handling_in_gnat doc}@anchor{22c}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id1}@anchor{22d}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-order-handling-in-gnat}@anchor{f}@anchor{gnat_ugn/elaboration_order_handling_in_gnat doc}@anchor{22a}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id1}@anchor{22b}
 @chapter Elaboration Order Handling in GNAT
 @geindex Order of elaboration
 * Controlling the Elaboration Order in GNAT::
 * Common Elaboration-model Traits::
 * Dynamic Elaboration Model in GNAT::
 * Static Elaboration Model in GNAT::
 * SPARK Elaboration Model in GNAT::
+* Legacy Elaboration Model in GNAT::
 * Mixing Elaboration Models::
 * Elaboration Circularities::
 * Resolving Elaboration Circularities::
 * Resolving Task Issues::
 * Elaboration-related Compiler Switches::
 * Inspecting the Chosen Elaboration Order::
 @end menu
 @node Elaboration Code,Elaboration Order,,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-code}@anchor{22e}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id2}@anchor{22f}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-code}@anchor{22c}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id2}@anchor{22d}
 @section Elaboration Code
 Ada defines the term @emph{execution} as the process by which a construct achieves
 its run-time effect. This process is also referred to as @strong{elaboration} for
 result, the call to @code{Proc} will be executed when the body of @code{Client} is
 elaborated.
 @end itemize
 @node Elaboration Order,Checking the Elaboration Order,Elaboration Code,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-order}@anchor{230}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id3}@anchor{231}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-order}@anchor{22e}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id3}@anchor{22f}
 @section Elaboration Order
 The sequence by which the elaboration code of all units within a partition is
 executed is referred to as @strong{elaboration order}.
 unit categorization, and elaboration control pragmas. Ideally an order which
 avoids ABE problems should be chosen, however a compiler may not always find
 such an order due to complications with respect to control and data flow.
 @node Checking the Elaboration Order,Controlling the Elaboration Order in Ada,Elaboration Order,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat id4}@anchor{232}@anchor{gnat_ugn/elaboration_order_handling_in_gnat checking-the-elaboration-order}@anchor{233}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat id4}@anchor{230}@anchor{gnat_ugn/elaboration_order_handling_in_gnat checking-the-elaboration-order}@anchor{231}
 @section Checking the Elaboration Order
 To avoid placing the entire elaboration order burden on the programmer, Ada
 provides three lines of defense:
 Pragmas are provided for the programmer to specify the desired elaboration
 order.
 @end itemize
 @node Controlling the Elaboration Order in Ada,Controlling the Elaboration Order in GNAT,Checking the Elaboration Order,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat controlling-the-elaboration-order-in-ada}@anchor{234}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id5}@anchor{235}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat controlling-the-elaboration-order-in-ada}@anchor{232}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id5}@anchor{233}
 @section Controlling the Elaboration Order in Ada
 Ada provides several idioms and pragmas to aid the programmer with specifying
 the desired elaboration order and avoiding ABE problems altogether.
 Note that one additional advantage of using @code{Elaborate} and @code{Elaborate_All}
 is that the program continues to stay in the last state (one or more correct
 orders exist) even if maintenance changes the bodies of targets.
 @node Controlling the Elaboration Order in GNAT,Common Elaboration-model Traits,Controlling the Elaboration Order in Ada,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat id6}@anchor{236}@anchor{gnat_ugn/elaboration_order_handling_in_gnat controlling-the-elaboration-order-in-gnat}@anchor{237}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat id6}@anchor{234}@anchor{gnat_ugn/elaboration_order_handling_in_gnat controlling-the-elaboration-order-in-gnat}@anchor{235}
 @section Controlling the Elaboration Order in GNAT
 In addition to Ada semantics and rules synthesized from them, GNAT offers
 three elaboration models to aid the programmer with specifying the correct
 The SPARK model is in effect only when a scenario and a target reside in a
 region subject to SPARK_Mode On, otherwise the dynamic or static model is in
 effect.
 @end itemize
+@geindex Legacy elaboration model
+@itemize *
+@item
+@emph{Legacy elaboration model}
+In addition to the three elaboration models outlined above, GNAT provides the
+elaboration model of pre-18.x versions referred to as @cite{legacy elaboration model}. The legacy elaboration model is enabled with compiler switch
+@code{-gnatH}.
+@end itemize
+@geindex Relaxed elaboration mode
+The dynamic, legacy, and static models can be relaxed using compiler switch
+@code{-gnatJ}, making them more permissive. Note that in this mode, GNAT
+may not diagnose certain elaboration issues or install run-time checks.
 @node Common Elaboration-model Traits,Dynamic Elaboration Model in GNAT,Controlling the Elaboration Order in GNAT,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat common-elaboration-model-traits}@anchor{238}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id7}@anchor{239}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat common-elaboration-model-traits}@anchor{236}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id7}@anchor{237}
 @section Common Elaboration-model Traits
 All three GNAT models are able to detect elaboration problems related to
 dispatching calls and a particular kind of ABE referred to as @emph{guaranteed ABE}.
 @end itemize
 Note that GNAT emits warnings rather than hard errors whenever it encounters an
 elaboration problem. This is because the elaboration model in effect may be too
 conservative, or a particular scenario may not be elaborated or executed due to
-data and control flow. The warnings can be suppressed with compiler switch
+data and control flow. The warnings can be suppressed selectively with @code{pragma
-@code{-gnatws}.
+Warnigns (Off)} or globally with compiler switch @code{-gnatwL}.
 @node Dynamic Elaboration Model in GNAT,Static Elaboration Model in GNAT,Common Elaboration-model Traits,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat dynamic-elaboration-model-in-gnat}@anchor{23a}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id8}@anchor{23b}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat dynamic-elaboration-model-in-gnat}@anchor{238}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id8}@anchor{239}
 @section Dynamic Elaboration Model in GNAT
 The dynamic model assumes that all code within all units in a partition is
 elaboration code. As a result, run-time checks are installed for each scenario
 4. end Dynamic_Model;
 @end example
 @node Static Elaboration Model in GNAT,SPARK Elaboration Model in GNAT,Dynamic Elaboration Model in GNAT,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat static-elaboration-model-in-gnat}@anchor{23c}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id9}@anchor{23d}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat static-elaboration-model-in-gnat}@anchor{23a}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id9}@anchor{23b}
 @section Static Elaboration Model in GNAT
 In contrast to the dynamic model, the static model is more precise in its
 analysis of elaboration code. The model makes a clear distinction between
 @item
 @emph{Internal targets}
 The static model performs extensive diagnostics on scenarios which elaborate
 or execute internal targets. The warnings resulting from these diagnostics
-are enabled by default, but can be suppressed using compiler switch
+are enabled by default, but can be suppressed selectively with @code{pragma
-@code{-gnatws}.
+Warnings (Off)} or globally with compiler switch @code{-gnatwL}.
 @example
 1. package body Static_Model is
 2.    generic
 3.       with function Func return Integer;
 @code{Server}. The pragma guarantees that both the spec and body of @code{Server},
 along with any additional dependencies that @code{Server} may require, are
 elaborated prior to the body of @code{Static_Model}.
 @end itemize
-@node SPARK Elaboration Model in GNAT,Mixing Elaboration Models,Static Elaboration Model in GNAT,Elaboration Order Handling in GNAT
+@node SPARK Elaboration Model in GNAT,Legacy Elaboration Model in GNAT,Static Elaboration Model in GNAT,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat id10}@anchor{23e}@anchor{gnat_ugn/elaboration_order_handling_in_gnat spark-elaboration-model-in-gnat}@anchor{23f}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat id10}@anchor{23c}@anchor{gnat_ugn/elaboration_order_handling_in_gnat spark-elaboration-model-in-gnat}@anchor{23d}
 @section SPARK Elaboration Model in GNAT
 The SPARK model is identical to the static model in its handling of internal
 targets. The SPARK model, however, requires explicit @code{Elaborate} or
 >>>   function "Func" called at line 3
 4. end SPARK_Model;
 @end example
-@node Mixing Elaboration Models,Elaboration Circularities,SPARK Elaboration Model in GNAT,Elaboration Order Handling in GNAT
+@node Legacy Elaboration Model in GNAT,Mixing Elaboration Models,SPARK Elaboration Model in GNAT,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat mixing-elaboration-models}@anchor{240}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id11}@anchor{241}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat legacy-elaboration-model-in-gnat}@anchor{23e}
+@section Legacy Elaboration Model in GNAT
+The legacy elaboration model is provided for compatibility with code bases
+developed with pre-18.x versions of GNAT. It is similar in functionality to
+the dynamic and static models of post-18.x version of GNAT, but may differ
+in terms of diagnostics and run-time checks. The legacy elaboration model is
+enabled with compiler switch @code{-gnatH}.
+@node Mixing Elaboration Models,Elaboration Circularities,Legacy Elaboration Model in GNAT,Elaboration Order Handling in GNAT
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat mixing-elaboration-models}@anchor{23f}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id11}@anchor{240}
 @section Mixing Elaboration Models
 It is possible to mix units compiled with a different elaboration model,
 however the following rules must be observed:
 @end example
 The warnings can be suppressed by binder switch @code{-ws}.
 @node Elaboration Circularities,Resolving Elaboration Circularities,Mixing Elaboration Models,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat id12}@anchor{242}@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-circularities}@anchor{243}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat id12}@anchor{241}@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-circularities}@anchor{242}
 @section Elaboration Circularities
 If the binder cannot find an acceptable elaboration order, it outputs detailed
 diagnostics describing an @strong{elaboration circularity}.
 @emph{with}s @code{Client}, implying that @code{Client} must be elaborated prior to
 @code{Server}. The end result is that @code{Client} must be elaborated prior to
 @code{Client}, and this leads to a circularity.
 @node Resolving Elaboration Circularities,Resolving Task Issues,Elaboration Circularities,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat id13}@anchor{244}@anchor{gnat_ugn/elaboration_order_handling_in_gnat resolving-elaboration-circularities}@anchor{245}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat id13}@anchor{243}@anchor{gnat_ugn/elaboration_order_handling_in_gnat resolving-elaboration-circularities}@anchor{244}
 @section Resolving Elaboration Circularities
 When faced with an elaboration circularity, a programmer has several options
 available.
 implicit @code{Elaborate} and @code{Elaborate_All} pragmas, resulting in a behavior
 identical to that specified by the Ada Reference Manual. The binder will
 generate an executable program that may or may not raise @code{Program_Error},
 and it is the programmer's responsibility to ensure that it does not raise
 @code{Program_Error}.
+If the compilation was performed using a post-18.x version of GNAT, consider
+using the legacy elaboration model, in the following order:
+@itemize -
+@item
+Use the legacy static elaboration model, with compiler switch
+@code{-gnatH}.
+@item
+Use the legacy dynamic elaboration model, with compiler switches
+@code{-gnatH} @code{-gnatE}.
+@item
+Use the relaxed legacy static elaboration model, with compiler switches
+@code{-gnatH} @code{-gnatJ}.
+@item
+Use the relaxed legacy dynamic elaboration model, with compiler switches
+@code{-gnatH} @code{-gnatJ} @code{-gnatE}.
+@end itemize
 @item
 @emph{Suppress all elaboration checks}
 The drawback of run-time checks is that they generate overhead at run time,
 run-time checks.
 @end itemize
 @end itemize
 @node Resolving Task Issues,Elaboration-related Compiler Switches,Resolving Elaboration Circularities,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat id14}@anchor{246}@anchor{gnat_ugn/elaboration_order_handling_in_gnat resolving-task-issues}@anchor{247}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat id14}@anchor{245}@anchor{gnat_ugn/elaboration_order_handling_in_gnat resolving-task-issues}@anchor{246}
 @section Resolving Task Issues
 The model of execution in Ada dictates that elaboration must first take place,
 and only then can the main program be started. Tasks which are activated during
 In addition to the change in behavior with respect to task bodies, the
 static model will verify that no entry calls take place at elaboration time.
 @end itemize
 @node Elaboration-related Compiler Switches,Summary of Procedures for Elaboration Control,Resolving Task Issues,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-related-compiler-switches}@anchor{248}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id15}@anchor{249}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-related-compiler-switches}@anchor{247}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id15}@anchor{248}
 @section Elaboration-related Compiler Switches
 GNAT has several switches that affect the elaboration model and consequently
 the elaboration order chosen by the binder.
-@geindex -gnatdE (gnat)
-@table @asis
-@item @code{-gnatdE}
-Elaboration checks on predefined units
-When this switch is in effect, GNAT will consider scenarios and targets that
-come from the Ada, GNAT, Interfaces, and System hierarchies. This switch is
-useful when a programmer has defined a custom grandchild of those packages.
-@end table
-@geindex -gnatd.G (gnat)
-@table @asis
-@item @code{-gnatd.G}
-Ignore calls through generic formal parameters for elaboration
-When this switch is in effect, GNAT will ignore calls that invoke generic
-actual entries, operators, or subprograms via generic formal subprograms. As
-a result, GNAT will not generate implicit @code{Elaborate} and @code{Elaborate_All}
-pragmas, and run-time checks for such calls. Note that this switch does not
-overlap with @code{-gnatdL}.
-@example
-package body Ignore_Calls is
-function ABE return Integer;
-generic
-with function Gen_Formal return Integer;
-package Gen is
-Val : constant Integer := Gen_Formal;
-end Gen;
-package Inst is new Gen (ABE);
-function ABE return Integer is
-begin
-...
-end ABE;
-end Ignore_Calls;
-@end example
-In the example above, the call to function @code{ABE} will be ignored because it
-occurs during the elaboration of instance @code{Inst}, through a call to generic
-formal subprogram @code{Gen_Formal}.
-@end table
-@geindex -gnatdL (gnat)
-@table @asis
-@item @code{-gnatdL}
-Ignore external calls from instances for elaboration
-When this switch is in effect, GNAT will ignore calls that originate from
-within an instance and directly target an entry, operator, or subprogram
-defined outside the instance. As a result, GNAT will not generate implicit
-@code{Elaborate} and @code{Elaborate_All} pragmas, and run-time checks for such
-calls.  Note that this switch does not overlap with @code{-gnatd.G}.
-@example
-package body Ignore_Calls is
-function ABE return Integer;
-generic
-package Gen is
-Val : constant Integer := ABE;
-end Gen;
-package Inst is new Gen;
-function ABE return Integer is
-begin
-...
-end ABE;
-end Ignore_Calls;
-@end example
-In the example above, the call to function @code{ABE} will be ignored because it
-originates from within an instance and targets a subprogram defined outside
-the instance.
-@end table
-@geindex -gnatd.o (gnat)
-@table @asis
-@item @code{-gnatd.o}
-Conservative elaboration order for indirect calls
-When this switch is in effect, GNAT will treat @code{'Access} of an entry,
-operator, or subprogram as an immediate call to that target. As a result,
-GNAT will generate implicit @code{Elaborate} and @code{Elaborate_All} pragmas as
-well as run-time checks for such attribute references.
-@example
-1. package body Attribute_Call is
-2.    function Func return Integer;
-3.    type Func_Ptr is access function return Integer;
-4.
-5.    Ptr : constant Func_Ptr := Func'Access;
-|
->>> warning: cannot call "Func" before body seen
->>> warning: Program_Error may be raised at run time
->>> warning:   body of unit "Attribute_Call" elaborated
->>> warning:   "Access" of "Func" taken at line 5
->>> warning:   function "Func" called at line 5
-6.
-7.    function Func return Integer is
-8.    begin
-9.       ...
-10.    end Func;
-11. end Attribute_Call;
-@end example
-In the example above, the elaboration of declaration @code{Ptr} is assigned
-@code{Func'Access} before the body of @code{Func} has been elaborated.
-@end table
-@geindex -gnatd.U (gnat)
-@table @asis
-@item @code{-gnatd.U}
-Ignore indirect calls for static elaboration
-When this switch is in effect, GNAT will ignore @code{'Access} of an entry,
-operator, or subprogram when the static model is in effect.
-@end table
-@geindex -gnatd.v (gnat)
-@table @asis
-@item @code{-gnatd.v}
-Enforce SPARK elaboration rules in SPARK code
-When this switch is in effect, GNAT will enforce the SPARK rules of
-elaboration as defined in the SPARK Reference Manual, section 7.7. As a
-result, constructs which violate the SPARK elaboration rules are no longer
-accepted, even if GNAT is able to statically ensure that these constructs
-will not lead to ABE problems.
-@end table
-@geindex -gnatd.y (gnat)
-@table @asis
-@item @code{-gnatd.y}
-Disable implicit pragma Elaborate[_All] on task bodies
-When this switch is in effect, GNAT will not generate @code{Elaborate} and
-@code{Elaborate_All} pragmas if the need for the pragma came directly or
-indirectly from a task body.
-@example
-with Server;
-package body Disable_Task is
-task T;
-task body T is
-begin
-Server.Proc;
-end T;
-end Disable_Task;
-@end example
-In the example above, the activation of single task @code{T} invokes
-@code{Server.Proc}, which implies that @code{Server} requires @code{Elaborate_All},
-however GNAT will not generate the pragma.
-@end table
 @geindex -gnatE (gnat)
 @table @asis
 >>> info: "Elaborate_All" requirement for unit "Server" met by pragma at line 1
 4. end Client;
 @end example
 @end itemize
+@end table
+@geindex -gnatH (gnat)
+@table @asis
+@item @code{-gnatH}
+Legacy elaboration checking mode enabled
+When this switch is in effect, GNAT will utilize the pre-18.x elaboration
+model.
+@end table
+@geindex -gnatJ (gnat)
+@table @asis
+@item @code{-gnatJ}
+Relaxed elaboration checking mode enabled
+When this switch is in effect, GNAT will not process certain scenarios,
+resulting in a more permissive elaboration model. Note that this may
+eliminate some diagnostics and run-time checks.
 @end table
 @geindex -gnatw.f (gnat)
 In the example above, the elaboration of declaration @code{Ptr} is assigned
 @code{Func'Access} before the body of @code{Func} has been elaborated.
 @end table
+@geindex -gnatwl (gnat)
+@table @asis
+@item @code{-gnatwl}
+Turn on warnings for elaboration problems
+When this switch is in effect, GNAT emits diagnostics in the form of warnings
+concerning various elaboration problems. The warnings are enabled by default.
+The switch is provided in case all warnings are suppressed, but elaboration
+warnings are still desired.
+@item @code{-gnatwL}
+Turn off warnings for elaboration problems
+When this switch is in effect, GNAT no longer emits any diagnostics in the
+form of warnings. Selective suppression of elaboration problems is possible
+using @code{pragma Warnings (Off)}.
+@example
+1. package body Selective_Suppression is
+2.    function ABE return Integer;
+3.
+4.    Val_1 : constant Integer := ABE;
+|
+>>> warning: cannot call "ABE" before body seen
+>>> warning: Program_Error will be raised at run time
+5.
+6.    pragma Warnings (Off);
+7.    Val_2 : constant Integer := ABE;
+8.    pragma Warnings (On);
+9.
+10.    function ABE return Integer is
+11.    begin
+12.       ...
+13.    end ABE;
+14. end Selective_Suppression;
+@end example
+Note that suppressing elaboration warnings does not eliminate run-time
+checks. The example above will still fail at run time with an ABE.
+@end table
 @node Summary of Procedures for Elaboration Control,Inspecting the Chosen Elaboration Order,Elaboration-related Compiler Switches,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat summary-of-procedures-for-elaboration-control}@anchor{24a}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id16}@anchor{24b}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat summary-of-procedures-for-elaboration-control}@anchor{249}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id16}@anchor{24a}
 @section Summary of Procedures for Elaboration Control
 A programmer should first compile the program with the default options, using
 none of the binder or compiler switches. If the binder succeeds in finding an
 elaboration order, then apart from possible cases involing dispatching calls
 and access-to-subprogram types, the program is free of elaboration errors.
 If it is important for the program to be portable to compilers other than GNAT,
 then the programmer should use compiler switch @code{-gnatel} and consider
 the messages about missing or implicitly created @code{Elaborate} and
 @code{Elaborate_All} pragmas.
 @itemize *
 @item
-Ensure that warnings are enabled. This will allow the static model to output
+Ensure that elaboration warnings are enabled. This will allow the static
-trace information of elaboration issues. The trace information could shed
+model to output trace information of elaboration issues. The trace
-light on previously unforeseen dependencies, as well as their origins.
+information could shed light on previously unforeseen dependencies, as well
+as their origins. Elaboration warnings are enabled with compiler switch
+@code{-gnatwl}.
 @item
 Use switch @code{-gnatel} to obtain messages on generated implicit
 @code{Elaborate} and @code{Elaborate_All} pragmas. The trace information could
 indicate why a server unit must be elaborated prior to a client unit.
 @item
 If the warnings produced by the static model indicate that a task is
-involved, consider the options in the section on resolving task issues as
+involved, consider the options in section @ref{245,,Resolving Task Issues}.
-well as compiler switch @code{-gnatd.y}.
+@item
-@item
+If none of the steps outlined above resolve the circularity, use a more
-If the warnings produced by the static model indicate that an generic
+permissive elaboration model, in the following order:
-instantiations are involved, consider using compiler switches
-@code{-gnatd.G} and @code{-gnatdL}.
+@itemize -
-@item
-If none of the steps outlined above resolve the circularity, recompile the
+@item
-program using the dynamic model by using compiler switch @code{-gnatE}.
+Use the dynamic elaboration model, with compiler switch @code{-gnatE}.
+@item
+Use the legacy static elaboration model, with compiler switch
+@code{-gnatH}.
+@item
+Use the legacy dynamic elaboration model, with compiler switches
+@code{-gnatH} @code{-gnatE}.
+@item
+Use the relaxed legacy static elaboration model, with compiler switches
+@code{-gnatH} @code{-gnatJ}.
+@item
+Use the relaxed legacy dynamic elaboration model, with compiler switches
+@code{-gnatH} @code{-gnatJ} @code{-gnatE}.
 @end itemize
+@end itemize
 @node Inspecting the Chosen Elaboration Order,,Summary of Procedures for Elaboration Control,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat inspecting-the-chosen-elaboration-order}@anchor{24c}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id17}@anchor{24d}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat inspecting-the-chosen-elaboration-order}@anchor{24b}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id17}@anchor{24c}
 @section Inspecting the Chosen Elaboration Order
 To see the elaboration order chosen by the binder, inspect the contents of file
 @cite{b~xxx.adb}. On certain targets, this file appears as @cite{b_xxx.adb}. The
 text_io (spec)
 gdbstr (body)
 @end example
 @node Inline Assembler,GNU Free Documentation License,Elaboration Order Handling in GNAT,Top
-@anchor{gnat_ugn/inline_assembler inline-assembler}@anchor{10}@anchor{gnat_ugn/inline_assembler doc}@anchor{24e}@anchor{gnat_ugn/inline_assembler id1}@anchor{24f}
+@anchor{gnat_ugn/inline_assembler inline-assembler}@anchor{10}@anchor{gnat_ugn/inline_assembler doc}@anchor{24d}@anchor{gnat_ugn/inline_assembler id1}@anchor{24e}
 @chapter Inline Assembler
 @geindex Inline Assembler
 * Other Asm Functionality::
 @end menu
 @node Basic Assembler Syntax,A Simple Example of Inline Assembler,,Inline Assembler
-@anchor{gnat_ugn/inline_assembler id2}@anchor{250}@anchor{gnat_ugn/inline_assembler basic-assembler-syntax}@anchor{251}
+@anchor{gnat_ugn/inline_assembler id2}@anchor{24f}@anchor{gnat_ugn/inline_assembler basic-assembler-syntax}@anchor{250}
 @section Basic Assembler Syntax
 The assembler used by GNAT and gcc is based not on the Intel assembly
 language, but rather on a language that descends from the AT&T Unix
 @end display
 @node A Simple Example of Inline Assembler,Output Variables in Inline Assembler,Basic Assembler Syntax,Inline Assembler
-@anchor{gnat_ugn/inline_assembler a-simple-example-of-inline-assembler}@anchor{252}@anchor{gnat_ugn/inline_assembler id3}@anchor{253}
+@anchor{gnat_ugn/inline_assembler a-simple-example-of-inline-assembler}@anchor{251}@anchor{gnat_ugn/inline_assembler id3}@anchor{252}
 @section A Simple Example of Inline Assembler
 The following example will generate a single assembly language statement,
 @code{nop}, which does nothing.  Despite its lack of run-time effect,
 input file, so you can easily find and correct any mistakes you made.
 If there are no errors, @code{as} will generate an object file
 @code{nothing.out}.
 @node Output Variables in Inline Assembler,Input Variables in Inline Assembler,A Simple Example of Inline Assembler,Inline Assembler
-@anchor{gnat_ugn/inline_assembler id4}@anchor{254}@anchor{gnat_ugn/inline_assembler output-variables-in-inline-assembler}@anchor{255}
+@anchor{gnat_ugn/inline_assembler id4}@anchor{253}@anchor{gnat_ugn/inline_assembler output-variables-in-inline-assembler}@anchor{254}
 @section Output Variables in Inline Assembler
 The examples in this section, showing how to access the processor flags,
 illustrate how to specify the destination operands for assembly language
 end Get_Flags_3;
 @end example
 @end quotation
 @node Input Variables in Inline Assembler,Inlining Inline Assembler Code,Output Variables in Inline Assembler,Inline Assembler
-@anchor{gnat_ugn/inline_assembler id5}@anchor{256}@anchor{gnat_ugn/inline_assembler input-variables-in-inline-assembler}@anchor{257}
+@anchor{gnat_ugn/inline_assembler id5}@anchor{255}@anchor{gnat_ugn/inline_assembler input-variables-in-inline-assembler}@anchor{256}
 @section Input Variables in Inline Assembler
 The example in this section illustrates how to specify the source operands
 for assembly language statements.
 ret
 @end example
 @end quotation
 @node Inlining Inline Assembler Code,Other Asm Functionality,Input Variables in Inline Assembler,Inline Assembler
-@anchor{gnat_ugn/inline_assembler id6}@anchor{258}@anchor{gnat_ugn/inline_assembler inlining-inline-assembler-code}@anchor{259}
+@anchor{gnat_ugn/inline_assembler id6}@anchor{257}@anchor{gnat_ugn/inline_assembler inlining-inline-assembler-code}@anchor{258}
 @section Inlining Inline Assembler Code
 For a short subprogram such as the @code{Incr} function in the previous
 section, the overhead of the call and return (creating / deleting the stack
 @end quotation
 thus saving the overhead of stack frame setup and an out-of-line call.
 @node Other Asm Functionality,,Inlining Inline Assembler Code,Inline Assembler
-@anchor{gnat_ugn/inline_assembler other-asm-functionality}@anchor{25a}@anchor{gnat_ugn/inline_assembler id7}@anchor{25b}
+@anchor{gnat_ugn/inline_assembler other-asm-functionality}@anchor{259}@anchor{gnat_ugn/inline_assembler id7}@anchor{25a}
 @section Other @code{Asm} Functionality
 This section describes two important parameters to the @code{Asm}
 procedure: @code{Clobber}, which identifies register usage;
 * The Volatile Parameter::
 @end menu
 @node The Clobber Parameter,The Volatile Parameter,,Other Asm Functionality
-@anchor{gnat_ugn/inline_assembler the-clobber-parameter}@anchor{25c}@anchor{gnat_ugn/inline_assembler id8}@anchor{25d}
+@anchor{gnat_ugn/inline_assembler the-clobber-parameter}@anchor{25b}@anchor{gnat_ugn/inline_assembler id8}@anchor{25c}
 @subsection The @code{Clobber} Parameter
 One of the dangers of intermixing assembly language and a compiled language
 such as Ada is that the compiler needs to be aware of which registers are
 @item
 Use 'register' name @code{memory} if you changed a memory location
 @end itemize
 @node The Volatile Parameter,,The Clobber Parameter,Other Asm Functionality
-@anchor{gnat_ugn/inline_assembler the-volatile-parameter}@anchor{25e}@anchor{gnat_ugn/inline_assembler id9}@anchor{25f}
+@anchor{gnat_ugn/inline_assembler the-volatile-parameter}@anchor{25d}@anchor{gnat_ugn/inline_assembler id9}@anchor{25e}
 @subsection The @code{Volatile} Parameter
 @geindex Volatile parameter
 important for efficiency. In general, you should set @code{Volatile}
 to @code{True} only if the compiler's optimizations have created
 problems.
 @node GNU Free Documentation License,Index,Inline Assembler,Top
-@anchor{share/gnu_free_documentation_license gnu-fdl}@anchor{1}@anchor{share/gnu_free_documentation_license doc}@anchor{260}@anchor{share/gnu_free_documentation_license gnu-free-documentation-license}@anchor{261}
+@anchor{share/gnu_free_documentation_license gnu-fdl}@anchor{1}@anchor{share/gnu_free_documentation_license doc}@anchor{25f}@anchor{share/gnu_free_documentation_license gnu-free-documentation-license}@anchor{260}
 @chapter GNU Free Documentation License
 Version 1.3, 3 November 2008

Mercurial > hg > CbC > CbC_gcc

comparison gcc/ada/gnat_ugn.texi @ 131:84e7813d76e9