An array has the same boundary requirements as the data type specified for the array. The size of an array is the size of the data type, multiplied by the number of elements.

For example, for the following declaration,

x : array [1..2, 1..3] of double;

the size of the resulting array is 48 bytes (2*3*8, where 8 is the size of the double-floating point type in bytes).

Each member of a record begins at an offset from the record base. The offset corresponds to the order in which a member is declared; the first member is at offset 0.

The size of a record in the object file is the size of its combined members plus padding added, where necessary, by the compiler.

The following rules apply to records:

Example: Record

This example shows a record in code:

type S = record v : integer; n : array [1..10] of char; end;

Figure 3-1 shows how it is mapped in storage.

Figure 3-1. Record in Storage, End Padded

Note that the length of the record is 16 bytes, even though the byte count as defined by the v:integer and the n:array[1..10] of char components is only 14. Because integer has a stricter boundary requirement (word boundary) than char (byte boundary), the record must end on a word boundary (a byte offset divisible by four). The compiler therefore adds two bytes of padding to meet this requirement.

An array of data records illustrates the reason for this requirement. For example, if the above record were the element-type of an array, some of the v:integer components would not be aligned properly without the two-byte pad.

Example: Record with Different Alignment

This example shows a record with different alignment in code:

type S = record n : packed array [1..10] of char; v : integer; end;

Figure 3-2 shows how it is mapped in storage.

Figure 3-2. Record in Storage, Middle Padding

In the example, the alignment requirements cause padding to appear in the middle of the record. Note that the size of the record remains 16 bytes, but two bytes of padding follow the n component to align v on a word boundary.

A variant record must align on the same boundary as the member with the most restrictive boundary requirement.

These are the boundary requirements, listed by increasing degree of restrictiveness:

For example, a variant record containing integer, char, and double data types must align on a doubleword boundary, as required by the double data type.

This example shows a packed record in code:

type virtual_address = packed record
    offset : 0..4095;               (* 12 bits *)
    page : 0..1023;                 (* 10 bits *)
    segment : 0..511;               (* 9 bits *)
    supervisor : 0..1;              (* 1 bit *)
end;

Figure 3-3 shows how it is mapped in storage.

Figure 3-3. Ranges in a Packed Record

Ranges in an unpacked record are packed from the most-significant bit to the least-significant bit, but each range is aligned to the appropriate boundary. This example shows an unpacked record in code:

type virtual_address = record
    offset : 0..4095;        (* 12 bits *)
    page : 0..1023;          (* 10 bits *)
    segment : 0..511;        (* 9 bits *)
    supervisor : 0..1;       (* 1 bit *)
end;

Figure 3-4 shows how it is mapped in storage.

Figure 3-4. Ranges in an Unpacked Record

For unpacked records, the compiler aligns a non-range element that follows a range declaration to the next boundary appropriate for its type.

This example shows another unpacked record in code:

var x : record
    a : 0..7;                 (* 3 bits packed *)
    b : char;                 (* 8 bits *)
    c : -32768..32767;        (* 16 bits *)
end;

Figure 3-5 shows how it is mapped in storage.

Figure 3-5. Non-Range Elements in an Unpacked Record

For a packed record, the computer bit-aligns booleans, chars, and ranges. All other types are word or double-word aligned as appropriate for the type. This example shows the same code as above in a packed record and its mapping in storage:

var x : packed record
    a : 0..7;             (* 3 bits *)
    b : char;             (* 8 bits *)
    c : -32768..32767     (* 16 bits *)
end;

Figure 3-6 shows how it is mapped in storage.

Figure 3-6. Non-Range Elements in a Packed Record

Table 3-4, following, lists size and alignment parameters for unpacked records. See Section 3.4, “Rules for Set Sizes,” for rules about specifying the upper and lower bounds of s

---

Note: For unpacked records, the compiler uses the following formula for determining the size of the set of a..b:

---

       size=[b2⌋ - ⌊a/32⌋ + 1 words

The notation [ x ] indicates the floor of x, which is the largest

integer not greater than x.

The compiler uses the rules shown in Table 3-5 for aligning packed arrays.

---

Note: For packed arrays, the compiler uses the minimum number of bits possible in creating the set of a..b.

---

The following formula is used:

If
   (b - 32 ⌊a/32⌋ + 1 ) ≤ 32
then
   size = b - 32 \ξεβ a/32⌋ + 1 bits
else
   size = ⌊b/32⌋ - \ξεβ a/32⌋ + 1 words

Note that the set of a..b is aligned on an n-bit boundary where n is a power of 2. The value of n is computed as follows:

n = 2⌈log2(size)⌉

For example, the set of 0..2 has a size of 3 bits as computed above and will align on a 4-bit boundary.

See Section 3.4 at the end of this chapter for rules about specifying the upper and lower bounds of sets.

The compiler uses the rules shown in Table 3-6 for aligning packed records.

---

Note: For packed records, the compiler uses the minimum number of bits possible in creating a subrange field.

---

For the subrange a..b, this formula is used:

If  a >= 0  then  size = ⌈log2(b + 1) ⌉ bits

If a > 0    then  size = max(⌈log2(b + 1)⌉,⌈log2(-a ) ⌉)+1  bits 

The notation ⌈ x ⌉ indicates the ceiling of x, which is the smallest integer not less than x.

To avoid crossing a word boundary, the compiler moves data types aligned to bit boundaries in a packed record to the next word.