+2014-07-18 Robert Dewar <dewar@adacore.com>
+
+ * sem_aggr.adb, exp_ch5.adb, sem_ch3.adb, layout.adb, sem_type.adb,
+ exp_util.adb, exp_attr.adb, einfo.adb, einfo.ads, exp_pakd.adb,
+ checks.adb, exp_pakd.ads, freeze.adb, sem_util.adb, exp_dbug.adb,
+ exp_dbug.ads, exp_ch4.adb, sem_ch8.adb, exp_aggr.adb, sem_eval.adb,
+ sem_ch13.adb: Change name Packed_Array_Type to Packed_Array_Impl_Type.
+
2014-07-18 Robert Dewar <dewar@adacore.com>
* lib-writ.adb, makeutl.adb, ali.ads: Minor reformatting.
-- so they are also always valid (in particular, the unused bits can be
-- random rubbish without affecting the validity of the array value).
- if not Is_Scalar_Type (Typ) or else Is_Packed_Array_Type (Typ) then
+ if not Is_Scalar_Type (Typ) or else Is_Packed_Array_Impl_Type (Typ) then
return True;
-- If no validity checking, then everything is considered valid
if Analyzed (PV)
and then Nkind (PV) = N_Indexed_Component
- and then Present (Packed_Array_Type (Etype (Prefix (PV))))
+ and then Present (Packed_Array_Impl_Type (Etype (Prefix (PV))))
then
Set_Analyzed (PV, False);
end if;
-- Generic_Renamings Elist23
-- Inner_Instances Elist23
-- Limited_View Node23
- -- Packed_Array_Type Node23
+ -- Packed_Array_Impl_Type Node23
-- Protection_Object Node23
-- Stored_Constraint Elist23
-- Has_Aliased_Components Flag135
-- No_Strict_Aliasing Flag136
-- Is_Machine_Code_Subprogram Flag137
- -- Is_Packed_Array_Type Flag138
+ -- Is_Packed_Array_Impl_Type Flag138
-- Has_Biased_Representation Flag139
-- Has_Complex_Representation Flag140
return Flag51 (Implementation_Base_Type (Id));
end Is_Packed;
- function Is_Packed_Array_Type (Id : E) return B is
+ function Is_Packed_Array_Impl_Type (Id : E) return B is
begin
return Flag138 (Id);
- end Is_Packed_Array_Type;
+ end Is_Packed_Array_Impl_Type;
function Is_Potentially_Use_Visible (Id : E) return B is
begin
return Node26 (Id);
end Package_Instantiation;
- function Packed_Array_Type (Id : E) return E is
+ function Packed_Array_Impl_Type (Id : E) return E is
begin
pragma Assert (Is_Array_Type (Id));
return Node23 (Id);
- end Packed_Array_Type;
+ end Packed_Array_Impl_Type;
function Parent_Subtype (Id : E) return E is
begin
Set_Flag51 (Id, V);
end Set_Is_Packed;
- procedure Set_Is_Packed_Array_Type (Id : E; V : B := True) is
+ procedure Set_Is_Packed_Array_Impl_Type (Id : E; V : B := True) is
begin
Set_Flag138 (Id, V);
- end Set_Is_Packed_Array_Type;
+ end Set_Is_Packed_Array_Impl_Type;
procedure Set_Is_Potentially_Use_Visible (Id : E; V : B := True) is
begin
Set_Node26 (Id, V);
end Set_Package_Instantiation;
- procedure Set_Packed_Array_Type (Id : E; V : E) is
+ procedure Set_Packed_Array_Impl_Type (Id : E; V : E) is
begin
pragma Assert (Is_Array_Type (Id));
Set_Node23 (Id, V);
- end Set_Packed_Array_Type;
+ end Set_Packed_Array_Impl_Type;
procedure Set_Parent_Subtype (Id : E; V : E) is
begin
W ("Is_Optional_Parameter", Flag134 (Id));
W ("Is_Package_Body_Entity", Flag160 (Id));
W ("Is_Packed", Flag51 (Id));
- W ("Is_Packed_Array_Type", Flag138 (Id));
+ W ("Is_Packed_Array_Impl_Type", Flag138 (Id));
W ("Is_Potentially_Use_Visible", Flag9 (Id));
W ("Is_Predicate_Function", Flag255 (Id));
W ("Is_Predicate_Function_M", Flag256 (Id));
Write_Str ("Inner_Instances");
when Array_Kind =>
- Write_Str ("Packed_Array_Type");
+ Write_Str ("Packed_Array_Impl_Type");
when Entry_Kind =>
Write_Str ("Protection_Object");
-- Is_Packed_Array (synth)
-- Applies to all entities, true if entity is for a packed array.
--- Is_Packed_Array_Type (Flag138)
+-- Is_Packed_Array_Impl_Type (Flag138)
-- Defined in all entities. This flag is set on the entity for the type
-- used to implement a packed array (either a modular type, or a subtype
-- of Packed_Bytes{1,2,4} as appropriate). The flag is set if and only
--- if the type appears in the Packed_Array_Type field of some other type
+-- if the type appears in the Packed_Array_Impl_Type field of some other
-- entity. It is used by the backend to activate the special processing
-- for such types (unchecked conversions that would not otherwise be
--- allowed are allowed for such types). If the Is_Packed_Array_Type flag
--- is set in an entity, then the Original_Array_Type field of this entity
--- points to the array type for which this is the packed array type.
+-- allowed are allowed for such types). If Is_Packed_Array_Impl_Type is
+-- set in an entity, then the Original_Array_Type field of this entity
+-- points to the array type for which this is the Packed_Array_Impl_Type.
-- Is_Potentially_Use_Visible (Flag9)
-- Defined in all entities. Set if entity is potentially use visible,
-- subprogram type.
-- Original_Array_Type (Node21)
--- Defined in modular types and array types and subtypes. Set only
--- if the Is_Packed_Array_Type flag is set, indicating that the type
+-- Defined in modular types and array types and subtypes. Set only if
+-- the Is_Packed_Array_Impl_Type flag is set, indicating that the type
-- is the implementation type for a packed array, and in this case it
-- points to the original array type for which this is the packed
-- array implementation type.
-- it should be set in all cases, including package entities associated
-- with formal packages. ???
--- Packed_Array_Type (Node23)
+-- Packed_Array_Impl_Type (Node23)
-- Defined in array types and subtypes, including the string literal
-- subtype case, if the corresponding type is packed (either bit packed
-- or packed to eliminate holes in non-contiguous enumeration type index
-- is either a modular type for short static arrays, or an array of
-- System.Unsigned. Note that in some situations (internal types, and
-- references to fields of variant records), it is not always possible
--- to construct this type in advance of its use. If Packed_Array_Type
--- is empty, then the necessary type is declared on the fly for each
--- reference to the array.
+-- to construct this type in advance of its use. If this field is empty,
+-- then the necessary type is declared on the fly for each reference to
+-- the array.
-- Parameter_Mode (synthesized)
-- Applies to formal parameter entities. This is a synonym for Ekind,
-- Is_Limited_Record (Flag25)
-- Is_Obsolescent (Flag153)
-- Is_Package_Body_Entity (Flag160)
- -- Is_Packed_Array_Type (Flag138)
+ -- Is_Packed_Array_Impl_Type (Flag138)
-- Is_Potentially_Use_Visible (Flag9)
-- Is_Preelaborated (Flag59)
-- Is_Primitive_Wrapper (Flag195)
-- Component_Type (Node20) (base type only)
-- Original_Array_Type (Node21)
-- Component_Size (Uint22) (base type only)
- -- Packed_Array_Type (Node23)
+ -- Packed_Array_Impl_Type (Node23)
-- Related_Array_Object (Node25)
-- Component_Alignment (special) (base type only)
-- Has_Component_Size_Clause (Flag68) (base type only)
-- String_Literal_Low_Bound (Node15)
-- String_Literal_Length (Uint16)
-- First_Index (Node17) (always Empty)
- -- Packed_Array_Type (Node23)
+ -- Packed_Array_Impl_Type (Node23)
-- (plus type attributes)
-- E_Subprogram_Body
function Is_Optional_Parameter (Id : E) return B;
function Is_Package_Body_Entity (Id : E) return B;
function Is_Packed (Id : E) return B;
- function Is_Packed_Array_Type (Id : E) return B;
+ function Is_Packed_Array_Impl_Type (Id : E) return B;
function Is_Potentially_Use_Visible (Id : E) return B;
function Is_Predicate_Function (Id : E) return B;
function Is_Predicate_Function_M (Id : E) return B;
function Overridden_Operation (Id : E) return E;
function PPC_Wrapper (Id : E) return E;
function Package_Instantiation (Id : E) return N;
- function Packed_Array_Type (Id : E) return E;
+ function Packed_Array_Impl_Type (Id : E) return E;
function Parent_Subtype (Id : E) return E;
function Part_Of_Constituents (Id : E) return L;
function Postcondition_Proc (Id : E) return E;
procedure Set_Is_Optional_Parameter (Id : E; V : B := True);
procedure Set_Is_Package_Body_Entity (Id : E; V : B := True);
procedure Set_Is_Packed (Id : E; V : B := True);
- procedure Set_Is_Packed_Array_Type (Id : E; V : B := True);
+ procedure Set_Is_Packed_Array_Impl_Type (Id : E; V : B := True);
procedure Set_Is_Potentially_Use_Visible (Id : E; V : B := True);
procedure Set_Is_Predicate_Function (Id : E; V : B := True);
procedure Set_Is_Predicate_Function_M (Id : E; V : B := True);
procedure Set_Overridden_Operation (Id : E; V : E);
procedure Set_PPC_Wrapper (Id : E; V : E);
procedure Set_Package_Instantiation (Id : E; V : N);
- procedure Set_Packed_Array_Type (Id : E; V : E);
+ procedure Set_Packed_Array_Impl_Type (Id : E; V : E);
procedure Set_Parent_Subtype (Id : E; V : E);
procedure Set_Part_Of_Constituents (Id : E; V : L);
procedure Set_Postcondition_Proc (Id : E; V : E);
pragma Inline (Is_Overloadable);
pragma Inline (Is_Package_Body_Entity);
pragma Inline (Is_Packed);
- pragma Inline (Is_Packed_Array_Type);
+ pragma Inline (Is_Packed_Array_Impl_Type);
pragma Inline (Is_Potentially_Use_Visible);
pragma Inline (Is_Predicate_Function);
pragma Inline (Is_Predicate_Function_M);
pragma Inline (Overridden_Operation);
pragma Inline (PPC_Wrapper);
pragma Inline (Package_Instantiation);
- pragma Inline (Packed_Array_Type);
+ pragma Inline (Packed_Array_Impl_Type);
pragma Inline (Parameter_Mode);
pragma Inline (Parent_Subtype);
pragma Inline (Part_Of_Constituents);
pragma Inline (Set_Is_Optional_Parameter);
pragma Inline (Set_Is_Package_Body_Entity);
pragma Inline (Set_Is_Packed);
- pragma Inline (Set_Is_Packed_Array_Type);
+ pragma Inline (Set_Is_Packed_Array_Impl_Type);
pragma Inline (Set_Is_Potentially_Use_Visible);
pragma Inline (Set_Is_Predicate_Function);
pragma Inline (Set_Is_Predicate_Function_M);
pragma Inline (Set_Overridden_Operation);
pragma Inline (Set_PPC_Wrapper);
pragma Inline (Set_Package_Instantiation);
- pragma Inline (Set_Packed_Array_Type);
+ pragma Inline (Set_Packed_Array_Impl_Type);
pragma Inline (Set_Parent_Subtype);
pragma Inline (Set_Part_Of_Constituents);
pragma Inline (Set_Postcondition_Proc);
if Present (Typ)
and then Is_Bit_Packed_Array (Typ)
- and then Is_Modular_Integer_Type (Packed_Array_Type (Typ))
+ and then Is_Modular_Integer_Type (Packed_Array_Impl_Type (Typ))
then
Append_To (New_Code,
Make_Assignment_Statement (Loc,
end if;
-- If two-dimensional, check whether it can be folded, and transformed
- -- into a one-dimensional aggregate for the Packed_Array_Type of the
- -- original type.
+ -- into a one-dimensional aggregate for the Packed_Array_Impl_Type of
+ -- the original type.
if Number_Dimensions (Typ) = 2 then
return Two_Dim_Packed_Array_Handled (N);
end if;
- if not Is_Modular_Integer_Type (Packed_Array_Type (Typ)) then
+ if not Is_Modular_Integer_Type (Packed_Array_Impl_Type (Typ)) then
return False;
end if;
Unchecked_Convert_To (Typ,
Make_Qualified_Expression (Loc,
Subtype_Mark =>
- New_Occurrence_Of (Packed_Array_Type (Typ), Loc),
+ New_Occurrence_Of (Packed_Array_Impl_Type (Typ), Loc),
Expression => Lit)));
Analyze_And_Resolve (N, Typ);
function Two_Dim_Packed_Array_Handled (N : Node_Id) return Boolean is
Loc : constant Source_Ptr := Sloc (N);
- Typ : constant Entity_Id := Etype (N);
- Ctyp : constant Entity_Id := Component_Type (Typ);
- Comp_Size : constant Int := UI_To_Int (Component_Size (Typ));
- Packed_Array : constant Entity_Id := Packed_Array_Type (Base_Type (Typ));
+ Typ : constant Entity_Id := Etype (N);
+ Ctyp : constant Entity_Id := Component_Type (Typ);
+ Comp_Size : constant Int := UI_To_Int (Component_Size (Typ));
+ Packed_Array : constant Entity_Id :=
+ Packed_Array_Impl_Type (Base_Type (Typ));
One_Comp : Node_Id;
-- Expression in original aggregate
when Attribute_First =>
-- If the prefix type is a constrained packed array type which
- -- already has a Packed_Array_Type representation defined, then
+ -- already has a Packed_Array_Impl_Type representation defined, then
-- replace this attribute with a direct reference to 'First of the
-- appropriate index subtype (since otherwise the back end will try
-- to give us the value of 'First for this implementation type).
when Attribute_Last =>
-- If the prefix type is a constrained packed array type which
- -- already has a Packed_Array_Type representation defined, then
+ -- already has a Packed_Array_Impl_Type representation defined, then
-- replace this attribute with a direct reference to 'Last of the
-- appropriate index subtype (since otherwise the back end will try
-- to give us the value of 'Last for this implementation type).
return;
-- If the prefix type is a constrained packed array type which
- -- already has a Packed_Array_Type representation defined, then
- -- replace this attribute with a direct reference to 'Range_Length
- -- of the appropriate index subtype (since otherwise the back end
- -- will try to give us the value of 'Length for this
- -- implementation type).
+ -- already has a Packed_Array_Impl_Type representation defined,
+ -- then replace this attribute with a reference to 'Range_Length
+ -- of the appropriate index subtype (since otherwise the
+ -- back end will try to give us the value of 'Length for
+ -- this implementation type).s
elsif Is_Constrained (Ptyp) then
Rewrite (N,
return Is_Array_Type (Arr)
and then Is_Constrained (Arr)
- and then Present (Packed_Array_Type (Arr));
+ and then Present (Packed_Array_Impl_Type (Arr));
end Is_Constrained_Packed_Array;
----------------------------------------
return;
end if;
- -- For a reference to a component of a bit packed array, we have to
- -- convert it to a reference to the corresponding Packed_Array_Type.
- -- We only want to do this for simple references, and not for:
+ -- For a reference to a component of a bit packed array, we convert it
+ -- to a reference to the corresponding Packed_Array_Impl_Type. We only
+ -- want to do this for simple references, and not for:
-- Left side of assignment, or prefix of left side of assignment, or
-- prefix of the prefix, to handle packed arrays of packed arrays,
-- --
-- B o d y --
-- --
--- Copyright (C) 1992-2013, Free Software Foundation, Inc. --
+-- Copyright (C) 1992-2014, Free Software Foundation, Inc. --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
Des_Type : Entity_Id;
begin
- if Present (Packed_Array_Type (Typ))
- and then Is_Array_Type (Packed_Array_Type (Typ))
- and then not Is_Constrained (Packed_Array_Type (Typ))
+ if Present (Packed_Array_Impl_Type (Typ))
+ and then Is_Array_Type (Packed_Array_Impl_Type (Typ))
+ and then not Is_Constrained (Packed_Array_Impl_Type (Typ))
then
return True;
-- --
-- B o d y --
-- --
--- Copyright (C) 1996-2013, Free Software Foundation, Inc. --
+-- Copyright (C) 1996-2014, Free Software Foundation, Inc. --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
end Get_Secondary_DT_External_Name;
---------------------------------
- -- Make_Packed_Array_Type_Name --
+ -- Make_Packed_Array_Impl_Type_Name --
---------------------------------
- function Make_Packed_Array_Type_Name
+ function Make_Packed_Array_Impl_Type_Name
(Typ : Entity_Id;
Csize : Uint)
return Name_Id
Add_Str_To_Name_Buffer ("___XP");
Add_Uint_To_Buffer (Csize);
return Name_Find;
- end Make_Packed_Array_Type_Name;
+ end Make_Packed_Array_Impl_Type_Name;
-----------------------------------
-- Output_Homonym_Numbers_Suffix --
-- --
-- S p e c --
-- --
--- Copyright (C) 1996-2012, Free Software Foundation, Inc. --
+-- Copyright (C) 1996-2014, Free Software Foundation, Inc. --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
-- Subprograms for Handling Packed Array Type Names --
------------------------------------------------------
- function Make_Packed_Array_Type_Name
+ function Make_Packed_Array_Impl_Type_Name
(Typ : Entity_Id;
Csize : Uint)
return Name_Id;
--
-- Atyp is the constrained array type (the actual subtype has been
-- computed if necessary to obtain the constraints, but this is still
- -- the original array type, not the Packed_Array_Type value).
+ -- the original array type, not the Packed_Array_Impl_Type value).
--
-- Obj is the object which is to be indexed. It is always of type Atyp.
--
begin
Convert_To_Actual_Subtype (Aexp);
Act_ST := Underlying_Type (Etype (Aexp));
- Create_Packed_Array_Type (Act_ST);
+ Create_Packed_Array_Impl_Type (Act_ST);
-- Just replace the etype with the packed array type. This works because
-- the expression will not be further analyzed, and Gigi considers the
-- more complex packed expressions in actuals is confused. Probably the
-- problem only remains for actuals in calls.
- Set_Etype (Aexp, Packed_Array_Type (Act_ST));
+ Set_Etype (Aexp, Packed_Array_Impl_Type (Act_ST));
if Is_Entity_Name (Aexp)
or else
end Convert_To_PAT_Type;
------------------------------
- -- Create_Packed_Array_Type --
+ -- Create_Packed_Array_Impl_Type --
------------------------------
- procedure Create_Packed_Array_Type (Typ : Entity_Id) is
+ procedure Create_Packed_Array_Impl_Type (Typ : Entity_Id) is
Loc : constant Source_Ptr := Sloc (Typ);
Ctyp : constant Entity_Id := Component_Type (Typ);
Csize : constant Uint := Component_Size (Typ);
end if;
Set_Is_Itype (PAT, True);
- Set_Packed_Array_Type (Typ, PAT);
+ Set_Packed_Array_Impl_Type (Typ, PAT);
Analyze (Decl, Suppress => All_Checks);
if Pushed_Scope then
Init_Alignment (PAT);
Set_Parent (PAT, Empty);
Set_Associated_Node_For_Itype (PAT, Typ);
- Set_Is_Packed_Array_Type (PAT, True);
+ Set_Is_Packed_Array_Impl_Type (PAT, True);
Set_Original_Array_Type (PAT, Typ);
-- For a non-bit-packed array, propagate reverse storage order
end if;
end Set_PB_Type;
- -- Start of processing for Create_Packed_Array_Type
+ -- Start of processing for Create_Packed_Array_Impl_Type
begin
-- If we already have a packed array type, nothing to do
- if Present (Packed_Array_Type (Typ)) then
+ if Present (Packed_Array_Impl_Type (Typ)) then
return;
end if;
if Present (Ancest)
and then Is_Array_Type (Ancest)
and then Is_Constrained (Ancest)
- and then Present (Packed_Array_Type (Ancest))
+ and then Present (Packed_Array_Impl_Type (Ancest))
then
- Set_Packed_Array_Type (Typ, Packed_Array_Type (Ancest));
+ Set_Packed_Array_Impl_Type (Typ, Packed_Array_Impl_Type (Ancest));
return;
end if;
end if;
Make_Defining_Identifier (Loc,
Chars => New_External_Name (Chars (Typ), 'P'));
- Set_Packed_Array_Type (Typ, PAT);
+ Set_Packed_Array_Impl_Type (Typ, PAT);
declare
Indexes : constant List_Id := New_List;
-- Set type as packed array type and install it
- Set_Is_Packed_Array_Type (PAT);
+ Set_Is_Packed_Array_Impl_Type (PAT);
Install_PAT;
return;
elsif not Is_Constrained (Typ) then
PAT :=
Make_Defining_Identifier (Loc,
- Chars => Make_Packed_Array_Type_Name (Typ, Csize));
+ Chars => Make_Packed_Array_Impl_Type_Name (Typ, Csize));
- Set_Packed_Array_Type (Typ, PAT);
+ Set_Packed_Array_Impl_Type (Typ, PAT);
Set_PB_Type;
Decl :=
else
PAT :=
Make_Defining_Identifier (Loc,
- Chars => Make_Packed_Array_Type_Name (Typ, Csize));
+ Chars => Make_Packed_Array_Impl_Type_Name (Typ, Csize));
- Set_Packed_Array_Type (Typ, PAT);
+ Set_Packed_Array_Impl_Type (Typ, PAT);
-- Build an expression for the length of the array in bits.
-- This is the product of the length of each of the dimensions
Set_Must_Be_On_Byte_Boundary (Typ);
end if;
end if;
- end Create_Packed_Array_Type;
+ end Create_Packed_Array_Impl_Type;
-----------------------------------
-- Expand_Bit_Packed_Element_Set --
Obj := Relocate_Node (Prefix (Lhs));
Convert_To_Actual_Subtype (Obj);
Atyp := Etype (Obj);
- PAT := Packed_Array_Type (Atyp);
+ PAT := Packed_Array_Impl_Type (Atyp);
Ctyp := Component_Type (Atyp);
Csiz := UI_To_Int (Component_Size (Atyp));
Obj := Relocate_Node (Prefix (N));
Convert_To_Actual_Subtype (Obj);
Atyp := Etype (Obj);
- PAT := Packed_Array_Type (Atyp);
+ PAT := Packed_Array_Impl_Type (Atyp);
Ctyp := Component_Type (Atyp);
Csiz := UI_To_Int (Component_Size (Atyp));
-- with its actual subtype. This actual subtype will have a packed array
-- type with appropriate bounds.
- if not Is_Constrained (Packed_Array_Type (Etype (Pfx))) then
+ if not Is_Constrained (Packed_Array_Impl_Type (Etype (Pfx))) then
Convert_To_Actual_Subtype (Pfx);
end if;
Rewrite (N,
Make_Indexed_Component (Sloc (N),
Prefix =>
- Unchecked_Convert_To (Packed_Array_Type (Etype (Pfx)), Pfx),
+ Unchecked_Convert_To (Packed_Array_Impl_Type (Etype (Pfx)), Pfx),
Expressions => Exprs));
Analyze_And_Resolve (N, Typ);
-- --
-- S p e c --
-- --
--- Copyright (C) 1992-2010, Free Software Foundation, Inc. --
+-- Copyright (C) 1992-2014, Free Software Foundation, Inc. --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
-------------------------------------
-- When a packed array (sub)type is frozen, we create a corresponding
- -- type that will be used to hold the bits of the packed value, and
- -- store the entity for this type in the Packed_Array_Type field of the
+ -- type that will be used to hold the bits of the packed value, and store
+ -- the entity for this type in the Packed_Array_Impl_Type field of the
-- E_Array_Type or E_Array_Subtype entity for the packed array.
-- This packed array type has the name xxxPn, where xxx is the name
-- Subprograms --
-----------------
- procedure Create_Packed_Array_Type (Typ : Entity_Id);
+ procedure Create_Packed_Array_Impl_Type (Typ : Entity_Id);
-- Typ is a array type or subtype to which pragma Pack applies. If the
- -- Packed_Array_Type field of Typ is already set, then the call has no
- -- effect, otherwise a suitable type or subtype is created and stored
- -- in the Packed_Array_Type field of Typ. This created type is an Itype
+ -- Packed_Array_Impl_Type field of Typ is already set, then the call has
+ -- no effect, otherwise a suitable type or subtype is created and stored in
+ -- the Packed_Array_Impl_Type field of Typ. This created type is an Itype
-- so that Gigi will simply elaborate and freeze the type on first use
-- (which is typically the definition of the corresponding array type).
--
elsif Esize (Typ) /= 0 and then Esize (Typ) <= 256 then
return False;
- elsif Is_Array_Type (Typ) and then Present (Packed_Array_Type (Typ)) then
- return May_Generate_Large_Temp (Packed_Array_Type (Typ));
+ elsif Is_Array_Type (Typ)
+ and then Present (Packed_Array_Impl_Type (Typ))
+ then
+ return May_Generate_Large_Temp (Packed_Array_Impl_Type (Typ));
-- We could do more here to find other small types ???
or else Is_Access_Type (Typ)
or else
(Is_Bit_Packed_Array (Typ)
- and then Is_Modular_Integer_Type (Packed_Array_Type (Typ)))
+ and then Is_Modular_Integer_Type (Packed_Array_Impl_Type (Typ)))
then
return False;
begin
return Is_Scalar_Type (UT)
or else (Is_Bit_Packed_Array (UT)
- and then Is_Scalar_Type (Packed_Array_Type (UT)));
+ and then Is_Scalar_Type (Packed_Array_Impl_Type (UT)));
end Represented_As_Scalar;
------------------------------
-- Conversions to and from packed array types are always ignored and
-- hence are safe.
- elsif Is_Packed_Array_Type (Otyp)
- or else Is_Packed_Array_Type (Ityp)
+ elsif Is_Packed_Array_Impl_Type (Otyp)
+ or else Is_Packed_Array_Impl_Type (Ityp)
then
return True;
end if;
-- directly, where all the information is at hand ???
if Is_Array_Type (Etype (Comp))
- and then Present (Packed_Array_Type (Etype (Comp)))
+ and then Present (Packed_Array_Impl_Type (Etype (Comp)))
then
declare
Ocomp : constant Entity_Id :=
if Is_Elementary_Type (Ctyp)
or else (Is_Array_Type (Ctyp)
- and then Present (Packed_Array_Type (Ctyp))
+ and then Present
+ (Packed_Array_Impl_Type (Ctyp))
and then Is_Modular_Integer_Type
- (Packed_Array_Type (Ctyp)))
+ (Packed_Array_Impl_Type (Ctyp)))
then
-- Packed size unknown if we have an atomic type
-- or a by reference type, since the back end
if Is_Packed (Arr)
and then Ekind (Arr) /= E_String_Literal_Subtype
then
- Create_Packed_Array_Type (Arr);
- Freeze_And_Append (Packed_Array_Type (Arr), N, Result);
+ Create_Packed_Array_Impl_Type (Arr);
+ Freeze_And_Append (Packed_Array_Impl_Type (Arr), N, Result);
-- Size information of packed array type is copied to the array
-- type, since this is really the representation. But do not
-- override explicit existing size values. If the ancestor subtype
- -- is constrained the packed_array_type will be inherited from it,
- -- but the size may have been provided already, and must not be
- -- overridden either.
+ -- is constrained the Packed_Array_Impl_Type will be inherited
+ -- from it, but the size may have been provided already, and
+ -- must not be overridden either.
if not Has_Size_Clause (Arr)
and then
(No (Ancestor_Subtype (Arr))
or else not Has_Size_Clause (Ancestor_Subtype (Arr)))
then
- Set_Esize (Arr, Esize (Packed_Array_Type (Arr)));
- Set_RM_Size (Arr, RM_Size (Packed_Array_Type (Arr)));
+ Set_Esize (Arr, Esize (Packed_Array_Impl_Type (Arr)));
+ Set_RM_Size (Arr, RM_Size (Packed_Array_Impl_Type (Arr)));
end if;
if not Has_Alignment_Clause (Arr) then
- Set_Alignment (Arr, Alignment (Packed_Array_Type (Arr)));
+ Set_Alignment (Arr, Alignment (Packed_Array_Impl_Type (Arr)));
end if;
end if;
then
exit;
elsif Is_Array_Type (Etype (Comp))
- and then Present (Packed_Array_Type (Etype (Comp)))
+ and then Present (Packed_Array_Impl_Type (Etype (Comp)))
then
Error_Msg_NE
("\packed array component& " &
elsif Is_Array_Type (Ctyp)
and then Is_Bit_Packed_Array (Ctyp)
- and then Is_Modular_Integer_Type (Packed_Array_Type (Ctyp))
+ and then Is_Modular_Integer_Type (Packed_Array_Impl_Type (Ctyp))
then
Forc := False;
-- array type if a packed array type has been created and the fields
-- are not currently set.
- if Is_Array_Type (E) and then Present (Packed_Array_Type (E)) then
+ if Is_Array_Type (E)
+ and then Present (Packed_Array_Impl_Type (E))
+ then
declare
- PAT : constant Entity_Id := Packed_Array_Type (E);
+ PAT : constant Entity_Id := Packed_Array_Impl_Type (E);
begin
if Unknown_Esize (E) then
-- front end layout, because otherwise this is always handled in the
-- backend.
- if Is_Packed_Array_Type (E) and then not Frontend_Layout_On_Target then
+ if Is_Packed_Array_Impl_Type (E)
+ and then not Frontend_Layout_On_Target
+ then
return;
-- If there is an alignment clause, then we respect it
and then Size_Known_At_Compile_Time (Component_Type (Typ)));
-- We always need a freeze node for a packed array subtype, so that we
- -- can build the Packed_Array_Type corresponding to the subtype. If
+ -- can build the Packed_Array_Impl_Type corresponding to the subtype. If
-- expansion is disabled, the packed array subtype is not built, and we
-- must not generate a freeze node for the type, or else it will appear
-- incomplete to gigi.
if Is_Bit_Packed_Array (P) then
Set_Is_Bit_Packed_Array (Base_Type (E));
- Set_Packed_Array_Type (E, Packed_Array_Type (P));
+ Set_Packed_Array_Impl_Type
+ (E, Packed_Array_Impl_Type (P));
end if;
end if;
Set_Component_Type (Implicit_Base, Element_Type);
Set_Has_Task (Implicit_Base, Has_Task (Element_Type));
Set_Component_Size (Implicit_Base, Uint_0);
- Set_Packed_Array_Type (Implicit_Base, Empty);
+ Set_Packed_Array_Impl_Type (Implicit_Base, Empty);
Set_Has_Controlled_Component
(Implicit_Base, Has_Controlled_Component
(Element_Type)
-- Common attributes for both cases
Set_Component_Type (Base_Type (T), Element_Type);
- Set_Packed_Array_Type (T, Empty);
+ Set_Packed_Array_Impl_Type (T, Empty);
if Aliased_Present (Component_Definition (Def)) then
Check_SPARK_Restriction
-- types created for packed entities do not need such, they are
-- compatible with the user-defined type.
- if Number_Dimensions (T) = 1 and then not Is_Packed_Array_Type (T) then
+ if Number_Dimensions (T) = 1
+ and then not Is_Packed_Array_Impl_Type (T)
+ then
New_Concatenation_Op (T);
end if;
Set_Is_Private_Composite (Def_Id, Is_Private_Composite (T));
Set_Is_Limited_Composite (Def_Id, Is_Limited_Composite (T));
- -- A subtype does not inherit the packed_array_type of is parent. We
- -- need to initialize the attribute because if Def_Id is previously
+ -- A subtype does not inherit the Packed_Array_Impl_Type of is parent.
+ -- We need to initialize the attribute because if Def_Id is previously
-- analyzed through a limited_with clause, it will have the attributes
-- of an incomplete type, one of which is an Elist that overlaps the
- -- Packed_Array_Type field.
+ -- Packed_Array_Impl_Type field.
- Set_Packed_Array_Type (Def_Id, Empty);
+ Set_Packed_Array_Impl_Type (Def_Id, Empty);
-- Build a freeze node if parent still needs one. Also make sure that
-- the Depends_On_Private status is set because the subtype will need
and then Is_Packed (Compon_Type)
and then Is_Frozen (Current_Scope)
then
- Create_Packed_Array_Type (Array_Comp);
+ Create_Packed_Array_Impl_Type (Array_Comp);
end if;
return Array_Comp;
Set_Convention (T1, Convention (T2));
Set_Is_Limited_Composite (T1, Is_Limited_Composite (T2));
Set_Is_Private_Composite (T1, Is_Private_Composite (T2));
- Set_Packed_Array_Type (T1, Packed_Array_Type (T2));
+ Set_Packed_Array_Impl_Type (T1, Packed_Array_Impl_Type (T2));
end Copy_Array_Subtype_Attributes;
-----------------------------------
if Is_Array_Type (Entyp)
and then Is_Packed (Entyp)
and then Present (Etype (N))
- and then Etype (N) = Packed_Array_Type (Entyp)
+ and then Etype (N) = Packed_Array_Impl_Type (Entyp)
then
null;
-- We do not attempt comparisons for packed arrays arrays represented as
-- modular types, where the semantics of comparison is quite different.
- elsif Is_Packed_Array_Type (Ltyp)
+ elsif Is_Packed_Array_Impl_Type (Ltyp)
and then Is_Modular_Integer_Type (Ltyp)
then
return Unknown;
-- We might want to try to evaluate these at compile time one
-- day, but we do not make that attempt now.
- if Is_Packed_Array_Type (Etype (Op)) then
+ if Is_Packed_Array_Impl_Type (Etype (Op)) then
return False;
end if;
then
if Nkind (Parent (N)) = N_Defining_Identifier
and then Is_Array_Type (Parent (N))
- and then Present (Packed_Array_Type (Parent (N)))
+ and then Present (Packed_Array_Impl_Type (Parent (N)))
and then Present (First_Rep_Item (Parent (N)))
then
Error_Msg_N
-- --
-- B o d y --
-- --
--- Copyright (C) 1992-2013, Free Software Foundation, Inc. --
+-- Copyright (C) 1992-2014, Free Software Foundation, Inc. --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
elsif Is_Array_Type (T2)
and then Is_Packed (T2)
- and then T1 = Packed_Array_Type (T2)
+ and then T1 = Packed_Array_Impl_Type (T2)
then
return True;
elsif Is_Array_Type (T1)
and then Is_Packed (T1)
- and then T2 = Packed_Array_Type (T1)
+ and then T2 = Packed_Array_Impl_Type (T1)
then
return True;
end if;
if Is_Packed (New_Itype) then
- Set_Packed_Array_Type (New_Itype,
+ Set_Packed_Array_Impl_Type (New_Itype,
Copy_Node_With_Replacement
- (Packed_Array_Type (New_Itype)));
+ (Packed_Array_Impl_Type (New_Itype)));
end if;
end if;
end Copy_Itype_With_Replacement;
end if;
if Is_Packed (Old_Itype) then
- Visit_Field (Union_Id (Packed_Array_Type (Old_Itype)),
+ Visit_Field (Union_Id (Packed_Array_Impl_Type (Old_Itype)),
Old_Itype);
end if;
end if;
-- also need it for the former if we need it for the latter.
if Is_Packed (T) then
- Set_Debug_Info_Needed_If_Not_Set (Packed_Array_Type (T));
+ Set_Debug_Info_Needed_If_Not_Set (Packed_Array_Impl_Type (T));
end if;
- if Is_Packed_Array_Type (T) then
+ if Is_Packed_Array_Impl_Type (T) then
Set_Debug_Info_Needed_If_Not_Set (Original_Array_Type (T));
end if;
projects / thirdparty / gcc.git / commitdiff
