ada: Add documentation about GNAT LLVM to GNAT User's Guide

Also be consistent on spelling of "back end".

gcc/ada/ChangeLog:

	* doc/gnat_ugn/about_this_guide.rst: Add information about GNAT LLVM.
	Be consistent about spelling of "back end".
	* doc/gnat_ugn/building_executable_programs_with_gnat.rst: Likewise.
	* doc/gnat_ugn/gnat_and_program_execution.rst: Be consistent about
	spelling of "back end".
	* doc/gnat_ugn/the_gnat_compilation_model.rst: Likewise.
	* gnat_ugn.texi: Regenerate.

5 files changed, 801 insertions, 557 deletions

diff --git a/gcc/ada/doc/gnat_ugn/about_this_guide.rst b/gcc/ada/doc/gnat_ugn/about_this_guide.rst
index ef8b239..d614fe1 100644
--- a/gcc/ada/doc/gnat_ugn/about_this_guide.rst
+++ b/gcc/ada/doc/gnat_ugn/about_this_guide.rst
@@ -22,6 +22,13 @@ language version.  Throughout this manual, references to 'Ada' without
 a year suffix apply to all versions of the Ada language starting with
 Ada 95.
 
+GNAT supports both the GCC and LLVM back end compilation families.
+Most GNAT versions use the GCC back end, but some are now available using
+the LLVM back end. In some places in this manual, we distinguish between
+the two back ends, but in most cases, everything in this manual applies
+to both back ends. We refer to GNAT with the LLVM back end as 'GNAT LLVM'.
+See :ref:`GNATLLVM` for limitations of GNAT LLVM.
+
 What This Guide Contains
 ========================
 
diff --git a/gcc/ada/doc/gnat_ugn/building_executable_programs_with_gnat.rst b/gcc/ada/doc/gnat_ugn/building_executable_programs_with_gnat.rst
index d8501b2..e6b87bd 100644
--- a/gcc/ada/doc/gnat_ugn/building_executable_programs_with_gnat.rst
+++ b/gcc/ada/doc/gnat_ugn/building_executable_programs_with_gnat.rst
@@ -1754,7 +1754,7 @@ Alphabetical List of All Switches
 
   ``Maximum_Alignment`` is the maximum alignment that the compiler can choose
   by default for a type or object, which is also the maximum alignment that can
-  be specified in GNAT. It is computed for GCC backends as ``BIGGEST_ALIGNMENT
+  be specified in GNAT. It is computed for GCC back ends as ``BIGGEST_ALIGNMENT
   / BITS_PER_UNIT`` where GCC macro ``BIGGEST_ALIGNMENT`` is documented as
   follows: `Biggest alignment that any data type can require on this machine,
   in bits.`
@@ -2009,7 +2009,7 @@ Alphabetical List of All Switches
 
 :switch:`-gnatn[12]`
   Activate inlining across units for subprograms for which pragma ``Inline``
-  is specified. This inlining is performed by the GCC back-end. An optional
+  is specified. This inlining is performed by the GCC back end. An optional
   digit sets the inlining level: 1 for moderate inlining across units
   or 2 for full inlining across units. If no inlining level is specified,
   the compiler will pick it based on the optimization level.
@@ -3587,7 +3587,7 @@ of the pragma in the :title:`GNAT_Reference_manual`).
   many reasons for not being able to inline a call, including most
   commonly that the call is too complex to inline. The default is
   that such warnings are not given.
-  Warnings on ineffective inlining by the gcc back-end can be activated
+  Warnings on ineffective inlining by the gcc back end can be activated
   separately, using the gcc switch -Winline.
 
 
@@ -7719,7 +7719,7 @@ The following switches are available with the ``gnatlink`` utility:
   command that will be used by ``gnatlink`` will be ``foo -c -x -y``.
   A limitation of this syntax is that the name and path name of the executable
   itself must not include any embedded spaces. If the compiler executable is
-  different from the default one (gcc or <prefix>-gcc), then the back-end
+  different from the default one (gcc or <prefix>-gcc), then the back end
   switches in the ALI file are not used to compile the binder generated source.
   For example, this is the case with ``--GCC="foo -x -y"``. But the back end
   switches will be used for ``--GCC="gcc -gnatv"``. If several
@@ -8021,3 +8021,123 @@ replace colons with semicolons in the assignments to these variables.
 
   all:
           gnatmake main_unit
+
+.. _GNATLLVM:
+
+GNAT with the LLVM Back End
+---------------------------
+
+This section outlines the usage of the GNAT compiler with the LLVM
+back end and highlights its key limitations. Certain GNAT versions,
+referred to as GNAT LLVM, include an alternative LLVM back end
+alongside the GCC back end, providing access to utilities that operate
+at the LLVM Intermediate Representation (IR) level. This also enhances
+safety by facilitating dissimilar redundancy through diverse code
+generation techniques, allowing for the creation of two distinct
+binaries from the same source code.
+
+Although both GNAT LLVM and the GCC-based GNAT follow most ABI rules,
+there are some cases where there you may encounter an incompatibility
+between the two compilers.  One such case for the 64-bit Intel X86 is
+a difference in parameter passing when a structure that consists of 64
+bits is passed. The native LLVM handling (and hence that of GNAT LLVM)
+and ``clang`` disagree in this case. GCC follows ``clang``. The formal
+ABI agrees with LLVM.
+
+In any case, we don't recommend you link code compiled with GNAT LLVM
+to code compiled by the GCC version of GNAT. This is a specific case
+of the general rule that you should compile all your Ada code with the
+same version of GNAT. Both ``gnatmake`` and ``gprbuild`` ensure this
+is done.
+
+You may, however, run into this incompatibility if you pass such a
+record between C and Ada. In general, we recommend keeping the data
+passed between C and Ada as simple as practical.
+
+GNAT LLVM currently provides limited support for debugging data. It
+provides full line number information for declarations and statements,
+but not sufficient debugging data to display all Ada data
+structures. GNAT LLVM outputs complete debugging data only for types
+with a direct equivalent in C, namely records without discriminants
+and constrained arrays whose dimensions are known at compile time. You
+will not be able to use ``gdb`` print commands to look at objects not
+of those types or to display components of those types. You can use
+low-level ``gdb`` commands that display memory to view such data
+provided you know how they're laid out.  Debugging information may
+also be limited for bitfields (fields whose size and position
+aren't on byte boundaries)
+
+In addition, debugging information may be confusing if you have
+``out`` parameters to subprograms. If you have a procedure with only
+one ``out`` parameter, GNAT LLVM converts that to a function returning
+an object of that type. If you have multiple ``out`` parameters or
+have a function that also has an ``out`` parameter, GNAT LLVM converts
+that subprogram into a function that returns a record where each field
+is either an ``out`` parameter or the function return value, if any.
+The debug information reflects these transformations and not the original
+Ada source code.
+
+GNAT LLVM doesn't fully implement the :switch:``-fcheck-stack`` switch.
+When you specify it, the code generated by GNAT LLVM tests for allocating
+overly-large items on the stack, but not all cases of stack overflow.  For
+example, if you have a very deep recursion where each call only uses a
+small amount of stack and the total stack depth exceeds the amount of
+available stack, the program will be terminated by a signal instead of
+raising an Ada exception.
+
+GNAT LLVM doesn't support the ``Scalar_Storage_Order`` pragma except when
+it's used to confirm the chosen storage order. This is because this facility
+is provided by GCC but not by LLVM.
+
+GNAT LLVM doesn't support Convention C++, which provides so-called
+'name mangling' by encoding parameter and return datatypes into a
+function name.
+
+.. only:: PRO
+
+    Unlike the GCC versions of GNAT, GNAT LLVM doesn't include any
+    Ada libraries. You can obtain source packages from GNATtracker and
+    build them with the compiler configuration appropriate for your
+    project. AdaCore internally builds and tests the GNAT Components
+    Collection, XML/Ada, and AUnit libraries to ensure compatibility
+    with GNAT LLVM, but not all options of those libraries are
+    currently supported with all targets of GNAT LLVM. If you need to
+    use any of these libraries, please open a support ticket.
+
+We provide two options that you can use to build code with GNAT LLVM:
+
+* GNAT LLVM includes a version of ``gnatmake`` called
+  ``llvm-gnatmake``, which is equivalent to ``gnatmake`` and has the
+  same switches, except that it uses GNAT LLVM instead of the GCC
+  version of GNAT.
+
+* ``gprbuild`` can detect and use GNAT LLVM when it is installed.
+
+  ``gprbuild`` uses the first applicable compiler on the executable
+  search path, including GNAT LLVM.  An easy way to build with GNAT
+  LLVM is to make it available on the operating system's search path
+  before any other Ada compiler (such as the GCC version of GNAT). To
+  avoid accidentally using a different compiler than the one you want
+  to use, we recommend generating an explicit toolchain configuration
+  file with ``gprconfig`` and using it with ``gprbuild``; see the
+  *GPRbuild and GPR Companion Tools User's Guide* for details. You
+  can determine from the first line of the :file:`.ali` file
+  which version of GNAT built that file because it contains either
+  :code:``GNAT`` or :code:``GNAT-LLVM``.
+
+.. only:: PRO
+
+    If your project uses one of the libraries packaged with the GCC
+    version of GNAT, it is important that you use the GPR tools from
+    the GNAT LLVM package when building with GNAT LLVM. Otherwise,
+    ``gprbuild`` would try to use the precompiled libraries shipped with
+    the GCC version of GNAT, mixing those objects with code generated
+    by GNAT LLVM, which is not supported.
+
+GNAT LLVM understands the same target triplets as the GCC version of
+GNAT.
+
+.. only:: PRO
+
+  It provides the same runtimes with the exception that light runtimes
+  are not currently included with the native compilers.
diff --git a/gcc/ada/doc/gnat_ugn/gnat_and_program_execution.rst b/gcc/ada/doc/gnat_ugn/gnat_and_program_execution.rst
index f90b7b3..756bc74 100644
--- a/gcc/ada/doc/gnat_ugn/gnat_and_program_execution.rst
+++ b/gcc/ada/doc/gnat_ugn/gnat_and_program_execution.rst
@@ -636,7 +636,7 @@ using GNAT and your familiarity with compiler internals.
   would on a C program (but :ref:`The_GNAT_Debugger_GDB` for caveats). The
   ``where`` command is the first line of attack; the variable
   ``lineno`` (seen by ``print lineno``), used by the second phase of
-  ``gnat1`` and by the ``gcc`` backend, indicates the source line at
+  ``gnat1`` and by the ``gcc`` back end, indicates the source line at
   which the execution stopped, and ``input_file name`` indicates the name of
   the source file.
 
@@ -666,7 +666,7 @@ brief description of its organization may be helpful:
 * All files prefixed with :file:`exp` perform normalization and
   expansion of the intermediate representation (abstract syntax tree, or AST).
   The expansion has the effect of lowering the semantic level of the AST to
-  a level closer to what the backend can handle. For example, it converts
+  a level closer to what the back end can handle. For example, it converts
   tasking operations into calls to the appropriate runtime routines.
   These files use the same numbering scheme as the parser and semantics files.
   For example, the construction of record initialization procedures is done in
@@ -1368,7 +1368,7 @@ The following are the most relevant of those switches:
 
 :switch:`--demangle[={style}]`, :switch:`--no-demangle`
   These switches control whether symbol names should be demangled when
-  printing output.  The default is to demangle C++ symbols.  You can use 
+  printing output.  The default is to demangle C++ symbols.  You can use
   :switch:`--no-demangle` to turn off demangling. Different
   compilers have different mangling styles.  The optional demangling style
   argument can be used to choose an appropriate demangling style for your
@@ -1773,7 +1773,7 @@ following conditions are met:
 * The optimization level is at least :switch:`-O1`.
 
 * The called subprogram is suitable for inlining: it must be small enough
-  and not contain something that the backend cannot support in inlined
+  and not contain something that the back end cannot support in inlined
   subprograms.
 
   .. index:: pragma Inline
@@ -1792,7 +1792,7 @@ in the body of the subprogram), the following conditions must all be true:
 * The optimization level is at least :switch:`-O1`.
 
 * The called subprogram is suitable for inlining: It must be small enough
-  and not contain something that the backend cannot support in inlined
+  and not contain something that the back end cannot support in inlined
   subprograms.
 
 * There is a ``pragma Inline`` for the subprogram.
@@ -1836,33 +1836,34 @@ is compiled, the call will be inlined if the body of ``Q`` is small
 enough, but now ``Main`` depends on the body of ``R`` in
 :file:`r.adb` as well as on the spec. This means that if this body is edited,
 the main program must be recompiled. Note that this extra dependency
-occurs whether or not the call is in fact inlined by the backend.
+occurs whether or not the call is in fact inlined by the back end.
 
 The use of front end inlining with :switch:`-gnatN` generates similar
 additional dependencies.
 
 .. index:: -fno-inline (gcc)
 
-Note: The :switch:`-fno-inline` switch overrides all other conditions and ensures that
-no inlining occurs, unless requested with pragma Inline_Always for most
-back-ends. The extra dependences resulting from :switch:`-gnatn` will still be active,
-even if this switch is used to suppress the resulting inlining actions.
+Note: The :switch:`-fno-inline` switch overrides all other conditions
+and ensures that no inlining occurs, unless requested with pragma
+Inline_Always for most back ends. The extra dependences resulting from
+:switch:`-gnatn` will still be active, even if this switch is used to
+suppress the resulting inlining actions.
 
 .. index:: -fno-inline-functions (gcc)
 
-For the GCC backend, you can use the
+For the GCC back end, you can use the
 :switch:`-fno-inline-functions` switch to prevent automatic inlining
 of subprograms if you use :switch:`-O3`.
 
 .. index:: -fno-inline-small-functions (gcc)
 
-For the GCC backend, you can use the
+For the GCC back end, you can use the
 :switch:`-fno-inline-small-functions` switch to prevent automatic
 inlining of small subprograms if you use :switch:`-O2`.
 
 .. index:: -fno-inline-functions-called-once (gcc)
 
-For the GC backend, you can use the
+For the GC back end, you can use the
 :switch:`-fno-inline-functions-called-once` switch to prevent inlining
 of subprograms local to the unit and called once from within it if you
 use :switch:`-O1`.
@@ -1941,10 +1942,10 @@ Vectorization of loops
 
 .. index:: Optimization Switches
 
-The GCC and LLVM backends have an auto-vectorizer that's enabled by
-default at some optimization levels.  For the GCC backend, it's
+The GCC and LLVM back ends have an auto-vectorizer that's enabled by
+default at some optimization levels.  For the GCC back end, it's
 enabled by default at :switch:`-O3` and you can request it at other
-levels with :switch:`-ftree-vectorize`. For the LLVM backend, it's
+levels with :switch:`-ftree-vectorize`. For the LLVM back end, it's
 enabled by default at lower levels, but you can explicitly enable or
 disable it with the :switch:`-fno-vectorize`, :switch:`-fvectorize`,
 :switch:`-fno-slp-vectorize`, and :switch:`-fslp-vectorize` switches.
@@ -2034,7 +2035,7 @@ preferably to other optimizations by means of pragma ``Loop_Optimize``:
 
 placed immediately within the loop will convey the appropriate hint to the
 compiler for this loop. This is currently only supported for the GCC
-backend.
+back end.
 
 You can also help the compiler generate better vectorized code
 for a given loop by asserting that there are no loop-carried dependencies
@@ -2065,7 +2066,7 @@ be overcome by another hint:
 
 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.
-This is also currently only supported by the GCC backend.
+This is also currently only supported by the GCC back end.
 
 
 .. _Other_Optimization_Switches:
@@ -2076,9 +2077,9 @@ Other Optimization Switches
 .. index:: Optimization Switches
 
 You can also use any specialized optimization switches supported by
-the backend being used.  These switches have not been extensively
+the back end being used.  These switches have not been extensively
 tested with GNAT but can generally be expected to work. Examples of
-switches in this category for the GCC backend are
+switches in this category for the GCC back end are
 :switch:`-funroll-loops` and the various target-specific :switch:`-m`
 options (in particular, it has been observed that :switch:`-march=xxx`
 can significantly improve performance on appropriate machines). For
@@ -2131,14 +2132,15 @@ instead of in every iteration (this is called load hoisting).
 
 This kind of optimizations, based on strict type-based aliasing, is
 triggered by specifying an optimization level of :switch:`-O2` or
-higher (or :switch:`-Os`) for the GCC backend and :switch:`-O1` or higher for the
-LLVM backend and allows the compiler to generate more
+higher (or :switch:`-Os`) for the GCC back end and :switch:`-O1` or
+higher for the LLVM back end and allows the compiler to generate more
 efficient code.
 
-However, although this optimization is always correct in terms of
-the formal semantics of the Ada Reference Manual, you can run into difficulties 
-arise if you use features like ``Unchecked_Conversion``  to break
-the typing system. Consider the following complete program example:
+However, although this optimization is always correct in terms of the
+formal semantics of the Ada Reference Manual, you can run into
+difficulties arise if you use features like ``Unchecked_Conversion``
+to break the typing system. Consider the following complete program
+example:
 
   .. code-block:: ada
 
@@ -2341,7 +2343,7 @@ the compiler can have significant benefits. We've seen cases of large
 scale application code where the execution time is increased by up to
 5% when these optimizations are turned off. However, if you have code
 that make significant use of unchecked conversion, you might want to
-just stick with :switch:`-O1` (with the GCC backend) and avoid the
+just stick with :switch:`-O1` (with the GCC back end) and avoid the
 entire issue. If you get adequate performance at this level of
 optimization, that's probably the safest approach. If tests show that
 you really need higher levels of optimization, then you can experiment
@@ -2592,7 +2594,7 @@ is directly performed by the linker.
 .. index:: -fdata-sections (gcc)
 
 In order to do this, it has to work with objects compiled with the
-following switches passed to the GCC backend:
+following switches passed to the GCC back end:
 :switch:`-ffunction-sections` :switch:`-fdata-sections`.
 
 These options are usable with C and Ada files.
@@ -2966,7 +2968,7 @@ or ``Unsuppress`` in the usual manner.
 .. index:: -gnato?? (gcc)
 
 Additionally, you can use the compiler switch :switch:`-gnato?` or
