Question

Suppose I have an arbitrary function:

void someFunc(int, double, char); 

and I call someFunc(8, 2.4, 'a');, what actually happens? How does 8, 2.4, and ‘a’ get memory, moved into that memory, and passed into the function? What type of optimizations does the compiler have for situations like these? What if I mix and match parameters, such like someFunc(myIntVar, 2.4, someChar);?

What happens if the function is declared as inline?

Answer 1

It makes no difference that the values are literal or not (unless the function is inlined and then the compiler can optimize some stuff out).

Usually, parameters are put into registers or the function parameter stack. Regardless of whether they are explicit values or variables.

Without optimizations, the parameter gets pushed onto the parameter stack. In the first case, the value of x is taken first and put into register eax, then pushed into the parameter stack. foo prints x.

    foo(x);
00361A75  mov         eax,dword ptr [x] 
00361A78  push        eax  
00361A79  call        get_4 (3612B7h) 
00361A7E  add         esp,4 
    foo(3);
00361A81  push        3    
00361A83  call        get_4 (3612B7h) 
00361A88  add         esp,4 

With optimizations the function is visible to the compiler (in my sample) and the call is skipped altogether:

    foo(x);
01011000  mov         ecx,dword ptr [__imp_std::cout (101203Ch)] 
01011006  push        3    
01011008  call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (1012038h)] 
    foo(3);
0101100E  mov         ecx,dword ptr [__imp_std::cout (101203Ch)] 
01011014  push        3    
01011016  call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (1012038h)] 

foo is defined as:

void foo(int x)
{
   std::cout << x;
}