[ASSEMBLY] Record di attivazione per variabili

[AR64S-H]

Qualkuno mi sa dire come si fa a capire in quale luogo del record di attivazione vanno le variabili. Ecco un esempio di record di attivazione di un esercizio:

# R | ... |
# E +- +---------------+
# C | | EBP vecchio | <-- %EBP (link dinamico)
# O | +---------------+
# R | | ind.ritorno | <-- +4(%EBP) (link statico)
# D | +---------------+
# | | ind.matr | <-- +8(%EBP) (I argomento)
# A | +---------------+
# T | | dim | <-- +12(%EBP) (II argomento)
# T +- +---------------+
# | ... |
#

perkè dim va al 12(%ebp) e magari una variabile lim va a -4(%ebp) e perkè ind. ritorno va a 4(%ebp) e ind.matr a 8(%ebp) piuttosto ke il contrario. Non riesco a capire questo il resto l'ho capito questo no

[andbin]

Originariamente inviato da AR64S-H
Qualkuno mi sa dire come si fa a capire in quale luogo del record di attivazione vanno le variabili. Ecco un esempio di record di attivazione di un esercizio:

# R | ... |
# E +- +---------------+
# C | | EBP vecchio | <-- %EBP (link dinamico)
# O | +---------------+
# R | | ind.ritorno | <-- +4(%EBP) (link statico)
# D | +---------------+
# | | ind.matr | <-- +8(%EBP) (I argomento)
# A | +---------------+
# T | | dim | <-- +12(%EBP) (II argomento)
# T +- +---------------+
# | ... |
#

perkè dim va al 12(%ebp) e magari una variabile lim va a -4(%ebp) e perkè ind. ritorno va a 4(%ebp) e ind.matr a 8(%ebp) piuttosto ke il contrario. Non riesco a capire questo il resto l'ho capito questo no

Supponendo di lavorare a 32 bit, con una procedura che usa la convenzione di passaggio "cdecl", si ha la seguente situazione:

Il chiamante ha un codice del tipo:

PUSH   arg N
PUSH   arg N-1
    ....
PUSH   arg 2
PUSH   arg 1
CALL   Procedure
ADD    ESP,args_size

La procedura chiamata ha un codice del tipo:

PUSH   EBP
MOV    EBP,ESP
SUB    ESP,locals_size
    ....
    ....
MOV    ESP,EBP
POP    EBP
RET

Lo stack frame quindi è composto così:

  32  bit
/         \

|         |
+---------+
| arg N   | EBP+??
+---------+
| arg N-1 |
+---------+
|   ...   |
+---------+
|   ...   |
+---------+
|  arg 2  |
+---------+
|  arg 1  | EBP+8
+---------+
| old EIP | EBP+4
+---------+
| old EBP | EBP
+---------+
|  local  | EBP-4
+---------+
|   ...   |
+---------+
|   ...   |
+---------+
|  local  | <-- ESP
+---------+
|         |

[AR64S-H]

mmh no ancora non mi è chiaro!! Scusa se io ho il codice del chiamante

# Esempio di utilizzo della routine bSort
# per l'ordinamento di un vettore con la
# tecnica del "bubble sort"
#

.GLOBAL start

.DATA

vett: .LONG 1,2,3,4,5,6,7,8,8,7,6,5,4,3,2,1
dim: .LONG 16

.TEXT
.INCLUDE "../lib/servizio"
.INCLUDE "../lib/print.s"

start:
#
#------ prologo chiamante -------
#

pushl dim # II argomento (dim)
pushl $vett # I argomento (ind.vett)
# inserimento in ordine inverso
# "alla C"
#
#---- fine prologo chiamante ----
#

call bSort # il risultato è in vett.

#
#------ epilogo chiamante -------
#

addl $8, %esp # rimuove gli argomenti
# dallo stack
#
#---- fine epilogo chiamante ----
#

call printCRLF # stampa di un vettore...
call printCRLF

movl $vett, %esi
movl dim, %ecx # mette in ECX il numero di elementi
ciclo:
lodsl # mette in EAX l'elemento del vettore
call printIL # stampa l'elemento del vettore
call printTAB
loop ciclo

call printCRLF
call printCRLF

jmp dos # termina il programma

e poi la subroutine:

.GLOBAL bSort

.TEXT

# Ordinamento di un vettore per mezzo della tecnica "bubble sort"
#
# Implementazione Java della funzione:
#
# void bSort (int [] vett, int dim) {
# int lim = dim-1;
# int j;
# int i;
# while (lim > 0) {
# j = 0;
# i = 0;
# while (i < lim) {
# if (vett[i] > vett[i+1]) {
# int temp = vett[i+1];
# vett[i+1] = vett[i];
# vett[i] = temp;
# j = i;
# }
# i++;
# }
# lim = j;
# }
# }
#
# record di attivazione della routine "bSort":
#
# | ... |
# +- +---------------+
# R | | lim | <-- -4(%EBP) (variabile d'ambiente)
# E | +---------------+
# C | | EBP vecchio | <-- %EBP (link dinamico)
# O | +---------------+
# R | | ind.ritorno | <-- +4(%EBP) (link statico)
# D | +---------------+
# | | ind.vett | <-- +8(%EBP) (I argomento)
# A | +---------------+
# T | | dim | <-- +12(%EBP) (II argomento)
# T +- +---------------+
# | ... |
#

bSort:
#
#------ prologo -------
#

pushl %ebp # link dinamico
movl %esp, %ebp # base del record d'attivazione

pushl $0 # riserva lo spazio per una
# variabile d'ambiente

pushl %eax #
pushl %ebx # salvataggio dei registri
pushl %ecx # che verranno usati
pushl %esi #
pushl %edi #

#
#---- fine prologo ----
#

movl 8(%ebp), %ebx # mette in EBX ind.vett

movl 12(%ebp), %eax #
decl %eax #
movl %eax, -4(%ebp) # lim = dim-1


ciclo_lim:
cmpl $0, -4(%ebp) # if (lim <= 0)
je fine_lim # then "vai a fine"

movl $0, %ecx # j = 0
movl $0, %esi # i = 0
movl $1, %edi # i+1

ciclo_i:
cmpl -4(%ebp), %esi # if (i >= lim)
jge fine_i # then "vai a fine_i"

movl (%ebx,%esi,4), %eax # EAX = vett[i]
cmpl %eax, (%ebx,%edi,4) # if (vett[i+1] >= vett[i])
jge prossimo # then "vai a prossimo"

pushl (%ebx,%esi,4) # salva vett[i]
pushl (%ebx,%edi,4) # salva vett[i+1]
popl %eax # EAX = vett[i+1]
movl %eax, (%ebx,%esi,4) # vett[i] = vett[i+1]
popl %eax # EAX = vett[i]
movl %eax, (%ebx,%edi,4) # vett[i+1] = vett[i]

movl %esi, %ecx # j = i
prossimo:
incl %esi # i++
incl %edi # (i+1)++
jmp ciclo_i

fine_i:
movl %ecx, -4(%ebp) # lim = j
jmp ciclo_lim

fine_lim:

#
#------ epilogo -------
#

popl %edi #
popl %esi # recupero dei registri
popl %ecx # salvati
popl %ebx #
popl %eax #

addl $4, %esp # ripulisce lo spazio
# d'ambiente

leave # ripristina EBP ed ESP
ret # ritorna al chiamante

#
#---- fine epilogo ----
#

mi spieghi come mai si sa ke l'offset di una certa variabile e 4 e un altro è -4! Sulla base di cosa?