-:switch:`-gnato??` to control the checking mode default (which you can 
+:switch:`-gnato??` to control the checking mode default (which you can
 subsequently override using the above pragmas).
 
 Here ``?`` is one of the digits ``1`` through ``3``:
@@ -3376,8 +3378,8 @@ the subtypes because both the parameter and return are of the same type.
 An example instantiation
 
   .. code-block:: ada
-  
-        package Mks_Numerics is new 
+
+        package Mks_Numerics is new
            Ada.Numerics.Generic_Elementary_Functions (System.Dim.Mks.Mks_Type);
 
 .. _Stack_Related_Facilities:
@@ -3431,7 +3433,7 @@ 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
 operating system documentation.
 
-When using the LLVM backend, this switch doesn't perform full stack overflow
+When using the LLVM back end, this switch doesn't perform full stack overflow
 checking, but just checks for very large local dynamic allocations.
 
 .. _Static_Stack_Usage_Analysis:
@@ -3475,7 +3477,7 @@ issue a warning for each subprogram whose stack usage might be larger
 than the specified amount of bytes.  The wording of that warning is
 consistent with that in the file documented above.
 
-This is not supported by the LLVM backend.
+This is not supported by the LLVM back end.
 
 
 .. _Dynamic_Stack_Usage_Analysis:
@@ -3496,7 +3498,7 @@ Note that this switch is not compatible with tools like
 Valgrind and DrMemory; they will report errors.
 
 It is not always convenient to output the stack usage when the program
-is still running. Hence, you can delay this output until the 
+is still running. Hence, you can delay this output until the
 termination of the number of tasks specified as the argument of the
 :switch:`-u` switch. For example:
 
@@ -3538,7 +3540,7 @@ given in kilobytes. For example:
 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.
 
-This is not suppored by the LLVM backend.
+This is not suppored by the LLVM back end.
 
 The package ``GNAT.Task_Stack_Usage`` provides facilities to get
 stack-usage reports at run time. See its body for the details.
diff --git a/gcc/ada/doc/gnat_ugn/the_gnat_compilation_model.rst b/gcc/ada/doc/gnat_ugn/the_gnat_compilation_model.rst
index a3789cd..4c87b73 100644
--- a/gcc/ada/doc/gnat_ugn/the_gnat_compilation_model.rst
+++ b/gcc/ada/doc/gnat_ugn/the_gnat_compilation_model.rst
@@ -1494,7 +1494,7 @@ Restrictions that require partition-wide consistency (like
 recognized wherever they appear
 and can be freely inherited, e.g. from a |withed| unit to the |withing|
 unit. This makes sense since the binder will always insist on seeing
-consistent us, so any unit not conforming to any restrictions 
+consistent us, so any unit not conforming to any restrictions
 anywhere in the partition will be rejected and it's better for you to find
 that out at compile time rather than bind time.
 
@@ -3713,9 +3713,9 @@ Convention identifiers are recognized by GNAT:
 
   * General subprogram entities. This is used  to bind an Ada subprogram
     declaration to
-    a compiler builtin by name with back-ends where such interfaces are
+    a compiler builtin by name with back ends where such interfaces are
     available. A typical example is the set of ``__builtin`` functions
-    exposed by the ``gcc`` back-end, as in the following example:
+    exposed by the ``gcc`` back end, as in the following example:
 
 
     .. code-block:: ada
diff --git a/gcc/ada/gnat_ugn.texi b/gcc/ada/gnat_ugn.texi
index 8bf72ec..5eef602 100644
--- a/gcc/ada/gnat_ugn.texi
+++ b/gcc/ada/gnat_ugn.texi
@@ -19,7 +19,7 @@
 
 @copying
 @quotation
-GNAT User's Guide for Native Platforms , Nov 04, 2024
+GNAT User's Guide for Native Platforms , Nov 08, 2024
 
 AdaCore
 
@@ -307,6 +307,7 @@ Using the GNU make Utility
 * Automatically Creating a List of Directories:: 
 * Generating the Command Line Switches:: 
 * Overcoming Command Line Length Limits:: 
+* GNAT with the LLVM Back End:: 
 
 GNAT Utility Programs
 
@@ -557,6 +558,13 @@ language version.  Throughout this manual, references to ‘Ada’ without
 a year suffix apply to all versions of the Ada language starting with
 Ada 95.
 
+GNAT supports both the GCC and LLVM back end compilation families.
+Most GNAT versions use the GCC back end, but some are now available using
+the LLVM back end. In some places in this manual, we distinguish between
+the two back ends, but in most cases, everything in this manual applies
+to both back ends. We refer to GNAT with the LLVM back end as ‘GNAT LLVM’.
+See @ref{7,,GNAT with the LLVM Back End} for limitations of GNAT LLVM.
+
 @menu
 * What This Guide Contains:: 
 * What You Should Know before Reading This Guide:: 
@@ -566,7 +574,7 @@ Ada 95.
 @end menu
 
 @node What This Guide Contains,What You Should Know before Reading This Guide,,About This Guide
-@anchor{gnat_ugn/about_this_guide what-this-guide-contains}@anchor{7}
+@anchor{gnat_ugn/about_this_guide what-this-guide-contains}@anchor{8}
 @section What This Guide Contains
 
 
@@ -576,24 +584,24 @@ This guide contains the following chapters:
 @itemize *
 
 @item 
-@ref{8,,Getting Started with GNAT} describes how to get started compiling
+@ref{9,,Getting Started with GNAT} describes how to get started compiling
 and running Ada programs with the GNAT Ada programming environment.
 
 @item 
-@ref{9,,The GNAT Compilation Model} describes the compilation model used
+@ref{a,,The GNAT Compilation Model} describes the compilation model used
 by GNAT.
 
 @item 
-@ref{a,,Building Executable Programs with GNAT} describes how to use the
+@ref{b,,Building Executable Programs with GNAT} describes how to use the
 main GNAT tools to build executable programs, and it also gives examples of
 using the GNU make utility with GNAT.
 
 @item 
-@ref{b,,GNAT Utility Programs} explains the various utility programs that
+@ref{c,,GNAT Utility Programs} explains the various utility programs that
 are included in the GNAT environment.
 
 @item 
-@ref{c,,GNAT and Program Execution} covers a number of topics related to
+@ref{d,,GNAT and Program Execution} covers a number of topics related to
 running, debugging, and tuning the performance of programs developed
 with GNAT.
 @end itemize
@@ -604,25 +612,25 @@ Appendices cover several additional topics:
 @itemize *
 
 @item 
-@ref{d,,Platform-Specific Information} describes the different run-time
+@ref{e,,Platform-Specific Information} describes the different run-time
 library implementations and also presents information on how to use
 GNAT on several specific platforms.
 
 @item 
-@ref{e,,Example of Binder Output File} shows the source code for the binder
+@ref{f,,Example of Binder Output File} shows the source code for the binder
 output file for a sample program.
 
 @item 
-@ref{f,,Elaboration Order Handling in GNAT} describes how GNAT helps
+@ref{10,,Elaboration Order Handling in GNAT} describes how GNAT helps
 you deal with elaboration order issues.
 
 @item 
-@ref{10,,Inline Assembler} shows how to use the inline assembly facility
+@ref{11,,Inline Assembler} shows how to use the inline assembly facility
 in an Ada program.
 @end itemize
 
 @node What You Should Know before Reading This Guide,Related Information,What This Guide Contains,About This Guide
-@anchor{gnat_ugn/about_this_guide what-you-should-know-before-reading-this-guide}@anchor{11}
+@anchor{gnat_ugn/about_this_guide what-you-should-know-before-reading-this-guide}@anchor{12}
 @section What You Should Know before Reading This Guide
 
 
@@ -637,7 +645,7 @@ Reference manuals for Ada 95, Ada 2005, and Ada 2012 are included in
 the GNAT documentation package.
 
 @node Related Information,Conventions,What You Should Know before Reading This Guide,About This Guide
-@anchor{gnat_ugn/about_this_guide related-information}@anchor{12}
+@anchor{gnat_ugn/about_this_guide related-information}@anchor{13}
 @section Related Information
 
 
@@ -675,7 +683,7 @@ environment Emacs.
 @end itemize
 
 @node Conventions,,Related Information,About This Guide
-@anchor{gnat_ugn/about_this_guide conventions}@anchor{13}
+@anchor{gnat_ugn/about_this_guide conventions}@anchor{14}
 @section Conventions
 
 
@@ -728,7 +736,7 @@ you should use the ‘\’ character instead.
 @end itemize
 
 @node Getting Started with GNAT,The GNAT Compilation Model,About This Guide,Top
-@anchor{gnat_ugn/getting_started_with_gnat doc}@anchor{14}@anchor{gnat_ugn/getting_started_with_gnat getting-started-with-gnat}@anchor{8}@anchor{gnat_ugn/getting_started_with_gnat id1}@anchor{15}
+@anchor{gnat_ugn/getting_started_with_gnat doc}@anchor{15}@anchor{gnat_ugn/getting_started_with_gnat getting-started-with-gnat}@anchor{9}@anchor{gnat_ugn/getting_started_with_gnat id1}@anchor{16}
 @chapter Getting Started with GNAT
 
 
@@ -751,7 +759,7 @@ For information on GNAT Studio please refer to the
 @end menu
 
 @node System Requirements,Running GNAT,,Getting Started with GNAT
-@anchor{gnat_ugn/getting_started_with_gnat id2}@anchor{16}@anchor{gnat_ugn/getting_started_with_gnat system-requirements}@anchor{17}
+@anchor{gnat_ugn/getting_started_with_gnat id2}@anchor{17}@anchor{gnat_ugn/getting_started_with_gnat system-requirements}@anchor{18}
 @section System Requirements
 
 
@@ -781,7 +789,7 @@ machine performing the compilation. You can do this by setting the
 @code{Object_Dir} project file attribute.
 
 @node Running GNAT,Running a Simple Ada Program,System Requirements,Getting Started with GNAT
-@anchor{gnat_ugn/getting_started_with_gnat id3}@anchor{18}@anchor{gnat_ugn/getting_started_with_gnat running-gnat}@anchor{19}
+@anchor{gnat_ugn/getting_started_with_gnat id3}@anchor{19}@anchor{gnat_ugn/getting_started_with_gnat running-gnat}@anchor{1a}
 @section Running GNAT
 
 
@@ -806,7 +814,7 @@ utility program.  You pass it the name of the main program and it automatically
 performs the necessary compilation, binding, and linking steps.
 
 @node Running a Simple Ada Program,Running a Program with Multiple Units,Running GNAT,Getting Started with GNAT
-@anchor{gnat_ugn/getting_started_with_gnat id4}@anchor{1a}@anchor{gnat_ugn/getting_started_with_gnat running-a-simple-ada-program}@anchor{1b}
+@anchor{gnat_ugn/getting_started_with_gnat id4}@anchor{1b}@anchor{gnat_ugn/getting_started_with_gnat running-a-simple-ada-program}@anchor{1c}
 @section Running a Simple Ada Program
 
 
@@ -832,12 +840,12 @@ unit name with periods replaced by hyphens; the
 extension is @code{ads} for a
 spec and @code{adb} for a body.
 You can override this default file naming convention by use of the
-special pragma @code{Source_File_Name} (see @ref{1c,,Using Other File Names}).
+special pragma @code{Source_File_Name} (see @ref{1d,,Using Other File Names}).
 Alternatively, if you want to rename your files according to this default
 convention, which is probably more convenient if you will be using GNAT
 for all your compilations, then you use can use the @code{gnatchop} utility
 to generate correctly-named source files
-(see @ref{1d,,Renaming Files with gnatchop}).
+(see @ref{1e,,Renaming Files with gnatchop}).
 
 You can compile the program using the following command (@code{$} is used
 as the command prompt in the examples in this document):
@@ -896,7 +904,7 @@ Hello WORLD!
 appear in response to this command.
 
 @node Running a Program with Multiple Units,,Running a Simple Ada Program,Getting Started with GNAT
-@anchor{gnat_ugn/getting_started_with_gnat id5}@anchor{1e}@anchor{gnat_ugn/getting_started_with_gnat running-a-program-with-multiple-units}@anchor{1f}
+@anchor{gnat_ugn/getting_started_with_gnat id5}@anchor{1f}@anchor{gnat_ugn/getting_started_with_gnat running-a-program-with-multiple-units}@anchor{20}
 @section Running a Program with Multiple Units
 
 
@@ -970,7 +978,7 @@ $ gnatmake gmain.adb
 @c -- Example: A |withing| unit has a |with| clause, it |withs| a |withed| unit
 
 @node The GNAT Compilation Model,Building Executable Programs with GNAT,Getting Started with GNAT,Top
-@anchor{gnat_ugn/the_gnat_compilation_model doc}@anchor{20}@anchor{gnat_ugn/the_gnat_compilation_model id1}@anchor{21}@anchor{gnat_ugn/the_gnat_compilation_model the-gnat-compilation-model}@anchor{9}
+@anchor{gnat_ugn/the_gnat_compilation_model doc}@anchor{21}@anchor{gnat_ugn/the_gnat_compilation_model id1}@anchor{22}@anchor{gnat_ugn/the_gnat_compilation_model the-gnat-compilation-model}@anchor{a}
 @chapter The GNAT Compilation Model
 
 
@@ -994,44 +1002,44 @@ Topics related to source file makeup and naming
 @itemize *
 
 @item 
-@ref{22,,Source Representation}
+@ref{23,,Source Representation}
 
 @item 
-@ref{23,,Foreign Language Representation}
+@ref{24,,Foreign Language Representation}
 
 @item 
-@ref{24,,File Naming Topics and Utilities}
+@ref{25,,File Naming Topics and Utilities}
 @end itemize
 
 @item 
-@ref{25,,Configuration Pragmas}
+@ref{26,,Configuration Pragmas}
 
 @item 
-@ref{26,,Generating Object Files}
+@ref{27,,Generating Object Files}
 
 @item 
-@ref{27,,Source Dependencies}
+@ref{28,,Source Dependencies}
 
 @item 
-@ref{28,,The Ada Library Information Files}
+@ref{29,,The Ada Library Information Files}
 
 @item 
-@ref{29,,Binding an Ada Program}
+@ref{2a,,Binding an Ada Program}
 
 @item 
-@ref{2a,,GNAT and Libraries}
+@ref{2b,,GNAT and Libraries}
 
 @item 
-@ref{2b,,Conditional Compilation}
+@ref{2c,,Conditional Compilation}
 
 @item 
-@ref{2c,,Mixed Language Programming}
+@ref{2d,,Mixed Language Programming}
 
 @item 
-@ref{2d,,GNAT and Other Compilation Models}
+@ref{2e,,GNAT and Other Compilation Models}
 
 @item 
-@ref{2e,,Using GNAT Files with External Tools}
+@ref{2f,,Using GNAT Files with External Tools}
 @end itemize
 
 @menu
@@ -1052,7 +1060,7 @@ Topics related to source file makeup and naming
 @end menu
 
 @node Source Representation,Foreign Language Representation,,The GNAT Compilation Model
-@anchor{gnat_ugn/the_gnat_compilation_model id2}@anchor{2f}@anchor{gnat_ugn/the_gnat_compilation_model source-representation}@anchor{22}
+@anchor{gnat_ugn/the_gnat_compilation_model id2}@anchor{30}@anchor{gnat_ugn/the_gnat_compilation_model source-representation}@anchor{23}
 @section Source Representation
 
 
@@ -1067,7 +1075,7 @@ Topics related to source file makeup and naming
 Ada source programs are represented in standard text files, using
 Latin-1 coding. Latin-1 is an 8-bit code that includes the familiar
 7-bit ASCII set plus additional characters used for
-representing foreign languages (see @ref{23,,Foreign Language Representation}
+representing foreign languages (see @ref{24,,Foreign Language Representation}
 for support of non-USA character sets). The format effector characters
 are represented using their standard ASCII encodings, as follows:
 
@@ -1178,13 +1186,13 @@ compilation units) is represented using a sequence of files. Similarly,
 you place each subunit or child unit in a separate file.
 
 @node Foreign Language Representation,File Naming Topics and Utilities,Source Representation,The GNAT Compilation Model
-@anchor{gnat_ugn/the_gnat_compilation_model foreign-language-representation}@anchor{23}@anchor{gnat_ugn/the_gnat_compilation_model id3}@anchor{30}
+@anchor{gnat_ugn/the_gnat_compilation_model foreign-language-representation}@anchor{24}@anchor{gnat_ugn/the_gnat_compilation_model id3}@anchor{31}
 @section Foreign Language Representation
 
 
 GNAT supports the standard character sets defined in Ada as well as
 several other non-standard character sets for use in localized versions
-of the compiler (@ref{31,,Character Set Control}).
+of the compiler (@ref{32,,Character Set Control}).
 
 @menu
 * Latin-1:: 
@@ -1195,7 +1203,7 @@ of the compiler (@ref{31,,Character Set Control}).
 @end menu
 
 @node Latin-1,Other 8-Bit Codes,,Foreign Language Representation
-@anchor{gnat_ugn/the_gnat_compilation_model id4}@anchor{32}@anchor{gnat_ugn/the_gnat_compilation_model latin-1}@anchor{33}
+@anchor{gnat_ugn/the_gnat_compilation_model id4}@anchor{33}@anchor{gnat_ugn/the_gnat_compilation_model latin-1}@anchor{34}
 @subsection Latin-1
 
 
@@ -1218,7 +1226,7 @@ string literals. In addition, the extended characters that represent
 letters can be used in identifiers.
 
 @node Other 8-Bit Codes,Wide_Character Encodings,Latin-1,Foreign Language Representation
-@anchor{gnat_ugn/the_gnat_compilation_model id5}@anchor{34}@anchor{gnat_ugn/the_gnat_compilation_model other-8-bit-codes}@anchor{35}
+@anchor{gnat_ugn/the_gnat_compilation_model id5}@anchor{35}@anchor{gnat_ugn/the_gnat_compilation_model other-8-bit-codes}@anchor{36}
 @subsection Other 8-Bit Codes
 
 
@@ -1335,7 +1343,7 @@ the GNAT compiler sources. You will need to obtain a full source release
 of GNAT to obtain this file.
 
 @node Wide_Character Encodings,Wide_Wide_Character Encodings,Other 8-Bit Codes,Foreign Language Representation
-@anchor{gnat_ugn/the_gnat_compilation_model id6}@anchor{36}@anchor{gnat_ugn/the_gnat_compilation_model wide-character-encodings}@anchor{37}
+@anchor{gnat_ugn/the_gnat_compilation_model id6}@anchor{37}@anchor{gnat_ugn/the_gnat_compilation_model wide-character-encodings}@anchor{38}
 @subsection Wide_Character Encodings
 
 
@@ -1457,7 +1465,7 @@ use of the upper half of the Latin-1 set.
 @end cartouche
 
 @node Wide_Wide_Character Encodings,,Wide_Character Encodings,Foreign Language Representation
-@anchor{gnat_ugn/the_gnat_compilation_model id7}@anchor{38}@anchor{gnat_ugn/the_gnat_compilation_model wide-wide-character-encodings}@anchor{39}
+@anchor{gnat_ugn/the_gnat_compilation_model id7}@anchor{39}@anchor{gnat_ugn/the_gnat_compilation_model wide-wide-character-encodings}@anchor{3a}
 @subsection Wide_Wide_Character Encodings
 
 
@@ -1509,7 +1517,7 @@ ACATS (Ada Conformity Assessment Test Suite) test suite distributions.
 @end table
 
 @node File Naming Topics and Utilities,Configuration Pragmas,Foreign Language Representation,The GNAT Compilation Model
-@anchor{gnat_ugn/the_gnat_compilation_model file-naming-topics-and-utilities}@anchor{24}@anchor{gnat_ugn/the_gnat_compilation_model id8}@anchor{3a}
+@anchor{gnat_ugn/the_gnat_compilation_model file-naming-topics-and-utilities}@anchor{25}@anchor{gnat_ugn/the_gnat_compilation_model id8}@anchor{3b}
 @section File Naming Topics and Utilities
 
 
@@ -1529,7 +1537,7 @@ contain.
 @end menu
 
 @node File Naming Rules,Using Other File Names,,File Naming Topics and Utilities
-@anchor{gnat_ugn/the_gnat_compilation_model file-naming-rules}@anchor{3b}@anchor{gnat_ugn/the_gnat_compilation_model id9}@anchor{3c}
+@anchor{gnat_ugn/the_gnat_compilation_model file-naming-rules}@anchor{3c}@anchor{gnat_ugn/the_gnat_compilation_model id9}@anchor{3d}
 @subsection File Naming Rules
 
 
@@ -1638,7 +1646,7 @@ unit names are long (for example, if child units or subunits are
 heavily nested). An option is available to shorten such long file names
 (called file name ‘krunching’). You may find this particularly useful when
 programs being developed with GNAT are to be used on operating systems
-with limited file name lengths. @ref{3d,,Using gnatkr}.
+with limited file name lengths. @ref{3e,,Using gnatkr}.
 
 Of course, no file shortening algorithm can guarantee uniqueness over
 all possible unit names; if file name krunching is used, it is your
@@ -1647,7 +1655,7 @@ can specify the exact file names that you want used, as described
 in the next section. Finally, if your Ada programs are migrating from a
 compiler with a different naming convention, you can use the @code{gnatchop}
 utility to produce source files that follow the GNAT naming conventions.
-(For details see @ref{1d,,Renaming Files with gnatchop}.)
+(For details see @ref{1e,,Renaming Files with gnatchop}.)
 
 Note: in the case of Windows or Mac OS operating systems, case is not
 significant. So, for example, on Windows if the canonical name is
@@ -1657,7 +1665,7 @@ if you want to use other than canonically cased file names on a Unix system,
 you need to follow the procedures described in the next section.
 
 @node Using Other File Names,Alternative File Naming Schemes,File Naming Rules,File Naming Topics and Utilities
-@anchor{gnat_ugn/the_gnat_compilation_model id10}@anchor{3e}@anchor{gnat_ugn/the_gnat_compilation_model using-other-file-names}@anchor{1c}
+@anchor{gnat_ugn/the_gnat_compilation_model id10}@anchor{3f}@anchor{gnat_ugn/the_gnat_compilation_model using-other-file-names}@anchor{1d}
 @subsection Using Other File Names
 
 
@@ -1695,7 +1703,7 @@ normally you will place it in the @code{gnat.adc}
 file used to hold configuration
 pragmas that apply to a complete compilation environment.
 For more details on how the @code{gnat.adc} file is created and used
-see @ref{3f,,Handling of Configuration Pragmas}.
+see @ref{40,,Handling of Configuration Pragmas}.
 
 @geindex gnat.adc
 
@@ -1717,7 +1725,7 @@ you must include it in the @code{gnatmake} command; it may not
 be omitted.
 
 @node Alternative File Naming Schemes,Handling Arbitrary File Naming Conventions with gnatname,Using Other File Names,File Naming Topics and Utilities
-@anchor{gnat_ugn/the_gnat_compilation_model alternative-file-naming-schemes}@anchor{40}@anchor{gnat_ugn/the_gnat_compilation_model id11}@anchor{41}
+@anchor{gnat_ugn/the_gnat_compilation_model alternative-file-naming-schemes}@anchor{41}@anchor{gnat_ugn/the_gnat_compilation_model id11}@anchor{42}
 @subsection Alternative File Naming Schemes
 
 
@@ -1859,7 +1867,7 @@ pragma Source_File_Name
 @geindex gnatname
 
 @node Handling Arbitrary File Naming Conventions with gnatname,File Name Krunching with gnatkr,Alternative File Naming Schemes,File Naming Topics and Utilities
-@anchor{gnat_ugn/the_gnat_compilation_model handling-arbitrary-file-naming-conventions-with-gnatname}@anchor{42}@anchor{gnat_ugn/the_gnat_compilation_model id12}@anchor{43}
+@anchor{gnat_ugn/the_gnat_compilation_model handling-arbitrary-file-naming-conventions-with-gnatname}@anchor{43}@anchor{gnat_ugn/the_gnat_compilation_model id12}@anchor{44}
 @subsection Handling Arbitrary File Naming Conventions with @code{gnatname}
 
 
@@ -1874,7 +1882,7 @@ pragma Source_File_Name
 @end menu
 
 @node Arbitrary File Naming Conventions,Running gnatname,,Handling Arbitrary File Naming Conventions with gnatname
-@anchor{gnat_ugn/the_gnat_compilation_model arbitrary-file-naming-conventions}@anchor{44}@anchor{gnat_ugn/the_gnat_compilation_model id13}@anchor{45}
+@anchor{gnat_ugn/the_gnat_compilation_model arbitrary-file-naming-conventions}@anchor{45}@anchor{gnat_ugn/the_gnat_compilation_model id13}@anchor{46}
 @subsubsection Arbitrary File Naming Conventions
 
 
@@ -1886,10 +1894,10 @@ does not need additional information.
 When the source file names do not follow the standard GNAT default
 file naming conventions, you must give the GNAT compiler additional
 information through a configuration pragmas file
-(@ref{25,,Configuration Pragmas}) or a project file.  When the
+(@ref{26,,Configuration Pragmas}) or a project file.  When the
 non-standard file naming conventions are well-defined, a small number
 of pragmas @code{Source_File_Name} specifying a naming pattern
-(@ref{40,,Alternative File Naming Schemes}) may be sufficient. However,
+(@ref{41,,Alternative File Naming Schemes}) may be sufficient. However,
 if the file naming conventions are irregular or arbitrary, you must
 define a number of pragma @code{Source_File_Name} for individual
 compilation units.  To help maintain the correspondence between
@@ -1898,7 +1906,7 @@ provides a tool @code{gnatname} to generate the required pragmas for a
 set of files.
 
 @node Running gnatname,Switches for gnatname,Arbitrary File Naming Conventions,Handling Arbitrary File Naming Conventions with gnatname
-@anchor{gnat_ugn/the_gnat_compilation_model id14}@anchor{46}@anchor{gnat_ugn/the_gnat_compilation_model running-gnatname}@anchor{47}
+@anchor{gnat_ugn/the_gnat_compilation_model id14}@anchor{47}@anchor{gnat_ugn/the_gnat_compilation_model running-gnatname}@anchor{48}
 @subsubsection Running @code{gnatname}
 
 
@@ -1950,7 +1958,7 @@ with pragmas @code{Source_File_Name} for each file that contains a valid Ada
 unit.
 
 @node Switches for gnatname,Examples of gnatname Usage,Running gnatname,Handling Arbitrary File Naming Conventions with gnatname
-@anchor{gnat_ugn/the_gnat_compilation_model id15}@anchor{48}@anchor{gnat_ugn/the_gnat_compilation_model switches-for-gnatname}@anchor{49}
+@anchor{gnat_ugn/the_gnat_compilation_model id15}@anchor{49}@anchor{gnat_ugn/the_gnat_compilation_model switches-for-gnatname}@anchor{4a}
 @subsubsection Switches for @code{gnatname}
 
 
@@ -2141,7 +2149,7 @@ except those whose names end with @code{_nt.ada}.
 @end table
 
 @node Examples of gnatname Usage,,Switches for gnatname,Handling Arbitrary File Naming Conventions with gnatname
-@anchor{gnat_ugn/the_gnat_compilation_model examples-of-gnatname-usage}@anchor{4a}@anchor{gnat_ugn/the_gnat_compilation_model id16}@anchor{4b}
+@anchor{gnat_ugn/the_gnat_compilation_model examples-of-gnatname-usage}@anchor{4b}@anchor{gnat_ugn/the_gnat_compilation_model id16}@anchor{4c}
 @subsubsection Examples of @code{gnatname} Usage
 
 
@@ -2166,7 +2174,7 @@ conjunction with one or several @code{-D} switches. This example
 illustrates multiple Naming Patterns and one excluded pattern.
 
 @node File Name Krunching with gnatkr,Renaming Files with gnatchop,Handling Arbitrary File Naming Conventions with gnatname,File Naming Topics and Utilities
-@anchor{gnat_ugn/the_gnat_compilation_model file-name-krunching-with-gnatkr}@anchor{4c}@anchor{gnat_ugn/the_gnat_compilation_model id17}@anchor{4d}
+@anchor{gnat_ugn/the_gnat_compilation_model file-name-krunching-with-gnatkr}@anchor{4d}@anchor{gnat_ugn/the_gnat_compilation_model id17}@anchor{4e}
 @subsection File Name Krunching with @code{gnatkr}
 
 
@@ -2187,7 +2195,7 @@ applying this shortening.
 @end menu
 
 @node About gnatkr,Using gnatkr,,File Name Krunching with gnatkr
-@anchor{gnat_ugn/the_gnat_compilation_model about-gnatkr}@anchor{4e}@anchor{gnat_ugn/the_gnat_compilation_model id18}@anchor{4f}
+@anchor{gnat_ugn/the_gnat_compilation_model about-gnatkr}@anchor{4f}@anchor{gnat_ugn/the_gnat_compilation_model id18}@anchor{50}
 @subsubsection About @code{gnatkr}
 
 
@@ -2224,7 +2232,7 @@ You can use the @code{gnatkr} utility to determine the krunched name for
 a given file when krunched to a specified maximum length.
 
 @node Using gnatkr,Krunching Method,About gnatkr,File Name Krunching with gnatkr
-@anchor{gnat_ugn/the_gnat_compilation_model id19}@anchor{50}@anchor{gnat_ugn/the_gnat_compilation_model using-gnatkr}@anchor{3d}
+@anchor{gnat_ugn/the_gnat_compilation_model id19}@anchor{51}@anchor{gnat_ugn/the_gnat_compilation_model using-gnatkr}@anchor{3e}
 @subsubsection Using @code{gnatkr}
 
 
@@ -2262,7 +2270,7 @@ The output is the krunched name. The output has an extension only if the
 original argument was a file name with an extension.
 
 @node Krunching Method,Examples of gnatkr Usage,Using gnatkr,File Name Krunching with gnatkr
-@anchor{gnat_ugn/the_gnat_compilation_model id20}@anchor{51}@anchor{gnat_ugn/the_gnat_compilation_model krunching-method}@anchor{52}
+@anchor{gnat_ugn/the_gnat_compilation_model id20}@anchor{52}@anchor{gnat_ugn/the_gnat_compilation_model krunching-method}@anchor{53}
 @subsubsection Krunching Method
 
 
@@ -2392,7 +2400,7 @@ program @code{gnatkr} is supplied so that you can conveniently determine the
 krunched name of a file.
 
 @node Examples of gnatkr Usage,,Krunching Method,File Name Krunching with gnatkr
-@anchor{gnat_ugn/the_gnat_compilation_model examples-of-gnatkr-usage}@anchor{53}@anchor{gnat_ugn/the_gnat_compilation_model id21}@anchor{54}
+@anchor{gnat_ugn/the_gnat_compilation_model examples-of-gnatkr-usage}@anchor{54}@anchor{gnat_ugn/the_gnat_compilation_model id21}@anchor{55}
 @subsubsection Examples of @code{gnatkr} Usage
 
 
@@ -2406,7 +2414,7 @@ $ gnatkr very_long_unit_name.ads/count=0 --> very_long_unit_name.ads
 @end example
 
 @node Renaming Files with gnatchop,,File Name Krunching with gnatkr,File Naming Topics and Utilities
-@anchor{gnat_ugn/the_gnat_compilation_model id22}@anchor{55}@anchor{gnat_ugn/the_gnat_compilation_model renaming-files-with-gnatchop}@anchor{1d}
+@anchor{gnat_ugn/the_gnat_compilation_model id22}@anchor{56}@anchor{gnat_ugn/the_gnat_compilation_model renaming-files-with-gnatchop}@anchor{1e}
 @subsection Renaming Files with @code{gnatchop}
 
 
@@ -2426,7 +2434,7 @@ files to meet the standard GNAT default file naming conventions.
 @end menu
 
 @node Handling Files with Multiple Units,Operating gnatchop in Compilation Mode,,Renaming Files with gnatchop
-@anchor{gnat_ugn/the_gnat_compilation_model handling-files-with-multiple-units}@anchor{56}@anchor{gnat_ugn/the_gnat_compilation_model id23}@anchor{57}
+@anchor{gnat_ugn/the_gnat_compilation_model handling-files-with-multiple-units}@anchor{57}@anchor{gnat_ugn/the_gnat_compilation_model id23}@anchor{58}
 @subsubsection Handling Files with Multiple Units
 
 
@@ -2439,7 +2447,7 @@ perhaps to maintain compatibility with some other Ada compilation system,
 you can use @code{gnatname} to generate or update your project files, which
 can be processed by GNAT.
 
-See @ref{42,,Handling Arbitrary File Naming Conventions with gnatname}
+See @ref{43,,Handling Arbitrary File Naming Conventions with gnatname}
 for more details on how to use @cite{gnatname}.
 
 Alternatively, if you want to permanently restructure a set of
@@ -2454,7 +2462,7 @@ will start with a copy of this BOM, meaning that they can be compiled
 automatically in UTF-8 mode without you needing to specify an explicit encoding.
 
 @node Operating gnatchop in Compilation Mode,Command Line for gnatchop,Handling Files with Multiple Units,Renaming Files with gnatchop
-@anchor{gnat_ugn/the_gnat_compilation_model id24}@anchor{58}@anchor{gnat_ugn/the_gnat_compilation_model operating-gnatchop-in-compilation-mode}@anchor{59}
+@anchor{gnat_ugn/the_gnat_compilation_model id24}@anchor{59}@anchor{gnat_ugn/the_gnat_compilation_model operating-gnatchop-in-compilation-mode}@anchor{5a}
 @subsubsection Operating gnatchop in Compilation Mode
 
 
@@ -2487,7 +2495,7 @@ should apply to all subsequent compilations in the same compilation
 environment. Using GNAT, the current directory, possibly containing a
 @code{gnat.adc} file is the representation
 of a compilation environment. For more information on the
-@code{gnat.adc} file, see @ref{3f,,Handling of Configuration Pragmas}.
+@code{gnat.adc} file, see @ref{40,,Handling of Configuration Pragmas}.
 
 Second, in compilation mode, if you give @code{gnatchop} a file that
 starts with configuration pragmas and contains one or more units, then
@@ -2513,7 +2521,7 @@ switch provides the required behavior. This is the mode
 in which GNAT processes the ACVC tests.
 
 @node Command Line for gnatchop,Switches for gnatchop,Operating gnatchop in Compilation Mode,Renaming Files with gnatchop
-@anchor{gnat_ugn/the_gnat_compilation_model command-line-for-gnatchop}@anchor{5a}@anchor{gnat_ugn/the_gnat_compilation_model id25}@anchor{5b}
+@anchor{gnat_ugn/the_gnat_compilation_model command-line-for-gnatchop}@anchor{5b}@anchor{gnat_ugn/the_gnat_compilation_model id25}@anchor{5c}
 @subsubsection Command Line for @code{gnatchop}
 
 
@@ -2587,7 +2595,7 @@ no source files written
 @end example
 
 @node Switches for gnatchop,Examples of gnatchop Usage,Command Line for gnatchop,Renaming Files with gnatchop
-@anchor{gnat_ugn/the_gnat_compilation_model id26}@anchor{5c}@anchor{gnat_ugn/the_gnat_compilation_model switches-for-gnatchop}@anchor{5d}
+@anchor{gnat_ugn/the_gnat_compilation_model id26}@anchor{5d}@anchor{gnat_ugn/the_gnat_compilation_model switches-for-gnatchop}@anchor{5e}
 @subsubsection Switches for @code{gnatchop}
 
 
@@ -2751,7 +2759,7 @@ so it must include the full pathname.
 @end table
 
 @node Examples of gnatchop Usage,,Switches for gnatchop,Renaming Files with gnatchop
-@anchor{gnat_ugn/the_gnat_compilation_model examples-of-gnatchop-usage}@anchor{5e}@anchor{gnat_ugn/the_gnat_compilation_model id27}@anchor{5f}
+@anchor{gnat_ugn/the_gnat_compilation_model examples-of-gnatchop-usage}@anchor{5f}@anchor{gnat_ugn/the_gnat_compilation_model id27}@anchor{60}
 @subsubsection Examples of @code{gnatchop} Usage
 
 
@@ -2792,7 +2800,7 @@ output and @code{gnatchop} will skip earlier duplicate occurrences for
 the same unit.
 
 @node Configuration Pragmas,Generating Object Files,File Naming Topics and Utilities,The GNAT Compilation Model
-@anchor{gnat_ugn/the_gnat_compilation_model configuration-pragmas}@anchor{25}@anchor{gnat_ugn/the_gnat_compilation_model id28}@anchor{60}
+@anchor{gnat_ugn/the_gnat_compilation_model configuration-pragmas}@anchor{26}@anchor{gnat_ugn/the_gnat_compilation_model id28}@anchor{61}
 @section Configuration Pragmas
 
 
@@ -2895,7 +2903,7 @@ Wide_Character_Encoding
 @end menu
 
 @node Handling of Configuration Pragmas,The Configuration Pragmas Files,,Configuration Pragmas
-@anchor{gnat_ugn/the_gnat_compilation_model handling-of-configuration-pragmas}@anchor{3f}@anchor{gnat_ugn/the_gnat_compilation_model id29}@anchor{61}
+@anchor{gnat_ugn/the_gnat_compilation_model handling-of-configuration-pragmas}@anchor{40}@anchor{gnat_ugn/the_gnat_compilation_model id29}@anchor{62}
 @subsection Handling of Configuration Pragmas
 
 
@@ -2906,7 +2914,7 @@ all compilations performed in a given compilation environment.
 GNAT includes the @code{gnatchop} utility to provide an automatic
 way to handle configuration pragmas that follows the semantics for
 compilations (that is, files with multiple units) described in the RM.
-See @ref{59,,Operating gnatchop in Compilation Mode} for details.
+See @ref{5a,,Operating gnatchop in Compilation Mode} for details.
 However, for most purposes, you will find it more convenient to edit the
 @code{gnat.adc} file that contains configuration pragmas directly,
 as described in the following section.
@@ -2937,7 +2945,7 @@ applies to all the relevant units). You can place it on a subunit only if
 you have previously placed it in the body of spec.
 
 @node The Configuration Pragmas Files,,Handling of Configuration Pragmas,Configuration Pragmas
-@anchor{gnat_ugn/the_gnat_compilation_model id30}@anchor{62}@anchor{gnat_ugn/the_gnat_compilation_model the-configuration-pragmas-files}@anchor{63}
+@anchor{gnat_ugn/the_gnat_compilation_model id30}@anchor{63}@anchor{gnat_ugn/the_gnat_compilation_model the-configuration-pragmas-files}@anchor{64}
 @subsection The Configuration Pragmas Files
 
 
@@ -2988,7 +2996,7 @@ project attributes.
 @c See :ref:`Specifying_Configuration_Pragmas` for more details.
 
 @node Generating Object Files,Source Dependencies,Configuration Pragmas,The GNAT Compilation Model
-@anchor{gnat_ugn/the_gnat_compilation_model generating-object-files}@anchor{26}@anchor{gnat_ugn/the_gnat_compilation_model id31}@anchor{64}
+@anchor{gnat_ugn/the_gnat_compilation_model generating-object-files}@anchor{27}@anchor{gnat_ugn/the_gnat_compilation_model id31}@anchor{65}
 @section Generating Object Files
 
 
@@ -3062,7 +3070,7 @@ part of the process of building a program. To compile a file in this
 checking mode, use the @code{-gnatc} switch.
 
 @node Source Dependencies,The Ada Library Information Files,Generating Object Files,The GNAT Compilation Model
-@anchor{gnat_ugn/the_gnat_compilation_model id32}@anchor{65}@anchor{gnat_ugn/the_gnat_compilation_model source-dependencies}@anchor{27}
+@anchor{gnat_ugn/the_gnat_compilation_model id32}@anchor{66}@anchor{gnat_ugn/the_gnat_compilation_model source-dependencies}@anchor{28}
 @section Source Dependencies
 
 
@@ -3156,7 +3164,7 @@ the necessary recompilations.
 @end itemize
 
 @node The Ada Library Information Files,Binding an Ada Program,Source Dependencies,The GNAT Compilation Model
-@anchor{gnat_ugn/the_gnat_compilation_model id33}@anchor{66}@anchor{gnat_ugn/the_gnat_compilation_model the-ada-library-information-files}@anchor{28}
+@anchor{gnat_ugn/the_gnat_compilation_model id33}@anchor{67}@anchor{gnat_ugn/the_gnat_compilation_model the-ada-library-information-files}@anchor{29}
 @section The Ada Library Information Files
 
 
@@ -3224,7 +3232,7 @@ see the source of the body of unit @code{Lib.Writ}, contained in file
 @code{lib-writ.adb} in the GNAT compiler sources.
 
 @node Binding an Ada Program,GNAT and Libraries,The Ada Library Information Files,The GNAT Compilation Model
-@anchor{gnat_ugn/the_gnat_compilation_model binding-an-ada-program}@anchor{29}@anchor{gnat_ugn/the_gnat_compilation_model id34}@anchor{67}
+@anchor{gnat_ugn/the_gnat_compilation_model binding-an-ada-program}@anchor{2a}@anchor{gnat_ugn/the_gnat_compilation_model id34}@anchor{68}
 @section Binding an Ada Program
 
 
@@ -3260,7 +3268,7 @@ using the object from the main program from the bind step as well as the
 object files for the Ada units of the program.
 
 @node GNAT and Libraries,Conditional Compilation,Binding an Ada Program,The GNAT Compilation Model
-@anchor{gnat_ugn/the_gnat_compilation_model gnat-and-libraries}@anchor{2a}@anchor{gnat_ugn/the_gnat_compilation_model id35}@anchor{68}
+@anchor{gnat_ugn/the_gnat_compilation_model gnat-and-libraries}@anchor{2b}@anchor{gnat_ugn/the_gnat_compilation_model id35}@anchor{69}
 @section GNAT and Libraries
 
 
@@ -3280,7 +3288,7 @@ Project Manager facility (see the `GNAT_Project_Manager' chapter of the
 @end menu
 
 @node Introduction to Libraries in GNAT,General Ada Libraries,,GNAT and Libraries
-@anchor{gnat_ugn/the_gnat_compilation_model id36}@anchor{69}@anchor{gnat_ugn/the_gnat_compilation_model introduction-to-libraries-in-gnat}@anchor{6a}
+@anchor{gnat_ugn/the_gnat_compilation_model id36}@anchor{6a}@anchor{gnat_ugn/the_gnat_compilation_model introduction-to-libraries-in-gnat}@anchor{6b}
 @subsection Introduction to Libraries in GNAT
 
 
@@ -3307,7 +3315,7 @@ In the GNAT environment, a library has these components:
 Source files,
 
 @item 
-@code{ALI} files (see @ref{28,,The Ada Library Information Files}), and
+@code{ALI} files (see @ref{29,,The Ada Library Information Files}), and
 
 @item 
 Object files, an archive, or a shared library.
@@ -3319,7 +3327,7 @@ an external user to make use of the library, in other words, the specs
 reflecting the library services along with all the units needed to compile
 those specs, which can include generic bodies or any body implementing an
 inlined routine. In the case of `stand-alone libraries' those exposed
-units are called `interface units' (@ref{6b,,Stand-alone Ada Libraries}).
+units are called `interface units' (@ref{6c,,Stand-alone Ada Libraries}).
 
 All compilation units comprising an application, including those in a library,
 need to be elaborated in an order partially defined by Ada’s semantics. GNAT
@@ -3330,7 +3338,7 @@ library elaboration routine is produced independently of the application(s)
 using the library.
 
 @node General Ada Libraries,Stand-alone Ada Libraries,Introduction to Libraries in GNAT,GNAT and Libraries
-@anchor{gnat_ugn/the_gnat_compilation_model general-ada-libraries}@anchor{6c}@anchor{gnat_ugn/the_gnat_compilation_model id37}@anchor{6d}
+@anchor{gnat_ugn/the_gnat_compilation_model general-ada-libraries}@anchor{6d}@anchor{gnat_ugn/the_gnat_compilation_model id37}@anchor{6e}
 @subsection General Ada Libraries
 
 
@@ -3342,7 +3350,7 @@ using the library.
 @end menu
 
 @node Building a library,Installing a library,,General Ada Libraries
-@anchor{gnat_ugn/the_gnat_compilation_model building-a-library}@anchor{6e}@anchor{gnat_ugn/the_gnat_compilation_model id38}@anchor{6f}
+@anchor{gnat_ugn/the_gnat_compilation_model building-a-library}@anchor{6f}@anchor{gnat_ugn/the_gnat_compilation_model id38}@anchor{70}
 @subsubsection Building a library
 
 
@@ -3425,7 +3433,7 @@ steps below.
 
 There are various possibilities for compiling the units that make up
 the library: for example with a @code{Makefile}
-(@ref{70,,Using the GNU make Utility}) or with a conventional script. For
+(@ref{71,,Using the GNU make Utility}) or with a conventional script. For
 simple libraries, you can also create a dummy main program
 that depends upon all the packages that comprise the interface of the
 library. You can then pass this dummy main program to @code{gnatmake},
@@ -3476,7 +3484,7 @@ or @code{lib`xxx'.so} (or @code{lib`xxx'.dll} on Windows) in order to
 be accessed by the @code{-l`xxx'} switch at link time.
 
 @node Installing a library,Using a library,Building a library,General Ada Libraries
-@anchor{gnat_ugn/the_gnat_compilation_model id39}@anchor{71}@anchor{gnat_ugn/the_gnat_compilation_model installing-a-library}@anchor{72}
+@anchor{gnat_ugn/the_gnat_compilation_model id39}@anchor{72}@anchor{gnat_ugn/the_gnat_compilation_model installing-a-library}@anchor{73}
 @subsubsection Installing a library
 
 
@@ -3491,7 +3499,7 @@ process (see the `Installing a Library with Project Files' section of the
 When you’re not able to use project files for some reason, you can
 also install the library so that the sources needed to use the library
 are on the Ada source path and the ALI files & libraries be on the Ada
-Object path (see @ref{73,,Search Paths and the Run-Time Library (RTL)}),
+Object path (see @ref{74,,Search Paths and the Run-Time Library (RTL)}),
 but we don’t recommend doing this.  Alternatively, the system
 administrator can place general-purpose libraries in the default
 compiler paths, by specifying the libraries’ location in the
@@ -3535,7 +3543,7 @@ general, a library must be installed before the GNAT library if it
 redefines any part of it.
 
 @node Using a library,,Installing a library,General Ada Libraries
-@anchor{gnat_ugn/the_gnat_compilation_model id40}@anchor{74}@anchor{gnat_ugn/the_gnat_compilation_model using-a-library}@anchor{75}
+@anchor{gnat_ugn/the_gnat_compilation_model id40}@anchor{75}@anchor{gnat_ugn/the_gnat_compilation_model using-a-library}@anchor{76}
 @subsubsection Using a library
 
 
@@ -3574,8 +3582,8 @@ left to the tools having visibility over project dependence information.
 
 In order to use an Ada library manually, you need to make sure that this
 library is on both your source and object path
-(see @ref{73,,Search Paths and the Run-Time Library (RTL)}
-and @ref{76,,Search Paths for gnatbind}). Furthermore, when the objects are grouped
+(see @ref{74,,Search Paths and the Run-Time Library (RTL)}
+and @ref{77,,Search Paths for gnatbind}). Furthermore, when the objects are grouped
 in an archive or a shared library, you need to specify the desired
 library at link time.
 
@@ -3629,7 +3637,7 @@ in the directory @code{share/examples/gnat/plugins} within the GNAT
 install area.
 
 @node Stand-alone Ada Libraries,Rebuilding the GNAT Run-Time Library,General Ada Libraries,GNAT and Libraries
-@anchor{gnat_ugn/the_gnat_compilation_model id41}@anchor{77}@anchor{gnat_ugn/the_gnat_compilation_model stand-alone-ada-libraries}@anchor{6b}
+@anchor{gnat_ugn/the_gnat_compilation_model id41}@anchor{78}@anchor{gnat_ugn/the_gnat_compilation_model stand-alone-ada-libraries}@anchor{6c}
 @subsection Stand-alone Ada Libraries
 
 
@@ -3644,7 +3652,7 @@ install area.
 @end menu
 
 @node Introduction to Stand-alone Libraries,Building a Stand-alone Library,,Stand-alone Ada Libraries
-@anchor{gnat_ugn/the_gnat_compilation_model id42}@anchor{78}@anchor{gnat_ugn/the_gnat_compilation_model introduction-to-stand-alone-libraries}@anchor{79}
+@anchor{gnat_ugn/the_gnat_compilation_model id42}@anchor{79}@anchor{gnat_ugn/the_gnat_compilation_model introduction-to-stand-alone-libraries}@anchor{7a}
 @subsubsection Introduction to Stand-alone Libraries
 
 
@@ -3676,7 +3684,7 @@ Stand-alone libraries are also well suited to be used in an executable whose
 main routine is not written in Ada.
 
 @node Building a Stand-alone Library,Creating a Stand-alone Library to be used in a non-Ada context,Introduction to Stand-alone Libraries,Stand-alone Ada Libraries
-@anchor{gnat_ugn/the_gnat_compilation_model building-a-stand-alone-library}@anchor{7a}@anchor{gnat_ugn/the_gnat_compilation_model id43}@anchor{7b}
+@anchor{gnat_ugn/the_gnat_compilation_model building-a-stand-alone-library}@anchor{7b}@anchor{gnat_ugn/the_gnat_compilation_model id43}@anchor{7c}
 @subsubsection Building a Stand-alone Library
 
 
@@ -3796,10 +3804,10 @@ read-only.
 @end itemize
 
 Using SALs is not different from using other libraries
-(see @ref{75,,Using a library}).
+(see @ref{76,,Using a library}).
 
 @node Creating a Stand-alone Library to be used in a non-Ada context,Restrictions in Stand-alone Libraries,Building a Stand-alone Library,Stand-alone Ada Libraries
-@anchor{gnat_ugn/the_gnat_compilation_model creating-a-stand-alone-library-to-be-used-in-a-non-ada-context}@anchor{7c}@anchor{gnat_ugn/the_gnat_compilation_model id44}@anchor{7d}
+@anchor{gnat_ugn/the_gnat_compilation_model creating-a-stand-alone-library-to-be-used-in-a-non-ada-context}@anchor{7d}@anchor{gnat_ugn/the_gnat_compilation_model id44}@anchor{7e}
 @subsubsection Creating a Stand-alone Library to be used in a non-Ada context
 
 
@@ -3878,7 +3886,7 @@ No call to these libraries or to the Ada run-time library should be made
 after the finalization phase.
 
 Information on limitations of binding Ada code in non-Ada contexts can be
-found under @ref{7e,,Binding with Non-Ada Main Programs}.
+found under @ref{7f,,Binding with Non-Ada Main Programs}.
 
 Note also that you must take special care with multi-tasking
 applications. In that case, the initialization and finalization
@@ -3888,7 +3896,7 @@ using a specific operating system services like a mutex or a
 critical-section.
 
 @node Restrictions in Stand-alone Libraries,,Creating a Stand-alone Library to be used in a non-Ada context,Stand-alone Ada Libraries
-@anchor{gnat_ugn/the_gnat_compilation_model id45}@anchor{7f}@anchor{gnat_ugn/the_gnat_compilation_model restrictions-in-stand-alone-libraries}@anchor{80}
+@anchor{gnat_ugn/the_gnat_compilation_model id45}@anchor{80}@anchor{gnat_ugn/the_gnat_compilation_model restrictions-in-stand-alone-libraries}@anchor{81}
 @subsubsection Restrictions in Stand-alone Libraries
 
 
@@ -3933,7 +3941,7 @@ In practice these attributes are rarely used, so this is unlikely
 to be a consideration.
 
 @node Rebuilding the GNAT Run-Time Library,,Stand-alone Ada Libraries,GNAT and Libraries
-@anchor{gnat_ugn/the_gnat_compilation_model id46}@anchor{81}@anchor{gnat_ugn/the_gnat_compilation_model rebuilding-the-gnat-run-time-library}@anchor{82}
+@anchor{gnat_ugn/the_gnat_compilation_model id46}@anchor{82}@anchor{gnat_ugn/the_gnat_compilation_model rebuilding-the-gnat-run-time-library}@anchor{83}
 @subsection Rebuilding the GNAT Run-Time Library
 
 
@@ -3970,7 +3978,7 @@ experiments or debugging and is not supported for other purposes.
 @geindex Conditional compilation
 
 @node Conditional Compilation,Mixed Language Programming,GNAT and Libraries,The GNAT Compilation Model
-@anchor{gnat_ugn/the_gnat_compilation_model conditional-compilation}@anchor{2b}@anchor{gnat_ugn/the_gnat_compilation_model id47}@anchor{83}
+@anchor{gnat_ugn/the_gnat_compilation_model conditional-compilation}@anchor{2c}@anchor{gnat_ugn/the_gnat_compilation_model id47}@anchor{84}
 @section Conditional Compilation
 
 
@@ -3987,7 +3995,7 @@ gnatprep preprocessor utility.
 @end menu
 
 @node Modeling Conditional Compilation in Ada,Preprocessing with gnatprep,,Conditional Compilation
-@anchor{gnat_ugn/the_gnat_compilation_model id48}@anchor{84}@anchor{gnat_ugn/the_gnat_compilation_model modeling-conditional-compilation-in-ada}@anchor{85}
+@anchor{gnat_ugn/the_gnat_compilation_model id48}@anchor{85}@anchor{gnat_ugn/the_gnat_compilation_model modeling-conditional-compilation-in-ada}@anchor{86}
 @subsection Modeling Conditional Compilation in Ada
 
 
@@ -4038,7 +4046,7 @@ be achieved using Ada in general and GNAT in particular.
 @end menu
 
 @node Use of Boolean Constants,Debugging - A Special Case,,Modeling Conditional Compilation in Ada
-@anchor{gnat_ugn/the_gnat_compilation_model id49}@anchor{86}@anchor{gnat_ugn/the_gnat_compilation_model use-of-boolean-constants}@anchor{87}
+@anchor{gnat_ugn/the_gnat_compilation_model id49}@anchor{87}@anchor{gnat_ugn/the_gnat_compilation_model use-of-boolean-constants}@anchor{88}
 @subsubsection Use of Boolean Constants
 
 
@@ -4082,7 +4090,7 @@ Then, any other unit requiring conditional compilation can do a `with'
 of @code{Config} to make the constants visible.
 
 @node Debugging - A Special Case,Conditionalizing Declarations,Use of Boolean Constants,Modeling Conditional Compilation in Ada
-@anchor{gnat_ugn/the_gnat_compilation_model debugging-a-special-case}@anchor{88}@anchor{gnat_ugn/the_gnat_compilation_model id50}@anchor{89}
+@anchor{gnat_ugn/the_gnat_compilation_model debugging-a-special-case}@anchor{89}@anchor{gnat_ugn/the_gnat_compilation_model id50}@anchor{8a}
 @subsubsection Debugging - A Special Case
 
 
@@ -4195,7 +4203,7 @@ end if;
 @end example
 
 @node Conditionalizing Declarations,Use of Alternative Implementations,Debugging - A Special Case,Modeling Conditional Compilation in Ada
-@anchor{gnat_ugn/the_gnat_compilation_model conditionalizing-declarations}@anchor{8a}@anchor{gnat_ugn/the_gnat_compilation_model id51}@anchor{8b}
+@anchor{gnat_ugn/the_gnat_compilation_model conditionalizing-declarations}@anchor{8b}@anchor{gnat_ugn/the_gnat_compilation_model id51}@anchor{8c}
 @subsubsection Conditionalizing Declarations
 
 
@@ -4260,7 +4268,7 @@ constant was introduced as @code{System.Default_Bit_Order}, so you don’t
 need to define this one yourself).
 
 @node Use of Alternative Implementations,Preprocessing,Conditionalizing Declarations,Modeling Conditional Compilation in Ada
-@anchor{gnat_ugn/the_gnat_compilation_model id52}@anchor{8c}@anchor{gnat_ugn/the_gnat_compilation_model use-of-alternative-implementations}@anchor{8d}
+@anchor{gnat_ugn/the_gnat_compilation_model id52}@anchor{8d}@anchor{gnat_ugn/the_gnat_compilation_model use-of-alternative-implementations}@anchor{8e}
 @subsubsection Use of Alternative Implementations
 
 
@@ -4392,7 +4400,7 @@ program.  The same idea can also be implemented using tagged types and
 dispatching calls.
 
 @node Preprocessing,,Use of Alternative Implementations,Modeling Conditional Compilation in Ada
-@anchor{gnat_ugn/the_gnat_compilation_model id53}@anchor{8e}@anchor{gnat_ugn/the_gnat_compilation_model preprocessing}@anchor{8f}
+@anchor{gnat_ugn/the_gnat_compilation_model id53}@anchor{8f}@anchor{gnat_ugn/the_gnat_compilation_model preprocessing}@anchor{90}
 @subsubsection Preprocessing
 
 
@@ -4415,7 +4423,7 @@ You can use the preprocessor used in two different modes. You can use it
 separately from the compiler to generate a separate output source file,
 which you then feed to the compiler as a separate step. This is the
 @code{gnatprep} utility, whose use is fully described in
-@ref{90,,Preprocessing with gnatprep}.
+@ref{91,,Preprocessing with gnatprep}.
 
 The preprocessing language allows such constructs as
 
@@ -4435,10 +4443,10 @@ often more convenient. In this approach, the preprocessing is integrated into
 the compilation process. You pass the compiler the preprocessor input, which
 includes @code{#if} lines etc, and the compiler carries out the
 preprocessing internally and compiles the resulting output.
-For more details on this approach, see @ref{91,,Integrated Preprocessing}.
+For more details on this approach, see @ref{92,,Integrated Preprocessing}.
 
 @node Preprocessing with gnatprep,Integrated Preprocessing,Modeling Conditional Compilation in Ada,Conditional Compilation
-@anchor{gnat_ugn/the_gnat_compilation_model id54}@anchor{92}@anchor{gnat_ugn/the_gnat_compilation_model preprocessing-with-gnatprep}@anchor{90}
+@anchor{gnat_ugn/the_gnat_compilation_model id54}@anchor{93}@anchor{gnat_ugn/the_gnat_compilation_model preprocessing-with-gnatprep}@anchor{91}
 @subsection Preprocessing with @code{gnatprep}
 
 
@@ -4450,7 +4458,7 @@ This section discusses how to you can use GNAT’s @code{gnatprep} utility
 for simple preprocessing.  Although designed for use with GNAT,
 @code{gnatprep} does not depend on any special GNAT features.  For
 further discussion of conditional compilation in general, see
-@ref{2b,,Conditional Compilation}.
+@ref{2c,,Conditional Compilation}.
 
 @menu
 * Preprocessing Symbols:: 
@@ -4462,7 +4470,7 @@ further discussion of conditional compilation in general, see
 @end menu
 
 @node Preprocessing Symbols,Using gnatprep,,Preprocessing with gnatprep
-@anchor{gnat_ugn/the_gnat_compilation_model id55}@anchor{93}@anchor{gnat_ugn/the_gnat_compilation_model preprocessing-symbols}@anchor{94}
+@anchor{gnat_ugn/the_gnat_compilation_model id55}@anchor{94}@anchor{gnat_ugn/the_gnat_compilation_model preprocessing-symbols}@anchor{95}
 @subsubsection Preprocessing Symbols
 
 
@@ -4472,7 +4480,7 @@ normal Ada (case-insensitive) rules for its syntax, with the restriction that
 all characters need to be in the ASCII set (no accented letters).
 
 @node Using gnatprep,Switches for gnatprep,Preprocessing Symbols,Preprocessing with gnatprep
-@anchor{gnat_ugn/the_gnat_compilation_model id56}@anchor{95}@anchor{gnat_ugn/the_gnat_compilation_model using-gnatprep}@anchor{96}
+@anchor{gnat_ugn/the_gnat_compilation_model id56}@anchor{96}@anchor{gnat_ugn/the_gnat_compilation_model using-gnatprep}@anchor{97}
 @subsubsection Using @code{gnatprep}
 
 
@@ -4530,7 +4538,7 @@ can omit this argument and instead use the @code{-D} switch.
 @end itemize
 
 @node Switches for gnatprep,Form of Definitions File,Using gnatprep,Preprocessing with gnatprep
-@anchor{gnat_ugn/the_gnat_compilation_model id57}@anchor{97}@anchor{gnat_ugn/the_gnat_compilation_model switches-for-gnatprep}@anchor{98}
+@anchor{gnat_ugn/the_gnat_compilation_model id57}@anchor{98}@anchor{gnat_ugn/the_gnat_compilation_model switches-for-gnatprep}@anchor{99}
 @subsubsection Switches for @code{gnatprep}
 
 
@@ -4682,7 +4690,7 @@ deleted lines are completely removed from the output, unless you specify
 @code{-r}, in which case @code{gnatprep} enables the @code{-b} switch.
 
 @node Form of Definitions File,Form of Input Text for gnatprep,Switches for gnatprep,Preprocessing with gnatprep
-@anchor{gnat_ugn/the_gnat_compilation_model form-of-definitions-file}@anchor{99}@anchor{gnat_ugn/the_gnat_compilation_model id58}@anchor{9a}
+@anchor{gnat_ugn/the_gnat_compilation_model form-of-definitions-file}@anchor{9a}@anchor{gnat_ugn/the_gnat_compilation_model id58}@anchor{9b}
 @subsubsection Form of Definitions File
 
 
@@ -4712,7 +4720,7 @@ the usual @code{--}
 and comments may be added to the end of each definition line.
 
 @node Form of Input Text for gnatprep,,Form of Definitions File,Preprocessing with gnatprep
-@anchor{gnat_ugn/the_gnat_compilation_model form-of-input-text-for-gnatprep}@anchor{9b}@anchor{gnat_ugn/the_gnat_compilation_model id59}@anchor{9c}
+@anchor{gnat_ugn/the_gnat_compilation_model form-of-input-text-for-gnatprep}@anchor{9c}@anchor{gnat_ugn/the_gnat_compilation_model id59}@anchor{9d}
 @subsubsection Form of Input Text for @code{gnatprep}
 
 
@@ -4827,7 +4835,7 @@ Header : String := $XYZ;
 and then the substitution will occur as desired.
 
 @node Integrated Preprocessing,,Preprocessing with gnatprep,Conditional Compilation
-@anchor{gnat_ugn/the_gnat_compilation_model id60}@anchor{9d}@anchor{gnat_ugn/the_gnat_compilation_model integrated-preprocessing}@anchor{91}
+@anchor{gnat_ugn/the_gnat_compilation_model id60}@anchor{9e}@anchor{gnat_ugn/the_gnat_compilation_model integrated-preprocessing}@anchor{92}
 @subsection Integrated Preprocessing
 
 
@@ -4887,7 +4895,7 @@ because @code{gnatmake} cannot compute the checksum of the source after
 preprocessing.
 
 The actual preprocessing function is described in detail in
-@ref{90,,Preprocessing with gnatprep}. This section explains the switches
+@ref{91,,Preprocessing with gnatprep}. This section explains the switches
 that relate to integrated preprocessing.
 
 @geindex -gnatep (gcc)
@@ -4986,7 +4994,7 @@ lines starting with the ‘*’ character.
 
 After the file name or ‘*’, you can place an optional literal string
 to specify the name of the definition file to be used for
-preprocessing (@ref{99,,Form of Definitions File}). The definition
+preprocessing (@ref{9a,,Form of Definitions File}). The definition
 files are found by the compiler in one of the source directories. In
 some cases, when compiling a source in a directory other than the
 current directory, if the definition file is in the current
@@ -5080,7 +5088,7 @@ the output file is @code{foo.adb.prep}.
 @end table
 
 @node Mixed Language Programming,GNAT and Other Compilation Models,Conditional Compilation,The GNAT Compilation Model
-@anchor{gnat_ugn/the_gnat_compilation_model id61}@anchor{9e}@anchor{gnat_ugn/the_gnat_compilation_model mixed-language-programming}@anchor{2c}
+@anchor{gnat_ugn/the_gnat_compilation_model id61}@anchor{9f}@anchor{gnat_ugn/the_gnat_compilation_model mixed-language-programming}@anchor{2d}
 @section Mixed Language Programming
 
 
@@ -5100,7 +5108,7 @@ with a focus on combining Ada with C or C++.
 @end menu
 
 @node Interfacing to C,Calling Conventions,,Mixed Language Programming
-@anchor{gnat_ugn/the_gnat_compilation_model id62}@anchor{9f}@anchor{gnat_ugn/the_gnat_compilation_model interfacing-to-c}@anchor{a0}
+@anchor{gnat_ugn/the_gnat_compilation_model id62}@anchor{a0}@anchor{gnat_ugn/the_gnat_compilation_model interfacing-to-c}@anchor{a1}
 @subsection Interfacing to C
 
 
@@ -5211,7 +5219,7 @@ $ gnatmake my_main.adb -largs file1.o file2.o
 If the main program is in a language other than Ada, you may have more
 than one entry point into the Ada subsystem. You must use a special
 binder option to generate callable routines that initialize and
-finalize the Ada units (@ref{7e,,Binding with Non-Ada Main Programs}).
+finalize the Ada units (@ref{7f,,Binding with Non-Ada Main Programs}).
 You must insert calls to the initialization and finalization routines
 in the main program or some other appropriate point in the code. You
 must place the call to initialize the Ada units so that it occurs
@@ -5328,7 +5336,7 @@ GNAT linker not to include the standard startup objects by passing the
 @code{-nostartfiles} switch to @code{gnatlink}.
 
 @node Calling Conventions,Building Mixed Ada and C++ Programs,Interfacing to C,Mixed Language Programming
-@anchor{gnat_ugn/the_gnat_compilation_model calling-conventions}@anchor{a1}@anchor{gnat_ugn/the_gnat_compilation_model id63}@anchor{a2}
+@anchor{gnat_ugn/the_gnat_compilation_model calling-conventions}@anchor{a2}@anchor{gnat_ugn/the_gnat_compilation_model id63}@anchor{a3}
 @subsection Calling Conventions
 
 
@@ -5556,9 +5564,9 @@ implemented as a single machine instruction.
 @item 
 General subprogram entities. This is used  to bind an Ada subprogram
 declaration to
-a compiler builtin by name with back-ends where such interfaces are
+a compiler builtin by name with back ends where such interfaces are
 available. A typical example is the set of @code{__builtin} functions
-exposed by the @code{gcc} back-end, as in the following example:
+exposed by the @code{gcc} back end, as in the following example:
 
 @example
 function builtin_sqrt (F : Float) return Float;
@@ -5640,7 +5648,7 @@ identifier (for example in an @code{Import} pragma) with the same
 meaning as @code{Fortran}.
 
 @node Building Mixed Ada and C++ Programs,Partition-Wide Settings,Calling Conventions,Mixed Language Programming
-@anchor{gnat_ugn/the_gnat_compilation_model building-mixed-ada-and-c-programs}@anchor{a3}@anchor{gnat_ugn/the_gnat_compilation_model id64}@anchor{a4}
+@anchor{gnat_ugn/the_gnat_compilation_model building-mixed-ada-and-c-programs}@anchor{a4}@anchor{gnat_ugn/the_gnat_compilation_model id64}@anchor{a5}
 @subsection Building Mixed Ada and C++ Programs
 
 
@@ -5658,7 +5666,7 @@ challenge.  This section gives a few hints that should make this task easier.
 @end menu
 
 @node Interfacing to C++,Linking a Mixed C++ & Ada Program,,Building Mixed Ada and C++ Programs
-@anchor{gnat_ugn/the_gnat_compilation_model id65}@anchor{a5}@anchor{gnat_ugn/the_gnat_compilation_model id66}@anchor{a6}
+@anchor{gnat_ugn/the_gnat_compilation_model id65}@anchor{a6}@anchor{gnat_ugn/the_gnat_compilation_model id66}@anchor{a7}
 @subsubsection Interfacing to C++
 
 
@@ -5670,7 +5678,7 @@ You can do interfacing at three levels: simple data, subprograms, and
 classes. In the first two cases, GNAT offers a specific @code{Convention C_Plus_Plus}
 (or @code{CPP}) that behaves exactly like @code{Convention C}.
 Usually, C++ mangles the names of subprograms. To generate proper mangled
-names automatically, see @ref{a7,,Generating Ada Bindings for C and C++ headers}).
+names automatically, see @ref{a8,,Generating Ada Bindings for C and C++ headers}).
 You can also address this problem addressed manually in two ways:
 
 
@@ -5690,7 +5698,7 @@ You can achieve interfacing at the class level by using the GNAT specific
 pragmas such as @code{CPP_Constructor}.  See the @cite{GNAT_Reference_Manual} for additional information.
 
 @node Linking a Mixed C++ & Ada Program,A Simple Example,Interfacing to C++,Building Mixed Ada and C++ Programs
-@anchor{gnat_ugn/the_gnat_compilation_model linking-a-mixed-c-ada-program}@anchor{a8}@anchor{gnat_ugn/the_gnat_compilation_model linking-a-mixed-c-and-ada-program}@anchor{a9}
+@anchor{gnat_ugn/the_gnat_compilation_model linking-a-mixed-c-ada-program}@anchor{a9}@anchor{gnat_ugn/the_gnat_compilation_model linking-a-mixed-c-and-ada-program}@anchor{aa}
 @subsubsection Linking a Mixed C++ & Ada Program
 
 
@@ -5808,7 +5816,7 @@ which has a large knowledge base and knows how to link Ada and C++ code
 together automatically in most cases.
 
 @node A Simple Example,Interfacing with C++ constructors,Linking a Mixed C++ & Ada Program,Building Mixed Ada and C++ Programs
-@anchor{gnat_ugn/the_gnat_compilation_model a-simple-example}@anchor{aa}@anchor{gnat_ugn/the_gnat_compilation_model id67}@anchor{ab}
+@anchor{gnat_ugn/the_gnat_compilation_model a-simple-example}@anchor{ab}@anchor{gnat_ugn/the_gnat_compilation_model id67}@anchor{ac}
 @subsubsection A Simple Example
 
 
@@ -5937,7 +5945,7 @@ end Simple_Cpp_Interface;
 @end example
 
 @node Interfacing with C++ constructors,Interfacing with C++ at the Class Level,A Simple Example,Building Mixed Ada and C++ Programs
-@anchor{gnat_ugn/the_gnat_compilation_model id68}@anchor{ac}@anchor{gnat_ugn/the_gnat_compilation_model interfacing-with-c-constructors}@anchor{ad}
+@anchor{gnat_ugn/the_gnat_compilation_model id68}@anchor{ad}@anchor{gnat_ugn/the_gnat_compilation_model interfacing-with-c-constructors}@anchor{ae}
 @subsubsection Interfacing with C++ constructors
 
 
@@ -5964,8 +5972,8 @@ public:
 
 For this purpose, we can write the following package spec (further
 information on how to build this spec is available in
-@ref{ae,,Interfacing with C++ at the Class Level} and
-@ref{a7,,Generating Ada Bindings for C and C++ headers}).
+@ref{af,,Interfacing with C++ at the Class Level} and
+@ref{a8,,Generating Ada Bindings for C and C++ headers}).
 
 @example
 with Interfaces.C; use Interfaces.C;
@@ -6133,7 +6141,7 @@ means of a limited aggregate. We could also place any further action
 associated with the constructor inside the construct.
 
 @node Interfacing with C++ at the Class Level,,Interfacing with C++ constructors,Building Mixed Ada and C++ Programs
-@anchor{gnat_ugn/the_gnat_compilation_model id69}@anchor{af}@anchor{gnat_ugn/the_gnat_compilation_model interfacing-with-c-at-the-class-level}@anchor{ae}
+@anchor{gnat_ugn/the_gnat_compilation_model id69}@anchor{b0}@anchor{gnat_ugn/the_gnat_compilation_model interfacing-with-c-at-the-class-level}@anchor{af}
 @subsubsection Interfacing with C++ at the Class Level
 
 
@@ -6381,7 +6389,7 @@ int main ()
 @end example
 
 @node Partition-Wide Settings,Generating Ada Bindings for C and C++ headers,Building Mixed Ada and C++ Programs,Mixed Language Programming
-@anchor{gnat_ugn/the_gnat_compilation_model id70}@anchor{b0}@anchor{gnat_ugn/the_gnat_compilation_model partition-wide-settings}@anchor{b1}
+@anchor{gnat_ugn/the_gnat_compilation_model id70}@anchor{b1}@anchor{gnat_ugn/the_gnat_compilation_model partition-wide-settings}@anchor{b2}
 @subsection Partition-Wide Settings
 
 
@@ -6443,7 +6451,7 @@ and @code{SIGILL} are used to raise corresponding Ada exceptions in the applicat
 while @code{SIGABRT} is used to asynchronously abort an action or a task.
 
 @node Generating Ada Bindings for C and C++ headers,Generating C Headers for Ada Specifications,Partition-Wide Settings,Mixed Language Programming
-@anchor{gnat_ugn/the_gnat_compilation_model generating-ada-bindings-for-c-and-c-headers}@anchor{a7}@anchor{gnat_ugn/the_gnat_compilation_model id71}@anchor{b2}
+@anchor{gnat_ugn/the_gnat_compilation_model generating-ada-bindings-for-c-and-c-headers}@anchor{a8}@anchor{gnat_ugn/the_gnat_compilation_model id71}@anchor{b3}
 @subsection Generating Ada Bindings for C and C++ headers
 
 
@@ -6494,7 +6502,7 @@ even if your code is compiled using earlier versions of Ada (e.g. @code{-gnat95}
 @end menu
 
 @node Running the Binding Generator,Generating Bindings for C++ Headers,,Generating Ada Bindings for C and C++ headers
-@anchor{gnat_ugn/the_gnat_compilation_model id72}@anchor{b3}@anchor{gnat_ugn/the_gnat_compilation_model running-the-binding-generator}@anchor{b4}
+@anchor{gnat_ugn/the_gnat_compilation_model id72}@anchor{b4}@anchor{gnat_ugn/the_gnat_compilation_model running-the-binding-generator}@anchor{b5}
 @subsubsection Running the Binding Generator
 
 
@@ -6560,7 +6568,7 @@ $ gcc -c -fdump-ada-spec readline1.h
 @end example
 
 @node Generating Bindings for C++ Headers,Switches,Running the Binding Generator,Generating Ada Bindings for C and C++ headers
-@anchor{gnat_ugn/the_gnat_compilation_model generating-bindings-for-c-headers}@anchor{b5}@anchor{gnat_ugn/the_gnat_compilation_model id73}@anchor{b6}
+@anchor{gnat_ugn/the_gnat_compilation_model generating-bindings-for-c-headers}@anchor{b6}@anchor{gnat_ugn/the_gnat_compilation_model id73}@anchor{b7}
 @subsubsection Generating Bindings for C++ Headers
 
 
@@ -6661,7 +6669,7 @@ use Class_Dog;
 @end example
 
 @node Switches,,Generating Bindings for C++ Headers,Generating Ada Bindings for C and C++ headers
-@anchor{gnat_ugn/the_gnat_compilation_model switches}@anchor{b7}@anchor{gnat_ugn/the_gnat_compilation_model switches-for-ada-binding-generation}@anchor{b8}
+@anchor{gnat_ugn/the_gnat_compilation_model switches}@anchor{b8}@anchor{gnat_ugn/the_gnat_compilation_model switches-for-ada-binding-generation}@anchor{b9}
 @subsubsection Switches
 
 
@@ -6709,7 +6717,7 @@ Extract comments from headers and generate Ada comments in the Ada spec files.
 @end table
 
 @node Generating C Headers for Ada Specifications,,Generating Ada Bindings for C and C++ headers,Mixed Language Programming
-@anchor{gnat_ugn/the_gnat_compilation_model generating-c-headers-for-ada-specifications}@anchor{b9}@anchor{gnat_ugn/the_gnat_compilation_model id74}@anchor{ba}
+@anchor{gnat_ugn/the_gnat_compilation_model generating-c-headers-for-ada-specifications}@anchor{ba}@anchor{gnat_ugn/the_gnat_compilation_model id74}@anchor{bb}
 @subsection Generating C Headers for Ada Specifications
 
 
@@ -6752,7 +6760,7 @@ Subprogram declarations
 @end menu
 
 @node Running the C Header Generator,,,Generating C Headers for Ada Specifications
-@anchor{gnat_ugn/the_gnat_compilation_model running-the-c-header-generator}@anchor{bb}
+@anchor{gnat_ugn/the_gnat_compilation_model running-the-c-header-generator}@anchor{bc}
 @subsubsection Running the C Header Generator
 
 
@@ -6820,7 +6828,7 @@ You can then @code{include} @code{pack1.h} from a C source file and use the type
 call subprograms, reference objects, and constants.
 
 @node GNAT and Other Compilation Models,Using GNAT Files with External Tools,Mixed Language Programming,The GNAT Compilation Model
-@anchor{gnat_ugn/the_gnat_compilation_model gnat-and-other-compilation-models}@anchor{2d}@anchor{gnat_ugn/the_gnat_compilation_model id75}@anchor{bc}
+@anchor{gnat_ugn/the_gnat_compilation_model gnat-and-other-compilation-models}@anchor{2e}@anchor{gnat_ugn/the_gnat_compilation_model id75}@anchor{bd}
 @section GNAT and Other Compilation Models
 
 
@@ -6836,7 +6844,7 @@ used for Ada 83.
 @end menu
 
 @node Comparison between GNAT and C/C++ Compilation Models,Comparison between GNAT and Conventional Ada Library Models,,GNAT and Other Compilation Models
-@anchor{gnat_ugn/the_gnat_compilation_model comparison-between-gnat-and-c-c-compilation-models}@anchor{bd}@anchor{gnat_ugn/the_gnat_compilation_model id76}@anchor{be}
+@anchor{gnat_ugn/the_gnat_compilation_model comparison-between-gnat-and-c-c-compilation-models}@anchor{be}@anchor{gnat_ugn/the_gnat_compilation_model id76}@anchor{bf}
 @subsection Comparison between GNAT and C/C++ Compilation Models
 
 
@@ -6869,7 +6877,7 @@ elaboration, a C++ compiler would simply construct a program that
 malfunctioned at run time.
 
 @node Comparison between GNAT and Conventional Ada Library Models,,Comparison between GNAT and C/C++ Compilation Models,GNAT and Other Compilation Models
-@anchor{gnat_ugn/the_gnat_compilation_model comparison-between-gnat-and-conventional-ada-library-models}@anchor{bf}@anchor{gnat_ugn/the_gnat_compilation_model id77}@anchor{c0}
+@anchor{gnat_ugn/the_gnat_compilation_model comparison-between-gnat-and-conventional-ada-library-models}@anchor{c0}@anchor{gnat_ugn/the_gnat_compilation_model id77}@anchor{c1}
 @subsection Comparison between GNAT and Conventional Ada Library Models
 
 
@@ -6937,7 +6945,7 @@ of rules saying what source files must be present when a file is
 compiled.
 
 @node Using GNAT Files with External Tools,,GNAT and Other Compilation Models,The GNAT Compilation Model
-@anchor{gnat_ugn/the_gnat_compilation_model id78}@anchor{c1}@anchor{gnat_ugn/the_gnat_compilation_model using-gnat-files-with-external-tools}@anchor{2e}
+@anchor{gnat_ugn/the_gnat_compilation_model id78}@anchor{c2}@anchor{gnat_ugn/the_gnat_compilation_model using-gnat-files-with-external-tools}@anchor{2f}
 @section Using GNAT Files with External Tools
 
 
@@ -6951,7 +6959,7 @@ used with tools designed for other languages.
 @end menu
 
 @node Using Other Utility Programs with GNAT,The External Symbol Naming Scheme of GNAT,,Using GNAT Files with External Tools
-@anchor{gnat_ugn/the_gnat_compilation_model id79}@anchor{c2}@anchor{gnat_ugn/the_gnat_compilation_model using-other-utility-programs-with-gnat}@anchor{c3}
+@anchor{gnat_ugn/the_gnat_compilation_model id79}@anchor{c3}@anchor{gnat_ugn/the_gnat_compilation_model using-other-utility-programs-with-gnat}@anchor{c4}
 @subsection Using Other Utility Programs with GNAT
 
 
@@ -6966,7 +6974,7 @@ Ada programs generated by GNAT. This includes software utilities such as
 as @code{Purify}.
 
 @node The External Symbol Naming Scheme of GNAT,,Using Other Utility Programs with GNAT,Using GNAT Files with External Tools
-@anchor{gnat_ugn/the_gnat_compilation_model id80}@anchor{c4}@anchor{gnat_ugn/the_gnat_compilation_model the-external-symbol-naming-scheme-of-gnat}@anchor{c5}
+@anchor{gnat_ugn/the_gnat_compilation_model id80}@anchor{c5}@anchor{gnat_ugn/the_gnat_compilation_model the-external-symbol-naming-scheme-of-gnat}@anchor{c6}
 @subsection The External Symbol Naming Scheme of GNAT
 
 
@@ -7025,23 +7033,23 @@ the external name of this procedure is @code{_ada_hello}.
 @c -- Example: A |withing| unit has a |with| clause, it |withs| a |withed| unit
 
 @node Building Executable Programs with GNAT,GNAT Utility Programs,The GNAT Compilation Model,Top
-@anchor{gnat_ugn/building_executable_programs_with_gnat doc}@anchor{c6}@anchor{gnat_ugn/building_executable_programs_with_gnat building-executable-programs-with-gnat}@anchor{a}@anchor{gnat_ugn/building_executable_programs_with_gnat id1}@anchor{c7}
+@anchor{gnat_ugn/building_executable_programs_with_gnat doc}@anchor{c7}@anchor{gnat_ugn/building_executable_programs_with_gnat building-executable-programs-with-gnat}@anchor{b}@anchor{gnat_ugn/building_executable_programs_with_gnat id1}@anchor{c8}
 @chapter Building Executable Programs with GNAT
 
 
 This chapter describes first the gnatmake tool
-(@ref{c8,,Building with gnatmake}),
+(@ref{c9,,Building with gnatmake}),
 which automatically determines the set of sources
 needed by an Ada compilation unit and executes the necessary
 (re)compilations, binding and linking.
 It also explains how to use each tool individually: the
-compiler (gcc, see @ref{c9,,Compiling with gcc}),
-binder (gnatbind, see @ref{ca,,Binding with gnatbind}),
-and linker (gnatlink, see @ref{cb,,Linking with gnatlink})
+compiler (gcc, see @ref{ca,,Compiling with gcc}),
+binder (gnatbind, see @ref{cb,,Binding with gnatbind}),
+and linker (gnatlink, see @ref{cc,,Linking with gnatlink})
 to build executable programs.
 Finally, this chapter provides examples of
 how to make use of the general GNU make mechanism
-in a GNAT context (see @ref{70,,Using the GNU make Utility}).
+in a GNAT context (see @ref{71,,Using the GNU make Utility}).
 
 
 @menu
@@ -7056,7 +7064,7 @@ in a GNAT context (see @ref{70,,Using the GNU make Utility}).
 @end menu
 
 @node Building with gnatmake,Compiling with gcc,,Building Executable Programs with GNAT
-@anchor{gnat_ugn/building_executable_programs_with_gnat building-with-gnatmake}@anchor{cc}@anchor{gnat_ugn/building_executable_programs_with_gnat the-gnat-make-program-gnatmake}@anchor{c8}
+@anchor{gnat_ugn/building_executable_programs_with_gnat building-with-gnatmake}@anchor{cd}@anchor{gnat_ugn/building_executable_programs_with_gnat the-gnat-make-program-gnatmake}@anchor{c9}
 @section Building with @code{gnatmake}
 
 
@@ -7120,7 +7128,7 @@ to @code{gnatmake}.
 @end menu
 
 @node Running gnatmake,Switches for gnatmake,,Building with gnatmake
-@anchor{gnat_ugn/building_executable_programs_with_gnat id2}@anchor{cd}@anchor{gnat_ugn/building_executable_programs_with_gnat running-gnatmake}@anchor{ce}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id2}@anchor{ce}@anchor{gnat_ugn/building_executable_programs_with_gnat running-gnatmake}@anchor{cf}
 @subsection Running @code{gnatmake}
 
 
@@ -7148,14 +7156,14 @@ be searched for in the specified directory only. Otherwise, the input
 source file will first be searched in the directory where
 @code{gnatmake} was invoked and if it is not found, it will be search on
 the source path of the compiler as described in
-@ref{73,,Search Paths and the Run-Time Library (RTL)}.
+@ref{74,,Search Paths and the Run-Time Library (RTL)}.
 
 All @code{gnatmake} output (except when you specify @code{-M}) is sent to
 @code{stderr}. The output produced by the
 @code{-M} switch is sent to @code{stdout}.
 
 @node Switches for gnatmake,Mode Switches for gnatmake,Running gnatmake,Building with gnatmake
-@anchor{gnat_ugn/building_executable_programs_with_gnat id3}@anchor{cf}@anchor{gnat_ugn/building_executable_programs_with_gnat switches-for-gnatmake}@anchor{d0}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id3}@anchor{d0}@anchor{gnat_ugn/building_executable_programs_with_gnat switches-for-gnatmake}@anchor{d1}
 @subsection Switches for @code{gnatmake}
 
 
@@ -7544,7 +7552,7 @@ then instead object files and ALI files that already exist are overwritten
 in place. This means that once a large project is organized into separate
 directories in the desired manner, then @code{gnatmake} will automatically
 maintain and update this organization. If no ALI files are found on the
-Ada object path (see @ref{73,,Search Paths and the Run-Time Library (RTL)}),
+Ada object path (see @ref{74,,Search Paths and the Run-Time Library (RTL)}),
 the new object and ALI files are created in the
 directory containing the source being compiled. If another organization
 is desired, where objects and sources are kept in different directories,
@@ -7797,7 +7805,7 @@ Verbosity level High. Equivalent to -v.
 @item @code{-vP`x'}
 
 Indicate the verbosity of the parsing of GNAT project files.
-See @ref{d1,,Switches Related to Project Files}.
+See @ref{d2,,Switches Related to Project Files}.
 @end table
 
 @geindex -x (gnatmake)
@@ -7821,7 +7829,7 @@ command line need to be sources of a project file.
 Indicate that external variable @code{name} has the value @code{value}.
 The Project Manager will use this value for occurrences of
 @code{external(name)} when parsing the project file.
-@ref{d1,,Switches Related to Project Files}.
+@ref{d2,,Switches Related to Project Files}.
 @end table
 
 @geindex -z (gnatmake)
@@ -7855,7 +7863,7 @@ is passed to @code{gcc} (e.g., @code{-O}, @code{-gnato,} etc.)
 
 When looking for source files also look in directory @code{dir}.
 The order in which source files search is undertaken is
-described in @ref{73,,Search Paths and the Run-Time Library (RTL)}.
+described in @ref{74,,Search Paths and the Run-Time Library (RTL)}.
 @end table
 
 @geindex -aL (gnatmake)
@@ -7887,7 +7895,7 @@ ALI files.
 
 When searching for library and object files, look in directory
 @code{dir}. The order in which library files are searched is described in
-@ref{76,,Search Paths for gnatbind}.
+@ref{77,,Search Paths for gnatbind}.
 @end table
 
 @geindex Search paths
@@ -7992,7 +8000,7 @@ The selected path is handled like a normal RTS path.
 @end table
 
 @node Mode Switches for gnatmake,Notes on the Command Line,Switches for gnatmake,Building with gnatmake
-@anchor{gnat_ugn/building_executable_programs_with_gnat id4}@anchor{d2}@anchor{gnat_ugn/building_executable_programs_with_gnat mode-switches-for-gnatmake}@anchor{d3}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id4}@anchor{d3}@anchor{gnat_ugn/building_executable_programs_with_gnat mode-switches-for-gnatmake}@anchor{d4}
 @subsection Mode Switches for @code{gnatmake}
 
 
@@ -8052,7 +8060,7 @@ or @code{-largs}.
 @end table
 
 @node Notes on the Command Line,How gnatmake Works,Mode Switches for gnatmake,Building with gnatmake
-@anchor{gnat_ugn/building_executable_programs_with_gnat id5}@anchor{d4}@anchor{gnat_ugn/building_executable_programs_with_gnat notes-on-the-command-line}@anchor{d5}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id5}@anchor{d5}@anchor{gnat_ugn/building_executable_programs_with_gnat notes-on-the-command-line}@anchor{d6}
 @subsection Notes on the Command Line
 
 
@@ -8122,7 +8130,7 @@ that the debugging information may be out of date.
 @end itemize
 
 @node How gnatmake Works,Examples of gnatmake Usage,Notes on the Command Line,Building with gnatmake
-@anchor{gnat_ugn/building_executable_programs_with_gnat how-gnatmake-works}@anchor{d6}@anchor{gnat_ugn/building_executable_programs_with_gnat id6}@anchor{d7}
+@anchor{gnat_ugn/building_executable_programs_with_gnat how-gnatmake-works}@anchor{d7}@anchor{gnat_ugn/building_executable_programs_with_gnat id6}@anchor{d8}
 @subsection How @code{gnatmake} Works
 
 
@@ -8162,14 +8170,14 @@ When invoking @code{gnatmake} with several @code{file_names}, if a unit is
 imported by several of the executables, it will be recompiled at most once.
 
 Note: when using non-standard naming conventions
-(@ref{1c,,Using Other File Names}), changing through a configuration pragmas
+(@ref{1d,,Using Other File Names}), changing through a configuration pragmas
 file the version of a source and invoking @code{gnatmake} to recompile may
 have no effect, if the previous version of the source is still accessible
 by @code{gnatmake}. It may be necessary to use the switch
 -f.
 
 @node Examples of gnatmake Usage,,How gnatmake Works,Building with gnatmake
-@anchor{gnat_ugn/building_executable_programs_with_gnat examples-of-gnatmake-usage}@anchor{d8}@anchor{gnat_ugn/building_executable_programs_with_gnat id7}@anchor{d9}
+@anchor{gnat_ugn/building_executable_programs_with_gnat examples-of-gnatmake-usage}@anchor{d9}@anchor{gnat_ugn/building_executable_programs_with_gnat id7}@anchor{da}
 @subsection Examples of @code{gnatmake} Usage
 
 
@@ -8201,7 +8209,7 @@ displaying commands it is executing.
 @end table
 
 @node Compiling with gcc,Compiler Switches,Building with gnatmake,Building Executable Programs with GNAT
-@anchor{gnat_ugn/building_executable_programs_with_gnat compiling-with-gcc}@anchor{c9}@anchor{gnat_ugn/building_executable_programs_with_gnat id8}@anchor{da}
+@anchor{gnat_ugn/building_executable_programs_with_gnat compiling-with-gcc}@anchor{ca}@anchor{gnat_ugn/building_executable_programs_with_gnat id8}@anchor{db}
 @section Compiling with @code{gcc}
 
 
@@ -8218,7 +8226,7 @@ that can be used to control the behavior of the compiler.
 @end menu
 
 @node Compiling Programs,Search Paths and the Run-Time Library RTL,,Compiling with gcc
-@anchor{gnat_ugn/building_executable_programs_with_gnat compiling-programs}@anchor{db}@anchor{gnat_ugn/building_executable_programs_with_gnat id9}@anchor{dc}
+@anchor{gnat_ugn/building_executable_programs_with_gnat compiling-programs}@anchor{dc}@anchor{gnat_ugn/building_executable_programs_with_gnat id9}@anchor{dd}
 @subsection Compiling Programs
 
 
@@ -8329,11 +8337,11 @@ calls @code{gnat1} (the Ada compiler) twice to compile @code{x.adb} and
 The compiler generates two object files @code{x.o} and @code{y.o}
 and the two ALI files @code{x.ali} and @code{y.ali}.
 
-Any switches apply to all the files listed, see @ref{dd,,Compiler Switches} for a
+Any switches apply to all the files listed, see @ref{de,,Compiler Switches} for a
 list of available @code{gcc} switches.
 
 @node Search Paths and the Run-Time Library RTL,Order of Compilation Issues,Compiling Programs,Compiling with gcc
-@anchor{gnat_ugn/building_executable_programs_with_gnat id10}@anchor{de}@anchor{gnat_ugn/building_executable_programs_with_gnat search-paths-and-the-run-time-library-rtl}@anchor{73}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id10}@anchor{df}@anchor{gnat_ugn/building_executable_programs_with_gnat search-paths-and-the-run-time-library-rtl}@anchor{74}
 @subsection Search Paths and the Run-Time Library (RTL)
 
 
@@ -8390,7 +8398,7 @@ names separated by colons (semicolons when working with the NT version).
 The content of the @code{ada_source_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) source files.
-See also @ref{72,,Installing a library}.
+See also @ref{73,,Installing a library}.
 @end itemize
 
 Specifying the switch @code{-I-}
@@ -8432,7 +8440,7 @@ in compiling sources from multiple directories. This can make
 development environments much more flexible.
 
 @node Order of Compilation Issues,Examples,Search Paths and the Run-Time Library RTL,Compiling with gcc
-@anchor{gnat_ugn/building_executable_programs_with_gnat id11}@anchor{df}@anchor{gnat_ugn/building_executable_programs_with_gnat order-of-compilation-issues}@anchor{e0}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id11}@anchor{e0}@anchor{gnat_ugn/building_executable_programs_with_gnat order-of-compilation-issues}@anchor{e1}
 @subsection Order of Compilation Issues
 
 
