how to find if stack increases upwards or downwards?

how to find if stack increases upwards 开发者_StackOverflowor downwards?

This is very platform-dependent, and even application-dependent.

The code posted by Vino only works in targets where parameters are passed on the stack AND local variables are allocated from the stack, in that order. Many compilers will assign fixed memory addresses to parameters, or pass parameters in registers. While common, passing parameters on the stack is one of the least efficient ways to get data into and out of a function.

Look at the disassembly for your compiled app and see what code the compiler is generating. If your target has native stack manipulation commands (like PUSH and POP) that the compiler is using, then the CPU datasheet/reference manual will tell you which direction the stack is growing. However, the compiler may choose to implement its own stack, in which case you'll have to do some digging.

Or, read the stack pointer, push something on the stack, and read the stack pointer again. Compare the results of the first and second read to determine the direction in which the pointer moves.

For future reference: if you include some details about your target architecture (embedded? PC? Linux, Windows? GCC? VC? Watcom? blah blah blah) you'll get more meaningful answers.

One possible way is...

#include <stdio.h>

void call(int *a) 
{
    int b;

    if (&b > a) 
        printf("Stack grows up.\n");
    else 
        printf("Stack grows down.\n");
}

int main () 
{
    int a;
    call(&a);
    return 0;
}

Brute force approach is to fill your memory with a known value say 0xFF. Push some items on the stack. Do a memory dump. Push some more items on the stack. Do another memory dump.

Create function with many local variables.
Turn off optimizations. Either print the assembly language.. Or when debugging, display as mixed source and assembly language. Note the stack pointer (or register) before the function is executed. Single-step through the function and watch the stack pointer.

In general, whether a compiler uses incrementing or decrementing stack pointers is a very minor issue as long as the issue is consistent and working. This is one issue that rarely occupies my mind. I tend to concentrate on more important topics, such as quality, correctness and robustness.

I'll trust the compiler to correctly handle stack manipulation. I don't trust recursive functions, especially on embedded or restricted platforms.