Question

Imagine I have the following code

void A(){
// blah blah blah
}
void B(){
// blah blah blah
}
void C(){
// blah blah blah
}

When the code’s compiled (using Visual Studio) and loaded into memory to execute, the addresses of A(), B(), C() may not in sequential order. How can we make them ordered? Is there any directive useful in this situation?

Answer 1

If your program consists of a single translation unit (source file), the resulting binary should usually contain the functions in the order in which they are defined in the translation unit. For example, consider the following program:

int A() { return  0; }
int B() { return  1; }
int C() { return -1; }

int main() { return A() + B() + C(); }

If you compile this program optimized for minimum size (/O1) and with inline function expansion disabled (/Ob0), the following machine code is produced:

int A() { return  0; }
00F71000 33 C0                xor         eax,eax  
00F71002 C3                   ret  
int B() { return  1; }
00F71003 33 C0                xor         eax,eax  
00F71005 40                   inc         eax  
00F71006 C3                   ret  
int C() { return -1; }
00F71007 83 C8 FF             or          eax,0FFFFFFFFh  
00F7100A C3                   ret  

int main() { return A() + B() + C(); }
00F7100B E8 F0 FF FF FF       call        A (0F71000h)  
00F71010 8B C8                mov         ecx,eax  
00F71012 E8 EC FF FF FF       call        B (0F71003h)  
00F71017 03 C8                add         ecx,eax  
00F71019 E8 E9 FF FF FF       call        C (0F71007h)  
00F7101E 03 C1                add         eax,ecx  
00F71020 C3                   ret  

The source annotations are provided by the debugger. Optimization for minimum size is required to eliminate the int 3 padding that is placed between functions when other optimization settings are used. Inline function expansion must be disabled to ensure that the functions actually exist in the resulting binary.

This is, to the best of my knowledge, an implementation detail, so it should not be relied upon in production code.