return Ceiling_Support;
    end Get_Ceiling_Support;
 
-   pragma Warnings (Off, "non-static call not allowed in preelaborated unit");
+   pragma Warnings (Off, "non-preelaborable call not allowed*");
    Ceiling_Support : constant Boolean := Get_Ceiling_Support;
-   pragma Warnings (On, "non-static call not allowed in preelaborated unit");
+   pragma Warnings (On, "non-preelaborable call not allowed*");
    --  True if the locking policy is Ceiling_Locking, and the current process
    --  has permission to use this policy. The process has permission if it is
    --  running as 'root', or if the capability was set by the setcap command,
 
 --                                                                          --
 ------------------------------------------------------------------------------
 
-pragma Ada_2020;
-
 with Ada.Unchecked_Deallocation;
 with Ada.Strings.Text_Output.Utils;
 
 
 --                                                                          --
 ------------------------------------------------------------------------------
 
-pragma Ada_2020;
-
 with Ada.Strings.Text_Output; use Ada.Strings.Text_Output;
 
 private with Ada.Finalization;
 
 
 --  This is the GMP version of this package
 
-pragma Ada_2020;
-
 with Ada.Unchecked_Conversion;
 with Ada.Unchecked_Deallocation;
 with Interfaces.C;               use Interfaces.C;
 
 
 --  This is the default version of this package, based on Big_Integers only.
 
-pragma Ada_2020;
-
 with Ada.Strings.Text_Output.Utils;
 
 package body Ada.Numerics.Big_Numbers.Big_Reals is
 
 --                                                                          --
 ------------------------------------------------------------------------------
 
-pragma Ada_2020;
-
 with Ada.Numerics.Big_Numbers.Big_Integers;
 
 with Ada.Strings.Text_Output; use Ada.Strings.Text_Output;
 
 --                                                                          --
 ------------------------------------------------------------------------------
 
-pragma Ada_2020;
-
 package body Ada.Strings.Text_Output.Bit_Buckets is
 
    type Bit_Bucket_Type is new Sink with null record;
 
 --                                                                          --
 ------------------------------------------------------------------------------
 
-pragma Ada_2020;
-
 package Ada.Strings.Text_Output.Bit_Buckets is
    function Bit_Bucket return Sink_Access;
 end Ada.Strings.Text_Output.Bit_Buckets;
 
 --                                                                          --
 ------------------------------------------------------------------------------
 
-pragma Ada_2020;
-
 with Ada.Strings.Text_Output.Utils; use Ada.Strings.Text_Output.Utils;
 package body Ada.Strings.Text_Output.Basic_Files is
    use type OS.File_Descriptor;
 
 --                                                                          --
 ------------------------------------------------------------------------------
 
-pragma Ada_2020;
-
 private with GNAT.OS_Lib;
 package Ada.Strings.Text_Output.Basic_Files is
    --  Normally, you should use Ada.Strings.Text_Output.Files, which
 
 --                                                                          --
 ------------------------------------------------------------------------------
 
-pragma Ada_2020;
-
 with Unchecked_Deallocation;
 with Ada.Strings.UTF_Encoding.Strings;
 with Ada.Strings.UTF_Encoding.Wide_Strings;
 
 --                                                                          --
 ------------------------------------------------------------------------------
 
-pragma Ada_2020;
-
 package Ada.Strings.Text_Output.Buffers is
 
    type Buffer (<>) is new Sink with private;
 
 --                                                                          --
 ------------------------------------------------------------------------------
 
-pragma Ada_2020;
-
 with Ada.Strings.Text_Output.Utils; use Ada.Strings.Text_Output.Utils;
 package body Ada.Strings.Text_Output.Files is
    use type OS.File_Descriptor;
 
 --                                                                          --
 ------------------------------------------------------------------------------
 
-pragma Ada_2020;
-
 private with GNAT.OS_Lib;
 private with Ada.Finalization;
 package Ada.Strings.Text_Output.Files is
 
 --                                                                          --
 ------------------------------------------------------------------------------
 
-pragma Ada_2020;
-
 with Ada.Strings.Text_Output.Files;
 with Ada.Strings.Text_Output.Buffers; use Ada.Strings.Text_Output.Buffers;
 with Ada.Strings.Text_Output.Utils; use Ada.Strings.Text_Output.Utils;
 
 --                                                                          --
 ------------------------------------------------------------------------------
 
-pragma Ada_2020;
-
 package Ada.Strings.Text_Output.Formatting is
 
    --  Template-based output, based loosely on C's printf family. Unlike
 
 --                                                                          --
 ------------------------------------------------------------------------------
 
-pragma Ada_2020;
-
 with Ada.Strings.UTF_Encoding.Wide_Wide_Strings;