@@ -8460,7 +8468,7 @@ source files on which it depends.
 
 @item 
 There is no library as such, apart from the ALI files
-(@ref{28,,The Ada Library Information Files}, for information on the format
+(@ref{29,,The Ada Library Information Files}, for information on the format
 of these files). For now we find it convenient to create separate ALI files,
 but eventually the information therein may be incorporated into the object
 file directly.
@@ -8473,7 +8481,7 @@ described above), or you will receive a fatal error message.
 @end itemize
 
 @node Examples,,Order of Compilation Issues,Compiling with gcc
-@anchor{gnat_ugn/building_executable_programs_with_gnat examples}@anchor{e1}@anchor{gnat_ugn/building_executable_programs_with_gnat id12}@anchor{e2}
+@anchor{gnat_ugn/building_executable_programs_with_gnat examples}@anchor{e2}@anchor{gnat_ugn/building_executable_programs_with_gnat id12}@anchor{e3}
 @subsection Examples
 
 
@@ -8501,7 +8509,7 @@ Compile the subunit in file @code{abc-def.adb} in semantic-checking-only
 mode.
 
 @node Compiler Switches,Linker Switches,Compiling with gcc,Building Executable Programs with GNAT
-@anchor{gnat_ugn/building_executable_programs_with_gnat compiler-switches}@anchor{e3}@anchor{gnat_ugn/building_executable_programs_with_gnat switches-for-gcc}@anchor{dd}
+@anchor{gnat_ugn/building_executable_programs_with_gnat compiler-switches}@anchor{e4}@anchor{gnat_ugn/building_executable_programs_with_gnat switches-for-gcc}@anchor{de}
 @section Compiler Switches
 
 
