Reverse-Ingenieur-Assembly-Code zu c-Code

Question

Ich denke, das ist eigentlich ein ziemlich einfaches Problem. Ich muss diesen Assembler-Code zu c-Code zurückentwickeln. Ich gebe auch, was ich denke, so dass Sie hoffentlich zeigen können, wo ich falsch gelaufen bin und ich kann jetzt aus meinen Fehlern lernen.

.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 

So ist es das, was ich denke, ist mit diesem los: die ersten beiden Zeilen nach .LFBO:

pushq %rbp 
movq %rsp,%rbp 

einrichten nur den Stapel für die Ausführung, der folgen ist, über.

movl %edi,-4(%rbp) 

wird die erste Variable erregenden, rufen sie x

movl %esi,-8(%rbp) 

wird die zweite variable erregenden nennen y

movl -4(%rbp),%eax 

x ist, greifen in der nächsten Zeile verglichen werden

compl -8(%rbp),%eax 

vergleichen es die Variablen x und y durch xy Rechen

jg  .L2 

sagen Sprung zu .L2 wenn x> y

wenn x = y < dann die nächsten Zeilen berechnen, ohne zu springen .L2

movl -8(%rbp),%eax 

Kopie x = y

jmp  .L3 

Sprung zu .L3

wenn x> y an der jg Linie dann Sie .L2 springen: und füllen Sie diese Zeile

movl -4(%rbp),%eax 

das ist, wo ich merkte, daß ich wirklich verwirrt. Es scheint mir, dass Sie x sind das Kopieren x dann .L3 abgeschlossen ist und ich denke, x

zurückgegeben

Answer 1

Nicht überdenken. Ersetzen Sie die Baugruppe nach und nach durch C. Dies ist eine mögliche Abfolge von Transformationen.

.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; 
} 

Sie können diese Strategie auf jedes Montageelement anwenden. Hier nahm ich mir die Zeit, um die verschiedenen Transformationen zu beschreiben. Mit etwas Übung können Sie schneller zum Endergebnis kommen.

Answer 2

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

Dies ist, was ich denke, dass wir in dem richtigen, mit Hilfe der Jungs zu sein, bestimmt Bemerkungen.

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 

Testen der Hypothese

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;} 
} 

Auseinandernehmen des Ergebnisses

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>