Alignment Rules

For HPUX_WORD and DOMAIN_WORD alignments, all structure and union types are 2-byte aligned. Member types larger than 2 bytes are aligned on a 2-byte boundary. Padding is performed as necessary to reach a resulting structure or union size which is a multiple of 2 bytes.

For example:

     struct st {
        char c;
        long l;
        char d;
        short b;
        int i[2];
     } s;

Compiling with the +m option to show the offsets of the identifiers, you will get the following output. Offsets are given as "byte-offset" @ "bit-offset" in hexadecimal.

       Identifier         Class       Type              Address
                -       -       -
       s                    ext def     struct st
         c                  member      char              0x0 @ 0x0
         l                  member      long int          0x2 @ 0x0
         d                  member      char              0x6 @ 0x0
         b                  member      short int         0x8 @ 0x0
         i                  member      ints [2]          0xa @ 0x0

The resulting size of the structure is 18 bytes, with the alignment of 2 bytes, as illustrated in Figure 2-1 “Example of HPUX_WORD/DOMAIN_WORD Alignment for Structure s ”

Figure 2-1 Example of HPUX_WORD/DOMAIN_WORD Alignment for Structure s

For HPUX_NATURAL and DOMAIN_NATURAL alignments, the alignment of structure and union types is the same as the strictest alignment of any member. Therefore, they may be aligned on 1-, 2-, 4-, or 8-byte boundaries. Padding is performed as necessary so that the size of the object is a multiple of the alignment size.

For example, the declaration shown in the previous section will now be aligned:

       Identifier         Class       Type              Address
                    -       -
       s                    ext def     struct st
         c                  member      char              0x0 @ 0x0
         l                  member      long int          0x4 @ 0x0
         d                  member      char              0x8 @ 0x0
         b                  member      short int         0xa @ 0x0
         i                  member      ints [2]          0xc @ 0x0

In this case, the size of the structure is 20 bytes, and the entire structure is aligned on a 4-byte boundary since the strictest alignment is 4 (from the int and long types), as illustrated in Figure 2-2 “Example of HPUX_NATURAL/DOMAIN_NATURAL Alignment for Structure s ”.

Figure 2-2 Example of HPUX_NATURAL/DOMAIN_NATURAL Alignment for Structure s

For HPUX_NATURAL_S500 alignments, series 500 computers align structures on 2- or 4-byte boundaries, according to the strictest alignment of its members. As with the other alignment modes, padding is done to a multiple of the alignment size.

For example, the following code:

     struct {
        char c;
        double d;
     } s1;

compiled with the +m option produces:

       Identifier         Class       Type              Address
                -     -           -
       s1                   ext def     struct
         c                  member      char              0x0 @ 0x0
         d                  member      double            0x4 @ 0x0

The entire structure is 4-byte aligned, with a resulting size of 12 bytes.

For NATURAL alignments, structures and unions are aligned on 2-, 4-, or 8-byte boundaries, according to the strictest alignment of its members. Padding is done to a multiple of the alignment size.

For NOPADDING alignments, structure or union members are byte aligned; therefore, struct and union types are byte aligned. This alignment mode does not cause compressed packing where there are zero bits of padding. It only ensures that there will be no full bytes of padding in the structure or union, unless bit-fields are used. There may be bit paddings or even a full byte of padding between members if there are bit-fields. Refer to “Alignment of Bit-Fields ” for more information.

Consider the following code fragment:

     #pragma HP_ALIGN NOPADDING
     typedef struct s {
        char c;
        short s;
     } s1;
 
     s1 arr[4];

The size of s1 is 3 bytes, with 1-byte alignment. Therefore, the size of arr is 12 bytes, with 1-byte alignment. There is no padding between the individual array elements; they are all packed on a byte boundary (see Figure 2-3 “Example of NOPADDING Alignment for Structure s1 ”).

Figure 2-3 Example of NOPADDING Alignment for Structure s1

