-- --
-- B o d y --
-- --
--- $Revision: 1.1 $
+-- $Revision$
-- --
-- Copyright (C) 2001 Free Software Foundation, Inc. --
-- --
Len : Node_Id;
type Val_Status_Type is (Const, Dynamic);
+
+ type Val_Type (Status : Val_Status_Type := Const) is
+ record
+ case Status is
+ when Const => Val : Uint;
+ when Dynamic => Nod : Node_Id;
+ end case;
+ end record;
-- Shows the status of the value so far. Const means that the value
- -- is constant, and Sval is the current constant value. Dynamic means
- -- that the value is dynamic, and in this case Snod is the Node_Id of
+ -- is constant, and Val is the current constant value. Dynamic means
+ -- that the value is dynamic, and in this case Nod is the Node_Id of
-- the expression to compute the value.
- Val_Status : Val_Status_Type;
- -- Indicate status of value so far
-
- Sval : Uint := Uint_0;
- -- Calculated value so far if Val_Status = Const
- -- (initialized to prevent junk warning)
-
- Snod : Node_Id;
- -- Expression value so far if Val_Status = Dynamic
+ Size : Val_Type;
+ -- Calculated value so far if Size.Status = Const,
+ -- or expression value so far if Size.Status = Dynamic.
SU_Convert_Required : Boolean := False;
-- This is set to True if the final result must be converted from
-- Initialize status from component size
if Known_Static_Component_Size (E) then
- Val_Status := Const;
- Sval := Component_Size (E);
+ Size := (Const, Component_Size (E));
else
- Val_Status := Dynamic;
- Snod := Expr_From_SO_Ref (Loc, Component_Size (E));
+ Size := (Dynamic, Expr_From_SO_Ref (Loc, Component_Size (E)));
end if;
-- Loop through indices
-- Current value is constant, evolve value
- if Val_Status = Const then
- Sval := Sval * S;
+ if Size.Status = Const then
+ Size.Val := Size.Val * S;
-- Current value is dynamic
SU_Convert_Required := False;
end if;
- Snod :=
+ Size.Nod :=
Assoc_Multiply (Loc,
- Left_Opnd => Snod,
+ Left_Opnd => Size.Nod,
Right_Opnd =>
Make_Integer_Literal (Loc, Intval => S));
end if;
-- we want to do the SU conversion after computing the size in
-- this case.
- if Val_Status = Const then
- Val_Status := Dynamic;
+ if Size.Status = Const then
-- If the current value is a multiple of the storage unit,
-- then most certainly we can do the conversion now, simply
-- by dividing the current value by the storage unit value.
-- If this works, we set SU_Convert_Required to False.
- if Sval mod SSU = 0 then
- Snod := Make_Integer_Literal (Loc, Sval / SSU);
+ if Size.Val mod SSU = 0 then
+
+ Size :=
+ (Dynamic, Make_Integer_Literal (Loc, Size.Val / SSU));
SU_Convert_Required := False;
-- Otherwise, we go ahead and convert the value in bits,
-- final value is indeed properly converted.
else
- Snod := Make_Integer_Literal (Loc, Sval);
+ Size := (Dynamic, Make_Integer_Literal (Loc, Size.Val));
SU_Convert_Required := True;
end if;
end if;
-- Here after processing all bounds to set sizes. If the value is
-- a constant, then it is bits, and we just return the value.
- if Val_Status = Const then
- return Make_Integer_Literal (Loc, Sval);
+ if Size.Status = Const then
+ return Make_Integer_Literal (Loc, Size.Val);
-- Case where the value is dynamic
if SU_Convert_Required then
- -- The expression required is (Snod + SU - 1) / SU
+ -- The expression required is (Size.Nod + SU - 1) / SU
- Snod :=
+ Size.Nod :=
Make_Op_Divide (Loc,
Left_Opnd =>
Make_Op_Add (Loc,
- Left_Opnd => Snod,
+ Left_Opnd => Size.Nod,
Right_Opnd => Make_Integer_Literal (Loc, SSU - 1)),
Right_Opnd => Make_Integer_Literal (Loc, SSU));
end if;
- return Snod;
+ return Size.Nod;
end if;
end Get_Max_Size;
-- question, and whose body is the expression.
type Val_Status_Type is (Const, Dynamic, Discrim);
- -- Shows the status of the value so far. Const means that the value
- -- is constant, and Sval is the current constant value. Dynamic means
- -- that the value is dynamic, and in this case Snod is the Node_Id of
- -- the expression to compute the value, and Discrim means that at least
- -- one bound is a discriminant, in which case Snod is the expression so
- -- far (which will be the body of the function).
- Val_Status : Val_Status_Type;
- -- Indicate status of value so far
-
- Sval : Uint := Uint_0;
- -- Calculated value so far if Val_Status = Const
- -- Initialized to prevent junk warning
-
- Snod : Node_Id;
- -- Expression value so far if Val_Status /= Const
-
- Vtyp : Entity_Id;
- -- Variant record type for the formal parameter of the discriminant
- -- function V if Val_Status = Discrim.
+ type Val_Type (Status : Val_Status_Type := Const) is
+ record
+ case Status is
+ when Const =>
+ Val : Uint;
+ -- Calculated value so far if Val_Status = Const
+
+ when Dynamic | Discrim =>
+ Nod : Node_Id;
+ -- Expression value so far if Val_Status /= Const
+
+ end case;
+ end record;
+ -- Records the value or expression computed so far. Const means that
+ -- the value is constant, and Val is the current constant value.
+ -- Dynamic means that the value is dynamic, and in this case Nod is
+ -- the Node_Id of the expression to compute the value, and Discrim
+ -- means that at least one bound is a discriminant, in which case Nod
+ -- is the expression so far (which will be the body of the function).
+
+ Size : Val_Type;
+ -- Value of size computed so far. See comments above.
+
+ Vtyp : Entity_Id := Empty;
+ -- Variant record type for the formal parameter of the
+ -- discriminant function V if Status = Discrim.
SU_Convert_Required : Boolean := False;
-- This is set to True if the final result must be converted from
-- bits to storage units (rounding up to a storage unit boundary).
procedure Discrimify (N : in out Node_Id);
- -- If N represents a discriminant, then the Val_Status is set to
+ -- If N represents a discriminant, then the Size.Status is set to
-- Discrim, and Vtyp is set. The parameter N is replaced with the
-- proper expression to extract the discriminant value from V.
then
Set_Size_Depends_On_Discriminant (E);
- if Val_Status /= Discrim then
- Val_Status := Discrim;
+ if Size.Status /= Discrim then
Decl := Parent (Parent (Entity (N)));
+ Size := (Discrim, Size.Nod);
Vtyp := Defining_Identifier (Decl);
end if;
-- Initialize status from component size
if Known_Static_Component_Size (E) then
- Val_Status := Const;
- Sval := Component_Size (E);
+ Size := (Const, Component_Size (E));
else
- Val_Status := Dynamic;
- Snod := Expr_From_SO_Ref (Loc, Component_Size (E));
+ Size := (Dynamic, Expr_From_SO_Ref (Loc, Component_Size (E)));
end if;
-- Loop to process array indices
-- If constant, evolve value
- if Val_Status = Const then
- Sval := Sval * S;
+ if Size.Status = Const then
+ Size.Val := Size.Val * S;
-- Current value is dynamic
-- Now go ahead and evolve the expression
- Snod :=
+ Size.Nod :=
Assoc_Multiply (Loc,
- Left_Opnd => Snod,
+ Left_Opnd => Size.Nod,
Right_Opnd =>
Make_Integer_Literal (Loc, Intval => S));
end if;
-- we want to do the SU conversion after computing the size in
-- this case.
- if Val_Status = Const then
- Val_Status := Dynamic;
+ if Size.Status = Const then
-- If the current value is a multiple of the storage unit,
-- then most certainly we can do the conversion now, simply
-- by dividing the current value by the storage unit value.
-- If this works, we set SU_Convert_Required to False.
- if Sval mod SSU = 0 then
- Snod := Make_Integer_Literal (Loc, Sval / SSU);
+ if Size.Val mod SSU = 0 then
+ Size :=
+ (Dynamic, Make_Integer_Literal (Loc, Size.Val / SSU));
SU_Convert_Required := False;
-- Otherwise, we go ahead and convert the value in bits,
-- final value is indeed properly converted.
else
- Snod := Make_Integer_Literal (Loc, Sval);
+ Size := (Dynamic, Make_Integer_Literal (Loc, Size.Val));
SU_Convert_Required := True;
end if;
end if;
-- At this stage, Len has the expression for the length
- Snod :=
+ Size.Nod :=
Assoc_Multiply (Loc,
- Left_Opnd => Snod,
+ Left_Opnd => Size.Nod,
Right_Opnd => Len);
end if;
-- a constant, then it is bits, and the only thing we need to do
-- is to check against explicit given size and do alignment adjust.
- if Val_Status = Const then
- Set_And_Check_Static_Size (E, Sval, Sval);
+ if Size.Status = Const then
+ Set_And_Check_Static_Size (E, Size.Val, Size.Val);
Adjust_Esize_Alignment (E);
-- Case where the value is dynamic
if SU_Convert_Required then
- -- The expression required is (Snod + SU - 1) / SU
+ -- The expression required is (Size.Nod + SU - 1) / SU
- Snod :=
+ Size.Nod :=
Make_Op_Divide (Loc,
Left_Opnd =>
Make_Op_Add (Loc,
- Left_Opnd => Snod,
+ Left_Opnd => Size.Nod,
Right_Opnd => Make_Integer_Literal (Loc, SSU - 1)),
Right_Opnd => Make_Integer_Literal (Loc, SSU));
end if;
-- Now set the dynamic size (the Value_Size is always the same
-- as the Object_Size for arrays whose length is dynamic).
- Set_Esize (E, SO_Ref_From_Expr (Snod, Insert_Typ, Vtyp));
+ -- ??? If Size.Status = Dynamic, Vtyp will not have been set.
+ -- The added initialization sets it to Empty now, but is this
+ -- correct?
+
+ Set_Esize (E, SO_Ref_From_Expr (Size.Nod, Insert_Typ, Vtyp));
Set_RM_Size (E, Esize (E));
end if;
end Layout_Array_Type;
projects / gcc.git / commitdiff