Freigeben über


intrinsic

Specifies that calls to functions specified in the pragma's argument list are intrinsic.

#pragma intrinsic( function1 [, function2, ...] )

Remarks

The intrinsic pragma tells the compiler that a function has known behavior. The compiler may call the function and not replace the function call with inline instructions, if it will result in better performance.

The library functions with intrinsic forms are listed below. Once an intrinsic pragma is seen, it takes effect at the first function definition containing a specified intrinsic function. The effect continues to the end of the source file or to the appearance of a function pragma specifying the same intrinsic function. The intrinsic pragma can be used only outside of a function definition — at the global level.

The following functions have intrinsic forms and the intrinsic forms are used when you specify /Oi:

_disable

_outp

fabs

strcmp

_enable

_outpw

labs

strcpy

_inp

_rotl

memcmp

strlen

_inpw

_rotr

memcpy

 

_lrotl

_strset

memset

 

_lrotr

abs

strcat

 

Programs that use intrinsic functions are faster because they do not have the overhead of function calls but may be larger due to the additional code generated.

x86 Specific

The _disable and _enable intrinsics generate kernel-mode instructions to disable/enable interrupts and could be useful in kernel-mode drivers.

Example

Compile the following code from the command line with "cl -c -FAs sample.c" and look at sample.asm to see that they turn into x86 instructions CLI and STI:

// pragma_directive_intrinsic.cpp
// processor: x86
#include <dos.h>   // definitions for _disable, _enable
#pragma intrinsic(_disable)
#pragma intrinsic(_enable)
void f1(void) {
   _disable();
   // do some work here that should not be interrupted
   _enable();
}
int main() {
}

End x86 Specific

The floating-point functions listed below do not have true intrinsic forms. Instead they have versions that pass arguments directly to the floating-point chip rather than pushing them onto the program stack:

acos

cosh

pow

tanh

asin

fmod

sinh

 

The floating-point functions listed below have true intrinsic forms when you specify /Oi, /Og, and /fp:fast (or any option that includes /Og: /Ox, /O1, and /O2):

atan

exp

log10

sqrt

atan2

log

sin

tan

cos

 

 

 

You can use /fp:strict or /Za to override generation of true intrinsic floating-point options. In this case, the functions are generated as library routines that pass arguments directly to the floating-point chip instead of pushing them onto the program stack.

See # pragma function for information and an example on how to enable/disable intrinsics for a block of source text.

See Also

Concepts

Pragma Directives and the __Pragma Keyword

Compiler Intrinsics