@@ -8541,7 +8549,7 @@ compilation units.
 @end menu
 
 @node Alphabetical List of All Switches,Output and Error Message Control,,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat alphabetical-list-of-all-switches}@anchor{e4}@anchor{gnat_ugn/building_executable_programs_with_gnat id13}@anchor{e5}
+@anchor{gnat_ugn/building_executable_programs_with_gnat alphabetical-list-of-all-switches}@anchor{e5}@anchor{gnat_ugn/building_executable_programs_with_gnat id13}@anchor{e6}
 @subsection Alphabetical List of All Switches
 
 
@@ -8739,7 +8747,7 @@ and thus producing inferior code.
 
 Causes the compiler to avoid assumptions regarding non-aliasing
 of objects of different types. See
-@ref{e6,,Optimization and Strict Aliasing} for details.
+@ref{e7,,Optimization and Strict Aliasing} for details.
 @end table
 
 @geindex -fno-strict-overflow (gcc)
@@ -8765,7 +8773,7 @@ for very peculiar cases of low-level programming.
 @item @code{-fstack-check}
 
 Activates stack checking.
-See @ref{e7,,Stack Overflow Checking} for details.
+See @ref{e8,,Stack Overflow Checking} for details.
 @end table
 
 @geindex -fstack-usage (gcc)
@@ -8776,7 +8784,7 @@ See @ref{e7,,Stack Overflow Checking} for details.
 @item @code{-fstack-usage}
 
 Makes the compiler output stack usage information for the program, on a
-per-subprogram basis. See @ref{e8,,Static Stack Usage Analysis} for details.
+per-subprogram basis. See @ref{e9,,Static Stack Usage Analysis} for details.
 @end table
 
 @geindex -g (gcc)
@@ -8916,7 +8924,7 @@ Generate brief messages to @code{stderr} even if verbose mode set.
 @item @code{-gnatB}
 
 Assume no invalid (bad) values except for ‘Valid attribute use
-(@ref{e9,,Validity Checking}).
+(@ref{ea,,Validity Checking}).
 @end table
 
 @geindex -gnatc (gcc)
@@ -9043,7 +9051,7 @@ ALI files.
 
 Specify a configuration pragma file
 (the equal sign is optional)
-(@ref{63,,The Configuration Pragmas Files}).
+(@ref{64,,The Configuration Pragmas Files}).
 @end table
 
 @geindex -gnateC (gcc)
@@ -9076,7 +9084,7 @@ Disable atomic synchronization
 @item @code{-gnateDsymbol[=`value']}
 
 Defines a symbol, associated with @code{value}, for preprocessing.
-(@ref{91,,Integrated Preprocessing}).
+(@ref{92,,Integrated Preprocessing}).
 @end table
 
 @geindex -gnateE (gcc)
@@ -9126,7 +9134,7 @@ for unconstrained predefined types. See description of pragma
 
 The @code{-gnatc} switch must always be specified before this switch, e.g.
 @code{-gnatceg}. Generate a C header from the Ada input file. See
-@ref{b9,,Generating C Headers for Ada Specifications} for more
+@ref{ba,,Generating C Headers for Ada Specifications} for more
 information.
 @end quotation
 
@@ -9212,7 +9220,7 @@ This switch turns off the info messages about implicit elaboration pragmas.
 
 Specify a mapping file
 (the equal sign is optional)
-(@ref{ea,,Units to Sources Mapping Files}).
+(@ref{eb,,Units to Sources Mapping Files}).
 @end table
 
 @geindex -gnatep (gcc)
@@ -9224,7 +9232,7 @@ Specify a mapping file
 
 Specify a preprocessing data file
 (the equal sign is optional)
-(@ref{91,,Integrated Preprocessing}).
+(@ref{92,,Integrated Preprocessing}).
 @end table
 
 @geindex -gnateP (gcc)
@@ -9323,7 +9331,7 @@ compiler can choose by default for a 64-bit or larger scalar type or object.
 
 @code{Maximum_Alignment} is the maximum alignment that the compiler can choose
 by default for a type or object, which is also the maximum alignment that can
-be specified in GNAT. It is computed for GCC backends as @code{BIGGEST_ALIGNMENT
+be specified in GNAT. It is computed for GCC back ends 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.}
 
@@ -9424,7 +9432,7 @@ support this switch.
 @item @code{-gnateV}
 
 Check that all actual parameters of a subprogram call are valid according to
-the rules of validity checking (@ref{e9,,Validity Checking}).
+the rules of validity checking (@ref{ea,,Validity Checking}).
 @end table
 
 @geindex -gnateY (gcc)
@@ -9448,7 +9456,7 @@ checking options to be controlled from the command line.
 @item @code{-gnatE}
 
 Dynamic elaboration checking mode enabled. For further details see
-@ref{f,,Elaboration Order Handling in GNAT}.
+@ref{10,,Elaboration Order Handling in GNAT}.
 @end table
 
 @geindex -gnatf (gcc)
@@ -9516,7 +9524,7 @@ Output usage information. The output is written to @code{stdout}.
 
 Legacy elaboration-checking mode enabled. When this switch is in effect,
 the pre-18.x access-before-elaboration model becomes the de facto model.
-For further details see @ref{f,,Elaboration Order Handling in GNAT}.
+For further details see @ref{10,,Elaboration Order Handling in GNAT}.
 @end table
 
 @geindex -gnati (gcc)
@@ -9528,7 +9536,7 @@ For further details see @ref{f,,Elaboration Order Handling in GNAT}.
 
 Identifier character set (@code{c} = 1/2/3/4/5/9/p/8/f/n/w).
 For details of the possible selections for @code{c},
-see @ref{31,,Character Set Control}.
+see @ref{32,,Character Set Control}.
 @end table
 
 @geindex -gnatI (gcc)
@@ -9610,7 +9618,7 @@ Synchronous task suspension
 @end itemize
 
 and does not emit compile-time diagnostics or run-time checks. For further
-details see @ref{f,,Elaboration Order Handling in GNAT}.
+details see @ref{10,,Elaboration Order Handling in GNAT}.
 @end table
 
 @geindex -gnatk (gcc)
@@ -9670,7 +9678,7 @@ means that no limit applies.
 @item @code{-gnatn[12]}
 
 Activate inlining across units for subprograms for which pragma @code{Inline}
-is specified. This inlining is performed by the GCC back-end. An optional
+is specified. This inlining is performed by the GCC back end. An optional
 digit sets the inlining level: 1 for moderate inlining across units
 or 2 for full inlining across units. If no inlining level is specified,
 the compiler will pick it based on the optimization level.
@@ -9776,7 +9784,7 @@ overflow checking is enabled.
 Note that division by zero is a separate check that is not
 controlled by this switch (divide-by-zero checking is on by default).
 
-See also @ref{eb,,Specifying the Desired Mode}.
+See also @ref{ec,,Specifying the Desired Mode}.
 @end table
 
 @geindex -gnatp (gcc)
@@ -9786,7 +9794,7 @@ See also @ref{eb,,Specifying the Desired Mode}.
 
 @item @code{-gnatp}
 
-Suppress all checks. See @ref{ec,,Run-Time Checks} for details. This switch
+Suppress all checks. See @ref{ed,,Run-Time Checks} for details. This switch
 has no effect if cancelled by a subsequent @code{-gnat-p} switch.
 @end table
 
@@ -9912,7 +9920,7 @@ Verbose mode. Full error output with source lines to @code{stdout}.
 
 @item @code{-gnatV}
 
-Control level of validity checking (@ref{e9,,Validity Checking}).
+Control level of validity checking (@ref{ea,,Validity Checking}).
 @end table
 
 @geindex -gnatw (gcc)
@@ -9925,7 +9933,7 @@ Control level of validity checking (@ref{e9,,Validity Checking}).
 Warning mode where
 @code{xxx} is a string of option letters that denotes
 the exact warnings that
-are enabled or disabled (@ref{ed,,Warning Message Control}).
+are enabled or disabled (@ref{ee,,Warning Message Control}).
 @end table
 
 @geindex -gnatW (gcc)
@@ -9976,7 +9984,7 @@ Enable all GNAT implementation extensions and latest Ada version.
 
 @item @code{-gnaty}
 
-Enable built-in style checks (@ref{ee,,Style Checking}).
+Enable built-in style checks (@ref{ef,,Style Checking}).
 @end table
 
 @geindex -gnatz (gcc)
@@ -10001,7 +10009,7 @@ Distribution stub generation and compilation
 
 Direct GNAT to search the @code{dir} directory for source files needed by
 the current compilation
-(see @ref{73,,Search Paths and the Run-Time Library (RTL)}).
+(see @ref{74,,Search Paths and the Run-Time Library (RTL)}).
 @end table
 
 @geindex -I- (gcc)
@@ -10015,7 +10023,7 @@ the current compilation
 
 Except for the source file named in the command line, do not look for source
 files in the directory containing the source file named in the command line
-(see @ref{73,,Search Paths and the Run-Time Library (RTL)}).
+(see @ref{74,,Search Paths and the Run-Time Library (RTL)}).
 @end table
 
 @geindex -o (gcc)
@@ -10119,7 +10127,7 @@ Optimize space usage
 @end multitable
 
 
-See also @ref{ef,,Optimization Levels}.
+See also @ref{f0,,Optimization Levels}.
 @end table
 
 @geindex -pass-exit-codes (gcc)
@@ -10141,7 +10149,7 @@ exit status.
 @item @code{--RTS=`rts-path'}
 
 Specifies the default location of the run-time library. Same meaning as the
-equivalent @code{gnatmake} flag (@ref{d0,,Switches for gnatmake}).
+equivalent @code{gnatmake} flag (@ref{d1,,Switches for gnatmake}).
 @end table
 
 @geindex -S (gcc)
@@ -10267,7 +10275,7 @@ as warning mode modifiers (see description of @code{-gnatw}).
 @item 
 Once a ‘V’ appears in the string (that is a use of the @code{-gnatV}
 switch), then all further characters in the switch are interpreted
-as validity checking options (@ref{e9,,Validity Checking}).
+as validity checking options (@ref{ea,,Validity Checking}).
 
 @item 
 Option ‘em’, ‘ec’, ‘ep’, ‘l=’ and ‘R’ must be the last options in
@@ -10275,7 +10283,7 @@ a combined list of options.
 @end itemize
 
 @node Output and Error Message Control,Warning Message Control,Alphabetical List of All Switches,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat id14}@anchor{f0}@anchor{gnat_ugn/building_executable_programs_with_gnat output-and-error-message-control}@anchor{f1}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id14}@anchor{f1}@anchor{gnat_ugn/building_executable_programs_with_gnat output-and-error-message-control}@anchor{f2}
 @subsection Output and Error Message Control
 
 
@@ -10570,7 +10578,7 @@ since ALI files are never generated if @code{-gnats} is set.
 @end table
 
 @node Warning Message Control,Info message Control,Output and Error Message Control,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat id15}@anchor{f2}@anchor{gnat_ugn/building_executable_programs_with_gnat warning-message-control}@anchor{ed}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id15}@anchor{f3}@anchor{gnat_ugn/building_executable_programs_with_gnat warning-message-control}@anchor{ee}
 @subsection Warning Message Control
 
 
@@ -11874,7 +11882,7 @@ This switch activates warnings for failure of front end inlining
 many reasons for not being able to inline a call, including most
 commonly that the call is too complex to inline. The default is
 that such warnings are not given.
-Warnings on ineffective inlining by the gcc back-end can be activated
+Warnings on ineffective inlining by the gcc back end can be activated
 separately, using the gcc switch -Winline.
 @end table
 
