Advertisement
Guest User

Untitled

a guest
Jan 23rd, 2020
130
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1.                                 ; typdef struct T_impls {
  2. NEXT    EQU     0               ;   struct T_impl *next;
  3. VALUE   EQU     4               ;   int value;
  4.                                 ; } T;
  5. SECTION .data                   ; /* contains initialized data */
  6.  
  7. SECTION .bss                    ; /* contains uninitialized data */
  8. ts  RESD    8                   ; T ts[4]; /* 4 Mal 2 DWORD Speicherplatz */
  9. m   RESD    1                   ; int m;
  10. SECTION .text                   ; /* contains code
  11.  
  12. GLOBAL _start                   ;
  13.  
  14. _start:                         ; void main(void){
  15.     nop                         ; /* do not remove the "nop" */
  16.     mov ebx, ts                 ; /* Fusspunkt von ts nach ebx */
  17.     mov eax, 12     ;
  18.     mov [ebx+0*8+VALUE], eax    ; ts[0].value = 12;
  19.     mov eax, ts+2*8             ;
  20.     mov [ebx+0*8+NEXT], eax     ; ts[0].next = &ts[2];
  21.     mov eax, -1                 ;
  22.     mov [ebx+1*8+VALUE], eax    ; ts[1].value = -1;
  23.     mov eax, ts+0*8             ;
  24.     mov [ebx+1*8+NEXT], eax     ; ts[1].next = &ts[0];
  25.     mov eax, 11                 ;
  26.     mov [ebx+2*8+VALUE], eax    ; ts[2].value = 11;
  27.     mov eax, ts+3*8             ;
  28.     mov [ebx+2*8+NEXT], eax     ; ts[2].next = &ts[3];
  29.     mov eax, 17                 ;
  30.     mov [ebx+3*8+VALUE], eax    ; ts[3].value = 17;
  31.     mov eax, ts+1*8             ;
  32.     mov [ebx+3*8+NEXT], eax     ; ts[3].next = &ts[1]
  33.  
  34.     push DWORD ts+2*8           ;
  35.     call findMax                ;
  36.     mov [m], eax                ; m = findMax(&ts[2]);
  37.     push DWORD ts+1*8           ;
  38.     call findMax                ;
  39.     add [m], eax                ; m += findMax(&ts[1]);
  40.     push DWORD ts+3*8           ;
  41.     call findMax                ;
  42.     add [m], eax                ; m += findMax(&ts[3]);
  43.     push DWORD ts+0*8           ;
  44.     call findMax                ;
  45.     add [m], eax                ; m += findMax(&ts[0]);
  46.     mov ebx, eax                ; return m;
  47.                                 ; }
  48.        
  49. end:mov eax, 1                  ; /* the exit system call
  50.                                 ;    no errorcode
  51.     int 80h                     ;    execute system call */
  52.                                 ; }
  53. findMax:                        ; int findMax(T *b) { /* *b in [ebp+8] */
  54.     push ebp                    ; /* ebp sichern und neueinstellen */
  55.     mov ebp, esp                    ;
  56.     sub esp, 4                  ; /* Speicherplatz für lokale Variablen */
  57.                                 ; /* *iter in [ebp-4] */
  58.                                 ; /* ret in eax */
  59.     push ebx                    ; /* Register sichern */
  60.     push esi                    ;
  61.     push ecx                    ;
  62.     mov ecx, [ebp+8]            ; /* *iter in ecx */
  63.     mov [ebp-4], ecx            ; T *iter = b;
  64.     mov eax, [ecx+VALUE]        ; int ret = b->value;
  65. do:                             ; do {
  66.     mov ecx, [ecx+NEXT]         ;       iter = iter->next;
  67.     mov ebx, [ecx+VALUE]        ;
  68.     cmp ebx, eax                ; if (iter->value > ret) {
  69.     jle ife                     ;
  70.     mov eax, ebx                ; ret = iter->value;
  71. ife:                            ;
  72.     cmp ecx, [ebp+8]            ;
  73.     jne do                      ; while (iter != b);
  74.     mov [ebp-4], ecx            ; /* iter zurueckschreiben */
  75.  
  76.     pop ecx                     ; /* Register rueckstellen */
  77.     pop esi                     ;
  78.     pop ebx                     ;
  79.     add esp, 4                  ; /* lokale Variable freigeben */
  80.     pop ebp                     ; /* ebp rueckstellen */
  81.     ret 4                       ; /* Parameter freigeben */
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement