Qual a relação deste endereço com o resto do enunciado do pb?
Não adianta avançar enquanto não responder a esta questão...

Este endereço é um valor muito próximo do valor do %eip imediatamente antes da execução destas 2 instruções; mais concretamente, está a apontar para o 3º byte localizado após o 1º byte da 1ª instrução.
Portanto, ou aponta para uma célula de memória que ainda contém parte da 1ª instrução, ou provavelmente é um endereço de memória que contém parte da 2ª instrução.

Sem ter de consultar o manual de referência da Intel com a especificação de todas as instruções do instruction set da família IA-32, será possível chegar a alguma conclusão?
Tente...!

Analisemos essa 1ª instrução: é uma instrução de mov, de Mem->Reg. De acordo com os formatos de instrução da Intel, qq instrução deste tipo em que especificam 2 operandos, são necessários pelo menos 2 bytes: um contendo o código de operação (opcode), e outro especificando um registo e um registo/memória.
Se o campo da instrução que especifica o registo/memória indicar uma localização de memória que necessite de adicionar o valor de um deslocamento (offset), este terá de vir no(s) byte(s) seguinte(s).

No caso concreto desta instrução, a especificação do endereço de memória - 8(%ebp) - requer o valor de um deslocamento positivo e menor que 127, pelo que é possível especificá-lo usando apenas 1 byte adicional, que será o 3º byte da instrução. E este 3º byte encontra-se precisamente no endereço 0x8124020...

Assim, sendo, qual será o valor que se encontra na memória nesse endereço?...

Sugestão de resolução

Quando se analisa a estrutura da stack na fase de arranque de uma função, quais as tarefas que normalmente são efectuadas?

PENSE!

E na salvaguarda de registos, que registos competem à função chamada guardar?
E que registo é usado para escrita na 2ª instrução em assembly deste enunciado?
E onde vai ser salvaguardado o conteúdo desse registo?

E se ficar aí, o array pode ficar onde se indica no enunciado?...

a) (...)
b) (...)
c) (...)
d) (...)
e) (...)
f) (...)
g) Indique o endereço provável da instrução que invoca esta função.
Nota: a resolução correcta desta alínea, após resolução da seguinte, pode estar ao alcance da classificação R (quase B); sem esta dica, é indispensável para a classificação E.

Sugestão de resolução

Veja no fim da resolução da alínea seguinte.

No interior de uma função em C encontra-se a seguinte instrução:
               var_x += elem_y[ind]

Quando essa instrução é compilada num PC (little endian) com "gcc –S" ... :
       movl   8(%ebp), %ecx
       addl   -24(%ebp, %ecx,4), %edi

a) (...)
b) (...)
c) (...)
d) (...)
e) (...)
f) (...)
g) (...)
h) Mostre a estrutura da stack associada a esta função na arquitetura IA-32, após a invocação da função e imediatamente antes da execução do corpo da função, indicando a dimensão e conteúdo de todas as células relevantes, bem como a localização do stack pointer e do base pointer.

Sugestão de resolução

Regressar...

R1.
Considere a expressão aritmética com inteiros a=b[i]-10, inserida no corpo de uma função em C, em que a é uma variável global escalar (cujo apontador foi passado como 1º argumento), b é um array global (cujo apontador foi passado como 2º argumento), i é a única variável escalar da função.

a) Apresente o código assembly que poderia ser gerado pelo gcc para IA-32, quando encontrasse essa expressão.

Sugestão de resolução

A operação pretendida é uma subtracção, que no caso do IA-32 será do tipo subl Src1,Dest, o que corresponde a Dest=Dest-Src .
Isto sugere, desde já, que se carregue o elemento do array da memória para um registo, e se faça a subtracção com operandos em registos, para minimizar acessos à memória.
De notar ainda que o índice do array, sendo a única variável escalar da função, muito provavelmente estará alojada num registo (tb para minimizar acessos à memória); vamos considerar que é o registo %ecx.

Sugestão de conversão desta instrução em C para uma sequência de outras que possam ser directamente traduzidas para assembly do IA-32 (notar que a utilização de uma variável temporária, local à função, pressupõe que o compilador irá usar um registo para essa variável):

    temp=b[i];
  temp-=10;
  a=temp;

Vamos ver agora se é possível traduzir cada uma destas instruções directamente para assembly (tente antes de espreitar para a resolução...):

Não é possível... pois é preciso ir tb à memória buscar os endereços do início do array e da variável global a.

       movl   12(%ebp), %esi        ; %esi= endereço do início do array b
       movl   (%esi,%ecx,4), %eax   ; %eax= b[i]
       subl   $-10, %eax            ; %eax= b[i]-10
       movl   8(%ebp), %esi         ; %esi= endereço da variável a
       movl   %eax, (%esi)          ; a= b[i]-10

Considere a expressão aritmética com inteiros a=b[i]-10, inserida no corpo de uma função em C, em que a é uma variável global escalar (cujo apontador foi passado como 1º argumento), b é um array global (cujo apontador foi passado como 2º argumento), i é a única variável escalar da função.

a) (...)
b) Mostre a estrutura da stack associada a esta função na arquitectura IA-32, após a invocação da função e imediatamente antes da execução do corpo da função, indicando a dimensão e conteúdo de todas as células relevantes, bem como a localização do stack pointer e do base pointer.

Sugestão de resolução

Quanto aos valores dos registos %ebp e %esp: o 1º aponta para a célula que tem o byte menos significativo do antigo valor do frame pointer, enquanto que o 2º aponta para o byte menos significativo do conteúdo do registo %esi, que foi salvaguardado por esta função.

Considere a expressão aritmética com inteiros a=b[i]-10, inserida no corpo de uma função em C, em que a é uma variável global escalar (cujo apontador foi passado como 1º argumento), b é um array global (cujo apontador foi passado como 2º argumento), i é a única variável escalar da função.

Sugestão de resolução

Vamos considerar o seguinte código C que satisfaz os requisitos do enunciado:

Vamos agora construir o código do corpo da função e, dentro deste, começar pelo código no interior do ciclo.

Código correspondente a *a=b[i]-10; :
        movl    12(%ebp),%edx
        movl    (%edx,%ebx,4),%eax
        subl    $10,%eax
        movl    %eax,(%edi)

Código correspondente a  printf ("->%d", *a);:
         ??                  ; passagem do 1º argumento para printf
        pushl   %eax
        call    _printf

Código genérico em C associado ao ciclo for :
        expr_inic ;
        cond = expr_test ;
        if (! cond)
            goto done;
    loop:
        body_statement
        act_expr ;
        cond = expr_test ;
        if (cond)
            goto loop;
    done:

Código em C para o ciclo for neste exercício concreto (em que a "variável" cond foi sempre substituída por expr_test ), e respectiva codificação em assembly:
        i = 0 ;                        xorl    %ebx,%ebx
        if (i >= dim)                  cmpl    %esi,%ebx
            goto done;                 jge     L6
    loop:                            L5:
        *a=b[i]-10;                                        ; transcrever código feito em cima
        printf ("->%d", *a);                               ; transcrever código feito em cima
        i++ ;                          incl    %ebx
        if (i < dim)                   cmpl    %esi,%ebx
            goto loop;                 jl      L5:
    done:                            L6: