description: "Learn more about: alloc_text pragma"

ms.date: "08/29/2019"

helpviewer_keywords: ["alloc_text pragma", "pragmas, alloc_text"]

The **alloc_text** pragma does not handle C++ member functions or overloaded functions. It is applicable only to functions declared with C linkage — that is, functions declared with the **extern "C"** linkage specification. If you attempt to use this pragma on a function with C++ linkage, a compiler error is generated.

Since function addressing using **`__based`** is not supported, specifying section locations requires the use of the **alloc_text** pragma. The name specified by *textsection* should be enclosed in double quotation marks.

The **alloc_text** pragma must appear after the declarations of any of the specified functions and before the definitions of these functions.

Functions referenced in an **alloc_text** pragma should be defined in the same module as the pragma. Otherwise, if an undefined function is later compiled into a different text section, the error may or may not be caught. Although the program will usually run correctly, the function will not be allocated in the intended sections.

Other limitations on **alloc_text** are as follows:

[Pragma directives and the __pragma keyword](../preprocessor/pragma-directives-and-the-pragma-keyword.md)

description: "Learn more about: auto_inline pragma"

ms.date: "08/29/2019"

helpviewer_keywords: ["pragmas, auto_inline", "auto_inline pragma"]

Excludes any functions defined within the range where **off** is specified from being considered as candidates for automatic inline expansion.

To use the **auto_inline** pragma, place it before and immediately after, not inside, a function definition. The pragma takes effect as soon as the first function definition after the pragma is seen.

[Pragma directives and the __pragma keyword](../preprocessor/pragma-directives-and-the-pragma-keyword.md)

description: "Learn more about: bss_seg pragma"

ms.date: "08/29/2019"

helpviewer_keywords: ["pragmas, bss_seg", "bss_seg pragma"]

**push**\

(Optional) Puts a record on the internal compiler stack. A **push** can have an *identifier* and *section-name*.

**pop**\

(Optional) Removes a record from the top of the internal compiler stack. A **pop** can have an *identifier* and *section-name*. You can pop multiple records using just one **pop** command by using the *identifier*. The *section-name* becomes the active BSS section name after the pop.

(Optional) When used with **push**, assigns a name to the record on the internal compiler stack. When used with **pop**, the directive pops records off the internal stack until *identifier* is removed. If *identifier* isn't found on the internal stack, nothing is popped.

(Optional) The name of a section. When used with **pop**, the stack is popped and *section-name* becomes the active BSS section name.

The **bss_seg** pragma directive tells the compiler to put all uninitialized data items from the translation unit into a BSS section named *section-name*. In some cases, use of **bss_seg** can speed load times by grouping uninitialized data into one section. By default, the BSS section used for uninitialized data in an object file is named `.bss`. A **bss_seg** pragma directive without a *section-name* parameter resets the BSS section name for the subsequent uninitialized data items to `.bss`.

Data allocated using the **bss_seg** pragma does not retain any information about its location.

For a list of names that shouldn't be used to create a section, see [/SECTION](../build/reference/section-specify-section-attributes.md).

You can also specify sections for initialized data ([data_seg](../preprocessor/data-seg.md)), functions ([code_seg](../preprocessor/code-seg.md)), and const variables ([const_seg](../preprocessor/const-seg.md)).

[Pragma directives and the __pragma keyword](../preprocessor/pragma-directives-and-the-pragma-keyword.md)

description: "Learn more about: check_stack pragma"

ms.date: "08/29/2019"

helpviewer_keywords: ["check_stack pragma", "pragmas, check_stack", "pragmas, check_stack usage table"]

Instructs the compiler to turn off stack probes if **off** (or **-**) is specified, or to turn on stack probes if **on** (or **+**) is specified.

If you don't give an argument for the **check_stack** pragma, stack checking reverts to the behavior specified on the command line. For more information, see [Compiler options](../build/reference/compiler-options.md). The interaction of the `#pragma check_stack` and the [/Gs](../build/reference/gs-control-stack-checking-calls.md) option is summarized in the following table.

|Syntax|Compiled with<br /><br /> /Gs option?|Action|

|------------|------------------------------------|------------|

|`#pragma check_stack( )` or<br /><br /> `#pragma check_stack`|Yes|Turns off stack checking for functions that follow|

|`#pragma check_stack( )` or<br /><br /> `#pragma check_stack`|No|Turns on stack checking for functions that follow|

|`#pragma check_stack(on)`<br /><br /> or `#pragma check_stack +`|Yes or No|Turns on stack checking for functions that follow|

|`#pragma check_stack(off)`<br /><br /> or `#pragma check_stack -`|Yes or No|Turns off stack checking for functions that follow|

[Pragma directives and the __pragma keyword](../preprocessor/pragma-directives-and-the-pragma-keyword.md)