@@ -12798,7 +12806,7 @@ used in conjunction with an optimization level greater than zero.
 @item @code{-Wstack-usage=`len'}
 
 Warn if the stack usage of a subprogram might be larger than @code{len} bytes.
-See @ref{e8,,Static Stack Usage Analysis} for details.
+See @ref{e9,,Static Stack Usage Analysis} for details.
 @end table
 
 @geindex -Wall (gcc)
@@ -12999,7 +13007,7 @@ When no switch @code{-gnatw} is used, this is equivalent to:
 @end quotation
 
 @node Info message Control,Debugging and Assertion Control,Warning Message Control,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat debugging-and-assertion-control}@anchor{f3}@anchor{gnat_ugn/building_executable_programs_with_gnat info-message-control}@anchor{f4}
+@anchor{gnat_ugn/building_executable_programs_with_gnat debugging-and-assertion-control}@anchor{f4}@anchor{gnat_ugn/building_executable_programs_with_gnat info-message-control}@anchor{f5}
 @subsection Info message Control
 
 
@@ -13019,7 +13027,7 @@ GNAT front end.
 @end table
 
 @node Debugging and Assertion Control,Validity Checking,Info message Control,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat id16}@anchor{f5}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id16}@anchor{f6}
 @subsection Debugging and Assertion Control
 
 
@@ -13124,7 +13132,7 @@ is @code{False}, the exception @code{Assert_Failure} is raised.
 @end table
 
 @node Validity Checking,Style Checking,Debugging and Assertion Control,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat id17}@anchor{f6}@anchor{gnat_ugn/building_executable_programs_with_gnat validity-checking}@anchor{e9}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id17}@anchor{f7}@anchor{gnat_ugn/building_executable_programs_with_gnat validity-checking}@anchor{ea}
 @subsection Validity Checking
 
 
@@ -13422,7 +13430,7 @@ the validity checking mode at the program source level, and also allows for
 temporary disabling of validity checks.
 
 @node Style Checking,Run-Time Checks,Validity Checking,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat id18}@anchor{f7}@anchor{gnat_ugn/building_executable_programs_with_gnat style-checking}@anchor{ee}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id18}@anchor{f8}@anchor{gnat_ugn/building_executable_programs_with_gnat style-checking}@anchor{ef}
 @subsection Style Checking
 
 
@@ -14175,7 +14183,7 @@ built-in standard style check options are enabled.
 The switch @code{-gnatyN} clears any previously set style checks.
 
 @node Run-Time Checks,Using gcc for Syntax Checking,Style Checking,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat id19}@anchor{f8}@anchor{gnat_ugn/building_executable_programs_with_gnat run-time-checks}@anchor{ec}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id19}@anchor{f9}@anchor{gnat_ugn/building_executable_programs_with_gnat run-time-checks}@anchor{ed}
 @subsection Run-Time Checks
 
 
@@ -14369,7 +14377,7 @@ on subprogram calls and generic instantiations.
 Note that @code{-gnatE} is not necessary for safety, because in the
 default mode, GNAT ensures statically that the checks would not fail.
 For full details of the effect and use of this switch,
-@ref{c9,,Compiling with gcc}.
+@ref{ca,,Compiling with gcc}.
 @end table
 
 @geindex -fstack-check (gcc)
@@ -14385,7 +14393,7 @@ For full details of the effect and use of this switch,
 @item @code{-fstack-check}
 
 Activates stack overflow checking. For full details of the effect and use of
-this switch see @ref{e7,,Stack Overflow Checking}.
+this switch see @ref{e8,,Stack Overflow Checking}.
 @end table
 
 @geindex Unsuppress
@@ -14396,7 +14404,7 @@ checks) or @code{Unsuppress} (to add back suppressed checks) pragmas in
 the program source.
 
 @node Using gcc for Syntax Checking,Using gcc for Semantic Checking,Run-Time Checks,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat id20}@anchor{f9}@anchor{gnat_ugn/building_executable_programs_with_gnat using-gcc-for-syntax-checking}@anchor{fa}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id20}@anchor{fa}@anchor{gnat_ugn/building_executable_programs_with_gnat using-gcc-for-syntax-checking}@anchor{fb}
 @subsection Using @code{gcc} for Syntax Checking
 
 
@@ -14449,11 +14457,11 @@ Normally, GNAT allows only a single unit in a source file. However, this
 restriction does not apply in syntax-check-only mode, and it is possible
 to check a file containing multiple compilation units concatenated
 together. This is primarily used by the @code{gnatchop} utility
-(@ref{1d,,Renaming Files with gnatchop}).
+(@ref{1e,,Renaming Files with gnatchop}).
 @end table
 
 @node Using gcc for Semantic Checking,Compiling Different Versions of Ada,Using gcc for Syntax Checking,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat id21}@anchor{fb}@anchor{gnat_ugn/building_executable_programs_with_gnat using-gcc-for-semantic-checking}@anchor{fc}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id21}@anchor{fc}@anchor{gnat_ugn/building_executable_programs_with_gnat using-gcc-for-semantic-checking}@anchor{fd}
 @subsection Using @code{gcc} for Semantic Checking
 
 
@@ -14478,13 +14486,13 @@ semantic restrictions on file structuring to operate in this mode:
 
 @item 
 The needed source files must be accessible
-(see @ref{73,,Search Paths and the Run-Time Library (RTL)}).
+(see @ref{74,,Search Paths and the Run-Time Library (RTL)}).
 
 @item 
 Each file must contain only one compilation unit.
 
 @item 
-The file name and unit name must match (@ref{3b,,File Naming Rules}).
+The file name and unit name must match (@ref{3c,,File Naming Rules}).
 @end itemize
 
 The output consists of error messages as appropriate. No object file is
@@ -14500,7 +14508,7 @@ and specifications where a separate body is present).
 @end table
 
 @node Compiling Different Versions of Ada,Character Set Control,Using gcc for Semantic Checking,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat compiling-different-versions-of-ada}@anchor{6}@anchor{gnat_ugn/building_executable_programs_with_gnat id22}@anchor{fd}
+@anchor{gnat_ugn/building_executable_programs_with_gnat compiling-different-versions-of-ada}@anchor{6}@anchor{gnat_ugn/building_executable_programs_with_gnat id22}@anchor{fe}
 @subsection Compiling Different Versions of Ada
 
 
@@ -14665,7 +14673,7 @@ extensions enabled by this switch, see the GNAT reference manual
 @end table
 
 @node Character Set Control,File Naming Control,Compiling Different Versions of Ada,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat character-set-control}@anchor{31}@anchor{gnat_ugn/building_executable_programs_with_gnat id23}@anchor{fe}
+@anchor{gnat_ugn/building_executable_programs_with_gnat character-set-control}@anchor{32}@anchor{gnat_ugn/building_executable_programs_with_gnat id23}@anchor{ff}
 @subsection Character Set Control
 
 
@@ -14776,7 +14784,7 @@ allowed in identifiers
 @end multitable
 
 
-See @ref{23,,Foreign Language Representation} for full details on the
+See @ref{24,,Foreign Language Representation} for full details on the
 implementation of these character sets.
 @end table
 
@@ -14844,7 +14852,7 @@ Brackets encoding only (default value)
 
 
 For full details on these encoding
-methods see @ref{37,,Wide_Character Encodings}.
+methods see @ref{38,,Wide_Character Encodings}.
 Note that brackets coding is always accepted, even if one of the other
 options is specified, so for example @code{-gnatW8} specifies that both
 brackets and UTF-8 encodings will be recognized. The units that are
@@ -14892,7 +14900,7 @@ comments are ended by an appropriate (CR, or CR/LF, or LF) line terminator.
 This is a common mode for many programs with foreign language comments.
 
 @node File Naming Control,Subprogram Inlining Control,Character Set Control,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat file-naming-control}@anchor{ff}@anchor{gnat_ugn/building_executable_programs_with_gnat id24}@anchor{100}
+@anchor{gnat_ugn/building_executable_programs_with_gnat file-naming-control}@anchor{100}@anchor{gnat_ugn/building_executable_programs_with_gnat id24}@anchor{101}
 @subsection File Naming Control
 
 
@@ -14908,11 +14916,11 @@ Activates file name ‘krunching’. @code{n}, a decimal integer in the range
 including the @code{.ads} or @code{.adb} extension). The default is not
 to enable file name krunching.
 
-For the source file naming rules, @ref{3b,,File Naming Rules}.
+For the source file naming rules, @ref{3c,,File Naming Rules}.
 @end table
 
 @node Subprogram Inlining Control,Auxiliary Output Control,File Naming Control,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat id25}@anchor{101}@anchor{gnat_ugn/building_executable_programs_with_gnat subprogram-inlining-control}@anchor{102}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id25}@anchor{102}@anchor{gnat_ugn/building_executable_programs_with_gnat subprogram-inlining-control}@anchor{103}
 @subsection Subprogram Inlining Control
 
 
@@ -14945,7 +14953,7 @@ If you specify this switch the compiler will access these bodies,
 creating an extra source dependency for the resulting object file, and
 where possible, the call will be inlined.
 For further details on when inlining is possible
-see @ref{103,,Inlining of Subprograms}.
+see @ref{104,,Inlining of Subprograms}.
 @end table
 
 @geindex -gnatN (gcc)
@@ -14965,7 +14973,7 @@ inlining, but that is no longer the case.
 @end table
 
 @node Auxiliary Output Control,Debugging Control,Subprogram Inlining Control,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat auxiliary-output-control}@anchor{104}@anchor{gnat_ugn/building_executable_programs_with_gnat id26}@anchor{105}
+@anchor{gnat_ugn/building_executable_programs_with_gnat auxiliary-output-control}@anchor{105}@anchor{gnat_ugn/building_executable_programs_with_gnat id26}@anchor{106}
 @subsection Auxiliary Output Control
 
 
@@ -15035,7 +15043,7 @@ An object file has been generated for every source file.
 @end table
 
 @node Debugging Control,Exception Handling Control,Auxiliary Output Control,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat debugging-control}@anchor{106}@anchor{gnat_ugn/building_executable_programs_with_gnat id27}@anchor{107}
+@anchor{gnat_ugn/building_executable_programs_with_gnat debugging-control}@anchor{107}@anchor{gnat_ugn/building_executable_programs_with_gnat id27}@anchor{108}
 @subsection Debugging Control
 
 
@@ -15384,7 +15392,7 @@ encodings for the rest.
 @end table
 
 @node Exception Handling Control,Units to Sources Mapping Files,Debugging Control,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat exception-handling-control}@anchor{108}@anchor{gnat_ugn/building_executable_programs_with_gnat id28}@anchor{109}
+@anchor{gnat_ugn/building_executable_programs_with_gnat exception-handling-control}@anchor{109}@anchor{gnat_ugn/building_executable_programs_with_gnat id28}@anchor{10a}
 @subsection Exception Handling Control
 
 
@@ -15452,11 +15460,11 @@ is available for the target in use, otherwise it will generate an error.
 
 The same option @code{--RTS} must be used both for @code{gcc}
 and @code{gnatbind}. Passing this option to @code{gnatmake}
-(@ref{d0,,Switches for gnatmake}) will ensure the required consistency
+(@ref{d1,,Switches for gnatmake}) will ensure the required consistency
 through the compilation and binding steps.
 
 @node Units to Sources Mapping Files,Code Generation Control,Exception Handling Control,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat id29}@anchor{10a}@anchor{gnat_ugn/building_executable_programs_with_gnat units-to-sources-mapping-files}@anchor{ea}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id29}@anchor{10b}@anchor{gnat_ugn/building_executable_programs_with_gnat units-to-sources-mapping-files}@anchor{eb}
 @subsection Units to Sources Mapping Files
 
 
@@ -15508,7 +15516,7 @@ mapping file and communicates it to the compiler using this switch.
 @end table
 
 @node Code Generation Control,,Units to Sources Mapping Files,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat code-generation-control}@anchor{10b}@anchor{gnat_ugn/building_executable_programs_with_gnat id30}@anchor{10c}
+@anchor{gnat_ugn/building_executable_programs_with_gnat code-generation-control}@anchor{10c}@anchor{gnat_ugn/building_executable_programs_with_gnat id30}@anchor{10d}
 @subsection Code Generation Control
 
 
@@ -15537,7 +15545,7 @@ there is no point in using @code{-m} switches to improve performance
 unless you actually see a performance improvement.
 
 @node Linker Switches,Binding with gnatbind,Compiler Switches,Building Executable Programs with GNAT
-@anchor{gnat_ugn/building_executable_programs_with_gnat id31}@anchor{10d}@anchor{gnat_ugn/building_executable_programs_with_gnat linker-switches}@anchor{10e}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id31}@anchor{10e}@anchor{gnat_ugn/building_executable_programs_with_gnat linker-switches}@anchor{10f}
 @section Linker Switches
 
 
@@ -15557,7 +15565,7 @@ platforms.
 @end table
 
 @node Binding with gnatbind,Linking with gnatlink,Linker Switches,Building Executable Programs with GNAT
-@anchor{gnat_ugn/building_executable_programs_with_gnat binding-with-gnatbind}@anchor{ca}@anchor{gnat_ugn/building_executable_programs_with_gnat id32}@anchor{10f}
+@anchor{gnat_ugn/building_executable_programs_with_gnat binding-with-gnatbind}@anchor{cb}@anchor{gnat_ugn/building_executable_programs_with_gnat id32}@anchor{110}
 @section Binding with @code{gnatbind}
 
 
@@ -15608,7 +15616,7 @@ to be read by the @code{gnatlink} utility used to link the Ada application.
 @end menu
 
 @node Running gnatbind,Switches for gnatbind,,Binding with gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat id33}@anchor{110}@anchor{gnat_ugn/building_executable_programs_with_gnat running-gnatbind}@anchor{111}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id33}@anchor{111}@anchor{gnat_ugn/building_executable_programs_with_gnat running-gnatbind}@anchor{112}
 @subsection Running @code{gnatbind}
 
 
@@ -15683,7 +15691,7 @@ error: "p.ads" has been modified and must be recompiled
 Now both files must be recompiled as indicated, and then the bind can
 succeed, generating a main program. You need not normally be concerned
 with the contents of this file, but for reference purposes a sample
-binder output file is given in @ref{e,,Example of Binder Output File}.
+binder output file is given in @ref{f,,Example of Binder Output File}.
 
 In most normal usage, the default mode of @code{gnatbind} which is to
 generate the main package in Ada, as described in the previous section.
@@ -15693,7 +15701,7 @@ Ada code provided the @code{-g} switch is used for
 @code{gnatbind} and @code{gnatlink}.
 
 @node Switches for gnatbind,Command-Line Access,Running gnatbind,Binding with gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat id34}@anchor{112}@anchor{gnat_ugn/building_executable_programs_with_gnat switches-for-gnatbind}@anchor{113}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id34}@anchor{113}@anchor{gnat_ugn/building_executable_programs_with_gnat switches-for-gnatbind}@anchor{114}
 @subsection Switches for @code{gnatbind}
 
 
@@ -15888,8 +15896,8 @@ Currently the same as @code{-Ea}.
 
 @item @code{-f`elab-order'}
 
-Force elaboration order. For further details see @ref{114,,Elaboration Control}
-and @ref{f,,Elaboration Order Handling in GNAT}.
+Force elaboration order. For further details see @ref{115,,Elaboration Control}
+and @ref{10,,Elaboration Order Handling in GNAT}.
 @end table
 
 @geindex -F (gnatbind)
@@ -15926,7 +15934,7 @@ Output usage (help) information.
 @item @code{-H}
 
 Legacy elaboration order model enabled. For further details see
-@ref{f,,Elaboration Order Handling in GNAT}.
+@ref{10,,Elaboration Order Handling in GNAT}.
 @end table
 
 @geindex -H32 (gnatbind)
@@ -15937,7 +15945,7 @@ Legacy elaboration order model enabled. For further details see
 @item @code{-H32}
 
 Use 32-bit allocations for @code{__gnat_malloc} (and thus for access types).
-For further details see @ref{115,,Dynamic Allocation Control}.
+For further details see @ref{116,,Dynamic Allocation Control}.
 @end table
 
 @geindex -H64 (gnatbind)
@@ -15950,7 +15958,7 @@ For further details see @ref{115,,Dynamic Allocation Control}.
 @item @code{-H64}
 
 Use 64-bit allocations for @code{__gnat_malloc} (and thus for access types).
-For further details see @ref{115,,Dynamic Allocation Control}.
+For further details see @ref{116,,Dynamic Allocation Control}.
 
 @geindex -I (gnatbind)
 
@@ -15993,11 +16001,11 @@ Output chosen elaboration order.
 @item @code{-L`xxx'}
 
 Bind the units for library building. In this case the @code{adainit} and
-@code{adafinal} procedures (@ref{7e,,Binding with Non-Ada Main Programs})
+@code{adafinal} procedures (@ref{7f,,Binding with Non-Ada Main Programs})
 are renamed to @code{@var{xxx}init} and
 @code{@var{xxx}final}.
 Implies -n.
-(@ref{2a,,GNAT and Libraries}, for more details.)
+(@ref{2b,,GNAT and Libraries}, for more details.)
 
 @geindex -M (gnatbind)
 
@@ -16064,7 +16072,7 @@ Do not look for library files in the system default directory.
 @item @code{--RTS=`rts-path'}
 
 Specifies the default location of the run-time library. Same meaning as the
-equivalent @code{gnatmake} flag (@ref{d0,,Switches for gnatmake}).
+equivalent @code{gnatmake} flag (@ref{d1,,Switches for gnatmake}).
 
 @geindex -o (gnatbind)
 
@@ -16239,7 +16247,7 @@ Enable dynamic stack usage, with @code{n} results stored and displayed
 at program termination. A result is generated when a task
 terminates. Results that can’t be stored are displayed on the fly, at
 task termination. This option is currently not supported on Itanium
-platforms. (See @ref{116,,Dynamic Stack Usage Analysis} for details.)
+platforms. (See @ref{117,,Dynamic Stack Usage Analysis} for details.)
 
 @geindex -v (gnatbind)
 
@@ -16319,7 +16327,7 @@ no arguments.
 @end menu
 
 @node Consistency-Checking Modes,Binder Error Message Control,,Switches for gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat consistency-checking-modes}@anchor{117}@anchor{gnat_ugn/building_executable_programs_with_gnat id35}@anchor{118}
+@anchor{gnat_ugn/building_executable_programs_with_gnat consistency-checking-modes}@anchor{118}@anchor{gnat_ugn/building_executable_programs_with_gnat id35}@anchor{119}
 @subsubsection Consistency-Checking Modes
 
 
@@ -16373,7 +16381,7 @@ case the checking against sources has already been performed by
 @end table
 
 @node Binder Error Message Control,Elaboration Control,Consistency-Checking Modes,Switches for gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat binder-error-message-control}@anchor{119}@anchor{gnat_ugn/building_executable_programs_with_gnat id36}@anchor{11a}
+@anchor{gnat_ugn/building_executable_programs_with_gnat binder-error-message-control}@anchor{11a}@anchor{gnat_ugn/building_executable_programs_with_gnat id36}@anchor{11b}
 @subsubsection Binder Error Message Control
 
 
@@ -16483,12 +16491,12 @@ with extreme care.
 @end table
 
 @node Elaboration Control,Output Control,Binder Error Message Control,Switches for gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat elaboration-control}@anchor{114}@anchor{gnat_ugn/building_executable_programs_with_gnat id37}@anchor{11b}
+@anchor{gnat_ugn/building_executable_programs_with_gnat elaboration-control}@anchor{115}@anchor{gnat_ugn/building_executable_programs_with_gnat id37}@anchor{11c}
 @subsubsection Elaboration Control
 
 
 The following switches provide additional control over the elaboration
-order. For further details see @ref{f,,Elaboration Order Handling in GNAT}.
+order. For further details see @ref{10,,Elaboration Order Handling in GNAT}.
 
 @geindex -f (gnatbind)
 
@@ -16568,7 +16576,7 @@ debugging/experimental use.
 @end table
 
 @node Output Control,Dynamic Allocation Control,Elaboration Control,Switches for gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat id38}@anchor{11c}@anchor{gnat_ugn/building_executable_programs_with_gnat output-control}@anchor{11d}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id38}@anchor{11d}@anchor{gnat_ugn/building_executable_programs_with_gnat output-control}@anchor{11e}
 @subsubsection Output Control
 
 
@@ -16649,7 +16657,7 @@ be used to improve code generation in some cases.
 @end table
 
 @node Dynamic Allocation Control,Binding with Non-Ada Main Programs,Output Control,Switches for gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat dynamic-allocation-control}@anchor{115}@anchor{gnat_ugn/building_executable_programs_with_gnat id39}@anchor{11e}
+@anchor{gnat_ugn/building_executable_programs_with_gnat dynamic-allocation-control}@anchor{116}@anchor{gnat_ugn/building_executable_programs_with_gnat id39}@anchor{11f}
 @subsubsection Dynamic Allocation Control
 
 
@@ -16675,7 +16683,7 @@ unless explicitly overridden by a @code{'Size} clause on the access type.
 These switches are only effective on VMS platforms.
 
 @node Binding with Non-Ada Main Programs,Binding Programs with No Main Subprogram,Dynamic Allocation Control,Switches for gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat binding-with-non-ada-main-programs}@anchor{7e}@anchor{gnat_ugn/building_executable_programs_with_gnat id40}@anchor{11f}
+@anchor{gnat_ugn/building_executable_programs_with_gnat binding-with-non-ada-main-programs}@anchor{7f}@anchor{gnat_ugn/building_executable_programs_with_gnat id40}@anchor{120}
 @subsubsection Binding with Non-Ada Main Programs
 
 
@@ -16684,7 +16692,7 @@ program is in Ada, and that the task of the binder is to generate a
 corresponding function @code{main} that invokes this Ada main
 program. GNAT also supports the building of executable programs where
 the main program is not in Ada, but some of the called routines are
-written in Ada and compiled using GNAT (@ref{2c,,Mixed Language Programming}).
+written in Ada and compiled using GNAT (@ref{2d,,Mixed Language Programming}).
 The following switch is used in this situation:
 
 @quotation
@@ -16771,7 +16779,7 @@ side effect is that this could be the wrong mode for the foreign code
 where floating point computation could be broken after this call.
 
 @node Binding Programs with No Main Subprogram,,Binding with Non-Ada Main Programs,Switches for gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat binding-programs-with-no-main-subprogram}@anchor{120}@anchor{gnat_ugn/building_executable_programs_with_gnat id41}@anchor{121}
+@anchor{gnat_ugn/building_executable_programs_with_gnat binding-programs-with-no-main-subprogram}@anchor{121}@anchor{gnat_ugn/building_executable_programs_with_gnat id41}@anchor{122}
 @subsubsection Binding Programs with No Main Subprogram
 
 
@@ -16802,7 +16810,7 @@ the binder switch
 @end table
 
 @node Command-Line Access,Search Paths for gnatbind,Switches for gnatbind,Binding with gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat command-line-access}@anchor{122}@anchor{gnat_ugn/building_executable_programs_with_gnat id42}@anchor{123}
+@anchor{gnat_ugn/building_executable_programs_with_gnat command-line-access}@anchor{123}@anchor{gnat_ugn/building_executable_programs_with_gnat id42}@anchor{124}
 @subsection Command-Line Access
 
 
@@ -16832,7 +16840,7 @@ required, your main program must set @code{gnat_argc} and
 it.
 
 @node Search Paths for gnatbind,Examples of gnatbind Usage,Command-Line Access,Binding with gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat id43}@anchor{124}@anchor{gnat_ugn/building_executable_programs_with_gnat search-paths-for-gnatbind}@anchor{76}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id43}@anchor{125}@anchor{gnat_ugn/building_executable_programs_with_gnat search-paths-for-gnatbind}@anchor{77}
 @subsection Search Paths for @code{gnatbind}
 
 
@@ -16840,7 +16848,7 @@ The binder takes the name of an ALI file as its argument and needs to
 locate source files as well as other ALI files to verify object consistency.
 
 For source files, it follows exactly the same search rules as @code{gcc}
-(see @ref{73,,Search Paths and the Run-Time Library (RTL)}). For ALI files the
+(see @ref{74,,Search Paths and the Run-Time Library (RTL)}). For ALI files the
 directories searched are:
 
 
@@ -16889,7 +16897,7 @@ of GNAT).
 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
-specified. See @ref{72,,Installing a library}
+specified. See @ref{73,,Installing a library}
 @end itemize
 
 @geindex -I (gnatbind)
@@ -16936,7 +16944,7 @@ in compiling sources from multiple directories. This can make
 development environments much more flexible.
 
 @node Examples of gnatbind Usage,,Search Paths for gnatbind,Binding with gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat examples-of-gnatbind-usage}@anchor{125}@anchor{gnat_ugn/building_executable_programs_with_gnat id44}@anchor{126}
+@anchor{gnat_ugn/building_executable_programs_with_gnat examples-of-gnatbind-usage}@anchor{126}@anchor{gnat_ugn/building_executable_programs_with_gnat id44}@anchor{127}
 @subsection Examples of @code{gnatbind} Usage
 
 
@@ -16965,7 +16973,7 @@ since gnatlink will not be able to find the generated file.
 @end quotation
 
 @node Linking with gnatlink,Using the GNU make Utility,Binding with gnatbind,Building Executable Programs with GNAT
-@anchor{gnat_ugn/building_executable_programs_with_gnat id45}@anchor{127}@anchor{gnat_ugn/building_executable_programs_with_gnat linking-with-gnatlink}@anchor{cb}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id45}@anchor{128}@anchor{gnat_ugn/building_executable_programs_with_gnat linking-with-gnatlink}@anchor{cc}
 @section Linking with @code{gnatlink}
 
 
@@ -16986,7 +16994,7 @@ generated by the @code{gnatbind} to determine this list.
 @end menu
 
 @node Running gnatlink,Switches for gnatlink,,Linking with gnatlink
-@anchor{gnat_ugn/building_executable_programs_with_gnat id46}@anchor{128}@anchor{gnat_ugn/building_executable_programs_with_gnat running-gnatlink}@anchor{129}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id46}@anchor{129}@anchor{gnat_ugn/building_executable_programs_with_gnat running-gnatlink}@anchor{12a}
 @subsection Running @code{gnatlink}
 
 
@@ -17045,8 +17053,8 @@ $ gnatlink my_prog -Wl,-Map,MAPFILE
 
 Using @code{linker options} it is possible to set the program stack and
 heap size.
-See @ref{12a,,Setting Stack Size from gnatlink} and
-@ref{12b,,Setting Heap Size from gnatlink}.
+See @ref{12b,,Setting Stack Size from gnatlink} and
+@ref{12c,,Setting Heap Size from gnatlink}.
 
 @code{gnatlink} determines the list of objects required by the Ada
 program and prepends them to the list of objects passed to the linker.
@@ -17055,7 +17063,7 @@ program and prepends them to the list of objects passed to the linker.
 presented to the linker.
 
 @node Switches for gnatlink,,Running gnatlink,Linking with gnatlink
-@anchor{gnat_ugn/building_executable_programs_with_gnat id47}@anchor{12c}@anchor{gnat_ugn/building_executable_programs_with_gnat switches-for-gnatlink}@anchor{12d}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id47}@anchor{12d}@anchor{gnat_ugn/building_executable_programs_with_gnat switches-for-gnatlink}@anchor{12e}
 @subsection Switches for @code{gnatlink}
 
 
@@ -17219,7 +17227,7 @@ inserted after your command name. Thus in the above example the compiler
 command that will be used by @code{gnatlink} will be @code{foo -c -x -y}.
 A limitation of this syntax is that the name and path name of the executable
 itself must not include any embedded spaces. If the compiler executable is
-different from the default one (gcc or <prefix>-gcc), then the back-end
+different from the default one (gcc or <prefix>-gcc), then the back end
 switches in the ALI file are not used to compile the binder generated source.
 For example, this is the case with @code{--GCC="foo -x -y"}. But the back end
 switches will be used for @code{--GCC="gcc -gnatv"}. If several
@@ -17250,7 +17258,7 @@ switch.
 @end table
 
 @node Using the GNU make Utility,,Linking with gnatlink,Building Executable Programs with GNAT
-@anchor{gnat_ugn/building_executable_programs_with_gnat id48}@anchor{12e}@anchor{gnat_ugn/building_executable_programs_with_gnat using-the-gnu-make-utility}@anchor{70}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id48}@anchor{12f}@anchor{gnat_ugn/building_executable_programs_with_gnat using-the-gnu-make-utility}@anchor{71}
 @section Using the GNU @code{make} Utility
 
 
@@ -17259,7 +17267,7 @@ switch.
 
 This chapter offers some examples of makefiles that solve specific
 problems. It does not explain how to write a makefile, nor does it try to replace the
-@code{gnatmake} utility (@ref{c8,,Building with gnatmake}).
+@code{gnatmake} utility (@ref{c9,,Building with gnatmake}).
 
 All the examples in this section are specific to the GNU version of
 make. Although @code{make} is a standard utility, and the basic language
@@ -17271,11 +17279,12 @@ is the same, these examples use some advanced features found only in
 * Automatically Creating a List of Directories:: 
 * Generating the Command Line Switches:: 
 * Overcoming Command Line Length Limits:: 
+* GNAT with the LLVM Back End:: 
 
 @end menu
 
 @node Using gnatmake in a Makefile,Automatically Creating a List of Directories,,Using the GNU make Utility
-@anchor{gnat_ugn/building_executable_programs_with_gnat id49}@anchor{12f}@anchor{gnat_ugn/building_executable_programs_with_gnat using-gnatmake-in-a-makefile}@anchor{130}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id49}@anchor{130}@anchor{gnat_ugn/building_executable_programs_with_gnat using-gnatmake-in-a-makefile}@anchor{131}
 @subsection Using gnatmake in a Makefile
 
 
@@ -17294,7 +17303,7 @@ the appropriate directories.
 
 Note that you should also read the example on how to automatically
 create the list of directories
-(@ref{131,,Automatically Creating a List of Directories})
+(@ref{132,,Automatically Creating a List of Directories})
 which might help you in case your project has a lot of subdirectories.
 
 @example
@@ -17374,7 +17383,7 @@ clean::
 @end example
 
 @node Automatically Creating a List of Directories,Generating the Command Line Switches,Using gnatmake in a Makefile,Using the GNU make Utility
-@anchor{gnat_ugn/building_executable_programs_with_gnat automatically-creating-a-list-of-directories}@anchor{131}@anchor{gnat_ugn/building_executable_programs_with_gnat id50}@anchor{132}
+@anchor{gnat_ugn/building_executable_programs_with_gnat automatically-creating-a-list-of-directories}@anchor{132}@anchor{gnat_ugn/building_executable_programs_with_gnat id50}@anchor{133}
 @subsection Automatically Creating a List of Directories
 
 
@@ -17447,12 +17456,12 @@ DIRS := $@{shell find $@{ROOT_DIRECTORY@} -type d -print@}
 @end example
 
 @node Generating the Command Line Switches,Overcoming Command Line Length Limits,Automatically Creating a List of Directories,Using the GNU make Utility
-@anchor{gnat_ugn/building_executable_programs_with_gnat generating-the-command-line-switches}@anchor{133}@anchor{gnat_ugn/building_executable_programs_with_gnat id51}@anchor{134}
+@anchor{gnat_ugn/building_executable_programs_with_gnat generating-the-command-line-switches}@anchor{134}@anchor{gnat_ugn/building_executable_programs_with_gnat id51}@anchor{135}
 @subsection Generating the Command Line Switches
 
 
 Once you have created the list of directories as explained in the
-previous section (@ref{131,,Automatically Creating a List of Directories}),
+previous section (@ref{132,,Automatically Creating a List of Directories}),
 you can easily generate the command line arguments to pass to gnatmake.
 
 For the sake of completeness, this example assumes that the source path
@@ -17472,8 +17481,8 @@ all:
         gnatmake $@{GNATMAKE_SWITCHES@} main_unit
 @end example
 
-@node Overcoming Command Line Length Limits,,Generating the Command Line Switches,Using the GNU make Utility
-@anchor{gnat_ugn/building_executable_programs_with_gnat id52}@anchor{135}@anchor{gnat_ugn/building_executable_programs_with_gnat overcoming-command-line-length-limits}@anchor{136}
+@node Overcoming Command Line Length Limits,GNAT with the LLVM Back End,Generating the Command Line Switches,Using the GNU make Utility
+@anchor{gnat_ugn/building_executable_programs_with_gnat id52}@anchor{136}@anchor{gnat_ugn/building_executable_programs_with_gnat overcoming-command-line-length-limits}@anchor{137}
 @subsection Overcoming Command Line Length Limits
 
 
@@ -17488,7 +17497,7 @@ even none on most systems).
 
 It assumes that you have created a list of directories in your Makefile,
 using one of the methods presented in
-@ref{131,,Automatically Creating a List of Directories}.
+@ref{132,,Automatically Creating a List of Directories}.
 For the sake of completeness, we assume that the object
 path (where the ALI files are found) is different from the sources patch.
 
@@ -17530,8 +17539,112 @@ all:
         gnatmake main_unit
 @end example
 
+@node GNAT with the LLVM Back End,,Overcoming Command Line Length Limits,Using the GNU make Utility
+@anchor{gnat_ugn/building_executable_programs_with_gnat gnat-with-the-llvm-back-end}@anchor{138}@anchor{gnat_ugn/building_executable_programs_with_gnat gnatllvm}@anchor{7}
+@subsection GNAT with the LLVM Back End
+
+
+This section outlines the usage of the GNAT compiler with the LLVM
+back end and highlights its key limitations. Certain GNAT versions,
+referred to as GNAT LLVM, include an alternative LLVM back end
+alongside the GCC back end, providing access to utilities that operate
+at the LLVM Intermediate Representation (IR) level. This also enhances
+safety by facilitating dissimilar redundancy through diverse code
+generation techniques, allowing for the creation of two distinct
+binaries from the same source code.
+
+Although both GNAT LLVM and the GCC-based GNAT follow most ABI rules,
+there are some cases where there you may encounter an incompatibility
+between the two compilers.  One such case for the 64-bit Intel X86 is
+a difference in parameter passing when a structure that consists of 64
+bits is passed. The native LLVM handling (and hence that of GNAT LLVM)
+and @code{clang} disagree in this case. GCC follows @code{clang}. The formal
+ABI agrees with LLVM.
+
+In any case, we don’t recommend you link code compiled with GNAT LLVM
+to code compiled by the GCC version of GNAT. This is a specific case
+of the general rule that you should compile all your Ada code with the
+same version of GNAT. Both @code{gnatmake} and @code{gprbuild} ensure this
+is done.
+
+You may, however, run into this incompatibility if you pass such a
+record between C and Ada. In general, we recommend keeping the data
+passed between C and Ada as simple as practical.
+
+GNAT LLVM currently provides limited support for debugging data. It
+provides full line number information for declarations and statements,
+but not sufficient debugging data to display all Ada data
+structures. GNAT LLVM outputs complete debugging data only for types
+with a direct equivalent in C, namely records without discriminants
+and constrained arrays whose dimensions are known at compile time. You
+will not be able to use @code{gdb} print commands to look at objects not
+of those types or to display components of those types. You can use
+low-level @code{gdb} commands that display memory to view such data
+provided you know how they’re laid out.  Debugging information may
+also be limited for bitfields (fields whose size and position
+aren’t on byte boundaries)
+
+In addition, debugging information may be confusing if you have
+@code{out} parameters to subprograms. If you have a procedure with only
+one @code{out} parameter, GNAT LLVM converts that to a function returning
+an object of that type. If you have multiple @code{out} parameters or
+have a function that also has an @code{out} parameter, GNAT LLVM converts
+that subprogram into a function that returns a record where each field
+is either an @code{out} parameter or the function return value, if any.
+The debug information reflects these transformations and not the original
+Ada source code.
+
+GNAT LLVM doesn’t fully implement the :switch:@code{-fcheck-stack} switch.
+When you specify it, the code generated by GNAT LLVM tests for allocating
+overly-large items on the stack, but not all cases of stack overflow.  For
+example, if you have a very deep recursion where each call only uses a
+small amount of stack and the total stack depth exceeds the amount of
+available stack, the program will be terminated by a signal instead of
+raising an Ada exception.
+
+GNAT LLVM doesn’t support the @code{Scalar_Storage_Order} pragma except when
+it’s used to confirm the chosen storage order. This is because this facility
+is provided by GCC but not by LLVM.
+
+GNAT LLVM doesn’t support Convention C++, which provides so-called
+‘name mangling’ by encoding parameter and return datatypes into a
+function name.
+
+
+We provide two options that you can use to build code with GNAT LLVM:
+
+
+@itemize *
+
+@item 
+GNAT LLVM includes a version of @code{gnatmake} called
+@code{llvm-gnatmake}, which is equivalent to @code{gnatmake} and has the
+same switches, except that it uses GNAT LLVM instead of the GCC
+version of GNAT.
+
+@item 
+@code{gprbuild} can detect and use GNAT LLVM when it is installed.
+
+@code{gprbuild} uses the first applicable compiler on the executable
+search path, including GNAT LLVM.  An easy way to build with GNAT
+LLVM is to make it available on the operating system’s search path
+before any other Ada compiler (such as the GCC version of GNAT). To
+avoid accidentally using a different compiler than the one you want
+to use, we recommend generating an explicit toolchain configuration
+file with @code{gprconfig} and using it with @code{gprbuild}; see the
+`GPRbuild and GPR Companion Tools User’s Guide' for details. You
+can determine from the first line of the @code{.ali} file
+which version of GNAT built that file because it contains either
+:code:@code{GNAT} or :code:@code{GNAT-LLVM}.
+@end itemize
+
+
+GNAT LLVM understands the same target triplets as the GCC version of
+GNAT.
+
+
 @node GNAT Utility Programs,GNAT and Program Execution,Building Executable Programs with GNAT,Top
-@anchor{gnat_ugn/gnat_utility_programs doc}@anchor{137}@anchor{gnat_ugn/gnat_utility_programs gnat-utility-programs}@anchor{b}@anchor{gnat_ugn/gnat_utility_programs id1}@anchor{138}
+@anchor{gnat_ugn/gnat_utility_programs doc}@anchor{139}@anchor{gnat_ugn/gnat_utility_programs gnat-utility-programs}@anchor{c}@anchor{gnat_ugn/gnat_utility_programs id1}@anchor{13a}
 @chapter GNAT Utility Programs
 
 
@@ -17542,10 +17655,10 @@ This chapter describes a number of utility programs:
 @itemize *
 
 @item 
-@ref{139,,The File Cleanup Utility gnatclean}
+@ref{13b,,The File Cleanup Utility gnatclean}
 
 @item 
-@ref{13a,,The GNAT Library Browser gnatls}
+@ref{13c,,The GNAT Library Browser gnatls}
 @end itemize
 
 Other GNAT utilities are described elsewhere in this manual:
@@ -17554,16 +17667,16 @@ Other GNAT utilities are described elsewhere in this manual:
 @itemize *
 
 @item 
-@ref{42,,Handling Arbitrary File Naming Conventions with gnatname}
+@ref{43,,Handling Arbitrary File Naming Conventions with gnatname}
 
 @item 
-@ref{4c,,File Name Krunching with gnatkr}
+@ref{4d,,File Name Krunching with gnatkr}
 
 @item 
-@ref{1d,,Renaming Files with gnatchop}
+@ref{1e,,Renaming Files with gnatchop}
 
 @item 
-@ref{90,,Preprocessing with gnatprep}
+@ref{91,,Preprocessing with gnatprep}
 @end itemize
 
 @menu
@@ -17573,7 +17686,7 @@ Other GNAT utilities are described elsewhere in this manual:
 @end menu
 
 @node The File Cleanup Utility gnatclean,The GNAT Library Browser gnatls,,GNAT Utility Programs
-@anchor{gnat_ugn/gnat_utility_programs id2}@anchor{13b}@anchor{gnat_ugn/gnat_utility_programs the-file-cleanup-utility-gnatclean}@anchor{139}
+@anchor{gnat_ugn/gnat_utility_programs id2}@anchor{13d}@anchor{gnat_ugn/gnat_utility_programs the-file-cleanup-utility-gnatclean}@anchor{13b}
 @section The File Cleanup Utility @code{gnatclean}
 
 
@@ -17593,7 +17706,7 @@ generated files and executable files.
 @end menu
 
 @node Running gnatclean,Switches for gnatclean,,The File Cleanup Utility gnatclean
-@anchor{gnat_ugn/gnat_utility_programs id3}@anchor{13c}@anchor{gnat_ugn/gnat_utility_programs running-gnatclean}@anchor{13d}
+@anchor{gnat_ugn/gnat_utility_programs id3}@anchor{13e}@anchor{gnat_ugn/gnat_utility_programs running-gnatclean}@anchor{13f}
 @subsection Running @code{gnatclean}
 
 
@@ -17617,7 +17730,7 @@ linker. In information-only mode, specified by switch
 normal mode, but doesn’t actually delete any files.
 
 @node Switches for gnatclean,,Running gnatclean,The File Cleanup Utility gnatclean
-@anchor{gnat_ugn/gnat_utility_programs id4}@anchor{13e}@anchor{gnat_ugn/gnat_utility_programs switches-for-gnatclean}@anchor{13f}
+@anchor{gnat_ugn/gnat_utility_programs id4}@anchor{140}@anchor{gnat_ugn/gnat_utility_programs switches-for-gnatclean}@anchor{141}
 @subsection Switches for @code{gnatclean}
 
 
@@ -17770,7 +17883,7 @@ Verbose mode.
 @item @code{-vP`x'}
 
 Indicates the verbosity of the parsing of GNAT project files.
