]>
Commit | Line | Data |
---|---|---|
70482933 RK |
1 | ------------------------------------------------------------------------------ |
2 | -- -- | |
3 | -- GNAT COMPILER COMPONENTS -- | |
4 | -- -- | |
5 | -- F R E E Z E -- | |
6 | -- -- | |
7 | -- S p e c -- | |
8 | -- -- | |
1d005acc | 9 | -- Copyright (C) 1992-2019, Free Software Foundation, Inc. -- |
70482933 RK |
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- -- | |
748086b7 | 13 | -- ware Foundation; either version 3, or (at your option) any later ver- -- |
70482933 RK |
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 -- | |
2010d078 AC |
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. -- | |
70482933 RK |
20 | -- -- |
21 | -- GNAT was originally developed by the GNAT team at New York University. -- | |
71ff80dc | 22 | -- Extensive contributions were provided by Ada Core Technologies Inc. -- |
70482933 RK |
23 | -- -- |
24 | ------------------------------------------------------------------------------ | |
25 | ||
26 | with Types; use Types; | |
27 | ||
28 | package Freeze is | |
29 | ||
30 | -------------------------- | |
31 | -- Handling of Freezing -- | |
32 | -------------------------- | |
33 | ||
34 | -- In the formal Ada semantics, freezing of entities occurs at a well | |
35 | -- defined point, described in (RM 13.14). The model in GNAT of freezing | |
36 | -- is that a Freeze_Entity node is generated at the point where an entity | |
37 | -- is frozen, and the entity contains a pointer (Freeze_Node) to this | |
38 | -- generated freeze node. | |
39 | ||
40 | -- The freeze node is processed in the expander to generate associated | |
41 | -- data and subprograms (e.g. an initialization procedure) which must | |
42 | -- be delayed until the type is frozen and its representation can be | |
43 | -- fully determined. Subsequently the freeze node is used by Gigi to | |
44 | -- determine the point at which it should elaborate the corresponding | |
45 | -- entity (this elaboration also requires the representation of the | |
46 | -- entity to be fully determinable). The freeze node is also used to | |
47 | -- provide additional diagnostic information (pinpointing the freeze | |
48 | -- point), when order of freezing errors are detected. | |
49 | ||
50 | -- If we were fully faithful to the Ada model, we would generate freeze | |
51 | -- nodes for all entities, but that is a bit heavy so we optimize (that | |
52 | -- is the nice word) or cut corners (which is a bit more honest). For | |
53 | -- many entities, we do not need to delay the freeze and instead can | |
54 | -- freeze them at the point of declaration. The conditions for this | |
55 | -- early freezing being permissible are as follows: | |
56 | ||
57 | -- There is no associated expander activity that needs to be delayed | |
58 | ||
59 | -- Gigi can fully elaborate the entity at the point of occurrence (or, | |
60 | -- equivalently, no real elaboration is required for the entity). | |
61 | ||
62 | -- In order for these conditions to be met (especially the second), it | |
63 | -- must be the case that all representation characteristics of the entity | |
64 | -- can be determined at declaration time. | |
65 | ||
66 | -- The following indicates how freezing is handled for all entity kinds: | |
67 | ||
68 | -- Types | |
69 | ||
70 | -- All declared types have freeze nodes, as well as anonymous base | |
71 | -- types created for type declarations where the defining identifier | |
72 | -- is a first subtype of the anonymous type. | |
73 | ||
74 | -- Subtypes | |
75 | ||
76 | -- All first subtypes have freeze nodes. Other subtypes need freeze | |
77 | -- nodes if the corresponding base type has not yet been frozen. If | |
78 | -- the base type has been frozen, then there is no need for a freeze | |
79 | -- node, since no rep clauses can appear for the subtype in any case. | |
80 | ||
81 | -- Implicit types and subtypes | |
82 | ||
83 | -- As noted above, implicit base types always have freeze nodes. Other | |
84 | -- implicit types and subtypes typically do not require freeze nodes, | |
85 | -- because there is no possibility of delaying any information about | |
86 | -- their representation. | |
87 | ||
88 | -- Subprograms | |
89 | -- | |
90 | -- Are frozen at the point of declaration unless one or more of the | |
91 | -- formal types or return type themselves have delayed freezing and | |
92 | -- are not yet frozen. This includes the case of a formal access type | |
93 | -- where the designated type is not frozen. Note that we are talking | |
94 | -- about subprogram specs here (subprogram body entities have no | |
95 | -- relevance), and in any case, subprogram bodies freeze everything. | |
96 | ||
97 | -- Objects with dynamic address clauses | |
98 | -- | |
99 | -- These have a delayed freeze. Gigi will generate code to evaluate | |
100 | -- the initialization expression if present and store it in a temp. | |
101 | -- The actual object is created at the point of the freeze, and if | |
638e383e | 102 | -- necessary initialized by copying the value of this temporary. |
70482933 RK |
103 | |
104 | -- Formal Parameters | |
105 | -- | |
106 | -- Are frozen when the associated subprogram is frozen, so there is | |
107 | -- never any need for them to have delayed freezing. | |
108 | ||
109 | -- Other Objects | |
110 | -- | |
111 | -- Are always frozen at the point of declaration | |
112 | ||
113 | -- All Other Entities | |
114 | ||
115 | -- Are always frozen at the point of declaration | |
116 | ||
b3db0949 BD |
117 | -- The flag Has_Delayed_Freeze is used to indicate that delayed freezing |
118 | -- is required. Usually the associated freeze node is allocated at the | |
119 | -- freezing point. One special exception occurs with anonymous base types, | |
120 | -- where the freeze node is preallocated at the point of declaration, so | |
121 | -- that the First_Subtype_Link field can be set. | |
70482933 | 122 | |
86cde7b1 RD |
123 | Freezing_Library_Level_Tagged_Type : Boolean := False; |
124 | -- Flag used to indicate that we are freezing the primitives of a library | |
b3db0949 | 125 | -- level tagged type. Used to disable checks on premature freezing. |
86cde7b1 RD |
126 | -- More documentation needed??? why is this flag needed? what are these |
127 | -- checks? why do they need disabling in some cases? | |
128 | ||
70482933 RK |
129 | ----------------- |
130 | -- Subprograms -- | |
131 | ----------------- | |
132 | ||
133 | function Build_Renamed_Body | |
134 | (Decl : Node_Id; | |
fbf5a39b | 135 | New_S : Entity_Id) return Node_Id; |
70482933 RK |
136 | -- Rewrite renaming declaration as a subprogram body, whose single |
137 | -- statement is a call to the renamed entity. New_S is the entity that | |
138 | -- appears in the renaming declaration. If this is a Renaming_As_Body, | |
139 | -- then Decl is the original subprogram declaration that is completed | |
140 | -- by the renaming, otherwise it is the renaming declaration itself. | |
141 | -- The caller inserts the body where required. If this call comes | |
142 | -- from a freezing action, the resulting body is analyzed at once. | |
143 | ||
144 | procedure Check_Compile_Time_Size (T : Entity_Id); | |
145 | -- Check to see whether the size of the type T is known at compile time. | |
146 | -- There are three possible cases: | |
147 | -- | |
148 | -- Size is not known at compile time. In this case, the call has no | |
149 | -- effect. Note that the processing is conservative here, in the sense | |
150 | -- that this routine may decide that the size is not known even if in | |
151 | -- fact Gigi decides it is known, but the opposite situation can never | |
152 | -- occur. | |
153 | -- | |
34da9c98 EB |
154 | -- Size is known at compile time, but the actual value of the size is not |
155 | -- known to the front end or is definitely greater than 64. In this case, | |
156 | -- Size_Known_At_Compile_Time is set, but the RM_Size field is left set | |
70482933 RK |
157 | -- to zero (to be set by Gigi). |
158 | -- | |
159 | -- Size is known at compile time, and the actual value of the size is | |
34da9c98 EB |
160 | -- known to the front end and is not greater than 64. In this case, the |
161 | -- flag Size_Known_At_Compile_Time is set, and in addition RM_Size is set | |
162 | -- to the required size, allowing for possible front end packing of an | |
70482933 RK |
163 | -- array using this type as a component type. |
164 | -- | |
165 | -- Note: the flag Size_Known_At_Compile_Time is used to determine if the | |
166 | -- secondary stack must be used to return a value of the type, and also | |
167 | -- to determine whether a component clause is allowed for a component | |
168 | -- of the given type. | |
169 | -- | |
170 | -- Note: this is public because of one dubious use in Sem_Res??? | |
171 | -- | |
172 | -- Note: Check_Compile_Time_Size does not test the case of the size being | |
173 | -- known because a size clause is specifically given. That is because we | |
174 | -- do not allow a size clause if the size would not otherwise be known at | |
175 | -- compile time in any case. | |
176 | ||
0c6826a5 | 177 | function Is_Atomic_VFA_Aggregate (N : Node_Id) return Boolean; |
f280dd8f RD |
178 | -- If an atomic/VFA object is initialized with an aggregate or is assigned |
179 | -- an aggregate, we have to prevent a piecemeal access or assignment to the | |
c159409f AC |
180 | -- object, even if the aggregate is to be expanded. We create a temporary |
181 | -- for the aggregate, and assign the temporary instead, so that the back | |
182 | -- end can generate an atomic move for it. This is only done in the context | |
183 | -- of an object declaration or an assignment. Function is a noop and | |
184 | -- returns false in other contexts. | |
185 | ||
2ffcbaa5 AC |
186 | procedure Explode_Initialization_Compound_Statement (E : Entity_Id); |
187 | -- If Initialization_Statements (E) is an N_Compound_Statement, insert its | |
188 | -- actions in the enclosing list and reset the attribute. | |
189 | ||
6dc87f5f | 190 | function Freeze_Entity |
b1d8d229 AC |
191 | (E : Entity_Id; |
192 | N : Node_Id; | |
193 | Do_Freeze_Profile : Boolean := True) return List_Id; | |
c159409f AC |
194 | -- Freeze an entity, and return Freeze nodes, to be inserted at the point |
195 | -- of call. N is a node whose source location corresponds to the freeze | |
196 | -- point. This is used in placing warning messages in the situation where | |
197 | -- it appears that a type has been frozen too early, e.g. when a primitive | |
198 | -- operation is declared after the freezing point of its tagged type. | |
b1d8d229 AC |
199 | -- Returns No_List if no freeze nodes needed. Parameter Do_Freeze_Profile |
200 | -- is used when E is a subprogram, and determines whether the profile of | |
201 | -- the subprogram should be frozen as well. | |
70482933 RK |
202 | |
203 | procedure Freeze_All (From : Entity_Id; After : in out Node_Id); | |
3e65bfab | 204 | -- Before a non-instance body, or at the end of a declarative part, |
70482933 RK |
205 | -- freeze all entities therein that are not yet frozen. Calls itself |
206 | -- recursively to catch types in inner packages that were not frozen | |
207 | -- at the inner level because they were not yet completely defined. | |
208 | -- This routine also analyzes and freezes default parameter expressions | |
209 | -- in subprogram specifications (this has to be delayed until all the | |
210 | -- types are frozen). The resulting freeze nodes are inserted just | |
211 | -- after node After (which is a list node) and analyzed. On return, | |
212 | -- 'After' is updated to point to the last node inserted (or is returned | |
213 | -- unchanged if no nodes were inserted). 'From' is the last entity frozen | |
214 | -- in the scope. It is used to prevent a quadratic traversal over already | |
215 | -- frozen entities. | |
216 | ||
6dc87f5f | 217 | procedure Freeze_Before |
b1d8d229 AC |
218 | (N : Node_Id; |
219 | T : Entity_Id; | |
220 | Do_Freeze_Profile : Boolean := True); | |
221 | -- Freeze T then Insert the generated Freeze nodes before the node N. Flag | |
222 | -- Do_Freeze_Profile is used when T is an overloadable entity and indicates | |
6dc87f5f | 223 | -- whether its profile should be frozen at the same time. |
70482933 RK |
224 | |
225 | procedure Freeze_Expression (N : Node_Id); | |
226 | -- Freezes the required entities when the Expression N causes freezing. | |
227 | -- The node N here is either a subexpression node (a "real" expression) | |
228 | -- or a subtype mark, or a subtype indication. The latter two cases are | |
229 | -- not really expressions, but they can appear within expressions and | |
230 | -- so need to be similarly treated. Freeze_Expression takes care of | |
231 | -- determining the proper insertion point for generated freeze actions. | |
232 | ||
0db1c386 ES |
233 | procedure Freeze_Expr_Types |
234 | (Def_Id : Entity_Id; | |
235 | Typ : Entity_Id; | |
236 | Expr : Node_Id; | |
237 | N : Node_Id); | |
238 | -- N is the body constructed for an expression function that is a | |
239 | -- completion, and Def_Id is the function being completed. | |
240 | -- This procedure freezes before N all the types referenced in Expr, | |
241 | -- which is either the expression of the expression function, or | |
242 | -- the expression in a pre/post aspect that applies to Def_Id; | |
243 | ||
de76a39c GB |
244 | procedure Freeze_Fixed_Point_Type (Typ : Entity_Id); |
245 | -- Freeze fixed point type. For fixed-point types, we have to defer | |
246 | -- setting the size and bounds till the freeze point, since they are | |
247 | -- potentially affected by the presence of size and small clauses. | |
248 | ||
70482933 RK |
249 | procedure Freeze_Itype (T : Entity_Id; N : Node_Id); |
250 | -- This routine is called when an Itype is created and must be frozen | |
251 | -- immediately at the point of creation (for the sake of the expansion | |
252 | -- activities in Exp_Ch3 (for example, the creation of packed array | |
253 | -- types). We can't just let Freeze_Expression do this job since it | |
254 | -- goes out of its way to make sure that the freeze node occurs at a | |
255 | -- point outside the current construct, e.g. outside the expression or | |
256 | -- outside the initialization procedure. That's normally right, but | |
257 | -- not in this case, since if we create an Itype in an expression it | |
258 | -- may be the case that it is not always elaborated (for example it | |
259 | -- may result from the right operand of a short circuit). In this case | |
260 | -- we want the freeze node to be inserted at the same point as the Itype. | |
261 | -- The node N provides both the location for the freezing and also the | |
262 | -- insertion point for the resulting freeze nodes. | |
263 | ||
264 | end Freeze; |