4. strlen

strlen

  • P

    Hi!
    Kann mir jemand diese Version von strlen erklären:

    ;
; fast strlen()
;
; input:
;   eax = offset to string
;
; output:
;   ecx = length
;
; destroys:
;   ebx
;   eflags
;

        lea     ecx,[eax-1]
l1:     inc     ecx
        test    ecx,3
        jz      l2
        cmp     [byte ptr ecx],0
        jne     l1
        jmp     l6
l2:     mov     ebx,[ecx]       ; U
        add     ecx,4           ;   V
        test    bl,bl           ; U
        jz      l5              ;   V
        test    bh,bh           ; U
        jz      l4              ;   V
        test    ebx,0ff0000h    ; U
        jz      l3              ;   V
        test    ebx,0ff000000h  ; U
        jnz     l2              ;   V +1brt
        inc     ecx
l3:     inc     ecx
l4:     inc     ecx
l5:     sub     ecx,4
l6:     sub     ecx,eax

    lg, phreaking

    0
  • N

    Sieht mir wieder ziemlich nach einem auf "Geschwindigkeit" optimierten code aus (auch wenn ich das bei solch einem Anblick immer nicht ganz glauben mag 😃 )

    Die auskommentierten Zeilen beduerfen glaube ich keiner weiteren Erklaehrung...

    lea ecx,[eax-1] ;ecx=StringOffs - 1
    ;in der naechsten Zeile wird ecx+1 gerechnet, dann ist ecx wieder StringOffs.
    l1: inc ecx
    test ecx,3 ;teste, ob ecx durch 4 teilbar ist
    jz l2 ;wenn ja, nach l2 springen
    cmp [byte ptr ecx],0 ;teste, ob ecx auf ein 0-Byte zeigt (String wird mit 0 terminiert)
    jne l1 ;wenn nicht, springe zu l1
    ;Diese Schleife hier laeuft nun so lange, bis ecx durch 4 teilbar ist,
    ;oder auf ein 0-Byte zeigt
    jmp l6 ;ecx zeigt auf ein 0-Byte => Nach l6 springen

    ;hierher wird gesprungen, wenn ecx (Offset des Strings + x) durch 4 teilbar ist.
    l2: mov ebx,[ecx] ; U <- ist vermutlich klar...
    add ecx,4 ; V <- das wohl auch...
    test bl,bl ; U <- teste, ob direkt bei ecx ein 0-Byte stand
    jz l5 ; V <- ja=> zu l5
    test bh,bh ; U <- teste, ob bei ecx + 1 ein 0-Byte stand
    jz l4 ; V <- ja=> zu l4
    test ebx,0ff0000h ; U <- teste, ob bei ecx + 2 ein 0-Byte stand
    jz l3 ; V <- ja=> zu l3
    test ebx,0ff000000h ; U <- teste, ob bei ecx + 3 ein 0-Byte stand
    jnz l2 ; V +1brt <- nein=> zurueck zu l2 und naechste 4 Byte laden
    ;im ganezn Block hier unter diesem Text, wird eigentlich nur folgendes gerechnet:
    ;ecx + 0Byte-Position - 4
    ;Es wurde schliesslich 4 zuvor ecx addiert, die muessen jetzt wieder abgezogen werden...
    inc ecx ;wenn das 0-Byte bei ecx+3 lag, muss 3 zu ecx addiert werden (3 incs ausfuehren)
    l3: inc ecx ;wenn das 0-Byte bei ecx+2 lag, muss 2 zu ecx addiert werden (2 incs... )
    l4: inc ecx ;... s.o.
    l5: sub ecx,4 ;die 4 wieder abziehen
    l6: sub ecx,eax ;das Offset des Strings abziehen...
    ;was bleibt, ist die Laenge des Strings...

    Und nochmal ganz simpel zusammengefasst:
    Dieses Ding kopiert das in eax uebergebene Offset eines Strings nach ecx und inkrementiert ecx so lange, bis es auf ein 0-Byte zeigt.
    Anschliessend wird das Offset des Strings wieder von ecx abgezogen.

    [ Dieser Beitrag wurde am 23.08.2002 um 15:37 Uhr von Nobuo T editiert. ]

    0
  • P

    Wow, danke, jetzt kapiere ich das.

    lg, phreaking

    0
Anmelden zum Antworten