align

Applies to C Applies to C++

Purpose

Specifies what aggregate alignment rules the compiler uses for file compilation. Use this option to specify the maximum alignment to be used when mapping a class-type object, either for the whole source program or for specific parts.

Syntax


Syntax Diagram

where available alignment options are:


linuxppc The compiler uses default GCC alignment rules to maintain compatibility with GCC objects. This is the default.
bit_packed The compiler uses the bit_packed alignment rules. This suboption is similar to the GCC -fpack-struct option.

See also #pragma align and #pragma options.

Notes

If you use the -qalign option more than once on the command line, the last alignment rule specified applies to the file.

You can control the alignment of a subset of your code by using #pragma align=alignment_rule to override the setting of the -qalign compiler option. Use #pragma align=reset to revert to a previous alignment rule. The compiler stacks alignment directives, so you can go back to using the previous alignment directive, without knowing what it is, by specifying the #pragma align=reset directive. For example, you can use this option if you have a class declaration within an include file and you do not want the alignment rule specified for the class to apply to the file in which the class is included.

Examples

Example 1 - Affecting Only Aggregate Definition

Using the compiler invocation:

xlc++ file2.C /* <-- default alignment rule for file is                 */
            /*     linuxppc because no alignment rule specified */

Where file2.C has:

extern struct A A1;
typedef struct A A2;
 
#pragma options align=bit_packed /* <-- use bit_packed alignment rules*/
struct A {
  int a;
  char c;
};
#pragma options align=reset /* <-- Go back to default alignment rules */
 
struct A A1;  /* <-- aligned using bit_packed alignment rules since   */
A2 A3;        /*     this rule applied when struct A was defined      */

Example 2 - Imbedded #pragmas

Using the compiler invocation:

xlc -qalign=linuxppc file.c  /* <-- default alignment rule for file */
                           /*    is linuxppc                        */

Where file.c has:

struct A {
  int a;
  struct B {
    char c;
    double d;
#pragma options align=bit_packed /* <-- B will be unaffected by this  */
                            /*     #pragma, unlike previous behavior; */
                            /*     linuxppc alignment rules still    */
                            /*     in effect                          */
  } BB;
#pragma options align=reset /* <-- A is unaffected by this #pragma;   */
} AA;                       /*     linuxppc alignment rules still    */
                            /*     in effect                          */

Using the __align specifier

You can use the __align specifier to explicitly specify data alignment when declaring or defining a data item.

__align Specifier

Purpose

Use the __align specifier to explicitly specify alignment and padding when declaring or defining data items.

Syntax
declarator __align (int_const) identifier;
 
__align (int_const) struct_or_union_specifier [identifier] {struct_decln_list}

where:


int_const Specifies a byte-alignment boundary. int_const must be an integer greater than 0 and equal to a power of 2.

Notes

The __align specifier can only be used with declarations of first-level variables and aggregate definitions. It ignores parameters and automatics.

The __align specifier can be used on an aggregate definition nested within another aggregate definition.

The __align specifier cannot be used in the following situations:

Not all alignments may be representable in an object file.

Examples

Applying __align to first-level variables:

int __align(1024) varA;        /* varA is aligned on a 1024-byte boundary
                                   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 size of variable alignment differs from size of 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 References

Compiler Command Line Options
#pragma align
#pragma pack

See also Aligning data in aggregates. IBM Copyright 2003