| blob | 6ff75278d9705758f1169545d35d8f062f7cd569 |
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-2014, 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 -- Entity Tables for Packed Access Routines --
82 ----------------------------------------------
84 -- For the cases of component size = 3,5-7,9-15,17-31,33-63 we call library
85 -- routines. This table provides the entity for the proper routine.
89 -- Array of Bits_nn entities. Note that we do not use library routines
90 -- for the 8-bit and 16-bit cases, but we still fill in the table, using
91 -- entries from System.Unsigned, because we also use this table for
92 -- certain special unchecked conversions in the big-endian case.
159 -- Array of Get routine entities. These are used to obtain an element from
160 -- a packed array. The N'th entry is used to obtain elements from a packed
161 -- array whose component size is N. RE_Null is used as a null entry, for
162 -- the cases where a library routine is not used.
229 -- Array of Get routine entities to be used in the case where the packed
230 -- array is itself a component of a packed structure, and therefore may not
231 -- be fully aligned. This only affects the even sizes, since for the odd
232 -- sizes, we do not get any fixed alignment in any case.
299 -- Array of Set routine entities. These are used to assign an element of a
300 -- packed array. The N'th entry is used to assign elements for a packed
301 -- array whose component size is N. RE_Null is used as a null entry, for
302 -- the cases where a library routine is not used.
369 -- Array of Set routine entities to be used in the case where the packed
370 -- array is itself a component of a packed structure, and therefore may not
371 -- be fully aligned. This only affects the even sizes, since for the odd
372 -- sizes, we do not get any fixed alignment in any case.
439 -----------------------
440 -- Local Subprograms --
441 -----------------------
443 procedure Compute_Linear_Subscript
447 -- Given a constrained array type Atyp, and an indexed component node N
448 -- referencing an array object of this type, build an expression of type
449 -- Standard.Integer representing the zero-based linear subscript value.
450 -- This expression includes any required range checks.
453 -- Given an expression of a packed array type, builds a corresponding
454 -- expression whose type is the implementation type used to represent
455 -- the packed array. Aexp is analyzed and resolved on entry and on exit.
457 procedure Get_Base_And_Bit_Offset
461 -- Given a node N for a name which involves a packed array reference,
462 -- return the base object of the reference and build an expression of
463 -- type Standard.Integer representing the zero-based offset in bits
464 -- from Base'Address to the first bit of the reference.
467 -- There are two versions of the Set routines, the ones used when the
468 -- object is known to be sufficiently well aligned given the number of
469 -- bits, and the ones used when the object is not known to be aligned.
470 -- This routine is used to determine which set to use. Obj is a reference
471 -- to the object, and Csiz is the component size of the packed array.
472 -- True is returned if the alignment of object is known to be sufficient,
473 -- defined as 1 for odd bit sizes, 4 for bit sizes divisible by 4, and
474 -- 2 otherwise.
477 -- Build a left shift node, checking for the case of a shift count of zero
480 -- Build a right shift node, checking for the case of a shift count of zero
482 function RJ_Unchecked_Convert_To
485 -- The packed array code does unchecked conversions which in some cases
486 -- may involve non-discrete types with differing sizes. The semantics of
487 -- such conversions is potentially endianness dependent, and the effect
488 -- we want here for such a conversion is to do the conversion in size as
489 -- though numeric items are involved, and we extend or truncate on the
490 -- left side. This happens naturally in the little-endian case, but in
491 -- the big endian case we can get left justification, when what we want
492 -- is right justification. This routine does the unchecked conversion in
493 -- a stepwise manner to ensure that it gives the expected result. Hence
494 -- the name (RJ = Right justified). The parameters Typ and Expr are as
495 -- for the case of a normal Unchecked_Convert_To call.
498 -- This routine is called in the Get and Set case for arrays that are
499 -- packed but not bit-packed, meaning that they have at least one
500 -- subscript that is of an enumeration type with a non-standard
501 -- representation. This routine modifies the given node to properly
502 -- reference the corresponding packed array type.
504 procedure Setup_Inline_Packed_Array_Reference
510 -- This procedure performs common processing on the N_Indexed_Component
511 -- parameter given as N, whose prefix is a reference to a packed array.
512 -- This is used for the get and set when the component size is 1, 2, 4,
513 -- or for other component sizes when the packed array type is a modular
514 -- type (i.e. the cases that are handled with inline code).
515 --
516 -- On entry:
517 --
518 -- N is the N_Indexed_Component node for the packed array reference
519 --
520 -- Atyp is the constrained array type (the actual subtype has been
521 -- computed if necessary to obtain the constraints, but this is still
522 -- the original array type, not the Packed_Array_Impl_Type value).
523 --
524 -- Obj is the object which is to be indexed. It is always of type Atyp.
525 --
526 -- On return:
527 --
528 -- Obj is the object containing the desired bit field. It is of type
529 -- Unsigned, Long_Unsigned, or Long_Long_Unsigned, and is either the
530 -- entire value, for the small static case, or the proper selected byte
531 -- from the array in the large or dynamic case. This node is analyzed
532 -- and resolved on return.
533 --
534 -- Shift is a node representing the shift count to be used in the
535 -- rotate right instruction that positions the field for access.
536 -- This node is analyzed and resolved on return.
537 --
538 -- Cmask is a mask corresponding to the width of the component field.
539 -- Its value is 2 ** Csize - 1 (e.g. 2#1111# for component size of 4).
540 --
541 -- Note: in some cases the call to this routine may generate actions
542 -- (for handling multi-use references and the generation of the packed
543 -- array type on the fly). Such actions are inserted into the tree
544 -- directly using Insert_Action.
547 -- Perform appropriate justification and byte ordering adjustments for N,
548 -- an element of a packed array type, when both the component type and
549 -- the enclosing packed array type have reverse scalar storage order.
550 -- On little-endian targets, the value is left justified before byte
551 -- swapping. The Etype of the returned expression is an integer type of
552 -- an appropriate power-of-2 size.
554 --------------------------
555 -- Revert_Storage_Order --
556 --------------------------
566 -- Swapping function
572 begin
575 -- Array component size is less than a byte: no swapping needed
580 else
581 -- Select byte swapping function depending on array component size
603 Arg :=
610 Adjusted :=
614 else
622 ------------------------------
623 -- Compute_Linear_Subscript --
624 ------------------------------
626 procedure Compute_Linear_Subscript
630 is
637 begin
640 -- Loop through dimensions
649 -- Get expression for the subscript value. First, if Do_Range_Check
650 -- is set on a subscript, then we must do a range check against the
651 -- original bounds (not the bounds of the packed array type). We do
652 -- this by introducing a subtype conversion.
656 then
660 -- Now evolve the expression for the subscript. First convert
661 -- the subscript to be zero based and of an integer type.
663 -- Case of integer type, where we just subtract to get lower bound
667 -- If length of integer type is smaller than standard integer,
668 -- then we convert to integer first, then do the subtract
670 -- Integer (subscript) - Integer (Styp'First)
673 Newsub :=
676 Right_Opnd =>
682 -- For larger integer types, subtract first, then convert to
683 -- integer, this deals with strange long long integer bounds.
685 -- Integer (subscript - Styp'First)
687 else
688 Newsub :=
692 Right_Opnd =>
698 -- For the enumeration case, we have to use 'Pos to get the value
699 -- to work with before subtracting the lower bound.
701 -- Integer (Styp'Pos (subscr)) - Integer (Styp'Pos (Styp'First));
703 -- This is not quite right for bizarre cases where the size of the
704 -- enumeration type is > Integer'Size bits due to rep clause ???
706 else
709 Newsub :=
717 Right_Opnd =>
730 -- For the first subscript, we just copy that subscript value
735 -- Otherwise, we must multiply what we already have by the current
736 -- stride and then add in the new value to the evolving subscript.
738 else
739 Subscr :=
741 Left_Opnd =>
744 Right_Opnd =>
751 -- Move to next subscript
758 -------------------------
759 -- Convert_To_PAT_Type --
760 -------------------------
762 -- The PAT is always obtained from the actual subtype
767 begin
772 -- Just replace the etype with the packed array type. This works because
773 -- the expression will not be further analyzed, and Gigi considers the
774 -- two types equivalent in any case.
776 -- This is not strictly the case ??? If the reference is an actual in
777 -- call, the expansion of the prefix is delayed, and must be reanalyzed,
778 -- see Reset_Packed_Prefix. On the other hand, if the prefix is a simple
779 -- array reference, reanalysis can produce spurious type errors when the
780 -- PAT type is replaced again with the original type of the array. Same
781 -- for the case of a dereference. Ditto for function calls: expansion
782 -- may introduce additional actuals which will trigger errors if call is
783 -- reanalyzed. The following is correct and minimal, but the handling of
784 -- more complex packed expressions in actuals is confused. Probably the
785 -- problem only remains for actuals in calls.
790 or else
794 then
799 -----------------------------------
800 -- Create_Packed_Array_Impl_Type --
801 -----------------------------------
822 -- This procedure is called with Decl set to the declaration for the
823 -- packed array type. It creates the type and installs it as required.
826 -- Sets PB_Type to Packed_Bytes{1,2,4} as required by the alignment
827 -- requirements (see documentation in the spec of this package).
829 -----------------
830 -- Install_PAT --
831 -----------------
836 begin
837 -- We do not want to put the declaration we have created in the tree
838 -- since it is often hard, and sometimes impossible to find a proper
839 -- place for it (the impossible case arises for a packed array type
840 -- with bounds depending on the discriminant, a declaration cannot
841 -- be put inside the record, and the reference to the discriminant
842 -- cannot be outside the record).
844 -- The solution is to analyze the declaration while temporarily
845 -- attached to the tree at an appropriate point, and then we install
846 -- the resulting type as an Itype in the packed array type field of
847 -- the original type, so that no explicit declaration is required.
849 -- Note: the packed type is created in the scope of its parent type.
850 -- There are at least some cases where the current scope is deeper,
851 -- and so when this is the case, we temporarily reset the scope
852 -- for the definition. This is clearly safe, since the first use
853 -- of the packed array type will be the implicit reference from
854 -- the corresponding unpacked type when it is elaborated.
858 else
872 Pop_Scope;
875 -- Set Esize and RM_Size to the actual size of the packed object
876 -- Do not reset RM_Size if already set, as happens in the case of
877 -- a modular type.
889 -- Set remaining fields of packed array type
897 -- For a non-bit-packed array, propagate reverse storage order
898 -- flag from original base type to packed array base type.
901 Set_Reverse_Storage_Order
905 -- We definitely do not want to delay freezing for packed array
906 -- types. This is of particular importance for the itypes that are
907 -- generated for record components depending on discriminants where
908 -- there is no place to put the freeze node.
913 -- If we did allocate a freeze node, then clear out the reference
914 -- since it is obsolete (should we delete the freeze node???)
920 -----------------
921 -- Set_PB_Type --
922 -----------------
925 begin
926 -- If the user has specified an explicit alignment for the
927 -- type or component, take it into account.
932 then
937 then
940 else
945 -- Start of processing for Create_Packed_Array_Impl_Type
947 begin
948 -- If we already have a packed array type, nothing to do
954 -- If our immediate ancestor subtype is constrained, and it already
955 -- has a packed array type, then just share the same type, since the
956 -- bounds must be the same. If the ancestor is not an array type but
957 -- a private type, as can happen with multiple instantiations, create
958 -- a new packed type, to avoid privacy issues.
967 then
973 -- We preset the result type size from the size of the original array
974 -- type, since this size clearly belongs to the packed array type. The
975 -- size of the conceptual unpacked type is always set to unknown.
979 -- Case of an array where at least one index is of an enumeration
980 -- type with a non-standard representation, but the component size
981 -- is not appropriate for bit packing. This is the case where we
982 -- have Is_Packed set (we would never be in this unit otherwise),
983 -- but Is_Bit_Packed_Array is false.
985 -- Note that if the component size is appropriate for bit packing,
986 -- then the circuit for the computation of the subscript properly
987 -- deals with the non-standard enumeration type case by taking the
988 -- Pos anyway.
992 -- Here we build a declaration:
994 -- type tttP is array (index1, index2, ...) of component_type
996 -- where index1, index2, are the index types. These are the same
997 -- as the index types of the original array, except for the non-
998 -- standard representation enumeration type case, where we have
999 -- two subcases.
1001 -- For the unconstrained array case, we use
1003 -- Natural range <>
1005 -- For the constrained case, we use
1007 -- Natural range Enum_Type'Pos (Enum_Type'First) ..
1008 -- Enum_Type'Pos (Enum_Type'Last);
1010 -- Note that tttP is created even if no index subtype is a non
1011 -- standard enumeration, because we still need to remove padding
1012 -- normally inserted for component alignment.
1014 PAT :=
1020 declare
1027 begin
1036 -- Unconstrained case
1045 -- Constrained case
1047 else
1051 else
1054 Subtype_Mark =>
1056 Constraint =>
1058 Range_Expression =>
1060 Low_Bound =>
1062 Prefix =>
1067 Prefix =>
1071 High_Bound =>
1073 Prefix =>
1078 Prefix =>
1089 Typedef :=
1092 Component_Definition =>
1095 Subtype_Indication =>
1098 else
1099 Typedef :=
1102 Component_Definition =>
1105 Subtype_Indication =>
1109 Decl :=
1115 -- Set type as packed array type and install it
1118 Install_PAT;
1121 -- Case of bit-packing required for unconstrained array. We create
1122 -- a subtype that is equivalent to use Packed_Bytes{1,2,4} as needed.
1125 PAT :=
1130 Set_PB_Type;
1132 Decl :=
1136 Install_PAT;
1139 -- Remaining code is for the case of bit-packing for constrained array
1141 -- The name of the packed array subtype is
1143 -- ttt___XPsss
1145 -- where sss is the component size in bits and ttt is the name of
1146 -- the parent packed type.
1148 else
1149 PAT :=
1155 -- Build an expression for the length of the array in bits.
1156 -- This is the product of the length of each of the dimensions
1158 declare
1161 begin
1164 loop
1165 Len_Dim :=
1175 else
1176 Len_Expr :=
1187 -- Temporarily attach the length expression to the tree and analyze
1188 -- and resolve it, so that we can test its value. We assume that the
1189 -- total length fits in type Integer. This expression may involve
1190 -- discriminants, so we treat it as a default/per-object expression.
1195 -- Use a modular type if possible. We can do this if we have
1196 -- static bounds, and the length is small enough, and the length
1197 -- is not zero. We exclude the zero length case because the size
1198 -- of things is always at least one, and the zero length object
1199 -- would have an anomalous size.
1204 -- Check for size known to be too large
1208 then
1210 Error_Msg_N
1213 else
1214 Error_Msg_N
1219 -- Reset length to arbitrary not too high value to continue
1225 -- We normally consider small enough to mean no larger than the
1226 -- value of System_Max_Binary_Modulus_Power, checking that in the
1227 -- case of values longer than word size, we have long shifts.
1230 and then
1234 then
1235 -- We can use the modular type, it has the form:
1237 -- subtype tttPn is btyp
1238 -- range 0 .. 2 ** ((Typ'Length (1)
1239 -- * ... * Typ'Length (n)) * Csize) - 1;
1241 -- The bounds are statically known, and btyp is one of the
1242 -- unsigned types, depending on the length.
1256 else
1263 Decl :=
1266 Subtype_Indication =>
1270 Constraint =>
1272 Range_Expression =>
1274 Low_Bound =>
1282 Install_PAT;
1284 -- Propagate a given alignment to the modular type. This can
1285 -- cause it to be under-aligned, but that's OK.
1295 -- Could not use a modular type, for all other cases, we build
1296 -- a packed array subtype:
1298 -- subtype tttPn is
1299 -- System.Packed_Bytes{1,2,4} (0 .. (Bits + 7) / 8 - 1);
1301 -- Bits is the length of the array in bits
1303 Set_PB_Type;
1305 Bits_U1 :=
1307 Left_Opnd =>
1309 Left_Opnd =>
1313 Right_Opnd =>
1318 PAT_High :=
1320 Left_Opnd =>
1326 Decl :=
1329 Subtype_Indication =>
1332 Constraint =>
1336 Low_Bound =>
1338 High_Bound =>
1341 Install_PAT;
1343 -- Currently the code in this unit requires that packed arrays
1344 -- represented by non-modular arrays of bytes be on a byte
1345 -- boundary for bit sizes handled by System.Pack_nn units.
1346 -- That's because these units assume the array being accessed
1347 -- starts on a byte boundary.
1355 -----------------------------------
1356 -- Expand_Bit_Packed_Element_Set --
1357 -----------------------------------
1364 -- Used to preserve assignment OK status when assignment is rewritten
1367 -- Initially Rhs is the right hand side value, it will be replaced
1368 -- later by an appropriate unchecked conversion for the assignment.
1378 -- The expression for the shift value that is required
1381 -- Set True if Shift has been used in the generated code at least once,
1382 -- so that it must be duplicated if used again.
1389 -- If the value of the right hand side as an integer constant is
1390 -- known at compile time, Rhs_Val_Known is set True, and Rhs_Val
1391 -- contains the value. Otherwise Rhs_Val_Known is set False, and
1392 -- the Rhs_Val is undefined.
1395 -- Function used to get the value of Shift, making sure that it
1396 -- gets duplicated if the function is called more than once.
1398 ---------------
1399 -- Get_Shift --
1400 ---------------
1403 begin
1404 -- If we used the shift value already, then duplicate it. We
1405 -- set a temporary parent in case actions have to be inserted.
1411 -- If first time, use Shift unchanged, and set flag for first use
1413 else
1419 -- Start of processing for Expand_Bit_Packed_Element_Set
1421 begin
1431 -- We remove side effects, in case the rhs modifies the lhs, because we
1432 -- are about to transform the rhs into an expression that first READS
1433 -- the lhs, so we can do the necessary shifting and masking. Example:
1434 -- "X(2) := F(...);" where F modifies X(3). Otherwise, the side effect
1435 -- will be lost.
1439 -- We convert the right hand side to the proper subtype to ensure
1440 -- that an appropriate range check is made (since the normal range
1441 -- check from assignment will be lost in the transformations). This
1442 -- conversion is analyzed immediately so that subsequent processing
1443 -- can work with an analyzed Rhs (and e.g. look at its Etype)
1445 -- If the right-hand side is a string literal, create a temporary for
1446 -- it, constant-folding is not ready to wrap the bit representation
1447 -- of a string literal.
1450 declare
1452 begin
1453 Decl :=
1467 -- If we are building the initialization procedure for a packed array,
1468 -- and Initialize_Scalars is enabled, each component assignment is an
1469 -- out-of-range value by design. Compile this value without checks,
1470 -- because a call to the array init_proc must not raise an exception.
1472 -- Condition is not consistent with description above, Within_Init_Proc
1473 -- is True also when we are building the IP for a record or protected
1474 -- type that has a packed array component???
1476 if Within_Init_Proc
1477 and then Initialize_Scalars
1478 then
1480 else
1484 -- For the AAMP target, indexing of certain packed array is passed
1485 -- through to the back end without expansion, because the expansion
1486 -- results in very inefficient code on that target. This allows the
1487 -- GNAAMP back end to generate specialized macros that support more
1488 -- efficient indexing of packed arrays with components having sizes
1489 -- that are small powers of two.
1491 if AAMP_On_Target
1493 then
1497 -- Case of component size 1,2,4 or any component size for the modular
1498 -- case. These are the cases for which we can inline the code.
1502 then
1505 -- The statement to be generated is:
1507 -- Obj := atyp!((Obj and Mask1) or (shift_left (rhs, Shift)))
1509 -- or in the case of a freestanding Reverse_Storage_Order object,
1511 -- Obj := Swap (atyp!((Swap (Obj) and Mask1)
1512 -- or (shift_left (rhs, Shift))))
1514 -- where Mask1 is obtained by shifting Cmask left Shift bits
1515 -- and then complementing the result.
1517 -- the "and Mask1" is omitted if rhs is constant and all 1 bits
1519 -- the "or ..." is omitted if rhs is constant and all 0 bits
1521 -- rhs is converted to the appropriate type
1523 -- The result is converted back to the array type, since
1524 -- otherwise we lose knowledge of the packed nature.
1526 -- Determine if right side is all 0 bits or all 1 bits
1532 -- The following test catches the case of an unchecked conversion of
1533 -- an integer literal. This results from optimizing aggregates of
1534 -- packed types.
1538 then
1542 else
1547 -- Some special checks for the case where the right hand value is
1548 -- known at compile time. Basically we have to take care of the
1549 -- implicit conversion to the subtype of the component object.
1553 -- If we have a biased component type then we must manually do the
1554 -- biasing, since we are taking responsibility in this case for
1555 -- constructing the exact bit pattern to be used.
1561 -- For a negative value, we manually convert the two's complement
1562 -- value to a corresponding unsigned value, so that the proper
1563 -- field width is maintained. If we did not do this, we would
1564 -- get too many leading sign bits later on.
1571 -- Now create copies removing side effects. Note that in some complex
1572 -- cases, this may cause the fact that we have already set a packed
1573 -- array type on Obj to get lost. So we save the type of Obj, and
1574 -- make sure it is reset properly.
1579 -- First we deal with the "and"
1582 declare
1586 begin
1588 Mask1 :=
1594 else
1597 Mask1 :=
1602 New_Rhs :=
1609 -- Then deal with the "or"
1612 declare
1616 -- Adjust Rhs by bias if biased representation for components
1617 -- or remove extraneous high order sign bits if signed.
1622 begin
1623 -- For biased case, do the required biasing by simply
1624 -- converting to the biased subtype (the conversion
1625 -- will generate the required bias).
1630 -- For a signed integer type that is not biased, generate
1631 -- a conversion to unsigned to strip high order sign bits.
1637 -- Set Etype, since it can be referenced before the node is
1638 -- completely analyzed.
1642 -- We now need to do an unchecked conversion of the
1643 -- result to the target type, but it is important that
1644 -- this conversion be a right justified conversion and
1645 -- not a left justified conversion.
1650 begin
1651 if Rhs_Val_Known
1653 then
1654 Or_Rhs :=
1659 else
1660 -- We have to convert the right hand side to Etype (Obj).
1661 -- A special case arises if what we have now is a Val
1662 -- attribute reference whose expression type is Etype (Obj).
1663 -- This happens for assignments of fields from the same
1664 -- array. In this case we get the required right hand side
1665 -- by simply removing the inner attribute reference.
1670 then
1672 Fixup_Rhs;
1674 -- If the value of the right hand side is a known integer
1675 -- value, then just replace it by an untyped constant,
1676 -- which will be properly retyped when we analyze and
1677 -- resolve the expression.
1681 -- Note that Rhs_Val has already been normalized to
1682 -- be an unsigned value with the proper number of bits.
1686 -- Otherwise we need an unchecked conversion
1688 else
1689 Fixup_Rhs;
1700 New_Rhs :=
1707 -- Now do the rewrite
1712 Expression =>
1716 -- All other component sizes for non-modular case
1718 else
1719 -- We generate
1721 -- Set_nn (Arr'address, Subscr, Bits_nn!(Rhs))
1723 -- where Subscr is the computed linear subscript
1725 declare
1732 begin
1735 -- Error, most likely High_Integrity_Mode restriction
1740 -- Acquire proper Set entity. We use the aligned or unaligned
1741 -- case as appropriate.
1745 else
1749 -- Now generate the set reference
1756 -- Set indication of whether the packed array has reverse SSO
1758 Rev_SSO :=
1759 New_Occurrence_Of
1762 -- Below we must make the assumption that Obj is
1763 -- at least byte aligned, since otherwise its address
1764 -- cannot be taken. The assumption holds since the
1765 -- only arrays that can be misaligned are small packed
1766 -- arrays which are implemented as a modular type, and
1767 -- that is not the case here.
1776 Subscr,
1778 Rev_SSO)));
1786 -------------------------------------
1787 -- Expand_Packed_Address_Reference --
1788 -------------------------------------
1795 begin
1796 -- We build an expression that has the form
1798 -- outer_object'Address
1799 -- + (linear-subscript * component_size for each array reference
1800 -- + field'Bit_Position for each record field
1801 -- + ...
1802 -- + ...) / Storage_Unit;
1809 Left_Opnd =>
1815 Right_Opnd =>
1819 Right_Opnd =>
1825 ---------------------------------
1826 -- Expand_Packed_Bit_Reference --
1827 ---------------------------------
1834 begin
1835 -- We build an expression that has the form
1837 -- (linear-subscript * component_size for each array reference
1838 -- + field'Bit_Position for each record field
1839 -- + ...
1840 -- + ...) mod Storage_Unit;
1853 ------------------------------------
1854 -- Expand_Packed_Boolean_Operator --
1855 ------------------------------------
1857 -- This routine expands "a op b" for the packed cases
1869 begin
1881 -- Deal with silly case of XOR where the subcomponent has a range
1882 -- True .. True where an exception must be raised.
1888 -- Now that that silliness is taken care of, get packed array type
1895 -- For the modular case, we expand a op b into
1897 -- rtyp!(pat!(a) op pat!(b))
1899 -- where rtyp is the Etype of the left operand. Note that we do not
1900 -- convert to the base type, since this would be unconstrained, and
1901 -- hence not have a corresponding packed array type set.
1903 -- Note that both operands must be modular for this code to be used
1906 and then
1908 then
1909 declare
1912 begin
1926 -- For the array case, we insert the actions
1928 -- Result : Ltype;
1930 -- System.Bit_Ops.Bit_And/Or/Xor
1931 -- (Left'Address,
1932 -- Ltype'Length * Ltype'Component_Size;
1933 -- Right'Address,
1934 -- Rtype'Length * Rtype'Component_Size
1935 -- Result'Address);
1937 -- where Left and Right are the Packed_Bytes{1,2,4} operands and
1938 -- the second argument and fourth arguments are the lengths of the
1939 -- operands in bits. Then we replace the expression by a reference
1940 -- to Result.
1942 -- Note that if we are mixing a modular and array operand, everything
1943 -- works fine, since we ensure that the modular representation has the
1944 -- same physical layout as the array representation (that's what the
1945 -- left justified modular stuff in the big-endian case is about).
1947 else
1948 declare
1952 begin
1978 Left_Opnd =>
1980 Prefix =>
1981 New_Occurrence_Of
1985 Right_Opnd =>
1993 Left_Opnd =>
1995 Prefix =>
1996 New_Occurrence_Of
2000 Right_Opnd =>
2015 -------------------------------------
2016 -- Expand_Packed_Element_Reference --
2017 -------------------------------------
2031 begin
2032 -- If the node is an actual in a call, the prefix has not been fully
2033 -- expanded, to account for the additional expansion for in-out actuals
2034 -- (see expand_actuals for details). If the prefix itself is a packed
2035 -- reference as well, we have to recurse to complete the transformation
2036 -- of the prefix.
2041 then
2045 -- If not bit packed, we have the enumeration case, which is easily
2046 -- dealt with (just adjust the subscripts of the indexed component)
2048 -- Note: this leaves the result as an indexed component, which is
2049 -- still a variable, so can be used in the assignment case, as is
2050 -- required in the enumeration case.
2057 -- Remaining processing is for the bit-packed case
2066 -- For the AAMP target, indexing of certain packed array is passed
2067 -- through to the back end without expansion, because the expansion
2068 -- results in very inefficient code on that target. This allows the
2069 -- GNAAMP back end to generate specialized macros that support more
2070 -- efficient indexing of packed arrays with components having sizes
2071 -- that are small powers of two.
2073 if AAMP_On_Target
2075 then
2079 -- Case of component size 1,2,4 or any component size for the modular
2080 -- case. These are the cases for which we can inline the code.
2084 then
2089 -- We generate a shift right to position the field, followed by a
2090 -- masking operation to extract the bit field, and we finally do an
2091 -- unchecked conversion to convert the result to the required target.
2093 -- Note that the unchecked conversion automatically deals with the
2094 -- bias if we are dealing with a biased representation. What will
2095 -- happen is that we temporarily generate the biased representation,
2096 -- but almost immediately that will be converted to the original
2097 -- unbiased component type, and the bias will disappear.
2099 Arg :=
2105 -- Component extraction is performed on a native endianness scalar
2106 -- value: if Atyp has reverse storage order, then it has been byte
2107 -- swapped, and if the component being extracted is itself of a
2108 -- composite type with reverse storage order, then we need to swap
2109 -- it back to its expected endianness after extraction.
2114 then
2118 -- We needed to analyze this before we do the unchecked convert
2119 -- below, but we need it temporarily attached to the tree for
2120 -- this analysis (hence the temporary Set_Parent call).
2127 -- All other component sizes for non-modular case
2129 else
2130 -- We generate
2132 -- Component_Type!(Get_nn (Arr'address, Subscr))
2134 -- where Subscr is the computed linear subscript
2136 declare
2140 New_Occurrence_Of
2143 begin
2144 -- Acquire proper Get entity. We use the aligned or unaligned
2145 -- case as appropriate.
2149 else
2153 -- Now generate the get reference
2157 -- Below we make the assumption that Obj is at least byte
2158 -- aligned, since otherwise its address cannot be taken.
2159 -- The assumption holds since the only arrays that can be
2160 -- misaligned are small packed arrays which are implemented
2161 -- as a modular type, and that is not the case here.
2171 Subscr,
2172 Rev_SSO))));
2179 ----------------------
2180 -- Expand_Packed_Eq --
2181 ----------------------
2183 -- Handles expansion of "=" on packed array types
2197 begin
2207 LLexpr :=
2209 Left_Opnd =>
2213 Right_Opnd =>
2216 RLexpr :=
2218 Left_Opnd =>
2222 Right_Opnd =>
2225 -- For the modular case, we transform the comparison to:
2227 -- Ltyp'Length = Rtyp'Length and then PAT!(L) = PAT!(R)
2229 -- where PAT is the packed array type. This works fine, since in the
2230 -- modular case we guarantee that the unused bits are always zeroes.
2231 -- We do have to compare the lengths because we could be comparing
2232 -- two different subtypes of the same base type.
2237 Left_Opnd =>
2242 Right_Opnd =>
2247 -- For the non-modular case, we call a runtime routine
2249 -- System.Bit_Ops.Bit_Eq
2250 -- (L'Address, L_Length, R'Address, R_Length)
2252 -- where PAT is the packed array type, and the lengths are the lengths
2253 -- in bits of the original packed arrays. This routine takes care of
2254 -- not comparing the unused bits in the last byte.
2256 else
2265 LLexpr,
2271 RLexpr)));
2277 -----------------------
2278 -- Expand_Packed_Not --
2279 -----------------------
2281 -- Handles expansion of "not" on packed array types
2292 begin
2296 -- Deal with silly False..False and True..True subtype case
2300 -- Now that the silliness is taken care of, get packed array type
2305 -- For the case where the packed array type is a modular type, "not A"
2306 -- expands simply into:
2308 -- Rtyp!(PAT!(A) xor Mask)
2310 -- where PAT is the packed array type, Mask is a mask of all 1 bits of
2311 -- length equal to the size of this packed type, and Rtyp is the actual
2312 -- actual subtype of the operand.
2324 -- For the array case, we insert the actions
2326 -- Result : Typ;
2328 -- System.Bit_Ops.Bit_Not
2329 -- (Opnd'Address,
2330 -- Typ'Length * Typ'Component_Size,
2331 -- Result'Address);
2333 -- where Opnd is the Packed_Bytes{1,2,4} operand and the second argument
2334 -- is the length of the operand in bits. We then replace the expression
2335 -- with a reference to Result.
2337 else
2338 declare
2341 begin
2355 Left_Opnd =>
2357 Prefix =>
2358 New_Occurrence_Of
2362 Right_Opnd =>
2376 -----------------------------
2377 -- Get_Base_And_Bit_Offset --
2378 -----------------------------
2380 procedure Get_Base_And_Bit_Offset
2384 is
2390 begin
2394 -- We build up an expression serially that has the form
2396 -- linear-subscript * component_size for each array reference
2397 -- + field'Bit_Position for each record field
2398 -- + ...
2400 loop
2408 Term :=
2411 Right_Opnd =>
2417 Term :=
2422 else
2429 else
2430 Offset :=
2440 -------------------------------------
2441 -- Involves_Packed_Array_Reference --
2442 -------------------------------------
2445 begin
2448 then
2454 else
2459 --------------------------
2460 -- Known_Aligned_Enough --
2461 --------------------------
2467 -- If the component is in a record that contains previous packed
2468 -- components, consider it unaligned because the back-end might
2469 -- choose to pack the rest of the record. Lead to less efficient code,
2470 -- but safer vis-a-vis of back-end choices.
2472 --------------------------------
2473 -- In_Partially_Packed_Record --
2474 --------------------------------
2480 begin
2496 -- Start of processing for Known_Aligned_Enough
2498 begin
2499 -- Odd bit sizes don't need alignment anyway
2504 -- If we have a specified alignment, see if it is sufficient, if not
2505 -- then we can't possibly be aligned enough in any case.
2508 -- Alignment required is 4 if size is a multiple of 4, and
2509 -- 2 otherwise (e.g. 12 bits requires 4, 10 bits requires 2)
2516 -- OK, alignment should be sufficient, if object is aligned
2518 -- If object is strictly aligned, then it is definitely aligned
2523 -- Case of subscripted array reference
2527 -- If we have a pointer to an array, then this is definitely
2528 -- aligned, because pointers always point to aligned versions.
2533 -- Otherwise, go look at the prefix
2535 else
2539 -- Case of record field
2543 -- What is significant here is whether the record type is packed
2547 then
2550 -- Or the component has a component clause which might cause
2551 -- the component to become unaligned (we can't tell if the
2552 -- backend is doing alignment computations).
2560 -- In all other cases, go look at prefix
2562 else
2569 -- For a formal parameter, it is safer to assume that it is not
2570 -- aligned, because the formal may be unconstrained while the actual
2571 -- is constrained. In this situation, a small constrained packed
2572 -- array, represented in modular form, may be unaligned.
2576 else
2578 -- If none of the above, must be aligned
2583 ---------------------
2584 -- Make_Shift_Left --
2585 ---------------------
2590 begin
2593 else
2594 Nod :=
2603 ----------------------
2604 -- Make_Shift_Right --
2605 ----------------------
2610 begin
2613 else
2614 Nod :=
2623 -----------------------------
2624 -- RJ_Unchecked_Convert_To --
2625 -----------------------------
2627 function RJ_Unchecked_Convert_To
2630 is
2639 begin
2643 -- For a little-endian target type stored byte-swapped on a
2644 -- big-endian machine, do not mask to Target_Siz bits.
2646 if Bytes_Big_Endian
2648 or else
2651 then
2655 -- First step, if the source type is not a discrete type, then we first
2656 -- convert to a modular type of the source length, since otherwise, on
2657 -- a big-endian machine, we get left-justification. We do it for little-
2658 -- endian machines as well, because there might be junk bits that are
2659 -- not cleared if the type is not numeric.
2663 then
2667 -- In the big endian case, if the lengths of the two types differ, then
2668 -- we must worry about possible left justification in the conversion,
2669 -- and avoiding that is what this is all about.
2673 -- Next step. If the target is not a discrete type, then we first
2674 -- convert to a modular type of the target length, since otherwise,
2675 -- on a big-endian machine, we get left-justification.
2682 -- And now we can do the final conversion to the target type
2687 ----------------------------------------------
2688 -- Setup_Enumeration_Packed_Array_Reference --
2689 ----------------------------------------------
2691 -- All we have to do here is to find the subscripts that correspond to the
2692 -- index positions that have non-standard enumeration types and insert a
2693 -- Pos attribute to get the proper subscript value.
2695 -- Finally the prefix must be uncheck-converted to the corresponding packed
2696 -- array type.
2698 -- Note that the component type is unchanged, so we do not need to fiddle
2699 -- with the types (Gigi always automatically takes the packed array type if
2700 -- it is set, as it will be in this case).
2708 begin
2709 -- If the array is unconstrained, then we replace the array reference
2710 -- with its actual subtype. This actual subtype will have a packed array
2711 -- type with appropriate bounds.
2719 declare
2723 begin
2726 then
2741 Prefix =>
2748 -----------------------------------------
2749 -- Setup_Inline_Packed_Array_Reference --
2750 -----------------------------------------
2752 procedure Setup_Inline_Packed_Array_Reference
2758 is
2765 begin
2777 else
2780 -- In the case where the PAT is a modular type, we want the actual
2781 -- size in bits of the modular value we use. This is neither the
2782 -- Object_Size nor the Value_Size, either of which may have been
2783 -- reset to strange values, but rather the minimum size. Note that
2784 -- since this is a modular type with full range, the issue of
2785 -- biased representation does not arise.
2792 -- If the component size is not 1, then the subscript must be multiplied
2793 -- by the component size to get the shift count.
2796 Shift :=
2802 -- If we have the array case, then this shift count must be broken down
2803 -- into a byte subscript, and a shift within the byte.
2807 declare
2810 begin
2811 -- We must analyze shift, since we will duplicate it
2814 Analyze_And_Resolve
2817 -- The shift count within the word is
2818 -- shift mod Osiz
2820 New_Shift :=
2825 -- The subscript to be used on the PAT array is
2826 -- shift / Osiz
2828 Obj :=
2839 -- For the modular integer case, the object to be manipulated is the
2840 -- entire array, so Obj is unchanged. Note that we will reset its type
2841 -- to PAT before returning to the caller.
2843 else
2847 -- The one remaining step is to modify the shift count for the
2848 -- big-endian case. Consider the following example in a byte:
2850 -- xxxxxxxx bits of byte
2851 -- vvvvvvvv bits of value
2852 -- 33221100 little-endian numbering
2853 -- 00112233 big-endian numbering
2855 -- Here we have the case of 2-bit fields
2857 -- For the little-endian case, we already have the proper shift count
2858 -- set, e.g. for element 2, the shift count is 2*2 = 4.
2860 -- For the big endian case, we have to adjust the shift count, computing
2861 -- it as (N - F) - Shift, where N is the number of bits in an element of
2862 -- the array used to implement the packed array, F is the number of bits
2863 -- in a source array element, and Shift is the count so far computed.
2865 -- We also have to adjust if the storage order is reversed
2868 Shift :=
2879 -- Make sure final type of object is the appropriate packed type