Advertisement
Guest User

Untitled

a guest
Jan 20th, 2020
106
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. SECTION .data  ; /* contains initialized data */
  2.  
  3. SECTION .bss   ; /* contains uninitialized data */
  4.  
  5. SECTION .text  ; /* contains code
  6.  
  7. GLOBAL _start  ;
  8.  
  9. _start:                 ; void main(void){
  10.     nop                 ; /* do not remove the "nop" */
  11.     push DWORD 11       ; return(funA(11));
  12.     call funA           ; }
  13.  
  14.    
  15.                         ; return 0;
  16. end:mov ebx, eax        ; /* the exit system call
  17.     mov eax, 1          ;    no errorcode
  18.     int 80h             ;    execute system call */
  19.                         ; }
  20.  
  21. funA:                   ; int funA(int a) { /* a in [ebp+8] */
  22.     push ebp            ; /* Retten und Neueinstellen ebp */
  23.     mov ebp, esp        ;
  24.     mov eax, [ebp+8]    ;
  25.     push edx            ; /* Register sicher */
  26.     push ecx            ;
  27.     cmp eax, 0          ; if (a > 0...
  28.     jle returnA         ;
  29.     mov edx, 0          ; /* Division vorbereiten */
  30.     mov ecx, 2          ;
  31.     idiv ecx            ;
  32.     cmp edx, 0          ; && a % 2 == 0){
  33.     jne elseIfA         ;
  34.     mov eax, [ebp+8]    ;
  35.     mov ecx, 3          ;
  36.     imul ecx            ; return (a + funA(3*a+1));
  37.     add eax, 1          ;
  38.     push eax            ;
  39.     call funA           ;
  40.     add eax, [ebp+8]    ; /* Ergebnis im eax */
  41.     pop ecx             ; /* Register rueckstellen */
  42.     pop edx             ;
  43.     pop ebp             ; /* Basiszeiger rueckstellen */
  44.     ret 4               ; /* Parameter freigeben */
  45. elseIfA:                ; } else if (a > 0) {
  46.     mov eax, [ebp+8]    ; /* Bedingung bereits ueberprueft */
  47.     shr eax, 1          ; return (a + funB(a / 2));
  48.     push eax            ; }
  49.     call funB           ;
  50.     add eax, [ebp+8]    ;
  51.     pop ecx             ; /* Register rueckstellen */
  52.     pop edx             ;
  53.     pop ebp             ; /* Basiszeiger rueckstellen */
  54.     ret 4               ; /* Parameter freigeben */
  55. returnA:                ; return (a);
  56.     mov eax, [ebp+8]    ;
  57.     pop ecx             ; /* Register rueckstellen */
  58.     pop edx             ;
  59.     pop ebp             ; /* Basiszeiger rueckstellen */
  60.     ret 4               ; /* Parameter freigeben */
  61.  
  62. funB:                   ; int funB(int a) { /* a in [ebp+8] */
  63.     push ebp            ; /* Retten und Neueinstellen ebp */
  64.     mov ebp, esp        ;
  65.     mov eax, [ebp+8]    ;
  66.     push edx            ; /* Register sicher */
  67.     push ecx            ;
  68.     cmp eax, 0          ; if (a > 0...
  69.     jle returnB         ;
  70.     mov edx, 0          ; /* Division vorbereiten */
  71.     mov ecx, 2          ;
  72.     idiv ecx            ;
  73.     cmp edx, 0          ; && a % 2 != 0){
  74.     je elseIfB          ;
  75.     mov eax, [ebp+8]    ;
  76.     mov ecx, 3          ;
  77.     imul ecx            ; return (a + funB(3*a+1));
  78.     add eax, 1          ;
  79.     push eax            ;
  80.     call funB           ;
  81.     add eax, [ebp+8]    ; /* Ergebnis im eax */
  82.     pop ecx             ; /* Register rueckstellen */
  83.     pop edx             ;
  84.     pop ebp             ; /* Basiszeiger rueckstellen */
  85.     ret 4               ; /* Parameter freigeben */
  86. elseIfB:                ; } else if (a > 0) {
  87.     mov eax, [ebp+8]    ; /* Bedingung bereits ueberprueft */
  88.     shr eax, 1          ; return (a + funA(a / 2));
  89.     push eax            ; }
  90.     call funA           ;
  91.     add eax, [ebp+8]    ;
  92.     pop ecx             ; /* Register rueckstellen */
  93.     pop edx             ;
  94.     pop ebp             ; /* Basiszeiger rueckstellen */
  95.     ret 4               ; /* Parameter freigeben */
  96. returnB:                ; return (a);
  97.     mov eax, [ebp+8]    ;
  98.     pop ecx             ; /* Register rueckstellen */
  99.     pop edx             ;
  100.     pop ebp             ; /* Basiszeiger rueckstellen */
  101.     ret 4               ; /* Parameter freigeben */
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement