Saves the current pragma state.

Restores the previously saved pragma state.

Changes optimization level. The value of num is 0, 1, 2 or 3.

Optimizes for space.

Optimizes for time.

Switches code generation to the ARM instruction set. This pragma overrides the --thumb compiler option.

Switches code generation to the Thumb^® instruction set. This pragma overrides the --arm compiler option.

If you are compiling code for a pre-Thumb-2 processor and using VFP, any function containing floating-point operations is compiled for ARM.

Enables or disables function unwinding at runtime. See Function unwinding at runtime for more details.

When this is placed at the beginning of a header file, it indicates that the header file has been written in a way that including it several times has the same effect as including it once. Therefore, the compiler skips any subsequent includes of that file.

Typically, you place a #ifndef guard around the body of the file, with a #define of the guard variable after the #ifndef, for example:

#ifndef FILE_H
#define FILE_H
#pragma once         // optional
... body of the header file ...
#endif

The #pragma once is marked as optional in this example. This is because the compiler recognizes the #ifndef header guard coding and skips subsequent includes even if #pragma once is absent.

#pragma once is accepted for compatibility with other compilers, and enables you to use other forms of header guard coding. However, it is preferable to use #ifndef and #define coding because this is more portable.

#pragma softfp_linkage asserts that all function declarations up to the next #pragma no_softfp_linkage describe functions that use software floating-point linkage. The __softfp keyword has the same effect (see Function keywords). The pragma form can be useful when applied to an entire interface specification (header file) without altering that file.

Generates an importing reference to symbol_name. This is the same as the assembler directive:

The symbol name is placed in the symbol table of the image as an external symbol. It is otherwise unused. You must not define the symbol or make a reference to it.

You can use this pragma to select certain features of the C library, such as the heap implementation or real-time division. If a feature described in this book requires a symbol reference to be imported, the required symbol is specified. For an example, see Avoiding semihosting.

Specifies that the Code or Data section name is used for subsequent functions or objects. This includes definitions of anonymous objects the compiler creates for initializations. The option has no effect on:

The full syntax for the pragma is:

#pragma arm section [sort_type[[=]"name"]] [,sort_type="name"]*

Where name is the name to use for the section, and sort_type is one of:

If sort_type is specified but name is not, the section name for sort_type is reset to the default value. Enter #pragma arm section on its own to restore the names of all object sections to their defaults (see Example 3.1).

    int x1 = 5;                     // in .data (default)
    int y1[100];                    // in .bss (default)
    int const z1[3] = {1,2,3};      // in .constdata (default)

    #pragma arm section rwdata = "foo", rodata = "bar"

    int x2 = 5;                     // in foo (data part of region)
    int y2[100];                    // in .bss
    int const z2[3] = {1,2,3};      // in bar
    char *s2 = "abc";               // s2 in foo, "abc" in .conststring

    #pragma arm section rodata
    int x3 = 5;                     // in foo
    int y3[100];                    // in .bss
    int const z3[3] = {1,2,3};      // in .constdata
    char *s3 = "abc";               // s3 in foo, "abc" in .conststring

    #pragma arm section code = "foo"
    int add1(int x)                   // in foo (code part of region)
    {
        return x+1;
    } 
    #pragma arm section code

Enables you to specify where the set of header files subject to precompilation ends.

This must appear before the first token that does not belong to a preprocessing directive.

Suppresses PCH processing for a given source file.

Enables support for anonymous structures and unions. See Anonymous classes, structures and unions for more details.

Returns the severity of a diagnostic message to the one that was in effect before any pragmas were issued (that is, the normal severity of the message as modified by any command-line options).

Sets the diagnostic messages that have the specified tag(s) to Error severity.

Sets the diagnostic messages that have the specified tag(s) to Remark severity.

Disables all diagnostic messages that have the specified tag(s).

Sets the diagnostic messages that have the specified tag(s) to Warning severity.