Assembly Sprache x86 Irvine32

Question

Ich bin ziemlich neu in der Assemblersprache und ich versuche, dieses Programm herauszufinden. Ich will nur wissen, ob ich mit dem Programm auf dem Laufenden bin. Wie korrigiere ich dieses Programm?

Schreiben Sie eine Schleife, die die Summe aller Elemente im Array von Bytes berechnet. Drucken Sie das Ergebnis. Einige Hinweise: Laden Sie die Größe des Arrays in ein entsprechendes Register. Laden Sie den Offset des aktuellen Elements des Arrays und ändern Sie ihn bei jeder Iteration der Schleife entsprechend.

Hier ist, was ich bisher habe:

INCLUDE Irvine32.inc 

.data 
    val1 BYTE 1,2,3 
    counter = 0 
.code 

main PROC 

    mov ax, 0 

    mov ax, (LENGTHOF val1) 
    mov ax, OFFSET Counter 
    movzx ecx,ax 
L1: 
    add eax, val1[ecx] 
    inc eax 

loop L1 

    Call WriteDec 

exit 
END PROC 
    end main 

Answer 1

Sie in Ihrem Code mehrere Fehler haben: In der folgenden Sequenz, die Sie immer wieder ax gesetzt, die ziemlich nutzlos ist: Sie

mov ax, 0       ; you set ax to 0 
mov ax, (LENGTHOF val1)   ; you set ax to 3 
mov ax, OFFSET Counter    ; you set ax to an address (and try to use a 16-bit register for a 32-bit address 

Dann Fügen Sie diesen Offset einem anderen Offset in

hinzu

movzx ecx,ax 
L1: 
    add eax, val1[ecx]    ; add offset(val1)[offset(Counter)] to offset(Counter) 

Mit Sicherheit gibt dies einen Speicherfehler, weil die Adresse irgendwo sein kann. Dann erhöhen Sie diesen Offset mit

inc eax       ; you probably confused this with a counter/index register 

Und danach verwenden Sie diesen Offset in ECX, die Sie dort setzen von movzx ecx, ax als Index in ECX in der LOOP Anweisung

loop L1       ; decrements ECX and loops if ECX != 0 

---

Nach Wenn Sie alle diese Fehler beheben, könnte der Code wie folgt aussehen:

INCLUDE Irvine32.inc  
.data 
    val1 BYTE 1,2,3 
    counter = 0 
.code 
main:  
    xor eax, eax      ; 32-bit register for the sum 
    xor edx, edx      ; 32-bit register for the counter/index 
    mov ecx, LENGTHOF val1   ; number of entries in fixed size array in ECX as maximum limit 
L1: 
    movsx ebx, byte ptr val1[edx] ; extend BYTE at offset val1 + EDX to 32-bit 
    add eax, ebx      ; add extended BYTE value to accumulator 
    inc edx       ; increase index in EDX 
loop L1       ; decreases ECX and jumps if not zero 

    Call WriteDec     ; I assume this prints EAX 
    exit 
end main