|
111
|
1 ------------------------------------------------------------------------------
|
|
|
2 -- --
|
|
|
3 -- GNAT COMPILER COMPONENTS --
|
|
|
4 -- --
|
|
|
5 -- S E M _ E V A L --
|
|
|
6 -- --
|
|
|
7 -- S p e c --
|
|
|
8 -- --
|
|
145
|
9 -- Copyright (C) 1992-2019, Free Software Foundation, Inc. --
|
|
111
|
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. 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. --
|
|
|
20 -- --
|
|
|
21 -- GNAT was originally developed by the GNAT team at New York University. --
|
|
|
22 -- Extensive contributions were provided by Ada Core Technologies Inc. --
|
|
|
23 -- --
|
|
|
24 ------------------------------------------------------------------------------
|
|
|
25
|
|
|
26 -- This package contains various subprograms involved in compile time
|
|
|
27 -- evaluation of expressions and checks for staticness of expressions and
|
|
|
28 -- types. It also contains the circuitry for checking for violations of pure
|
|
|
29 -- and preelaborated conditions (this naturally goes here, since these rules
|
|
|
30 -- involve consideration of staticness).
|
|
|
31
|
|
|
32 -- Note: the static evaluation for attributes is found in Sem_Attr even though
|
|
|
33 -- logically it belongs here. We have done this so that it is easier to add
|
|
|
34 -- new attributes to GNAT.
|
|
|
35
|
|
|
36 with Types; use Types;
|
|
|
37 with Uintp; use Uintp;
|
|
|
38 with Urealp; use Urealp;
|
|
|
39
|
|
|
40 package Sem_Eval is
|
|
|
41
|
|
|
42 ------------------------------------
|
|
|
43 -- Handling of Static Expressions --
|
|
|
44 ------------------------------------
|
|
|
45
|
|
|
46 -- This package contains a set of routines that process individual
|
|
|
47 -- subexpression nodes with the objective of folding (precomputing) the
|
|
|
48 -- value of static expressions that are known at compile time and properly
|
|
|
49 -- computing the setting of two flags that appear in every subexpression
|
|
|
50 -- node:
|
|
|
51
|
|
|
52 -- Is_Static_Expression
|
|
|
53
|
|
145
|
54 -- True for static expressions, as defined in RM-4.9.
|
|
111
|
55
|
|
|
56 -- Raises_Constraint_Error
|
|
|
57
|
|
|
58 -- This flag indicates that it is known at compile time that the
|
|
|
59 -- evaluation of an expression raises constraint error. If the
|
|
|
60 -- expression is static, and this flag is off, then it is also known at
|
|
|
61 -- compile time that the expression does not raise constraint error
|
|
|
62 -- (i.e. the flag is accurate for static expressions, and conservative
|
|
|
63 -- for non-static expressions.
|
|
|
64
|
|
145
|
65 -- See also Is_OK_Static_Expression, which is True for static
|
|
|
66 -- expressions that do not raise Constraint_Error. This is used in most
|
|
|
67 -- legality checks, because static expressions that raise Constraint_Error
|
|
|
68 -- are usually illegal.
|
|
111
|
69
|
|
145
|
70 -- See also Compile_Time_Known_Value, which is True for an expression whose
|
|
|
71 -- value is known at compile time. In this case, the expression is folded
|
|
|
72 -- to a literal or to a constant that is itself (recursively) either a
|
|
|
73 -- literal or a constant
|
|
|
74
|
|
|
75 -- Is_[OK_]Static_Expression are used for legality checks, whereas
|
|
|
76 -- Compile_Time_Known_Value is used for optimization purposes.
|
|
111
|
77
|
|
|
78 -- When we are analyzing and evaluating static expressions, we propagate
|
|
145
|
79 -- both flags. Usually if a subexpression raises a Constraint_Error, then
|
|
|
80 -- so will its parent expression, and Raise_Constraint_Error will be
|
|
|
81 -- propagated to this parent. The exception is conditional cases like
|
|
|
82 -- (True or else 1/0 = 0), which results in an expression that has the
|
|
111
|
83 -- Is_Static_Expression flag True, and Raises_Constraint_Error False. Even
|
|
|
84 -- though 1/0 would raise an exception, the right operand is never actually
|
|
|
85 -- executed, so the expression as a whole does not raise CE.
|
|
|
86
|
|
|
87 -- Finally, the case of static predicates. These are applied only to entire
|
|
|
88 -- expressions, not to subexpressions, so we do not have the case of having
|
|
|
89 -- to propagate this information. We handle this case simply by resetting
|
|
|
90 -- the Is_Static_Expression flag if a static predicate fails. Note that we
|
|
|
91 -- can't use this simpler approach for the constraint error case because of
|
|
|
92 -- the (True or else 1/0 = 0) example discussed above.
|
|
|
93
|
|
|
94 -------------------------------
|
|
|
95 -- Compile-Time Known Values --
|
|
|
96 -------------------------------
|
|
|
97
|
|
|
98 -- For most legality checking purposes the flag Is_Static_Expression
|
|
|
99 -- defined in Sinfo should be used. This package also provides a routine
|
|
|
100 -- called Is_OK_Static_Expression which in addition of checking that an
|
|
|
101 -- expression is static in the RM 4.9 sense, it checks that the expression
|
|
|
102 -- does not raise constraint error. In fact for certain legality checks not
|
|
|
103 -- only do we need to ascertain that the expression is static, but we must
|
|
|
104 -- also ensure that it does not raise constraint error.
|
|
|
105
|
|
|
106 -- Neither of Is_Static_Expression and Is_OK_Static_Expression should be
|
|
|
107 -- used for compile time evaluation purposes. In fact certain expression
|
|
|
108 -- whose value may be known at compile time are not static in the RM 4.9
|
|
|
109 -- sense. A typical example is:
|
|
|
110
|
|
|
111 -- C : constant Integer := Record_Type'Size;
|
|
|
112
|
|
|
113 -- The expression 'C' is not static in the technical RM sense, but for many
|
|
|
114 -- simple record types, the size is in fact known at compile time. When we
|
|
|
115 -- are trying to perform compile time constant folding (for instance for
|
|
|
116 -- expressions like C + 1, Is_Static_Expression or Is_OK_Static_Expression
|
|
|
117 -- are not the right functions to test if folding is possible. Instead, we
|
|
|
118 -- use Compile_Time_Known_Value. All static expressions that do not raise
|
|
|
119 -- constraint error (i.e. those for which Is_OK_Static_Expression is true)
|
|
|
120 -- are known at compile time, but as shown by the above example, there may
|
|
|
121 -- be cases of non-static expressions which are known at compile time.
|
|
|
122
|
|
|
123 -----------------
|
|
|
124 -- Subprograms --
|
|
|
125 -----------------
|
|
|
126
|
|
|
127 procedure Check_Expression_Against_Static_Predicate
|
|
|
128 (Expr : Node_Id;
|
|
|
129 Typ : Entity_Id);
|
|
|
130 -- Determine whether an arbitrary expression satisfies the static predicate
|
|
|
131 -- of a type. The routine does nothing if Expr is not known at compile time
|
|
|
132 -- or Typ lacks a static predicate, otherwise it may emit a warning if the
|
|
|
133 -- expression is prohibited by the predicate. If the expression is a static
|
|
|
134 -- expression and it fails a predicate that was not explicitly stated to be
|
|
|
135 -- a dynamic predicate, then an additional warning is given, and the flag
|
|
|
136 -- Is_Static_Expression is reset on Expr.
|
|
|
137
|
|
|
138 procedure Check_Non_Static_Context (N : Node_Id);
|
|
|
139 -- Deals with the special check required for a static expression that
|
|
|
140 -- appears in a non-static context, i.e. is not part of a larger static
|
|
|
141 -- expression (see RM 4.9(35)), i.e. the value of the expression must be
|
|
|
142 -- within the base range of the base type of its expected type. A check is
|
|
|
143 -- also made for expressions that are inside the base range, but outside
|
|
|
144 -- the range of the expected subtype (this is a warning message rather than
|
|
|
145 -- an illegality).
|
|
|
146 --
|
|
|
147 -- Note: most cases of non-static context checks are handled within
|
|
|
148 -- Sem_Eval itself, including all cases of expressions at the outer level
|
|
|
149 -- (i.e. those that are not a subexpression). Currently the only outside
|
|
|
150 -- customer for this procedure is Sem_Attr (because Eval_Attribute is
|
|
|
151 -- there). There is also one special case arising from ranges (see body of
|
|
|
152 -- Resolve_Range).
|
|
|
153 --
|
|
|
154 -- Note: this procedure is also called by GNATprove on real literals
|
|
|
155 -- that are not sub-expressions of static expressions, to convert them to
|
|
|
156 -- machine numbers, as GNATprove cannot perform this conversion contrary
|
|
|
157 -- to gigi.
|
|
|
158
|
|
|
159 procedure Check_String_Literal_Length (N : Node_Id; Ttype : Entity_Id);
|
|
|
160 -- N is either a string literal, or a constraint error node. In the latter
|
|
|
161 -- case, the situation is already dealt with, and the call has no effect.
|
|
|
162 -- In the former case, if the target type, Ttyp is constrained, then a
|
|
|
163 -- check is made to see if the string literal is of appropriate length.
|
|
|
164
|
|
|
165 type Compare_Result is (LT, LE, EQ, GT, GE, NE, Unknown);
|
|
|
166 subtype Compare_GE is Compare_Result range EQ .. GE;
|
|
|
167 subtype Compare_LE is Compare_Result range LT .. EQ;
|
|
|
168 -- Result subtypes for Compile_Time_Compare subprograms
|
|
|
169
|
|
|
170 function Compile_Time_Compare
|
|
|
171 (L, R : Node_Id;
|
|
|
172 Assume_Valid : Boolean) return Compare_Result;
|
|
|
173 pragma Inline (Compile_Time_Compare);
|
|
|
174 -- Given two expression nodes, finds out whether it can be determined at
|
|
|
175 -- compile time how the runtime values will compare. An Unknown result
|
|
|
176 -- means that the result of a comparison cannot be determined at compile
|
|
|
177 -- time, otherwise the returned result indicates the known result of the
|
|
|
178 -- comparison, given as tightly as possible (i.e. EQ or LT is preferred
|
|
|
179 -- returned value to LE). If Assume_Valid is true, the result reflects
|
|
|
180 -- the result of assuming that entities involved in the comparison have
|
|
|
181 -- valid representations. If Assume_Valid is false, then the base type of
|
|
|
182 -- any involved entity is used so that no assumption of validity is made.
|
|
|
183
|
|
|
184 function Compile_Time_Compare
|
|
|
185 (L, R : Node_Id;
|
|
|
186 Diff : access Uint;
|
|
|
187 Assume_Valid : Boolean;
|
|
|
188 Rec : Boolean := False) return Compare_Result;
|
|
|
189 -- This version of Compile_Time_Compare returns extra information if the
|
|
|
190 -- result is GT or LT. In these cases, if the magnitude of the difference
|
|
|
191 -- can be determined at compile time, this (positive) magnitude is returned
|
|
|
192 -- in Diff.all. If the magnitude of the difference cannot be determined
|
|
|
193 -- then Diff.all contains No_Uint on return. Rec is a parameter that is set
|
|
|
194 -- True for a recursive call from within Compile_Time_Compare to avoid some
|
|
|
195 -- infinite recursion cases. It should never be set by a client.
|
|
|
196
|
|
|
197 function Compile_Time_Known_Bounds (T : Entity_Id) return Boolean;
|
|
|
198 -- If T is an array whose index bounds are all known at compile time, then
|
|
|
199 -- True is returned. If T is not an array type, or one or more of its index
|
|
|
200 -- bounds is not known at compile time, then False is returned.
|
|
|
201
|
|
|
202 function Compile_Time_Known_Value (Op : Node_Id) return Boolean;
|
|
|
203 -- Returns true if Op is an expression not raising Constraint_Error whose
|
|
|
204 -- value is known at compile time and for which a call to Expr_Value can
|
|
|
205 -- be used to determine this value. This is always true if Op is a static
|
|
|
206 -- expression, but can also be true for expressions which are technically
|
|
|
207 -- non-static but which are in fact known at compile time. Some examples of
|
|
|
208 -- such expressions are the static lower bound of a non-static range or the
|
|
|
209 -- value of a constant object whose initial value is itself compile time
|
|
|
210 -- known in the sense of this routine. Note that this routine is defended
|
|
|
211 -- against unanalyzed expressions. Such expressions will not cause a
|
|
|
212 -- blowup, they may cause pessimistic (i.e. False) results to be returned.
|
|
|
213 -- In general we take a pessimistic view. False does not mean the value
|
|
|
214 -- could not be known at compile time, but True means that absolutely
|
|
|
215 -- definition it is known at compile time and it is safe to call
|
|
|
216 -- Expr_Value[_XX] on the expression Op.
|
|
|
217 --
|
|
|
218 -- Note that we don't define precisely the set of expressions that return
|
|
|
219 -- True. Callers should not make any assumptions regarding the value that
|
|
|
220 -- is returned for non-static expressions. Functional behavior should never
|
|
|
221 -- be affected by whether a given non-static expression returns True or
|
|
|
222 -- False when this function is called. In other words this is purely for
|
|
|
223 -- efficiency optimization purposes. The code generated can often be more
|
|
|
224 -- efficient with compile time known values, e.g. range analysis for the
|
|
|
225 -- purpose of removing checks is more effective if we know precise bounds.
|
|
|
226
|
|
145
|
227 -- WARNING: There is a matching C declaration of this subprogram in fe.h
|
|
|
228
|
|
111
|
229 function Compile_Time_Known_Value_Or_Aggr (Op : Node_Id) return Boolean;
|
|
|
230 -- Similar to Compile_Time_Known_Value, but also returns True if the value
|
|
|
231 -- is a compile-time-known aggregate, i.e. an aggregate all of whose
|
|
|
232 -- constituent expressions are either compile-time-known values (based on
|
|
|
233 -- calling Compile_Time_Known_Value) or compile-time-known aggregates.
|
|
|
234 -- Note that the aggregate could still involve run-time checks that might
|
|
|
235 -- fail (such as for subtype checks in component associations), but the
|
|
|
236 -- evaluation of the expressions themselves will not raise an exception.
|
|
|
237
|
|
|
238 function CRT_Safe_Compile_Time_Known_Value (Op : Node_Id) return Boolean;
|
|
|
239 -- In the case of configurable run-times, there may be an issue calling
|
|
|
240 -- Compile_Time_Known_Value with non-static expressions where the legality
|
|
|
241 -- of the program is not well-defined. Consider this example:
|
|
|
242 --
|
|
|
243 -- X := B ** C;
|
|
|
244 --
|
|
|
245 -- Now if C is compile time known, and has the value 4, then inline code
|
|
|
246 -- can be generated at compile time, instead of calling a run-time routine.
|
|
|
247 -- That's fine in the normal case, but when we have a configurable run-time
|
|
|
248 -- the run-time routine may not be available. This means that the program
|
|
|
249 -- will be rejected if C is not known at compile time. We don't want the
|
|
|
250 -- legality of a program to depend on how clever the implementation of this
|
|
|
251 -- function is. If the run-time in use lacks the exponentiation routine,
|
|
|
252 -- then what we say is that exponentiation is permitted if the exponent is
|
|
|
253 -- officially static and has a value in the range 0 .. 4.
|
|
|
254 --
|
|
|
255 -- In a case like this, we use CRT_Safe_Compile_Time_Known_Value to avoid
|
|
|
256 -- this effect. This routine will return False for a non-static expression
|
|
|
257 -- if we are in configurable run-time mode, even if the expression would
|
|
|
258 -- normally be considered compile-time known.
|
|
|
259
|
|
|
260 function Expr_Rep_Value (N : Node_Id) return Uint;
|
|
|
261 -- This is identical to Expr_Value, except in the case of enumeration
|
|
|
262 -- literals of types for which an enumeration representation clause has
|
|
|
263 -- been given, in which case it returns the representation value rather
|
|
|
264 -- than the pos value. This is the value that is needed for generating code
|
|
|
265 -- sequences, while the Expr_Value value is appropriate for compile time
|
|
|
266 -- constraint errors or getting the logical value. Note that this function
|
|
|
267 -- does NOT concern itself with biased values, if the caller needs a
|
|
|
268 -- properly biased value, the subtraction of the bias must be handled
|
|
|
269 -- explicitly.
|
|
|
270
|
|
|
271 function Expr_Value (N : Node_Id) return Uint;
|
|
|
272 -- Returns the folded value of the expression N. This function is called in
|
|
|
273 -- instances where it has already been determined that the expression is
|
|
|
274 -- static or its value is compile time known (Compile_Time_Known_Value (N)
|
|
|
275 -- returns True). This version is used for integer values, and enumeration
|
|
|
276 -- or character literals. In the latter two cases, the value returned is
|
|
|
277 -- the Pos value in the relevant enumeration type. It can also be used for
|
|
|
278 -- fixed-point values, in which case it returns the corresponding integer
|
|
|
279 -- value. It cannot be used for floating-point values.
|
|
|
280
|
|
|
281 function Expr_Value_E (N : Node_Id) return Entity_Id;
|
|
|
282 -- Returns the folded value of the expression. This function is called in
|
|
|
283 -- instances where it has already been determined that the expression is
|
|
|
284 -- static or its value known at compile time. This version is used for
|
|
|
285 -- enumeration types and returns the corresponding enumeration literal.
|
|
|
286
|
|
|
287 function Expr_Value_R (N : Node_Id) return Ureal;
|
|
|
288 -- Returns the folded value of the expression. This function is called in
|
|
|
289 -- instances where it has already been determined that the expression is
|
|
|
290 -- static or its value known at compile time. This version is used for real
|
|
|
291 -- values (including both the floating-point and fixed-point cases). In the
|
|
|
292 -- case of a fixed-point type, the real value is returned (cf above version
|
|
|
293 -- returning Uint).
|
|
|
294
|
|
|
295 function Expr_Value_S (N : Node_Id) return Node_Id;
|
|
|
296 -- Returns the folded value of the expression. This function is called
|
|
|
297 -- in instances where it has already been determined that the expression
|
|
|
298 -- is static or its value is known at compile time. This version is used
|
|
|
299 -- for string types and returns the corresponding N_String_Literal node.
|
|
|
300
|
|
|
301 procedure Eval_Actual (N : Node_Id);
|
|
|
302 procedure Eval_Allocator (N : Node_Id);
|
|
|
303 procedure Eval_Arithmetic_Op (N : Node_Id);
|
|
|
304 procedure Eval_Call (N : Node_Id);
|
|
|
305 procedure Eval_Case_Expression (N : Node_Id);
|
|
|
306 procedure Eval_Character_Literal (N : Node_Id);
|
|
|
307 procedure Eval_Concatenation (N : Node_Id);
|
|
|
308 procedure Eval_Entity_Name (N : Node_Id);
|
|
|
309 procedure Eval_If_Expression (N : Node_Id);
|
|
|
310 procedure Eval_Indexed_Component (N : Node_Id);
|
|
|
311 procedure Eval_Integer_Literal (N : Node_Id);
|
|
|
312 procedure Eval_Logical_Op (N : Node_Id);
|
|
|
313 procedure Eval_Membership_Op (N : Node_Id);
|
|
|
314 procedure Eval_Named_Integer (N : Node_Id);
|
|
|
315 procedure Eval_Named_Real (N : Node_Id);
|
|
|
316 procedure Eval_Op_Expon (N : Node_Id);
|
|
|
317 procedure Eval_Op_Not (N : Node_Id);
|
|
|
318 procedure Eval_Real_Literal (N : Node_Id);
|
|
|
319 procedure Eval_Relational_Op (N : Node_Id);
|
|
|
320 procedure Eval_Shift (N : Node_Id);
|
|
|
321 procedure Eval_Short_Circuit (N : Node_Id);
|
|
|
322 procedure Eval_Slice (N : Node_Id);
|
|
|
323 procedure Eval_String_Literal (N : Node_Id);
|
|
|
324 procedure Eval_Qualified_Expression (N : Node_Id);
|
|
|
325 procedure Eval_Type_Conversion (N : Node_Id);
|
|
|
326 procedure Eval_Unary_Op (N : Node_Id);
|
|
|
327 procedure Eval_Unchecked_Conversion (N : Node_Id);
|
|
|
328
|
|
|
329 procedure Flag_Non_Static_Expr (Msg : String; Expr : Node_Id);
|
|
|
330 -- This procedure is called after it has been determined that Expr is not
|
|
|
331 -- static when it is required to be. Msg is the text of a message that
|
|
|
332 -- explains the error. This procedure checks if an error is already posted
|
|
|
333 -- on Expr, if so, it does nothing unless All_Errors_Mode is set in which
|
|
|
334 -- case this flag is ignored. Otherwise the given message is posted using
|
|
|
335 -- Error_Msg_F, and then Why_Not_Static is called on Expr to generate
|
|
|
336 -- additional messages. The string given as Msg should end with ! to make
|
|
|
337 -- it an unconditional message, to ensure that if it is posted, the entire
|
|
|
338 -- set of messages is all posted.
|
|
|
339
|
|
|
340 procedure Fold_Str (N : Node_Id; Val : String_Id; Static : Boolean);
|
|
|
341 -- Rewrite N with a new N_String_Literal node as the result of the compile
|
|
|
342 -- time evaluation of the node N. Val is the resulting string value from
|
|
|
343 -- the folding operation. The Is_Static_Expression flag is set in the
|
|
|
344 -- result node. The result is fully analyzed and resolved. Static indicates
|
|
|
345 -- whether the result should be considered static or not (True = consider
|
|
|
346 -- static). The point here is that normally all string literals are static,
|
|
|
347 -- but if this was the result of some sequence of evaluation where values
|
|
|
348 -- were known at compile time but not static, then the result is not
|
|
|
349 -- static. The call has no effect if Raises_Constraint_Error (N) is True,
|
|
|
350 -- since there is no point in folding if we have an error.
|
|
|
351
|
|
|
352 procedure Fold_Uint (N : Node_Id; Val : Uint; Static : Boolean);
|
|
|
353 -- Rewrite N with a (N_Integer_Literal, N_Identifier, N_Character_Literal)
|
|
|
354 -- node as the result of the compile time evaluation of the node N. Val is
|
|
|
355 -- the result in the integer case and is the position of the literal in the
|
|
|
356 -- literals list for the enumeration case. Is_Static_Expression is set True
|
|
|
357 -- in the result node. The result is fully analyzed/resolved. Static
|
|
|
358 -- indicates whether the result should be considered static or not (True =
|
|
|
359 -- consider static). The point here is that normally all integer literals
|
|
|
360 -- are static, but if this was the result of some sequence of evaluation
|
|
|
361 -- where values were known at compile time but not static, then the result
|
|
|
362 -- is not static. The call has no effect if Raises_Constraint_Error (N) is
|
|
|
363 -- True, since there is no point in folding if we have an error.
|
|
|
364
|
|
|
365 procedure Fold_Ureal (N : Node_Id; Val : Ureal; Static : Boolean);
|
|
|
366 -- Rewrite N with a new N_Real_Literal node as the result of the compile
|
|
|
367 -- time evaluation of the node N. Val is the resulting real value from the
|
|
|
368 -- folding operation. The Is_Static_Expression flag is set in the result
|
|
|
369 -- node. The result is fully analyzed and result. Static indicates whether
|
|
|
370 -- the result should be considered static or not (True = consider static).
|
|
|
371 -- The point here is that normally all string literals are static, but if
|
|
|
372 -- this was the result of some sequence of evaluation where values were
|
|
|
373 -- known at compile time but not static, then the result is not static.
|
|
|
374 -- The call has no effect if Raises_Constraint_Error (N) is True, since
|
|
|
375 -- there is no point in folding if we have an error.
|
|
|
376
|
|
|
377 function Is_In_Range
|
|
|
378 (N : Node_Id;
|
|
|
379 Typ : Entity_Id;
|
|
|
380 Assume_Valid : Boolean := False;
|
|
|
381 Fixed_Int : Boolean := False;
|
|
|
382 Int_Real : Boolean := False) return Boolean;
|
|
|
383 -- Returns True if it can be guaranteed at compile time that expression
|
|
|
384 -- N is known to be in range of the subtype Typ. A result of False does
|
|
|
385 -- not mean that the expression is out of range, merely that it cannot be
|
|
|
386 -- determined at compile time that it is in range. If Typ is a floating
|
|
|
387 -- point type or Int_Real is set, any integer value is treated as though it
|
|
|
388 -- was a real value (i.e. the underlying real value is used). In this case
|
|
|
389 -- we use the corresponding real value, both for the bounds of Typ, and for
|
|
|
390 -- the value of the expression N. If Typ is a fixed type or a discrete type
|
|
|
391 -- and Int_Real is False but flag Fixed_Int is True then any fixed-point
|
|
|
392 -- value is treated as though it was discrete value (i.e. the underlying
|
|
|
393 -- integer value is used). In this case we use the corresponding integer
|
|
|
394 -- value, both for the bounds of Typ, and for the value of the expression
|
|
|
395 -- N. If Typ is a discrete type and Fixed_Int as well as Int_Real are
|
|
|
396 -- false, integer values are used throughout.
|
|
|
397 --
|
|
|
398 -- If Assume_Valid is set True, then N is always assumed to contain a valid
|
|
|
399 -- value. If Assume_Valid is set False, then N may be invalid (unless there
|
|
|
400 -- is some independent way of knowing that it is valid, i.e. either it is
|
|
|
401 -- an entity with Is_Known_Valid set, or Assume_No_Invalid_Values is True.
|
|
|
402
|
|
|
403 function Is_Null_Range (Lo : Node_Id; Hi : Node_Id) return Boolean;
|
|
|
404 -- Returns True if it can guarantee that Lo .. Hi is a null range. If it
|
|
|
405 -- cannot (because the value of Lo or Hi is not known at compile time) then
|
|
|
406 -- it returns False.
|
|
|
407
|
|
|
408 function Is_OK_Static_Expression (N : Node_Id) return Boolean;
|
|
|
409 -- An OK static expression is one that is static in the RM definition sense
|
|
|
410 -- and which does not raise constraint error. For most legality checking
|
|
|
411 -- purposes you should use Is_Static_Expression. For those legality checks
|
|
|
412 -- where the expression N should not raise constraint error use this
|
|
|
413 -- routine. This routine is *not* to be used in contexts where the test is
|
|
|
414 -- for compile time evaluation purposes. Use Compile_Time_Known_Value
|
|
|
415 -- instead (see section on "Compile-Time Known Values" above).
|
|
|
416
|
|
145
|
417 -- WARNING: There is a matching C declaration of this subprogram in fe.h
|
|
|
418
|
|
111
|
419 function Is_OK_Static_Range (N : Node_Id) return Boolean;
|
|
|
420 -- Determines if range is static, as defined in RM 4.9(26), and also checks
|
|
|
421 -- that neither bound of the range raises constraint error, thus ensuring
|
|
|
422 -- that both bounds of the range are compile-time evaluable (i.e. do not
|
|
|
423 -- raise constraint error). A result of true means that the bounds are
|
|
|
424 -- compile time evaluable. A result of false means they are not (either
|
|
|
425 -- because the range is not static, or because one or the other bound
|
|
|
426 -- raises CE).
|
|
|
427
|
|
|
428 function Is_OK_Static_Subtype (Typ : Entity_Id) return Boolean;
|
|
|
429 -- Determines whether a subtype fits the definition of an Ada static
|
|
|
430 -- subtype as given in (RM 4.9(26)) with the additional check that neither
|
|
|
431 -- bound raises constraint error (meaning that Expr_Value[_R|S] can be used
|
|
|
432 -- on these bounds).
|
|
|
433 --
|
|
|
434 -- This differs from Is_Static_Subtype in that it includes the constraint
|
|
|
435 -- error checks, which are missing from Is_Static_Subtype.
|
|
|
436
|
|
|
437 function Is_Out_Of_Range
|
|
|
438 (N : Node_Id;
|
|
|
439 Typ : Entity_Id;
|
|
|
440 Assume_Valid : Boolean := False;
|
|
|
441 Fixed_Int : Boolean := False;
|
|
|
442 Int_Real : Boolean := False) return Boolean;
|
|
|
443 -- Returns True if it can be guaranteed at compile time that expression is
|
|
|
444 -- known to be out of range of the subtype Typ. True is returned if Typ is
|
|
|
445 -- a scalar type, and the value of N can be determined to be outside the
|
|
|
446 -- range of Typ. A result of False does not mean that the expression is in
|
|
|
447 -- range, but rather merely that it cannot be determined at compile time
|
|
|
448 -- that it is out of range. The parameters Assume_Valid, Fixed_Int, and
|
|
|
449 -- Int_Real are as described for Is_In_Range above.
|
|
|
450
|
|
|
451 function Is_Static_Subtype (Typ : Entity_Id) return Boolean;
|
|
|
452 -- Determines whether a subtype fits the definition of an Ada static
|
|
|
453 -- subtype as given in (RM 4.9(26)).
|
|
|
454 --
|
|
|
455 -- This differs from Is_OK_Static_Subtype (which is what must be used by
|
|
|
456 -- clients) in that it does not care whether the bounds raise a constraint
|
|
|
457 -- error exception or not. Used for checking whether expressions are static
|
|
|
458 -- in the 4.9 sense (without worrying about exceptions).
|
|
|
459
|
|
|
460 function Is_Statically_Unevaluated (Expr : Node_Id) return Boolean;
|
|
|
461 -- This function returns True if the given expression Expr is statically
|
|
|
462 -- unevaluated, as defined in (RM 4.9 (32.1-32.6)).
|
|
|
463
|
|
|
464 function In_Subrange_Of
|
|
|
465 (T1 : Entity_Id;
|
|
|
466 T2 : Entity_Id;
|
|
|
467 Fixed_Int : Boolean := False) return Boolean;
|
|
|
468 -- Returns True if it can be guaranteed at compile time that the range of
|
|
|
469 -- values for scalar type T1 are always in the range of scalar type T2. A
|
|
|
470 -- result of False does not mean that T1 is not in T2's subrange, only that
|
|
|
471 -- it cannot be determined at compile time. Flag Fixed_Int is used as in
|
|
|
472 -- routine Is_In_Range above.
|
|
|
473
|
|
|
474 function Not_Null_Range (Lo : Node_Id; Hi : Node_Id) return Boolean;
|
|
|
475 -- Returns True if it can guarantee that Lo .. Hi is not a null range. If
|
|
|
476 -- it cannot (because the value of Lo or Hi is not known at compile time)
|
|
|
477 -- then it returns False.
|
|
|
478
|
|
|
479 function Predicates_Match (T1, T2 : Entity_Id) return Boolean;
|
|
|
480 -- In Ada 2012, subtypes statically match if their static predicates
|
|
|
481 -- match as well. This function performs the required check that
|
|
|
482 -- predicates match. Separated out from Subtypes_Statically_Match so
|
|
|
483 -- that it can be used in specializing error messages.
|
|
|
484
|
|
|
485 function Subtypes_Statically_Compatible
|
|
|
486 (T1 : Entity_Id;
|
|
|
487 T2 : Entity_Id;
|
|
|
488 Formal_Derived_Matching : Boolean := False) return Boolean;
|
|
|
489 -- Returns true if the subtypes are unconstrained or the constraint on
|
|
|
490 -- on T1 is statically compatible with T2 (as defined by 4.9.1(4)).
|
|
|
491 -- Otherwise returns false. Formal_Derived_Matching indicates whether
|
|
|
492 -- the type T1 is a generic actual being checked against ancestor T2
|
|
|
493 -- in a formal derived type association.
|
|
|
494
|
|
|
495 function Subtypes_Statically_Match
|
|
|
496 (T1 : Entity_Id;
|
|
|
497 T2 : Entity_Id;
|
|
|
498 Formal_Derived_Matching : Boolean := False) return Boolean;
|
|
|
499 -- Determine whether two types T1, T2, which have the same base type,
|
|
|
500 -- are statically matching subtypes (RM 4.9.1(1-2)). Also includes the
|
|
|
501 -- extra GNAT rule that object sizes must match (this can be false for
|
|
|
502 -- types that match in the RM sense because of use of 'Object_Size),
|
|
|
503 -- except when testing a generic actual T1 against an ancestor T2 in a
|
|
|
504 -- formal derived type association (indicated by Formal_Derived_Matching).
|
|
|
505
|
|
|
506 procedure Test_Comparison
|
|
|
507 (Op : Node_Id;
|
|
|
508 Assume_Valid : Boolean;
|
|
|
509 True_Result : out Boolean;
|
|
|
510 False_Result : out Boolean);
|
|
|
511 -- Determine the outcome of evaluating comparison operator Op using routine
|
|
|
512 -- Compile_Time_Compare. Assume_Valid should be set when the operands are
|
|
|
513 -- to be assumed valid. Flags True_Result and False_Result are set when the
|
|
|
514 -- comparison evaluates to True or False respectively.
|
|
|
515
|
|
|
516 procedure Why_Not_Static (Expr : Node_Id);
|
|
|
517 -- This procedure may be called after generating an error message that
|
|
|
518 -- complains that something is non-static. If it finds good reasons, it
|
|
|
519 -- generates one or more error messages pointing the appropriate offending
|
|
|
520 -- component of the expression. If no good reasons can be figured out, then
|
|
|
521 -- no messages are generated. The expectation here is that the caller has
|
|
|
522 -- already issued a message complaining that the expression is non-static.
|
|
|
523 -- Note that this message should be placed using Error_Msg_F or
|
|
|
524 -- Error_Msg_FE, so that it will sort before any messages placed by this
|
|
|
525 -- call. Note that it is fine to call Why_Not_Static with something that
|
|
|
526 -- is not an expression, and usually this has no effect, but in some cases
|
|
|
527 -- (N_Parameter_Association or N_Range), it makes sense for the internal
|
|
|
528 -- recursive calls.
|
|
|
529 --
|
|
|
530 -- Note that these messages are not continuation messages, instead they are
|
|
|
531 -- separate unconditional messages, marked with '!'. The reason for this is
|
|
|
532 -- that they can be posted at a different location from the main message as
|
|
|
533 -- documented above ("appropriate offending component"), and continuation
|
|
|
534 -- messages must always point to the same location as the parent message.
|
|
|
535
|
|
|
536 procedure Initialize;
|
|
|
537 -- Initializes the internal data structures. Must be called before each
|
|
|
538 -- separate main program unit (e.g. in a GNSA/ASIS context).
|
|
|
539
|
|
|
540 private
|
|
|
541 -- The Eval routines are all marked inline, since they are called once
|
|
|
542
|
|
|
543 pragma Inline (Eval_Actual);
|
|
|
544 pragma Inline (Eval_Allocator);
|
|
|
545 pragma Inline (Eval_Character_Literal);
|
|
|
546 pragma Inline (Eval_If_Expression);
|
|
|
547 pragma Inline (Eval_Indexed_Component);
|
|
|
548 pragma Inline (Eval_Named_Integer);
|
|
|
549 pragma Inline (Eval_Named_Real);
|
|
|
550 pragma Inline (Eval_Real_Literal);
|
|
|
551 pragma Inline (Eval_Shift);
|
|
|
552 pragma Inline (Eval_Slice);
|
|
|
553 pragma Inline (Eval_String_Literal);
|
|
|
554 pragma Inline (Eval_Unchecked_Conversion);
|
|
|
555
|
|
|
556 pragma Inline (Is_OK_Static_Expression);
|
|
|
557
|
|
|
558 end Sem_Eval;
|