+
 package body Ada.Strings.Text_Output.Utils is
 
    procedure Put_Octet (S : in out Sink'Class; Item : Character) with Inline;
 
 --                                                                          --
 ------------------------------------------------------------------------------
 
-pragma Ada_2020;
-
 package Ada.Strings.Text_Output.Utils with Preelaborate is
 
    --  This package provides utility functions on Sink'Class. These are
 
 --                                                                          --
 ------------------------------------------------------------------------------
 
-pragma Ada_2020;
 package Ada.Streams.Storage with Pure is
 
    type Storage_Stream_Type is abstract new Root_Stream_Type with private;
 
 --                                                                          --
 ------------------------------------------------------------------------------
 
-pragma Ada_2020;
 package body Ada.Streams.Storage.Bounded is
 
    ----------
 
 --                                                                          --
 ------------------------------------------------------------------------------
 
-pragma Ada_2020;
 package Ada.Streams.Storage.Bounded with Pure is
 
    type Stream_Type (Max_Elements : Stream_Element_Count) is
 
 --                                                                          --
 ------------------------------------------------------------------------------
 
-pragma Ada_2020;
 with Ada.Unchecked_Deallocation;
+
 package body Ada.Streams.Storage.Unbounded is
 
    procedure Free is new Ada.Unchecked_Deallocation
 
 --                                                                          --
 ------------------------------------------------------------------------------
 
-pragma Ada_2020;
 private with Ada.Finalization;
+
 package Ada.Streams.Storage.Unbounded with Preelaborate is
 
    type Stream_Type is new Storage_Stream_Type with private with
 
 --                                                                          --
 ------------------------------------------------------------------------------
 
-pragma Ada_2020;
-
 with Ada.Strings.UTF_Encoding;
 with Ada.Strings.UTF_Encoding.Wide_Wide_Strings;
+
 package Ada.Strings.Text_Output with Preelaborate is
 
    --  This package provides a "Sink" abstraction, to which characters of type
 
 --                                                                          --
 ------------------------------------------------------------------------------
 
-pragma Ada_2020;
-
 generic
    type Atomic_Type is range <> with Atomic;
 package System.Atomic_Operations.Integer_Arithmetic
 
 --                                                                          --
 ------------------------------------------------------------------------------
 
-pragma Ada_2020;
-
 generic
    type Atomic_Type is mod <> with Atomic;
 package System.Atomic_Operations.Modular_Arithmetic
 
 --                                                                          --
 ------------------------------------------------------------------------------
 
-pragma Ada_2020;
-
 generic
    type Atomic_Type is private with Atomic;
 package System.Atomic_Operations.Exchange
   with Pure
---  Blocking
 is
    function Atomic_Exchange
      (Item  : aliased in out Atomic_Type;
 
 --                                                                          --
 ------------------------------------------------------------------------------
 
-pragma Ada_2020;
 with Unchecked_Conversion;
 with Ada.Strings.Text_Output.Utils;
 use Ada.Strings.Text_Output;
 
 --                                                                          --
 ------------------------------------------------------------------------------
 
-pragma Ada_2020;
 with Ada.Strings.Text_Output;
 with Ada.Task_Identification;
+
 package System.Put_Task_Images is
 
    --  This package contains subprograms that are called by the generated code
 
 --                                                                          --
 ------------------------------------------------------------------------------
 
-pragma Ada_2020;
 with Unchecked_Conversion;
 with Ada.Strings.Text_Output.Utils;
 use Ada.Strings.Text_Output;
 
 --                                                                          --
 ------------------------------------------------------------------------------
 
-pragma Ada_2020;
 with Ada.Strings.Text_Output;
 with System.Unsigned_Types;
+
 package System.Put_Images is
 
    --  This package contains subprograms that are called by the generated code
 
    --  remains set to Ada_Version_Default). This is used in the rare cases
    --  (notably pragma Obsolescent) where we want the explicit version set.
 
-   Ada_Version_Runtime : Ada_Version_Type := Ada_2012;
+   Ada_Version_Runtime : Ada_Version_Type := Ada_2020;
    --  GNAT
    --  Ada version used to compile the runtime. Used to set Ada_Version (but
    --  not Ada_Version_Explicit) when compiling predefined or internal units.
 
 
       --  If the base type is a scalar type, or else if there is no
       --  constraint, the atomic flag is inherited by the subtype.
+      --  Ditto for the Independent aspect.
 
       if Is_Scalar_Type (Id)
         or else Is_Entity_Name (Subtype_Indication (N))
       then
          Set_Is_Atomic (Id, Is_Atomic (T));
+         Set_Is_Independent (Id, Is_Independent (T));
       end if;
 
       --  Remaining processing depends on characteristics of base type