-@ref{d1,,Switches Related to Project Files}.
+@ref{d2,,Switches Related to Project Files}.
 @end table
 
 @geindex -X (gnatclean)
@@ -17783,7 +17896,7 @@ Indicates the verbosity of the parsing of GNAT project files.
 Indicates that external variable @code{name} has the value @code{value}.
 The Project Manager will use this value for occurrences of
 @code{external(name)} when parsing the project file.
-See @ref{d1,,Switches Related to Project Files}.
+See @ref{d2,,Switches Related to Project Files}.
 @end table
 
 @geindex -aO (gnatclean)
@@ -17821,7 +17934,7 @@ where @code{gnatclean} was invoked.
 @end table
 
 @node The GNAT Library Browser gnatls,,The File Cleanup Utility gnatclean,GNAT Utility Programs
-@anchor{gnat_ugn/gnat_utility_programs id5}@anchor{140}@anchor{gnat_ugn/gnat_utility_programs the-gnat-library-browser-gnatls}@anchor{13a}
+@anchor{gnat_ugn/gnat_utility_programs id5}@anchor{142}@anchor{gnat_ugn/gnat_utility_programs the-gnat-library-browser-gnatls}@anchor{13c}
 @section The GNAT Library Browser @code{gnatls}
 
 
@@ -17842,7 +17955,7 @@ as well as various characteristics.
 @end menu
 
 @node Running gnatls,Switches for gnatls,,The GNAT Library Browser gnatls
-@anchor{gnat_ugn/gnat_utility_programs id6}@anchor{141}@anchor{gnat_ugn/gnat_utility_programs running-gnatls}@anchor{142}
+@anchor{gnat_ugn/gnat_utility_programs id6}@anchor{143}@anchor{gnat_ugn/gnat_utility_programs running-gnatls}@anchor{144}
 @subsection Running @code{gnatls}
 
 
@@ -17856,7 +17969,7 @@ $ gnatls switches object_or_ali_file
 @end quotation
 
 The main argument is the list of object or @code{ali} files
-(see @ref{28,,The Ada Library Information Files})
+(see @ref{29,,The Ada Library Information Files})
 for which you are requesting information.
 
 In the default mode, without additional options, @code{gnatls} produces a
@@ -17922,7 +18035,7 @@ version of the same source that has been modified.
 @end table
 
 @node Switches for gnatls,Example of gnatls Usage,Running gnatls,The GNAT Library Browser gnatls
-@anchor{gnat_ugn/gnat_utility_programs id7}@anchor{143}@anchor{gnat_ugn/gnat_utility_programs switches-for-gnatls}@anchor{144}
+@anchor{gnat_ugn/gnat_utility_programs id7}@anchor{145}@anchor{gnat_ugn/gnat_utility_programs switches-for-gnatls}@anchor{146}
 @subsection Switches for @code{gnatls}
 
 
@@ -18037,7 +18150,7 @@ specified on the same command.
 @item @code{-aO`dir'}, @code{-aI`dir'}, @code{-I`dir'}, @code{-I-}, @code{-nostdinc}
 
 Source path manipulation. It has the same meaning as the equivalent
-@code{gnatmake} switches (@ref{d0,,Switches for gnatmake}).
+@code{gnatmake} switches (@ref{d1,,Switches for gnatmake}).
 @end table
 
 @geindex -aP (gnatls)
@@ -18059,7 +18172,7 @@ Add @code{dir} at the beginning of the project search dir.
 
 Specifies the default location of the runtime library. It has the
 same meaning as the equivalent @code{gnatmake} switch
-(@ref{d0,,Switches for gnatmake}).
+(@ref{d1,,Switches for gnatmake}).
 @end table
 
 @geindex -v (gnatls)
@@ -18105,7 +18218,7 @@ by the user.
 @end table
 
 @node Example of gnatls Usage,,Switches for gnatls,The GNAT Library Browser gnatls
-@anchor{gnat_ugn/gnat_utility_programs example-of-gnatls-usage}@anchor{145}@anchor{gnat_ugn/gnat_utility_programs id8}@anchor{146}
+@anchor{gnat_ugn/gnat_utility_programs example-of-gnatls-usage}@anchor{147}@anchor{gnat_ugn/gnat_utility_programs id8}@anchor{148}
 @subsection Example of @code{gnatls} Usage
 
 
@@ -18191,7 +18304,7 @@ instr.ads
 @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 doc}@anchor{147}@anchor{gnat_ugn/gnat_and_program_execution gnat-and-program-execution}@anchor{c}@anchor{gnat_ugn/gnat_and_program_execution id1}@anchor{148}
+@anchor{gnat_ugn/gnat_and_program_execution doc}@anchor{149}@anchor{gnat_ugn/gnat_and_program_execution gnat-and-program-execution}@anchor{d}@anchor{gnat_ugn/gnat_and_program_execution id1}@anchor{14a}
 @chapter GNAT and Program Execution
 
 
@@ -18201,25 +18314,25 @@ This chapter covers several topics:
 @itemize *
 
 @item 
-@ref{149,,Running and Debugging Ada Programs}
+@ref{14b,,Running and Debugging Ada Programs}
 
 @item 
-@ref{14a,,Profiling}
+@ref{14c,,Profiling}
 
 @item 
-@ref{14b,,Improving Performance}
+@ref{14d,,Improving Performance}
 
 @item 
-@ref{14c,,Overflow Check Handling in GNAT}
+@ref{14e,,Overflow Check Handling in GNAT}
 
 @item 
-@ref{14d,,Performing Dimensionality Analysis in GNAT}
+@ref{14f,,Performing Dimensionality Analysis in GNAT}
 
 @item 
-@ref{14e,,Stack Related Facilities}
+@ref{150,,Stack Related Facilities}
 
 @item 
-@ref{14f,,Memory Management Issues}
+@ref{151,,Memory Management Issues}
 @end itemize
 
 @menu
@@ -18234,7 +18347,7 @@ This chapter covers several topics:
 @end menu
 
 @node Running and Debugging Ada Programs,Profiling,,GNAT and Program Execution
-@anchor{gnat_ugn/gnat_and_program_execution id2}@anchor{149}@anchor{gnat_ugn/gnat_and_program_execution running-and-debugging-ada-programs}@anchor{150}
+@anchor{gnat_ugn/gnat_and_program_execution id2}@anchor{14b}@anchor{gnat_ugn/gnat_and_program_execution running-and-debugging-ada-programs}@anchor{152}
 @section Running and Debugging Ada Programs
 
 
@@ -18288,7 +18401,7 @@ the incorrect user program.
 @end menu
 
 @node The GNAT Debugger GDB,Running GDB,,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution id3}@anchor{151}@anchor{gnat_ugn/gnat_and_program_execution the-gnat-debugger-gdb}@anchor{152}
+@anchor{gnat_ugn/gnat_and_program_execution id3}@anchor{153}@anchor{gnat_ugn/gnat_and_program_execution the-gnat-debugger-gdb}@anchor{154}
 @subsection The GNAT Debugger GDB
 
 
@@ -18346,7 +18459,7 @@ 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{153}@anchor{gnat_ugn/gnat_and_program_execution running-gdb}@anchor{154}
+@anchor{gnat_ugn/gnat_and_program_execution id4}@anchor{155}@anchor{gnat_ugn/gnat_and_program_execution running-gdb}@anchor{156}
 @subsection Running GDB
 
 
@@ -18373,7 +18486,7 @@ exactly as if the debugger were not present. The following section
 describes some of the additional commands that you can give 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 id5}@anchor{155}@anchor{gnat_ugn/gnat_and_program_execution introduction-to-gdb-commands}@anchor{156}
+@anchor{gnat_ugn/gnat_and_program_execution id5}@anchor{157}@anchor{gnat_ugn/gnat_and_program_execution introduction-to-gdb-commands}@anchor{158}
 @subsection Introduction to GDB Commands
 
 
@@ -18587,7 +18700,7 @@ characters need be typed to disambiguate the command (e.g., “br” for
 @code{breakpoint}).
 
 @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{157}@anchor{gnat_ugn/gnat_and_program_execution using-ada-expressions}@anchor{158}
+@anchor{gnat_ugn/gnat_and_program_execution id6}@anchor{159}@anchor{gnat_ugn/gnat_and_program_execution using-ada-expressions}@anchor{15a}
 @subsection Using Ada Expressions
 
 
@@ -18625,7 +18738,7 @@ their packages, regardless of context. Where this causes ambiguity,
 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 calling-user-defined-subprograms}@anchor{159}@anchor{gnat_ugn/gnat_and_program_execution id7}@anchor{15a}
+@anchor{gnat_ugn/gnat_and_program_execution calling-user-defined-subprograms}@anchor{15b}@anchor{gnat_ugn/gnat_and_program_execution id7}@anchor{15c}
 @subsection Calling User-Defined Subprograms
 
 
@@ -18684,7 +18797,7 @@ elements directly from GDB, you can write a callable procedure that prints
 the elements in the format you desire.
 
 @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 id8}@anchor{15b}@anchor{gnat_ugn/gnat_and_program_execution using-the-next-command-in-a-function}@anchor{15c}
+@anchor{gnat_ugn/gnat_and_program_execution id8}@anchor{15d}@anchor{gnat_ugn/gnat_and_program_execution using-the-next-command-in-a-function}@anchor{15e}
 @subsection Using the `next' Command in a Function
 
 
@@ -18707,7 +18820,7 @@ 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 id9}@anchor{15d}@anchor{gnat_ugn/gnat_and_program_execution stopping-when-ada-exceptions-are-raised}@anchor{15e}
+@anchor{gnat_ugn/gnat_and_program_execution id9}@anchor{15f}@anchor{gnat_ugn/gnat_and_program_execution stopping-when-ada-exceptions-are-raised}@anchor{160}
 @subsection Stopping When Ada Exceptions Are Raised
 
 
@@ -18764,7 +18877,7 @@ argument, prints out only those exceptions whose name matches `regexp'.
 @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{15f}@anchor{gnat_ugn/gnat_and_program_execution id10}@anchor{160}
+@anchor{gnat_ugn/gnat_and_program_execution ada-tasks}@anchor{161}@anchor{gnat_ugn/gnat_and_program_execution id10}@anchor{162}
 @subsection Ada Tasks
 
 
@@ -18851,7 +18964,7 @@ see @cite{Debugging with GDB}.
 @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{161}@anchor{gnat_ugn/gnat_and_program_execution id11}@anchor{162}
+@anchor{gnat_ugn/gnat_and_program_execution debugging-generic-units}@anchor{163}@anchor{gnat_ugn/gnat_and_program_execution id11}@anchor{164}
 @subsection Debugging Generic Units
 
 
@@ -18911,7 +19024,7 @@ variables, as you do for 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 id12}@anchor{163}@anchor{gnat_ugn/gnat_and_program_execution remote-debugging-with-gdbserver}@anchor{164}
+@anchor{gnat_ugn/gnat_and_program_execution id12}@anchor{165}@anchor{gnat_ugn/gnat_and_program_execution remote-debugging-with-gdbserver}@anchor{166}
 @subsection Remote Debugging with gdbserver
 
 
@@ -18970,7 +19083,7 @@ 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{165}@anchor{gnat_ugn/gnat_and_program_execution id13}@anchor{166}
+@anchor{gnat_ugn/gnat_and_program_execution gnat-abnormal-termination-or-failure-to-terminate}@anchor{167}@anchor{gnat_ugn/gnat_and_program_execution id13}@anchor{168}
 @subsection GNAT Abnormal Termination or Failure to Terminate
 
 
@@ -19025,16 +19138,16 @@ 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{152,,The GNAT Debugger GDB} for caveats). The
+would on a C program (but @ref{154,,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
+@code{gnat1} and by the @code{gcc} back end, 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 id14}@anchor{167}@anchor{gnat_ugn/gnat_and_program_execution naming-conventions-for-gnat-source-files}@anchor{168}
+@anchor{gnat_ugn/gnat_and_program_execution id14}@anchor{169}@anchor{gnat_ugn/gnat_and_program_execution naming-conventions-for-gnat-source-files}@anchor{16a}
 @subsection Naming Conventions for GNAT Source Files
 
 
@@ -19065,7 +19178,7 @@ files, such as @code{sem_aggr.adb} for aggregates and
 All files prefixed with @code{exp} perform normalization and
 expansion of the intermediate representation (abstract syntax tree, or AST).
 The expansion has the effect of lowering the semantic level of the AST to
-a level closer to what the backend can handle. For example, it converts
+a level closer to what the back end can handle. For example, it converts
 tasking operations into calls to the appropriate runtime routines.
 These files use the same numbering scheme as the parser and semantics files.
 For example, the construction of record initialization procedures is done in
@@ -19124,7 +19237,7 @@ 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 getting-internal-debugging-information}@anchor{169}@anchor{gnat_ugn/gnat_and_program_execution id15}@anchor{16a}
+@anchor{gnat_ugn/gnat_and_program_execution getting-internal-debugging-information}@anchor{16b}@anchor{gnat_ugn/gnat_and_program_execution id15}@anchor{16c}
 @subsection Getting Internal Debugging Information
 
 
@@ -19152,7 +19265,7 @@ are replaced with run-time calls.
 @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 id16}@anchor{16b}@anchor{gnat_ugn/gnat_and_program_execution stack-traceback}@anchor{16c}
+@anchor{gnat_ugn/gnat_and_program_execution id16}@anchor{16d}@anchor{gnat_ugn/gnat_and_program_execution stack-traceback}@anchor{16e}
 @subsection Stack Traceback
 
 
@@ -19181,7 +19294,7 @@ is enabled and no exception is raised during program execution.
 @end menu
 
 @node Non-Symbolic Traceback,Symbolic Traceback,,Stack Traceback
-@anchor{gnat_ugn/gnat_and_program_execution id17}@anchor{16d}@anchor{gnat_ugn/gnat_and_program_execution non-symbolic-traceback}@anchor{16e}
+@anchor{gnat_ugn/gnat_and_program_execution id17}@anchor{16f}@anchor{gnat_ugn/gnat_and_program_execution non-symbolic-traceback}@anchor{170}
 @subsubsection Non-Symbolic Traceback
 
 
@@ -19198,7 +19311,7 @@ instructions.  To enable this feature you must use the @code{-E}
 runtime as part of exception information.
 
 You can translate this information using the @code{addr2line} tool, provided that
-the program is compiled with debugging options (see @ref{dd,,Compiler Switches})
+the program is compiled with debugging options (see @ref{de,,Compiler Switches})
 and linked at a fixed position with @code{-no-pie}.
 
 Here’s a simple example with @code{gnatmake}:
@@ -19315,7 +19428,7 @@ $ addr2line -e stb -a -f -p --demangle=gnat 0x401373 0x40138b
 From this traceback, we can see that the exception was raised in @code{stb.adb}
 at line 5, which was reached from a procedure call in @code{stb.adb} at line
 10, and so on. @code{b~std.adb} is the binder file, which contains the
-call to the main program; @ref{111,,Running gnatbind}. The remaining entries are
+call to the main program; @ref{112,,Running gnatbind}. The remaining entries are
 assorted runtime routines. The output will vary from platform to platform.
 
 You can also use @code{GDB} with these traceback addresses to debug
@@ -19503,7 +19616,7 @@ addresses need to be specified in C format, with a leading ‘0x’).
 @geindex symbolic
 
 @node Symbolic Traceback,,Non-Symbolic Traceback,Stack Traceback
-@anchor{gnat_ugn/gnat_and_program_execution id18}@anchor{16f}@anchor{gnat_ugn/gnat_and_program_execution symbolic-traceback}@anchor{170}
+@anchor{gnat_ugn/gnat_and_program_execution id18}@anchor{171}@anchor{gnat_ugn/gnat_and_program_execution symbolic-traceback}@anchor{172}
 @subsubsection Symbolic Traceback
 
 
@@ -19622,7 +19735,7 @@ 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{171}@anchor{gnat_ugn/gnat_and_program_execution pretty-printers-for-the-gnat-runtime}@anchor{172}
+@anchor{gnat_ugn/gnat_and_program_execution id19}@anchor{173}@anchor{gnat_ugn/gnat_and_program_execution pretty-printers-for-the-gnat-runtime}@anchor{174}
 @subsection Pretty-Printers for the GNAT runtime
 
 
@@ -19731,7 +19844,7 @@ for more information.
 @geindex Profiling
 
 @node Profiling,Improving Performance,Running and Debugging Ada Programs,GNAT and Program Execution
-@anchor{gnat_ugn/gnat_and_program_execution id20}@anchor{173}@anchor{gnat_ugn/gnat_and_program_execution profiling}@anchor{14a}
+@anchor{gnat_ugn/gnat_and_program_execution id20}@anchor{175}@anchor{gnat_ugn/gnat_and_program_execution profiling}@anchor{14c}
 @section Profiling
 
 
@@ -19747,7 +19860,7 @@ This section describes how to use the @code{gprof} profiler tool on Ada programs
 @end menu
 
 @node Profiling an Ada Program with gprof,,,Profiling
-@anchor{gnat_ugn/gnat_and_program_execution id21}@anchor{174}@anchor{gnat_ugn/gnat_and_program_execution profiling-an-ada-program-with-gprof}@anchor{175}
+@anchor{gnat_ugn/gnat_and_program_execution id21}@anchor{176}@anchor{gnat_ugn/gnat_and_program_execution profiling-an-ada-program-with-gprof}@anchor{177}
 @subsection Profiling an Ada Program with gprof
 
 
@@ -19802,7 +19915,7 @@ to interpret the results.
 @end menu
 
 @node Compilation for profiling,Program execution,,Profiling an Ada Program with gprof
-@anchor{gnat_ugn/gnat_and_program_execution compilation-for-profiling}@anchor{176}@anchor{gnat_ugn/gnat_and_program_execution id22}@anchor{177}
+@anchor{gnat_ugn/gnat_and_program_execution compilation-for-profiling}@anchor{178}@anchor{gnat_ugn/gnat_and_program_execution id22}@anchor{179}
 @subsubsection Compilation for profiling
 
 
@@ -19833,7 +19946,7 @@ Note that on Windows, @code{gprof} does not support PIE. You should add
 the @code{-no-pie} switch to the linker flags to disable PIE.
 
 @node Program execution,Running gprof,Compilation for profiling,Profiling an Ada Program with gprof
-@anchor{gnat_ugn/gnat_and_program_execution id23}@anchor{178}@anchor{gnat_ugn/gnat_and_program_execution program-execution}@anchor{179}
+@anchor{gnat_ugn/gnat_and_program_execution id23}@anchor{17a}@anchor{gnat_ugn/gnat_and_program_execution program-execution}@anchor{17b}
 @subsubsection Program execution
 
 
@@ -19848,7 +19961,7 @@ generated in the directory where the program was launched from. If this file
 already exists, it will be overwritten by running the program.
 
 @node Running gprof,Interpretation of profiling results,Program execution,Profiling an Ada Program with gprof
-@anchor{gnat_ugn/gnat_and_program_execution id24}@anchor{17a}@anchor{gnat_ugn/gnat_and_program_execution running-gprof}@anchor{17b}
+@anchor{gnat_ugn/gnat_and_program_execution id24}@anchor{17c}@anchor{gnat_ugn/gnat_and_program_execution running-gprof}@anchor{17d}
 @subsubsection Running gprof
 
 
@@ -19960,7 +20073,7 @@ switch.
 @end table
 
 @node Interpretation of profiling results,,Running gprof,Profiling an Ada Program with gprof
-@anchor{gnat_ugn/gnat_and_program_execution id25}@anchor{17c}@anchor{gnat_ugn/gnat_and_program_execution interpretation-of-profiling-results}@anchor{17d}
+@anchor{gnat_ugn/gnat_and_program_execution id25}@anchor{17e}@anchor{gnat_ugn/gnat_and_program_execution interpretation-of-profiling-results}@anchor{17f}
 @subsubsection Interpretation of profiling results
 
 
@@ -19977,7 +20090,7 @@ and the subprograms that it calls. It also provides an estimate of the time
 spent in each of those callers and called subprograms.
 
 @node Improving Performance,Overflow Check Handling in GNAT,Profiling,GNAT and Program Execution
-@anchor{gnat_ugn/gnat_and_program_execution id26}@anchor{14b}@anchor{gnat_ugn/gnat_and_program_execution improving-performance}@anchor{17e}
+@anchor{gnat_ugn/gnat_and_program_execution id26}@anchor{14d}@anchor{gnat_ugn/gnat_and_program_execution improving-performance}@anchor{180}
 @section Improving Performance
 
 
@@ -19998,7 +20111,7 @@ which can reduce the size of program executables.
 @end menu
 
 @node Performance Considerations,Text_IO Suggestions,,Improving Performance
-@anchor{gnat_ugn/gnat_and_program_execution id27}@anchor{17f}@anchor{gnat_ugn/gnat_and_program_execution performance-considerations}@anchor{180}
+@anchor{gnat_ugn/gnat_and_program_execution id27}@anchor{181}@anchor{gnat_ugn/gnat_and_program_execution performance-considerations}@anchor{182}
 @subsection Performance Considerations
 
 
@@ -20059,7 +20172,7 @@ some guidelines on debugging optimized code.
 @end menu
 
 @node Controlling Run-Time Checks,Use of Restrictions,,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution controlling-run-time-checks}@anchor{181}@anchor{gnat_ugn/gnat_and_program_execution id28}@anchor{182}
+@anchor{gnat_ugn/gnat_and_program_execution controlling-run-time-checks}@anchor{183}@anchor{gnat_ugn/gnat_and_program_execution id28}@anchor{184}
 @subsubsection Controlling Run-Time Checks
 
 
@@ -20073,7 +20186,7 @@ necessary checking is done at compile time.
 @geindex -gnato (gcc)
 
 The GNAT switch, @code{-gnatp} allows you to modify this default; see
-@ref{ec,,Run-Time Checks}.
+@ref{ed,,Run-Time Checks}.
 
 Our experience is that the default is suitable for most development
 purposes.
@@ -20111,7 +20224,7 @@ remove checks) or @code{pragma Unsuppress} (to add back suppressed
 checks) in your program source.
 
 @node Use of Restrictions,Optimization Levels,Controlling Run-Time Checks,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution id29}@anchor{183}@anchor{gnat_ugn/gnat_and_program_execution use-of-restrictions}@anchor{184}
+@anchor{gnat_ugn/gnat_and_program_execution id29}@anchor{185}@anchor{gnat_ugn/gnat_and_program_execution use-of-restrictions}@anchor{186}
 @subsubsection Use of Restrictions
 
 
@@ -20147,7 +20260,7 @@ this, it also means 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 id30}@anchor{185}@anchor{gnat_ugn/gnat_and_program_execution optimization-levels}@anchor{ef}
+@anchor{gnat_ugn/gnat_and_program_execution id30}@anchor{187}@anchor{gnat_ugn/gnat_and_program_execution optimization-levels}@anchor{f0}
 @subsubsection Optimization Levels
 
 
@@ -20227,7 +20340,7 @@ your ability to display and modify variables in the debugger.
 
 Full optimization as in @code{-O2};
 also uses more aggressive automatic inlining of subprograms within a unit
-(@ref{103,,Inlining of Subprograms}) and attempts to vectorize loops.
+(@ref{104,,Inlining of Subprograms}) and attempts to vectorize loops.
 @end table
 
 @item 
@@ -20267,10 +20380,10 @@ levels.
 A note regarding the use of @code{-O3}: The use of this optimization level
 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{103,,Inlining of Subprograms}.
+See further discussion of this point in @ref{104,,Inlining of Subprograms}.
 
 @node Debugging Optimized Code,Inlining of Subprograms,Optimization Levels,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution debugging-optimized-code}@anchor{186}@anchor{gnat_ugn/gnat_and_program_execution id31}@anchor{187}
+@anchor{gnat_ugn/gnat_and_program_execution debugging-optimized-code}@anchor{188}@anchor{gnat_ugn/gnat_and_program_execution id31}@anchor{189}
 @subsubsection Debugging Optimized Code
 
 
@@ -20398,7 +20511,7 @@ 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 id32}@anchor{188}@anchor{gnat_ugn/gnat_and_program_execution inlining-of-subprograms}@anchor{103}
+@anchor{gnat_ugn/gnat_and_program_execution id32}@anchor{18a}@anchor{gnat_ugn/gnat_and_program_execution inlining-of-subprograms}@anchor{104}
 @subsubsection Inlining of Subprograms
 
 
@@ -20413,7 +20526,7 @@ The optimization level is at least @code{-O1}.
 
 @item 
 The called subprogram is suitable for inlining: it must be small enough
-and not contain something that the backend cannot support in inlined
+and not contain something that the back end cannot support in inlined
 subprograms.
 
 @geindex pragma Inline
@@ -20440,7 +20553,7 @@ The optimization level is at least @code{-O1}.
 
 @item 
 The called subprogram is suitable for inlining: It must be small enough
-and not contain something that the backend cannot support in inlined
+and not contain something that the back end cannot support in inlined
 subprograms.
 
 @item 
@@ -20490,33 +20603,34 @@ is compiled, the call will be inlined if the body of @code{Q} is small
 enough, but now @code{Main} depends on the body of @code{R} in
 @code{r.adb} as well as on the spec. This means that if this body is edited,
 the main program must be recompiled. Note that this extra dependency
-occurs whether or not the call is in fact inlined by the backend.
+occurs whether or not the call is in fact inlined by the back end.
 
 The use of front end inlining with @code{-gnatN} generates similar
 additional dependencies.
 
 @geindex -fno-inline (gcc)
 
-Note: The @code{-fno-inline} switch overrides all other conditions and ensures that
-no inlining occurs, unless requested with pragma Inline_Always for most
-back-ends. The extra dependences resulting from @code{-gnatn} will still be active,
-even if this switch is used to suppress the resulting inlining actions.
+Note: The @code{-fno-inline} switch overrides all other conditions
+and ensures that no inlining occurs, unless requested with pragma
+Inline_Always for most back ends. The extra dependences resulting from
+@code{-gnatn} will still be active, even if this switch is used to
+suppress the resulting inlining actions.
 
 @geindex -fno-inline-functions (gcc)
 
-For the GCC backend, you can use the
+For the GCC back end, you can use the
 @code{-fno-inline-functions} switch to prevent automatic inlining
 of subprograms if you use @code{-O3}.
 
 @geindex -fno-inline-small-functions (gcc)
 
-For the GCC backend, you can use the
+For the GCC back end, you can use the
 @code{-fno-inline-small-functions} switch to prevent automatic
 inlining of small subprograms if you use @code{-O2}.
 
 @geindex -fno-inline-functions-called-once (gcc)
 
-For the GC backend, you can use the
+For the GC back end, you can use the
 @code{-fno-inline-functions-called-once} switch to prevent inlining
 of subprograms local to the unit and called once from within it if you
 use @code{-O1}.
@@ -20541,7 +20655,7 @@ 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 floating-point-operations}@anchor{189}@anchor{gnat_ugn/gnat_and_program_execution id33}@anchor{18a}
+@anchor{gnat_ugn/gnat_and_program_execution floating-point-operations}@anchor{18b}@anchor{gnat_ugn/gnat_and_program_execution id33}@anchor{18c}
 @subsubsection Floating Point Operations
 
 
@@ -20588,16 +20702,16 @@ Note that the ABI has the same form for both floating-point models,
 so you can 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 id34}@anchor{18b}@anchor{gnat_ugn/gnat_and_program_execution vectorization-of-loops}@anchor{18c}
+@anchor{gnat_ugn/gnat_and_program_execution id34}@anchor{18d}@anchor{gnat_ugn/gnat_and_program_execution vectorization-of-loops}@anchor{18e}
 @subsubsection Vectorization of loops
 
 
 @geindex Optimization Switches
 
-The GCC and LLVM backends have an auto-vectorizer that’s enabled by
-default at some optimization levels.  For the GCC backend, it’s
+The GCC and LLVM back ends have an auto-vectorizer that’s enabled by
+default at some optimization levels.  For the GCC back end, it’s
 enabled by default at @code{-O3} and you can request it at other
-levels with @code{-ftree-vectorize}. For the LLVM backend, it’s
+levels with @code{-ftree-vectorize}. For the LLVM back end, it’s
 enabled by default at lower levels, but you can explicitly enable or
 disable it with the @code{-fno-vectorize}, @code{-fvectorize},
 @code{-fno-slp-vectorize}, and @code{-fslp-vectorize} switches.
@@ -20704,7 +20818,7 @@ pragma Loop_Optimize (Vector);
 
 placed immediately within the loop will convey the appropriate hint to the
 compiler for this loop. This is currently only supported for the GCC
-backend.
+back end.
 
 You can also help the compiler generate better vectorized code
 for a given loop by asserting that there are no loop-carried dependencies
@@ -20741,19 +20855,19 @@ pragma Loop_Optimize (Ivdep);
 
 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.
-This is also currently only supported by the GCC backend.
+This is also currently only supported by the GCC back end.
 
 @node Other Optimization Switches,Optimization and Strict Aliasing,Vectorization of loops,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution id35}@anchor{18d}@anchor{gnat_ugn/gnat_and_program_execution other-optimization-switches}@anchor{18e}
+@anchor{gnat_ugn/gnat_and_program_execution id35}@anchor{18f}@anchor{gnat_ugn/gnat_and_program_execution other-optimization-switches}@anchor{190}
 @subsubsection Other Optimization Switches
 
 
 @geindex Optimization Switches
 
 You can also use any specialized optimization switches supported by
