OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [ada/] [sem_eval.ads] - Blame information for rev 706

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 706 jeremybenn
------------------------------------------------------------------------------
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-2010, 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
 
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
 
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)).
200
 
201
   function Is_OK_Static_Subtype (Typ : Entity_Id) return Boolean;
202
   --  Like Is_Static_Subtype but also makes sure that the bounds of the
203
   --  subtype are compile-time evaluable (i.e. do not raise constraint error).
204
   --  A result of true means that the bounds are compile time evaluable. A
205
   --  result of false means they are not (either because the range is not
206
   --  static, or because one or the other bound raises CE).
207
 
208
   function Subtypes_Statically_Compatible
209
     (T1 : Entity_Id;
210
      T2 : Entity_Id) return Boolean;
211
   --  Returns true if the subtypes are unconstrained or the constraint on
212
   --  on T1 is statically compatible with T2 (as defined by 4.9.1(4)).
213
   --  Otherwise returns false.
214
 
215
   function Subtypes_Statically_Match (T1, T2 : Entity_Id) return Boolean;
216
   --  Determine whether two types T1, T2, which have the same base type,
217
   --  are statically matching subtypes (RM 4.9.1(1-2)).
218
 
219
   function Compile_Time_Known_Value (Op : Node_Id) return Boolean;
220
   --  Returns true if Op is an expression not raising constraint error whose
221
   --  value is known at compile time. This is true if Op is a static
222
   --  expression, but can also be true for expressions which are technically
223
   --  non-static but which are in fact known at compile time, such as the
224
   --  static lower bound of a non-static range or the value of a constant
225
   --  object whose initial value is static. Note that this routine is defended
226
   --  against unanalyzed expressions. Such expressions will not cause a
227
   --  blowup, they may cause pessimistic (i.e. False) results to be returned.
228
 
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 or compile
233
   --  time known aggregates.
234
 
235
   function Compile_Time_Known_Bounds (T : Entity_Id) return Boolean;
236
   --  If T is an array whose index bounds are all known at compile time, then
237
   --  True is returned, if T is not an array, or one or more of its index
238
   --  bounds is not known at compile time, then False is returned.
239
 
240
   function Expr_Value (N : Node_Id) return Uint;
241
   --  Returns the folded value of the expression N. This function is called in
242
   --  instances where it has already been determined that the expression is
243
   --  static or its value is compile time known (Compile_Time_Known_Value (N)
244
   --  returns True). This version is used for integer values, and enumeration
245
   --  or character literals. In the latter two cases, the value returned is
246
   --  the Pos value in the relevant enumeration type. It can also be used for
247
   --  fixed-point values, in which case it returns the corresponding integer
248
   --  value. It cannot be used for floating-point values.
249
 
250
   function Expr_Value_E (N : Node_Id) return Entity_Id;
251
   --  Returns the folded value of the expression. This function is called in
252
   --  instances where it has already been determined that the expression is
253
   --  static or its value known at compile time. This version is used for
254
   --  enumeration types and returns the corresponding enumeration literal.
255
 
256
   function Expr_Value_R (N : Node_Id) return Ureal;
257
   --  Returns the folded value of the expression. This function is called in
258
   --  instances where it has already been determined that the expression is
259
   --  static or its value known at compile time. This version is used for real
260
   --  values (including both the floating-point and fixed-point cases). In the
261
   --  case of a fixed-point type, the real value is returned (cf above version
262
   --  returning Uint).
263
 
264
   function Expr_Value_S (N : Node_Id) return Node_Id;
265
   --  Returns the folded value of the expression. This function is called
266
   --  in instances where it has already been determined that the expression
267
   --  is static or its value is known at compile time. This version is used
268
   --  for string types and returns the corresponding N_String_Literal node.
269
 
270
   function Expr_Rep_Value (N : Node_Id) return Uint;
271
   --  This is identical to Expr_Value, except in the case of enumeration
272
   --  literals of types for which an enumeration representation clause has
273
   --  been given, in which case it returns the representation value rather
274
   --  than the pos value. This is the value that is needed for generating code
275
   --  sequences, while the Expr_Value value is appropriate for compile time
276
   --  constraint errors or getting the logical value. Note that this function
277
   --  does NOT concern itself with biased values, if the caller needs a
278
   --  properly biased value, the subtraction of the bias must be handled
279
   --  explicitly.
280
 
281
   procedure Eval_Actual                 (N : Node_Id);
282
   procedure Eval_Allocator              (N : Node_Id);
