| blob | d4968a325a0f9475c2e37c7e87ea847e74bd1d18 |
1 ------------------------------------------------------------------------------
2 -- --
3 -- GNAT COMPILER COMPONENTS --
4 -- --
5 -- E X P _ P A K D --
6 -- --
7 -- B o d y --
8 -- --
9 -- Copyright (C) 1992-2015, Free Software Foundation, Inc. --
10 -- --
11 -- GNAT is free software; you can redistribute it and/or modify it under --
12 -- terms of the GNU General Public License as published by the Free Soft- --
13 -- ware Foundation; either version 3, or (at your option) any later ver- --
14 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
15 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
16 -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
17 -- for more details. You should have received a copy of the GNU General --
18 -- Public License distributed with GNAT; see file COPYING3. If not, go to --
19 -- http://www.gnu.org/licenses for a complete copy of the license. --
20 -- --
21 -- GNAT was originally developed by the GNAT team at New York University. --
22 -- Extensive contributions were provided by Ada Core Technologies Inc. --
23 -- --
24 ------------------------------------------------------------------------------
56 ---------------------------
57 -- Endian Considerations --
58 ---------------------------
60 -- As described in the specification, bit numbering in a packed array
61 -- is consistent with bit numbering in a record representation clause,
62 -- and hence dependent on the endianness of the machine:
64 -- For little-endian machines, element zero is at the right hand end
65 -- (low order end) of a bit field.
67 -- For big-endian machines, element zero is at the left hand end
68 -- (high order end) of a bit field.
70 -- The shifts that are used to right justify a field therefore differ in
71 -- the two cases. For the little-endian case, we can simply use the bit
72 -- number (i.e. the element number * element size) as the count for a right
73 -- shift. For the big-endian case, we have to subtract the shift count from
74 -- an appropriate constant to use in the right shift. We use rotates
75 -- instead of shifts (which is necessary in the store case to preserve
76 -- other fields), and we expect that the backend will be able to change the
77 -- right rotate into a left rotate, avoiding the subtract, if the machine
78 -- architecture provides such an instruction.
80 -----------------------
81 -- Local Subprograms --
82 -----------------------
84 procedure Compute_Linear_Subscript
88 -- Given a constrained array type Atyp, and an indexed component node N
89 -- referencing an array object of this type, build an expression of type
90 -- Standard.Integer representing the zero-based linear subscript value.
91 -- This expression includes any required range checks.
94 -- Given an expression of a packed array type, builds a corresponding
95 -- expression whose type is the implementation type used to represent
96 -- the packed array. Aexp is analyzed and resolved on entry and on exit.
98 procedure Get_Base_And_Bit_Offset
102 -- Given a node N for a name which involves a packed array reference,
103 -- return the base object of the reference and build an expression of
104 -- type Standard.Integer representing the zero-based offset in bits
105 -- from Base'Address to the first bit of the reference.
108 -- There are two versions of the Set routines, the ones used when the
109 -- object is known to be sufficiently well aligned given the number of
110 -- bits, and the ones used when the object is not known to be aligned.
111 -- This routine is used to determine which set to use. Obj is a reference
112 -- to the object, and Csiz is the component size of the packed array.
113 -- True is returned if the alignment of object is known to be sufficient,
114 -- defined as 1 for odd bit sizes, 4 for bit sizes divisible by 4, and
115 -- 2 otherwise.
118 -- Build a left shift node, checking for the case of a shift count of zero
121 -- Build a right shift node, checking for the case of a shift count of zero
123 function RJ_Unchecked_Convert_To
126 -- The packed array code does unchecked conversions which in some cases
127 -- may involve non-discrete types with differing sizes. The semantics of
128 -- such conversions is potentially endianness dependent, and the effect
129 -- we want here for such a conversion is to do the conversion in size as
130 -- though numeric items are involved, and we extend or truncate on the
131 -- left side. This happens naturally in the little-endian case, but in
132 -- the big endian case we can get left justification, when what we want
133 -- is right justification. This routine does the unchecked conversion in
134 -- a stepwise manner to ensure that it gives the expected result. Hence
135 -- the name (RJ = Right justified). The parameters Typ and Expr are as
136 -- for the case of a normal Unchecked_Convert_To call.
139 -- This routine is called in the Get and Set case for arrays that are
140 -- packed but not bit-packed, meaning that they have at least one
141 -- subscript that is of an enumeration type with a non-standard
142 -- representation. This routine modifies the given node to properly
143 -- reference the corresponding packed array type.
145 procedure Setup_Inline_Packed_Array_Reference
151 -- This procedure performs common processing on the N_Indexed_Component
152 -- parameter given as N, whose prefix is a reference to a packed array.
153 -- This is used for the get and set when the component size is 1, 2, 4,
154 -- or for other component sizes when the packed array type is a modular
155 -- type (i.e. the cases that are handled with inline code).
156 --
157 -- On entry:
158 --
159 -- N is the N_Indexed_Component node for the packed array reference
160 --
161 -- Atyp is the constrained array type (the actual subtype has been
162 -- computed if necessary to obtain the constraints, but this is still
163 -- the original array type, not the Packed_Array_Impl_Type value).
164 --
165 -- Obj is the object which is to be indexed. It is always of type Atyp.
166 --
167 -- On return:
168 --
169 -- Obj is the object containing the desired bit field. It is of type
170 -- Unsigned, Long_Unsigned, or Long_Long_Unsigned, and is either the
171 -- entire value, for the small static case, or the proper selected byte
172 -- from the array in the large or dynamic case. This node is analyzed
173 -- and resolved on return.
174 --
175 -- Shift is a node representing the shift count to be used in the
176 -- rotate right instruction that positions the field for access.
177 -- This node is analyzed and resolved on return.
178 --
179 -- Cmask is a mask corresponding to the width of the component field.
180 -- Its value is 2 ** Csize - 1 (e.g. 2#1111# for component size of 4).
181 --
182 -- Note: in some cases the call to this routine may generate actions
183 -- (for handling multi-use references and the generation of the packed
184 -- array type on the fly). Such actions are inserted into the tree
185 -- directly using Insert_Action.
188 -- Perform appropriate justification and byte ordering adjustments for N,
189 -- an element of a packed array type, when both the component type and
190 -- the enclosing packed array type have reverse scalar storage order.
191 -- On little-endian targets, the value is left justified before byte
192 -- swapping. The Etype of the returned expression is an integer type of
193 -- an appropriate power-of-2 size.
195 --------------------------
196 -- Revert_Storage_Order --
197 --------------------------
207 -- Swapping function
213 begin
216 -- Array component size is less than a byte: no swapping needed
221 else
222 -- Select byte swapping function depending on array component size
244 Arg :=
251 Adjusted :=
255 else
263 ------------------------------
264 -- Compute_Linear_Subscript --
265 ------------------------------
267 procedure Compute_Linear_Subscript
271 is
278 begin
281 -- Loop through dimensions
290 -- Get expression for the subscript value. First, if Do_Range_Check
291 -- is set on a subscript, then we must do a range check against the
292 -- original bounds (not the bounds of the packed array type). We do
293 -- this by introducing a subtype conversion.
297 then
301 -- Now evolve the expression for the subscript. First convert
302 -- the subscript to be zero based and of an integer type.
304 -- Case of integer type, where we just subtract to get lower bound
308 -- If length of integer type is smaller than standard integer,
309 -- then we convert to integer first, then do the subtract
311 -- Integer (subscript) - Integer (Styp'First)
314 Newsub :=
317 Right_Opnd =>
323 -- For larger integer types, subtract first, then convert to
324 -- integer, this deals with strange long long integer bounds.
326 -- Integer (subscript - Styp'First)
328 else
329 Newsub :=
333 Right_Opnd =>
339 -- For the enumeration case, we have to use 'Pos to get the value
340 -- to work with before subtracting the lower bound.
342 -- Integer (Styp'Pos (subscr)) - Integer (Styp'Pos (Styp'First));
344 -- This is not quite right for bizarre cases where the size of the
345 -- enumeration type is > Integer'Size bits due to rep clause ???
347 else
350 Newsub :=
358 Right_Opnd =>
371 -- For the first subscript, we just copy that subscript value
376 -- Otherwise, we must multiply what we already have by the current
377 -- stride and then add in the new value to the evolving subscript.
379 else
380 Subscr :=
382 Left_Opnd =>
385 Right_Opnd =>
392 -- Move to next subscript
399 -------------------------
400 -- Convert_To_PAT_Type --
401 -------------------------
403 -- The PAT is always obtained from the actual subtype
408 begin
413 -- Just replace the etype with the packed array type. This works because
414 -- the expression will not be further analyzed, and Gigi considers the
415 -- two types equivalent in any case.
417 -- This is not strictly the case ??? If the reference is an actual in
418 -- call, the expansion of the prefix is delayed, and must be reanalyzed,
419 -- see Reset_Packed_Prefix. On the other hand, if the prefix is a simple
420 -- array reference, reanalysis can produce spurious type errors when the
421 -- PAT type is replaced again with the original type of the array. Same
422 -- for the case of a dereference. Ditto for function calls: expansion
423 -- may introduce additional actuals which will trigger errors if call is
424 -- reanalyzed. The following is correct and minimal, but the handling of
425 -- more complex packed expressions in actuals is confused. Probably the
426 -- problem only remains for actuals in calls.
431 or else
435 then
440 -----------------------------------
441 -- Create_Packed_Array_Impl_Type --
442 -----------------------------------
463 -- This procedure is called with Decl set to the declaration for the
464 -- packed array type. It creates the type and installs it as required.
467 -- Sets PB_Type to Packed_Bytes{1,2,4} as required by the alignment
468 -- requirements (see documentation in the spec of this package).
470 -----------------
471 -- Install_PAT --
472 -----------------
477 begin
478 -- We do not want to put the declaration we have created in the tree
479 -- since it is often hard, and sometimes impossible to find a proper
480 -- place for it (the impossible case arises for a packed array type
481 -- with bounds depending on the discriminant, a declaration cannot
482 -- be put inside the record, and the reference to the discriminant
483 -- cannot be outside the record).
485 -- The solution is to analyze the declaration while temporarily
486 -- attached to the tree at an appropriate point, and then we install
487 -- the resulting type as an Itype in the packed array type field of
488 -- the original type, so that no explicit declaration is required.
490 -- Note: the packed type is created in the scope of its parent type.
491 -- There are at least some cases where the current scope is deeper,
492 -- and so when this is the case, we temporarily reset the scope
493 -- for the definition. This is clearly safe, since the first use
494 -- of the packed array type will be the implicit reference from
495 -- the corresponding unpacked type when it is elaborated.
499 else
513 Pop_Scope;
516 -- Set Esize and RM_Size to the actual size of the packed object
517 -- Do not reset RM_Size if already set, as happens in the case of
518 -- a modular type.
530 -- Set remaining fields of packed array type
538 -- Propagate representation aspects
546 -- For a non-bit-packed array, propagate reverse storage order
547 -- flag from original base type to packed array base type.
550 Set_Reverse_Storage_Order
554 -- We definitely do not want to delay freezing for packed array
555 -- types. This is of particular importance for the itypes that are
556 -- generated for record components depending on discriminants where
557 -- there is no place to put the freeze node.
562 -- If we did allocate a freeze node, then clear out the reference
563 -- since it is obsolete (should we delete the freeze node???)
569 -----------------
570 -- Set_PB_Type --
571 -----------------
574 begin
575 -- If the user has specified an explicit alignment for the
576 -- type or component, take it into account.
581 then
586 then
589 else
594 -- Start of processing for Create_Packed_Array_Impl_Type
596 begin
597 -- If we already have a packed array type, nothing to do
603 -- If our immediate ancestor subtype is constrained, and it already
604 -- has a packed array type, then just share the same type, since the
605 -- bounds must be the same. If the ancestor is not an array type but
606 -- a private type, as can happen with multiple instantiations, create
607 -- a new packed type, to avoid privacy issues.
616 then
622 -- We preset the result type size from the size of the original array
623 -- type, since this size clearly belongs to the packed array type. The
624 -- size of the conceptual unpacked type is always set to unknown.
628 -- Case of an array where at least one index is of an enumeration
629 -- type with a non-standard representation, but the component size
630 -- is not appropriate for bit packing. This is the case where we
631 -- have Is_Packed set (we would never be in this unit otherwise),
632 -- but Is_Bit_Packed_Array is false.
634 -- Note that if the component size is appropriate for bit packing,
635 -- then the circuit for the computation of the subscript properly
636 -- deals with the non-standard enumeration type case by taking the
637 -- Pos anyway.
641 -- Here we build a declaration:
643 -- type tttP is array (index1, index2, ...) of component_type
645 -- where index1, index2, are the index types. These are the same
646 -- as the index types of the original array, except for the non-
647 -- standard representation enumeration type case, where we have
648 -- two subcases.
650 -- For the unconstrained array case, we use
652 -- Natural range <>
654 -- For the constrained case, we use
656 -- Natural range Enum_Type'Pos (Enum_Type'First) ..
657 -- Enum_Type'Pos (Enum_Type'Last);
659 -- Note that tttP is created even if no index subtype is a non
660 -- standard enumeration, because we still need to remove padding
661 -- normally inserted for component alignment.
663 PAT :=
669 declare
676 begin
685 -- Unconstrained case
694 -- Constrained case
696 else
700 else
703 Subtype_Mark =>
705 Constraint =>
707 Range_Expression =>
709 Low_Bound =>
711 Prefix =>
716 Prefix =>
720 High_Bound =>
722 Prefix =>
727 Prefix =>
738 Typedef :=
741 Component_Definition =>
744 Subtype_Indication =>
747 else
748 Typedef :=
751 Component_Definition =>
754 Subtype_Indication =>
758 Decl :=
764 -- Set type as packed array type and install it
767 Install_PAT;
770 -- Case of bit-packing required for unconstrained array. We create
771 -- a subtype that is equivalent to use Packed_Bytes{1,2,4} as needed.
775 -- When generating standard DWARF (i.e when GNAT_Encodings is
776 -- DWARF_GNAT_Encodings_Minimal), the ___XP suffix will be stripped
777 -- by the back-end but generate it anyway to ease compiler debugging.
778 -- This will help to distinguish implementation types from original
779 -- packed arrays.
781 PAT :=
786 Set_PB_Type;
788 Decl :=
792 Install_PAT;
795 -- Remaining code is for the case of bit-packing for constrained array
797 -- The name of the packed array subtype is
799 -- ttt___XPsss
801 -- where sss is the component size in bits and ttt is the name of
802 -- the parent packed type.
804 else
805 PAT :=
811 -- Build an expression for the length of the array in bits.
812 -- This is the product of the length of each of the dimensions
814 declare
817 begin
820 loop
821 Len_Dim :=
831 else
832 Len_Expr :=
843 -- Temporarily attach the length expression to the tree and analyze
844 -- and resolve it, so that we can test its value. We assume that the
845 -- total length fits in type Integer. This expression may involve
846 -- discriminants, so we treat it as a default/per-object expression.
851 -- Use a modular type if possible. We can do this if we have
852 -- static bounds, and the length is small enough, and the length
853 -- is not zero. We exclude the zero length case because the size
854 -- of things is always at least one, and the zero length object
855 -- would have an anomalous size.
860 -- Check for size known to be too large
864 then
866 Error_Msg_N
869 else
870 Error_Msg_N
875 -- Reset length to arbitrary not too high value to continue
881 -- We normally consider small enough to mean no larger than the
882 -- value of System_Max_Binary_Modulus_Power, checking that in the
883 -- case of values longer than word size, we have long shifts.
886 and then
890 then
891 -- We can use the modular type, it has the form:
893 -- subtype tttPn is btyp
894 -- range 0 .. 2 ** ((Typ'Length (1)
895 -- * ... * Typ'Length (n)) * Csize) - 1;
897 -- The bounds are statically known, and btyp is one of the
898 -- unsigned types, depending on the length.
912 else
919 Decl :=
922 Subtype_Indication =>
926 Constraint =>
928 Range_Expression =>
930 Low_Bound =>
938 Install_PAT;
940 -- Propagate a given alignment to the modular type. This can
941 -- cause it to be under-aligned, but that's OK.
951 -- Could not use a modular type, for all other cases, we build
952 -- a packed array subtype:
954 -- subtype tttPn is
955 -- System.Packed_Bytes{1,2,4} (0 .. (Bits + 7) / 8 - 1);
957 -- Bits is the length of the array in bits
959 Set_PB_Type;
961 Bits_U1 :=
963 Left_Opnd =>
965 Left_Opnd =>
969 Right_Opnd =>
974 PAT_High :=
976 Left_Opnd =>
982 Decl :=
985 Subtype_Indication =>
988 Constraint =>
992 Low_Bound =>
994 High_Bound =>
997 Install_PAT;
999 -- Currently the code in this unit requires that packed arrays
1000 -- represented by non-modular arrays of bytes be on a byte
1001 -- boundary for bit sizes handled by System.Pack_nn units.
1002 -- That's because these units assume the array being accessed
1003 -- starts on a byte boundary.
1011 -----------------------------------
1012 -- Expand_Bit_Packed_Element_Set --
1013 -----------------------------------
1020 -- Used to preserve assignment OK status when assignment is rewritten
1023 -- Initially Rhs is the right hand side value, it will be replaced
1024 -- later by an appropriate unchecked conversion for the assignment.
1034 -- The expression for the shift value that is required
1037 -- Set True if Shift has been used in the generated code at least once,
1038 -- so that it must be duplicated if used again.
1045 -- If the value of the right hand side as an integer constant is
1046 -- known at compile time, Rhs_Val_Known is set True, and Rhs_Val
1047 -- contains the value. Otherwise Rhs_Val_Known is set False, and
1048 -- the Rhs_Val is undefined.
1051 -- Function used to get the value of Shift, making sure that it
1052 -- gets duplicated if the function is called more than once.
1054 ---------------
1055 -- Get_Shift --
1056 ---------------
1059 begin
1060 -- If we used the shift value already, then duplicate it. We
1061 -- set a temporary parent in case actions have to be inserted.
1067 -- If first time, use Shift unchanged, and set flag for first use
1069 else
1075 -- Start of processing for Expand_Bit_Packed_Element_Set
1077 begin
1087 -- We remove side effects, in case the rhs modifies the lhs, because we
1088 -- are about to transform the rhs into an expression that first READS
1089 -- the lhs, so we can do the necessary shifting and masking. Example:
1090 -- "X(2) := F(...);" where F modifies X(3). Otherwise, the side effect
1091 -- will be lost.
1095 -- We convert the right hand side to the proper subtype to ensure
1096 -- that an appropriate range check is made (since the normal range
1097 -- check from assignment will be lost in the transformations). This
1098 -- conversion is analyzed immediately so that subsequent processing
1099 -- can work with an analyzed Rhs (and e.g. look at its Etype)
1101 -- If the right-hand side is a string literal, create a temporary for
1102 -- it, constant-folding is not ready to wrap the bit representation
1103 -- of a string literal.
1106 declare
1108 begin
1109 Decl :=
1123 -- If we are building the initialization procedure for a packed array,
1124 -- and Initialize_Scalars is enabled, each component assignment is an
1125 -- out-of-range value by design. Compile this value without checks,
1126 -- because a call to the array init_proc must not raise an exception.
1128 -- Condition is not consistent with description above, Within_Init_Proc
1129 -- is True also when we are building the IP for a record or protected
1130 -- type that has a packed array component???
1132 if Within_Init_Proc
1133 and then Initialize_Scalars
1134 then
1136 else
1140 -- For the AAMP target, indexing of certain packed array is passed
1141 -- through to the back end without expansion, because the expansion
1142 -- results in very inefficient code on that target. This allows the
1143 -- GNAAMP back end to generate specialized macros that support more
1144 -- efficient indexing of packed arrays with components having sizes
1145 -- that are small powers of two.
1147 if AAMP_On_Target
1149 then
1153 -- Case of component size 1,2,4 or any component size for the modular
1154 -- case. These are the cases for which we can inline the code.
1158 then
1161 -- The statement to be generated is:
1163 -- Obj := atyp!((Obj and Mask1) or (shift_left (rhs, Shift)))
1165 -- or in the case of a freestanding Reverse_Storage_Order object,
1167 -- Obj := Swap (atyp!((Swap (Obj) and Mask1)
1168 -- or (shift_left (rhs, Shift))))
1170 -- where Mask1 is obtained by shifting Cmask left Shift bits
1171 -- and then complementing the result.
1173 -- the "and Mask1" is omitted if rhs is constant and all 1 bits
1175 -- the "or ..." is omitted if rhs is constant and all 0 bits
1177 -- rhs is converted to the appropriate type
1179 -- The result is converted back to the array type, since
1180 -- otherwise we lose knowledge of the packed nature.
1182 -- Determine if right side is all 0 bits or all 1 bits
1188 -- The following test catches the case of an unchecked conversion of
1189 -- an integer literal. This results from optimizing aggregates of
1190 -- packed types.
1194 then
1198 else
1203 -- Some special checks for the case where the right hand value is
1204 -- known at compile time. Basically we have to take care of the
1205 -- implicit conversion to the subtype of the component object.
1209 -- If we have a biased component type then we must manually do the
1210 -- biasing, since we are taking responsibility in this case for
1211 -- constructing the exact bit pattern to be used.
1217 -- For a negative value, we manually convert the two's complement
1218 -- value to a corresponding unsigned value, so that the proper
1219 -- field width is maintained. If we did not do this, we would
1220 -- get too many leading sign bits later on.
1227 -- Now create copies removing side effects. Note that in some complex
1228 -- cases, this may cause the fact that we have already set a packed
1229 -- array type on Obj to get lost. So we save the type of Obj, and
1230 -- make sure it is reset properly.
1235 -- First we deal with the "and"
1238 declare
1242 begin
1244 Mask1 :=
1250 else
1253 Mask1 :=
1258 New_Rhs :=
1265 -- Then deal with the "or"
1268 declare
1272 -- Adjust Rhs by bias if biased representation for components
1273 -- or remove extraneous high order sign bits if signed.
1278 begin
1279 -- For biased case, do the required biasing by simply
1280 -- converting to the biased subtype (the conversion
1281 -- will generate the required bias).
1286 -- For a signed integer type that is not biased, generate
1287 -- a conversion to unsigned to strip high order sign bits.
1293 -- Set Etype, since it can be referenced before the node is
1294 -- completely analyzed.
1298 -- We now need to do an unchecked conversion of the
1299 -- result to the target type, but it is important that
1300 -- this conversion be a right justified conversion and
1301 -- not a left justified conversion.
1306 begin
1307 if Rhs_Val_Known
1309 then
1310 Or_Rhs :=
1315 else
1316 -- We have to convert the right hand side to Etype (Obj).
1317 -- A special case arises if what we have now is a Val
1318 -- attribute reference whose expression type is Etype (Obj).
1319 -- This happens for assignments of fields from the same
1320 -- array. In this case we get the required right hand side
1321 -- by simply removing the inner attribute reference.
1326 then
1328 Fixup_Rhs;
1330 -- If the value of the right hand side is a known integer
1331 -- value, then just replace it by an untyped constant,
1332 -- which will be properly retyped when we analyze and
1333 -- resolve the expression.
1337 -- Note that Rhs_Val has already been normalized to
1338 -- be an unsigned value with the proper number of bits.
1342 -- Otherwise we need an unchecked conversion
1344 else
1345 Fixup_Rhs;
1356 New_Rhs :=
1363 -- Now do the rewrite
1368 Expression =>
1372 -- All other component sizes for non-modular case
1374 else
1375 -- We generate
1377 -- Set_nn (Arr'address, Subscr, Bits_nn!(Rhs))
1379 -- where Subscr is the computed linear subscript
1381 declare
1388 begin
1391 -- Error, most likely High_Integrity_Mode restriction
1396 -- Acquire proper Set entity. We use the aligned or unaligned
1397 -- case as appropriate.
1401 else
1405 -- Now generate the set reference
1412 -- Set indication of whether the packed array has reverse SSO
1414 Rev_SSO :=
1415 New_Occurrence_Of
1418 -- Below we must make the assumption that Obj is
1419 -- at least byte aligned, since otherwise its address
1420 -- cannot be taken. The assumption holds since the
1421 -- only arrays that can be misaligned are small packed
1422 -- arrays which are implemented as a modular type, and
1423 -- that is not the case here.
1432 Subscr,
1434 Rev_SSO)));
1442 -------------------------------------
1443 -- Expand_Packed_Address_Reference --
1444 -------------------------------------
1451 begin
1452 -- We build an expression that has the form
1454 -- outer_object'Address
1455 -- + (linear-subscript * component_size for each array reference
1456 -- + field'Bit_Position for each record field
1457 -- + ...
1458 -- + ...) / Storage_Unit;
1465 Left_Opnd =>
1471 Right_Opnd =>
1475 Right_Opnd =>
1481 ---------------------------------
1482 -- Expand_Packed_Bit_Reference --
1483 ---------------------------------
1490 begin
1491 -- We build an expression that has the form
1493 -- (linear-subscript * component_size for each array reference
1494 -- + field'Bit_Position for each record field
1495 -- + ...
1496 -- + ...) mod Storage_Unit;
1509 ------------------------------------
1510 -- Expand_Packed_Boolean_Operator --
1511 ------------------------------------
1513 -- This routine expands "a op b" for the packed cases
1525 begin
1537 -- Deal with silly case of XOR where the subcomponent has a range
1538 -- True .. True where an exception must be raised.
1544 -- Now that that silliness is taken care of, get packed array type
1551 -- For the modular case, we expand a op b into
1553 -- rtyp!(pat!(a) op pat!(b))
1555 -- where rtyp is the Etype of the left operand. Note that we do not
1556 -- convert to the base type, since this would be unconstrained, and
1557 -- hence not have a corresponding packed array type set.
1559 -- Note that both operands must be modular for this code to be used
1562 and then
1564 then
1565 declare
1568 begin
1582 -- For the array case, we insert the actions
1584 -- Result : Ltype;
1586 -- System.Bit_Ops.Bit_And/Or/Xor
1587 -- (Left'Address,
1588 -- Ltype'Length * Ltype'Component_Size;
1589 -- Right'Address,
1590 -- Rtype'Length * Rtype'Component_Size
1591 -- Result'Address);
1593 -- where Left and Right are the Packed_Bytes{1,2,4} operands and
1594 -- the second argument and fourth arguments are the lengths of the
1595 -- operands in bits. Then we replace the expression by a reference
1596 -- to Result.
1598 -- Note that if we are mixing a modular and array operand, everything
1599 -- works fine, since we ensure that the modular representation has the
1600 -- same physical layout as the array representation (that's what the
1601 -- left justified modular stuff in the big-endian case is about).
1603 else
1604 declare
1608 begin
1634 Left_Opnd =>
1636 Prefix =>
1637 New_Occurrence_Of
1641 Right_Opnd =>
1649 Left_Opnd =>
1651 Prefix =>
1652 New_Occurrence_Of
1656 Right_Opnd =>
1671 -------------------------------------
1672 -- Expand_Packed_Element_Reference --
1673 -------------------------------------
1687 begin
1688 -- If the node is an actual in a call, the prefix has not been fully
1689 -- expanded, to account for the additional expansion for in-out actuals
1690 -- (see expand_actuals for details). If the prefix itself is a packed
1691 -- reference as well, we have to recurse to complete the transformation
1692 -- of the prefix.
1697 then
1701 -- The prefix may be rewritten below as a conversion. If it is a source
1702 -- entity generate reference to it now, to prevent spurious warnings
1703 -- about unused entities.
1707 then
1711 -- If not bit packed, we have the enumeration case, which is easily
1712 -- dealt with (just adjust the subscripts of the indexed component)
1714 -- Note: this leaves the result as an indexed component, which is
1715 -- still a variable, so can be used in the assignment case, as is
1716 -- required in the enumeration case.
1723 -- Remaining processing is for the bit-packed case
1732 -- For the AAMP target, indexing of certain packed array is passed
1733 -- through to the back end without expansion, because the expansion
1734 -- results in very inefficient code on that target. This allows the
1735 -- GNAAMP back end to generate specialized macros that support more
1736 -- efficient indexing of packed arrays with components having sizes
1737 -- that are small powers of two.
1739 if AAMP_On_Target
1741 then
1745 -- Case of component size 1,2,4 or any component size for the modular
1746 -- case. These are the cases for which we can inline the code.
1750 then
1755 -- We generate a shift right to position the field, followed by a
1756 -- masking operation to extract the bit field, and we finally do an
1757 -- unchecked conversion to convert the result to the required target.
1759 -- Note that the unchecked conversion automatically deals with the
1760 -- bias if we are dealing with a biased representation. What will
1761 -- happen is that we temporarily generate the biased representation,
1762 -- but almost immediately that will be converted to the original
1763 -- unbiased component type, and the bias will disappear.
1765 Arg :=
1771 -- Component extraction is performed on a native endianness scalar
1772 -- value: if Atyp has reverse storage order, then it has been byte
1773 -- swapped, and if the component being extracted is itself of a
1774 -- composite type with reverse storage order, then we need to swap
1775 -- it back to its expected endianness after extraction.
1780 then
1784 -- We needed to analyze this before we do the unchecked convert
1785 -- below, but we need it temporarily attached to the tree for
1786 -- this analysis (hence the temporary Set_Parent call).
1793 -- All other component sizes for non-modular case
1795 else
1796 -- We generate
1798 -- Component_Type!(Get_nn (Arr'address, Subscr))
1800 -- where Subscr is the computed linear subscript
1802 declare
1806 New_Occurrence_Of
1809 begin
1810 -- Acquire proper Get entity. We use the aligned or unaligned
1811 -- case as appropriate.
1815 else
1819 -- Now generate the get reference
1823 -- Below we make the assumption that Obj is at least byte
1824 -- aligned, since otherwise its address cannot be taken.
1825 -- The assumption holds since the only arrays that can be
1826 -- misaligned are small packed arrays which are implemented
1827 -- as a modular type, and that is not the case here.
1837 Subscr,
1838 Rev_SSO))));
1845 ----------------------
1846 -- Expand_Packed_Eq --
1847 ----------------------
1849 -- Handles expansion of "=" on packed array types
1863 begin
1873 LLexpr :=
1875 Left_Opnd =>
1879 Right_Opnd =>
1882 RLexpr :=
1884 Left_Opnd =>
1888 Right_Opnd =>
1891 -- For the modular case, we transform the comparison to:
1893 -- Ltyp'Length = Rtyp'Length and then PAT!(L) = PAT!(R)
1895 -- where PAT is the packed array type. This works fine, since in the
1896 -- modular case we guarantee that the unused bits are always zeroes.
1897 -- We do have to compare the lengths because we could be comparing
1898 -- two different subtypes of the same base type.
1903 Left_Opnd =>
1908 Right_Opnd =>
1913 -- For the non-modular case, we call a runtime routine
1915 -- System.Bit_Ops.Bit_Eq
1916 -- (L'Address, L_Length, R'Address, R_Length)
1918 -- where PAT is the packed array type, and the lengths are the lengths
1919 -- in bits of the original packed arrays. This routine takes care of
1920 -- not comparing the unused bits in the last byte.
1922 else
1931 LLexpr,
1937 RLexpr)));
1943 -----------------------
1944 -- Expand_Packed_Not --
1945 -----------------------
1947 -- Handles expansion of "not" on packed array types
1958 begin
1962 -- Deal with silly False..False and True..True subtype case
1966 -- Now that the silliness is taken care of, get packed array type
1971 -- For the case where the packed array type is a modular type, "not A"
1972 -- expands simply into:
1974 -- Rtyp!(PAT!(A) xor Mask)
1976 -- where PAT is the packed array type, Mask is a mask of all 1 bits of
1977 -- length equal to the size of this packed type, and Rtyp is the actual
1978 -- actual subtype of the operand.
1990 -- For the array case, we insert the actions
1992 -- Result : Typ;
1994 -- System.Bit_Ops.Bit_Not
1995 -- (Opnd'Address,
1996 -- Typ'Length * Typ'Component_Size,
1997 -- Result'Address);
1999 -- where Opnd is the Packed_Bytes{1,2,4} operand and the second argument
2000 -- is the length of the operand in bits. We then replace the expression
2001 -- with a reference to Result.
2003 else
2004 declare
2007 begin
2021 Left_Opnd =>
2023 Prefix =>
2024 New_Occurrence_Of
2028 Right_Opnd =>
2042 -----------------------------
2043 -- Get_Base_And_Bit_Offset --
2044 -----------------------------
2046 procedure Get_Base_And_Bit_Offset
2050 is
2056 begin
2060 -- We build up an expression serially that has the form
2062 -- linear-subscript * component_size for each array reference
2063 -- + field'Bit_Position for each record field
2064 -- + ...
2066 loop
2074 Term :=
2077 Right_Opnd =>
2083 Term :=
2088 else
2095 else
2096 Offset :=
2106 -------------------------------------
2107 -- Involves_Packed_Array_Reference --
2108 -------------------------------------
2111 begin
2114 then
2120 else
2125 --------------------------
2126 -- Known_Aligned_Enough --
2127 --------------------------
2133 -- If the component is in a record that contains previous packed
2134 -- components, consider it unaligned because the back-end might
2135 -- choose to pack the rest of the record. Lead to less efficient code,
2136 -- but safer vis-a-vis of back-end choices.
2138 --------------------------------
2139 -- In_Partially_Packed_Record --
2140 --------------------------------
2146 begin
2162 -- Start of processing for Known_Aligned_Enough
2164 begin
2165 -- Odd bit sizes don't need alignment anyway
2170 -- If we have a specified alignment, see if it is sufficient, if not
2171 -- then we can't possibly be aligned enough in any case.
2174 -- Alignment required is 4 if size is a multiple of 4, and
2175 -- 2 otherwise (e.g. 12 bits requires 4, 10 bits requires 2)
2182 -- OK, alignment should be sufficient, if object is aligned
2184 -- If object is strictly aligned, then it is definitely aligned
2189 -- Case of subscripted array reference
2193 -- If we have a pointer to an array, then this is definitely
2194 -- aligned, because pointers always point to aligned versions.
2199 -- Otherwise, go look at the prefix
2201 else
2205 -- Case of record field
2209 -- What is significant here is whether the record type is packed
2213 then
2216 -- Or the component has a component clause which might cause
2217 -- the component to become unaligned (we can't tell if the
2218 -- backend is doing alignment computations).
2226 -- In all other cases, go look at prefix
2228 else
2235 -- For a formal parameter, it is safer to assume that it is not
2236 -- aligned, because the formal may be unconstrained while the actual
2237 -- is constrained. In this situation, a small constrained packed
2238 -- array, represented in modular form, may be unaligned.
2242 else
2244 -- If none of the above, must be aligned
2249 ---------------------
2250 -- Make_Shift_Left --
2251 ---------------------
2256 begin
2259 else
2260 Nod :=
2269 ----------------------
2270 -- Make_Shift_Right --
2271 ----------------------
2276 begin
2279 else
2280 Nod :=
2289 -----------------------------
2290 -- RJ_Unchecked_Convert_To --
2291 -----------------------------
2293 function RJ_Unchecked_Convert_To
2296 is
2305 begin
2309 -- For a little-endian target type stored byte-swapped on a
2310 -- big-endian machine, do not mask to Target_Siz bits.
2312 if Bytes_Big_Endian
2314 or else
2317 then
2321 -- First step, if the source type is not a discrete type, then we first
2322 -- convert to a modular type of the source length, since otherwise, on
2323 -- a big-endian machine, we get left-justification. We do it for little-
2324 -- endian machines as well, because there might be junk bits that are
2325 -- not cleared if the type is not numeric.
2329 then
2333 -- In the big endian case, if the lengths of the two types differ, then
2334 -- we must worry about possible left justification in the conversion,
2335 -- and avoiding that is what this is all about.
2339 -- Next step. If the target is not a discrete type, then we first
2340 -- convert to a modular type of the target length, since otherwise,
2341 -- on a big-endian machine, we get left-justification.
2348 -- And now we can do the final conversion to the target type
2353 ----------------------------------------------
2354 -- Setup_Enumeration_Packed_Array_Reference --
2355 ----------------------------------------------
2357 -- All we have to do here is to find the subscripts that correspond to the
2358 -- index positions that have non-standard enumeration types and insert a
2359 -- Pos attribute to get the proper subscript value.
2361 -- Finally the prefix must be uncheck-converted to the corresponding packed
2362 -- array type.
2364 -- Note that the component type is unchanged, so we do not need to fiddle
2365 -- with the types (Gigi always automatically takes the packed array type if
2366 -- it is set, as it will be in this case).
2374 begin
2375 -- If the array is unconstrained, then we replace the array reference
2376 -- with its actual subtype. This actual subtype will have a packed array
2377 -- type with appropriate bounds.
2385 declare
2389 begin
2392 then
2407 Prefix =>
2414 -----------------------------------------
2415 -- Setup_Inline_Packed_Array_Reference --
2416 -----------------------------------------
2418 procedure Setup_Inline_Packed_Array_Reference
2424 is
2431 begin
2443 else
2446 -- In the case where the PAT is a modular type, we want the actual
2447 -- size in bits of the modular value we use. This is neither the
2448 -- Object_Size nor the Value_Size, either of which may have been
2449 -- reset to strange values, but rather the minimum size. Note that
2450 -- since this is a modular type with full range, the issue of
2451 -- biased representation does not arise.
2458 -- If the component size is not 1, then the subscript must be multiplied
2459 -- by the component size to get the shift count.
2462 Shift :=
2468 -- If we have the array case, then this shift count must be broken down
2469 -- into a byte subscript, and a shift within the byte.
2473 declare
2476 begin
2477 -- We must analyze shift, since we will duplicate it
2480 Analyze_And_Resolve
2483 -- The shift count within the word is
2484 -- shift mod Osiz
2486 New_Shift :=
2491 -- The subscript to be used on the PAT array is
2492 -- shift / Osiz
2494 Obj :=
2505 -- For the modular integer case, the object to be manipulated is the
2506 -- entire array, so Obj is unchanged. Note that we will reset its type
2507 -- to PAT before returning to the caller.
2509 else
2513 -- The one remaining step is to modify the shift count for the
2514 -- big-endian case. Consider the following example in a byte:
2516 -- xxxxxxxx bits of byte
2517 -- vvvvvvvv bits of value
2518 -- 33221100 little-endian numbering
2519 -- 00112233 big-endian numbering
2521 -- Here we have the case of 2-bit fields
2523 -- For the little-endian case, we already have the proper shift count
2524 -- set, e.g. for element 2, the shift count is 2*2 = 4.
2526 -- For the big endian case, we have to adjust the shift count, computing
2527 -- it as (N - F) - Shift, where N is the number of bits in an element of
2528 -- the array used to implement the packed array, F is the number of bits
2529 -- in a source array element, and Shift is the count so far computed.
2531 -- We also have to adjust if the storage order is reversed
2534 Shift :=
2545 -- Make sure final type of object is the appropriate packed type