Codice dell'assieme di ingegnere inverso al codice c

Question

Penso che questo sia in realtà un problema piuttosto semplice. Devo decodificare questo codice assembly in codice c. Fornirò anche ciò che penso stia succedendo, quindi puoi sperare di indicare dove ho sbagliato e ora posso imparare dai miei errori.

.LFBO 
    pushq %rbp 
    movq %rsp,%rbp 
    movl %edi,-4(%rbp) 
    movl %esi,-8(%rbp) 
    movl -4(%rbp),%eax 
    compl -8(%rbp),%eax 
    jg  .L2 
    movl -8(%rbp),%eax 
    jmp  .L3 
.L2: 
    movl -4(%rbp),%eax 
.L3: 
    popq %rbp 
    ret 

Quindi questo è quello che penso sta succedendo con questo: le prime due righe dopo .LFBO:

pushq %rbp 
movq %rsp,%rbp 

sono solo la creazione di stack per l'esecuzione che sta per seguire.

movl %edi,-4(%rbp) 

è afferrare la prima variabile, chiamano x

movl %esi,-8(%rbp) 

è afferrare la seconda variabile chiamano y

movl -4(%rbp),%eax 

è afferrare x da confrontare nella riga successiva

compl -8(%rbp),%eax 

confronto es le variabili xey calcolando xy

jg  .L2 

dice salto per .L2 se x> y

se x = y < poi calcolare le prossime righe senza saltare a .L2

movl -8(%rbp),%eax 

copia x = y

jmp  .L3 

salti al .L3

se x> y alla linea jg poi saltare a .L2: e completare questa linea

movl -4(%rbp),%eax 

questo è dove mi sono reso conto che ero davvero confuso. Sembra a me che si sta copiando x di x poi .L3 è completata e penso che x viene restituito

Answer 1

Non pensarci troppo. Sostituisci gradualmente l'assemblaggio con C. Ecco una possibile sequenza di trasformazioni.

.LFBO 
    pushq %rbp 
    movq %rsp,%rbp 
    movl %edi,-4(%rbp) 
    movl %esi,-8(%rbp) 
    movl -4(%rbp),%eax 
    compl -8(%rbp),%eax 
    jg  .L2 
    movl -8(%rbp),%eax 
    jmp  .L3 
.L2: 
    movl -4(%rbp),%eax 
.L3: 
    popq %rbp 
    ret 

---- 

int LFBO (int edi, int esi) 
{ 
    rbp = rsp 
    [rbp - 4] = edi 
    [rbp - 8] = esi 
    eax = [rbp - 4] 
    if (eax > [rbp - 8]) goto L2 
    eax = [rbp - 8] 
    goto L3 
L2: 
    eax = [rbp - 4] 
L3: 
    return eax 
} 

---- 

int LFBO (int edi, int esi) 
{ 
    rbp = rsp 
    [rbp - 4] = edi 
    [rbp - 8] = esi 
    eax = [rbp - 4] 
    if (eax <= [rbp - 8]) { 
     eax = [rbp - 8] 
    } 
    else { 
     eax = [rbp - 4] 
    } 
    return eax 
} 

---- 

int LFBO (int edi, int esi) 
{ 
    int eax; 

    eax = edi; 
    if (eax <= esi) { 
     eax = esi; 
    } 
    else { 
     eax = edi; 
    } 
    return eax; 
} 

---- 

int LFBO (int edi, int esi) 
{ 
    if (edi <= esi) { 
     return esi; 
    } 
    else { 
     return edi; 
    } 
} 

---- 

int LFBO (int x, int y) 
{ 
    if (x <= y) { 
     return y; 
    } 
    else { 
     return x; 
    } 
} 

---- 

int LFBO (int x, int y) 
{ 
    return (x > y) ? x : y; 
} 

È possibile applicare questa strategia a qualsiasi pezzo di assemblaggio. Qui ho preso il tempo per dettagliare le varie trasformazioni. Con la pratica puoi arrivare al risultato finale molto più velocemente.

Answer 2

LFB0(int x, int y){ 
    if (x<=y){ 
     x = y; 
    }else{ 
     x = x; 
    } 
    return(x); 
} 

Questo è quello che penso abbiamo ritenuto non corretta, con l'aiuto dei ragazzi della Commenti.

Answer 3

.LFBO 
    pushq %rbp    prolog 
    movq %rsp,%rbp   prolog 
    movl %edi,-4(%rbp)  [ebp-4] = edi 
    movl %esi,-8(%rbp)  [ebp-8] = esi 
    movl -4(%rbp),%eax  eax = [ebp-4] ie edi 
    compl -8(%rbp),%eax  cmp eax with [ebp-8] ie esi 
    jg  .L2     ;jg requires <= 
    movl -8(%rbp),%eax  so cutting the junk 
    jmp  .L3     this effectively becomes 
.L2: 
    movl -4(%rbp),%eax  (edi <= esi) ? { eax = esi } : { eax= edi} ; return; 
.L3: 
    popq %rbp    epilog 
    ret       epilog 

verificare l'ipotesi

lets compile the code in vc and test should compile unoptimized else 
clever compiler will cast away everything do 
/O1 push 10 pop eax retn; 
/O2 mov eax ,10 ret 

int main(void) { 
int edi=8,esi=10; 
if (edi <= esi) { return esi; } else { return edi;} 
} 

smontare il risultato

0:000> uf @eip 
image00400000+0x1000: 
00401000 55    push ebp 
00401001 8bec   mov  ebp,esp 
00401003 83ec08   sub  esp,8 
00401006 c745fc08000000 mov  dword ptr [ebp-4],8 
0040100d c745f80a000000 mov  dword ptr [ebp-8],0Ah 
00401014 8b45fc   mov  eax,dword ptr [ebp-4] 
00401017 3b45f8   cmp  eax,dword ptr [ebp-8] 
0040101a 7f07   jg  image00400000+0x1023 (00401023) 

image00400000+0x101c: 
0040101c 8b45f8   mov  eax,dword ptr [ebp-8] 
0040101f eb05   jmp  image00400000+0x1026 (00401026) 

image00400000+0x1023: 
00401023 8b45fc   mov  eax,dword ptr [ebp-4] 

image00400000+0x1026: 
00401026 8be5   mov  esp,ebp 
00401028 5d    pop  ebp 
00401029 c3    ret 
0:000>