URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [ada/] [exp_pakd.adb] - Rev 729
Go to most recent revision | Compare with Previous | Blame | View Log
------------------------------------------------------------------------------ -- -- -- GNAT COMPILER COMPONENTS -- -- -- -- E X P _ P A K D -- -- -- -- B o d y -- -- -- -- Copyright (C) 1992-2011, 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- -- -- ware Foundation; either version 3, or (at your option) any later ver- -- -- sion. GNAT is distributed in the hope that it will be useful, but WITH- -- -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -- -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- -- for more details. You should have received a copy of the GNU General -- -- Public License distributed with GNAT; see file COPYING3. If not, go to -- -- http://www.gnu.org/licenses for a complete copy of the license. -- -- -- -- GNAT was originally developed by the GNAT team at New York University. -- -- Extensive contributions were provided by Ada Core Technologies Inc. -- -- -- ------------------------------------------------------------------------------ with Atree; use Atree; with Checks; use Checks; with Einfo; use Einfo; with Errout; use Errout; with Exp_Dbug; use Exp_Dbug; with Exp_Util; use Exp_Util; with Layout; use Layout; with Namet; use Namet; with Nlists; use Nlists; with Nmake; use Nmake; with Opt; use Opt; with Rtsfind; use Rtsfind; with Sem; use Sem; with Sem_Aux; use Sem_Aux; with Sem_Ch3; use Sem_Ch3; with Sem_Ch8; use Sem_Ch8; with Sem_Ch13; use Sem_Ch13; with Sem_Eval; use Sem_Eval; with Sem_Res; use Sem_Res; with Sem_Util; use Sem_Util; with Sinfo; use Sinfo; with Snames; use Snames; with Stand; use Stand; with Targparm; use Targparm; with Tbuild; use Tbuild; with Ttypes; use Ttypes; with Uintp; use Uintp; package body Exp_Pakd is --------------------------- -- Endian Considerations -- --------------------------- -- As described in the specification, bit numbering in a packed array -- is consistent with bit numbering in a record representation clause, -- and hence dependent on the endianness of the machine: -- For little-endian machines, element zero is at the right hand end -- (low order end) of a bit field. -- For big-endian machines, element zero is at the left hand end -- (high order end) of a bit field. -- The shifts that are used to right justify a field therefore differ in -- the two cases. For the little-endian case, we can simply use the bit -- number (i.e. the element number * element size) as the count for a right -- shift. For the big-endian case, we have to subtract the shift count from -- an appropriate constant to use in the right shift. We use rotates -- instead of shifts (which is necessary in the store case to preserve -- other fields), and we expect that the backend will be able to change the -- right rotate into a left rotate, avoiding the subtract, if the machine -- architecture provides such an instruction. ---------------------------------------------- -- Entity Tables for Packed Access Routines -- ---------------------------------------------- -- For the cases of component size = 3,5-7,9-15,17-31,33-63 we call library -- routines. This table provides the entity for the proper routine. type E_Array is array (Int range 01 .. 63) of RE_Id; -- Array of Bits_nn entities. Note that we do not use library routines -- for the 8-bit and 16-bit cases, but we still fill in the table, using -- entries from System.Unsigned, because we also use this table for -- certain special unchecked conversions in the big-endian case. Bits_Id : constant E_Array := (01 => RE_Bits_1, 02 => RE_Bits_2, 03 => RE_Bits_03, 04 => RE_Bits_4, 05 => RE_Bits_05, 06 => RE_Bits_06, 07 => RE_Bits_07, 08 => RE_Unsigned_8, 09 => RE_Bits_09, 10 => RE_Bits_10, 11 => RE_Bits_11, 12 => RE_Bits_12, 13 => RE_Bits_13, 14 => RE_Bits_14, 15 => RE_Bits_15, 16 => RE_Unsigned_16, 17 => RE_Bits_17, 18 => RE_Bits_18, 19 => RE_Bits_19, 20 => RE_Bits_20, 21 => RE_Bits_21, 22 => RE_Bits_22, 23 => RE_Bits_23, 24 => RE_Bits_24, 25 => RE_Bits_25, 26 => RE_Bits_26, 27 => RE_Bits_27, 28 => RE_Bits_28, 29 => RE_Bits_29, 30 => RE_Bits_30, 31 => RE_Bits_31, 32 => RE_Unsigned_32, 33 => RE_Bits_33, 34 => RE_Bits_34, 35 => RE_Bits_35, 36 => RE_Bits_36, 37 => RE_Bits_37, 38 => RE_Bits_38, 39 => RE_Bits_39, 40 => RE_Bits_40, 41 => RE_Bits_41, 42 => RE_Bits_42, 43 => RE_Bits_43, 44 => RE_Bits_44, 45 => RE_Bits_45, 46 => RE_Bits_46, 47 => RE_Bits_47, 48 => RE_Bits_48, 49 => RE_Bits_49, 50 => RE_Bits_50, 51 => RE_Bits_51, 52 => RE_Bits_52, 53 => RE_Bits_53, 54 => RE_Bits_54, 55 => RE_Bits_55, 56 => RE_Bits_56, 57 => RE_Bits_57, 58 => RE_Bits_58, 59 => RE_Bits_59, 60 => RE_Bits_60, 61 => RE_Bits_61, 62 => RE_Bits_62, 63 => RE_Bits_63); -- Array of Get routine entities. These are used to obtain an element from -- a packed array. The N'th entry is used to obtain elements from a packed -- array whose component size is N. RE_Null is used as a null entry, for -- the cases where a library routine is not used. Get_Id : constant E_Array := (01 => RE_Null, 02 => RE_Null, 03 => RE_Get_03, 04 => RE_Null, 05 => RE_Get_05, 06 => RE_Get_06, 07 => RE_Get_07, 08 => RE_Null, 09 => RE_Get_09, 10 => RE_Get_10, 11 => RE_Get_11, 12 => RE_Get_12, 13 => RE_Get_13, 14 => RE_Get_14, 15 => RE_Get_15, 16 => RE_Null, 17 => RE_Get_17, 18 => RE_Get_18, 19 => RE_Get_19, 20 => RE_Get_20, 21 => RE_Get_21, 22 => RE_Get_22, 23 => RE_Get_23, 24 => RE_Get_24, 25 => RE_Get_25, 26 => RE_Get_26, 27 => RE_Get_27, 28 => RE_Get_28, 29 => RE_Get_29, 30 => RE_Get_30, 31 => RE_Get_31, 32 => RE_Null, 33 => RE_Get_33, 34 => RE_Get_34, 35 => RE_Get_35, 36 => RE_Get_36, 37 => RE_Get_37, 38 => RE_Get_38, 39 => RE_Get_39, 40 => RE_Get_40, 41 => RE_Get_41, 42 => RE_Get_42, 43 => RE_Get_43, 44 => RE_Get_44, 45 => RE_Get_45, 46 => RE_Get_46, 47 => RE_Get_47, 48 => RE_Get_48, 49 => RE_Get_49, 50 => RE_Get_50, 51 => RE_Get_51, 52 => RE_Get_52, 53 => RE_Get_53, 54 => RE_Get_54, 55 => RE_Get_55, 56 => RE_Get_56, 57 => RE_Get_57, 58 => RE_Get_58, 59 => RE_Get_59, 60 => RE_Get_60, 61 => RE_Get_61, 62 => RE_Get_62, 63 => RE_Get_63); -- Array of Get routine entities to be used in the case where the packed -- array is itself a component of a packed structure, and therefore may not -- be fully aligned. This only affects the even sizes, since for the odd -- sizes, we do not get any fixed alignment in any case. GetU_Id : constant E_Array := (01 => RE_Null, 02 => RE_Null, 03 => RE_Get_03, 04 => RE_Null, 05 => RE_Get_05, 06 => RE_GetU_06, 07 => RE_Get_07, 08 => RE_Null, 09 => RE_Get_09, 10 => RE_GetU_10, 11 => RE_Get_11, 12 => RE_GetU_12, 13 => RE_Get_13, 14 => RE_GetU_14, 15 => RE_Get_15, 16 => RE_Null, 17 => RE_Get_17, 18 => RE_GetU_18, 19 => RE_Get_19, 20 => RE_GetU_20, 21 => RE_Get_21, 22 => RE_GetU_22, 23 => RE_Get_23, 24 => RE_GetU_24, 25 => RE_Get_25, 26 => RE_GetU_26, 27 => RE_Get_27, 28 => RE_GetU_28, 29 => RE_Get_29, 30 => RE_GetU_30, 31 => RE_Get_31, 32 => RE_Null, 33 => RE_Get_33, 34 => RE_GetU_34, 35 => RE_Get_35, 36 => RE_GetU_36, 37 => RE_Get_37, 38 => RE_GetU_38, 39 => RE_Get_39, 40 => RE_GetU_40, 41 => RE_Get_41, 42 => RE_GetU_42, 43 => RE_Get_43, 44 => RE_GetU_44, 45 => RE_Get_45, 46 => RE_GetU_46, 47 => RE_Get_47, 48 => RE_GetU_48, 49 => RE_Get_49, 50 => RE_GetU_50, 51 => RE_Get_51, 52 => RE_GetU_52, 53 => RE_Get_53, 54 => RE_GetU_54, 55 => RE_Get_55, 56 => RE_GetU_56, 57 => RE_Get_57, 58 => RE_GetU_58, 59 => RE_Get_59, 60 => RE_GetU_60, 61 => RE_Get_61, 62 => RE_GetU_62, 63 => RE_Get_63); -- Array of Set routine entities. These are used to assign an element of a -- packed array. The N'th entry is used to assign elements for a packed -- array whose component size is N. RE_Null is used as a null entry, for -- the cases where a library routine is not used. Set_Id : constant E_Array := (01 => RE_Null, 02 => RE_Null, 03 => RE_Set_03, 04 => RE_Null, 05 => RE_Set_05, 06 => RE_Set_06, 07 => RE_Set_07, 08 => RE_Null, 09 => RE_Set_09, 10 => RE_Set_10, 11 => RE_Set_11, 12 => RE_Set_12, 13 => RE_Set_13, 14 => RE_Set_14, 15 => RE_Set_15, 16 => RE_Null, 17 => RE_Set_17, 18 => RE_Set_18, 19 => RE_Set_19, 20 => RE_Set_20, 21 => RE_Set_21, 22 => RE_Set_22, 23 => RE_Set_23, 24 => RE_Set_24, 25 => RE_Set_25, 26 => RE_Set_26, 27 => RE_Set_27, 28 => RE_Set_28, 29 => RE_Set_29, 30 => RE_Set_30, 31 => RE_Set_31, 32 => RE_Null, 33 => RE_Set_33, 34 => RE_Set_34, 35 => RE_Set_35, 36 => RE_Set_36, 37 => RE_Set_37, 38 => RE_Set_38, 39 => RE_Set_39, 40 => RE_Set_40, 41 => RE_Set_41, 42 => RE_Set_42, 43 => RE_Set_43, 44 => RE_Set_44, 45 => RE_Set_45, 46 => RE_Set_46, 47 => RE_Set_47, 48 => RE_Set_48, 49 => RE_Set_49, 50 => RE_Set_50, 51 => RE_Set_51, 52 => RE_Set_52, 53 => RE_Set_53, 54 => RE_Set_54, 55 => RE_Set_55, 56 => RE_Set_56, 57 => RE_Set_57, 58 => RE_Set_58, 59 => RE_Set_59, 60 => RE_Set_60, 61 => RE_Set_61, 62 => RE_Set_62, 63 => RE_Set_63); -- Array of Set routine entities to be used in the case where the packed -- array is itself a component of a packed structure, and therefore may not -- be fully aligned. This only affects the even sizes, since for the odd -- sizes, we do not get any fixed alignment in any case. SetU_Id : constant E_Array := (01 => RE_Null, 02 => RE_Null, 03 => RE_Set_03, 04 => RE_Null, 05 => RE_Set_05, 06 => RE_SetU_06, 07 => RE_Set_07, 08 => RE_Null, 09 => RE_Set_09, 10 => RE_SetU_10, 11 => RE_Set_11, 12 => RE_SetU_12, 13 => RE_Set_13, 14 => RE_SetU_14, 15 => RE_Set_15, 16 => RE_Null, 17 => RE_Set_17, 18 => RE_SetU_18, 19 => RE_Set_19, 20 => RE_SetU_20, 21 => RE_Set_21, 22 => RE_SetU_22, 23 => RE_Set_23, 24 => RE_SetU_24, 25 => RE_Set_25, 26 => RE_SetU_26, 27 => RE_Set_27, 28 => RE_SetU_28, 29 => RE_Set_29, 30 => RE_SetU_30, 31 => RE_Set_31, 32 => RE_Null, 33 => RE_Set_33, 34 => RE_SetU_34, 35 => RE_Set_35, 36 => RE_SetU_36, 37 => RE_Set_37, 38 => RE_SetU_38, 39 => RE_Set_39, 40 => RE_SetU_40, 41 => RE_Set_41, 42 => RE_SetU_42, 43 => RE_Set_43, 44 => RE_SetU_44, 45 => RE_Set_45, 46 => RE_SetU_46, 47 => RE_Set_47, 48 => RE_SetU_48, 49 => RE_Set_49, 50 => RE_SetU_50, 51 => RE_Set_51, 52 => RE_SetU_52, 53 => RE_Set_53, 54 => RE_SetU_54, 55 => RE_Set_55, 56 => RE_SetU_56, 57 => RE_Set_57, 58 => RE_SetU_58, 59 => RE_Set_59, 60 => RE_SetU_60, 61 => RE_Set_61, 62 => RE_SetU_62, 63 => RE_Set_63); ----------------------- -- Local Subprograms -- ----------------------- procedure Compute_Linear_Subscript (Atyp : Entity_Id; N : Node_Id; Subscr : out Node_Id); -- Given a constrained array type Atyp, and an indexed component node N -- referencing an array object of this type, build an expression of type -- Standard.Integer representing the zero-based linear subscript value. -- This expression includes any required range checks. procedure Convert_To_PAT_Type (Aexp : Node_Id); -- Given an expression of a packed array type, builds a corresponding -- expression whose type is the implementation type used to represent -- the packed array. Aexp is analyzed and resolved on entry and on exit. procedure Get_Base_And_Bit_Offset (N : Node_Id; Base : out Node_Id; Offset : out Node_Id); -- Given a node N for a name which involves a packed array reference, -- return the base object of the reference and build an expression of -- type Standard.Integer representing the zero-based offset in bits -- from Base'Address to the first bit of the reference. function Known_Aligned_Enough (Obj : Node_Id; Csiz : Nat) return Boolean; -- There are two versions of the Set routines, the ones used when the -- object is known to be sufficiently well aligned given the number of -- bits, and the ones used when the object is not known to be aligned. -- This routine is used to determine which set to use. Obj is a reference -- to the object, and Csiz is the component size of the packed array. -- True is returned if the alignment of object is known to be sufficient, -- defined as 1 for odd bit sizes, 4 for bit sizes divisible by 4, and -- 2 otherwise. function Make_Shift_Left (N : Node_Id; S : Node_Id) return Node_Id; -- Build a left shift node, checking for the case of a shift count of zero function Make_Shift_Right (N : Node_Id; S : Node_Id) return Node_Id; -- Build a right shift node, checking for the case of a shift count of zero function RJ_Unchecked_Convert_To (Typ : Entity_Id; Expr : Node_Id) return Node_Id; -- The packed array code does unchecked conversions which in some cases -- may involve non-discrete types with differing sizes. The semantics of -- such conversions is potentially endian dependent, and the effect we -- want here for such a conversion is to do the conversion in size as -- though numeric items are involved, and we extend or truncate on the -- left side. This happens naturally in the little-endian case, but in -- the big endian case we can get left justification, when what we want -- is right justification. This routine does the unchecked conversion in -- a stepwise manner to ensure that it gives the expected result. Hence -- the name (RJ = Right justified). The parameters Typ and Expr are as -- for the case of a normal Unchecked_Convert_To call. procedure Setup_Enumeration_Packed_Array_Reference (N : Node_Id); -- This routine is called in the Get and Set case for arrays that are -- packed but not bit-packed, meaning that they have at least one -- subscript that is of an enumeration type with a non-standard -- representation. This routine modifies the given node to properly -- reference the corresponding packed array type. procedure Setup_Inline_Packed_Array_Reference (N : Node_Id; Atyp : Entity_Id; Obj : in out Node_Id; Cmask : out Uint; Shift : out Node_Id); -- This procedure performs common processing on the N_Indexed_Component -- parameter given as N, whose prefix is a reference to a packed array. -- This is used for the get and set when the component size is 1,2,4 -- or for other component sizes when the packed array type is a modular -- type (i.e. the cases that are handled with inline code). -- -- On entry: -- -- N is the N_Indexed_Component node for the packed array reference -- -- 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). -- -- Obj is the object which is to be indexed. It is always of type Atyp. -- -- On return: -- -- Obj is the object containing the desired bit field. It is of type -- Unsigned, Long_Unsigned, or Long_Long_Unsigned, and is either the -- entire value, for the small static case, or the proper selected byte -- from the array in the large or dynamic case. This node is analyzed -- and resolved on return. -- -- Shift is a node representing the shift count to be used in the -- rotate right instruction that positions the field for access. -- This node is analyzed and resolved on return. -- -- Cmask is a mask corresponding to the width of the component field. -- Its value is 2 ** Csize - 1 (e.g. 2#1111# for component size of 4). -- -- Note: in some cases the call to this routine may generate actions -- (for handling multi-use references and the generation of the packed -- array type on the fly). Such actions are inserted into the tree -- directly using Insert_Action. ------------------------------ -- Compute_Linear_Subscript -- ------------------------------ procedure Compute_Linear_Subscript (Atyp : Entity_Id; N : Node_Id; Subscr : out Node_Id) is Loc : constant Source_Ptr := Sloc (N); Oldsub : Node_Id; Newsub : Node_Id; Indx : Node_Id; Styp : Entity_Id; begin Subscr := Empty; -- Loop through dimensions Indx := First_Index (Atyp); Oldsub := First (Expressions (N)); while Present (Indx) loop Styp := Etype (Indx); Newsub := Relocate_Node (Oldsub); -- Get expression for the subscript value. First, if Do_Range_Check -- is set on a subscript, then we must do a range check against the -- original bounds (not the bounds of the packed array type). We do -- this by introducing a subtype conversion. if Do_Range_Check (Newsub) and then Etype (Newsub) /= Styp then Newsub := Convert_To (Styp, Newsub); end if; -- Now evolve the expression for the subscript. First convert -- the subscript to be zero based and of an integer type. -- Case of integer type, where we just subtract to get lower bound if Is_Integer_Type (Styp) then -- If length of integer type is smaller than standard integer, -- then we convert to integer first, then do the subtract -- Integer (subscript) - Integer (Styp'First) if Esize (Styp) < Esize (Standard_Integer) then Newsub := Make_Op_Subtract (Loc, Left_Opnd => Convert_To (Standard_Integer, Newsub), Right_Opnd => Convert_To (Standard_Integer, Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Styp, Loc), Attribute_Name => Name_First))); -- For larger integer types, subtract first, then convert to -- integer, this deals with strange long long integer bounds. -- Integer (subscript - Styp'First) else Newsub := Convert_To (Standard_Integer, Make_Op_Subtract (Loc, Left_Opnd => Newsub, Right_Opnd => Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Styp, Loc), Attribute_Name => Name_First))); end if; -- For the enumeration case, we have to use 'Pos to get the value -- to work with before subtracting the lower bound. -- Integer (Styp'Pos (subscr)) - Integer (Styp'Pos (Styp'First)); -- This is not quite right for bizarre cases where the size of the -- enumeration type is > Integer'Size bits due to rep clause ??? else pragma Assert (Is_Enumeration_Type (Styp)); Newsub := Make_Op_Subtract (Loc, Left_Opnd => Convert_To (Standard_Integer, Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Styp, Loc), Attribute_Name => Name_Pos, Expressions => New_List (Newsub))), Right_Opnd => Convert_To (Standard_Integer, Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Styp, Loc), Attribute_Name => Name_Pos, Expressions => New_List ( Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Styp, Loc), Attribute_Name => Name_First))))); end if; Set_Paren_Count (Newsub, 1); -- For the first subscript, we just copy that subscript value if No (Subscr) then Subscr := Newsub; -- Otherwise, we must multiply what we already have by the current -- stride and then add in the new value to the evolving subscript. else Subscr := Make_Op_Add (Loc, Left_Opnd => Make_Op_Multiply (Loc, Left_Opnd => Subscr, Right_Opnd => Make_Attribute_Reference (Loc, Attribute_Name => Name_Range_Length, Prefix => New_Occurrence_Of (Styp, Loc))), Right_Opnd => Newsub); end if; -- Move to next subscript Next_Index (Indx); Next (Oldsub); end loop; end Compute_Linear_Subscript; ------------------------- -- Convert_To_PAT_Type -- ------------------------- -- The PAT is always obtained from the actual subtype procedure Convert_To_PAT_Type (Aexp : Node_Id) is Act_ST : Entity_Id; begin Convert_To_Actual_Subtype (Aexp); Act_ST := Underlying_Type (Etype (Aexp)); Create_Packed_Array_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 -- two types equivalent in any case. -- This is not strictly the case ??? If the reference is an actual in -- call, the expansion of the prefix is delayed, and must be reanalyzed, -- see Reset_Packed_Prefix. On the other hand, if the prefix is a simple -- array reference, reanalysis can produce spurious type errors when the -- PAT type is replaced again with the original type of the array. Same -- for the case of a dereference. Ditto for function calls: expansion -- may introduce additional actuals which will trigger errors if call is -- reanalyzed. The following is correct and minimal, but the handling of -- 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)); if Is_Entity_Name (Aexp) or else (Nkind (Aexp) = N_Indexed_Component and then Is_Entity_Name (Prefix (Aexp))) or else Nkind_In (Aexp, N_Explicit_Dereference, N_Function_Call) then Set_Analyzed (Aexp); end if; end Convert_To_PAT_Type; ------------------------------ -- Create_Packed_Array_Type -- ------------------------------ procedure Create_Packed_Array_Type (Typ : Entity_Id) is Loc : constant Source_Ptr := Sloc (Typ); Ctyp : constant Entity_Id := Component_Type (Typ); Csize : constant Uint := Component_Size (Typ); Ancest : Entity_Id; PB_Type : Entity_Id; PASize : Uint; Decl : Node_Id; PAT : Entity_Id; Len_Dim : Node_Id; Len_Expr : Node_Id; Len_Bits : Uint; Bits_U1 : Node_Id; PAT_High : Node_Id; Btyp : Entity_Id; Lit : Node_Id; procedure Install_PAT; -- This procedure is called with Decl set to the declaration for the -- packed array type. It creates the type and installs it as required. procedure Set_PB_Type; -- Sets PB_Type to Packed_Bytes{1,2,4} as required by the alignment -- requirements (see documentation in the spec of this package). ----------------- -- Install_PAT -- ----------------- procedure Install_PAT is Pushed_Scope : Boolean := False; begin -- We do not want to put the declaration we have created in the tree -- since it is often hard, and sometimes impossible to find a proper -- place for it (the impossible case arises for a packed array type -- with bounds depending on the discriminant, a declaration cannot -- be put inside the record, and the reference to the discriminant -- cannot be outside the record). -- The solution is to analyze the declaration while temporarily -- attached to the tree at an appropriate point, and then we install -- the resulting type as an Itype in the packed array type field of -- the original type, so that no explicit declaration is required. -- Note: the packed type is created in the scope of its parent -- type. There are at least some cases where the current scope -- is deeper, and so when this is the case, we temporarily reset -- the scope for the definition. This is clearly safe, since the -- first use of the packed array type will be the implicit -- reference from the corresponding unpacked type when it is -- elaborated. if Is_Itype (Typ) then Set_Parent (Decl, Associated_Node_For_Itype (Typ)); else Set_Parent (Decl, Declaration_Node (Typ)); end if; if Scope (Typ) /= Current_Scope then Push_Scope (Scope (Typ)); Pushed_Scope := True; end if; Set_Is_Itype (PAT, True); Set_Packed_Array_Type (Typ, PAT); Analyze (Decl, Suppress => All_Checks); if Pushed_Scope then Pop_Scope; end if; -- Set Esize and RM_Size to the actual size of the packed object -- Do not reset RM_Size if already set, as happens in the case of -- a modular type. if Unknown_Esize (PAT) then Set_Esize (PAT, PASize); end if; if Unknown_RM_Size (PAT) then Set_RM_Size (PAT, PASize); end if; Adjust_Esize_Alignment (PAT); -- Set remaining fields of packed array type Init_Alignment (PAT); Set_Parent (PAT, Empty); Set_Associated_Node_For_Itype (PAT, Typ); Set_Is_Packed_Array_Type (PAT, True); Set_Original_Array_Type (PAT, Typ); -- We definitely do not want to delay freezing for packed array -- types. This is of particular importance for the itypes that -- are generated for record components depending on discriminants -- where there is no place to put the freeze node. Set_Has_Delayed_Freeze (PAT, False); Set_Has_Delayed_Freeze (Etype (PAT), False); -- If we did allocate a freeze node, then clear out the reference -- since it is obsolete (should we delete the freeze node???) Set_Freeze_Node (PAT, Empty); Set_Freeze_Node (Etype (PAT), Empty); end Install_PAT; ----------------- -- Set_PB_Type -- ----------------- procedure Set_PB_Type is begin -- If the user has specified an explicit alignment for the -- type or component, take it into account. if Csize <= 2 or else Csize = 4 or else Csize mod 2 /= 0 or else Alignment (Typ) = 1 or else Component_Alignment (Typ) = Calign_Storage_Unit then PB_Type := RTE (RE_Packed_Bytes1); elsif Csize mod 4 /= 0 or else Alignment (Typ) = 2 then PB_Type := RTE (RE_Packed_Bytes2); else PB_Type := RTE (RE_Packed_Bytes4); end if; end Set_PB_Type; -- Start of processing for Create_Packed_Array_Type begin -- If we already have a packed array type, nothing to do if Present (Packed_Array_Type (Typ)) then return; end if; -- If our immediate ancestor subtype is constrained, and it already -- has a packed array type, then just share the same type, since the -- bounds must be the same. If the ancestor is not an array type but -- a private type, as can happen with multiple instantiations, create -- a new packed type, to avoid privacy issues. if Ekind (Typ) = E_Array_Subtype then Ancest := Ancestor_Subtype (Typ); if Present (Ancest) and then Is_Array_Type (Ancest) and then Is_Constrained (Ancest) and then Present (Packed_Array_Type (Ancest)) then Set_Packed_Array_Type (Typ, Packed_Array_Type (Ancest)); return; end if; end if; -- We preset the result type size from the size of the original array -- type, since this size clearly belongs to the packed array type. The -- size of the conceptual unpacked type is always set to unknown. PASize := RM_Size (Typ); -- Case of an array where at least one index is of an enumeration -- type with a non-standard representation, but the component size -- is not appropriate for bit packing. This is the case where we -- have Is_Packed set (we would never be in this unit otherwise), -- but Is_Bit_Packed_Array is false. -- Note that if the component size is appropriate for bit packing, -- then the circuit for the computation of the subscript properly -- deals with the non-standard enumeration type case by taking the -- Pos anyway. if not Is_Bit_Packed_Array (Typ) then -- Here we build a declaration: -- type tttP is array (index1, index2, ...) of component_type -- where index1, index2, are the index types. These are the same -- as the index types of the original array, except for the non- -- standard representation enumeration type case, where we have -- two subcases. -- For the unconstrained array case, we use -- Natural range <> -- For the constrained case, we use -- Natural range Enum_Type'Pos (Enum_Type'First) .. -- Enum_Type'Pos (Enum_Type'Last); PAT := Make_Defining_Identifier (Loc, Chars => New_External_Name (Chars (Typ), 'P')); Set_Packed_Array_Type (Typ, PAT); declare Indexes : constant List_Id := New_List; Indx : Node_Id; Indx_Typ : Entity_Id; Enum_Case : Boolean; Typedef : Node_Id; begin Indx := First_Index (Typ); while Present (Indx) loop Indx_Typ := Etype (Indx); Enum_Case := Is_Enumeration_Type (Indx_Typ) and then Has_Non_Standard_Rep (Indx_Typ); -- Unconstrained case if not Is_Constrained (Typ) then if Enum_Case then Indx_Typ := Standard_Natural; end if; Append_To (Indexes, New_Occurrence_Of (Indx_Typ, Loc)); -- Constrained case else if not Enum_Case then Append_To (Indexes, New_Occurrence_Of (Indx_Typ, Loc)); else Append_To (Indexes, Make_Subtype_Indication (Loc, Subtype_Mark => New_Occurrence_Of (Standard_Natural, Loc), Constraint => Make_Range_Constraint (Loc, Range_Expression => Make_Range (Loc, Low_Bound => Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Indx_Typ, Loc), Attribute_Name => Name_Pos, Expressions => New_List ( Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Indx_Typ, Loc), Attribute_Name => Name_First))), High_Bound => Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Indx_Typ, Loc), Attribute_Name => Name_Pos, Expressions => New_List ( Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Indx_Typ, Loc), Attribute_Name => Name_Last))))))); end if; end if; Next_Index (Indx); end loop; if not Is_Constrained (Typ) then Typedef := Make_Unconstrained_Array_Definition (Loc, Subtype_Marks => Indexes, Component_Definition => Make_Component_Definition (Loc, Aliased_Present => False, Subtype_Indication => New_Occurrence_Of (Ctyp, Loc))); else Typedef := Make_Constrained_Array_Definition (Loc, Discrete_Subtype_Definitions => Indexes, Component_Definition => Make_Component_Definition (Loc, Aliased_Present => False, Subtype_Indication => New_Occurrence_Of (Ctyp, Loc))); end if; Decl := Make_Full_Type_Declaration (Loc, Defining_Identifier => PAT, Type_Definition => Typedef); end; -- Set type as packed array type and install it Set_Is_Packed_Array_Type (PAT); Install_PAT; return; -- Case of bit-packing required for unconstrained array. We create -- a subtype that is equivalent to use Packed_Bytes{1,2,4} as needed. elsif not Is_Constrained (Typ) then PAT := Make_Defining_Identifier (Loc, Chars => Make_Packed_Array_Type_Name (Typ, Csize)); Set_Packed_Array_Type (Typ, PAT); Set_PB_Type; Decl := Make_Subtype_Declaration (Loc, Defining_Identifier => PAT, Subtype_Indication => New_Occurrence_Of (PB_Type, Loc)); Install_PAT; return; -- Remaining code is for the case of bit-packing for constrained array -- The name of the packed array subtype is -- ttt___Xsss -- where sss is the component size in bits and ttt is the name of -- the parent packed type. else PAT := Make_Defining_Identifier (Loc, Chars => Make_Packed_Array_Type_Name (Typ, Csize)); Set_Packed_Array_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 declare J : Nat := 1; begin Len_Expr := Empty; -- suppress junk warning loop Len_Dim := Make_Attribute_Reference (Loc, Attribute_Name => Name_Length, Prefix => New_Occurrence_Of (Typ, Loc), Expressions => New_List ( Make_Integer_Literal (Loc, J))); if J = 1 then Len_Expr := Len_Dim; else Len_Expr := Make_Op_Multiply (Loc, Left_Opnd => Len_Expr, Right_Opnd => Len_Dim); end if; J := J + 1; exit when J > Number_Dimensions (Typ); end loop; end; -- Temporarily attach the length expression to the tree and analyze -- and resolve it, so that we can test its value. We assume that the -- total length fits in type Integer. This expression may involve -- discriminants, so we treat it as a default/per-object expression. Set_Parent (Len_Expr, Typ); Preanalyze_Spec_Expression (Len_Expr, Standard_Long_Long_Integer); -- Use a modular type if possible. We can do this if we have -- static bounds, and the length is small enough, and the length -- is not zero. We exclude the zero length case because the size -- of things is always at least one, and the zero length object -- would have an anomalous size. if Compile_Time_Known_Value (Len_Expr) then Len_Bits := Expr_Value (Len_Expr) * Csize; -- Check for size known to be too large if Len_Bits > Uint_2 ** (Standard_Integer_Size - 1) * System_Storage_Unit then if System_Storage_Unit = 8 then Error_Msg_N ("packed array size cannot exceed " & "Integer''Last bytes", Typ); else Error_Msg_N ("packed array size cannot exceed " & "Integer''Last storage units", Typ); end if; -- Reset length to arbitrary not too high value to continue Len_Expr := Make_Integer_Literal (Loc, 65535); Analyze_And_Resolve (Len_Expr, Standard_Long_Long_Integer); end if; -- We normally consider small enough to mean no larger than the -- value of System_Max_Binary_Modulus_Power, checking that in the -- case of values longer than word size, we have long shifts. if Len_Bits > 0 and then (Len_Bits <= System_Word_Size or else (Len_Bits <= System_Max_Binary_Modulus_Power and then Support_Long_Shifts_On_Target)) then -- We can use the modular type, it has the form: -- subtype tttPn is btyp -- range 0 .. 2 ** ((Typ'Length (1) -- * ... * Typ'Length (n)) * Csize) - 1; -- The bounds are statically known, and btyp is one of the -- unsigned types, depending on the length. if Len_Bits <= Standard_Short_Short_Integer_Size then Btyp := RTE (RE_Short_Short_Unsigned); elsif Len_Bits <= Standard_Short_Integer_Size then Btyp := RTE (RE_Short_Unsigned); elsif Len_Bits <= Standard_Integer_Size then Btyp := RTE (RE_Unsigned); elsif Len_Bits <= Standard_Long_Integer_Size then Btyp := RTE (RE_Long_Unsigned); else Btyp := RTE (RE_Long_Long_Unsigned); end if; Lit := Make_Integer_Literal (Loc, 2 ** Len_Bits - 1); Set_Print_In_Hex (Lit); Decl := Make_Subtype_Declaration (Loc, Defining_Identifier => PAT, Subtype_Indication => Make_Subtype_Indication (Loc, Subtype_Mark => New_Occurrence_Of (Btyp, Loc), Constraint => Make_Range_Constraint (Loc, Range_Expression => Make_Range (Loc, Low_Bound => Make_Integer_Literal (Loc, 0), High_Bound => Lit)))); if PASize = Uint_0 then PASize := Len_Bits; end if; Install_PAT; -- Propagate a given alignment to the modular type. This can -- cause it to be under-aligned, but that's OK. if Present (Alignment_Clause (Typ)) then Set_Alignment (PAT, Alignment (Typ)); end if; return; end if; end if; -- Could not use a modular type, for all other cases, we build -- a packed array subtype: -- subtype tttPn is -- System.Packed_Bytes{1,2,4} (0 .. (Bits + 7) / 8 - 1); -- Bits is the length of the array in bits Set_PB_Type; Bits_U1 := Make_Op_Add (Loc, Left_Opnd => Make_Op_Multiply (Loc, Left_Opnd => Make_Integer_Literal (Loc, Csize), Right_Opnd => Len_Expr), Right_Opnd => Make_Integer_Literal (Loc, 7)); Set_Paren_Count (Bits_U1, 1); PAT_High := Make_Op_Subtract (Loc, Left_Opnd => Make_Op_Divide (Loc, Left_Opnd => Bits_U1, Right_Opnd => Make_Integer_Literal (Loc, 8)), Right_Opnd => Make_Integer_Literal (Loc, 1)); Decl := Make_Subtype_Declaration (Loc, Defining_Identifier => PAT, Subtype_Indication => Make_Subtype_Indication (Loc, Subtype_Mark => New_Occurrence_Of (PB_Type, Loc), Constraint => Make_Index_Or_Discriminant_Constraint (Loc, Constraints => New_List ( Make_Range (Loc, Low_Bound => Make_Integer_Literal (Loc, 0), High_Bound => Convert_To (Standard_Integer, PAT_High)))))); Install_PAT; -- Currently the code in this unit requires that packed arrays -- represented by non-modular arrays of bytes be on a byte -- boundary for bit sizes handled by System.Pack_nn units. -- That's because these units assume the array being accessed -- starts on a byte boundary. if Get_Id (UI_To_Int (Csize)) /= RE_Null then Set_Must_Be_On_Byte_Boundary (Typ); end if; end if; end Create_Packed_Array_Type; ----------------------------------- -- Expand_Bit_Packed_Element_Set -- ----------------------------------- procedure Expand_Bit_Packed_Element_Set (N : Node_Id) is Loc : constant Source_Ptr := Sloc (N); Lhs : constant Node_Id := Name (N); Ass_OK : constant Boolean := Assignment_OK (Lhs); -- Used to preserve assignment OK status when assignment is rewritten Rhs : Node_Id := Expression (N); -- Initially Rhs is the right hand side value, it will be replaced -- later by an appropriate unchecked conversion for the assignment. Obj : Node_Id; Atyp : Entity_Id; PAT : Entity_Id; Ctyp : Entity_Id; Csiz : Int; Cmask : Uint; Shift : Node_Id; -- The expression for the shift value that is required Shift_Used : Boolean := False; -- Set True if Shift has been used in the generated code at least -- once, so that it must be duplicated if used again New_Lhs : Node_Id; New_Rhs : Node_Id; Rhs_Val_Known : Boolean; Rhs_Val : Uint; -- If the value of the right hand side as an integer constant is -- known at compile time, Rhs_Val_Known is set True, and Rhs_Val -- contains the value. Otherwise Rhs_Val_Known is set False, and -- the Rhs_Val is undefined. function Get_Shift return Node_Id; -- Function used to get the value of Shift, making sure that it -- gets duplicated if the function is called more than once. --------------- -- Get_Shift -- --------------- function Get_Shift return Node_Id is begin -- If we used the shift value already, then duplicate it. We -- set a temporary parent in case actions have to be inserted. if Shift_Used then Set_Parent (Shift, N); return Duplicate_Subexpr_No_Checks (Shift); -- If first time, use Shift unchanged, and set flag for first use else Shift_Used := True; return Shift; end if; end Get_Shift; -- Start of processing for Expand_Bit_Packed_Element_Set begin pragma Assert (Is_Bit_Packed_Array (Etype (Prefix (Lhs)))); Obj := Relocate_Node (Prefix (Lhs)); Convert_To_Actual_Subtype (Obj); Atyp := Etype (Obj); PAT := Packed_Array_Type (Atyp); Ctyp := Component_Type (Atyp); Csiz := UI_To_Int (Component_Size (Atyp)); -- We remove side effects, in case the rhs modifies the lhs, because we -- are about to transform the rhs into an expression that first READS -- the lhs, so we can do the necessary shifting and masking. Example: -- "X(2) := F(...);" where F modifies X(3). Otherwise, the side effect -- will be lost. Remove_Side_Effects (Rhs); -- We convert the right hand side to the proper subtype to ensure -- that an appropriate range check is made (since the normal range -- check from assignment will be lost in the transformations). This -- conversion is analyzed immediately so that subsequent processing -- can work with an analyzed Rhs (and e.g. look at its Etype) -- If the right-hand side is a string literal, create a temporary for -- it, constant-folding is not ready to wrap the bit representation -- of a string literal. if Nkind (Rhs) = N_String_Literal then declare Decl : Node_Id; begin Decl := Make_Object_Declaration (Loc, Defining_Identifier => Make_Temporary (Loc, 'T', Rhs), Object_Definition => New_Occurrence_Of (Ctyp, Loc), Expression => New_Copy_Tree (Rhs)); Insert_Actions (N, New_List (Decl)); Rhs := New_Occurrence_Of (Defining_Identifier (Decl), Loc); end; end if; Rhs := Convert_To (Ctyp, Rhs); Set_Parent (Rhs, N); -- If we are building the initialization procedure for a packed array, -- and Initialize_Scalars is enabled, each component assignment is an -- out-of-range value by design. Compile this value without checks, -- because a call to the array init_proc must not raise an exception. if Within_Init_Proc and then Initialize_Scalars then Analyze_And_Resolve (Rhs, Ctyp, Suppress => All_Checks); else Analyze_And_Resolve (Rhs, Ctyp); end if; -- For the AAMP target, indexing of certain packed array is passed -- through to the back end without expansion, because the expansion -- results in very inefficient code on that target. This allows the -- GNAAMP back end to generate specialized macros that support more -- efficient indexing of packed arrays with components having sizes -- that are small powers of two. if AAMP_On_Target and then (Csiz = 1 or else Csiz = 2 or else Csiz = 4) then return; end if; -- Case of component size 1,2,4 or any component size for the modular -- case. These are the cases for which we can inline the code. if Csiz = 1 or else Csiz = 2 or else Csiz = 4 or else (Present (PAT) and then Is_Modular_Integer_Type (PAT)) then Setup_Inline_Packed_Array_Reference (Lhs, Atyp, Obj, Cmask, Shift); -- The statement to be generated is: -- Obj := atyp!((Obj and Mask1) or (shift_left (rhs, Shift))) -- where Mask1 is obtained by shifting Cmask left Shift bits -- and then complementing the result. -- the "and Mask1" is omitted if rhs is constant and all 1 bits -- the "or ..." is omitted if rhs is constant and all 0 bits -- rhs is converted to the appropriate type -- The result is converted back to the array type, since -- otherwise we lose knowledge of the packed nature. -- Determine if right side is all 0 bits or all 1 bits if Compile_Time_Known_Value (Rhs) then Rhs_Val := Expr_Rep_Value (Rhs); Rhs_Val_Known := True; -- The following test catches the case of an unchecked conversion -- of an integer literal. This results from optimizing aggregates -- of packed types. elsif Nkind (Rhs) = N_Unchecked_Type_Conversion and then Compile_Time_Known_Value (Expression (Rhs)) then Rhs_Val := Expr_Rep_Value (Expression (Rhs)); Rhs_Val_Known := True; else Rhs_Val := No_Uint; Rhs_Val_Known := False; end if; -- Some special checks for the case where the right hand value is -- known at compile time. Basically we have to take care of the -- implicit conversion to the subtype of the component object. if Rhs_Val_Known then -- If we have a biased component type then we must manually do the -- biasing, since we are taking responsibility in this case for -- constructing the exact bit pattern to be used. if Has_Biased_Representation (Ctyp) then Rhs_Val := Rhs_Val - Expr_Rep_Value (Type_Low_Bound (Ctyp)); end if; -- For a negative value, we manually convert the two's complement -- value to a corresponding unsigned value, so that the proper -- field width is maintained. If we did not do this, we would -- get too many leading sign bits later on. if Rhs_Val < 0 then Rhs_Val := 2 ** UI_From_Int (Csiz) + Rhs_Val; end if; end if; -- Now create copies removing side effects. Note that in some -- complex cases, this may cause the fact that we have already -- set a packed array type on Obj to get lost. So we save the -- type of Obj, and make sure it is reset properly. declare T : constant Entity_Id := Etype (Obj); begin New_Lhs := Duplicate_Subexpr (Obj, True); New_Rhs := Duplicate_Subexpr_No_Checks (Obj); Set_Etype (Obj, T); Set_Etype (New_Lhs, T); Set_Etype (New_Rhs, T); end; -- First we deal with the "and" if not Rhs_Val_Known or else Rhs_Val /= Cmask then declare Mask1 : Node_Id; Lit : Node_Id; begin if Compile_Time_Known_Value (Shift) then Mask1 := Make_Integer_Literal (Loc, Modulus (Etype (Obj)) - 1 - (Cmask * (2 ** Expr_Value (Get_Shift)))); Set_Print_In_Hex (Mask1); else Lit := Make_Integer_Literal (Loc, Cmask); Set_Print_In_Hex (Lit); Mask1 := Make_Op_Not (Loc, Right_Opnd => Make_Shift_Left (Lit, Get_Shift)); end if; New_Rhs := Make_Op_And (Loc, Left_Opnd => New_Rhs, Right_Opnd => Mask1); end; end if; -- Then deal with the "or" if not Rhs_Val_Known or else Rhs_Val /= 0 then declare Or_Rhs : Node_Id; procedure Fixup_Rhs; -- Adjust Rhs by bias if biased representation for components -- or remove extraneous high order sign bits if signed. procedure Fixup_Rhs is Etyp : constant Entity_Id := Etype (Rhs); begin -- For biased case, do the required biasing by simply -- converting to the biased subtype (the conversion -- will generate the required bias). if Has_Biased_Representation (Ctyp) then Rhs := Convert_To (Ctyp, Rhs); -- For a signed integer type that is not biased, generate -- a conversion to unsigned to strip high order sign bits. elsif Is_Signed_Integer_Type (Ctyp) then Rhs := Unchecked_Convert_To (RTE (Bits_Id (Csiz)), Rhs); end if; -- Set Etype, since it can be referenced before the node is -- completely analyzed. Set_Etype (Rhs, Etyp); -- We now need to do an unchecked conversion of the -- result to the target type, but it is important that -- this conversion be a right justified conversion and -- not a left justified conversion. Rhs := RJ_Unchecked_Convert_To (Etype (Obj), Rhs); end Fixup_Rhs; begin if Rhs_Val_Known and then Compile_Time_Known_Value (Get_Shift) then Or_Rhs := Make_Integer_Literal (Loc, Rhs_Val * (2 ** Expr_Value (Get_Shift))); Set_Print_In_Hex (Or_Rhs); else -- We have to convert the right hand side to Etype (Obj). -- A special case arises if what we have now is a Val -- attribute reference whose expression type is Etype (Obj). -- This happens for assignments of fields from the same -- array. In this case we get the required right hand side -- by simply removing the inner attribute reference. if Nkind (Rhs) = N_Attribute_Reference and then Attribute_Name (Rhs) = Name_Val and then Etype (First (Expressions (Rhs))) = Etype (Obj) then Rhs := Relocate_Node (First (Expressions (Rhs))); Fixup_Rhs; -- If the value of the right hand side is a known integer -- value, then just replace it by an untyped constant, -- which will be properly retyped when we analyze and -- resolve the expression. elsif Rhs_Val_Known then -- Note that Rhs_Val has already been normalized to -- be an unsigned value with the proper number of bits. Rhs := Make_Integer_Literal (Loc, Rhs_Val); -- Otherwise we need an unchecked conversion else Fixup_Rhs; end if; Or_Rhs := Make_Shift_Left (Rhs, Get_Shift); end if; if Nkind (New_Rhs) = N_Op_And then Set_Paren_Count (New_Rhs, 1); end if; New_Rhs := Make_Op_Or (Loc, Left_Opnd => New_Rhs, Right_Opnd => Or_Rhs); end; end if; -- Now do the rewrite Rewrite (N, Make_Assignment_Statement (Loc, Name => New_Lhs, Expression => Unchecked_Convert_To (Etype (New_Lhs), New_Rhs))); Set_Assignment_OK (Name (N), Ass_OK); -- All other component sizes for non-modular case else -- We generate -- Set_nn (Arr'address, Subscr, Bits_nn!(Rhs)) -- where Subscr is the computed linear subscript declare Bits_nn : constant Entity_Id := RTE (Bits_Id (Csiz)); Set_nn : Entity_Id; Subscr : Node_Id; Atyp : Entity_Id; begin if No (Bits_nn) then -- Error, most likely High_Integrity_Mode restriction return; end if; -- Acquire proper Set entity. We use the aligned or unaligned -- case as appropriate. if Known_Aligned_Enough (Obj, Csiz) then Set_nn := RTE (Set_Id (Csiz)); else Set_nn := RTE (SetU_Id (Csiz)); end if; -- Now generate the set reference Obj := Relocate_Node (Prefix (Lhs)); Convert_To_Actual_Subtype (Obj); Atyp := Etype (Obj); Compute_Linear_Subscript (Atyp, Lhs, Subscr); -- Below we must make the assumption that Obj is -- at least byte aligned, since otherwise its address -- cannot be taken. The assumption holds since the -- only arrays that can be misaligned are small packed -- arrays which are implemented as a modular type, and -- that is not the case here. Rewrite (N, Make_Procedure_Call_Statement (Loc, Name => New_Occurrence_Of (Set_nn, Loc), Parameter_Associations => New_List ( Make_Attribute_Reference (Loc, Prefix => Obj, Attribute_Name => Name_Address), Subscr, Unchecked_Convert_To (Bits_nn, Convert_To (Ctyp, Rhs))))); end; end if; Analyze (N, Suppress => All_Checks); end Expand_Bit_Packed_Element_Set; ------------------------------------- -- Expand_Packed_Address_Reference -- ------------------------------------- procedure Expand_Packed_Address_Reference (N : Node_Id) is Loc : constant Source_Ptr := Sloc (N); Base : Node_Id; Offset : Node_Id; begin -- We build an expression that has the form -- outer_object'Address -- + (linear-subscript * component_size for each array reference -- + field'Bit_Position for each record field -- + ... -- + ...) / Storage_Unit; Get_Base_And_Bit_Offset (Prefix (N), Base, Offset); Rewrite (N, Unchecked_Convert_To (RTE (RE_Address), Make_Op_Add (Loc, Left_Opnd => Unchecked_Convert_To (RTE (RE_Integer_Address), Make_Attribute_Reference (Loc, Prefix => Base, Attribute_Name => Name_Address)), Right_Opnd => Unchecked_Convert_To (RTE (RE_Integer_Address), Make_Op_Divide (Loc, Left_Opnd => Offset, Right_Opnd => Make_Integer_Literal (Loc, System_Storage_Unit)))))); Analyze_And_Resolve (N, RTE (RE_Address)); end Expand_Packed_Address_Reference; --------------------------------- -- Expand_Packed_Bit_Reference -- --------------------------------- procedure Expand_Packed_Bit_Reference (N : Node_Id) is Loc : constant Source_Ptr := Sloc (N); Base : Node_Id; Offset : Node_Id; begin -- We build an expression that has the form -- (linear-subscript * component_size for each array reference -- + field'Bit_Position for each record field -- + ... -- + ...) mod Storage_Unit; Get_Base_And_Bit_Offset (Prefix (N), Base, Offset); Rewrite (N, Unchecked_Convert_To (Universal_Integer, Make_Op_Mod (Loc, Left_Opnd => Offset, Right_Opnd => Make_Integer_Literal (Loc, System_Storage_Unit)))); Analyze_And_Resolve (N, Universal_Integer); end Expand_Packed_Bit_Reference; ------------------------------------ -- Expand_Packed_Boolean_Operator -- ------------------------------------ -- This routine expands "a op b" for the packed cases procedure Expand_Packed_Boolean_Operator (N : Node_Id) is Loc : constant Source_Ptr := Sloc (N); Typ : constant Entity_Id := Etype (N); L : constant Node_Id := Relocate_Node (Left_Opnd (N)); R : constant Node_Id := Relocate_Node (Right_Opnd (N)); Ltyp : Entity_Id; Rtyp : Entity_Id; PAT : Entity_Id; begin Convert_To_Actual_Subtype (L); Convert_To_Actual_Subtype (R); Ensure_Defined (Etype (L), N); Ensure_Defined (Etype (R), N); Apply_Length_Check (R, Etype (L)); Ltyp := Etype (L); Rtyp := Etype (R); -- Deal with silly case of XOR where the subcomponent has a range -- True .. True where an exception must be raised. if Nkind (N) = N_Op_Xor then Silly_Boolean_Array_Xor_Test (N, Rtyp); end if; -- Now that that silliness is taken care of, get packed array type Convert_To_PAT_Type (L); Convert_To_PAT_Type (R); PAT := Etype (L); -- For the modular case, we expand a op b into -- rtyp!(pat!(a) op pat!(b)) -- where rtyp is the Etype of the left operand. Note that we do not -- convert to the base type, since this would be unconstrained, and -- hence not have a corresponding packed array type set. -- Note that both operands must be modular for this code to be used if Is_Modular_Integer_Type (PAT) and then Is_Modular_Integer_Type (Etype (R)) then declare P : Node_Id; begin if Nkind (N) = N_Op_And then P := Make_Op_And (Loc, L, R); elsif Nkind (N) = N_Op_Or then P := Make_Op_Or (Loc, L, R); else -- Nkind (N) = N_Op_Xor P := Make_Op_Xor (Loc, L, R); end if; Rewrite (N, Unchecked_Convert_To (Ltyp, P)); end; -- For the array case, we insert the actions -- Result : Ltype; -- System.Bit_Ops.Bit_And/Or/Xor -- (Left'Address, -- Ltype'Length * Ltype'Component_Size; -- Right'Address, -- Rtype'Length * Rtype'Component_Size -- Result'Address); -- where Left and Right are the Packed_Bytes{1,2,4} operands and -- the second argument and fourth arguments are the lengths of the -- operands in bits. Then we replace the expression by a reference -- to Result. -- Note that if we are mixing a modular and array operand, everything -- works fine, since we ensure that the modular representation has the -- same physical layout as the array representation (that's what the -- left justified modular stuff in the big-endian case is about). else declare Result_Ent : constant Entity_Id := Make_Temporary (Loc, 'T'); E_Id : RE_Id; begin if Nkind (N) = N_Op_And then E_Id := RE_Bit_And; elsif Nkind (N) = N_Op_Or then E_Id := RE_Bit_Or; else -- Nkind (N) = N_Op_Xor E_Id := RE_Bit_Xor; end if; Insert_Actions (N, New_List ( Make_Object_Declaration (Loc, Defining_Identifier => Result_Ent, Object_Definition => New_Occurrence_Of (Ltyp, Loc)), Make_Procedure_Call_Statement (Loc, Name => New_Occurrence_Of (RTE (E_Id), Loc), Parameter_Associations => New_List ( Make_Byte_Aligned_Attribute_Reference (Loc, Prefix => L, Attribute_Name => Name_Address), Make_Op_Multiply (Loc, Left_Opnd => Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Etype (First_Index (Ltyp)), Loc), Attribute_Name => Name_Range_Length), Right_Opnd => Make_Integer_Literal (Loc, Component_Size (Ltyp))), Make_Byte_Aligned_Attribute_Reference (Loc, Prefix => R, Attribute_Name => Name_Address), Make_Op_Multiply (Loc, Left_Opnd => Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Etype (First_Index (Rtyp)), Loc), Attribute_Name => Name_Range_Length), Right_Opnd => Make_Integer_Literal (Loc, Component_Size (Rtyp))), Make_Byte_Aligned_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Result_Ent, Loc), Attribute_Name => Name_Address))))); Rewrite (N, New_Occurrence_Of (Result_Ent, Loc)); end; end if; Analyze_And_Resolve (N, Typ, Suppress => All_Checks); end Expand_Packed_Boolean_Operator; ------------------------------------- -- Expand_Packed_Element_Reference -- ------------------------------------- procedure Expand_Packed_Element_Reference (N : Node_Id) is Loc : constant Source_Ptr := Sloc (N); Obj : Node_Id; Atyp : Entity_Id; PAT : Entity_Id; Ctyp : Entity_Id; Csiz : Int; Shift : Node_Id; Cmask : Uint; Lit : Node_Id; Arg : Node_Id; begin -- If not bit packed, we have the enumeration case, which is easily -- dealt with (just adjust the subscripts of the indexed component) -- Note: this leaves the result as an indexed component, which is -- still a variable, so can be used in the assignment case, as is -- required in the enumeration case. if not Is_Bit_Packed_Array (Etype (Prefix (N))) then Setup_Enumeration_Packed_Array_Reference (N); return; end if; -- Remaining processing is for the bit-packed case Obj := Relocate_Node (Prefix (N)); Convert_To_Actual_Subtype (Obj); Atyp := Etype (Obj); PAT := Packed_Array_Type (Atyp); Ctyp := Component_Type (Atyp); Csiz := UI_To_Int (Component_Size (Atyp)); -- For the AAMP target, indexing of certain packed array is passed -- through to the back end without expansion, because the expansion -- results in very inefficient code on that target. This allows the -- GNAAMP back end to generate specialized macros that support more -- efficient indexing of packed arrays with components having sizes -- that are small powers of two. if AAMP_On_Target and then (Csiz = 1 or else Csiz = 2 or else Csiz = 4) then return; end if; -- Case of component size 1,2,4 or any component size for the modular -- case. These are the cases for which we can inline the code. if Csiz = 1 or else Csiz = 2 or else Csiz = 4 or else (Present (PAT) and then Is_Modular_Integer_Type (PAT)) then Setup_Inline_Packed_Array_Reference (N, Atyp, Obj, Cmask, Shift); Lit := Make_Integer_Literal (Loc, Cmask); Set_Print_In_Hex (Lit); -- We generate a shift right to position the field, followed by a -- masking operation to extract the bit field, and we finally do an -- unchecked conversion to convert the result to the required target. -- Note that the unchecked conversion automatically deals with the -- bias if we are dealing with a biased representation. What will -- happen is that we temporarily generate the biased representation, -- but almost immediately that will be converted to the original -- unbiased component type, and the bias will disappear. Arg := Make_Op_And (Loc, Left_Opnd => Make_Shift_Right (Obj, Shift), Right_Opnd => Lit); -- We needed to analyze this before we do the unchecked convert -- below, but we need it temporarily attached to the tree for -- this analysis (hence the temporary Set_Parent call). Set_Parent (Arg, Parent (N)); Analyze_And_Resolve (Arg); Rewrite (N, RJ_Unchecked_Convert_To (Ctyp, Arg)); -- All other component sizes for non-modular case else -- We generate -- Component_Type!(Get_nn (Arr'address, Subscr)) -- where Subscr is the computed linear subscript declare Get_nn : Entity_Id; Subscr : Node_Id; begin -- Acquire proper Get entity. We use the aligned or unaligned -- case as appropriate. if Known_Aligned_Enough (Obj, Csiz) then Get_nn := RTE (Get_Id (Csiz)); else Get_nn := RTE (GetU_Id (Csiz)); end if; -- Now generate the get reference Compute_Linear_Subscript (Atyp, N, Subscr); -- Below we make the assumption that Obj is at least byte -- aligned, since otherwise its address cannot be taken. -- The assumption holds since the only arrays that can be -- misaligned are small packed arrays which are implemented -- as a modular type, and that is not the case here. Rewrite (N, Unchecked_Convert_To (Ctyp, Make_Function_Call (Loc, Name => New_Occurrence_Of (Get_nn, Loc), Parameter_Associations => New_List ( Make_Attribute_Reference (Loc, Prefix => Obj, Attribute_Name => Name_Address), Subscr)))); end; end if; Analyze_And_Resolve (N, Ctyp, Suppress => All_Checks); end Expand_Packed_Element_Reference; ---------------------- -- Expand_Packed_Eq -- ---------------------- -- Handles expansion of "=" on packed array types procedure Expand_Packed_Eq (N : Node_Id) is Loc : constant Source_Ptr := Sloc (N); L : constant Node_Id := Relocate_Node (Left_Opnd (N)); R : constant Node_Id := Relocate_Node (Right_Opnd (N)); LLexpr : Node_Id; RLexpr : Node_Id; Ltyp : Entity_Id; Rtyp : Entity_Id; PAT : Entity_Id; begin Convert_To_Actual_Subtype (L); Convert_To_Actual_Subtype (R); Ltyp := Underlying_Type (Etype (L)); Rtyp := Underlying_Type (Etype (R)); Convert_To_PAT_Type (L); Convert_To_PAT_Type (R); PAT := Etype (L); LLexpr := Make_Op_Multiply (Loc, Left_Opnd => Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Ltyp, Loc), Attribute_Name => Name_Length), Right_Opnd => Make_Integer_Literal (Loc, Component_Size (Ltyp))); RLexpr := Make_Op_Multiply (Loc, Left_Opnd => Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Rtyp, Loc), Attribute_Name => Name_Length), Right_Opnd => Make_Integer_Literal (Loc, Component_Size (Rtyp))); -- For the modular case, we transform the comparison to: -- Ltyp'Length = Rtyp'Length and then PAT!(L) = PAT!(R) -- where PAT is the packed array type. This works fine, since in the -- modular case we guarantee that the unused bits are always zeroes. -- We do have to compare the lengths because we could be comparing -- two different subtypes of the same base type. if Is_Modular_Integer_Type (PAT) then Rewrite (N, Make_And_Then (Loc, Left_Opnd => Make_Op_Eq (Loc, Left_Opnd => LLexpr, Right_Opnd => RLexpr), Right_Opnd => Make_Op_Eq (Loc, Left_Opnd => L, Right_Opnd => R))); -- For the non-modular case, we call a runtime routine -- System.Bit_Ops.Bit_Eq -- (L'Address, L_Length, R'Address, R_Length) -- where PAT is the packed array type, and the lengths are the lengths -- in bits of the original packed arrays. This routine takes care of -- not comparing the unused bits in the last byte. else Rewrite (N, Make_Function_Call (Loc, Name => New_Occurrence_Of (RTE (RE_Bit_Eq), Loc), Parameter_Associations => New_List ( Make_Byte_Aligned_Attribute_Reference (Loc, Prefix => L, Attribute_Name => Name_Address), LLexpr, Make_Byte_Aligned_Attribute_Reference (Loc, Prefix => R, Attribute_Name => Name_Address), RLexpr))); end if; Analyze_And_Resolve (N, Standard_Boolean, Suppress => All_Checks); end Expand_Packed_Eq; ----------------------- -- Expand_Packed_Not -- ----------------------- -- Handles expansion of "not" on packed array types procedure Expand_Packed_Not (N : Node_Id) is Loc : constant Source_Ptr := Sloc (N); Typ : constant Entity_Id := Etype (N); Opnd : constant Node_Id := Relocate_Node (Right_Opnd (N)); Rtyp : Entity_Id; PAT : Entity_Id; Lit : Node_Id; begin Convert_To_Actual_Subtype (Opnd); Rtyp := Etype (Opnd); -- Deal with silly False..False and True..True subtype case Silly_Boolean_Array_Not_Test (N, Rtyp); -- Now that the silliness is taken care of, get packed array type Convert_To_PAT_Type (Opnd); PAT := Etype (Opnd); -- For the case where the packed array type is a modular type, "not A" -- expands simply into: -- Rtyp!(PAT!(A) xor Mask) -- where PAT is the packed array type, Mask is a mask of all 1 bits of -- length equal to the size of this packed type, and Rtyp is the actual -- actual subtype of the operand. Lit := Make_Integer_Literal (Loc, 2 ** RM_Size (PAT) - 1); Set_Print_In_Hex (Lit); if not Is_Array_Type (PAT) then Rewrite (N, Unchecked_Convert_To (Rtyp, Make_Op_Xor (Loc, Left_Opnd => Opnd, Right_Opnd => Lit))); -- For the array case, we insert the actions -- Result : Typ; -- System.Bit_Ops.Bit_Not -- (Opnd'Address, -- Typ'Length * Typ'Component_Size, -- Result'Address); -- where Opnd is the Packed_Bytes{1,2,4} operand and the second argument -- is the length of the operand in bits. We then replace the expression -- with a reference to Result. else declare Result_Ent : constant Entity_Id := Make_Temporary (Loc, 'T'); begin Insert_Actions (N, New_List ( Make_Object_Declaration (Loc, Defining_Identifier => Result_Ent, Object_Definition => New_Occurrence_Of (Rtyp, Loc)), Make_Procedure_Call_Statement (Loc, Name => New_Occurrence_Of (RTE (RE_Bit_Not), Loc), Parameter_Associations => New_List ( Make_Byte_Aligned_Attribute_Reference (Loc, Prefix => Opnd, Attribute_Name => Name_Address), Make_Op_Multiply (Loc, Left_Opnd => Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Etype (First_Index (Rtyp)), Loc), Attribute_Name => Name_Range_Length), Right_Opnd => Make_Integer_Literal (Loc, Component_Size (Rtyp))), Make_Byte_Aligned_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Result_Ent, Loc), Attribute_Name => Name_Address))))); Rewrite (N, New_Occurrence_Of (Result_Ent, Loc)); end; end if; Analyze_And_Resolve (N, Typ, Suppress => All_Checks); end Expand_Packed_Not; ----------------------------- -- Get_Base_And_Bit_Offset -- ----------------------------- procedure Get_Base_And_Bit_Offset (N : Node_Id; Base : out Node_Id; Offset : out Node_Id) is Loc : Source_Ptr; Term : Node_Id; Atyp : Entity_Id; Subscr : Node_Id; begin Base := N; Offset := Empty; -- We build up an expression serially that has the form -- linear-subscript * component_size for each array reference -- + field'Bit_Position for each record field -- + ... loop Loc := Sloc (Base); if Nkind (Base) = N_Indexed_Component then Convert_To_Actual_Subtype (Prefix (Base)); Atyp := Etype (Prefix (Base)); Compute_Linear_Subscript (Atyp, Base, Subscr); Term := Make_Op_Multiply (Loc, Left_Opnd => Subscr, Right_Opnd => Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Atyp, Loc), Attribute_Name => Name_Component_Size)); elsif Nkind (Base) = N_Selected_Component then Term := Make_Attribute_Reference (Loc, Prefix => Selector_Name (Base), Attribute_Name => Name_Bit_Position); else return; end if; if No (Offset) then Offset := Term; else Offset := Make_Op_Add (Loc, Left_Opnd => Offset, Right_Opnd => Term); end if; Base := Prefix (Base); end loop; end Get_Base_And_Bit_Offset; ------------------------------------- -- Involves_Packed_Array_Reference -- ------------------------------------- function Involves_Packed_Array_Reference (N : Node_Id) return Boolean is begin if Nkind (N) = N_Indexed_Component and then Is_Bit_Packed_Array (Etype (Prefix (N))) then return True; elsif Nkind (N) = N_Selected_Component then return Involves_Packed_Array_Reference (Prefix (N)); else return False; end if; end Involves_Packed_Array_Reference; -------------------------- -- Known_Aligned_Enough -- -------------------------- function Known_Aligned_Enough (Obj : Node_Id; Csiz : Nat) return Boolean is Typ : constant Entity_Id := Etype (Obj); function In_Partially_Packed_Record (Comp : Entity_Id) return Boolean; -- If the component is in a record that contains previous packed -- components, consider it unaligned because the back-end might -- choose to pack the rest of the record. Lead to less efficient code, -- but safer vis-a-vis of back-end choices. -------------------------------- -- In_Partially_Packed_Record -- -------------------------------- function In_Partially_Packed_Record (Comp : Entity_Id) return Boolean is Rec_Type : constant Entity_Id := Scope (Comp); Prev_Comp : Entity_Id; begin Prev_Comp := First_Entity (Rec_Type); while Present (Prev_Comp) loop if Is_Packed (Etype (Prev_Comp)) then return True; elsif Prev_Comp = Comp then return False; end if; Next_Entity (Prev_Comp); end loop; return False; end In_Partially_Packed_Record; -- Start of processing for Known_Aligned_Enough begin -- Odd bit sizes don't need alignment anyway if Csiz mod 2 = 1 then return True; -- If we have a specified alignment, see if it is sufficient, if not -- then we can't possibly be aligned enough in any case. elsif Known_Alignment (Etype (Obj)) then -- Alignment required is 4 if size is a multiple of 4, and -- 2 otherwise (e.g. 12 bits requires 4, 10 bits requires 2) if Alignment (Etype (Obj)) < 4 - (Csiz mod 4) then return False; end if; end if; -- OK, alignment should be sufficient, if object is aligned -- If object is strictly aligned, then it is definitely aligned if Strict_Alignment (Typ) then return True; -- Case of subscripted array reference elsif Nkind (Obj) = N_Indexed_Component then -- If we have a pointer to an array, then this is definitely -- aligned, because pointers always point to aligned versions. if Is_Access_Type (Etype (Prefix (Obj))) then return True; -- Otherwise, go look at the prefix else return Known_Aligned_Enough (Prefix (Obj), Csiz); end if; -- Case of record field elsif Nkind (Obj) = N_Selected_Component then -- What is significant here is whether the record type is packed if Is_Record_Type (Etype (Prefix (Obj))) and then Is_Packed (Etype (Prefix (Obj))) then return False; -- Or the component has a component clause which might cause -- the component to become unaligned (we can't tell if the -- backend is doing alignment computations). elsif Present (Component_Clause (Entity (Selector_Name (Obj)))) then return False; elsif In_Partially_Packed_Record (Entity (Selector_Name (Obj))) then return False; -- In all other cases, go look at prefix else return Known_Aligned_Enough (Prefix (Obj), Csiz); end if; elsif Nkind (Obj) = N_Type_Conversion then return Known_Aligned_Enough (Expression (Obj), Csiz); -- For a formal parameter, it is safer to assume that it is not -- aligned, because the formal may be unconstrained while the actual -- is constrained. In this situation, a small constrained packed -- array, represented in modular form, may be unaligned. elsif Is_Entity_Name (Obj) then return not Is_Formal (Entity (Obj)); else -- If none of the above, must be aligned return True; end if; end Known_Aligned_Enough; --------------------- -- Make_Shift_Left -- --------------------- function Make_Shift_Left (N : Node_Id; S : Node_Id) return Node_Id is Nod : Node_Id; begin if Compile_Time_Known_Value (S) and then Expr_Value (S) = 0 then return N; else Nod := Make_Op_Shift_Left (Sloc (N), Left_Opnd => N, Right_Opnd => S); Set_Shift_Count_OK (Nod, True); return Nod; end if; end Make_Shift_Left; ---------------------- -- Make_Shift_Right -- ---------------------- function Make_Shift_Right (N : Node_Id; S : Node_Id) return Node_Id is Nod : Node_Id; begin if Compile_Time_Known_Value (S) and then Expr_Value (S) = 0 then return N; else Nod := Make_Op_Shift_Right (Sloc (N), Left_Opnd => N, Right_Opnd => S); Set_Shift_Count_OK (Nod, True); return Nod; end if; end Make_Shift_Right; ----------------------------- -- RJ_Unchecked_Convert_To -- ----------------------------- function RJ_Unchecked_Convert_To (Typ : Entity_Id; Expr : Node_Id) return Node_Id is Source_Typ : constant Entity_Id := Etype (Expr); Target_Typ : constant Entity_Id := Typ; Src : Node_Id := Expr; Source_Siz : Nat; Target_Siz : Nat; begin Source_Siz := UI_To_Int (RM_Size (Source_Typ)); Target_Siz := UI_To_Int (RM_Size (Target_Typ)); -- First step, if the source type is not a discrete type, then we first -- convert to a modular type of the source length, since otherwise, on -- a big-endian machine, we get left-justification. We do it for little- -- endian machines as well, because there might be junk bits that are -- not cleared if the type is not numeric. if Source_Siz /= Target_Siz and then not Is_Discrete_Type (Source_Typ) then Src := Unchecked_Convert_To (RTE (Bits_Id (Source_Siz)), Src); end if; -- In the big endian case, if the lengths of the two types differ, then -- we must worry about possible left justification in the conversion, -- and avoiding that is what this is all about. if Bytes_Big_Endian and then Source_Siz /= Target_Siz then -- Next step. If the target is not a discrete type, then we first -- convert to a modular type of the target length, since otherwise, -- on a big-endian machine, we get left-justification. if not Is_Discrete_Type (Target_Typ) then Src := Unchecked_Convert_To (RTE (Bits_Id (Target_Siz)), Src); end if; end if; -- And now we can do the final conversion to the target type return Unchecked_Convert_To (Target_Typ, Src); end RJ_Unchecked_Convert_To; ---------------------------------------------- -- Setup_Enumeration_Packed_Array_Reference -- ---------------------------------------------- -- All we have to do here is to find the subscripts that correspond to the -- index positions that have non-standard enumeration types and insert a -- Pos attribute to get the proper subscript value. -- Finally the prefix must be uncheck-converted to the corresponding packed -- array type. -- Note that the component type is unchanged, so we do not need to fiddle -- with the types (Gigi always automatically takes the packed array type if -- it is set, as it will be in this case). procedure Setup_Enumeration_Packed_Array_Reference (N : Node_Id) is Pfx : constant Node_Id := Prefix (N); Typ : constant Entity_Id := Etype (N); Exprs : constant List_Id := Expressions (N); Expr : Node_Id; begin -- If the array is unconstrained, then we replace the array reference -- 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 Convert_To_Actual_Subtype (Pfx); end if; Expr := First (Exprs); while Present (Expr) loop declare Loc : constant Source_Ptr := Sloc (Expr); Expr_Typ : constant Entity_Id := Etype (Expr); begin if Is_Enumeration_Type (Expr_Typ) and then Has_Non_Standard_Rep (Expr_Typ) then Rewrite (Expr, Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Expr_Typ, Loc), Attribute_Name => Name_Pos, Expressions => New_List (Relocate_Node (Expr)))); Analyze_And_Resolve (Expr, Standard_Natural); end if; end; Next (Expr); end loop; Rewrite (N, Make_Indexed_Component (Sloc (N), Prefix => Unchecked_Convert_To (Packed_Array_Type (Etype (Pfx)), Pfx), Expressions => Exprs)); Analyze_And_Resolve (N, Typ); end Setup_Enumeration_Packed_Array_Reference; ----------------------------------------- -- Setup_Inline_Packed_Array_Reference -- ----------------------------------------- procedure Setup_Inline_Packed_Array_Reference (N : Node_Id; Atyp : Entity_Id; Obj : in out Node_Id; Cmask : out Uint; Shift : out Node_Id) is Loc : constant Source_Ptr := Sloc (N); PAT : Entity_Id; Otyp : Entity_Id; Csiz : Uint; Osiz : Uint; begin Csiz := Component_Size (Atyp); Convert_To_PAT_Type (Obj); PAT := Etype (Obj); Cmask := 2 ** Csiz - 1; if Is_Array_Type (PAT) then Otyp := Component_Type (PAT); Osiz := Component_Size (PAT); else Otyp := PAT; -- In the case where the PAT is a modular type, we want the actual -- size in bits of the modular value we use. This is neither the -- Object_Size nor the Value_Size, either of which may have been -- reset to strange values, but rather the minimum size. Note that -- since this is a modular type with full range, the issue of -- biased representation does not arise. Osiz := UI_From_Int (Minimum_Size (Otyp)); end if; Compute_Linear_Subscript (Atyp, N, Shift); -- If the component size is not 1, then the subscript must be multiplied -- by the component size to get the shift count. if Csiz /= 1 then Shift := Make_Op_Multiply (Loc, Left_Opnd => Make_Integer_Literal (Loc, Csiz), Right_Opnd => Shift); end if; -- If we have the array case, then this shift count must be broken down -- into a byte subscript, and a shift within the byte. if Is_Array_Type (PAT) then declare New_Shift : Node_Id; begin -- We must analyze shift, since we will duplicate it Set_Parent (Shift, N); Analyze_And_Resolve (Shift, Standard_Integer, Suppress => All_Checks); -- The shift count within the word is -- shift mod Osiz New_Shift := Make_Op_Mod (Loc, Left_Opnd => Duplicate_Subexpr (Shift), Right_Opnd => Make_Integer_Literal (Loc, Osiz)); -- The subscript to be used on the PAT array is -- shift / Osiz Obj := Make_Indexed_Component (Loc, Prefix => Obj, Expressions => New_List ( Make_Op_Divide (Loc, Left_Opnd => Duplicate_Subexpr (Shift), Right_Opnd => Make_Integer_Literal (Loc, Osiz)))); Shift := New_Shift; end; -- For the modular integer case, the object to be manipulated is the -- entire array, so Obj is unchanged. Note that we will reset its type -- to PAT before returning to the caller. else null; end if; -- The one remaining step is to modify the shift count for the -- big-endian case. Consider the following example in a byte: -- xxxxxxxx bits of byte -- vvvvvvvv bits of value -- 33221100 little-endian numbering -- 00112233 big-endian numbering -- Here we have the case of 2-bit fields -- For the little-endian case, we already have the proper shift count -- set, e.g. for element 2, the shift count is 2*2 = 4. -- For the big endian case, we have to adjust the shift count, computing -- it as (N - F) - Shift, where N is the number of bits in an element of -- the array used to implement the packed array, F is the number of bits -- in a source array element, and Shift is the count so far computed. if Bytes_Big_Endian then Shift := Make_Op_Subtract (Loc, Left_Opnd => Make_Integer_Literal (Loc, Osiz - Csiz), Right_Opnd => Shift); end if; Set_Parent (Shift, N); Set_Parent (Obj, N); Analyze_And_Resolve (Obj, Otyp, Suppress => All_Checks); Analyze_And_Resolve (Shift, Standard_Integer, Suppress => All_Checks); -- Make sure final type of object is the appropriate packed type Set_Etype (Obj, Otyp); end Setup_Inline_Packed_Array_Reference; end Exp_Pakd;
Go to most recent revision | Compare with Previous | Blame | View Log