283
   procedure Eval_Arithmetic_Op          (N : Node_Id);
284
   procedure Eval_Call                   (N : Node_Id);
285
   procedure Eval_Case_Expression        (N : Node_Id);
286
   procedure Eval_Character_Literal      (N : Node_Id);
287
   procedure Eval_Concatenation          (N : Node_Id);
288
   procedure Eval_Conditional_Expression (N : Node_Id);
289
   procedure Eval_Entity_Name            (N : Node_Id);
290
   procedure Eval_Indexed_Component      (N : Node_Id);
291
   procedure Eval_Integer_Literal        (N : Node_Id);
292
   procedure Eval_Logical_Op             (N : Node_Id);
293
   procedure Eval_Membership_Op          (N : Node_Id);
294
   procedure Eval_Named_Integer          (N : Node_Id);
295
   procedure Eval_Named_Real             (N : Node_Id);
296
   procedure Eval_Op_Expon               (N : Node_Id);
297
   procedure Eval_Op_Not                 (N : Node_Id);
298
   procedure Eval_Real_Literal           (N : Node_Id);
299
   procedure Eval_Relational_Op          (N : Node_Id);
300
   procedure Eval_Shift                  (N : Node_Id);
301
   procedure Eval_Short_Circuit          (N : Node_Id);
302
   procedure Eval_Slice                  (N : Node_Id);
303
   procedure Eval_String_Literal         (N : Node_Id);
304
   procedure Eval_Qualified_Expression   (N : Node_Id);
305
   procedure Eval_Type_Conversion        (N : Node_Id);
306
   procedure Eval_Unary_Op               (N : Node_Id);
307
   procedure Eval_Unchecked_Conversion   (N : Node_Id);
308
 
309
   procedure Fold_Str (N : Node_Id; Val : String_Id; Static : Boolean);
310
   --  Rewrite N with a new N_String_Literal node as the result of the compile
311
   --  time evaluation of the node N. Val is the resulting string value from
312
   --  the folding operation. The Is_Static_Expression flag is set in the
313
   --  result node. The result is fully analyzed and resolved. Static indicates
314
   --  whether the result should be considered static or not (True = consider
315
   --  static). The point here is that normally all string literals are static,
316
   --  but if this was the result of some sequence of evaluation where values
317
   --  were known at compile time but not static, then the result is not
318
   --  static.
319
 
320
   procedure Fold_Uint (N : Node_Id; Val : Uint; Static : Boolean);
321
   --  Rewrite N with a (N_Integer_Literal, N_Identifier, N_Character_Literal)
322
   --  node as the result of the compile time evaluation of the node N. Val is
323
   --  the result in the integer case and is the position of the literal in the
324
   --  literals list for the enumeration case. Is_Static_Expression is set True
325
   --  in the result node. The result is fully analyzed/resolved. Static
326
   --  indicates whether the result should be considered static or not (True =
327
   --  consider static). The point here is that normally all integer literals
328
   --  are static, but if this was the result of some sequence of evaluation
329
   --  where values were known at compile time but not static, then the result
330
   --  is not static.
331
 
332
   procedure Fold_Ureal (N : Node_Id; Val : Ureal; Static : Boolean);
333
   --  Rewrite N with a new N_Real_Literal node as the result of the compile
334
   --  time evaluation of the node N. Val is the resulting real value from the
335
   --  folding operation. The Is_Static_Expression flag is set in the result
336
   --  node. The result is fully analyzed and result. Static indicates whether
337
   --  the result should be considered static or not (True = consider static).
338
   --  The point here is that normally all string literals are static, but if
339
   --  this was the result of some sequence of evaluation where values were
340
   --  known at compile time but not static, then the result is not static.
341
 
342
   function Is_In_Range
343
     (N            : Node_Id;
344
      Typ          : Entity_Id;
345
      Assume_Valid : Boolean := False;
346
      Fixed_Int    : Boolean := False;
347
      Int_Real     : Boolean := False) return Boolean;
348
   --  Returns True if it can be guaranteed at compile time that expression is
349
   --  known to be in range of the subtype Typ. A result of False does not mean
350
   --  that the expression is out of range, merely that it cannot be determined
351
   --  at compile time that it is in range. If Typ is a floating point type or
352
   --  Int_Real is set, any integer value is treated as though it was a real
353
   --  value (i.e. the underlying real value is used). In this case we use the
354
   --  corresponding real value, both for the bounds of Typ, and for the value
355
   --  of the expression N. If Typ is a fixed type or a discrete type and
