Confusione dello "stack" nella programmazione a livello di assembly [closed]

In genere, lo stack è un'area di memoria.

È possibile aggiungere dati allo stack ("push"), o recuperarlo e portarlo fuori dallo stack ("pop"). L'ultimo dato aggiunto allo stack è il primo ad essere recuperato.

PUSH 1
PUSH 2
PUSH 3
POP -> Result 3
PUSH 4
POP -> Result 4
POP -> Result 2
POP -> Result 1

The processor pushes bits through registers on to the stack in RAM, or do I have it wrong here?

I processori hanno spesso istruzioni per copiare i dati dai registri allo stack e viceversa.

Nell'assembly x86 (32 bit):

MOV EAX, 20
PUSH EAX ; Adds 20 to the stack (32 bits, many of which are zero)
POP EBX ; EBX will have the value 20, and the stack will be restored to its former state

Tuttavia, nella maggior parte delle architetture (tutte?), è possibile ottenere dati dallo stack senza in realtà scoppiarlo.

In x86 (32 bit)

MOV EAX, [ESP+20] ; Will copy to EAX the contents of the stack 20 bytes before its current state

The "stack" is a region in RAM? Or is it some other space I'm uncertain of here?

Puoi pensare in questo modo.

Nelle architetture moderne, c'è qualcosa chiamata memoria virtuale che sarà frequentemente, ma non sempre, mappata alla memoria fisica (RAM). A volte, quando la memoria fisica si esaurisce, questa memoria verrà archiviata sul disco.

La memoria virtuale è la posizione in cui viene solitamente posizionata la pila.

Tuttavia, lo stack sarà anche utilizzato frequentemente, quindi sarà spesso anche nella cache del processore.

Fortunatamente, tutto ciò è stato sottratto. Per quanto riguarda un programma in esecuzione nella macchina, lo stack è nella RAM. Il sistema operativo in genere si occupa dei dettagli brutti.

È un'area riservata della RAM a cui si accede da un offset da un puntatore dello stack. Ad esempio, considera una pila composta da 5 parole:

5 garbage
4 garbage
3 garbage
2 garbage
1 garbage

Prima che una funzione venga chiamata ha un pointer stack (SP) uguale a 6. L'istruzione call della funzione pone l'indirizzo di ritorno sullo stack e decrementa il puntatore dello stack, quindi ora assomiglia a:

5 return address <-------- SP
4 garbage
3 garbage
2 garbage
1 garbage

Se vuoi allocare un intero nello stack, decrementa il puntatore dello stack:

5 return address
4 local integer  <-------- SP
3 garbage
2 garbage
1 garbage

Ora, quando la mia funzione deve accedere al mio intero locale, usa l'indirizzo di memoria di SP + 0. Se chiamo un'altra funzione, decrementa nuovamente l'SP e posso allocare di nuovo un po 'di spazio, come:

5 return address
4 local integer
3 return address for second function
2 local integer for second function
1 another local integer for second function   <-------- SP

Ora, se uso l'indirizzo di memoria SP+0 , si riferisce al numero intero locale della seconda funzione. Tieni presente che ora ho esaurito lo spazio di stack, quindi eventuali altre operazioni genereranno un overflow dello stack.

Quando torno, lo faccio solo al contrario, aggiungo all'SP per deallocare la memoria, quindi l'istruzione return legge l'indirizzo di ritorno dallo stack.

Si noti che le pile di diverse architetture funzionano in modo leggermente diverso. Su alcuni SP viene decrementato prima di premere l'indirizzo di ritorno e alcuni dopo. Alcuni salvano automaticamente i registri nello stack oltre al solo indirizzo di ritorno, specialmente durante un'interruzione. Su un PIC, per un altro esempio, lo stack è una memoria completamente isolata che contiene solo gli indirizzi di ritorno e non può essere utilizzato per le variabili. Ciò che è comune è l'allocazione della memoria LIFO.

Non indichi a quale processore è destinato il tuo assembly, tuttavia la comprensione di base non cambierà poiché tutti fanno la stessa cosa.

Praticamente tutti i computer hanno una piccola serie di codici macchina che forniscono supporto per le operazioni di base dello stack. Questi sono PUSH e POP e un registro puntatore stack (lo chiamerò SP) - che punta a una posizione in memoria. Se supportato, le chiamate di procedura (CALL) e restituisce (RET) utilizzano uno stack premendo e popando l'indirizzo di ritorno. Gli interrupt hardware utilizzano uno stack per il salvataggio dell'indirizzo di ritorno e dei registri. A seconda della macchina, potrebbero esserci più di un puntatore allo stack (ad esempio uno per gli interrupt Hardware, uno per il flusso del programma e uno per i dati).

Il concetto di "Stack" è supportato dalle istruzioni del processore, ma è davvero qualcosa di cui il processore sa poco. SP punta a un indirizzo, PUSH memorizza e aggiorna SP, POP aggiorna SP e recupera dall'indirizzo. Come programmatori, trasformiamo queste semplici istruzioni in una "pila". Clever Assembly può fare uso di queste istruzioni per altri compiti (a rischio per gli sviluppatori).

La maggior parte dei processori ha altre istruzioni per gestire lo stack e manipolare il puntatore dello stack.

Lo stack funziona impostando per prima cosa SP in modo che punti ad una posizione di memoria RAM. PUSH Diminuisce SP (in base alla dimensione dell'articolo) e quindi copia l'elemento nella posizione SP. POP Copia l'elemento dal punto di posizionamento a SP, quindi aumenta l'SP in base alla dimensione dell'elemento. Nota: in genere le pile crescono dagli indirizzi di memoria più alti fino agli indirizzi di memoria più bassi. Non c'è una ragione particolare per questo al di là delle scelte storiche: lo stack si trova nelle posizioni di memoria superiore e il programma nelle posizioni più basse. Nei primi tempi, si era esaurito la memoria quando lo stack e la memoria del programma si sono scontrati, tuttavia, ha reso più facile la gestione della memoria. Questo accade ancora su piccoli microcomputer. Su un'architettura più complessa, esiste un sistema di gestione della memoria che impedisce che ciò accada

A seconda della macchina in uso, le istruzioni PUSH e POP possono spostare registri, posizioni di memoria ecc. di varie dimensioni tra la pila. Molti processori hanno altri registri che consentono il rilevamento di stack overflow / underflow, l'uso di stack multipli ecc.