1------------------------------------------------------------------------------ 2-- -- 3-- GNAT COMPILER COMPONENTS -- 4-- -- 5-- S E M _ E V A L -- 6-- -- 7-- S p e c -- 8-- -- 9-- Copyright (C) 1992-2012, 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. 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 36with Types; use Types; 37with Uintp; use Uintp; 38with Urealp; use Urealp; 39 40package 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 54 -- This flag is set on any expression that is static according to the 55 -- rules in (RM 4.9(3-32)). 56 57 -- Raises_Constraint_Error 58 59 -- This flag indicates that it is known at compile time that the 60 -- evaluation of an expression raises constraint error. If the 61 -- expression is static, and this flag is off, then it is also known at 62 -- compile time that the expression does not raise constraint error 63 -- (i.e. the flag is accurate for static expressions, and conservative 64 -- for non-static expressions. 65 66 -- If a static expression does not raise constraint error, then the 67 -- Raises_Constraint_Error flag is off, and the expression must be computed 68 -- at compile time, which means that it has the form of either a literal, 69 -- or a constant that is itself (recursively) either a literal or a 70 -- constant. 71 72 -- The above rules must be followed exactly in order for legality checks to 73 -- be accurate. For subexpressions that are not static according to the RM 74 -- definition, they are sometimes folded anyway, but of course in this case 75 -- Is_Static_Expression is not set. 76 77 ------------------------------- 78 -- Compile-Time Known Values -- 79 ------------------------------- 80 81 -- For most legality checking purposes the flag Is_Static_Expression 82 -- defined in Sinfo should be used. This package also provides a routine 83 -- called Is_OK_Static_Expression which in addition of checking that an 84 -- expression is static in the RM 4.9 sense, it checks that the expression 85 -- does not raise constraint error. In fact for certain legality checks not 86 -- only do we need to ascertain that the expression is static, but we must 87 -- also ensure that it does not raise constraint error. 88 -- 89 -- Neither of Is_Static_Expression and Is_OK_Static_Expression should be 90 -- used for compile time evaluation purposes. In fact certain expression 91 -- whose value is known at compile time are not static in the RM 4.9 sense. 92 -- A typical example is: 93 -- 94 -- C : constant Integer := Record_Type'Size; 95 -- 96 -- The expression 'C' is not static in the technical RM sense, but for many 97 -- simple record types, the size is in fact known at compile time. When we 98 -- are trying to perform compile time constant folding (for instance for 99 -- expressions like C + 1, Is_Static_Expression or Is_OK_Static_Expression 100 -- are not the right functions to test if folding is possible. Instead, we 101 -- use Compile_Time_Known_Value. All static expressions that do not raise 102 -- constraint error (i.e. those for which Is_OK_Static_Expression is true) 103 -- are known at compile time, but as shown by the above example, there are 104 -- cases of non-static expressions which are known at compile time. 105 106 ----------------- 107 -- Subprograms -- 108 ----------------- 109 110 procedure Check_Non_Static_Context (N : Node_Id); 111 -- Deals with the special check required for a static expression that 112 -- appears in a non-static context, i.e. is not part of a larger static 113 -- expression (see RM 4.9(35)), i.e. the value of the expression must be 114 -- within the base range of the base type of its expected type. A check is 115 -- also made for expressions that are inside the base range, but outside 116 -- the range of the expected subtype (this is a warning message rather than 117 -- an illegality). 118 -- 119 -- Note: most cases of non-static context checks are handled within 120 -- Sem_Eval itself, including all cases of expressions at the outer level 121 -- (i.e. those that are not a subexpression). Currently the only outside 122 -- customer for this procedure is Sem_Attr (because Eval_Attribute is 123 -- there). There is also one special case arising from ranges (see body of 124 -- Resolve_Range). 125 126 procedure Check_String_Literal_Length (N : Node_Id; Ttype : Entity_Id); 127 -- N is either a string literal, or a constraint error node. In the latter 128 -- case, the situation is already dealt with, and the call has no effect. 129 -- In the former case, if the target type, Ttyp is constrained, then a 130 -- check is made to see if the string literal is of appropriate length. 131 132 type Compare_Result is (LT, LE, EQ, GT, GE, NE, Unknown); 133 subtype Compare_GE is Compare_Result range EQ .. GE; 134 subtype Compare_LE is Compare_Result range LT .. EQ; 135 -- Result subtypes for Compile_Time_Compare subprograms 136 137 function Compile_Time_Compare 138 (L, R : Node_Id; 139 Assume_Valid : Boolean) return Compare_Result; 140 pragma Inline (Compile_Time_Compare); 141 -- Given two expression nodes, finds out whether it can be determined at 142 -- compile time how the runtime values will compare. An Unknown result 143 -- means that the result of a comparison cannot be determined at compile 144 -- time, otherwise the returned result indicates the known result of the 145 -- comparison, given as tightly as possible (i.e. EQ or LT is preferred 146 -- returned value to LE). If Assume_Valid is true, the result reflects 147 -- the result of assuming that entities involved in the comparison have 148 -- valid representations. If Assume_Valid is false, then the base type of 149 -- any involved entity is used so that no assumption of validity is made. 150 151 function Compile_Time_Compare 152 (L, R : Node_Id; 153 Diff : access Uint; 154 Assume_Valid : Boolean; 155 Rec : Boolean := False) return Compare_Result; 156 -- This version of Compile_Time_Compare returns extra information if the 157 -- result is GT or LT. In these cases, if the magnitude of the difference 158 -- can be determined at compile time, this (positive) magnitude is returned 159 -- in Diff.all. If the magnitude of the difference cannot be determined 160 -- then Diff.all contains No_Uint on return. Rec is a parameter that is set 161 -- True for a recursive call from within Compile_Time_Compare to avoid some 162 -- infinite recursion cases. It should never be set by a client. 163 164 procedure Flag_Non_Static_Expr (Msg : String; Expr : Node_Id); 165 -- This procedure is called after it has been determined that Expr is not 166 -- static when it is required to be. Msg is the text of a message that 167 -- explains the error. This procedure checks if an error is already posted 168 -- on Expr, if so, it does nothing unless All_Errors_Mode is set in which 169 -- case this flag is ignored. Otherwise the given message is posted using 170 -- Error_Msg_F, and then Why_Not_Static is called on Expr to generate 171 -- additional messages. The string given as Msg should end with ! to make 172 -- it an unconditional message, to ensure that if it is posted, the entire 173 -- set of messages is all posted. 174 175 function Is_OK_Static_Expression (N : Node_Id) return Boolean; 176 -- An OK static expression is one that is static in the RM definition sense 177 -- and which does not raise constraint error. For most legality checking 178 -- purposes you should use Is_Static_Expression. For those legality checks 179 -- where the expression N should not raise constraint error use this 180 -- routine. This routine is *not* to be used in contexts where the test is 181 -- for compile time evaluation purposes. Use Compile_Time_Known_Value 182 -- instead (see section on "Compile-Time Known Values" above). 183 184 function Is_Static_Range (N : Node_Id) return Boolean; 185 -- Determine if range is static, as defined in RM 4.9(26). The only allowed 186 -- argument is an N_Range node (but note that the semantic analysis of 187 -- equivalent range attribute references already turned them into the 188 -- equivalent range). 189 190 function Is_OK_Static_Range (N : Node_Id) return Boolean; 191 -- Like Is_Static_Range, but also makes sure that the bounds of the range 192 -- are compile-time evaluable (i.e. do not raise constraint error). A 193 -- result of true means that the bounds are compile time evaluable. A 194 -- result of false means they are not (either because the range is not 195 -- static, or because one or the other bound raises CE). 196 197 function Is_Static_Subtype (Typ : Entity_Id) return Boolean; 198 -- Determines whether a subtype fits the definition of an Ada static 199 -- subtype as given in (RM 4.9(26)). Important note: This check does not 200 -- include the Ada 2012 case of a non-static predicate which results in an 201 -- otherwise static subtype being non-static. Such a subtype will return 202 -- True for this test, so if the distinction is important, the caller must 203 -- deal with this. 204 -- 205 -- Implementation note: an attempt to include this Ada 2012 case failed, 206 -- since it appears that this routine is called in some cases before the 207 -- Static_Predicate field is set ??? 208 209 function Is_OK_Static_Subtype (Typ : Entity_Id) return Boolean; 210 -- Like Is_Static_Subtype but also makes sure that the bounds of the 211 -- subtype are compile-time evaluable (i.e. do not raise constraint error). 212 -- A result of true means that the bounds are compile time evaluable. A 213 -- result of false means they are not (either because the range is not 214 -- static, or because one or the other bound raises CE). 215 216 function Subtypes_Statically_Compatible 217 (T1 : Entity_Id; 218 T2 : Entity_Id) return Boolean; 219 -- Returns true if the subtypes are unconstrained or the constraint on 220 -- on T1 is statically compatible with T2 (as defined by 4.9.1(4)). 221 -- Otherwise returns false. 222 223 function Subtypes_Statically_Match (T1, T2 : Entity_Id) return Boolean; 224 -- Determine whether two types T1, T2, which have the same base type, 225 -- are statically matching subtypes (RM 4.9.1(1-2)). 226 227 function Compile_Time_Known_Value (Op : Node_Id) return Boolean; 228 -- Returns true if Op is an expression not raising Constraint_Error whose 229 -- value is known at compile time. This is true if Op is a static 230 -- expression, but can also be true for expressions which are technically 231 -- non-static but which are in fact known at compile time, such as the 232 -- static lower bound of a non-static range or the value of a constant 233 -- object whose initial value is static. Note that this routine is defended 234 -- against unanalyzed expressions. Such expressions will not cause a 235 -- blowup, they may cause pessimistic (i.e. False) results to be returned. 236 237 function Compile_Time_Known_Value_Or_Aggr (Op : Node_Id) return Boolean; 238 -- Similar to Compile_Time_Known_Value, but also returns True if the value 239 -- is a compile-time-known aggregate, i.e. an aggregate all of whose 240 -- constituent expressions are either compile-time-known values (based on 241 -- calling Compile_Time_Known_Value) or compile-time-known aggregates. 242 -- Note that the aggregate could still involve run-time checks that might 243 -- fail (such as for subtype checks in component associations), but the 244 -- evaluation of the expressions themselves will not raise an exception. 245 246 function Compile_Time_Known_Bounds (T : Entity_Id) return Boolean; 247 -- If T is an array whose index bounds are all known at compile time, then 248 -- True is returned, if T is not an array, or one or more of its index 249 -- bounds is not known at compile time, then False is returned. 250 251 function Expr_Value (N : Node_Id) return Uint; 252 -- Returns the folded value of the expression N. This function is called in 253 -- instances where it has already been determined that the expression is 254 -- static or its value is compile time known (Compile_Time_Known_Value (N) 255 -- returns True). This version is used for integer values, and enumeration 256 -- or character literals. In the latter two cases, the value returned is 257 -- the Pos value in the relevant enumeration type. It can also be used for 258 -- fixed-point values, in which case it returns the corresponding integer 259 -- value. It cannot be used for floating-point values. 260 261 function Expr_Value_E (N : Node_Id) return Entity_Id; 262 -- Returns the folded value of the expression. This function is called in 263 -- instances where it has already been determined that the expression is 264 -- static or its value known at compile time. This version is used for 265 -- enumeration types and returns the corresponding enumeration literal. 266 267 function Expr_Value_R (N : Node_Id) return Ureal; 268 -- Returns the folded value of the expression. This function is called in 269 -- instances where it has already been determined that the expression is 270 -- static or its value known at compile time. This version is used for real 271 -- values (including both the floating-point and fixed-point cases). In the 272 -- case of a fixed-point type, the real value is returned (cf above version 273 -- returning Uint). 274 275 function Expr_Value_S (N : Node_Id) return Node_Id; 276 -- Returns the folded value of the expression. This function is called 277 -- in instances where it has already been determined that the expression 278 -- is static or its value is known at compile time. This version is used 279 -- for string types and returns the corresponding N_String_Literal node. 280 281 function Expr_Rep_Value (N : Node_Id) return Uint; 282 -- This is identical to Expr_Value, except in the case of enumeration 283 -- literals of types for which an enumeration representation clause has 284 -- been given, in which case it returns the representation value rather 285 -- than the pos value. This is the value that is needed for generating code 286 -- sequences, while the Expr_Value value is appropriate for compile time 287 -- constraint errors or getting the logical value. Note that this function 288 -- does NOT concern itself with biased values, if the caller needs a 289 -- properly biased value, the subtraction of the bias must be handled 290 -- explicitly. 291 292 procedure Eval_Actual (N : Node_Id); 293 procedure Eval_Allocator (N : Node_Id); 294 procedure Eval_Arithmetic_Op (N : Node_Id); 295 procedure Eval_Call (N : Node_Id); 296 procedure Eval_Case_Expression (N : Node_Id); 297 procedure Eval_Character_Literal (N : Node_Id); 298 procedure Eval_Concatenation (N : Node_Id); 299 procedure Eval_Entity_Name (N : Node_Id); 300 procedure Eval_If_Expression (N : Node_Id); 301 procedure Eval_Indexed_Component (N : Node_Id); 302 procedure Eval_Integer_Literal (N : Node_Id); 303 procedure Eval_Logical_Op (N : Node_Id); 304 procedure Eval_Membership_Op (N : Node_Id); 305 procedure Eval_Named_Integer (N : Node_Id); 306 procedure Eval_Named_Real (N : Node_Id); 307 procedure Eval_Op_Expon (N : Node_Id); 308 procedure Eval_Op_Not (N : Node_Id); 309 procedure Eval_Real_Literal (N : Node_Id); 310 procedure Eval_Relational_Op (N : Node_Id); 311 procedure Eval_Shift (N : Node_Id); 312 procedure Eval_Short_Circuit (N : Node_Id); 313 procedure Eval_Slice (N : Node_Id); 314 procedure Eval_String_Literal (N : Node_Id); 315 procedure Eval_Qualified_Expression (N : Node_Id); 316 procedure Eval_Type_Conversion (N : Node_Id); 317 procedure Eval_Unary_Op (N : Node_Id); 318 procedure Eval_Unchecked_Conversion (N : Node_Id); 319 320 function Eval_Static_Predicate_Check 321 (N : Node_Id; 322 Typ : Entity_Id) return Boolean; 323 -- Evaluate a static predicate check applied to a scalar literal 324 325 procedure Fold_Str (N : Node_Id; Val : String_Id; Static : Boolean); 326 -- Rewrite N with a new N_String_Literal node as the result of the compile 327 -- time evaluation of the node N. Val is the resulting string value from 328 -- the folding operation. The Is_Static_Expression flag is set in the 329 -- result node. The result is fully analyzed and resolved. Static indicates 330 -- whether the result should be considered static or not (True = consider 331 -- static). The point here is that normally all string literals are static, 332 -- but if this was the result of some sequence of evaluation where values 333 -- were known at compile time but not static, then the result is not 334 -- static. 335 336 procedure Fold_Uint (N : Node_Id; Val : Uint; Static : Boolean); 337 -- Rewrite N with a (N_Integer_Literal, N_Identifier, N_Character_Literal) 338 -- node as the result of the compile time evaluation of the node N. Val is 339 -- the result in the integer case and is the position of the literal in the 340 -- literals list for the enumeration case. Is_Static_Expression is set True 341 -- in the result node. The result is fully analyzed/resolved. Static 342 -- indicates whether the result should be considered static or not (True = 343 -- consider static). The point here is that normally all integer literals 344 -- are static, but if this was the result of some sequence of evaluation 345 -- where values were known at compile time but not static, then the result 346 -- is not static. 347 348 procedure Fold_Ureal (N : Node_Id; Val : Ureal; Static : Boolean); 349 -- Rewrite N with a new N_Real_Literal node as the result of the compile 350 -- time evaluation of the node N. Val is the resulting real value from the 351 -- folding operation. The Is_Static_Expression flag is set in the result 352 -- node. The result is fully analyzed and result. Static indicates whether 353 -- the result should be considered static or not (True = consider static). 354 -- The point here is that normally all string literals are static, but if 355 -- this was the result of some sequence of evaluation where values were 356 -- known at compile time but not static, then the result is not static. 357 358 function Is_In_Range 359 (N : Node_Id; 360 Typ : Entity_Id; 361 Assume_Valid : Boolean := False; 362 Fixed_Int : Boolean := False; 363 Int_Real : Boolean := False) return Boolean; 364 -- Returns True if it can be guaranteed at compile time that expression is 365 -- known to be in range of the subtype Typ. A result of False does not mean 366 -- that the expression is out of range, merely that it cannot be determined 367 -- at compile time that it is in range. If Typ is a floating point type or 368 -- Int_Real is set, any integer value is treated as though it was a real 369 -- value (i.e. the underlying real value is used). In this case we use the 370 -- corresponding real value, both for the bounds of Typ, and for the value 371 -- of the expression N. If Typ is a fixed type or a discrete type and 372 -- Int_Real is False but flag Fixed_Int is True then any fixed-point value 373 -- is treated as though it was discrete value (i.e. the underlying integer 374 -- value is used). In this case we use the corresponding integer value, 375 -- both for the bounds of Typ, and for the value of the expression N. If 376 -- Typ is a discrete type and Fixed_Int as well as Int_Real are false, 377 -- integer values are used throughout. 378 -- 379 -- If Assume_Valid is set True, then N is always assumed to contain a valid 380 -- value. If Assume_Valid is set False, then N may be invalid (unless there 381 -- is some independent way of knowing that it is valid, i.e. either it is 382 -- an entity with Is_Known_Valid set, or Assume_No_Invalid_Values is True. 383 384 function Is_Out_Of_Range 385 (N : Node_Id; 386 Typ : Entity_Id; 387 Assume_Valid : Boolean := False; 388 Fixed_Int : Boolean := False; 389 Int_Real : Boolean := False) return Boolean; 390 -- Returns True if it can be guaranteed at compile time that expression is 391 -- known to be out of range of the subtype Typ. True is returned if Typ is 392 -- a scalar type, and the value of N can be determined to be outside the 393 -- range of Typ. A result of False does not mean that the expression is in 394 -- range, but rather merely that it cannot be determined at compile time 395 -- that it is out of range. The parameters Assume_Valid, Fixed_Int, and 396 -- Int_Real are as described for Is_In_Range above. 397 398 function In_Subrange_Of 399 (T1 : Entity_Id; 400 T2 : Entity_Id; 401 Fixed_Int : Boolean := False) return Boolean; 402 -- Returns True if it can be guaranteed at compile time that the range of 403 -- values for scalar type T1 are always in the range of scalar type T2. A 404 -- result of False does not mean that T1 is not in T2's subrange, only that 405 -- it cannot be determined at compile time. Flag Fixed_Int is used as in 406 -- routine Is_In_Range above. 407 408 function Is_Null_Range (Lo : Node_Id; Hi : Node_Id) return Boolean; 409 -- Returns True if it can guarantee that Lo .. Hi is a null range. If it 410 -- cannot (because the value of Lo or Hi is not known at compile time) then 411 -- it returns False. 412 413 function Not_Null_Range (Lo : Node_Id; Hi : Node_Id) return Boolean; 414 -- Returns True if it can guarantee that Lo .. Hi is not a null range. If 415 -- it cannot (because the value of Lo or Hi is not known at compile time) 416 -- then it returns False. 417 418 procedure Why_Not_Static (Expr : Node_Id); 419 -- This procedure may be called after generating an error message that 420 -- complains that something is non-static. If it finds good reasons, it 421 -- generates one or more error messages pointing the appropriate offending 422 -- component of the expression. If no good reasons can be figured out, then 423 -- no messages are generated. The expectation here is that the caller has 424 -- already issued a message complaining that the expression is non-static. 425 -- Note that this message should be placed using Error_Msg_F or 426 -- Error_Msg_FE, so that it will sort before any messages placed by this 427 -- call. Note that it is fine to call Why_Not_Static with something that is 428 -- not an expression, and usually this has no effect, but in some cases 429 -- (N_Parameter_Association or N_Range), it makes sense for the internal 430 -- recursive calls. 431 432 procedure Initialize; 433 -- Initializes the internal data structures. Must be called before each 434 -- separate main program unit (e.g. in a GNSA/ASIS context). 435 436private 437 -- The Eval routines are all marked inline, since they are called once 438 439 pragma Inline (Eval_Actual); 440 pragma Inline (Eval_Allocator); 441 pragma Inline (Eval_Character_Literal); 442 pragma Inline (Eval_If_Expression); 443 pragma Inline (Eval_Indexed_Component); 444 pragma Inline (Eval_Named_Integer); 445 pragma Inline (Eval_Named_Real); 446 pragma Inline (Eval_Real_Literal); 447 pragma Inline (Eval_Shift); 448 pragma Inline (Eval_Slice); 449 pragma Inline (Eval_String_Literal); 450 pragma Inline (Eval_Unchecked_Conversion); 451 452 pragma Inline (Is_OK_Static_Expression); 453 454end Sem_Eval; 455