assembly e stack

[is-katsura]

Ciao a tutti!
Per interesse personale sto studiando il funzionamento dello stack su un processore AMD; sto seguendo il libro "Self Service Linux", che tratta approfonditamente l'argomento, e come guida per l'assembly seguo "Il linguaggio PC Assembly" di Paul A. Carter (bel libro free tradotto in italiano per chi non lo conoscesse!).
Credo di aver capito bene il funzionamento di base, con il prologo e l'epilogo degli stack frame, e l'utilizzo dei registri BP, SP e IP; pero' disassemblando con GDB il codice di una semplicissimo main non mi tornano delle cose. Questo e' il sorgente in C:

Codice:

void function(int a, int b, int c) {
   char buffer1[5];
   char buffer2[10];
}

void main() {
  function(1,2,3);
}

E questo e' il disassemblato in assembly del main (ho numerato le righe per riferirmi, sotto, ai numeri di riga):

Codice:

Dump of assembler code for function main:
1   0x0804834c <main+0>: lea    0x4(%esp),%ecx
2   0x08048350 <main+4>: and    $0xfffffff0,%esp
3   0x08048353 <main+7>: pushl  -0x4(%ecx)
4   0x08048356 <main+10>: push   %ebp
5   0x08048357 <main+11>: mov    %esp,%ebp
6   0x08048359 <main+13>: push   %ecx
7   0x0804835a <main+14>: sub    $0xc,%esp
8   0x0804835d <main+17>: movl   $0x3,0x8(%esp)
9   0x08048365 <main+25>: movl   $0x2,0x4(%esp)
10  0x0804836d <main+33>: movl   $0x1,(%esp)
11  0x08048374 <main+40>: call   0x8048344 <function>
12  0x08048379 <main+45>: add    $0xc,%esp
13  0x0804837c <main+48>: pop    %ecx
14  0x0804837d <main+49>: pop    %ebp
15  0x0804837e <main+50>: lea    -0x4(%ecx),%esp
16  0x08048381 <main+53>: ret   
End of assembler dump.

Le righe 1, 2 e 3 proprio non le capisco, anche conoscendo le tre le istruzioni li' utilizzate; in "Self Service Linux" le prime istruzioni del main o di una funzione sono sempre il prologo, che invece e' alle righe 4 e 5, quindi immagino che mi sia sfuggito qualcosa. Forse gli esempi che ho visto sono semplificati? O forse da AMD a Intel (archittetura di riferimento su SELf S L) puo' cambiare molto, anche per sorgenti semplici come quello che ho postato?
Non ho mai visto dei MOV come quelli alle righe 8,9 e 10, con due valori per ogni MOV separati da una virgola: come modificano SP?
Scusatemi le domande probabilmente stupide, sono alle prime armi con l'assembly e sono rimasto un po' sorpreso nel vedere la differenza tra un assembly studiato sui libri e quello che effettivamente restituisce un debugger.
Grazie a chi ha letto fino a qui!
Luca

PS: conoscete bei link o libri che parlano dello stack? Avere piu' materiale mi farebbe piacere, con google ho trovato parecchie cose, ma molto basilati

[tindal]

ehm.. non so se da queste parti c'è qualcuno esperto di assembly (io no), magari puoi trovare qualche aiuto in più su irc: se fai un giro su irc.azzurra.net è probabile che qualche canale di appassionati lo trovi

a me comunque vengono in mente 2 suggerimenti molto generali:

1- non è che per caso includi qualche header in quel sorgente?

2- anche se sei su amd, dovresti poter compilare il codice per qualunque variante di processore intel, che sarebbe utile per verificare le tue ipotesi

ciao
tindal

[is-katsura]

Ti ringrazio per il consiglio! mi sono buttato subito su irc, purtroppo per ora senza successo ma non mollo!
Sono sicuro di non includere header, il codice C e' quello che ho postato, ne piu' ne meno.
Comunque adesso provo a compilare i sorgenti assembly di esempio che ho trovato sul Self Service Linux, vediamo cosa combino.
Luca

[galileo75]

Personalmente ti posso segnalare "Programming from the ground up", lo trovi free su savannah, cerca pure con Google.
In aggiunta dovresti scaricarti i manuali AMD (io ho scaricato quelli Intel ma immagino che da qualche parte sul sito di AMD ci siano anche per AMD). ...buona lettura...


Queste istruzioni non modificano lo stack pointer:
8   0x0804835d <main+17>:   movl   $0x3,0x8(%esp)
9   0x08048365 <main+25>:   movl   $0x2,0x4(%esp)
10  0x0804836d <main+33>:   movl   $0x1,(%esp)

