C Program to find direction of growth of stack

A stack is a data structure that stores elements in memory. The stack can grow in two directions: upward (toward higher memory addresses) or downward (toward lower memory addresses). This direction depends on the system architecture and compiler implementation.

When functions are called, local variables are allocated on the stack. By comparing the memory addresses of local variables in different function calls, we can determine the stack's growth direction.

Syntax

void function_name(int *address_pointer);
// Compare addresses using pointer arithmetic
if (address1 < address2) { /* stack direction logic */ }

Algorithm

Step 1: Create a local variable in the main function.
Step 2: Create a function with a local variable.
Step 3: Call the function from main and pass the address of main's local variable.
Step 4: Compare the address of local variables in main and the function.
Step 5: If the main variable's address is less than function variable's address, stack grows upward; otherwise downward.

Example

#include <stdio.h>

void checkStackDirection(int *main_local_addr) {
    int function_local;
    
    printf("Address of main's local variable: %p<br>", (void*)main_local_addr);
    printf("Address of function's local variable: %p<br>", (void*)&function_local);
    
    if (main_local_addr < &function_local) {
        printf("Stack grows upward (toward higher addresses)<br>");
    } else {
        printf("Stack grows downward (toward lower addresses)<br>");
    }
}

int main() {
    int main_local;
    
    printf("Checking stack growth direction...<br>");
    checkStackDirection(&main_local);
    
    return 0;
}

Output

Checking stack growth direction...
Address of main's local variable: 0x7ffd123456789
Address of function's local variable: 0x7ffd123456788
Stack grows downward (toward lower addresses)

How It Works

When main() is called first, its local variable is allocated on the stack. When checkStackDirection() is called from main(), its local variable is allocated after main's variable. By comparing these addresses, we determine if the stack grows toward higher memory addresses (upward) or lower addresses (downward).

Key Points

• On most modern systems (x86, x86_64), the stack typically grows downward.
• The actual addresses will vary between program runs due to address space layout randomization (ASLR).
• Stack direction is determined by the system architecture and is consistent within the same platform.

Conclusion

This program demonstrates how to determine stack growth direction by comparing memory addresses of local variables in different function scopes. Understanding stack direction is useful for system programming and debugging memory-related issues.