Declares a local object (auto variable) to have the storage class register. A register declaration is a suggestion to the compiler that it is to attempt to put the object in a physical register. However, if no more registers are available, the compiler places the object on the stack instead.

Depending on the variant of the AAPCS being used, there are between five and seven integer registers available, and four floating-point registers. In general, it is recommended that you do not declare more than four integer register variables and two floating-point register variables.

The following object types can be declared to have the register storage class:

This type specifier is an alternative name for type long long. This is accepted even when using --strict.

This storage class specifier allocates the declared variable to a global integer register variable. If you use this storage class, you cannot also use any of the other storage classes such as extern, static, or typedef. vreg is an AAPCS callee-save register (for example, v1) and not a real register number (for example, r4). In C, global register variables cannot be qualified or initialized at declaration. In C++, any initialization is treated as a dynamic initialization. Valid types are:

For example, to declare a global integer register variable allocated to r5 (the AAPCS register v2), use the following:

__global_reg(2) int x;

The global register must be specified in all declarations of the same variable. For example, the following is an error:

int x;
__global_reg(1) int x; // error

Also, __global_reg variables in C cannot be initialized at definition. For example, the following is an error in C, but not in C++:

__global_reg(1) int x=1; // error in C, OK in C++

Depending on the AAPCS variant used, between five and seven integer registers, and four floating-point registers are available for use as global register variables. In practice, it is recommended that you do not use more than three global integer register variables in ARM code, or more than one global integer register variable in Thumb code, or more than two global floating-point register variables.

Unlike register variables declared with the standard register keyword, the compiler does not move global register variables to memory as required. If you declare too many global variables, code size increases significantly. In some cases, your program might not compile.

The __align(n) storage class modifier aligns a top-level object on an n-byte boundary, where n is either 2, 4, or 8. Eight-byte alignment is required if you are using the LDRD or STRD instructions, and can give a significant performance advantage with VFP instructions.

For example, if you are using LDRD or STRD instructions to access data objects defined in C or C++ from ARM assembly language, you must use the __align(8) storage class specifier to ensure that the data objects are properly aligned.

You can specify a power of two for the alignment boundary, however eight is the maximum for auto variables. Also, you can only overalign, that is, you can make a 2-byte object 4-byte aligned but you cannot align a 4-byte object at 2 bytes.

__align(n) is a storage class modifier. This means that it can be used only on top-level objects. You cannot use it on:

__align(n) can be used in conjunction with extern and static.

__align(8) only ensures that the qualified object is eight-byte aligned. This means, for example, that you must explicitly pad structures where required.

The __weak keyword can be applied to function and object declarations, and to function definitions:

The __packed qualifier sets the alignment of any valid type to 1. This means:

The __packed qualifier cannot be used on structures that were previously declared without __packed.

The __packed qualifier does not affect local variables of integral type.

The __packed qualifier applies to all members of a structure or union when it is declared using __packed. There is no padding between members, or at the end of the structure. All substructures of a packed structure must be declared using __packed. Integral subfields of an unpacked structure can be packed individually.

A packed structure or union is not assignment-compatible with the corresponding unpacked structure. Because the structures have a different memory layout, the only way to assign a packed structure to an unpacked structure is by a field-by-field copy. See also Packed structures.

The effect of casting away __packed is undefined. The effect of casting a non-packed structure to a packed structure is undefined. A pointer to an integral type can be legally cast, explicitly or implicitly, to a pointer to a packed integral type.

A pointer can point to a packed type (see Example 3.3).

typedef __packed int* PpI;          /*pointer to a __packed int */
PpI p2;                             /* 'p2' has the same type as 'p' */
                                    /* __packed is a qualifier  */
                                    /* just like 'const' or 'volatile' */

typedef int *PI;                    /* pointer to int */
__packed PI p3;                     /* a __packed pointer to a normal int */
                                    /*  -- not the same type as 'p' and 'p2' */

int *__packed p4;                   /* 'p4' has the same type as 'p3' */

There are no packed array types. A packed array is an array of objects of packed type. There is no padding in the array.

The __packed qualifier is useful to map a structure to an external data structure, or for accessing unaligned data, but it is generally not useful to save data size because of the relatively high cost of access. Only packing fields in a structure that requires packing can reduce the number of unaligned accesses.

When a packed object is accessed using a pointer, the compiler generates code that works and that is independent of the pointer alignment (see Example 3.4).

typedef __packed struct
{
    char x;                   // all fields inherit the __packed qualifier	
    int y;
}X;                           // 5 byte structure, natural alignment = 1	

int f(X *p)
{
    return p->y;              // does an unaligned read
}

typedef struct
{
    short x;
    char y;
    __packed int z;           // only pack this field
    char a;
}Y;                           // 8 byte structure, natural alignment = 2

int g(Y *p)
{
    return p->z + p->x;       // only unaligned read for z
}

The standard ISO qualifier volatile informs the compiler that the qualified type contains data that can be changed from outside the program. Such variables must be placed in RW or ZI data (not in .constdata) so that they can be changed. This includes const volatile variables.

The compiler does not attempt to optimize accesses to volatile types. For example, volatile structures can be mapped onto memory-mapped peripheral registers:

/* define a memory-mapped port register */
volatile unsigned *port = (unsigned int *) 0x40000000;

/* to access the port */
*port = value;     /* write to port */
value = *port;     /* read from port */

In ARM C and C++, a volatile object is accessed if any word or byte (or halfword on ARM architectures with halfword support) of the object is read or written. For volatile objects, reads and writes occur as directly implied by the source code, in the order implied by the source code. The effect of accessing a volatile short is undefined for ARM architectures that do not support halfwords. Accessing volatile packed data is undefined.