-the backend being used.  These switches have not been extensively
+the back end being used.  These switches have not been extensively
 tested with GNAT but can generally be expected to work. Examples of
-switches in this category for the GCC backend are
+switches in this category for the GCC back end are
 @code{-funroll-loops} and the various target-specific @code{-m}
 options (in particular, it has been observed that @code{-march=xxx}
 can significantly improve performance on appropriate machines). For
@@ -20761,7 +20875,7 @@ full details of these switches, see the `Submodel Options' section in
 the `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 id36}@anchor{18f}@anchor{gnat_ugn/gnat_and_program_execution optimization-and-strict-aliasing}@anchor{e6}
+@anchor{gnat_ugn/gnat_and_program_execution id36}@anchor{191}@anchor{gnat_ugn/gnat_and_program_execution optimization-and-strict-aliasing}@anchor{e7}
 @subsubsection Optimization and Strict Aliasing
 
 
@@ -20809,14 +20923,15 @@ instead of in every iteration (this is called load hoisting).
 
 This kind of optimizations, based on strict type-based aliasing, is
 triggered by specifying an optimization level of @code{-O2} or
-higher (or @code{-Os}) for the GCC backend and @code{-O1} or higher for the
-LLVM backend and allows the compiler to generate more
+higher (or @code{-Os}) for the GCC back end and @code{-O1} or
+higher for the LLVM back end and allows the compiler to generate more
 efficient code.
 
-However, although this optimization is always correct in terms of
-the formal semantics of the Ada Reference Manual, you can run into difficulties
-arise if you use features like @code{Unchecked_Conversion}  to break
-the typing system. Consider the following complete program example:
+However, although this optimization is always correct in terms of the
+formal semantics of the Ada Reference Manual, you can run into
+difficulties arise if you use features like @code{Unchecked_Conversion}
+to break the typing system. Consider the following complete program
+example:
 
 @quotation
 
@@ -21043,7 +21158,7 @@ the compiler can have significant benefits. We’ve seen cases of large
 scale application code where the execution time is increased by up to
 5% when these optimizations are turned off. However, if you have code
 that make significant use of unchecked conversion, you might want to
-just stick with @code{-O1} (with the GCC backend) and avoid the
+just stick with @code{-O1} (with the GCC back end) and avoid the
 entire issue. If you get adequate performance at this level of
 optimization, that’s probably the safest approach. If tests show that
 you really need higher levels of optimization, then you can experiment
@@ -21054,7 +21169,7 @@ review any uses of unchecked conversion, 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{190}@anchor{gnat_ugn/gnat_and_program_execution id37}@anchor{191}
+@anchor{gnat_ugn/gnat_and_program_execution aliased-variables-and-optimization}@anchor{192}@anchor{gnat_ugn/gnat_and_program_execution id37}@anchor{193}
 @subsubsection Aliased Variables and Optimization
 
 
@@ -21114,7 +21229,7 @@ avoid code such as this if possible because it’s not portable and may not
 functin as you expect with all compilers.
 
 @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{192}@anchor{gnat_ugn/gnat_and_program_execution id38}@anchor{193}
+@anchor{gnat_ugn/gnat_and_program_execution atomic-variables-and-optimization}@anchor{194}@anchor{gnat_ugn/gnat_and_program_execution id38}@anchor{195}
 @subsubsection Atomic Variables and Optimization
 
 
@@ -21195,7 +21310,7 @@ such synchronization code is not required, you may find it
 useful to disable it.
 
 @node Passive Task Optimization,,Atomic Variables and Optimization,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution id39}@anchor{194}@anchor{gnat_ugn/gnat_and_program_execution passive-task-optimization}@anchor{195}
+@anchor{gnat_ugn/gnat_and_program_execution id39}@anchor{196}@anchor{gnat_ugn/gnat_and_program_execution passive-task-optimization}@anchor{197}
 @subsubsection Passive Task Optimization
 
 
@@ -21240,7 +21355,7 @@ that typically clients of the tasks who call entries will not have
 to be modified, only the task definitions themselves.
 
 @node Text_IO Suggestions,Reducing Size of Executables with Unused Subprogram/Data Elimination,Performance Considerations,Improving Performance
-@anchor{gnat_ugn/gnat_and_program_execution id40}@anchor{196}@anchor{gnat_ugn/gnat_and_program_execution text-io-suggestions}@anchor{197}
+@anchor{gnat_ugn/gnat_and_program_execution id40}@anchor{198}@anchor{gnat_ugn/gnat_and_program_execution text-io-suggestions}@anchor{199}
 @subsection @code{Text_IO} Suggestions
 
 
@@ -21263,7 +21378,7 @@ 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 id41}@anchor{198}@anchor{gnat_ugn/gnat_and_program_execution reducing-size-of-executables-with-unused-subprogram-data-elimination}@anchor{199}
+@anchor{gnat_ugn/gnat_and_program_execution id41}@anchor{19a}@anchor{gnat_ugn/gnat_and_program_execution reducing-size-of-executables-with-unused-subprogram-data-elimination}@anchor{19b}
 @subsection Reducing Size of Executables with Unused Subprogram/Data Elimination
 
 
@@ -21280,7 +21395,7 @@ your executable just by setting options at compilation time.
 @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 about-unused-subprogram-data-elimination}@anchor{19a}@anchor{gnat_ugn/gnat_and_program_execution id42}@anchor{19b}
+@anchor{gnat_ugn/gnat_and_program_execution about-unused-subprogram-data-elimination}@anchor{19c}@anchor{gnat_ugn/gnat_and_program_execution id42}@anchor{19d}
 @subsubsection About unused subprogram/data elimination
 
 
@@ -21294,7 +21409,7 @@ 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 compilation-options}@anchor{19c}@anchor{gnat_ugn/gnat_and_program_execution id43}@anchor{19d}
+@anchor{gnat_ugn/gnat_and_program_execution compilation-options}@anchor{19e}@anchor{gnat_ugn/gnat_and_program_execution id43}@anchor{19f}
 @subsubsection Compilation options
 
 
@@ -21306,7 +21421,7 @@ is directly performed by the linker.
 @geindex -fdata-sections (gcc)
 
 In order to do this, it has to work with objects compiled with the
-following switches passed to the GCC backend:
+following switches passed to the GCC back end:
 @code{-ffunction-sections} @code{-fdata-sections}.
 
 These options are usable with C and Ada files.
@@ -21335,7 +21450,7 @@ 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 example-of-unused-subprogram-data-elimination}@anchor{19e}@anchor{gnat_ugn/gnat_and_program_execution id44}@anchor{19f}
+@anchor{gnat_ugn/gnat_and_program_execution example-of-unused-subprogram-data-elimination}@anchor{1a0}@anchor{gnat_ugn/gnat_and_program_execution id44}@anchor{1a1}
 @subsubsection Example of unused subprogram/data elimination
 
 
@@ -21405,7 +21520,7 @@ appropriate switches.
 @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 id45}@anchor{14c}@anchor{gnat_ugn/gnat_and_program_execution overflow-check-handling-in-gnat}@anchor{1a0}
+@anchor{gnat_ugn/gnat_and_program_execution id45}@anchor{14e}@anchor{gnat_ugn/gnat_and_program_execution overflow-check-handling-in-gnat}@anchor{1a2}
 @section Overflow Check Handling in GNAT
 
 
@@ -21421,7 +21536,7 @@ This section explains how to control the handling of overflow checks.
 @end menu
 
 @node Background,Management of Overflows in GNAT,,Overflow Check Handling in GNAT
-@anchor{gnat_ugn/gnat_and_program_execution background}@anchor{1a1}@anchor{gnat_ugn/gnat_and_program_execution id46}@anchor{1a2}
+@anchor{gnat_ugn/gnat_and_program_execution background}@anchor{1a3}@anchor{gnat_ugn/gnat_and_program_execution id46}@anchor{1a4}
 @subsection Background
 
 
@@ -21547,7 +21662,7 @@ exception raised because of the intermediate overflow (and we really
 would prefer this precondition to be considered @code{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 id47}@anchor{1a3}@anchor{gnat_ugn/gnat_and_program_execution management-of-overflows-in-gnat}@anchor{1a4}
+@anchor{gnat_ugn/gnat_and_program_execution id47}@anchor{1a5}@anchor{gnat_ugn/gnat_and_program_execution management-of-overflows-in-gnat}@anchor{1a6}
 @subsection Management of Overflows in GNAT
 
 
@@ -21661,7 +21776,7 @@ 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 id48}@anchor{1a5}@anchor{gnat_ugn/gnat_and_program_execution specifying-the-desired-mode}@anchor{eb}
+@anchor{gnat_ugn/gnat_and_program_execution id48}@anchor{1a7}@anchor{gnat_ugn/gnat_and_program_execution specifying-the-desired-mode}@anchor{ec}
 @subsection Specifying the Desired Mode
 
 
@@ -21785,7 +21900,7 @@ equivalent to @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 default-settings}@anchor{1a6}@anchor{gnat_ugn/gnat_and_program_execution id49}@anchor{1a7}
+@anchor{gnat_ugn/gnat_and_program_execution default-settings}@anchor{1a8}@anchor{gnat_ugn/gnat_and_program_execution id49}@anchor{1a9}
 @subsection Default Settings
 
 
@@ -21809,7 +21924,7 @@ checking but 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 id50}@anchor{1a8}@anchor{gnat_ugn/gnat_and_program_execution implementation-notes}@anchor{1a9}
+@anchor{gnat_ugn/gnat_and_program_execution id50}@anchor{1aa}@anchor{gnat_ugn/gnat_and_program_execution implementation-notes}@anchor{1ab}
 @subsection Implementation Notes
 
 
@@ -21857,7 +21972,7 @@ platforms for which @code{Long_Long_Integer} is at least 64-bits (nearly all GNA
 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 id51}@anchor{14d}@anchor{gnat_ugn/gnat_and_program_execution performing-dimensionality-analysis-in-gnat}@anchor{1aa}
+@anchor{gnat_ugn/gnat_and_program_execution id51}@anchor{14f}@anchor{gnat_ugn/gnat_and_program_execution performing-dimensionality-analysis-in-gnat}@anchor{1ac}
 @section Performing Dimensionality Analysis in GNAT
 
 
@@ -22260,7 +22375,7 @@ package Mks_Numerics is new
 @end quotation
 
 @node Stack Related Facilities,Memory Management Issues,Performing Dimensionality Analysis in GNAT,GNAT and Program Execution
-@anchor{gnat_ugn/gnat_and_program_execution id52}@anchor{14e}@anchor{gnat_ugn/gnat_and_program_execution stack-related-facilities}@anchor{1ab}
+@anchor{gnat_ugn/gnat_and_program_execution id52}@anchor{150}@anchor{gnat_ugn/gnat_and_program_execution stack-related-facilities}@anchor{1ad}
 @section Stack Related Facilities
 
 
@@ -22276,7 +22391,7 @@ particular, it deals with dynamic and static stack usage measurements.
 @end menu
 
 @node Stack Overflow Checking,Static Stack Usage Analysis,,Stack Related Facilities
-@anchor{gnat_ugn/gnat_and_program_execution id53}@anchor{1ac}@anchor{gnat_ugn/gnat_and_program_execution stack-overflow-checking}@anchor{e7}
+@anchor{gnat_ugn/gnat_and_program_execution id53}@anchor{1ae}@anchor{gnat_ugn/gnat_and_program_execution stack-overflow-checking}@anchor{e8}
 @subsection Stack Overflow Checking
 
 
@@ -22313,18 +22428,18 @@ If the space is exceeded, a @code{Storage_Error} exception is raised.
 
 For declared tasks, the default stack size is defined by the GNAT runtime,
 whose size may be modified at bind time through the @code{-d} bind switch
-(@ref{113,,Switches for gnatbind}). You can set task specific stack sizes using the
+(@ref{114,,Switches for gnatbind}). You can set task specific stack sizes using the
 @code{Storage_Size} pragma.
 
 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
 operating system documentation.
 
-When using the LLVM backend, this switch doesn’t perform full stack overflow
+When using the LLVM back end, this switch doesn’t perform full stack overflow
 checking, but just checks for very large local dynamic allocations.
 
 @node Static Stack Usage Analysis,Dynamic Stack Usage Analysis,Stack Overflow Checking,Stack Related Facilities
-@anchor{gnat_ugn/gnat_and_program_execution id54}@anchor{1ad}@anchor{gnat_ugn/gnat_and_program_execution static-stack-usage-analysis}@anchor{e8}
+@anchor{gnat_ugn/gnat_and_program_execution id54}@anchor{1af}@anchor{gnat_ugn/gnat_and_program_execution static-stack-usage-analysis}@anchor{e9}
 @subsection Static Stack Usage Analysis
 
 
@@ -22373,10 +22488,10 @@ issue a warning for each subprogram whose stack usage might be larger
 than the specified amount of bytes.  The wording of that warning is
 consistent with that in the file documented above.
 
-This is not supported by the LLVM backend.
+This is not supported by the LLVM back end.
 
 @node Dynamic Stack Usage Analysis,,Static Stack Usage Analysis,Stack Related Facilities
-@anchor{gnat_ugn/gnat_and_program_execution dynamic-stack-usage-analysis}@anchor{116}@anchor{gnat_ugn/gnat_and_program_execution id55}@anchor{1ae}
+@anchor{gnat_ugn/gnat_and_program_execution dynamic-stack-usage-analysis}@anchor{117}@anchor{gnat_ugn/gnat_and_program_execution id55}@anchor{1b0}
 @subsection Dynamic Stack Usage Analysis
 
 
@@ -22455,13 +22570,13 @@ $ set GNAT_STACK_LIMIT 1600
 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.
 
-This is not suppored by the LLVM backend.
+This is not suppored by the LLVM back end.
 
 The package @code{GNAT.Task_Stack_Usage} provides facilities to get
 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 id56}@anchor{14f}@anchor{gnat_ugn/gnat_and_program_execution memory-management-issues}@anchor{1af}
+@anchor{gnat_ugn/gnat_and_program_execution id56}@anchor{151}@anchor{gnat_ugn/gnat_and_program_execution memory-management-issues}@anchor{1b1}
 @section Memory Management Issues
 
 
@@ -22477,7 +22592,7 @@ incorrect uses of access values (including ‘dangling references’).
 @end menu
 
 @node Some Useful Memory Pools,The GNAT Debug Pool Facility,,Memory Management Issues
-@anchor{gnat_ugn/gnat_and_program_execution id57}@anchor{1b0}@anchor{gnat_ugn/gnat_and_program_execution some-useful-memory-pools}@anchor{1b1}
+@anchor{gnat_ugn/gnat_and_program_execution id57}@anchor{1b2}@anchor{gnat_ugn/gnat_and_program_execution some-useful-memory-pools}@anchor{1b3}
 @subsection Some Useful Memory Pools
 
 
@@ -22559,7 +22674,7 @@ for T1'Storage_Size use 10_000;
 @end quotation
 
 @node The GNAT Debug Pool Facility,,Some Useful Memory Pools,Memory Management Issues
-@anchor{gnat_ugn/gnat_and_program_execution id58}@anchor{1b2}@anchor{gnat_ugn/gnat_and_program_execution the-gnat-debug-pool-facility}@anchor{1b3}
+@anchor{gnat_ugn/gnat_and_program_execution id58}@anchor{1b4}@anchor{gnat_ugn/gnat_and_program_execution the-gnat-debug-pool-facility}@anchor{1b5}
 @subsection The GNAT Debug Pool Facility
 
 
@@ -22722,7 +22837,7 @@ Debug Pool info:
 @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 doc}@anchor{1b4}@anchor{gnat_ugn/platform_specific_information id1}@anchor{1b5}@anchor{gnat_ugn/platform_specific_information platform-specific-information}@anchor{d}
+@anchor{gnat_ugn/platform_specific_information doc}@anchor{1b6}@anchor{gnat_ugn/platform_specific_information id1}@anchor{1b7}@anchor{gnat_ugn/platform_specific_information platform-specific-information}@anchor{e}
 @chapter Platform-Specific Information
 
 
@@ -22740,7 +22855,7 @@ related to the GNAT implementation on specific Operating Systems.
 @end menu
 
 @node Run-Time Libraries,Specifying a Run-Time Library,,Platform-Specific Information
-@anchor{gnat_ugn/platform_specific_information id2}@anchor{1b6}@anchor{gnat_ugn/platform_specific_information run-time-libraries}@anchor{1b7}
+@anchor{gnat_ugn/platform_specific_information id2}@anchor{1b8}@anchor{gnat_ugn/platform_specific_information run-time-libraries}@anchor{1b9}
 @section Run-Time Libraries
 
 
@@ -22801,7 +22916,7 @@ are supplied on various GNAT platforms.
 @end menu
 
 @node Summary of Run-Time Configurations,,,Run-Time Libraries
-@anchor{gnat_ugn/platform_specific_information id3}@anchor{1b8}@anchor{gnat_ugn/platform_specific_information summary-of-run-time-configurations}@anchor{1b9}
+@anchor{gnat_ugn/platform_specific_information id3}@anchor{1ba}@anchor{gnat_ugn/platform_specific_information summary-of-run-time-configurations}@anchor{1bb}
 @subsection Summary of Run-Time Configurations
 
 
@@ -22901,7 +23016,7 @@ ZCX
 
 
 @node Specifying a Run-Time Library,GNU/Linux Topics,Run-Time Libraries,Platform-Specific Information
-@anchor{gnat_ugn/platform_specific_information id4}@anchor{1ba}@anchor{gnat_ugn/platform_specific_information specifying-a-run-time-library}@anchor{1bb}
+@anchor{gnat_ugn/platform_specific_information id4}@anchor{1bc}@anchor{gnat_ugn/platform_specific_information specifying-a-run-time-library}@anchor{1bd}
 @section Specifying a Run-Time Library
 
 
@@ -22994,7 +23109,7 @@ by using the @code{--RTS} switch, e.g., @code{--RTS=sjlj}
 @geindex GNU/Linux
 
 @node GNU/Linux Topics,Microsoft Windows Topics,Specifying a Run-Time Library,Platform-Specific Information
-@anchor{gnat_ugn/platform_specific_information gnu-linux-topics}@anchor{1bc}@anchor{gnat_ugn/platform_specific_information id5}@anchor{1bd}
+@anchor{gnat_ugn/platform_specific_information gnu-linux-topics}@anchor{1be}@anchor{gnat_ugn/platform_specific_information id5}@anchor{1bf}
 @section GNU/Linux Topics
 
 
@@ -23009,7 +23124,7 @@ This section describes topics that are specific to GNU/Linux platforms.
 @end menu
 
 @node Required Packages on GNU/Linux,Position Independent Executable PIE Enabled by Default on Linux,,GNU/Linux Topics
-@anchor{gnat_ugn/platform_specific_information id6}@anchor{1be}@anchor{gnat_ugn/platform_specific_information required-packages-on-gnu-linux}@anchor{1bf}
+@anchor{gnat_ugn/platform_specific_information id6}@anchor{1c0}@anchor{gnat_ugn/platform_specific_information required-packages-on-gnu-linux}@anchor{1c1}
 @subsection Required Packages on GNU/Linux
 
 
@@ -23046,7 +23161,7 @@ Other GNU/Linux distributions might choose different name
 for those packages.
 
 @node Position Independent Executable PIE Enabled by Default on Linux,Choosing the Scheduling Policy with GNU/Linux,Required Packages on GNU/Linux,GNU/Linux Topics
-@anchor{gnat_ugn/platform_specific_information pie-enabled-by-default-on-linux}@anchor{1c0}@anchor{gnat_ugn/platform_specific_information position-independent-executable-pie-enabled-by-default-on-linux}@anchor{1c1}
+@anchor{gnat_ugn/platform_specific_information pie-enabled-by-default-on-linux}@anchor{1c2}@anchor{gnat_ugn/platform_specific_information position-independent-executable-pie-enabled-by-default-on-linux}@anchor{1c3}
 @subsection Position Independent Executable (PIE) Enabled by Default on Linux
 
 
@@ -23094,9 +23209,9 @@ and linked with @code{-pie}).
 @geindex SCHED_RR scheduling policy
 
 @geindex SCHED_OTHER scheduling policy
-@anchor{gnat_ugn/platform_specific_information choosing-the-scheduling-policy-with-gnu-linux}@anchor{1c2}
+@anchor{gnat_ugn/platform_specific_information choosing-the-scheduling-policy-with-gnu-linux}@anchor{1c4}
 @node Choosing the Scheduling Policy with GNU/Linux,A GNU/Linux Debug Quirk,Position Independent Executable PIE Enabled by Default on Linux,GNU/Linux Topics
-@anchor{gnat_ugn/platform_specific_information id7}@anchor{1c3}
+@anchor{gnat_ugn/platform_specific_information id7}@anchor{1c5}
 @subsection Choosing the Scheduling Policy with GNU/Linux
 
 
@@ -23154,7 +23269,7 @@ but not on the host machine running the container, so check that you also
 have sufficient priviledge for running the container image.
 
 @node A GNU/Linux Debug Quirk,,Choosing the Scheduling Policy with GNU/Linux,GNU/Linux Topics
-@anchor{gnat_ugn/platform_specific_information a-gnu-linux-debug-quirk}@anchor{1c4}@anchor{gnat_ugn/platform_specific_information id8}@anchor{1c5}
+@anchor{gnat_ugn/platform_specific_information a-gnu-linux-debug-quirk}@anchor{1c6}@anchor{gnat_ugn/platform_specific_information id8}@anchor{1c7}
 @subsection A GNU/Linux Debug Quirk
 
 
@@ -23174,7 +23289,7 @@ the symptoms most commonly observed.
 @geindex Windows
 
 @node Microsoft Windows Topics,Mac OS Topics,GNU/Linux Topics,Platform-Specific Information
-@anchor{gnat_ugn/platform_specific_information id9}@anchor{1c6}@anchor{gnat_ugn/platform_specific_information microsoft-windows-topics}@anchor{1c7}
+@anchor{gnat_ugn/platform_specific_information id9}@anchor{1c8}@anchor{gnat_ugn/platform_specific_information microsoft-windows-topics}@anchor{1c9}
 @section Microsoft Windows Topics
 
 
@@ -23196,7 +23311,7 @@ platforms.
 @end menu
 
 @node Using GNAT on Windows,Using a network installation of GNAT,,Microsoft Windows Topics
-@anchor{gnat_ugn/platform_specific_information id10}@anchor{1c8}@anchor{gnat_ugn/platform_specific_information using-gnat-on-windows}@anchor{1c9}
+@anchor{gnat_ugn/platform_specific_information id10}@anchor{1ca}@anchor{gnat_ugn/platform_specific_information using-gnat-on-windows}@anchor{1cb}
 @subsection Using GNAT on Windows
 
 
@@ -23275,7 +23390,7 @@ 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 id11}@anchor{1ca}@anchor{gnat_ugn/platform_specific_information using-a-network-installation-of-gnat}@anchor{1cb}
+@anchor{gnat_ugn/platform_specific_information id11}@anchor{1cc}@anchor{gnat_ugn/platform_specific_information using-a-network-installation-of-gnat}@anchor{1cd}
 @subsection Using a network installation of GNAT
 
 
@@ -23302,7 +23417,7 @@ transfer of large amounts of data across the network and will likely cause
 a 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{1cc}@anchor{gnat_ugn/platform_specific_information id12}@anchor{1cd}
+@anchor{gnat_ugn/platform_specific_information console-and-windows-subsystems}@anchor{1ce}@anchor{gnat_ugn/platform_specific_information id12}@anchor{1cf}
 @subsection CONSOLE and WINDOWS subsystems
 
 
@@ -23327,7 +23442,7 @@ $ gnatmake winprog -largs -mwindows
 @end quotation
 
 @node Temporary Files,Disabling Command Line Argument Expansion,CONSOLE and WINDOWS subsystems,Microsoft Windows Topics
-@anchor{gnat_ugn/platform_specific_information id13}@anchor{1ce}@anchor{gnat_ugn/platform_specific_information temporary-files}@anchor{1cf}
+@anchor{gnat_ugn/platform_specific_information id13}@anchor{1d0}@anchor{gnat_ugn/platform_specific_information temporary-files}@anchor{1d1}
 @subsection Temporary Files
 
 
@@ -23365,7 +23480,7 @@ environments where you may not have write access to some
 directories.
 
 @node Disabling Command Line Argument Expansion,Choosing the Scheduling Policy with Windows,Temporary Files,Microsoft Windows Topics
-@anchor{gnat_ugn/platform_specific_information disabling-command-line-argument-expansion}@anchor{1d0}
+@anchor{gnat_ugn/platform_specific_information disabling-command-line-argument-expansion}@anchor{1d2}
 @subsection Disabling Command Line Argument Expansion
 
 
@@ -23436,7 +23551,7 @@ Ada.Command_Line.Argument (1) -> "'*.txt'"
 @end example
 
 @node Choosing the Scheduling Policy with Windows,Windows Socket Timeouts,Disabling Command Line Argument Expansion,Microsoft Windows Topics
-@anchor{gnat_ugn/platform_specific_information choosing-the-scheduling-policy-with-windows}@anchor{1d1}@anchor{gnat_ugn/platform_specific_information id14}@anchor{1d2}
+@anchor{gnat_ugn/platform_specific_information choosing-the-scheduling-policy-with-windows}@anchor{1d3}@anchor{gnat_ugn/platform_specific_information id14}@anchor{1d4}
 @subsection Choosing the Scheduling Policy with Windows
 
 
@@ -23454,7 +23569,7 @@ in @code{system.ads}. For more information about Windows priorities, please
 refer to Microsoft documentation.
 
 @node Windows Socket Timeouts,Mixed-Language Programming on Windows,Choosing the Scheduling Policy with Windows,Microsoft Windows Topics
-@anchor{gnat_ugn/platform_specific_information windows-socket-timeouts}@anchor{1d3}
+@anchor{gnat_ugn/platform_specific_information windows-socket-timeouts}@anchor{1d5}
 @subsection Windows Socket Timeouts
 
 
@@ -23502,7 +23617,7 @@ socket timeout shorter than 500 ms. If a socket timeout shorter than
 operations.
 
 @node Mixed-Language Programming on Windows,Windows Specific Add-Ons,Windows Socket Timeouts,Microsoft Windows Topics
-@anchor{gnat_ugn/platform_specific_information id15}@anchor{1d4}@anchor{gnat_ugn/platform_specific_information mixed-language-programming-on-windows}@anchor{1d5}
+@anchor{gnat_ugn/platform_specific_information id15}@anchor{1d6}@anchor{gnat_ugn/platform_specific_information mixed-language-programming-on-windows}@anchor{1d7}
 @subsection Mixed-Language Programming on Windows
 
 
@@ -23524,17 +23639,17 @@ to use the Microsoft tools for your C++ code, you have two choices:
 You can encapsulate your C++ code in a DLL to be linked with your Ada
 application. In this case, use the Microsoft or other environment to
 build the DLL and use GNAT to build your executable
-(@ref{1d6,,Using DLLs with GNAT}).
+(@ref{1d8,,Using DLLs with GNAT}).
 
 @item 
 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{1d7,,Building DLLs with GNAT Project files}) and use the Microsoft
+(@ref{1d9,,Building DLLs with GNAT Project files}) and use the Microsoft
 or other environment to build your executable.
 @end itemize
 
 In addition to the description about C @code{main} in
-@ref{2c,,Mixed Language Programming} section, if the C @code{main} uses a
+@ref{2d,,Mixed Language Programming} section, if the C @code{main} uses a
 stand-alone library, it is required on x86-windows to
 setup the SEH context. For this, the C @code{main} must looks like this:
 
@@ -23586,7 +23701,7 @@ native SEH support is used.
 @end menu
 
 @node Windows Calling Conventions,Introduction to Dynamic Link Libraries DLLs,,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information id16}@anchor{1d8}@anchor{gnat_ugn/platform_specific_information windows-calling-conventions}@anchor{1d9}
+@anchor{gnat_ugn/platform_specific_information id16}@anchor{1da}@anchor{gnat_ugn/platform_specific_information windows-calling-conventions}@anchor{1db}
 @subsubsection Windows Calling Conventions
 
 
@@ -23631,7 +23746,7 @@ are available for Windows:
 @end menu
 
 @node C Calling Convention,Stdcall Calling Convention,,Windows Calling Conventions
-@anchor{gnat_ugn/platform_specific_information c-calling-convention}@anchor{1da}@anchor{gnat_ugn/platform_specific_information id17}@anchor{1db}
+@anchor{gnat_ugn/platform_specific_information c-calling-convention}@anchor{1dc}@anchor{gnat_ugn/platform_specific_information id17}@anchor{1dd}
 @subsubsection @code{C} Calling Convention
 
 
@@ -23673,10 +23788,10 @@ the @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{1dc,,Stdcall Calling Convention}).
+convention, @ref{1de,,Stdcall Calling Convention}).
 
 @node Stdcall Calling Convention,Win32 Calling Convention,C Calling Convention,Windows Calling Conventions
-@anchor{gnat_ugn/platform_specific_information id18}@anchor{1dd}@anchor{gnat_ugn/platform_specific_information stdcall-calling-convention}@anchor{1dc}
+@anchor{gnat_ugn/platform_specific_information id18}@anchor{1df}@anchor{gnat_ugn/platform_specific_information stdcall-calling-convention}@anchor{1de}
 @subsubsection @code{Stdcall} Calling Convention
 
 
@@ -23774,7 +23889,7 @@ 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 id19}@anchor{1de}@anchor{gnat_ugn/platform_specific_information win32-calling-convention}@anchor{1df}
+@anchor{gnat_ugn/platform_specific_information id19}@anchor{1e0}@anchor{gnat_ugn/platform_specific_information win32-calling-convention}@anchor{1e1}
 @subsubsection @code{Win32} Calling Convention
 
 
@@ -23782,7 +23897,7 @@ 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{1e0}@anchor{gnat_ugn/platform_specific_information id20}@anchor{1e1}
+@anchor{gnat_ugn/platform_specific_information dll-calling-convention}@anchor{1e2}@anchor{gnat_ugn/platform_specific_information id20}@anchor{1e3}
 @subsubsection @code{DLL} Calling Convention
 
 
@@ -23790,7 +23905,7 @@ 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 id21}@anchor{1e2}@anchor{gnat_ugn/platform_specific_information introduction-to-dynamic-link-libraries-dlls}@anchor{1e3}
+@anchor{gnat_ugn/platform_specific_information id21}@anchor{1e4}@anchor{gnat_ugn/platform_specific_information introduction-to-dynamic-link-libraries-dlls}@anchor{1e5}
 @subsubsection Introduction to Dynamic Link Libraries (DLLs)
 
 
@@ -23874,10 +23989,10 @@ 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{1e4,,The Definition File}).
+a definition file (see @ref{1e6,,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 id22}@anchor{1e5}@anchor{gnat_ugn/platform_specific_information using-dlls-with-gnat}@anchor{1d6}
+@anchor{gnat_ugn/platform_specific_information id22}@anchor{1e7}@anchor{gnat_ugn/platform_specific_information using-dlls-with-gnat}@anchor{1d8}
 @subsubsection Using DLLs with GNAT
 
 
@@ -23968,7 +24083,7 @@ example a fictitious DLL called @code{API.dll}.
 @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{1e6}@anchor{gnat_ugn/platform_specific_information id23}@anchor{1e7}
+@anchor{gnat_ugn/platform_specific_information creating-an-ada-spec-for-the-dll-services}@anchor{1e8}@anchor{gnat_ugn/platform_specific_information id23}@anchor{1e9}
 @subsubsection Creating an Ada Spec for the DLL Services
 
 
@@ -24008,7 +24123,7 @@ end API;
 @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 creating-an-import-library}@anchor{1e8}@anchor{gnat_ugn/platform_specific_information id24}@anchor{1e9}
+@anchor{gnat_ugn/platform_specific_information creating-an-import-library}@anchor{1ea}@anchor{gnat_ugn/platform_specific_information id24}@anchor{1eb}
 @subsubsection Creating an Import Library
 
 
@@ -24022,7 +24137,7 @@ 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{1e4}
+@anchor{gnat_ugn/platform_specific_information the-definition-file}@anchor{1e6}
 @subsubheading The Definition File
 
 
@@ -24070,17 +24185,17 @@ EXPORTS
 @end table
 
 Note that you must specify the correct suffix (@code{@@@var{nn}})
