1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 1992-2020, 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. 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 COPYING3. If not, go to --
19 -- http://www.gnu.org/licenses for a complete copy of the license. --
21 -- GNAT was originally developed by the GNAT team at New York University. --
22 -- Extensive contributions were provided by Ada Core Technologies Inc. --
24 ------------------------------------------------------------------------------
26 -- This package contains constants describing target properties
28 with Types
; use Types
;
33 ------------------------------
34 -- Host/Target Dependencies --
35 ------------------------------
37 -- It is vital to maintain a clear distinction between properties of
38 -- types on the host and types on the target, since in the general
39 -- case of a cross-compiler these will be different.
41 -- This package provides definitions of values that describe the properties
42 -- of the target types. All instances of target dependencies, including the
43 -- definitions of such packages as Standard and System depend directly or
44 -- indirectly on the definitions in the Ttypes packages.
46 -- In the source of the compiler, references to attributes such as
47 -- Integer'Size will give information regarding the host types (i.e.
48 -- the types within the compiler itself). Such references are therefore
49 -- almost always suspicious (it is hard for example to see that the
50 -- code in the compiler should even be using type Integer very much,
51 -- and certainly this code should not depend on the size of Integer).
53 -- On the other hand, it is perfectly reasonable for the compiler to
54 -- require access to the size of type Integer for the target machine,
55 -- e.g. in constructing the internal representation of package Standard.
56 -- For this purpose, instead of referencing the attribute Integer'Size,
57 -- a reference to Ttypes.Standard_Integer_Size will provide the needed
58 -- value for the target type.
60 -- Two approaches are used for handling target dependent values in the
61 -- standard library packages. Package Standard is handled specially,
62 -- being constructed internally (by package Stand). Target dependent
63 -- values needed in Stand are obtained by direct reference to Ttypes
66 -- For package System, there is a separate version for each target, with
67 -- explicit declarations of the required, constants.
69 -- Historical note: Originally we had in mind dealing with target dependent
70 -- differences by referencing appropriate attributes. Ada 95 already
71 -- defines most of the required attributes, and GNAT specific attributes
72 -- were defined to cover the remaining cases (such as Storage_Unit).
73 -- The additional attributes that have been added to GNAT (Address_Size,
74 -- Storage_Unit, and Word_Size) are redundant with respect to the
75 -- corresponding references to System constants. For example in a program,
76 -- System.Address_Size and Standard'Address_Size yield the same value.
77 -- These attributes have been retained for compatibility purposes, but
78 -- serve no purpose at this stage.
80 -- Note that during compilation there are two versions of package System
81 -- around. The version that is directly with'ed by compiler packages
82 -- contains host-dependent definitions, which is what is needed in that
83 -- case (for example, System.Storage_Unit referenced in the source of the
84 -- compiler refers to the storage unit of the host, not the target). This
85 -- means that, like attribute references, any references to constants in
86 -- package System in the compiler code are suspicious, since it is strange
87 -- for the compiler to have such host dependencies. If the compiler needs
88 -- to access the target dependent values of such quantities as Storage_Unit
89 -- then it should reference the constants in this package (Ttypes), rather
90 -- than referencing System.Storage_Unit, or Standard'Storage_Unit, both of
91 -- which would yield the host value.
93 ---------------------------------------------------
94 -- Target-Dependent Values for Types in Standard --
95 ---------------------------------------------------
97 -- Note: GNAT always supplies all the following integer and float types,
98 -- but depending on the machine, some of the types may be identical. For
99 -- example, on some machines, Short_Float may be the same as Float, and
100 -- Long_Long_Float may be the same as Long_Float.
102 Standard_Short_Short_Integer_Size
: constant Pos
:=
105 Standard_Short_Integer_Size
: constant Pos
:=
108 Standard_Integer_Size
: constant Pos
:=
111 Standard_Long_Integer_Size
: constant Pos
:=
114 Standard_Long_Long_Integer_Size
: constant Pos
:=
115 Set_Targ
.Long_Long_Size
;
117 Standard_Long_Long_Long_Integer_Size
: Pos
:=
118 Set_Targ
.Long_Long_Long_Size
;
120 Standard_Short_Float_Size
: constant Pos
:=
123 Standard_Float_Size
: constant Pos
:=
126 Standard_Long_Float_Size
: constant Pos
:=
127 Set_Targ
.Double_Size
;
129 Standard_Long_Long_Float_Size
: constant Pos
:=
130 Set_Targ
.Long_Double_Size
;
132 Standard_Character_Size
: constant Pos
:= Set_Targ
.Char_Size
;
134 Standard_Wide_Character_Size
: constant Pos
:= 16;
135 Standard_Wide_Wide_Character_Size
: constant Pos
:= 32;
136 -- Standard wide character sizes
138 -- Note: there is no specific control over the representation of
139 -- enumeration types. The convention used is that if an enumeration
140 -- type has fewer than 2**(Character'Size) elements, then the size
141 -- used is Character'Size, otherwise Integer'Size is used.
143 -- Similarly, the size of fixed-point types depends on the size of the
144 -- corresponding integer type, which is the smallest predefined integer
145 -- type capable of representing the required range of values.
147 -------------------------------------------------
148 -- Target-Dependent Values for Types in System --
149 -------------------------------------------------
151 System_Address_Size
: constant Pos
:= Set_Targ
.Pointer_Size
;
152 -- System.Address'Size (also size of all thin pointers)
154 System_Max_Integer_Size
: Pos
:= Standard_Long_Long_Long_Integer_Size
;
156 System_Max_Binary_Modulus_Power
: Pos
:=
157 Standard_Long_Long_Long_Integer_Size
;
159 System_Max_Nonbinary_Modulus_Power
: constant Pos
:= Standard_Integer_Size
;
161 System_Storage_Unit
: constant Pos
:= Set_Targ
.Bits_Per_Unit
;
162 System_Word_Size
: constant Pos
:= Set_Targ
.Bits_Per_Word
;
164 System_Tick_Nanoseconds
: constant Pos
:= 1_000_000_000
;
165 -- Value of System.Tick in nanoseconds. At the moment, this is a fixed
166 -- constant (with value of 1.0 seconds), but later we should add this
167 -- value to the GCC configuration file so that its value can be made
168 -- configuration dependent.
170 -----------------------------------------------------
171 -- Target-Dependent Values for Types in Interfaces --
172 -----------------------------------------------------
174 Interfaces_Wchar_T_Size
: constant Pos
:= Set_Targ
.Wchar_T_Size
;
176 ----------------------------------------
177 -- Other Target-Dependent Definitions --
178 ----------------------------------------
180 Maximum_Alignment
: constant Pos
:= Set_Targ
.Maximum_Alignment
;
181 -- The maximum alignment, in storage units, that an object or type may
182 -- require on the target machine.
184 System_Allocator_Alignment
: constant Pos
:=
185 Set_Targ
.System_Allocator_Alignment
;
186 -- The alignment in storage units of addresses returned by malloc
188 Max_Unaligned_Field
: constant Pos
:= Set_Targ
.Max_Unaligned_Field
;
189 -- The maximum supported size in bits for a field that is not aligned
190 -- on a storage unit boundary.
192 Bytes_Big_Endian
: Boolean := Set_Targ
.Bytes_BE
/= 0;
193 -- Important note: for Ada purposes, the important setting is the bytes
194 -- endianness (Bytes_Big_Endian), not the bits value (Bits_Big_Endian).
195 -- This is because Ada bit addressing must be compatible with the byte
196 -- ordering (otherwise we would end up with non-contiguous fields). It
197 -- is rare for the two to be different, but if they are, Bits_Big_Endian
198 -- is relevant only for the generation of instructions with bit numbers,
199 -- and thus relevant only to the back end. Note that this is a variable
200 -- rather than a constant, since it can be modified (flipped) by -gnatd8.
202 Target_Short_Enums
: constant Boolean := Set_Targ
.Short_Enums
/= 0;
203 -- True if we are in short enums mode, where foreign convention
204 -- (in particular C and C++) enumeration types will be sized as in Ada,
205 -- using the shortest possibility from 8,16,32 bits, signed or unsigned.
206 -- A zero value means Short_Enums are not in use, and in this case all
207 -- foreign convention enumeration types are given the same size as c int.
209 Target_Strict_Alignment
: Boolean :=
210 Set_Targ
.Strict_Alignment
/= 0;
211 -- True if instructions will fail if data is misaligned. Note that this
212 -- is a variable rather than a constant since it can be modified (set to
213 -- True) if the debug flag -gnatd.A is used.
215 Target_Double_Float_Alignment
: constant Nat
:=
216 Set_Targ
.Double_Float_Alignment
;
217 -- The default alignment of "double" floating-point types, i.e. floating
218 -- point types whose size is equal to 64 bits, or 0 if this alignment is
219 -- not lower than the largest power of 2 multiple of System.Storage_Unit
220 -- that does not exceed either the object size of the type or the maximum
221 -- allowed alignment.
223 Target_Double_Scalar_Alignment
: constant Nat
:=
224 Set_Targ
.Double_Scalar_Alignment
;
225 -- The default alignment of "double" or larger scalar types, i.e. scalar
226 -- types whose size is greater or equal to 64 bits, or 0 if this alignment
227 -- is not lower than the largest power of 2 multiple of System.Storage_Unit
228 -- that does not exceed either the object size of the type or the maximum
229 -- allowed alignment.