gcc/ada/s-auxdec.ads

   1 ------------------------------------------------------------------------------
   2 --                                                                          --
   3 --                         GNAT COMPILER COMPONENTS                         --
   4 --                                                                          --
   5 --                       S Y S T E M . A U X _ D E C                        --
   6 --                                                                          --
   7 --                                 S p e c                                  --
   8 --                                                                          --
   9 -- GNAT is free software;  you can  redistribute it  and/or modify it under --
  10 -- terms of the  GNU General Public License as published  by the Free Soft- --
  11 -- ware  Foundation;  either version 3,  or (at your option) any later ver- --
  12 -- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
  13 -- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
  14 -- or FITNESS FOR A PARTICULAR PURPOSE.                                     --
  15 --                                                                          --
  16 -- As a special exception under Section 7 of GPL version 3, you are granted --
  17 -- additional permissions described in the GCC Runtime Library Exception,   --
  18 -- version 3.1, as published by the Free Software Foundation.               --
  19 --                                                                          --
  20 -- You should have received a copy of the GNU General Public License and    --
  21 -- a copy of the GCC Runtime Library Exception along with this program;     --
  22 -- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    --
  23 -- <http://www.gnu.org/licenses/>.                                          --
  24 --                                                                          --
  25 -- GNAT was originally developed  by the GNAT team at  New York University. --
  26 -- Extensive contributions were provided by Ada Core Technologies Inc.      --
  27 --                                                                          --
  28 ------------------------------------------------------------------------------
  29
  30 --  This package contains definitions that are designed to be compatible
  31 --  with the extra definitions in package System for DEC Ada implementations.
  32
  33 --  These definitions can be used directly by withing this package, or merged
  34 --  with System using pragma Extend_System (Aux_DEC)
  35
  36 with Ada.Unchecked_Conversion;
  37
  38 package System.Aux_DEC is
  39    pragma Preelaborate;
  40
  41    subtype Short_Address is Address;
  42    --  For compatibility with systems having short and long addresses
  43
  44    type Integer_8  is range -2 **  (8 - 1) .. +2 **  (8 - 1) - 1;
  45    for Integer_8'Size  use  8;
  46
  47    type Integer_16 is range -2 ** (16 - 1) .. +2 ** (16 - 1) - 1;
  48    for Integer_16'Size use 16;
  49
  50    type Integer_32 is range -2 ** (32 - 1) .. +2 ** (32 - 1) - 1;
  51    for Integer_32'Size use 32;
  52
  53    type Integer_64 is range -2 ** (64 - 1) .. +2 ** (64 - 1) - 1;
  54    for Integer_64'Size use 64;
  55
  56    type Integer_8_Array  is array (Integer range <>) of Integer_8;
  57    type Integer_16_Array is array (Integer range <>) of Integer_16;
  58    type Integer_32_Array is array (Integer range <>) of Integer_32;
  59    type Integer_64_Array is array (Integer range <>) of Integer_64;
  60    --  These array types are not in all versions of DEC System, and in fact it
  61    --  is not quite clear why they are in some and not others, but since they
  62    --  definitely appear in some versions, we include them unconditionally.
  63
  64    type Largest_Integer is range Min_Int .. Max_Int;
  65
  66    type AST_Handler is private;
  67
  68    No_AST_Handler : constant AST_Handler;
  69
  70    type Type_Class is
  71      (Type_Class_Enumeration,
  72       Type_Class_Integer,
  73       Type_Class_Fixed_Point,
  74       Type_Class_Floating_Point,
  75       Type_Class_Array,
  76       Type_Class_Record,
  77       Type_Class_Access,
  78       Type_Class_Task,             -- also in Ada 95 protected
  79       Type_Class_Address);
  80
  81    function "not" (Left        : Largest_Integer) return Largest_Integer;
  82    function "and" (Left, Right : Largest_Integer) return Largest_Integer;
  83    function "or"  (Left, Right : Largest_Integer) return Largest_Integer;
  84    function "xor" (Left, Right : Largest_Integer) return Largest_Integer;
  85
  86    Address_Zero       : constant Address;
  87    No_Addr            : constant Address;
  88    Address_Size       : constant := Standard'Address_Size;
  89    Short_Address_Size : constant := Standard'Address_Size;
  90
  91    function "+" (Left : Address; Right : Integer) return Address;
  92    function "+" (Left : Integer; Right : Address) return Address;
  93    function "-" (Left : Address; Right : Address) return Integer;
  94    function "-" (Left : Address; Right : Integer) return Address;
  95
  96    generic
  97       type Target is private;
  98    function Fetch_From_Address (A : Address) return Target;
  99
 100    generic
 101       type Target is private;
 102    procedure Assign_To_Address (A : Address; T : Target);
 103
 104    --  Floating point type declarations for VAX floating point data types
 105
 106    type F_Float is digits 6;
 107    type D_Float is digits 9;
 108    type G_Float is digits 15;
 109    --  We provide the type names, but these will be IEEE format, not VAX format
 110
 111    --  Floating point type declarations for IEEE floating point data types
 112
 113    type IEEE_Single_Float is digits 6;
 114    type IEEE_Double_Float is digits 15;
 115
 116    Non_Ada_Error : exception;
 117
 118    --  Hardware-oriented types and functions
 119
 120    type Bit_Array is array (Integer range <>) of Boolean;
 121    pragma Pack (Bit_Array);
 122
 123    subtype Bit_Array_8  is Bit_Array (0 ..  7);
 124    subtype Bit_Array_16 is Bit_Array (0 .. 15);
 125    subtype Bit_Array_32 is Bit_Array (0 .. 31);
 126    subtype Bit_Array_64 is Bit_Array (0 .. 63);
 127
 128    type Unsigned_Byte is range 0 .. 255;
 129    for  Unsigned_Byte'Size use 8;
 130
 131    function "not" (Left        : Unsigned_Byte) return Unsigned_Byte;
 132    function "and" (Left, Right : Unsigned_Byte) return Unsigned_Byte;
 133    function "or"  (Left, Right : Unsigned_Byte) return Unsigned_Byte;
 134    function "xor" (Left, Right : Unsigned_Byte) return Unsigned_Byte;
 135
 136    function To_Unsigned_Byte (X : Bit_Array_8) return Unsigned_Byte;
 137    function To_Bit_Array_8   (X : Unsigned_Byte) return Bit_Array_8;
 138
 139    type Unsigned_Byte_Array is array (Integer range <>) of Unsigned_Byte;
 140
 141    type Unsigned_Word is range 0 .. 65535;
 142    for  Unsigned_Word'Size use 16;
 143
 144    function "not" (Left        : Unsigned_Word) return Unsigned_Word;
 145    function "and" (Left, Right : Unsigned_Word) return Unsigned_Word;
 146    function "or"  (Left, Right : Unsigned_Word) return Unsigned_Word;
 147    function "xor" (Left, Right : Unsigned_Word) return Unsigned_Word;
 148
 149    function To_Unsigned_Word (X : Bit_Array_16) return Unsigned_Word;
 150    function To_Bit_Array_16  (X : Unsigned_Word) return Bit_Array_16;
 151
 152    type Unsigned_Word_Array is array (Integer range <>) of Unsigned_Word;
 153
 154    type Unsigned_Longword is range -2_147_483_648 .. 2_147_483_647;
 155    for  Unsigned_Longword'Size use 32;
 156
 157    function "not" (Left        : Unsigned_Longword) return Unsigned_Longword;
 158    function "and" (Left, Right : Unsigned_Longword) return Unsigned_Longword;
 159    function "or"  (Left, Right : Unsigned_Longword) return Unsigned_Longword;
 160    function "xor" (Left, Right : Unsigned_Longword) return Unsigned_Longword;
 161
 162    function To_Unsigned_Longword (X : Bit_Array_32) return Unsigned_Longword;
 163    function To_Bit_Array_32 (X : Unsigned_Longword) return Bit_Array_32;
 164
 165    type Unsigned_Longword_Array is
 166       array (Integer range <>) of Unsigned_Longword;
 167
 168    type Unsigned_32 is range 0 .. 4_294_967_295;
 169    for  Unsigned_32'Size use 32;
 170
 171    function "not" (Left        : Unsigned_32) return Unsigned_32;
 172    function "and" (Left, Right : Unsigned_32) return Unsigned_32;
 173    function "or"  (Left, Right : Unsigned_32) return Unsigned_32;
 174    function "xor" (Left, Right : Unsigned_32) return Unsigned_32;
 175
 176    function To_Unsigned_32 (X : Bit_Array_32) return Unsigned_32;
 177    function To_Bit_Array_32 (X : Unsigned_32) return Bit_Array_32;
 178
 179    type Unsigned_Quadword is record
 180       L0 : Unsigned_Longword;
 181       L1 : Unsigned_Longword;
 182    end record;
 183
 184    for Unsigned_Quadword'Size      use 64;
 185    for Unsigned_Quadword'Alignment use
 186      Integer'Min (8, Standard'Maximum_Alignment);
 187
 188    function "not" (Left        : Unsigned_Quadword) return Unsigned_Quadword;
 189    function "and" (Left, Right : Unsigned_Quadword) return Unsigned_Quadword;
 190    function "or"  (Left, Right : Unsigned_Quadword) return Unsigned_Quadword;
 191    function "xor" (Left, Right : Unsigned_Quadword) return Unsigned_Quadword;
 192
 193    function To_Unsigned_Quadword (X : Bit_Array_64) return Unsigned_Quadword;
 194    function To_Bit_Array_64 (X : Unsigned_Quadword) return Bit_Array_64;
 195
 196    type Unsigned_Quadword_Array is
 197       array (Integer range <>) of Unsigned_Quadword;
 198
 199    function To_Address (X : Integer) return Address;
 200    pragma Pure_Function (To_Address);
 201
 202    function To_Address_Long (X : Unsigned_Longword) return Address;
 203    pragma Pure_Function (To_Address_Long);
 204
 205    function To_Integer (X : Address) return Integer;
 206
 207    function To_Unsigned_Longword (X : Address)     return Unsigned_Longword;
 208    function To_Unsigned_Longword (X : AST_Handler) return Unsigned_Longword;
 209
 210    --  Conventional names for static subtypes of type UNSIGNED_LONGWORD
 211
 212    subtype Unsigned_1  is Unsigned_Longword range 0 .. 2** 1 - 1;
 213    subtype Unsigned_2  is Unsigned_Longword range 0 .. 2** 2 - 1;
 214    subtype Unsigned_3  is Unsigned_Longword range 0 .. 2** 3 - 1;
 215    subtype Unsigned_4  is Unsigned_Longword range 0 .. 2** 4 - 1;
 216    subtype Unsigned_5  is Unsigned_Longword range 0 .. 2** 5 - 1;
 217    subtype Unsigned_6  is Unsigned_Longword range 0 .. 2** 6 - 1;
 218    subtype Unsigned_7  is Unsigned_Longword range 0 .. 2** 7 - 1;
 219    subtype Unsigned_8  is Unsigned_Longword range 0 .. 2** 8 - 1;
 220    subtype Unsigned_9  is Unsigned_Longword range 0 .. 2** 9 - 1;
 221    subtype Unsigned_10 is Unsigned_Longword range 0 .. 2**10 - 1;
 222    subtype Unsigned_11 is Unsigned_Longword range 0 .. 2**11 - 1;
 223    subtype Unsigned_12 is Unsigned_Longword range 0 .. 2**12 - 1;
 224    subtype Unsigned_13 is Unsigned_Longword range 0 .. 2**13 - 1;
 225    subtype Unsigned_14 is Unsigned_Longword range 0 .. 2**14 - 1;
 226    subtype Unsigned_15 is Unsigned_Longword range 0 .. 2**15 - 1;
 227    subtype Unsigned_16 is Unsigned_Longword range 0 .. 2**16 - 1;
 228    subtype Unsigned_17 is Unsigned_Longword range 0 .. 2**17 - 1;
 229    subtype Unsigned_18 is Unsigned_Longword range 0 .. 2**18 - 1;
 230    subtype Unsigned_19 is Unsigned_Longword range 0 .. 2**19 - 1;
 231    subtype Unsigned_20 is Unsigned_Longword range 0 .. 2**20 - 1;
 232    subtype Unsigned_21 is Unsigned_Longword range 0 .. 2**21 - 1;
 233    subtype Unsigned_22 is Unsigned_Longword range 0 .. 2**22 - 1;
 234    subtype Unsigned_23 is Unsigned_Longword range 0 .. 2**23 - 1;
 235    subtype Unsigned_24 is Unsigned_Longword range 0 .. 2**24 - 1;
 236    subtype Unsigned_25 is Unsigned_Longword range 0 .. 2**25 - 1;
 237    subtype Unsigned_26 is Unsigned_Longword range 0 .. 2**26 - 1;
 238    subtype Unsigned_27 is Unsigned_Longword range 0 .. 2**27 - 1;
 239    subtype Unsigned_28 is Unsigned_Longword range 0 .. 2**28 - 1;
 240    subtype Unsigned_29 is Unsigned_Longword range 0 .. 2**29 - 1;
 241    subtype Unsigned_30 is Unsigned_Longword range 0 .. 2**30 - 1;
 242    subtype Unsigned_31 is Unsigned_Longword range 0 .. 2**31 - 1;
 243
 244    --  Function for obtaining global symbol values
 245
 246    function Import_Value         (Symbol : String) return Unsigned_Longword;
 247    function Import_Address       (Symbol : String) return Address;
 248    function Import_Largest_Value (Symbol : String) return Largest_Integer;
 249
 250    pragma Import (Intrinsic, Import_Value);
 251    pragma Import (Intrinsic, Import_Address);
 252    pragma Import (Intrinsic, Import_Largest_Value);
 253
 254    --  For the following declarations, note that the declaration without a
 255    --  Retry_Count parameter means to retry infinitely. A value of zero for
 256    --  the Retry_Count parameter means do not retry.
 257
 258    --  Interlocked-instruction procedures
 259
 260    procedure Clear_Interlocked
 261      (Bit       : in out Boolean;
 262       Old_Value : out Boolean);
 263
 264    procedure Set_Interlocked
 265      (Bit       : in out Boolean;
 266       Old_Value : out Boolean);
 267
 268    type Aligned_Word is record
 269       Value : Short_Integer;
 270    end record;
 271
 272    for Aligned_Word'Alignment use Integer'Min (2, Standard'Maximum_Alignment);
 273
 274    procedure Clear_Interlocked
 275      (Bit          : in out Boolean;
 276       Old_Value    : out Boolean;
 277       Retry_Count  : Natural;
 278       Success_Flag : out Boolean);
 279
 280    procedure Set_Interlocked
 281      (Bit          : in out Boolean;
 282       Old_Value    : out Boolean;
 283       Retry_Count  : Natural;
 284       Success_Flag : out Boolean);
 285
 286    procedure Add_Interlocked
 287      (Addend       : Short_Integer;
 288       Augend       : in out Aligned_Word;
 289       Sign         : out Integer);
 290
 291    type Aligned_Integer is record
 292       Value : Integer;
 293    end record;
 294
 295    for Aligned_Integer'Alignment use
 296      Integer'Min (4, Standard'Maximum_Alignment);
 297
 298    type Aligned_Long_Integer is record
 299       Value : Long_Integer;
 300    end record;
 301
 302    for Aligned_Long_Integer'Alignment use
 303      Integer'Min (8, Standard'Maximum_Alignment);
 304
 305    --  For the following declarations, note that the declaration without a
 306    --  Retry_Count parameter mean to retry infinitely. A value of zero for
 307    --  the Retry_Count means do not retry.
 308
 309    procedure Add_Atomic
 310      (To           : in out Aligned_Integer;
 311       Amount       : Integer);
 312
 313    procedure Add_Atomic
 314      (To           : in out Aligned_Integer;
 315       Amount       : Integer;
 316       Retry_Count  : Natural;
 317       Old_Value    : out Integer;
 318       Success_Flag : out Boolean);
 319
 320    procedure Add_Atomic
 321      (To           : in out Aligned_Long_Integer;
 322       Amount       : Long_Integer);
 323
 324    procedure Add_Atomic
 325      (To           : in out Aligned_Long_Integer;
 326       Amount       : Long_Integer;
 327       Retry_Count  : Natural;
 328       Old_Value    : out Long_Integer;
 329       Success_Flag : out Boolean);
 330
 331    procedure And_Atomic
 332      (To           : in out Aligned_Integer;
 333       From         : Integer);
 334
 335    procedure And_Atomic
 336      (To           : in out Aligned_Integer;
 337       From         : Integer;
 338       Retry_Count  : Natural;
 339       Old_Value    : out Integer;
 340       Success_Flag : out Boolean);
 341
 342    procedure And_Atomic
 343      (To           : in out Aligned_Long_Integer;
 344       From         : Long_Integer);
 345
 346    procedure And_Atomic
 347      (To           : in out Aligned_Long_Integer;
 348       From         : Long_Integer;
 349       Retry_Count  : Natural;
 350       Old_Value    : out Long_Integer;
 351       Success_Flag : out Boolean);
 352
 353    procedure Or_Atomic
 354      (To           : in out Aligned_Integer;
 355       From         : Integer);
 356
 357    procedure Or_Atomic
 358      (To           : in out Aligned_Integer;
 359       From         : Integer;
 360       Retry_Count  : Natural;
 361       Old_Value    : out Integer;
 362       Success_Flag : out Boolean);
 363
 364    procedure Or_Atomic
 365      (To           : in out Aligned_Long_Integer;
 366       From         : Long_Integer);
 367
 368    procedure Or_Atomic
 369      (To           : in out Aligned_Long_Integer;
 370       From         : Long_Integer;
 371       Retry_Count  : Natural;
 372       Old_Value    : out Long_Integer;
 373       Success_Flag : out Boolean);
 374
 375    type Insq_Status is (Fail_No_Lock, OK_Not_First, OK_First);
 376
 377    for Insq_Status use
 378      (Fail_No_Lock => -1,
 379       OK_Not_First =>  0,
 380       OK_First     => +1);
 381
 382    type Remq_Status is (
 383      Fail_No_Lock,
 384      Fail_Was_Empty,
 385      OK_Not_Empty,
 386      OK_Empty);
 387
 388    for Remq_Status use
 389      (Fail_No_Lock   => -1,
 390       Fail_Was_Empty =>  0,
 391       OK_Not_Empty   => +1,
 392       OK_Empty       => +2);
 393
 394    procedure Insqhi
 395      (Item   : Address;
 396       Header : Address;
 397       Status : out Insq_Status);
 398
 399    procedure Remqhi
 400      (Header : Address;
 401       Item   : out Address;
 402       Status : out Remq_Status);
 403
 404    procedure Insqti
 405      (Item   : Address;
 406       Header : Address;
 407       Status : out Insq_Status);
 408
 409    procedure Remqti
 410      (Header : Address;
 411       Item   : out Address;
 412       Status : out Remq_Status);
 413
 414 private
 415
 416    Address_Zero : constant Address := Null_Address;
 417    No_Addr      : constant Address := Null_Address;
 418
 419    --  An AST_Handler value is from a typing point of view simply a pointer
 420    --  to a procedure taking a single 64 bit parameter. However, this
 421    --  is a bit misleading, because the data that this pointer references is
 422    --  highly stylized. See body of System.AST_Handling for full details.
 423
 424    type AST_Handler is access procedure (Param : Long_Integer);
 425    No_AST_Handler : constant AST_Handler := null;
 426
 427    --  Other operators have incorrect profiles. It would be nice to make
 428    --  them intrinsic, since the backend can handle them, but the front
 429    --  end is not prepared to deal with them, so at least inline them.
 430
 431    pragma Inline_Always ("+");
 432    pragma Inline_Always ("-");
 433    pragma Inline_Always ("not");
 434    pragma Inline_Always ("and");
 435    pragma Inline_Always ("or");
 436    pragma Inline_Always ("xor");
 437
 438    --  Other inlined subprograms
 439
 440    pragma Inline_Always (Fetch_From_Address);
 441    pragma Inline_Always (Assign_To_Address);
 442
 443    --  Synchronization related subprograms. Mechanism is explicitly set
 444    --  so that the critical parameters are passed by reference.
 445    --  Without this, the parameters are passed by copy, creating load/store
 446    --  race conditions. We also inline them, since this seems more in the
 447    --  spirit of the original (hardware intrinsic) routines.
 448
 449    pragma Export_Procedure
 450      (Clear_Interlocked,
 451       External        => "system__aux_dec__clear_interlocked__1",
 452       Parameter_Types => (Boolean, Boolean),
 453       Mechanism       => (Reference, Reference));
 454    pragma Export_Procedure
 455      (Clear_Interlocked,
 456       External        => "system__aux_dec__clear_interlocked__2",
 457       Parameter_Types => (Boolean, Boolean, Natural, Boolean),
 458       Mechanism       => (Reference, Reference, Value, Reference));
 459    pragma Inline_Always (Clear_Interlocked);
 460
 461    pragma Export_Procedure
 462      (Set_Interlocked,
 463       External        => "system__aux_dec__set_interlocked__1",
 464       Parameter_Types => (Boolean, Boolean),
 465       Mechanism       => (Reference, Reference));
 466    pragma Export_Procedure
 467      (Set_Interlocked,
 468       External        => "system__aux_dec__set_interlocked__2",
 469       Parameter_Types => (Boolean, Boolean, Natural, Boolean),
 470       Mechanism       => (Reference, Reference, Value, Reference));
 471    pragma Inline_Always (Set_Interlocked);
 472
 473    pragma Export_Procedure
 474      (Add_Interlocked,
 475       External        => "system__aux_dec__add_interlocked__1",
 476       Mechanism       => (Value, Reference, Reference));
 477    pragma Inline_Always (Add_Interlocked);
 478
 479    pragma Export_Procedure
 480      (Add_Atomic,
 481       External        => "system__aux_dec__add_atomic__1",
 482       Parameter_Types => (Aligned_Integer, Integer),
 483       Mechanism       => (Reference, Value));
 484    pragma Export_Procedure
 485      (Add_Atomic,
 486       External        => "system__aux_dec__add_atomic__2",
 487       Parameter_Types => (Aligned_Integer, Integer, Natural, Integer, Boolean),
 488       Mechanism       => (Reference, Value, Value, Reference, Reference));
 489    pragma Export_Procedure
 490      (Add_Atomic,
 491       External        => "system__aux_dec__add_atomic__3",
 492       Parameter_Types => (Aligned_Long_Integer, Long_Integer),
 493       Mechanism       => (Reference, Value));
 494    pragma Export_Procedure
 495      (Add_Atomic,
 496       External        => "system__aux_dec__add_atomic__4",
 497       Parameter_Types => (Aligned_Long_Integer, Long_Integer, Natural,
 498                           Long_Integer, Boolean),
 499       Mechanism       => (Reference, Value, Value, Reference, Reference));
 500    pragma Inline_Always (Add_Atomic);
 501
 502    pragma Export_Procedure
 503      (And_Atomic,
 504       External        => "system__aux_dec__and_atomic__1",
 505       Parameter_Types => (Aligned_Integer, Integer),
 506       Mechanism       => (Reference, Value));
 507    pragma Export_Procedure
 508      (And_Atomic,
 509       External        => "system__aux_dec__and_atomic__2",
 510       Parameter_Types => (Aligned_Integer, Integer, Natural, Integer, Boolean),
 511       Mechanism       => (Reference, Value, Value, Reference, Reference));
 512    pragma Export_Procedure
 513      (And_Atomic,
 514       External => "system__aux_dec__and_atomic__3",
 515       Parameter_Types => (Aligned_Long_Integer, Long_Integer),
 516       Mechanism => (Reference, Value));
 517    pragma Export_Procedure
 518      (And_Atomic,
 519       External        => "system__aux_dec__and_atomic__4",
 520       Parameter_Types => (Aligned_Long_Integer, Long_Integer, Natural,
 521                           Long_Integer, Boolean),
 522       Mechanism       => (Reference, Value, Value, Reference, Reference));
 523    pragma Inline_Always (And_Atomic);
 524
 525    pragma Export_Procedure
 526      (Or_Atomic,
 527       External        => "system__aux_dec__or_atomic__1",
 528       Parameter_Types => (Aligned_Integer, Integer),
 529       Mechanism       => (Reference, Value));
 530    pragma Export_Procedure
 531      (Or_Atomic,
 532       External        => "system__aux_dec__or_atomic__2",
 533       Parameter_Types => (Aligned_Integer, Integer, Natural, Integer, Boolean),
 534       Mechanism       => (Reference, Value, Value, Reference, Reference));
 535    pragma Export_Procedure
 536      (Or_Atomic,
 537       External        => "system__aux_dec__or_atomic__3",
 538       Parameter_Types => (Aligned_Long_Integer, Long_Integer),
 539       Mechanism       => (Reference, Value));
 540    pragma Export_Procedure
 541      (Or_Atomic,
 542       External        => "system__aux_dec__or_atomic__4",
 543       Parameter_Types => (Aligned_Long_Integer, Long_Integer, Natural,
 544                           Long_Integer, Boolean),
 545       Mechanism       => (Reference, Value, Value, Reference, Reference));
 546    pragma Inline_Always (Or_Atomic);
 547
 548    --  Provide proper unchecked conversion definitions for transfer
 549    --  functions. Note that we need this level of indirection because
 550    --  the formal parameter name is X and not Source (and this is indeed
 551    --  detectable by a program)
 552
 553    function To_Unsigned_Byte_A is new
 554      Ada.Unchecked_Conversion (Bit_Array_8, Unsigned_Byte);
 555
 556    function To_Unsigned_Byte (X : Bit_Array_8) return Unsigned_Byte
 557      renames To_Unsigned_Byte_A;
 558
 559    function To_Bit_Array_8_A is new
 560      Ada.Unchecked_Conversion (Unsigned_Byte, Bit_Array_8);
 561
 562    function To_Bit_Array_8 (X : Unsigned_Byte) return Bit_Array_8
 563      renames To_Bit_Array_8_A;
 564
 565    function To_Unsigned_Word_A is new
 566      Ada.Unchecked_Conversion (Bit_Array_16, Unsigned_Word);
 567
 568    function To_Unsigned_Word (X : Bit_Array_16) return Unsigned_Word
 569      renames To_Unsigned_Word_A;
 570
 571    function To_Bit_Array_16_A is new
 572      Ada.Unchecked_Conversion (Unsigned_Word, Bit_Array_16);
 573
 574    function To_Bit_Array_16 (X : Unsigned_Word) return Bit_Array_16
 575      renames To_Bit_Array_16_A;
 576
 577    function To_Unsigned_Longword_A is new
 578      Ada.Unchecked_Conversion (Bit_Array_32, Unsigned_Longword);
 579
 580    function To_Unsigned_Longword (X : Bit_Array_32) return Unsigned_Longword
 581      renames To_Unsigned_Longword_A;
 582
 583    function To_Bit_Array_32_A is new
 584      Ada.Unchecked_Conversion (Unsigned_Longword, Bit_Array_32);
 585
 586    function To_Bit_Array_32 (X : Unsigned_Longword) return Bit_Array_32
 587      renames To_Bit_Array_32_A;
 588
 589    function To_Unsigned_32_A is new
 590      Ada.Unchecked_Conversion (Bit_Array_32, Unsigned_32);
 591
 592    function To_Unsigned_32 (X : Bit_Array_32) return Unsigned_32
 593      renames To_Unsigned_32_A;
 594
 595    function To_Bit_Array_32_A is new
 596      Ada.Unchecked_Conversion (Unsigned_32, Bit_Array_32);
 597
 598    function To_Bit_Array_32 (X : Unsigned_32) return Bit_Array_32
 599      renames To_Bit_Array_32_A;
 600
 601    function To_Unsigned_Quadword_A is new
 602      Ada.Unchecked_Conversion (Bit_Array_64, Unsigned_Quadword);
 603
 604    function To_Unsigned_Quadword (X : Bit_Array_64) return Unsigned_Quadword
 605      renames To_Unsigned_Quadword_A;
 606
 607    function To_Bit_Array_64_A is new
 608      Ada.Unchecked_Conversion (Unsigned_Quadword, Bit_Array_64);
 609
 610    function To_Bit_Array_64 (X : Unsigned_Quadword) return Bit_Array_64
 611      renames To_Bit_Array_64_A;
 612
 613    pragma Warnings (Off);
 614    --  Turn warnings off. This is needed for systems with 64-bit integers,
 615    --  where some of these operations are of dubious meaning, but we do not
 616    --  want warnings when we compile on such systems.
 617
 618    function To_Address_A is new
 619      Ada.Unchecked_Conversion (Integer, Address);
 620    pragma Pure_Function (To_Address_A);
 621
 622    function To_Address (X : Integer) return Address
 623      renames To_Address_A;
 624    pragma Pure_Function (To_Address);
 625
 626    function To_Address_Long_A is new
 627      Ada.Unchecked_Conversion (Unsigned_Longword, Address);
 628    pragma Pure_Function (To_Address_Long_A);
 629
 630    function To_Address_Long (X : Unsigned_Longword) return Address
 631      renames To_Address_Long_A;
 632    pragma Pure_Function (To_Address_Long);
 633
 634    function To_Integer_A is new
 635      Ada.Unchecked_Conversion (Address, Integer);
 636
 637    function To_Integer (X : Address) return Integer
 638      renames To_Integer_A;
 639
 640    function To_Unsigned_Longword_A is new
 641      Ada.Unchecked_Conversion (Address, Unsigned_Longword);
 642
 643    function To_Unsigned_Longword (X : Address) return Unsigned_Longword
 644      renames To_Unsigned_Longword_A;
 645
 646    function To_Unsigned_Longword_A is new
 647      Ada.Unchecked_Conversion (AST_Handler, Unsigned_Longword);
 648
 649    function To_Unsigned_Longword (X : AST_Handler) return Unsigned_Longword
 650      renames To_Unsigned_Longword_A;
 651
 652    pragma Warnings (On);
 653
 654 end System.Aux_DEC;