=========================
GNAT 21 NEW FEATURES LIST
=========================

Copyright (C) 2021, AdaCore

This file contains a complete list of new features in version 21 of GNAT. A
full description of all GNAT features can be found in the GNAT User's Guide
and GNAT Reference Manual.

An ISO date (YYYY-MM-DD) appears in parentheses after the description line.
This date shows the implementation date of the feature. Any 21.0w wavefront
subsequent to this date will contain the indicated feature, as will any
subsequent 21 or later release.

NF-TC15-026 Improved handling of 'Valid and 'Valid_Scalars (2020-12-07)

  The 'Valid attribute no longer generates redundant checks when
  used on a type whose size is smaller than integer and where all
  values are valid (such as type Character). This is particularly
  useful when using 'Valid_Scalars on arrays of such types where
  lots of redundant code (including loops) can now be suppressed and
  when using -gnateV or -gnatVa.

NF-TA25-003 Renaming of a qualified expression of a variable (2020-10-31)

  Ada 202x AI12-0401 restricts renaming of a qualified expression to
  cases where the operand is a constant, or the target subtype
  statically matches the nominal subtype of the operand, or is
  unconstrained with no predicates, to prevent setting variables to
  values outside their range or constraints.

NF-TA14-037 Symbolic backtraces for arm-linux (2020-12-15)

  Symbolic backtraces are now supported on arm-linux targets, which
  includes armhf-linux.

NF-T831-015 New parameter for Representation_Specifications rule (2020-09-04)

  A new Record_Types_Only parameter is added to the gnatcheck
  Representation_Specifications rule. If this parameter is
  specified, the rule flags only those representation specifications
  that are applied to declarations of record types.

NF-T825-038 Address for aliased array of unconstrained subtype (2020-08-29)

  It is now possible to put an address clause whose value is
  absolute on an aliased array with an unconstrained nominal subtype
  and to initialize it with a box aggregate.

NF-T811-027 Improved detection of unused "with" clauses (2020-08-30)

  The -gnatwu switch now detects more cases of unused "with" clauses
  where previously the detection was more conservative.

NF-T803-004 Better precision for Ada.Directory.Modification_Time (2020-08-04)

  The precision of the result of calling the
  Ada.Directory.Modification_Time function has been increased to
  match the capabilities of the operating system.

NF-T731-010 gnatpp: Binary operators with --no-compact improved (2020-08-27)

  Formatting of binary operators with --no-compact is improved. In
  particular, --no-compact is ignored for binary operators, so that
  long chains like "A & B & ... & Z" do not get split with just one
  operand per line.

NF-T730-039 gnatpp: Improve --vertical-case-alternatives (2020-08-21)

  If --vertical-case-alternatives is given, insert a hard line break
  after the "is" of a case expression, and between alternatives. In
  addition, if the context has a soft line break, treat it as hard,
  and skip a following space, if any.

NF-T723-048 DWARF debugging information for fixed point types (2020-07-30)

  Except for fixed point types whose small is too small to be
  encoded as a fraction of two integers, GNAT Pro now describes
  fixed point type objects in DWARF using the proper encoding and
  scale. For fixed point types whose small cannot be encoded, the
  information about the type's small remains available in the name
  of the type itself (see exp_dbug.ads in the GNAT Pro sources for
  more information).

NF-T722-036 Function Empty for standard containers (AI12-0339) (2020-08-06)

  To provide uniform support for container aggregates, all standard
  container libraries have been enhanced with a function Empty, to
  be used when initializing an aggregate prior to inserting the
  specified elements in the object being constructed. All products
  have been updated to remove the ambiguities that may have arisen
  from previous uses of entities named Empty in our sources, and the
  expansion of container aggregates uses Empty wherever needed.

NF-T717-030 Support for Unreferenced aspect on formal parameters (2020-07-24)

  It is now possible to specify the Unreferenced aspect on a formal
  parameter. This is useful in particular for marking a formal
  parameter of an expression function as unreferenced:

    function F (Param : Integer with Unreferenced) return Integer is
  (1);

  This feature is available under the -gnatX switch.

NF-T716-066 gnatpp: improved --vertical-named-aggregates (2020-07-22)

  Formatting is improved in the case of aggregates in certain
  contexts (notably calls and expression functions, but several
  others as well) when the --vertical-named-aggregates switch is
  used.

NF-T709-007 Ada 202x: Early derivation and equality of records (2020-07-09)

  AI12-0352 is now implemented, which clarifies that declaring a
  user-defined primitive equality operation for a record type T is
  illegal if it occurs after a type has been derived from T.

NF-T701-004 LynxOS-178 stand-alone library support (2020-07-06)

  The LynxOS-178 cert runtimes now support the use of stand-alone
  libraries.

NF-T625-001 -gnatP and pragma Polling removed (2020-06-26)

  The -gnatP switch and corresponding pragma Polling have been
  removed. These switches were not very convenient to use and caused
  a large runtime overhead. The use of --RTS=sjlj or pragma
  Abort_Defer can replace their usage.

NF-T624-035 Use of a procedure in a Reduce attribute reference (2020-06-29)

  AI12-0262 specifies that the reducer in a Reduce attribute
  reference can be a procedure with an in-out parameter that serves
  as the collector for the computed value. This patch implements
  this additional functionality, as well as the use of the
  attributes Min and Max as reducers, given that these are
  attributes that are binary functions.

NF-T622-002 Unknown aspects ignored (2020-06-22)

  By default, GNAT will now ignore unknown aspects and generate a
  warning instead of rejecting them with an error, to provide a
  handling similar to unknown pragmas and better compatibility
  across different Ada and GNAT compiler versions.

