In C programming, function prototypes and local variables are fundamental. Function prototypes declare the interface of functions, while local variables store temporary data within functions. Understanding their impact on assembly code helps in writing efficient programs and debugging at the assembly level.
What are Function Prototypes in C?
A function prototype is a declaration that specifies a function’s name, return type, and parameter types—without providing its body. For example:
int add(int a, int b);
This declaration informs the compiler about the function’s interface and enables type checking during compilation.
Do Function Prototypes Generate Assembly Code?
Function prototypes themselves do not generate assembly code. They serve as declarations, allowing the compiler to verify function usage. Only when a function is defined does the compiler generate corresponding assembly instructions.
What are Local Variables in C?
Local variables are declared within functions and are accessible only within their scope. For example:
void quiz() { int score = 0; }
In this case, score is a local variable accessible only within the function quiz().
Do Local Variables Generate Assembly Code?
Local variables may generate assembly code depending on their usage:
- Unused Local Variables: If you declare a variable but don’t use it, modern compilers often remove it during optimization. In that case, the compiler won’t generate any assembly code for it.
- Used Local Variables: When you use a local variable, the compiler sets aside space—usually on the stack—and creates assembly instructions to manage its value.
Assembly Code Generation
Function Prototypes
As declarations, function prototypes do not produce assembly code. They guide the compiler during the compilation process but have no direct representation in the generated assembly.
Local Variables
When local variables are used, the compiler generates assembly code to allocate space and manage their values.
Example 1: Only Declarations (No Initialization)
void lvar_funpt() { long a1, a2, a3, a4, a5, a6, a7, a8, a9, a10; int *pi1, *pi2, *pi3, *pi4, *pi5, *pi6, *pi7, *pi8, *pi9, *pi10; fun_ret_ptr(); fun_ret_int(); }
Corresponding x86-64 Assembly (GCC or Clang):
lvar_funpt: pushq %rbp movq %rsp, %rbp movl $0, %eax call fun_ret_ptr movl $0, %eax call fun_ret_int popq %rbp ret
Observation: No assembly instructions were generated for any of the declared variables or function prototypes. Only the function calls appear in the output.
Example 2: Declarations with Initialization
void lvar_funpt() { long a1 = 10, a2 = 20, a3 = 30, a4 = 40, a5 = 50; int *pi1 = (int *)100; int *pi2 = (int *)200; fun_ret_ptr(); fun_ret_int(); }
Corresponding x86-64 Assembly:
lvar_funpt: pushq %rbp movq %rsp, %rbp subq $64, %rsp movq $10, -8(%rbp) movq $20, -16(%rbp) movq $30, -24(%rbp) movq $40, -32(%rbp) movq $50, -40(%rbp) movq $100, -48(%rbp) movq $200, -56(%rbp) movl $0, %eax call fun_ret_ptr movl $0, %eax call fun_ret_int leave ret
Observation: Now you see specific instructions that allocate space on the stack and assign values to variables. This proves that only used or initialized local variables impact the generated assembly.
Example 3:
int sum(int a, int b) { int result = a + b; return result; }
A possible assembly translation might look like:
sum: push rbp mov rbp, rsp mov DWORD PTR [rbp-4], edi mov DWORD PTR [rbp-8], esi mov eax, DWORD PTR [rbp-4] add eax, DWORD PTR [rbp-8] pop rbp ret
In this assembly code:
- push rbp and mov rbp, rsp set up the stack frame.
- the mov DWORD PTR [rbp-4], edi stores the first parameter.
- mov DWORD PTR [rbp-8], esi stores the second parameter.
- mov eax, DWORD PTR [rbp-4] and add eax, DWORD PTR [rbp-8] compute the sum.
- pop rbp and ret clean up and return.
This demonstrates how local variables and operations on them are represented in assembly.
How to View Assembly Code
You can inspect assembly output with these commands:
gcc -S -O2 test.c -o test.s # Using GCC clang -S -O2 test.c -o test.s # Using Clang
These commands generate a .s file containing the assembly code.
Sanfoundry Global Education & Learning Series – 1000 C Tutorials.
- Practice BCA MCQs
- Watch Advanced C Programming Videos
- Check C Books
- Practice Computer Science MCQs
- Apply for Computer Science Internship