356
   --  Int_Real is False but flag Fixed_Int is True then any fixed-point value
357
   --  is treated as though it was discrete value (i.e. the underlying integer
358
   --  value is used). In this case we use the corresponding integer value,
359
   --  both for the bounds of Typ, and for the value of the expression N. If
360
   --  Typ is a discrete type and Fixed_Int as well as Int_Real are false,
361
   --  integer values are used throughout.
362
   --
363
   --  If Assume_Valid is set True, then N is always assumed to contain a valid
364
   --  value. If Assume_Valid is set False, then N may be invalid (unless there
365
   --  is some independent way of knowing that it is valid, i.e. either it is
366
   --  an entity with Is_Known_Valid set, or Assume_No_Invalid_Values is True.
367
 
368
   function Is_Out_Of_Range
369
     (N            : Node_Id;
370
      Typ          : Entity_Id;
371
      Assume_Valid : Boolean := False;
372
      Fixed_Int    : Boolean := False;
373
      Int_Real     : Boolean := False) return Boolean;
374
   --  Returns True if it can be guaranteed at compile time that expression is
375
   --  known to be out of range of the subtype Typ. True is returned if Typ is
376
   --  a scalar type, and the value of N can be determined to be outside the
377
   --  range of Typ. A result of False does not mean that the expression is in
378
   --  range, but rather merely that it cannot be determined at compile time
379
   --  that it is out of range. The parameters Assume_Valid, Fixed_Int, and
380
   --  Int_Real are as described for Is_In_Range above.
381
 
382
   function In_Subrange_Of
383
     (T1        : Entity_Id;
384
      T2        : Entity_Id;
385
      Fixed_Int : Boolean := False) return Boolean;
386
   --  Returns True if it can be guaranteed at compile time that the range of
387
   --  values for scalar type T1 are always in the range of scalar type T2. A
388
   --  result of False does not mean that T1 is not in T2's subrange, only that
389
   --  it cannot be determined at compile time. Flag Fixed_Int is used as in
390
   --  routine Is_In_Range above.
391
 
392
   function Is_Null_Range (Lo : Node_Id; Hi : Node_Id) return Boolean;
393
   --  Returns True if it can guarantee that Lo .. Hi is a null range. If it
394
   --  cannot (because the value of Lo or Hi is not known at compile time) then
395
   --  it returns False.
396
 
397
   function Not_Null_Range (Lo : Node_Id; Hi : Node_Id) return Boolean;
398
   --  Returns True if it can guarantee that Lo .. Hi is not a null range. If
399
   --  it cannot (because the value of Lo or Hi is not known at compile time)
400
   --  then it returns False.
401
 
402
   procedure Why_Not_Static (Expr : Node_Id);
403
   --  This procedure may be called after generating an error message that
404
   --  complains that something is non-static. If it finds good reasons, it
405
   --  generates one or more error messages pointing the appropriate offending
406
   --  component of the expression. If no good reasons can be figured out, then
407
   --  no messages are generated. The expectation here is that the caller has
408
   --  already issued a message complaining that the expression is non-static.
409
   --  Note that this message should be placed using Error_Msg_F or
410
   --  Error_Msg_FE, so that it will sort before any messages placed by this
411
   --  call. Note that it is fine to call Why_Not_Static with something that is
412
   --  not an expression, and usually this has no effect, but in some cases
413
   --  (N_Parameter_Association or N_Range), it makes sense for the internal
414
   --  recursive calls.
415
 
416
   procedure Initialize;
417
   --  Initializes the internal data structures. Must be called before each
418
   --  separate main program unit (e.g. in a GNSA/ASIS context).
419
 
420
private
421
   --  The Eval routines are all marked inline, since they are called once
422
 
423
   pragma Inline (Eval_Actual);
424
   pragma Inline (Eval_Allocator);
425
   pragma Inline (Eval_Character_Literal);
426
   pragma Inline (Eval_Conditional_Expression);
427
   pragma Inline (Eval_Indexed_Component);
428
   pragma Inline (Eval_Named_Integer);
429
   pragma Inline (Eval_Named_Real);
430
   pragma Inline (Eval_Real_Literal);
431
   pragma Inline (Eval_Shift);
432
   pragma Inline (Eval_Slice);
433
   pragma Inline (Eval_String_Literal);
434
   pragma Inline (Eval_Unchecked_Conversion);
435
 
436
   pragma Inline (Is_OK_Static_Expression);
437
 
438
end Sem_Eval;

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.