NF-T617-001 Compile-time evaluation of shift operations (2020-06-29)

  The intrinsic operations Shift_Left, Shift_Right, and
  Shift_Right_Arithmetic are now evaluated at compile time when
  possible.

NF-T615-009 Fixes for Atomic and Volatile (AI12-0363) (2020-09-08)

  This amendment has been implemented under the -gnat2020 switch and
  the compiler now supports the Full_Access_Only aspect, which is
  mostly equivalent to GNAT's Volatile_Full_Access.

NF-T615-004 Ada 202x: Renaming values (AI12-0383) (2020-06-17)

  This AI allow names that denote values rather than objects to
  nevertheless be renamed using an object renaming.

NF-T615-003 View conversions and out params (AI12-0377) (2020-06-17)

  This AI clarifies that an actual of an out parameter that is a
  view conversion is illegal if either the target or operand type
  has Default_Value specified while the other does not.

NF-T612-042 Reduced stack usage on large concatenations (2020-06-28)

  When concatenating large arrays (such as large strings) and some
  operand is already using the secondary stack (such as a function
  call returning a string), the result of the concatenation will now
  also be allocated on the secondary stack instead of the primary
  stack, to avoid, for example, exceeding the stack size.

NF-T611-008 Use libm for Generic_Elementary_Functions on x86 (2020-06-11)

  On x86 platforms, Ada.Numerics.Generic_Elementary_Functions is now
  implemented on top of the underlying C math library as already
  done on other architectures. This provides in particular more
  accurate and faster results on recent OS versions and will allow
  further optimizations in the future.

NF-T604-015 gnatpp: improved --vertical-named-aggregates switch (2020-07-01)

  The cases where aggregates can be formatted vertically by gnatpp
  are adjusted. Vertical aggregates are allowed as the default value
  in a component declaration, analogous to the initial value in an
  object declaration, and singleton aggregates are not formatted
  vertically, unless the single component is itself an aggregate.

NF-T531-006 CCG: support for restriction No_Elaboration_Code (2020-05-31)

  This restriction is now handled by CCG and detection of violations
  of this restriction are now flagged.

NF-T528-046 New gnatcheck warnings for global rules (2020-06-02)

  When creating a call graph used for checking global rules,
  gnatcheck issues a warning if the call graph contains an imported
  or exported subprogram.

NF-T525-005 Inlining nonstatic calls to static expression funcs (2020-07-17)

  GNAT can now inline calls to static expression functions that have
  nonstatic actual parameters when inlining is enabled.

NF-T525-004 CCG: Interfaces.C types mapped to C types (2020-05-29)

  In particular, types Interfaces.C.long and unsigned_long are
  mapped to the C types long and unsigned long when generating C
  code, to improve compatibility and mixing of Ada and C code.

NF-T522-012 Interfaces.C.Extensions and long_long integer types (2020-05-22)

  The types long_long and unsigned_long_long in
  Interfaces.C.Extensions are now defined as subtypes of
  Interfaces.C types, since Ada 202x adds these same types there.

NF-T522-007 Allow some intrinsics as static functions (2020-06-02)

  Some imported intrinsic functions such as Shift_Left and
  Shift_Right are now evaluated at compile time when passed static
  actual parameters, and can have the Ada 202x aspect "Static"
  applied to their declaration. This feature is available when using
  the -gnatX switch.

NF-T521-012 GNAT_INLINE macro can be overridden in CCG (2020-05-26)

  In the context of the GNAT CCG compiler, the GNAT_INLINE macro now
  defaults to "inline" for all C compilers, and this value can be
  overridden via the command line (for example, -DGNAT_INLINE=) when
  needed.

NF-T518-026 More accurate -gnatRj for derived untagged types (2020-05-19)

  The information output in JSON format by means of the -gnatRj
  option is now more accurate for derived untagged types with
  discriminants and variant parts.

NF-T508-012 Image function for Time with Time_Zone (2020-05-09)

  A new Image function is added to GNAT.Calendar.Time_IO. This
  function takes a Time_Zone parameter. The old Image function in
  this package uses local time.

NF-T508-009 Description of gnatcheck exit codes (2020-05-10)

  A new section that describes gnatcheck exit codes has been added
  to the GNATcheck Reference Manual.

NF-T508-003 Warning suppressed by default in C/C++ binding (2020-05-11)

  The warning about an unused Interfaces.C unit in the C and C++
  bindings generated by means of the -fdump-ada-spec option is now
  suppressed by default.

NF-T504-043 Improve handling of custom-named gnatcheck reports (2020-05-26)

  If a custom name is specified for a gnatcheck report file with the
  '-o' or '-ox' options, the auxiliary files created for the report
  file (list of sources, list of rules) are named after the custom
  report file name. If the argument project file is specified and
  defines the objects directory, all custom-named report files are
  placed in this objects directory.

NF-T504-024 Improved performance for large initialized allocator (2020-05-04)

  The compiler generates faster code to initialize a large allocator
  for an integer array type to all zeros when initialized by an
  aggregate and, more generally, to initialize a large allocator for
  an array of storage units to a single value.

NF-T425-003 Gnatcheck warnings are added to the generated report (2020-04-25)

  The warnings that gnatcheck generates when it cannot find certain
  subprogram bodies when analyzing a call graph as a part of
  checking global rules are now added to the generated report file.

NF-T423-014 Support for XDR stream attributes (2020-04-23)

  A new binder switch -xdr is provided to enable support for the XDR
  protocol on stream attributes. This capability was provided
  previously via a separate runtime file s-stratt__xdr.adb which is
  now removed and no longer needed.