Note that if a member of a structure or union has been declared previously under a different alignment mode, it will retain its original alignment which may not be byte alignment. The NOPADDING alignment will not override the alignment of the member, so there may be some padding done within the structure, and the structure may be greater than byte aligned.

Refer to “Aligning Structures Between Architectures” below for examples on on structure alignment for different systems.

For HPUX_NATURAL and HPUX_NATURAL_S500 alignments, no bit-field can cross a "natural" boundary. A bit-field that immediately follows another bit-field is packed into adjacent bits, unless the second bit-field crosses a natural boundary according to its type. For example:

      struct {
        int   a:5;
        int   b:15;
        int   c:17;
        char   :0;
        char  d:5;
        char  e:5;
     } foo;

when compiled with the +m option produces:

       Identifier           Class       Type              Address
                  -                   -
       foo                  ext def     struct
         a                    member      int               0x0 @ 0x0
         b                    member      int               0x0 @ 0x5
         c                    member      int               0x4 @ 0x0
    <NULL_SYMBOL>             member      char              0x7 @ 0x0
         d                    member      char              0x7 @ 0x0
         e                    member      char              0x8 @ 0x0

The size of the structure is 12 bytes, with 4-byte alignment as illustrated in Figure 2-4 “Example of HPUX_NATURAL/HPUX_NATURAL_S500 Alignment for Structure foo ”.

Figure 2-4 Example of HPUX_NATURAL/HPUX_NATURAL_S500 Alignment for Structure foo

Since b (being an int type) does not cross any word boundaries, a and b are adjacent. c starts on the next word because it would cross a word boundary if it started right after b. The zero length bit-field forces no further bit-field to be placed between the previous bit-field, if any, and the next boundary described by the zero-length bit field's type. Thus, if we are at bit 5 and see a zero length bit-field of type int, then the next member will start at the next word boundary (bits 5-31 will be empty). However, if we are at bit 5 and see a zero length bit-field of type char, then the next member will start at least at the next byte (bits 5-7 will be empty), depending on whether the next member can start at a byte-boundary.

For DOMAIN_WORD, DOMAIN_NATURAL, NATURAL, and NOPADDING alignments:

	NOTE: NOPADDING of bit-fields follows the DOMAIN alignment scheme. This may result in a full byte of padding between two bit-fields.

For example:

     struct {
        char c;
        int i:31;  <-- At offset 2 bytes.
     } bar;

The above structure bar will align the bit-field at offset 2 bytes, so that there is a full byte of padding between c and i, even with NOPADDING alignment mode (see Figure 2-5 “Example of NATURAL Alignment for Structure bar ”.)

Figure 2-5 Example of NATURAL Alignment for Structure bar

For HPUX_WORD alignments:

Note that alignment of a char or short bit-field may not be the same as alignment of a char or short enum bit-field under the same circumstances.

For example:

     #pragma HP_ALIGN HPUX_WORD
 
     char enum b {a};
     struct s {
        int           int_bit :30;
        char          char_bit :5;
     };
     struct t {
        int           int_bit :30;
        char enum b   char_enum_bit: 5;
     };
 
     int main()
     {
        struct s basic_str;
        struct t enum_str;
     }

Compilation with the +m option gives the following map:

       Identifier           Class       Type              Address
                  -                 -
       basic_str            auto        struct s          SP-48
         int_bit              member      int               0x0 @ 0x0
         char_bit             member      char              0x4 @ 0x0
       enum_str             auto        struct t          SP-42
         int_bit              member      int               0x0 @ 0x0
         char_enum_bit        member      enum              0x3 @ 0x6

Both structures have a resulting size of 6 bytes, with 2-byte alignment as shown in Figure 2-6 “Example of Structures basic_str and enum_str ”.

Figure 2-6 Example of Structures basic_str and enum_str

Notice that char_bit follows the HPUX_NATURAL alignment scheme, but char_enum_bit follows the DOMAIN_WORD alignment scheme, even though the length of their bit-field types are equivalent.