1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
5 -- S Y S T E M . A U X _ D E C --
9 -- Copyright (C) 1996-2009, Free Software Foundation, Inc. --
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 3, 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. --
18 -- As a special exception under Section 7 of GPL version 3, you are granted --
19 -- additional permissions described in the GCC Runtime Library Exception, --
20 -- version 3.1, as published by the Free Software Foundation. --
22 -- You should have received a copy of the GNU General Public License and --
23 -- a copy of the GCC Runtime Library Exception along with this program; --
24 -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
25 -- <http://www.gnu.org/licenses/>. --
27 -- GNAT was originally developed by the GNAT team at New York University. --
28 -- Extensive contributions were provided by Ada Core Technologies Inc. --
30 ------------------------------------------------------------------------------
32 -- This package contains definitions that are designed to be compatible
33 -- with the extra definitions in package System for DEC Ada implementations.
35 -- These definitions can be used directly by withing this package, or merged
36 -- with System using pragma Extend_System (Aux_DEC)
38 with Ada.Unchecked_Conversion;
40 package System.Aux_DEC is
43 subtype Short_Address is Address;
44 -- In some versions of System.Aux_DEC, notably that for VMS on the
45 -- ia64, there are two address types (64-bit and 32-bit), and the
46 -- name Short_Address is used for the short address form. To avoid
47 -- difficulties (in regression tests and elsewhere) with units that
48 -- reference Short_Address, it is provided for other targets as a
49 -- synonym for the normal Address type, and, as in the case where
50 -- the lengths are different, Address and Short_Address can be
51 -- freely inter-converted.
53 type Integer_8 is range -2 ** (8 - 1) .. +2 ** (8 - 1) - 1;
54 for Integer_8'Size use 8;
56 type Integer_16 is range -2 ** (16 - 1) .. +2 ** (16 - 1) - 1;
57 for Integer_16'Size use 16;
59 type Integer_32 is range -2 ** (32 - 1) .. +2 ** (32 - 1) - 1;
60 for Integer_32'Size use 32;
62 type Integer_64 is range -2 ** (64 - 1) .. +2 ** (64 - 1) - 1;
63 for Integer_64'Size use 64;
65 type Largest_Integer is range Min_Int .. Max_Int;
67 type AST_Handler is private;
69 No_AST_Handler : constant AST_Handler;
72 (Type_Class_Enumeration,
74 Type_Class_Fixed_Point,
75 Type_Class_Floating_Point,
79 Type_Class_Task, -- also in Ada 95 protected
82 function "not" (Left : Largest_Integer) return Largest_Integer;
83 function "and" (Left, Right : Largest_Integer) return Largest_Integer;
84 function "or" (Left, Right : Largest_Integer) return Largest_Integer;
85 function "xor" (Left, Right : Largest_Integer) return Largest_Integer;
87 Address_Zero : constant Address;
88 No_Addr : constant Address;
89 Address_Size : constant := Standard'Address_Size;
90 Short_Address_Size : constant := Standard'Address_Size;
92 function "+" (Left : Address; Right : Integer) return Address;
93 function "+" (Left : Integer; Right : Address) return Address;
94 function "-" (Left : Address; Right : Address) return Integer;
95 function "-" (Left : Address; Right : Integer) return Address;
98 type Target is private;
99 function Fetch_From_Address (A : Address) return Target;
102 type Target is private;
103 procedure Assign_To_Address (A : Address; T : Target);
105 -- Floating point type declarations for VAX floating point data types
107 pragma Warnings (Off);
110 type F_Float is digits 6;
111 pragma Float_Representation (VAX_Float, F_Float);
113 type D_Float is digits 9;
114 pragma Float_Representation (Vax_Float, D_Float);
116 type G_Float is digits 15;
117 pragma Float_Representation (Vax_Float, G_Float);
119 -- Floating point type declarations for IEEE floating point data types
121 type IEEE_Single_Float is digits 6;
122 pragma Float_Representation (IEEE_Float, IEEE_Single_Float);
124 type IEEE_Double_Float is digits 15;
125 pragma Float_Representation (IEEE_Float, IEEE_Double_Float);
127 pragma Warnings (On);
129 Non_Ada_Error : exception;
131 -- Hardware-oriented types and functions
133 type Bit_Array is array (Integer range <>) of Boolean;
134 pragma Pack (Bit_Array);
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);
141 type Unsigned_Byte is range 0 .. 255;
142 for Unsigned_Byte'Size use 8;
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;
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;
152 type Unsigned_Byte_Array is array (Integer range <>) of Unsigned_Byte;
154 type Unsigned_Word is range 0 .. 65535;
155 for Unsigned_Word'Size use 16;
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;
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;
165 type Unsigned_Word_Array is array (Integer range <>) of Unsigned_Word;
167 type Unsigned_Longword is range -2_147_483_648 .. 2_147_483_647;
168 for Unsigned_Longword'Size use 32;
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;
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;
178 type Unsigned_Longword_Array is
179 array (Integer range <>) of Unsigned_Longword;
181 type Unsigned_32 is range 0 .. 4_294_967_295;
182 for Unsigned_32'Size use 32;
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;
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;
192 type Unsigned_Quadword is record
193 L0 : Unsigned_Longword;
194 L1 : Unsigned_Longword;
197 for Unsigned_Quadword'Size use 64;
198 for Unsigned_Quadword'Alignment use
199 Integer'Min (8, Standard'Maximum_Alignment);
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;
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;
209 type Unsigned_Quadword_Array is
210 array (Integer range <>) of Unsigned_Quadword;
212 function To_Address (X : Integer) return Address;
213 pragma Pure_Function (To_Address);
215 function To_Address_Long (X : Unsigned_Longword) return Address;
216 pragma Pure_Function (To_Address_Long);
218 function To_Integer (X : Address) return Integer;
220 function To_Unsigned_Longword (X : Address) return Unsigned_Longword;
221 function To_Unsigned_Longword (X : AST_Handler) return Unsigned_Longword;
223 -- Conventional names for static subtypes of type UNSIGNED_LONGWORD
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;
257 -- Function for obtaining global symbol values
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;
263 pragma Import (Intrinsic, Import_Value);
264 pragma Import (Intrinsic, Import_Address);
265 pragma Import (Intrinsic, Import_Largest_Value);
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.
271 -- Interlocked-instruction procedures
273 procedure Clear_Interlocked
274 (Bit : in out Boolean;
275 Old_Value : out Boolean);
277 procedure Set_Interlocked
278 (Bit : in out Boolean;
279 Old_Value : out Boolean);
281 type Aligned_Word is record
282 Value : Short_Integer;
285 for Aligned_Word'Alignment use
286 Integer'Min (2, Standard'Maximum_Alignment);
288 procedure Clear_Interlocked
289 (Bit : in out Boolean;
290 Old_Value : out Boolean;
291 Retry_Count : Natural;
292 Success_Flag : out Boolean);
294 procedure Set_Interlocked
295 (Bit : in out Boolean;
296 Old_Value : out Boolean;
297 Retry_Count : Natural;
298 Success_Flag : out Boolean);
300 procedure Add_Interlocked
301 (Addend : Short_Integer;
302 Augend : in out Aligned_Word;
305 type Aligned_Integer is record
309 for Aligned_Integer'Alignment use
310 Integer'Min (4, Standard'Maximum_Alignment);
312 type Aligned_Long_Integer is record
313 Value : Long_Integer;
316 for Aligned_Long_Integer'Alignment use
317 Integer'Min (8, Standard'Maximum_Alignment);
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.
324 (To : in out Aligned_Integer;
328 (To : in out Aligned_Integer;
330 Retry_Count : Natural;
331 Old_Value : out Integer;
332 Success_Flag : out Boolean);
335 (To : in out Aligned_Long_Integer;
336 Amount : Long_Integer);
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);
346 (To : in out Aligned_Integer;
350 (To : in out Aligned_Integer;
352 Retry_Count : Natural;
353 Old_Value : out Integer;
354 Success_Flag : out Boolean);
357 (To : in out Aligned_Long_Integer;
358 From : Long_Integer);
361 (To : in out Aligned_Long_Integer;
363 Retry_Count : Natural;
364 Old_Value : out Long_Integer;
365 Success_Flag : out Boolean);
368 (To : in out Aligned_Integer;
372 (To : in out Aligned_Integer;
374 Retry_Count : Natural;
375 Old_Value : out Integer;
376 Success_Flag : out Boolean);
379 (To : in out Aligned_Long_Integer;
380 From : Long_Integer);
383 (To : in out Aligned_Long_Integer;
385 Retry_Count : Natural;
386 Old_Value : out Long_Integer;
387 Success_Flag : out Boolean);
390 (Fail_No_Lock, OK_Not_First, OK_First);
397 type Remq_Status is (
412 Status : out Insq_Status);
417 Status : out Remq_Status);
422 Status : out Insq_Status);
427 Status : out Remq_Status);
431 Address_Zero : constant Address := Null_Address;
432 No_Addr : constant Address := Null_Address;
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.
439 type AST_Handler is access procedure (Param : Long_Integer);
440 No_AST_Handler : constant AST_Handler := null;
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.
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");
453 -- Other inlined subprograms
455 pragma Inline_Always (Fetch_From_Address);
456 pragma Inline_Always (Assign_To_Address);
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.
464 pragma Export_Procedure
466 External => "system__aux_dec__clear_interlocked__1",
467 Parameter_Types => (Boolean, Boolean),
468 Mechanism => (Reference, Reference));
469 pragma Export_Procedure
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);
476 pragma Export_Procedure
478 External => "system__aux_dec__set_interlocked__1",
479 Parameter_Types => (Boolean, Boolean),
480 Mechanism => (Reference, Reference));
481 pragma Export_Procedure
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);
488 pragma Export_Procedure
490 External => "system__aux_dec__add_interlocked__1",
491 Mechanism => (Value, Reference, Reference));
492 pragma Inline_Always (Add_Interlocked);
494 pragma Export_Procedure
496 External => "system__aux_dec__add_atomic__1",
497 Parameter_Types => (Aligned_Integer, Integer),
498 Mechanism => (Reference, Value));
499 pragma Export_Procedure
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
506 External => "system__aux_dec__add_atomic__3",
507 Parameter_Types => (Aligned_Long_Integer, Long_Integer),
508 Mechanism => (Reference, Value));
509 pragma Export_Procedure
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);
517 pragma Export_Procedure
519 External => "system__aux_dec__and_atomic__1",
520 Parameter_Types => (Aligned_Integer, Integer),
521 Mechanism => (Reference, Value));
522 pragma Export_Procedure
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
529 External => "system__aux_dec__and_atomic__3",
530 Parameter_Types => (Aligned_Long_Integer, Long_Integer),
531 Mechanism => (Reference, Value));
532 pragma Export_Procedure
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);
540 pragma Export_Procedure
542 External => "system__aux_dec__or_atomic__1",
543 Parameter_Types => (Aligned_Integer, Integer),
544 Mechanism => (Reference, Value));
545 pragma Export_Procedure
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
552 External => "system__aux_dec__or_atomic__3",
553 Parameter_Types => (Aligned_Long_Integer, Long_Integer),
554 Mechanism => (Reference, Value));
555 pragma Export_Procedure
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);
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)
568 function To_Unsigned_Byte_A is new
569 Ada.Unchecked_Conversion (Bit_Array_8, Unsigned_Byte);
571 function To_Unsigned_Byte (X : Bit_Array_8) return Unsigned_Byte
572 renames To_Unsigned_Byte_A;
574 function To_Bit_Array_8_A is new
575 Ada.Unchecked_Conversion (Unsigned_Byte, Bit_Array_8);
577 function To_Bit_Array_8 (X : Unsigned_Byte) return Bit_Array_8
578 renames To_Bit_Array_8_A;
580 function To_Unsigned_Word_A is new
581 Ada.Unchecked_Conversion (Bit_Array_16, Unsigned_Word);
583 function To_Unsigned_Word (X : Bit_Array_16) return Unsigned_Word
584 renames To_Unsigned_Word_A;
586 function To_Bit_Array_16_A is new
587 Ada.Unchecked_Conversion (Unsigned_Word, Bit_Array_16);
589 function To_Bit_Array_16 (X : Unsigned_Word) return Bit_Array_16
590 renames To_Bit_Array_16_A;
592 function To_Unsigned_Longword_A is new
593 Ada.Unchecked_Conversion (Bit_Array_32, Unsigned_Longword);
595 function To_Unsigned_Longword (X : Bit_Array_32) return Unsigned_Longword
596 renames To_Unsigned_Longword_A;
598 function To_Bit_Array_32_A is new
599 Ada.Unchecked_Conversion (Unsigned_Longword, Bit_Array_32);
601 function To_Bit_Array_32 (X : Unsigned_Longword) return Bit_Array_32
602 renames To_Bit_Array_32_A;
604 function To_Unsigned_32_A is new
605 Ada.Unchecked_Conversion (Bit_Array_32, Unsigned_32);
607 function To_Unsigned_32 (X : Bit_Array_32) return Unsigned_32
608 renames To_Unsigned_32_A;
610 function To_Bit_Array_32_A is new
611 Ada.Unchecked_Conversion (Unsigned_32, Bit_Array_32);
613 function To_Bit_Array_32 (X : Unsigned_32) return Bit_Array_32
614 renames To_Bit_Array_32_A;
616 function To_Unsigned_Quadword_A is new
617 Ada.Unchecked_Conversion (Bit_Array_64, Unsigned_Quadword);
619 function To_Unsigned_Quadword (X : Bit_Array_64) return Unsigned_Quadword
620 renames To_Unsigned_Quadword_A;
622 function To_Bit_Array_64_A is new
623 Ada.Unchecked_Conversion (Unsigned_Quadword, Bit_Array_64);
625 function To_Bit_Array_64 (X : Unsigned_Quadword) return Bit_Array_64
626 renames To_Bit_Array_64_A;
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.
633 function To_Address_A is new
634 Ada.Unchecked_Conversion (Integer, Address);
635 pragma Pure_Function (To_Address_A);
637 function To_Address (X : Integer) return Address
638 renames To_Address_A;
639 pragma Pure_Function (To_Address);
641 function To_Address_Long_A is new
642 Ada.Unchecked_Conversion (Unsigned_Longword, Address);
643 pragma Pure_Function (To_Address_Long_A);
645 function To_Address_Long (X : Unsigned_Longword) return Address
646 renames To_Address_Long_A;
647 pragma Pure_Function (To_Address_Long);
649 function To_Integer_A is new
650 Ada.Unchecked_Conversion (Address, Integer);
652 function To_Integer (X : Address) return Integer
653 renames To_Integer_A;
655 function To_Unsigned_Longword_A is new
656 Ada.Unchecked_Conversion (Address, Unsigned_Longword);
658 function To_Unsigned_Longword (X : Address) return Unsigned_Longword
659 renames To_Unsigned_Longword_A;
661 function To_Unsigned_Longword_A is new
662 Ada.Unchecked_Conversion (AST_Handler, Unsigned_Longword);
664 function To_Unsigned_Longword (X : AST_Handler) return Unsigned_Longword
665 renames To_Unsigned_Longword_A;
667 pragma Warnings (On);