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