NF-T416-033 Fewer arithmetic checks at low optimization level (2020-04-22)

  The compiler now generates fewer checks that can never fail for
  arithmetic operations at low optimization level (-O1 or below).

NF-T410-029 More efficient length checks for slice assignment (2020-04-10)

  The compiler now generates more efficient length checks, or can
  even elide them if they are unnecessary, for assignments of array
  slices.

NF-T409-005 Ada 202x: Relaxation of 'Old restrictions (2020-07-24)

  For Ada 202x, AI12-0280-2 relaxes Ada's restrictions on 'Old
  attribute references whose attribute prefix does not statically
  name an entity. Previously, it was required that such an attribute
  reference must be unconditionally evaluated when the postcondition
  is evaluated; with the new rule, conditional evaluation is
  permitted if the relevant conditions can be evaluated upon entry
  to the subprogram with the same results as evaluation at the time
  of the postcondition's evaluation. In this case, the 'Old
  attribute prefix is evaluated conditionally (more specifically,
  the prefix is evaluated only if the result of that evaluation is
  going to be referenced later when the postcondition is evaluated).

NF-T409-003 Inherited nonoverridable aspects (AI12-0211) (2020-08-24)

  For Ada 202x, AI12-0211 introduces two new legality rules. The
  first says that if a nonoverridable aspect is explicitly specified
  for a type that also inherits that aspect from another type (an
  ancestor or a progenitor), then the explicit aspect specification
  shall be confirming. The second says that if a type inherits a
  nonoverridable aspect from two different sources (this can only
  occur if at least one of the two is an interface type), then the
  two sources shall agree with respect to the given aspect. This AI
  is a binding interpretation, so these checks are performed even
  for earlier Ada versions. Because of compatibility concerns, an
  "escape mechanism" for suppressing these legality checks is
  provided: these new checks always pass if the -gnatd.M switch
  (relaxed RM semantics) is specified.

NF-T409-001 Ada 202x: No_Dynamic_CPU_Assignment (AI12-0055) (2020-06-09)

  AI12-0055 is implemented. This allows use of the
  No_Dynamic_CPU_Assignment restriction in pragmas Restrictions and
  Restrictions_Warnings.

NF-T402-002 Common matching for formal derived types (AI12-0351) (2020-04-03)

  This binding interpretation has been implemented, and the compiler
  now checks that an actual subtype in a generic parameter
  association of an instantiation is statically compatible (even
  when the actual is unconstrained) with the ancestor of an
  associated nondiscriminated generic formal derived type.

NF-T331-034 Ada 202x: No_Tasks_Unassigned_To_CPU (AI12-0117) (2020-06-12)

  The No_Tasks_Unassigned_To_CPU restriction is implemented.

NF-T331-032 Ada 202x: Specify standard storage pool (AI12-0003) (2020-06-25)

  The standard storage pool can be specified in a
  Default_Storage_Pool pragma or aspect. This new feature is
  documented in AI12-0003.

NF-T331-031 Declare expressions can be static (2020-05-30)

  AI12-0368, which says declare expressions can be static in Ada
  202x, is implemented.

NF-T330-015 Checks for extended return statements (AI12-0343) (2020-04-02)

  This binding interpretation has been implemented and the
  accessibility, predicate, and tag checks prescribed by RM 6.5 are
  now performed at the appropriate points, as required by AI12-0343.

NF-T330-004 CCG: support for more representation clauses (2020-03-06)

  Various improvements in the CCG compiler have been implemented to
  provide more control over representation clauses: Padding of more
  than 64 bits in records is now supported; Support has been added
  for Unchecked_Conversion between fixed point and discrete types;
  Some representation clauses are now recognized as confirming and
  there is no attempt to map them to bitfields.

