Laten we nogmaals ons programmaatje bekijken, om twee getallen van elkaar af te trekken en afhankelijk van de uitkomst een 0 of een 1 in B te zetten. Nu op de 8086 en dus worden de registers iets anders. En dit keer maken we meteen gebruik van eigen data-segmenten:

MOV AL, [DS:DX]         ; Laad het eerste getal in AL
INC DX                  ; Verhoog DX
SUB AL, [DS:DX]         ; Trek het tweede getal af van het eerste
JZ ZERO                 ; Als resultaat 0 is, spring naar ZERO
MOV BX, 1               ; Anders, zet 1 in BX
JMP END                 ; Spring naar einde

ZERO:
MOV BX, 0               ; Zet 0 in BX

END:
HLT                     ; Stop het programma

Het verschil met de 8080-code en met de Z80 is minimaal. Alleen de adressering is iets anders. We hadden in plaats van AL ook van AX gebruik kunnen maken, maar ik ben uitgegaan van twee 8-bits getallen, dus hadden we maar de helft van AX nodig.

Overigens is het ook mogelijk wat meer gebruik te maken van de extra mogelijkheden van de 8086. Deze code geeft hetzelfde resultaat, maar doet dat wat eleganter:

; DS:DX wijst naar het geheugenadres van de twee getallen
; Geheugen:
; [DS:DX]   = eerste getal
; [DS:DX+1] = tweede getal
; BX wordt gebruikt om 0 of 1 op te slaan

LES DI, [DS:DX]         ; Laad DS:DX in ES:DI, zodat DI direct naar [DS:DX] wijst
MOV AL, [DI]            ; Laad het eerste getal in AL
MOV BL, [DI+1]          ; Laad het tweede getal in BL
SUB AL, BL              ; Trek het tweede getal af van het eerste
SETZ BYTE PTR [RESULT]  ; Zet resultaat (0 of 1) in tijdelijk geheugen op basis van Zero Flag
MOVZX BX, BYTE PTR [RESULT] ; Zet de 8-bit waarde van RESULT in BX

HLT                     ; Stop het programma

RESULT DB 0                 ; Tijdelijk opslaggebied voor resultaat

We maken nu gebruik van de indexeringsmogelijkheden die het DI register biedt, van de mogelijkheid om een bit rechtstreeks in het geheugen voorwaardelijk te manipuleren met SETZ en van de mogelijkheid om een woordbreedte van minder dan 16 bits direct in een 16-bitsregister te laden waarbij de overgebleven ruimte op nul wordt gezet middels MOVZX.

Hiermee wordt al duidelijk dat de 8086 een typisch voorbeeld van CISC-architectuur is: Complex Instruction Set Computing. De 8086 heeft voor allerlei zaken die je zou willen regelen specifieke instructies. Dat programmeert prettig, maar het resultaat is relatief langzaam en energieslurpend. Het alternatief, RISC, of Reduced Instruction Set Computing, kent veel minder instructies maar werkt veel sneller en met minder energieverbruik. Maar op RISC komen we voorlopig nog niet.

Wie mee wil doen met #klooienmetcomputers kan dat doen via GitHub. Maak een account op github.com en zoek naar Abmvk/kmc. Het account Abmvk volgen kan ook. Lezers zijn vrij te gebruiken wat ze willen en om zelf zaken toe te voegen of aan te passen, vragen te stellen of commentaar te leveren.