Was this page helpful?
Your feedback about this content is important. Let us know what you think.
Additional feedback?
1500 characters remaining
Rules and Limitations for Naked Functions
Collapse the table of content
Expand the table of content

Rules and Limitations for Naked Functions

The following rules and limitations apply to naked functions:

  • The return statement is not permitted.

  • Structured Exception Handling and C++ Exception Handling constructs are not permitted because they must unwind across the stack frame.

  • For the same reason, any form of setjmp is prohibited.

  • Use of the _alloca function is prohibited.

  • To ensure that no initialization code for local variables appears before the prolog sequence, initialized local variables are not permitted at function scope. In particular, the declaration of C++ objects is not permitted at function scope. There may, however, be initialized data in a nested scope.

  • Frame pointer optimization (the /Oy compiler option) is not recommended, but it is automatically suppressed for a naked function.

  • You cannot declare C++ class objects at the function lexical scope. You can, however, declare objects in a nested block.

  • The naked keyword is ignored when compiling with /clr.

  • For __fastcall naked functions, whenever there is a reference in C/C++ code to one of the register arguments, the prolog code should store the values of that register into the stack location for that variable. For example:

// nkdfastcl.cpp
// compile with: /c
// processor: x86
__declspec(naked) int __fastcall  power(int i, int j) {
   // calculates i^j, assumes that j >= 0

   // prolog
   __asm {
      push ebp
      mov ebp, esp
      sub esp, __LOCAL_SIZE
     // store ECX and EDX into stack locations allocated for i and j
     mov i, ecx
     mov j, edx

      int k = 1;   // return value
      while (j-- > 0) 
         k *= i;
      __asm { 
         mov eax, k 

   // epilog
   __asm {
      mov esp, ebp
      pop ebp

Community Additions

© 2015 Microsoft