NF-T327-030 Ada 202x: Put_Image attrs for language-defined types (2020-07-07)

  AI12-0304 is now implemented. In particular, Put_Image (and
  therefore 'Image) is provided for the containers and for unbounded
  strings.

NF-T325-015 Square brackets for Ada 202x aggregates (2020-08-13)

  The proposed new syntax for aggregates in Ada 202x uses square
  brackets as delimiters, and in particular allows [] as a notation
  for empty array and container aggregates. This syntax is currently
  available as an experimental feature under the -gnatX flag.

NF-T318-009 Put_Image attribute for Big_Numbers packages (2020-03-19)

  The Big_Integers and Big_Reals packages have been updated to
  define the Put_Image attribute, using the Ada.Strings.Text_Output
  package.

NF-T312-059 Ada 202x barrier restrictions relaxation (AI12-0369) (2020-03-25)

  The definitions of the Simple_Barriers and Pure_Barriers
  restrictions were modified by AI12-0369, replacing uses of
  "statically denotes" with "statically names". This means that in
  many cases (but not all) a barrier expression that references a
  subcomponent of a component of the protected type while subject to
  either of the two restrictions is now allowed; with the previous
  restriction definitions, such a barrier expression would not have
  been legal.

NF-T312-056 Preelaborable units with address clauses (AI12-0175) (2020-03-20)

  This amendment has been implemented under the -gnat2020 switch,
  and the compiler nows accepts calls to certain functions that are
  essentially unchecked conversions in preelaborated library units.

NF-T309-026 CCG: avoiding predefined includes in standard.h (2020-03-16)

  The file standard.h now checks the macro CCG_NO_STD_INCLUDE to
  avoid including pre ISO C99 standard include files such as math.h,
  string.h, and stdlib.h, which may not be available and are only
  needed to support optional features.

NF-T307-004 Ada 202x AI12-0192 "requires late initialization" (2020-03-11)

  This AI clarifies that components of a protected type require late
  initialization when their initialization references (implicitly)
  the current instance of the type.

NF-T306-048 More efficient code for dynamic record aggregates (2020-03-24)

  The compiler now generates an intermediate temporary for the
  assignment of dynamic record aggregates in fewer cases.

NF-T228-034 Support for secondary stack with -mavx on x86[_64] (2020-03-26)

  On x86[_64] targets, the use of AVX vector types and -mavx is now
  also supported with functions returning unconstrained arrays of
  vector objects.

NF-T226-001 Handling of LEON3 RETT Restart Errata GRLIB-TN-0018 (2020-03-10)

  The workaround number one from Leon3FT errata GRLIB-TN-0018 is now
  implemented and enabled for all of the Leon3 run-times. Please
  refer to the Gaisler documentation for more information about the
  triggering of the errata. The workaround can be disabled by
  commenting out the definition of the LEON3_ERRATA_GRLIB_TN_0018
  macro in the crt0.S source file of a run-time, and then
  recompiling the run-time.

NF-T223-010 Ada202x AI12-0301 Predicates and Default_Value (2020-02-25)

  This AI clarifies that predicate checks apply for objects that are
  initialized by default and that are of a type that has any
  components whose subtypes specify Default_Value or
  Default_Component_Value.

NF-T220-048 Ada 202x adds new Ravenscar restriction (AI12-0073) (2020-02-24)

  Ada 202x adds (as a binding interpretation) a "No_Dependence =>
  Ada.Synchronous_Barriers" restriction to the Ravenscar profile.

NF-T219-046 Ada 202x Jorvik profile (AI12-0291) (2020-02-19)

  The Jorvik profile is now implemented, as defined in the Ada RM
  (see AI12-0291). For Ada 2012 and earlier versions of Ada, Jorvik
  is an implementation-defined profile whose definition matches its
  Ada 202x definition.

NF-T217-007 AI12-0228 Properties of qualified expressions (2020-02-19)

  This AI clarifies that properties of a qualified object pass
  through a qualified expression used as a name. Specifically,
  "aliased" and "known to be constrained" are not changed by a
  qualified expression.

NF-T208-001 Ada 202x restriction Pure_Barriers (AI12-0290) (2020-02-18)

  The GNAT implementation of the Pure_Barriers restriction has been
  updated to match the Ada RM's definition (see AI12-0290). Some
  constructs that were accepted by the previous implementation are
  now rejected, and vice versa. In particular, the use of a
  component of a component of a protected record in a barrier
  expression, as in "when Some_Component.Another_Component =>",
  formerly was (at least in some cases) not considered to be a
  violation of the Pure_Barriers restriction; that is no longer the
  case.

NF-T207-022 Extra information in exception message in more cases (2020-02-07)

  The compiler now generates extra information in exception messages
  in more cases by means of the -gnateE switch.

NF-T205-003 gnatpp: --[no-]separate-return switch is implemented (2020-02-26)

  In --no-compact mode, if a subprogram spec does not fit on one
  line, --no-separate-return switch now tries to place the "return"
  on the same line as the last formal parameter. The default is
  --separate-return, which behaves as before.

NF-T204-043 Fully static string concatenation after inlining (2020-03-28)

  The compiler can now turn a dynamic string concatenation into a
  fully static one after inlining a call (with actuals given by
  string literals) to the subprogram that contains the
  concatentation, when the unit is compiled at the -O2 optimization
  level or above.

NF-T204-040 Compile_Time_Warning pragmas never treated as errors (2020-04-24)

  The compiler now never treats warnings issued from a
  Compile_Time_Warning pragma as an error, even with `-gnatwe`.
  Issuing errors can be achieved with the Compile_Time_Error pragma.

NF-T131-050 Ada 202x AI12-0207 Convention of anonymous access (2020-02-01)

  Ada 202x AI12-0207 has been fully implemented and, in particular,
  the convention of anonymous access elements of arrays now have the
  same convention as the array instead of convention Ada.

NF-T131-049 More robust C/C++ binding for anonymous structures (2020-02-02)

  The C and C++ bindings generated by means of the -fdump-ada-spec
  option can now handle structures with array subfields with the
  same name in anonymous nested structures.

NF-T131-031 Ada202x AI12-0237 Enum_Rep and Enum_Val attributes (2020-01-31)

  The GNAT-specific attributes Enum_Rep and Enum_Val have been
  standardized and are now also supported as Ada 202x attributes.

NF-T131-024 Ada202x AI12-0318 No_IO applies to Ada.Directories (2020-01-31)

  The restriction No_IO now applies to and prevents the use of the
  Ada.Directories package.

NF-T123-002 Support for LEON3v7 (2020-01-28)

  GNAT now supports LEON3v7, a reduced-size variant of the LEON3
  processor supporting only the SPARCv7 architecture. To take
  advantage of this support you will need to create a custom runtime
  and in runtime.xml replace the "-mcpu=leon" switch with
  "-mcpu=leon3v7".

NF-T117-005 New package Ada.Task_Initialization (2020-01-30)

  A new package Ada.Task_Initialization is available to provide a
  way to set up a global initialization handler when tasks start.

NF-T114-028 Support for Allow_Integer_Address on 64-bit targets (2020-01-15)

  The pragma Allow_Integer_Address is now supported on 64-bit
  targets where the executables are mapped outside the lower 4 GB of
  virtual memory space.

NF-T113-044 More cases of empty loops recognized and optimized (2020-01-16)

  The Ada compiler's front end has been enhanced to recognize more
  cases of loops that contain no useful statements and to eliminate
  such loops.

NF-T113-019 Nonzero Gnatcheck exit status for illegal sources (2020-01-14)

  Gnatcheck returns a nonzero exit status if compilation errors are
  detected for some of the source files.

NF-T108-063 Improved 'Val implementation for enumeration types (2020-01-09)

  The implementation of the Val, Pred, and Succ attributes applied
  to an enumeration type with a nonstandard but contiguous
  representation is now more efficient.

NF-SC07-001 Debugger text user interface on Linux (2020-04-10)

  The debugger text user interface ("TUI") is now enabled on Linux
  builds.

NF-SC06-058 CCG generates better code for records with variants (2020-01-19)

  The CCG back end has been enhanced to generate internal names for
  unions and structs that are output for variants of record types
  (since anonymous unions and structs are not supported by C90).

NF-SB28-039 Gnatcheck warnings about uncheckable restrictions (2019-12-06)

  If a parameter of the Restrictions rule denotes a restriction that
  cannot be checked statically or that cannot be checked by the
  compiler when code generation is disabled, gnatcheck now generates
  a warning and does not activate such a Restrictions rule.

NF-SB26-047 GDB's Python interpreter upgraded to version 3.x (2020-03-04)

  The Python interpreter integrated in the GDB debugger has been
  upgraded from version 2.7 to version 3.7.

NF-SB25-062 Implementation of the Reduce attribute (AI12-0262) (2019-11-28)

  The attribute Reduce, proposed as an Ada amendment in AI12-00262
  is now implemented, and is treated as a language extension, under
  control of the -gnatX flag. Its status as part of the new Ada
  standard is still under discussion. AI12-0242, which applies the
  attribute to existing objects, is also implemented.

NF-SB24-002 Ada 202X atomic operations (AI12-0234/321) (2019-11-28)

  Three new units are added that provide support for atomic
    operations to write lock-free synchronizations:
    System.Atomic_Operations.Test_And_Set,
    System.Atomic_Operations.Arithmetic and
    System.Atomic_Operations.Exchange.

NF-SB08-026 Support for big numbers in Ada 202X (AI12-0208) (2019-11-22)

  Two new units are added that provide support for infinite
  precision integers and rationals:
  Ada.Numerics.Big_Numbers.Big_Integers and Big_Reals.

NF-SB08-020 More support for unchecked type conversions in CCG (2019-11-16)

  The CCG back end has been enhanced to support unchecked type
  conversions of selected components, dereferences, and composite
  types.

NF-SB07-048 Partial access to atomic composite types (AI12-0128) (2019-11-24)

  This amendment has been implemented under the -gnat2020 switch and
  the compiler now generates full access to atomic composite objects
  even if the access is only partial in the source code.

NF-SB07-018 Support for time > 24 hrs in Ada.Calendar.Formatting (2019-11-16)

  The function Ada.Calendar.Formatting.Image now supports duration
  values larger than 24 hours. Time_Error is still raised for
  duration values that are not supported (more than 100 hours).

NF-SB06-040 Debugger includes error code when attach fails (2019-11-06)

  The debugger now includes the error code when attach fails on
  Windows, making it easier to diagnose problems.

NF-SB05-028 Additional warnings on overlapping actuals (2020-03-18)

  When warnings on overlapping actuals are enabled (using the
  -gnatw.i switch) the compiler now warns when two actuals in a call
  are identical or have an overlap, even if only one of them is an
  in-out or an out parameter.

NF-SA18-053 Implementation of AI12-0184 for Ada 202X (2020-01-30)

  Two new types long_long and unsigned_long_long are introduced in
  the package Interfaces.C.

NF-SA10-003 Ada 202x: static expression functions (AI12-0075) (2020-04-13)

  Ada 202x defines a new aspect Static that can be specified on
  expression functions. Such an expression function can be called in
  contexts requiring static expressions when the actual parameters
  are all static, allowing for greater abstraction in complex static
  expressions. This feature is documented in AI12-0075.

NF-SA09-028 Suppress unused warnings in the presence of errors (2019-12-01)

  The compiler no longer warns about unused use clauses, unused
  declarations, and the like, if errors were already detected. This
  is an improvement, because the errors can hide the relevant uses,
  and thus cause things to look "unused" when they are not.

NF-SA03-012 Improved API to detect end of command-line arguments (2019-10-10)

  An additional Get_Argument function has been added to
  GNAT.Command_Line that has an End_Of_Arguments Boolean out
  parameter that supports distinguishing between the empty argument
  and the end of arguments.

NF-S925-004 Pragma Compile_Time_Error now forces evaluation (2019-12-12)

  Pragma Compile_Time_Error previously issued an error only when the
  condition was evaluated to True at compile time. Now it also
  issues an error when the condition cannot be evaluated at compile
  time. This makes it possible to safely rely on such conditions
  being always false in static analyzers like GNATprove. In cases
  where the error is not desirable, users can instead use pragma
  Compile_Time_Warning.

NF-S923-025 Ability to print value of named numbers in debugger (2019-09-24)

  The debugging information generated by the compiler has been
  enhanced so as to allow the debugger to print the value of named
  numbers.

NF-S910-050 Obsolete debugger "break" syntax has been removed (2019-10-08)

  The old "break exception" and "break assert" syntax has been
  removed from the debugger. These have been obsolete for many
  years. The supported approach is to use the appropriate "catch"
  subcommands.

NF-S909-059 Better code generation for nested aggregates (2020-02-13)

  For aggregate components that are themselves aggregates, the front
  end has been enhanced to evaluate whether the inner aggregate
  depends on the variable being assigned to. This enhancement allows
  the compiler to avoid the generation of a temporary and thus
  generate better code for large nested aggregates.

NF-S905-038 New procedure Register_Global_Unhandled_Action (2020-01-23)

  A new procedure Register_Global_Unhandled_Action is provided in
  package GNAT.Exception_Actions to register a handler when an
  unhandled exception is raised, so that it is possible, for
  example, to dump a core file.

NF-S904-042 Ada 202x: potentially unevaluated array components (2020-05-13)

  Ada 202x enforces the detection of components that belong to a
  nonstatic or null range of index values of an array aggregate.
  This feature is specified in AI12-0198.

NF-S904-038 AI1-0201 Relational operators of static string types (2020-02-25)

  Relational operators and type conversions of static string types
  are now static in Ada 202x.

NF-S904-034 Ada202x: AI12-0144 Discrete_Random more flexible (2020-01-31)

  A new function Random with First/Last parameters is provided in
  the Ada.Numerics.Discrete_Random package.

NF-S904-033 Ada 202x: Freezing of renames-as-body (AI12-0132) (2020-06-13)

  This AI clarifies that a renames-as-body freezes the expression of
  any expression function that it renames.

NF-S904-031 Convention of By_Protected_Procedure (AI12-0107) (2020-06-05)

  A prefixed view of a subprogram with aspect Synchronization set to
  By_Protected_Procedure has convention protected. This binding
  interpretation is documented in AI12-0107.

NF-S904-030 Prevent access to unaliased components (AI12-0027) (2020-06-15)

  AI12-0027 adds a requirement for a value conversion that converts
  from an array of unaliased components to an array of aliased
  components to make a copy, and defines such conversions to have a
  very local accessibility, effectively preventing the possibility
  of unsafe accesses to unaliased components.

NF-S821-023 Ada 202x: null-excluding anonymous access types (2020-06-09)

  AI12-0289 is implemented for Ada 202x, allowing safer use of
  access parameters when the partial view of the designated type is
  untagged, but the full view is tagged.

NF-S821-016 Object_Size clauses and composite types (AI12-0059) (2019-12-02)

  As a by-product of the implementation of this amendment, the
  support of Object_Size clauses for composite types is now more
  robust in all versions of the language.

NF-S820-055 Ada 202x: pre/postconditions on access-to-subp types (2020-04-14)

  Contract aspects can now be specified for access-to-subprogram
  types, as defined for Ada 202x in AI12-0220.

NF-S820-054 Packing and independent components (AI12-0001) (2019-11-27)

  This Binding Interpretation has been implemented and the compiler
  now accepts packing clauses in all cases, even if they have
  effectively no effects on the layout.

NF-S820-053 Ada 202x: Storage streams packages (AI12-0293) (2020-04-21)

  The package Ada.Streams.Storage and its children
  Ada.Streams.Storage.Unbounded and Ada.Streams.Storage.Bounded are
  implemented. These allow streaming to be done to an in-memory
  buffer.

NF-S820-046 Protected and task invariant visibility (AI12-0180) (2020-06-22)

  AI12-0180 is now implemented, so entries and protected subprograms
  are directly visible within Invariant aspects of a task or
  protected type.

NF-S820-039 Tampering checks are performed first (AI12-0110) (2020-04-14)

  AI12-0110, which requires tampering checks in the containers
  library to be performed first, before any other checks, is now
  implemented.

NF-S820-038 Predicate checks on qualified expressions (AI12-100) (2020-02-17)

  The compiler now enforces predicate checks on qualified
  expressions when the qualifying subtype imposes a predicate, as
  required by AI12-0100.

NF-S820-033 Invariant checking on in-mode parameters (AI12-0044) (2020-05-11)

  Type-invariant checking is required and now performed on
  parameters of mode in upon return from procedure calls, but such
  checking is not done for in-mode parameters of functions (to avoid
  infinite recursion on function calls in invariant expressions), as
  specified by AI12-0044.

NF-S820-030 Added rules for type invariants (AI12-0042) (2020-06-05)

  AI12-0042 adds rules for type invariants that are now implemented.
  Specifically, when inheriting a private dispatching operation when
  the ancestor operation is visible at the point of the type
  extension, the operation must be abstract or else overridden. In
  addition, for a class-wide view conversion from an object of a
  specific type T to which a type invariant applies, an invariant
  check is performed when the conversion is within the immediate
  scope of T.

NF-S819-048 Shorthand for object renamings (AI12-0275) (2020-01-28)

  AI12-0275, an amendment to Ada 2012, allows object renamings to be
  declared without an explicit subtype_mark or access_definition,
  and is now supported as an extension. This feature can be used by
  compiling with the switch -gnat2020.

NF-S819-047 Aspect/pragma No_Return for functions (AI12-0269) (2020-03-19)

  This amendment has been implemented under the -gnat2020 switch,
  and the compiler now accepts the aspect/pragma No_Return for
  functions and generic functions.

NF-S819-043 Abstract calls in class-wide pre/post (AI12-0170) (2020-07-06)

  The compiler now implements the rules specified in AI12-0170 for
  calls to abstract functions within class-wide preconditions and
  postconditions.

NF-S818-007 Support for 128-bit integers on 64-bit platforms (2020-09-01)

  Support for 128-bit integer types on 64-bit bareboard platforms
  has been implemented in the compiler.

NF-S817-006 Ada 202x: Normalization and allowed chars, AI12-0004 (2020-06-11)

  This Ada 202x AI clarifies that Ada identifiers that contain
  characters that are not allowed in Normalization Form KC are
  illegal.

NF-S816-028 Is_Basic and To_Basic in Wide_Characters.Handling (2020-04-01)

  AI12-0260 is implemented for Ada 202x, providing the new functions
  Is_Basic and To_Basic in package Ada.Wide_Characters.Handling.

NF-S815-005 GNATstack adds the cycle size to the stack size (2021-03-12)

  When printing the used stack size, GNATstack now adds the cycle
  size, which makes the switch \`-c X\` more useful.

NF-S809-020 gnatpp: Add --[no-]compact switch (2019-12-23)

  The new switch --compact/--no-compact is added to gnatpp. If a
  call does not fit on one line, then in the default --compact mode,
  as many actual parameters as fit on a line are placed on one line.
  If you say, --no-compact, then each actual parameter is placed on
  a line by itself, which matches the behavior of earlier versions
  of gnatpp.

NF-S729-063 Ada 202x user-defined-literals aspects supported (2020-04-07)

  Compiler support is added for three new aspects (Integer_Literal,
  Real_Literal, and String_Literal) as described in AI12-0249 (for
  Integer_Literal and Real_Literal), AI12-0295 (for String_Literal),
  and in two follow-up AIs (AI12-0325 and AI12-0342). For pre-Ada
  202x versions of Ada, these are treated as implementation-defined
  aspects. Some implementation work remains, particularly in the
  interactions between these aspects and tagged types.

NF-S729-061 Removal of loophole in derivation rules (AI12-0109) (2019-11-12)

  Ada disallows a nonconfirming specification of a type-related
  representation aspect of an untagged by-reference type. The
  motivation for this rule is to ensure that a parent type and a
  later type derived from the parent agree with respect to such
  aspects. AI12-0109 disallows a construct that otherwise could be
  used to get around this rule: an aspect specification for the
  parent type that occurs after the declaration of the derived type.

NF-S729-060 AI12-0101 implemented (allow private "=" functions) (2019-10-31)

  AI12-0101 is a binding interpretation that removes a legality rule
  that prohibited the declaration of a primitive equality function
  for a private type in the private part of its enclosing package
  (either before or after the completion of the type) when the type
  is completed as an untagged record type. Such declarations are now
  accepted in Ada 2012 and later Ada versions.
  As a consequence of this work, some cases where the implementation
  of AI05-0123 was incomplete were corrected. More specifically, if
  a user-defined equality operator is present for an untagged record
  type in an Ada 2012 program, that user-defined equality operator
  will be (correctly) executed in some difficult-to-characterize
  cases where the predefined component-by-component comparison was
  previously being (incorrectly) executed. This can arise, for
  example, in the case of the predefined equality operation for an
  enclosing composite type that has a component of the user-defined
  primitive equality op's operand type. This correction means that
  the impact of this change is not limited solely to code that was
  previously rejected at compile time.

NF-S729-057 AI12-0036 is implemented (a new instantiation check) (2019-10-21)

  AI12-0036 is a binding interpretation that adds the following
  legality rule: The actual type for a formal derived type shall be
  tagged if and only if the formal derived type is a private
  extension. The check is implemented for all Ada dialects (not just
  Ada 202x) because the AI is a binding intepretation.

NF-S729-049 Formal derived types and streaming (AI12-0030) (2020-08-21)

  Corner cases involving streaming operations for formal derived
  limited types that are now defined to raise Program_Error are now
  correctly implemented; before AI12-0030, behavior in these cases
  was undefined. Stream attribute availability is more precisely
  computed in cases where a derived type declaration occurs ahead of
  a streaming attribute specification for the parent type.

NF-S722-028 Ada 202x: more dispatching points with aspect Yield (2020-04-17)

  Ada 202x defines a new aspect Yield that can be specified in the
  declaration of a noninstance subprogram (including a generic
  formal subprogram), a generic subprogram, or an entry, to ensure
  that the associated subprogram has at least one task dispatching
  point during each invocation. This feature is documented in
  AI12-0279.

NF-S716-002 Improved support of subprogram instantiations in CCG (2020-02-06)

  The CCG back end has been enhanced to generate better code for
  subprogram instantiations.

NF-S715-034 Predicates and subtype current instances (AI12-0068) (2020-05-06)

  AI12-0068 is a binding interpretation that defines the current
  instance name in a type or subtype aspect to be a value rather
  than an object. This affects attributes whose prefix is a current
  instance in predicates, type invariants, and
  Default_Initial_Condition aspects. In particular, in the case of
  the Constrained attribute the value will always be True, and
  formerly legal attributes that require an object as their prefix
  (such as Size, Access, Address, etc.) are now illegal when applied
  to a current instance in type and subtype aspects.

NF-S715-033 View conversion and by-copy out params (AI12-0074) (2020-03-26)

  This Ada 202x AI makes illegal some cases of out parameters whose
  type has a Default_Value aspect.

NF-S709-048 gnatpp: Allow alignment in --RM-style-spacing mode (2019-12-23)

  Previously, the --RM-style-spacing switch would turn off
  alignment, whether or not --alignment was specified. Now --RM-
  style-spacing turns off alignment by default, but an explicit
  --alignment switch can be used to turn it on.

NF-S423-008 Support for 128-bit integers on 64-bit platforms (2020-08-26)

  Support for 128-bit integer types on 64-bit Linux, Windows, and
  VxWorks platforms has been implemented in the compiler.

NF-S411-031 Import of variadic C functions (AI12-0028) (2020-03-03)

  This binding interpretation has been implemented, and Ada programs
  can now properly call variadic C functions by means of the
  conventions C_Variadic_n, for small integer values n.

NF-S318-091 Ada 202x Iterator filters (AI12-0250) (2020-05-19)

  The Ada 202x feature of iterator filters, which can be applied to
  loop parameter specifications and iterator specifications, is now
  implemented in GNAT.

NF-S318-086 Ada 202x AI12-0204 Renaming of a prefixed view (2020-02-24)

  AI12-0204 clarified that the prefix of a prefixed view that is
  renamed or passed as a formal subprogram must be renamable as an
  object, which is now implemented.

NF-S318-082 Ada 202x: read/write protected functions (AI12-0129) (2020-07-01)

  A new aspect Exclusive_Functions has been added to the language to
  force the use of read/write locks on protected functions when
  needed.

NF-S318-077 Ada 202x relaxes 'Old prefix restriction (AI12-0217) (2020-03-25)

  AI12-0217 loosens the rules regarding what is allowed as the
  prefix of a 'Old attribute reference. In particular, a prefix is
  now only required to "statically name" (as opposed to the previous
  "statically denote") an object. This means that, at least in many
  cases, components of composite objects that previously would have
  been illegal are now legal prefixes. The compiler changes that
  implemented this AI were included in the compiler work for a
  related AI, AI12-0369, which also makes use of the term
  "statically name"; the ticket for that AI is T312-059. No compiler
  changes were made specifically on this ticket. Thus, the merge
  date for this ticket is that of T312-059.

NF-S318-072 Has_Same_Storage on objects of size zero (AI12-0077) (2020-03-30)

  This binding interpretation has been implemented and the
  Has_Same_Storage attribute now always returns false for objects
  that have a size of zero.

NF-S318-061 'Ada 202x: 'Old accessibility rules (AI12-0032)' (2020-04-24)

  AI12-0032 resolves several issues related to the Old attribute.
  The GNAT compiler already implemented what the AI requires in most
  of those cases, but two having to do with static and dynamic
  checking of the accessibility level of the constant object
  implicitly declared for an Old attribute reference were not yet
  implemented. Accessibility checking for these constants is now
  implemented as defined in the AI.

NF-S318-059 Ada 202x: Put_Image attribute (AI12-0020) (2020-03-30)

  The Put_Image attribute is implemented with some limitations.
  Put_Image prints out a human-readable representation of an object.
  It composes properly for composite types. It may be specified via
  an aspect_specification. Current limitations on this feature are
  that it is currently disabled for tagged types (but may be enabled
  via the -gnatd_z switch), and it is not yet fully supported for
  types in Remote_Types packages. (Also, the Image attribute is not
  yet supported for nonscalar types; the intent is that it should
  invoke Put_Image.)

NF-S312-013 Refinement of -gnatwv warnings (2020-07-20)

  The warnings detected by -gnatwv on unassigned variables have been
  refined: variables that are at least partially initialized or
  controlled are no longer flagged, and variables assigned via the
  aggregate "(others => <>)" will be flagged if the aggregate does
  not fully set the variable.

NF-S116-053 Improved performance on empty unbounded strings (2020-03-03)

  The handling of empty unbounded strings has been improved by
  removing concurrent access contention, leading to much faster
  execution time in the case of many manipulations of empty strings
  concurrently.

NF-RA25-045 Improved consistency of symbolic backtraces (2020-09-14)

  The output of symbolic backtraces obtained through the
  GNAT.Traceback.Symbolic API is now formatted in a more systematic
  manner. In particular, we now always start each line with the
  hexadecimal address for which the line is emitted, as we
  previously used to, and we always output ??? in lieu of the
  subprogram name when it is unknown.

NF-R922-002 More info given in "bit number out of range" error (2020-05-19)

  The compiler now indicates the actual and specified sizes when the
  bit range of a component_clause is inconsistent with the actual
  size of the record component.

NF-R622-002 Iterate over GNAT.String_Split.Slice_Set (2020-06-21)

  The package GNAT.String_Split now allows iterating over a
  Slice_Set with the 'for X of ...' notation.

NF-R613-002 Ada 202x AI12-0287 Legality rules for null exclusion (2020-02-17)

  The null exclusion legality rules for generic formal object
  matching and object renaming now only apply to generic formal
  objects with mode in out.

NF-PB02-055 Debug information for completed array types (2019-10-04)

  Forward-declared arrays in C-like languages may have the length of
  a dimension omitted, and the omission is reflected in debug
  information. The definition of such arrays must implicitly or
  explicitly complete the array type with the length that was
  missing in the forward declaration. This length was not being
  reflected in the debug information, but it is now output as the
  type associated with the definition of the array object. Its
  specification, however, remains unchanged, reflecting the
  incompleteness of the forward declaration even in the unit that
  defines the array object. Debug information consumers may need
  adjustments to use the overriding type information, and this was
  the case for GDB.

NF-P902-024 Ada 202x: Declare expressions (AI12-0236) (2020-04-08)

  The declare expression feature of Ada 202x (defined in AI12-0236)
  is now implemented.

NF-P728-023 gnatmetric: per-file --lines-average metrics (2019-10-15)

  The --lines-average metrics are now printed for each source file.
  They were previously printed only globally, for all source files
  taken together.

NF-P502-032 Nonsymbolic backtrace for arm-linux (2020-12-15)

  Nonsymbolic backtraces are now supported on arm-linux targets.

NF-P321-012 Improved code generation for aggregate with "others" (2020-03-02)

  Code generation for aggregates with only an others clause is
  improved and will in particular generate static code at the
  library level in more cases.

NF-J106-002 Support poll system call in GNAT.Sockets API (2020-09-09)

  New polling API in GNAT.Sockets.Poll package is free from some
  restrictions imposed by the Socket_Set_Type used in Check_Selector
  call.