Mercurial > hg > CbC > CbC_gcc
comparison gcc/ada/libgnat/s-unstyp.ads @ 111:04ced10e8804
gcc 7
author | kono |
---|---|
date | Fri, 27 Oct 2017 22:46:09 +0900 |
parents | |
children | 84e7813d76e9 |
comparison
equal
deleted
inserted
replaced
68:561a7518be6b | 111:04ced10e8804 |
---|---|
1 ------------------------------------------------------------------------------ | |
2 -- -- | |
3 -- GNAT RUN-TIME COMPONENTS -- | |
4 -- -- | |
5 -- S Y S T E M . U N S I G N E D _ T Y P E S -- | |
6 -- -- | |
7 -- S p e c -- | |
8 -- -- | |
9 -- Copyright (C) 1992-2017, 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 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. -- | |
17 -- -- | |
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. -- | |
21 -- -- | |
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/>. -- | |
26 -- -- | |
27 -- GNAT was originally developed by the GNAT team at New York University. -- | |
28 -- Extensive contributions were provided by Ada Core Technologies Inc. -- | |
29 -- -- | |
30 ------------------------------------------------------------------------------ | |
31 | |
32 -- This package contains definitions of standard unsigned types that | |
33 -- correspond in size to the standard signed types declared in Standard, | |
34 -- and (unlike the types in Interfaces) have corresponding names. It | |
35 -- also contains some related definitions for other specialized types | |
36 -- used by the compiler in connection with packed array types. | |
37 | |
38 pragma Compiler_Unit_Warning; | |
39 | |
40 package System.Unsigned_Types is | |
41 pragma Pure; | |
42 pragma No_Elaboration_Code_All; | |
43 | |
44 type Short_Short_Unsigned is mod 2 ** Short_Short_Integer'Size; | |
45 type Short_Unsigned is mod 2 ** Short_Integer'Size; | |
46 type Unsigned is mod 2 ** Integer'Size; | |
47 type Long_Unsigned is mod 2 ** Long_Integer'Size; | |
48 type Long_Long_Unsigned is mod 2 ** Long_Long_Integer'Size; | |
49 | |
50 type Float_Unsigned is mod 2 ** Float'Size; | |
51 -- Used in the implementation of Is_Negative intrinsic (see Exp_Intr) | |
52 | |
53 type Packed_Byte is mod 2 ** 8; | |
54 pragma Universal_Aliasing (Packed_Byte); | |
55 for Packed_Byte'Size use 8; | |
56 -- Component type for Packed_Bytes1, Packed_Bytes2 and Packed_Byte4 arrays. | |
57 -- As this type is used by the compiler to implement operations on user | |
58 -- packed array, it needs to be able to alias any type. | |
59 | |
60 type Packed_Bytes1 is array (Natural range <>) of aliased Packed_Byte; | |
61 for Packed_Bytes1'Alignment use 1; | |
62 for Packed_Bytes1'Component_Size use Packed_Byte'Size; | |
63 pragma Suppress_Initialization (Packed_Bytes1); | |
64 -- This is the type used to implement packed arrays where no alignment | |
65 -- is required. This includes the cases of 1,2,4 (where we use direct | |
66 -- masking operations), and all odd component sizes (where the clusters | |
67 -- are not aligned anyway, see, e.g. System.Pack_07 in file s-pack07 | |
68 -- for details. | |
69 | |
70 type Packed_Bytes2 is new Packed_Bytes1; | |
71 for Packed_Bytes2'Alignment use Integer'Min (2, Standard'Maximum_Alignment); | |
72 pragma Suppress_Initialization (Packed_Bytes2); | |
73 -- This is the type used to implement packed arrays where an alignment | |
74 -- of 2 (is possible) is helpful for maximum efficiency of the get and | |
75 -- set routines in the corresponding library unit. This is true of all | |
76 -- component sizes that are even but not divisible by 4 (other than 2 for | |
77 -- which we use direct masking operations). In such cases, the clusters | |
78 -- can be assumed to be 2-byte aligned if the array is aligned. See for | |
79 -- example System.Pack_10 in file s-pack10). | |
80 | |
81 type Packed_Bytes4 is new Packed_Bytes1; | |
82 for Packed_Bytes4'Alignment use Integer'Min (4, Standard'Maximum_Alignment); | |
83 pragma Suppress_Initialization (Packed_Bytes4); | |
84 -- This is the type used to implement packed arrays where an alignment | |
85 -- of 4 (if possible) is helpful for maximum efficiency of the get and | |
86 -- set routines in the corresponding library unit. This is true of all | |
87 -- component sizes that are divisible by 4 (other than powers of 2, which | |
88 -- are either handled by direct masking or not packed at all). In such | |
89 -- cases the clusters can be assumed to be 4-byte aligned if the array | |
90 -- is aligned (see System.Pack_12 in file s-pack12 as an example). | |
91 | |
92 type Bits_1 is mod 2**1; | |
93 type Bits_2 is mod 2**2; | |
94 type Bits_4 is mod 2**4; | |
95 -- Types used for packed array conversions | |
96 | |
97 subtype Bytes_F is Packed_Bytes4 (1 .. Float'Size / 8); | |
98 -- Type used in implementation of Is_Negative intrinsic (see Exp_Intr) | |
99 | |
100 function Shift_Left | |
101 (Value : Short_Short_Unsigned; | |
102 Amount : Natural) return Short_Short_Unsigned; | |
103 | |
104 function Shift_Right | |
105 (Value : Short_Short_Unsigned; | |
106 Amount : Natural) return Short_Short_Unsigned; | |
107 | |
108 function Shift_Right_Arithmetic | |
109 (Value : Short_Short_Unsigned; | |
110 Amount : Natural) return Short_Short_Unsigned; | |
111 | |
112 function Rotate_Left | |
113 (Value : Short_Short_Unsigned; | |
114 Amount : Natural) return Short_Short_Unsigned; | |
115 | |
116 function Rotate_Right | |
117 (Value : Short_Short_Unsigned; | |
118 Amount : Natural) return Short_Short_Unsigned; | |
119 | |
120 function Shift_Left | |
121 (Value : Short_Unsigned; | |
122 Amount : Natural) return Short_Unsigned; | |
123 | |
124 function Shift_Right | |
125 (Value : Short_Unsigned; | |
126 Amount : Natural) return Short_Unsigned; | |
127 | |
128 function Shift_Right_Arithmetic | |
129 (Value : Short_Unsigned; | |
130 Amount : Natural) return Short_Unsigned; | |
131 | |
132 function Rotate_Left | |
133 (Value : Short_Unsigned; | |
134 Amount : Natural) return Short_Unsigned; | |
135 | |
136 function Rotate_Right | |
137 (Value : Short_Unsigned; | |
138 Amount : Natural) return Short_Unsigned; | |
139 | |
140 function Shift_Left | |
141 (Value : Unsigned; | |
142 Amount : Natural) return Unsigned; | |
143 | |
144 function Shift_Right | |
145 (Value : Unsigned; | |
146 Amount : Natural) return Unsigned; | |
147 | |
148 function Shift_Right_Arithmetic | |
149 (Value : Unsigned; | |
150 Amount : Natural) return Unsigned; | |
151 | |
152 function Rotate_Left | |
153 (Value : Unsigned; | |
154 Amount : Natural) return Unsigned; | |
155 | |
156 function Rotate_Right | |
157 (Value : Unsigned; | |
158 Amount : Natural) return Unsigned; | |
159 | |
160 function Shift_Left | |
161 (Value : Long_Unsigned; | |
162 Amount : Natural) return Long_Unsigned; | |
163 | |
164 function Shift_Right | |
165 (Value : Long_Unsigned; | |
166 Amount : Natural) return Long_Unsigned; | |
167 | |
168 function Shift_Right_Arithmetic | |
169 (Value : Long_Unsigned; | |
170 Amount : Natural) return Long_Unsigned; | |
171 | |
172 function Rotate_Left | |
173 (Value : Long_Unsigned; | |
174 Amount : Natural) return Long_Unsigned; | |
175 | |
176 function Rotate_Right | |
177 (Value : Long_Unsigned; | |
178 Amount : Natural) return Long_Unsigned; | |
179 | |
180 function Shift_Left | |
181 (Value : Long_Long_Unsigned; | |
182 Amount : Natural) return Long_Long_Unsigned; | |
183 | |
184 function Shift_Right | |
185 (Value : Long_Long_Unsigned; | |
186 Amount : Natural) return Long_Long_Unsigned; | |
187 | |
188 function Shift_Right_Arithmetic | |
189 (Value : Long_Long_Unsigned; | |
190 Amount : Natural) return Long_Long_Unsigned; | |
191 | |
192 function Rotate_Left | |
193 (Value : Long_Long_Unsigned; | |
194 Amount : Natural) return Long_Long_Unsigned; | |
195 | |
196 function Rotate_Right | |
197 (Value : Long_Long_Unsigned; | |
198 Amount : Natural) return Long_Long_Unsigned; | |
199 | |
200 pragma Import (Intrinsic, Shift_Left); | |
201 pragma Import (Intrinsic, Shift_Right); | |
202 pragma Import (Intrinsic, Shift_Right_Arithmetic); | |
203 pragma Import (Intrinsic, Rotate_Left); | |
204 pragma Import (Intrinsic, Rotate_Right); | |
205 | |
206 -- The following definitions are obsolescent. They were needed by the | |
207 -- previous version of the compiler and runtime, but are not needed | |
208 -- by the current version. We retain them to help with bootstrap path | |
209 -- problems. Also they seem harmless, and if any user programs have | |
210 -- been using these types, why discombobulate them? | |
211 | |
212 subtype Packed_Bytes is Packed_Bytes4; | |
213 subtype Packed_Bytes_Unaligned is Packed_Bytes1; | |
214 | |
215 end System.Unsigned_Types; |