IBM extension

The __align qualifier

The __align qualifier is a language extension that allows you to specify an explicit alignment for an aggregate or a static (or global) variable. The specified byte boundary affects the alignment of an aggregate as a whole, not that of its members. The __align qualifier can be applied to an aggregate definition nested within another aggregate definition, but not to individual elements of an aggregate. The alignment specification is ignored for parameters and automatic variables.

A declaration takes one of the following forms:

Read syntax diagramSkip visual syntax diagram__align qualifier syntax for simple variables
 
>>-type specifier--__align--(--int_constant--)--declarator-----><
 

Read syntax diagramSkip visual syntax diagram__align qualifier syntax for structures or unions
 
>>-__align--(--int_constant--)--+-struct-+---------------------->
                                '-union--'
 
>--+----------------+--{--member_declaration_list--}--;--------><
   '-tag_identifier-'
 

where int_constant is a positive integer value indicating the byte-alignment boundary. The legal values are 1, 2, 4, 8, or 16.

The following restrictions and limitations apply:

Examples using the __align qualifier

Applying __align to static or global variables:

int __align(1024) varA;        /* varA is aligned on a 1024-byte boundary
main()  												and padded with 1020 bytes              */
{...}                                 
static int __align(512) varB;  /* varB is aligned on a 512-byte boundary
                                   and padded with 508 bytes               */
int __align(128) functionB( ); /* An error                                 */
typedef int __align(128) T;    /* An error                                 */
__align enum C {a, b, c};      /* An error                                 */

 

Applying __align to align and pad aggregate tags without affecting aggregate members:

__align(1024) struct structA {int i; int j;}; /* struct structA is aligned
                                                 on a 1024-byte boundary 
                                                 with size including padding
                                                 of 1024 bytes             */
__align(1024) union unionA {int i; int j;}; /* union unionA is aligned
                                                 on a 1024-byte boundary
                                                 with size including padding
                                                 of 1024 bytes            */

 

Applying __align to a structure or union, where the size and alignment of the aggregate using the structure or union is affected:

__align(128) struct S {int i;};     /* sizeof(struct S) == 128             */

struct S sarray[10];                /* sarray is aligned on 128-byte boundary
                                       with sizeof(sarray) == 1280         */

struct S __align(64) svar;          /* error - alignment of variable is
                                         smaller than alignment of type    */

struct S2 {struct S s1; int a;} s2; /* s2 is aligned on 128-byte boundary
                                         with sizeof(s2) == 256            */

 

Applying __align to an array:

AnyType __align(64) arrayA[10]; /* Only arrayA is aligned on a 64-byte 
                                  boundary, and elements within that array
                                  are aligned according to the alignment 
                                  of AnyType.  Padding is applied after the
                                  back of the array and does not affect
                                  the size of the array member itself.    */ 

 

Applying __align where the size of the variable alignment differs from the size of the type alignment:

__align(64) struct S {int i;};

struct S __align(32) s1;          /* error, alignment of variable is smaller 
                                     than alignment of type                 */

struct S __align(128) s2;         /* s2 is aligned on 128-byte boundary     */

struct S __align(16) s3[10];      /* error                                  */
int __align(1) s4;                /* error                                  */
__align(1) struct S {int i;};     /* error                                  */

Related information

End of IBM extension