-(see @ref{1d9,,Windows Calling Conventions}) for a Stdcall
+(see @ref{1db,,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{1ea}
+@anchor{gnat_ugn/platform_specific_information create-def-file-automatically}@anchor{1ec}
 @subsubheading Creating a Definition File Automatically
 
 
 You can automatically create the definition file @code{API.def}
-(see @ref{1e4,,The Definition File}) from a DLL.
+(see @ref{1e6,,The Definition File}) from a DLL.
 To do that, use the @code{dlltool} program as follows:
 
 @quotation
@@ -24090,7 +24205,7 @@ $ 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{1d9,,Windows Calling Conventions}) with stripped @code{@@@var{nn}}
+(@ref{1db,,Windows Calling Conventions}) with stripped @code{@@@var{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.
 
@@ -24115,13 +24230,13 @@ tells you what symbol is expected. You then can 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{1eb}
+@anchor{gnat_ugn/platform_specific_information gnat-style-import-library}@anchor{1ed}
 @subsubheading GNAT-Style Import Library
 
 
 To create a static import library from @code{API.dll} with the GNAT tools,
 you should create the @code{.def} file and use the @code{gnatdll} tool
-(see @ref{1ec,,Using gnatdll}) as follows:
+(see @ref{1ee,,Using gnatdll}) as follows:
 
 @quotation
 
@@ -24137,15 +24252,15 @@ definition file name is @code{xyz.def}, the import library name will
 be @code{libxyz.a}. Note that in the previous example, the switch
 @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{1ec,,Using gnatdll} for more information about @code{gnatdll}).
+DLL (@ref{1ee,,Using gnatdll} for more information about @code{gnatdll}).
 @end quotation
-@anchor{gnat_ugn/platform_specific_information msvs-style-import-library}@anchor{1ed}
+@anchor{gnat_ugn/platform_specific_information msvs-style-import-library}@anchor{1ef}
 @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{1d5,,Mixed-Language Programming on Windows}).
+tools (@ref{1d7,,Mixed-Language Programming on Windows}).
 
 To create a Microsoft-style import library for @code{API.dll} you
 should create the @code{.def} file, then build the actual import library using
@@ -24169,7 +24284,7 @@ See the Microsoft documentation for further details about the usage of
 @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 building-dlls-with-gnat-project-files}@anchor{1d7}@anchor{gnat_ugn/platform_specific_information id25}@anchor{1ee}
+@anchor{gnat_ugn/platform_specific_information building-dlls-with-gnat-project-files}@anchor{1d9}@anchor{gnat_ugn/platform_specific_information id25}@anchor{1f0}
 @subsubsection Building DLLs with GNAT Project files
 
 
@@ -24185,7 +24300,7 @@ when inside the @code{DllMain} routine which is used for auto-initialization
 of shared libraries, so you can’t 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{1ef}@anchor{gnat_ugn/platform_specific_information id26}@anchor{1f0}
+@anchor{gnat_ugn/platform_specific_information building-dlls-with-gnat}@anchor{1f1}@anchor{gnat_ugn/platform_specific_information id26}@anchor{1f2}
 @subsubsection Building DLLs with GNAT
 
 
@@ -24216,7 +24331,7 @@ $ gcc -shared -shared-libgcc -o api.dll obj1.o obj2.o ...
 It’s important to note that in this case all symbols found in the
 object files are automatically exported. You can restrict
 the set of symbols to export by passing to @code{gcc} a definition
-file (see @ref{1e4,,The Definition File}).
+file (see @ref{1e6,,The Definition File}).
 For example:
 
 @example
@@ -24254,7 +24369,7 @@ $ gnatmake main -Iapilib -bargs -shared -largs -Lapilib -lAPI
 @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{1f1}@anchor{gnat_ugn/platform_specific_information id27}@anchor{1f2}
+@anchor{gnat_ugn/platform_specific_information building-dlls-with-gnatdll}@anchor{1f3}@anchor{gnat_ugn/platform_specific_information id27}@anchor{1f4}
 @subsubsection Building DLLs with gnatdll
 
 
@@ -24262,8 +24377,8 @@ $ gnatmake main -Iapilib -bargs -shared -largs -Lapilib -lAPI
 @geindex building
 
 Note that it is preferred to use GNAT Project files
-(@ref{1d7,,Building DLLs with GNAT Project files}) or the built-in GNAT
-DLL support (@ref{1ef,,Building DLLs with GNAT}) to build DLLs.
+(@ref{1d9,,Building DLLs with GNAT Project files}) or the built-in GNAT
+DLL support (@ref{1f1,,Building DLLs with GNAT}) 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
@@ -24279,20 +24394,20 @@ non-Ada applications are as follows:
 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{1f3,,Exporting Ada Entities}). You can
+(see @ref{1f5,,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{1f4,,Ada DLLs and Elaboration}). The initialization
+the Ada code in the DLL (@ref{1f6,,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} (also generated by @code{gnatbind}) to perform the
-finalization of the Ada code in the DLL (@ref{1f5,,Ada DLLs and Finalization}).
+finalization of the Ada code in the DLL (@ref{1f7,,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.
 
@@ -24302,11 +24417,11 @@ 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{1e4,,The Definition File}).
+(@ref{1e6,,The Definition File}).
 
 @item 
 Finally, you must use @code{gnatdll} to produce the DLL and the import
-library (@ref{1ec,,Using gnatdll}).
+library (@ref{1ee,,Using gnatdll}).
 @end itemize
 
 Note that a relocatable DLL stripped using the @code{strip}
@@ -24326,7 +24441,7 @@ chapter of the `GPRbuild User’s Guide'.
 @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{1f6}
+@anchor{gnat_ugn/platform_specific_information limitations-when-using-ada-dlls-from-ada}@anchor{1f8}
 @subsubsection Limitations When Using Ada DLLs from Ada
 
 
@@ -24347,7 +24462,7 @@ 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{1f3}@anchor{gnat_ugn/platform_specific_information id28}@anchor{1f7}
+@anchor{gnat_ugn/platform_specific_information exporting-ada-entities}@anchor{1f5}@anchor{gnat_ugn/platform_specific_information id28}@anchor{1f9}
 @subsubsection Exporting Ada Entities
 
 
@@ -24447,10 +24562,10 @@ end API;
 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{1f8,,Creating the Definition File}).
+(@ref{1fa,,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{1f4}@anchor{gnat_ugn/platform_specific_information id29}@anchor{1f9}
+@anchor{gnat_ugn/platform_specific_information ada-dlls-and-elaboration}@anchor{1f6}@anchor{gnat_ugn/platform_specific_information id29}@anchor{1fb}
 @subsubsection Ada DLLs and Elaboration
 
 
@@ -24459,16 +24574,16 @@ in the definition file of the Ada DLL
 The DLL that you are building contains your Ada code as well as all the
 routines in the Ada library that are needed by it. The first thing a
 user of your DLL must do is elaborate the Ada code
-(@ref{f,,Elaboration Order Handling in GNAT}).
+(@ref{10,,Elaboration Order Handling in GNAT}).
 
 To allow this, you must export an initialization routine
 (@code{Initialize_API} in the previous example), which must be invoked
 before using any of the DLL services. This elaboration routine must call
 the Ada elaboration routine @code{adainit} generated by the GNAT binder
-(@ref{7e,,Binding with Non-Ada Main Programs}). See the body of
+(@ref{7f,,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{1ec,,Using gnatdll}).
+tool (@ref{1ee,,Using gnatdll}).
 
 When a DLL is loaded, Windows systematically invokes a routine called
 @code{DllMain}. It should therefore be possible to call @code{adainit}
@@ -24481,7 +24596,7 @@ time), which means that the GNAT run-time will deadlock waiting for a
 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{1f5}@anchor{gnat_ugn/platform_specific_information id30}@anchor{1fa}
+@anchor{gnat_ugn/platform_specific_information ada-dlls-and-finalization}@anchor{1f7}@anchor{gnat_ugn/platform_specific_information id30}@anchor{1fc}
 @subsubsection Ada DLLs and Finalization
 
 
@@ -24492,14 +24607,14 @@ invoke the DLL finalization routine, if available. The DLL finalization
 routine is in charge of releasing all resources acquired by the DLL. In the
 case of the Ada code contained in the DLL, this is achieved by calling
 routine @code{adafinal} generated by the GNAT binder
-(@ref{7e,,Binding with Non-Ada Main Programs}).
+(@ref{7f,,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{1ec,,Using gnatdll}).
+(@ref{1ee,,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 creating-a-spec-for-ada-dlls}@anchor{1fb}@anchor{gnat_ugn/platform_specific_information id31}@anchor{1fc}
+@anchor{gnat_ugn/platform_specific_information creating-a-spec-for-ada-dlls}@anchor{1fd}@anchor{gnat_ugn/platform_specific_information id31}@anchor{1fe}
 @subsubsection Creating a Spec for Ada DLLs
 
 
@@ -24557,7 +24672,7 @@ end API;
 @end menu
 
 @node Creating the Definition File,Using gnatdll,,Creating a Spec for Ada DLLs
-@anchor{gnat_ugn/platform_specific_information creating-the-definition-file}@anchor{1f8}@anchor{gnat_ugn/platform_specific_information id32}@anchor{1fd}
+@anchor{gnat_ugn/platform_specific_information creating-the-definition-file}@anchor{1fa}@anchor{gnat_ugn/platform_specific_information id32}@anchor{1ff}
 @subsubsection Creating the Definition File
 
 
@@ -24593,7 +24708,7 @@ EXPORTS
 @end quotation
 
 @node Using gnatdll,,Creating the Definition File,Creating a Spec for Ada DLLs
-@anchor{gnat_ugn/platform_specific_information id33}@anchor{1fe}@anchor{gnat_ugn/platform_specific_information using-gnatdll}@anchor{1ec}
+@anchor{gnat_ugn/platform_specific_information id33}@anchor{200}@anchor{gnat_ugn/platform_specific_information using-gnatdll}@anchor{1ee}
 @subsubsection Using @code{gnatdll}
 
 
@@ -24691,7 +24806,7 @@ Help mode. Displays @code{gnatdll} switch usage information.
 
 Direct @code{gnatdll} to search the @code{dir} directory for source and
 object files needed to build the DLL.
-(@ref{73,,Search Paths and the Run-Time Library (RTL)}).
+(@ref{74,,Search Paths and the Run-Time Library (RTL)}).
 
 @geindex -k (gnatdll)
 
@@ -24804,7 +24919,7 @@ asks @code{gnatlink} to generate the routines @code{DllMain} and
 is loaded into memory.
 
 @item 
-uses @code{dlltool} (see @ref{1ff,,Using dlltool}) to build the
+uses @code{dlltool} (see @ref{201,,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.
@@ -24842,7 +24957,7 @@ $ gnatbind -n api
 $ gnatlink api api.exp -o api.dll -mdll
 @end example
 @end itemize
-@anchor{gnat_ugn/platform_specific_information using-dlltool}@anchor{1ff}
+@anchor{gnat_ugn/platform_specific_information using-dlltool}@anchor{201}
 @subsubheading Using @code{dlltool}
 
 
@@ -24900,7 +25015,7 @@ DLL in the static import library generated by @code{dlltool} with switch
 @item @code{-k}
 
 Kill @code{@@@var{nn}} from exported names
-(@ref{1d9,,Windows Calling Conventions}
+(@ref{1db,,Windows Calling Conventions}
 for a discussion about @code{Stdcall}-style symbols).
 @end table
 
@@ -24956,7 +25071,7 @@ 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{200}@anchor{gnat_ugn/platform_specific_information id34}@anchor{201}
+@anchor{gnat_ugn/platform_specific_information gnat-and-windows-resources}@anchor{202}@anchor{gnat_ugn/platform_specific_information id34}@anchor{203}
 @subsubsection GNAT and Windows Resources
 
 
@@ -25048,7 +25163,7 @@ the corresponding Microsoft documentation.
 @end menu
 
 @node Building Resources,Compiling Resources,,GNAT and Windows Resources
-@anchor{gnat_ugn/platform_specific_information building-resources}@anchor{202}@anchor{gnat_ugn/platform_specific_information id35}@anchor{203}
+@anchor{gnat_ugn/platform_specific_information building-resources}@anchor{204}@anchor{gnat_ugn/platform_specific_information id35}@anchor{205}
 @subsubsection Building Resources
 
 
@@ -25068,7 +25183,7 @@ 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{204}@anchor{gnat_ugn/platform_specific_information id36}@anchor{205}
+@anchor{gnat_ugn/platform_specific_information compiling-resources}@anchor{206}@anchor{gnat_ugn/platform_specific_information id36}@anchor{207}
 @subsubsection Compiling Resources
 
 
@@ -25110,7 +25225,7 @@ $ windres -i myres.res -o myres.o
 @end quotation
 
 @node Using Resources,,Compiling Resources,GNAT and Windows Resources
-@anchor{gnat_ugn/platform_specific_information id37}@anchor{206}@anchor{gnat_ugn/platform_specific_information using-resources}@anchor{207}
+@anchor{gnat_ugn/platform_specific_information id37}@anchor{208}@anchor{gnat_ugn/platform_specific_information using-resources}@anchor{209}
 @subsubsection Using Resources
 
 
@@ -25130,7 +25245,7 @@ $ gnatmake myprog -largs myres.o
 @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{208}@anchor{gnat_ugn/platform_specific_information using-gnat-dlls-from-microsoft-visual-studio-applications}@anchor{209}
+@anchor{gnat_ugn/platform_specific_information using-gnat-dll-from-msvs}@anchor{20a}@anchor{gnat_ugn/platform_specific_information using-gnat-dlls-from-microsoft-visual-studio-applications}@anchor{20b}
 @subsubsection Using GNAT DLLs from Microsoft Visual Studio Applications
 
 
@@ -25165,7 +25280,7 @@ $ gprbuild -p mylib.gpr
 @item 
 Produce a @code{.def} file for the symbols you need to interface
 with, either by hand or automatically with possibly some manual
-adjustments (see @ref{1ea,,Creating Definition File Automatically}):
+adjustments (see @ref{1ec,,Creating Definition File Automatically}):
 @end enumerate
 
 @quotation
@@ -25182,7 +25297,7 @@ $ dlltool libmylib.dll -z libmylib.def --export-all-symbols
 Make sure that MSVS command-line tools are accessible on the path.
 
 @item 
-Create the Microsoft-style import library (see @ref{1ed,,MSVS-Style Import Library}):
+Create the Microsoft-style import library (see @ref{1ef,,MSVS-Style Import Library}):
 @end enumerate
 
 @quotation
@@ -25225,7 +25340,7 @@ the @code{.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 debugging-a-dll}@anchor{20a}@anchor{gnat_ugn/platform_specific_information id38}@anchor{20b}
+@anchor{gnat_ugn/platform_specific_information debugging-a-dll}@anchor{20c}@anchor{gnat_ugn/platform_specific_information id38}@anchor{20d}
 @subsubsection Debugging a DLL
 
 
@@ -25262,7 +25377,7 @@ debugger compatible with the tools suite used to build the DLL.
 @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 id39}@anchor{20c}@anchor{gnat_ugn/platform_specific_information program-and-dll-both-built-with-gcc-gnat}@anchor{20d}
+@anchor{gnat_ugn/platform_specific_information id39}@anchor{20e}@anchor{gnat_ugn/platform_specific_information program-and-dll-both-built-with-gcc-gnat}@anchor{20f}
 @subsubsection Program and DLL Both Built with GCC/GNAT
 
 
@@ -25272,7 +25387,7 @@ the process. Let’s suppose the main procedure is named
 @code{ada_main} and in the DLL there’s an entry point named
 @code{ada_dll}.
 
-The DLL (@ref{1e3,,Introduction to Dynamic Link Libraries (DLLs)}) and
+The DLL (@ref{1e5,,Introduction to Dynamic Link Libraries (DLLs)}) and
 program must have been built with the debugging information (see the GNAT
 @code{-g} switch). Here are the step-by-step instructions for debugging it:
 
@@ -25309,10 +25424,10 @@ Set a breakpoint inside the DLL
 
 At this stage, a breakpoint is set inside the DLL. From there on
 you can use standard @code{GDB} commands to debug the whole program
-(@ref{150,,Running and Debugging Ada Programs}).
+(@ref{152,,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 id40}@anchor{20e}@anchor{gnat_ugn/platform_specific_information program-built-with-foreign-tools-and-dll-built-with-gcc-gnat}@anchor{20f}
+@anchor{gnat_ugn/platform_specific_information id40}@anchor{210}@anchor{gnat_ugn/platform_specific_information program-built-with-foreign-tools-and-dll-built-with-gcc-gnat}@anchor{211}
 @subsubsection Program Built with Foreign Tools and DLL Built with GCC/GNAT
 
 
@@ -25329,7 +25444,7 @@ case, for example, for some C code built with Microsoft Visual C) and that
 there’s a DLL named @code{test.dll} containing an Ada entry point named
 @code{ada_dll}.
 
-The DLL (see @ref{1e3,,Introduction to Dynamic Link Libraries (DLLs)}) must have
+The DLL (see @ref{1e5,,Introduction to Dynamic Link Libraries (DLLs)}) must have
 been built with debugging information (see the GNAT @code{-g} switch).
 
 @subsubheading Debugging the DLL Directly
@@ -25396,7 +25511,7 @@ Continue the program.
 This runs the program until it reaches the breakpoint that you’ve
 set. From that point, you can use standard @code{GDB} commands to debug
 a program as described in
-(@ref{150,,Running and Debugging Ada Programs}).
+(@ref{152,,Running and Debugging Ada Programs}).
 @end itemize
 
 You can also debug the DLL by attaching @code{GDB} to a running process.
@@ -25466,10 +25581,10 @@ Continue process execution.
 This last step will resume the process execution and stop at
 the breakpoint we have set. From there you can use standard
 @code{GDB} commands to debug a program, as described in
-@ref{150,,Running and Debugging Ada Programs}.
+@ref{152,,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 id41}@anchor{210}@anchor{gnat_ugn/platform_specific_information setting-stack-size-from-gnatlink}@anchor{12a}
+@anchor{gnat_ugn/platform_specific_information id41}@anchor{212}@anchor{gnat_ugn/platform_specific_information setting-stack-size-from-gnatlink}@anchor{12b}
 @subsubsection Setting Stack Size from @code{gnatlink}
 
 
@@ -25512,7 +25627,7 @@ because the comma is a separator for this switch.
 @end itemize
 
 @node Setting Heap Size from gnatlink,,Setting Stack Size from gnatlink,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information id42}@anchor{211}@anchor{gnat_ugn/platform_specific_information setting-heap-size-from-gnatlink}@anchor{12b}
+@anchor{gnat_ugn/platform_specific_information id42}@anchor{213}@anchor{gnat_ugn/platform_specific_information setting-heap-size-from-gnatlink}@anchor{12c}
 @subsubsection Setting Heap Size from @code{gnatlink}
 
 
@@ -25545,7 +25660,7 @@ because the comma is a separator for this switch.
 @end itemize
 
 @node Windows Specific Add-Ons,,Mixed-Language Programming on Windows,Microsoft Windows Topics
-@anchor{gnat_ugn/platform_specific_information win32-specific-addons}@anchor{212}@anchor{gnat_ugn/platform_specific_information windows-specific-add-ons}@anchor{213}
+@anchor{gnat_ugn/platform_specific_information win32-specific-addons}@anchor{214}@anchor{gnat_ugn/platform_specific_information windows-specific-add-ons}@anchor{215}
 @subsection Windows Specific Add-Ons
 
 
@@ -25558,7 +25673,7 @@ This section describes the Windows specific add-ons.
 @end menu
 
 @node Win32Ada,wPOSIX,,Windows Specific Add-Ons
-@anchor{gnat_ugn/platform_specific_information id43}@anchor{214}@anchor{gnat_ugn/platform_specific_information win32ada}@anchor{215}
+@anchor{gnat_ugn/platform_specific_information id43}@anchor{216}@anchor{gnat_ugn/platform_specific_information win32ada}@anchor{217}
 @subsubsection Win32Ada
 
 
@@ -25589,7 +25704,7 @@ gprbuild p.gpr
 @end quotation
 
 @node wPOSIX,,Win32Ada,Windows Specific Add-Ons
-@anchor{gnat_ugn/platform_specific_information id44}@anchor{216}@anchor{gnat_ugn/platform_specific_information wposix}@anchor{217}
+@anchor{gnat_ugn/platform_specific_information id44}@anchor{218}@anchor{gnat_ugn/platform_specific_information wposix}@anchor{219}
 @subsubsection wPOSIX
 
 
@@ -25622,7 +25737,7 @@ gprbuild p.gpr
 @end quotation
 
 @node Mac OS Topics,,Microsoft Windows Topics,Platform-Specific Information
-@anchor{gnat_ugn/platform_specific_information id45}@anchor{218}@anchor{gnat_ugn/platform_specific_information mac-os-topics}@anchor{219}
+@anchor{gnat_ugn/platform_specific_information id45}@anchor{21a}@anchor{gnat_ugn/platform_specific_information mac-os-topics}@anchor{21b}
 @section Mac OS Topics
 
 
@@ -25637,7 +25752,7 @@ platform.
 @end menu
 
 @node Codesigning the Debugger,,,Mac OS Topics
-@anchor{gnat_ugn/platform_specific_information codesigning-the-debugger}@anchor{21a}
+@anchor{gnat_ugn/platform_specific_information codesigning-the-debugger}@anchor{21c}
 @subsection Codesigning the Debugger
 
 
@@ -25719,7 +25834,7 @@ installed GNAT.  Also, be sure that users of @code{GDB} 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 doc}@anchor{21b}@anchor{gnat_ugn/example_of_binder_output example-of-binder-output-file}@anchor{e}@anchor{gnat_ugn/example_of_binder_output id1}@anchor{21c}
+@anchor{gnat_ugn/example_of_binder_output doc}@anchor{21d}@anchor{gnat_ugn/example_of_binder_output example-of-binder-output-file}@anchor{f}@anchor{gnat_ugn/example_of_binder_output id1}@anchor{21e}
 @chapter Example of Binder Output File
 
 
@@ -26469,7 +26584,7 @@ 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 doc}@anchor{21d}@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-order-handling-in-gnat}@anchor{f}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id1}@anchor{21e}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat doc}@anchor{21f}@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-order-handling-in-gnat}@anchor{10}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id1}@anchor{220}
 @chapter Elaboration Order Handling in GNAT
 
 
@@ -26499,7 +26614,7 @@ GNAT, either automatically or with explicit programming features.
 @end menu
 
 @node Elaboration Code,Elaboration Order,,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-code}@anchor{21f}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id2}@anchor{220}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-code}@anchor{221}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id2}@anchor{222}
 @section Elaboration Code
 
 
@@ -26648,7 +26763,7 @@ 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{221}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id3}@anchor{222}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-order}@anchor{223}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id3}@anchor{224}
 @section Elaboration Order
 
 
@@ -26818,7 +26933,7 @@ 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 checking-the-elaboration-order}@anchor{223}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id4}@anchor{224}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat checking-the-elaboration-order}@anchor{225}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id4}@anchor{226}
 @section Checking the Elaboration Order
 
 
@@ -26879,7 +26994,7 @@ 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{225}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id5}@anchor{226}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat controlling-the-elaboration-order-in-ada}@anchor{227}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id5}@anchor{228}
 @section Controlling the Elaboration Order in Ada
 
 
@@ -27208,7 +27323,7 @@ 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,Mixing Elaboration Models,Controlling the Elaboration Order in Ada,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat controlling-the-elaboration-order-in-gnat}@anchor{227}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id6}@anchor{228}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat controlling-the-elaboration-order-in-gnat}@anchor{229}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id6}@anchor{22a}
 @section Controlling the Elaboration Order in GNAT
 
 
@@ -27339,7 +27454,7 @@ that in this mode, GNAT may not diagnose certain elaboration issues or
 install run-time checks.
 
 @node Mixing Elaboration Models,ABE Diagnostics,Controlling the Elaboration Order in GNAT,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat id7}@anchor{229}@anchor{gnat_ugn/elaboration_order_handling_in_gnat mixing-elaboration-models}@anchor{22a}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat id7}@anchor{22b}@anchor{gnat_ugn/elaboration_order_handling_in_gnat mixing-elaboration-models}@anchor{22c}
 @section Mixing Elaboration Models
 
 
@@ -27386,7 +27501,7 @@ warning:   "y.ads" which has static elaboration checks
 You can suppress these warnings by specifying binder switch @code{-ws}.
 
 @node ABE Diagnostics,SPARK Diagnostics,Mixing Elaboration Models,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat abe-diagnostics}@anchor{22b}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id8}@anchor{22c}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat abe-diagnostics}@anchor{22d}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id8}@anchor{22e}
 @section ABE Diagnostics
 
 
@@ -27493,7 +27608,7 @@ declaration @code{Safe} because the body of function @code{ABE} has already been
 elaborated at that point.
 
 @node SPARK Diagnostics,Elaboration Circularities,ABE Diagnostics,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat id9}@anchor{22d}@anchor{gnat_ugn/elaboration_order_handling_in_gnat spark-diagnostics}@anchor{22e}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat id9}@anchor{22f}@anchor{gnat_ugn/elaboration_order_handling_in_gnat spark-diagnostics}@anchor{230}
 @section SPARK Diagnostics
 
 
@@ -27519,7 +27634,7 @@ rules.
 @end quotation
 
 @node Elaboration Circularities,Resolving Elaboration Circularities,SPARK Diagnostics,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-circularities}@anchor{22f}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id10}@anchor{230}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-circularities}@anchor{231}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id10}@anchor{232}
 @section Elaboration Circularities
 
 
@@ -27619,7 +27734,7 @@ This section enumerates various tactics for eliminating the circularity.
 @end itemize
 
 @node Resolving Elaboration Circularities,Elaboration-related Compiler Switches,Elaboration Circularities,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat id11}@anchor{231}@anchor{gnat_ugn/elaboration_order_handling_in_gnat resolving-elaboration-circularities}@anchor{232}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat id11}@anchor{233}@anchor{gnat_ugn/elaboration_order_handling_in_gnat resolving-elaboration-circularities}@anchor{234}
 @section Resolving Elaboration Circularities
 
 
@@ -27890,7 +28005,7 @@ Use the relaxed dynamic-elaboration model, with compiler switches
 @end itemize
 
 @node Elaboration-related Compiler Switches,Summary of Procedures for Elaboration Control,Resolving Elaboration Circularities,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-related-compiler-switches}@anchor{233}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id12}@anchor{234}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-related-compiler-switches}@anchor{235}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id12}@anchor{236}
 @section Elaboration-related Compiler Switches
 
 
@@ -28071,7 +28186,7 @@ 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 id13}@anchor{235}@anchor{gnat_ugn/elaboration_order_handling_in_gnat summary-of-procedures-for-elaboration-control}@anchor{236}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat id13}@anchor{237}@anchor{gnat_ugn/elaboration_order_handling_in_gnat summary-of-procedures-for-elaboration-control}@anchor{238}
 @section Summary of Procedures for Elaboration Control
 
 
@@ -28129,7 +28244,7 @@ Use the relaxed dynamic elaboration model, with compiler switches
 @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 id14}@anchor{237}@anchor{gnat_ugn/elaboration_order_handling_in_gnat inspecting-the-chosen-elaboration-order}@anchor{238}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat id14}@anchor{239}@anchor{gnat_ugn/elaboration_order_handling_in_gnat inspecting-the-chosen-elaboration-order}@anchor{23a}
 @section Inspecting the Chosen Elaboration Order
 
 
@@ -28272,7 +28387,7 @@ gdbstr (body)
 @end quotation
 
 @node Inline Assembler,GNU Free Documentation License,Elaboration Order Handling in GNAT,Top
-@anchor{gnat_ugn/inline_assembler doc}@anchor{239}@anchor{gnat_ugn/inline_assembler id1}@anchor{23a}@anchor{gnat_ugn/inline_assembler inline-assembler}@anchor{10}
+@anchor{gnat_ugn/inline_assembler doc}@anchor{23b}@anchor{gnat_ugn/inline_assembler id1}@anchor{23c}@anchor{gnat_ugn/inline_assembler inline-assembler}@anchor{11}
 @chapter Inline Assembler
 
 
@@ -28331,7 +28446,7 @@ and assembly language programming.
 @end menu
 
 @node Basic Assembler Syntax,A Simple Example of Inline Assembler,,Inline Assembler
-@anchor{gnat_ugn/inline_assembler basic-assembler-syntax}@anchor{23b}@anchor{gnat_ugn/inline_assembler id2}@anchor{23c}
+@anchor{gnat_ugn/inline_assembler basic-assembler-syntax}@anchor{23d}@anchor{gnat_ugn/inline_assembler id2}@anchor{23e}
 @section Basic Assembler Syntax
 
 
@@ -28447,7 +28562,7 @@ Intel: Destination first; for example @code{mov eax, 4}@w{ }
 
 
 @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{23d}@anchor{gnat_ugn/inline_assembler id3}@anchor{23e}
+@anchor{gnat_ugn/inline_assembler a-simple-example-of-inline-assembler}@anchor{23f}@anchor{gnat_ugn/inline_assembler id3}@anchor{240}
 @section A Simple Example of Inline Assembler
 
 
@@ -28596,7 +28711,7 @@ If there are no errors, @code{as} generates an object file called
 @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{23f}@anchor{gnat_ugn/inline_assembler output-variables-in-inline-assembler}@anchor{240}
+@anchor{gnat_ugn/inline_assembler id4}@anchor{241}@anchor{gnat_ugn/inline_assembler output-variables-in-inline-assembler}@anchor{242}
 @section Output Variables in Inline Assembler
 
 
@@ -28963,7 +29078,7 @@ end Get_Flags_3;
 @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{241}@anchor{gnat_ugn/inline_assembler input-variables-in-inline-assembler}@anchor{242}
+@anchor{gnat_ugn/inline_assembler id5}@anchor{243}@anchor{gnat_ugn/inline_assembler input-variables-in-inline-assembler}@anchor{244}
 @section Input Variables in Inline Assembler
 
 
@@ -29052,7 +29167,7 @@ _increment__incr.1:
 @end quotation
 
 @node Inlining Inline Assembler Code,Other Asm Functionality,Input Variables in Inline Assembler,Inline Assembler
-@anchor{gnat_ugn/inline_assembler id6}@anchor{243}@anchor{gnat_ugn/inline_assembler inlining-inline-assembler-code}@anchor{244}
+@anchor{gnat_ugn/inline_assembler id6}@anchor{245}@anchor{gnat_ugn/inline_assembler inlining-inline-assembler-code}@anchor{246}
 @section Inlining Inline Assembler Code
 
 
@@ -29123,7 +29238,7 @@ movl %esi,%eax
 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 id7}@anchor{245}@anchor{gnat_ugn/inline_assembler other-asm-functionality}@anchor{246}
+@anchor{gnat_ugn/inline_assembler id7}@anchor{247}@anchor{gnat_ugn/inline_assembler other-asm-functionality}@anchor{248}
 @section Other @code{Asm} Functionality
 
 
@@ -29138,7 +29253,7 @@ and @code{Volatile}, which inhibits unwanted optimizations.
 @end menu
 
 @node The Clobber Parameter,The Volatile Parameter,,Other Asm Functionality
-@anchor{gnat_ugn/inline_assembler id8}@anchor{247}@anchor{gnat_ugn/inline_assembler the-clobber-parameter}@anchor{248}
+@anchor{gnat_ugn/inline_assembler id8}@anchor{249}@anchor{gnat_ugn/inline_assembler the-clobber-parameter}@anchor{24a}
 @subsection The @code{Clobber} Parameter
 
 
@@ -29202,7 +29317,7 @@ 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 id9}@anchor{249}@anchor{gnat_ugn/inline_assembler the-volatile-parameter}@anchor{24a}
+@anchor{gnat_ugn/inline_assembler id9}@anchor{24b}@anchor{gnat_ugn/inline_assembler the-volatile-parameter}@anchor{24c}
 @subsection The @code{Volatile} Parameter
 
 
@@ -29238,7 +29353,7 @@ 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 doc}@anchor{24b}@anchor{share/gnu_free_documentation_license gnu-fdl}@anchor{1}@anchor{share/gnu_free_documentation_license gnu-free-documentation-license}@anchor{24c}
+@anchor{share/gnu_free_documentation_license doc}@anchor{24d}@anchor{share/gnu_free_documentation_license gnu-fdl}@anchor{1}@anchor{share/gnu_free_documentation_license gnu-free-documentation-license}@anchor{24e}
 @chapter GNU Free Documentation License
 
 
@@ -29726,8 +29841,8 @@ to permit their use in free software.
 
 @printindex ge
 
+@anchor{d2}@w{                              }
 @anchor{gnat_ugn/gnat_utility_programs switches-related-to-project-files}@w{                              }
-@anchor{d1}@w{                              }
 
 @c %**end of body
 @bye