ma spostano dei valori 1,2 e 3 (nota l'ordine in cui vengono messi nello stack pointer) nelle posizioni +8, +4 e  0 (lo stack parte dall'alto e si muove verso il basso) partendo da dove punta %esp (di 4 byte alla volta dato che sei su una architettura a 32 bit).

ret

3

2

1   <- %esp

il puntamento di %esp e' stato spostato prima con questa istruzione:
sub    $0xc,%esp in modo da riservarti spazio

cioe' di 12 posizioni, 3 per i valori e un intero per l'indirizzo di ritorno (se non erro dato che hai messo void non c'e' valore che restituisce la funzione).

quello che succede dopo sono le solite cose...ripristino del base pointer e dello stack pointer.


Non so esattamente perche' esegue le prime istruzioni ma devi sapere che in un programma in C, ci sono alcune funzioni che sono nascoste e che vengono chiamate quando si esegue un programma. Queste funzioni vengono aggiunte dal gcc e in qualche modo si possono eliminare (ci sono degli articoli in rete). Sono le famose funzioni di quando metti le keyword in C di __init e __fin (qualcosa del genere, fai riferimento al gapil o usa objdump/readelf). Per cui il ret che ti trovi alla fine del main, non e' affatto (e spero di non sbagliarmi) l'istruzioni di exit dal programma che avviene con un int 0x80 (dopo aver impostato alcuni registry). Quindi un programma non inizia dal main una volta compilato.

Questo secondo me spiegherebbe parzialmente perche' salva e ripristina 0x4(%esp) in %ecx:

1   0x0804834c <main+0>:   lea    0x4(%esp),%ecx
...
lea    -0x4(%ecx),%esp

per quanto riguarda questo and:

2   0x08048350 <main+4>:   and    $0xfffffff0,%esp

no idea  potrebbe essere una specie di allineamento? E poi il tutto viene ripristinato come prima.
Sembrerebbe funzionare. Una specie di finestra nello stack.

Spero di non aver detto troppe idiozie.

ciao

[galileo75]

Non so se questo thread e' ancora seguito.

Comunque a chi interessa ho trovato questo articolo.

http://linuxgazette.net/issue84/hawk.html

Secondo me e' ben fatto.

ciao

[is-katsura]

In questo periodo sono poco nel forum ma il thread mi interessa e, anche se un po' in ritardo, ti ringrazio molto per la segnalazione!
Luca

[marbel]

[OT]:
ma lo sapete che un tizio (non ricordo chi è) ha scritto un sistema operativo tutto in assembly? Intendo oggi, non 20 anni fa, con tanto di ambiente desktop e il tutto perfettamente funzionante. il sistema operativo si chiama menuetOs, ed è stata fatta anche una versione a 64 bit che si chiama kolibriOs.
questo sì che vuol dire programmare!
[fine OT].

[galileo75]

G U L P ! 

Questo si che vuol dire essere geek!

[More+]

[OT]:
ma lo sapete che un tizio (non ricordo chi è) ha scritto un sistema operativo tutto in assembly? Intendo oggi, non 20 anni fa, con tanto di ambiente desktop e il tutto perfettamente funzionante. il sistema operativo si chiama menuetOs, ed è stata fatta anche una versione a 64 bit che si chiama kolibriOs.
questo sì che vuol dire programmare!
[fine OT].

No, non posso e voglio crederci che ha scritto tutto in assembly
ottenere questo :
http://www.menuetos.net/screens.htm
è impossibile!
Già con il C senza alcuna libreria grafica è assai impegnativo creare una gestione a finestre, in assembly bisogna centuplicare le righe da scrivere!

Dato che non sono rilasciati i sorgenti ...permettetemi il sospetto  che buona parte del codice sia stato tradotto in assembly


@marbel
grazie per la bella chicca OT!

[marbel]

No, non posso e voglio crederci che ha scritto tutto in assembly
ottenere questo :
http://www.menuetos.net/screens.htm
è impossibile!

ho letto la notizia in una rivista, che però non è mia e non posso verificare se ho letto bene. in quella rivista si affermava che sia menuetos che kolibrios sono scritti in assembly e, proprio per questo si lodava la grandissima velocità di esecuzione e l'impegno irrisorio delle risorse hardware.

[More+]

http://it.wikipedia.org/wiki/MenuetOS
che sia in assembly posso accettarlo
ma che sia scritto da zero in puro assembly senza tradurre codici da un linguaggio ad alto livello
...è semplicemente DISUMANO!