13.2 Packed TypesPragma Pack
[The Pack aspect having the value True A
specifies that storage minimization should be the main criterion when
selecting the representation of a composite type.]
For a full type declaration
of a composite type, the following language-defined representation aspect
may be specified: A
specifies the packing aspect of representation; the type (or the
extension part) is said to be packed. For a type extension, the
parent part is packed as for the parent type, and a pragma
Pack causes packing only of the extension part.
The type of aspect Pack is Boolean. When aspect
Pack is True for a type, the type (or the extension part) is said to
be packed. For a type extension, the parent part is packed as
for the parent type, and specifying Pack causes packing only of the extension
for Pack: Minimize
storage when laying out records and arrays.
If directly specified,
shall be a static expression. If not specified (including by inheritance),
the aspect is False.
If a type is packed, then the implementation should
try to minimize storage allocated to objects of the type, possibly at
the expense of speed of accessing components, subject to reasonable complexity
in addressing calculations.
Storage allocated to objects of a packed
type should be minimized.
Specifying the A pragma
is for gaining space efficiency,
possibly at the expense of time. If more explicit control over representation
is desired, then a record_representation_clause
a Component_Size clause, or a Size clause should be used instead of,
or in addition to, the a
If a packed type has a component that is not of
a by-reference type and has no aliased part, then such a component need
not be aligned according to the Alignment of its subtype; in particular
it need not be allocated on a storage element boundary.
For a packed record type, the components should
be packed as tightly as possible subject to the Sizes of the component
subtypes, and subject to any record_representation_clause
that applies to the type; the implementation may, but need not, reorder
components or cross aligned word boundaries to improve the packing. A
component whose Size is greater than the word size may be allocated an
integral number of words.
Ramification: The implementation can
always allocate an integral number of words for a component that will
not fit in a word. The rule also allows small component sizes to be rounded
up if such rounding does not waste space. For example, if Storage_Unit
= 8, then a component of size 8 is probably more efficient than a component
of size 7 plus a 1-bit gap (assuming the gap is needed anyway).
For a packed array type, if the component subtype's
Size of the component subtype
less than or equal to the word size, and Component_Size
is not specified for the type
, Component_Size should be less than
or equal to the Size of the component subtype, rounded up to the nearest
factor of the word size.
Ramification: If a component subtype
is aliased, its Size will generally be a multiple of Storage_Unit, so
it probably won't get packed very tightly.
Implementation Advice: The
recommended level of support for the pragma Pack aspect should be followed.
Wording Changes from Ada 95
Added clarification that the pragma Pack aspect can ignore alignment requirements on types that don't have by-reference
or aliased parts. This was always intended, but there was no wording
to that effect.
Extensions to Ada 2005
Wording Changes from Ada 2005
Correction: Fixed so that the presence or
absence of a confirming Component_Size representation clause does not
change the meaning of the Pack aspect.
Ada 2005 and 2012 Editions sponsored in part by Ada-Europe