This pragma marks printf-like functions for type checking against a literal format string, if it exists. If the format is not a literal string, no type checking is done. The format string must be the last fixed argument. For example:

#pragma check_printf_formats
extern void myprintf(const char * format,...);	
                    //printf format
#pragma no_check_printf_formats

This pragma marks a function declared as a scanf-like function, so that the arguments are type checked against the literal format string. If the format is not a literal string, no type checking is done. The format string must be the last fixed argument. For example:

#pragma check_scanf_formats
extern void myformat(const char * format,...);
                    //scanf format
#pragma no_check_scanf_formats

This pragma turns debug table generation on or off.

If #pragma no_debug is specified, no debug table entries are generated for subsequent declarations and functions until the next #pragma debug.

This pragma optimizes for space (uppercase O).

This pragma optimizes for time.

This pragma changes optimization level. The value of num is 0, 1, or 2. See Defining optimization criteria for more information on optimization levels.

This pragma reenables the generation of function entry code that checks for stack limit violation if stack checking has been disabled with #pragma no_check_stack and the -apcs /swst command-line option is used.

This pragma 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 and is preferred (see Function keywords). The pragma form can be useful when applied to an entire interface specification (header file) without altering that file.

This pragma 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. For an example of its use, see Avoiding the semihosting SWI.

This pragma specifies the code or data section name that 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 bar
    #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 .constdata
    #pragma arm section code = "foo"
    int add1(int x)                   // in foo (code part of region)
    {
        return x+1;
    } 
    #pragma arm section code