Memória Stack

[vitorrtonon]

Olá, boa tarde!

Eu tenho uma dúvida a respeito da disposição da região de memória armazenada pelas variáveis de meu programa.

Nós sabemos que as variáveis são "empilhadas" na memória Stack a medida que aparecem no programa.

Da mesma forma, sabemos que a região do topo da pilha tem sempre menor posição de memória que um elemento mais no seu "fundo".

Por exemplo, se eu tenho o seguinte trecho de código:

int main (int argc, char *argv[])

{

int a;

char b;

printf("Endereco de a: %p\n", &a);

printf("Endereco de b: %p\n", &;

return 0;

}

Em uma execução, tenho a seguinte saída:

Endereco de a: 0xbf9bf72c

Endereco de b: 0xbf9bf72b

Ou seja, a memória stack, basicamente, está da seguinte maneira:

b

a

Por outro lado, se o meu código é o seguinte:

int main (int argc, char *argv[])

{

int c, a;

char b;

printf("Endereco de argc: %p\n", &argc);

printf("Endereco de a: %p\n", &a);

printf("Endereco de b: %p\n", &;

printf("Endereco de c: %p\n", &c);

return 0;

}

A saída é:

Endereco de argc: 0xbffa8bc0

Endereco de a: 0xbffa8bac

Endereco de b: 0xbffa8ba7

Endereco de c: 0xbffa8ba8

Ou seja, teríamos uma pilha da seguinte maneira:

b

c

a

argc

No entanto, seguindo o conceito de que as variáveis são empilhadas na memória em ordem de declaração, deveríamos ter, na verdade, o seguinte:

b

a

c

argc.

Alguém poderia me explicar o motivo dessa divergência?

Obrigado.

[LNW]

Olá vitorrtonon,

Olá, boa tarde!

Eu tenho uma dúvida a respeito da disposição da região de memória armazenada pelas variáveis de meu programa.

Nós sabemos que as variáveis são "empilhadas" na memória Stack a medida que aparecem no programa.

[...]

No entanto, seguindo o conceito de que as variáveis são empilhadas na memória em ordem de declaração, deveríamos ter, na verdade, o seguinte:

b

a

c

argc.

Alguém poderia me explicar o motivo dessa divergência?

Obrigado.

Uma característica by design do próprio compilador? Ele teria a liberdade para definir em que posições (na stack..) colocar as variáveis. Tentarei explicar; eu estendi o seu programa, dê uma olhada:

int main (int argc, char *argv[])
{
    int c = 1, a = 2, d = 3;
    char b;
    int e;

    printf("Endereco de argv: %p\n", &argv);
    printf("Endereco de argc: %p\n\n", &argc);

    printf("Endereco de c: %p - Valor: %d\n", &c, *(&c - 0));
    printf("Endereco de a: %p - Valor: %d\n", &a, *(&c - 1));
    printf("Endereco de d: %p - Valor: %d\n", &d, *(&c - 2));

    printf("\nEndereco de b: %p\n", &;

    printf("\nEndereco de e: %p\n", &e);

    return 0;
}

E resulta:

stack frame (env, argv, argc)

Endereco de argv: 0028FF34

Endereco de argc: 0028FF30

stack frame (main() - auto variables)

Endereco de c: 0028FF1C - Valor: 1

Endereco de a: 0028FF18 - Valor: 2

Endereco de d: 0028FF14 - Valor: 3

Endereco de b: 0028FF13

Endereco de e: 0028FF0C

Passa a impressão que variáveis do mesmo tipo declaradas contiguamente são arranjadas em memória pelo compilador para poderem ser tratadas como scalars. No exemplo acima, o acesso aos valores das outras variáveis através de um offset tomando como base o endereço de c parece evidenciar essa possibilidade. Veja que a variável e, já não mais contígua, está alocada num endereço 8 bytes posterior ao da última inteira (d).

Creio que o acesso à documentação da especificação da linguagem ou do compilador poderia confirmar essa questão. Particularmente, não me restam muitas dúvidas sobre isso...

[]'s

LNW