Wie mache ich Schleifen in Assembler?

Schleifen nennt man die Methode, ein Stück Code zu wiederholen. Wenn das Stück Code immer wieder ohne Abbruchbedingung wiederholt wird, spricht man von einer Endlosschleife, was meistens (aber nicht immer) gleichbedeutend mit einem Programmierfehler ist.

Man unterscheidet drei Arten von Schleifen:

• Zählschleife,
• Repeat-Schleife,
• While-Schleife.

Eine Zählschleife wiederholt einen Block eine gewisse Anzahl.

    mov ecx, 5
  .Schleife:                    ; 5 Wiederholungen
    ; Anweisungen
    loop .Schleife

Bei einer Repeat-Schleife wird die Abbruchbedingung am Ende der Schleife geprüft. Der Schleifenkörper wird also mindestens einmal durchlaufen.

    xor ecx, ecx
  .Schleife:                   ; repeat ... until (ecx == 5)
    ; Anweisungen
    inc ecx
    cmp ecx, 5
    jne .Schleife

Bei einer While-Schleife wird die Abbruchbedingung am Anfang der Schleife geprüft.

    xor ecx, ecx
  .Schleife:                    ; while (ecx != 5)
    cmp ecx, 5
    je .Break
    ; Anweisungen
    inc ecx
    jmp .Schleife
  .Break:

Ein Sonderfall der While-Schleife ist die Foreach-Schleife: Die Abbruchbedingung ist das Ende einer Struktur (String, Array, Objekte), deren Größe nicht bekannt ist. Das Ende der Struktur muss natürlich irgendwie erkennbar sein, ein C-String z. B. endet mit einem Nullbyte.

  ; Foreach-Schleife für jeden Buchstaben in einem C-String
  .Schleife:
    lodsb
    or al, al
    je .Break
    ; Anweisungen
    jmp .Schleife
  .Break:

Ein Break ist eine zusätzliche Abbruchbedingung:

  ; Zählschleife mit Break
    mov ecx, 5
  .Schleife:
    cmp ecx, 3
    je .Break
    ; Anweisungen
    loop .Schleife
  .Break:

Ein Continue ist die Anweisung für einen neuen Schleifendurchlauf, wobei der restliche Schleifenkörper ignoriert wird:

  ; Zählschleife mit Continue
    mov ecx, 5
  .Schleife:
    cmp ecx, 2
    je .Continue
    ; Anweisungen
  .Continue:
    loop .Schleife

Von einer verschachtelten Schleife spricht man, wenn sich eine Schleife innerhalb einer anderen Schleife befindet. In Pseudo-Hochsprachen-Code ausgedrückt:

Beispiel einer verschachtelten Schleife:

FOR I=1 TO 10
  FOR J=2 TO 20
  NEXT J
NEXT I

In Assembler ist die Gefahr groß, dass man beim Aufbau einer solchen Schleife den Überblick verliert. Es empfiehlt sich, die Schleife Stück für Stück herzustellen und bei jedem Schritt zu prüfen, ob sie noch funktioniert:

1. Schritt: Die äußere Schleife herstellen.

    mov ecx, 10
    I:
    loop I

2. Schritt: Die innere Schleife herstellen.

    mov ecx, 20
    J:
    loop J

3. Schritt: Schleifen verschachteln (Copy&Paste).

    mov ecx, 10
    I:
    mov ecx, 20
    J:
    loop J
    loop I

4. Schritt: Erkennen, dass beide Schleifen sich mit ihrem Zugriff auf ECX in die Quere kommen.
5. Schritt: ECX vor der jeweils anderen Schleife in Sicherheit bringen.

    mov ecx, 10
    I:
    push ecx

    mov ecx, 20
    J:
    push ecx

    pop ecx
    loop J

    pop ecx
    loop I

Ralph 'rkhb' Bauer Aug 2008 / Feb 2009