Probleme umkehren einer Zeichenfolge in der Montage

Ich versuche das umkehren einer Zeichenfolge in der Montage.
Aber mein code scheint nicht korrekt zu funktionieren.
Ich habe eine newline-Schnur für bessere Lesbarkeit.

Ich bin mit linux und nasm als compiler.

Dachte ich, dass wenn ich nahm die Werte der adresspointers und schaltete Sie an der richtigen Stelle, der string würde schließlich Umgekehrt werden, und dann wieder normal.

Dies ist mein code:

section .data
    hello     db 'Hello world!'
    helloLen  equ $-hello
    derp db '=========',10
    derplen equ $-derp

section .text
    global main

main:
    mov eax,0
    mov ecx,helloLen

    reverse:
        ;move pointer
        mov ebx,hello
        add ebx,eax
        push eax

        ;move pointer
        mov eax,hello
        add eax,ecx
        push ecx

        ;switch bytes
        push ebx
        mov ebx,[ebx]
        mov [eax],ebx
        pop ebx
        mov eax,[eax]
        mov [ebx],eax

        ;print text
        mov eax,4
        mov ebx,1
        mov ecx,hello
        mov edx,helloLen
        int 80h

        ;Print newline
        mov eax,4
        mov ebx,1
        mov ecx,derp
        mov edx,derplen
        int 80h

        ;increment and decrement
        pop ecx
        dec ecx
        pop eax
        inc eax

        cmp eax,helloLen
    jne reverse

    end:
        mov eax,1
        mov ebx,0
        int 80h

Dies ist die Ausgabe die ich bekomme:

Hello world!Hell=====
Hello worldellol=====
Hello worlllo ol=====
Hello worlo w ol=====
Hello woo wow ol=====
Hello wooooow ol=====
Hello wooooow ol=====
Helloooooooow ol=====
Helloooooooow ol=====
Helooowooooow ol=====
Heoow wooooow ol=====
How o wooooow ol=====
  • Es gibt ein paar Dinge, die ich beachten rechts von der Fledermaus: 1) Wenn Sie die swap-Charaktere, sollten Sie das austauschen von bytes, nicht dwords. 2) ecx sollte helloLen-1. 3) Die Abbruchbedingung für den Algorithmus ist falsch; Sie werden am Ende tauschen jedes Zeichen zweimal. (Aufhören, wenn eax >= ecx)
InformationsquelleAutor Horse SMith | 2012-11-27
  1. 5

    Den Weg umkehren einer Zeichenfolge durch den Austausch von Zeichen ist, tauschen die erste und die Letzte, dann die zweite und vorletzte, usw.. In C, würden Sie schreiben:

    for (i = 0; i < len/2; ++i)
{
    c = s[i];
    s[i] = s[len-i-1];
    s[len-i-1] = c;
}

    In Assembler, ist der einfachste Weg zum einrichten der ESI und EDI Register-zu-Punkt am Anfang und Ende des Strings, dann Schleife. Bei jeder iteration, Sie erhöhen ESI-und Dekrement-EDI. Das Ergebnis sieht wie folgt aus:

    mov ecx, helloLen
mov eax, hello
mov esi, eax  ; esi points to start of string
add eax, ecx
mov edi, eax
dec edi       ; edi points to end of string
shr ecx, 1    ; ecx is count (length/2)
jz done       ; if string is 0 or 1 characters long, done
reverseLoop:
mov al, [esi] ; load characters
mov bl, [edi]
mov [esi], bl ; and swap
mov [edi], al
inc esi       ; adjust pointers
dec edi
dec ecx       ; and loop
jnz reverseLoop
    • Vielen Dank, das gelöscht Dinge für mich!
    • Woulkd diese Arbeit, wenn die Zeichenfolge len ist nicht divisble von beiden?
    • Ja. Denn wenn die Länge ist ungerade den mittleren Charakter nicht bewegen. Zum Beispiel, wenn die Länge 3 nur eine iteration der Schleife ausgeführt wird, vertauschen die Elemente 0 und 2. Das Element in der Mitte nicht bewegen.
    InformationsquelleAutor Jim Mischel
  2. 0

    Als ich diese für ein interview, ich kam mit dieser... Es ist ein bisschen Microsoft-spezifische, aber es ist ungefähr das gleiche wie das, was @Jim schrieb Mischel mit ein, außer dieser berechnet die Länge der Zeichenfolge, anstatt übergeben es etc.

    Diese Funktion ist nackt, so da es keinen prolog oder epilog, die Sie tun müssen vorsichtig sein, über welche Register Sie verwenden können. (Es sei denn, Sie push und pop, wenn Sie Sie verwenden. In diesem Beispiel bin ich nicht mit jedem Register, die bewahrt werden müssen)

    #define USE_STRLEN 0                                    ; Use strlen to find string length?

__declspec(naked) uint8_t* string_rev(uint8_t* s)
{
    __asm
    {
              mov    eax, dword ptr[esp + 4]            ; Get the address of string
              test   eax, eax                           ; Been passed a null pointer?
              jz     lp_3
#if (USE_STRLEN)
              push   eax                                ; Push string address onto stack
              call   strlen
              pop    ecx                                ; Pop our string back off the stack
              xchg   ecx, eax                           ; String length in eax
#else
              or     ecx, 0ffffffffh                    ; Start ecx at -1
        lp_1:
              inc    ecx
              test   byte ptr[eax + ecx], 0ffh          ; Test string byte for zero
              jnz    lp_1                               ; ecx = string length

#endif
              lea    edx, dword ptr[eax + ecx - 1]      ; edx = last character in string
              and    ecx, -2                            ; Is string 1 character or less?
              jz     lp_3
        lp_2:
              mov    cl, byte ptr[edx]
              mov    ch, byte ptr[eax]
              mov    byte ptr[eax], cl
              mov    byte ptr[edx], ch
              inc    eax
              dec    edx
              cmp    edx, eax                           ; Loop whilst one pointer is less
              ja     lp_2                               ; than the other (equiv. len/2)
        lp_3:
              ret                                       ; Reversed string in eax
    }
}
    InformationsquelleAutor The Welder
Schreibe einen Kommentar