Illustrert opplæring om Assembler. Monteringsaritmetiske instruksjoner
Team ADC(Add with Carry) tilhører gruppen heltallskommandoer(eller binær)aritmetikk (Binære aritmetiske instruksjoner) og utfører heltall addisjon av to signerte eller usignerte operander ( DEST Og SRC) Og bære flagg EFLAGS.CF . Første operand ( destinasjonsoperand, DEST) kan være en variabel i et register eller i minnet ( , r16, r32 , r/m8, r/m16, r/m32). Andre operand ( kildeoperand, SRC) - umiddelbar betydning ( imm8, imm16, imm32), en variabel i et register eller i minnet. I dette tilfellet kan ikke begge operandene samtidig være variabler i minnet.
Resultat av tillegg ved kommando ADC er plassert i stedet for den første operanden ( DEST). Flaggene i EFLAGS-registeret settes etter resultatet.
Når du legger til en direkte verdi imm8 eller imm16 med en to-byte eller fire-byte operand, blir den umiddelbare verdien først fortegnsutvidet til størrelsen på den første operanden, og først deretter utføres addisjonen.
Team ADC vanligvis brukt i multibyte eller multiword ( flerord) tilleggsoperasjoner. I dette tilfellet følger den ADD-instruksjonen, som returnerer summen av lavordens biter av multibyte (multi-ord) operander, slik at bære kan tas i betraktning når du legger til høyordens biter. For eksempel:
mov edx, 0 ; EDX = 0
mov eax, 0FFFFFFFFh ; Det første 32-bits tillegget er plassert i EAX
legg til eax, 0FFFFFFFFh ; andre 32-bits tillegg - 0x FFFFFFFFh, vi legger til to 32-biters operander
adc edx, 0 ; EDX = EDX + CF, ta hensyn til overføringen
; EDX:EAX = 0000000lh:FFFFFFFEh - det resulterende 64-bits resultatet
Team ADC tillater manipulering av heltallsoperander som i usignert format, og i signert format. Når du legger til data med et tegn skilt flagg EFLAGS.SF vil gjenspeile tegnet på det oppnådde resultatet. Overløpsflagg EFLAGS.OF vil settes til 1 hvis det, når man legger til fortegnede heltallsverdier representert i tos komplement eller tos komplement, oppstår et overløp (som fører fra den mest signifikante biten som biten foran fortegnsbiten tilsvarer), dvs. resulterende resultat overskrider den tilgjengelige størrelsen på operand-avtalene ( DEST). I hovedsak ligner dette på hvordan EFLAGS.CF-flagget reflekterer overløp (carry) når du legger til usignerte operander. For eksempel, når du legger til to 32-bits verdier representert i omvendt kode, kan det se slik ut:
mov eax, operand1 ; EAX = operand1, det første 32-bits tillegget er plassert i EAX
legg til eax, operand2 ; vi legger til to 32-biters operander i omvendt kode
inn i ; hopp for å avbryte handler i tilfelle overløp
adc eax, 0 ; EAX = EAX + CF, ta hensyn til bæren (nødvendig for å legge til i omvendt kode)
; EAX = operand1 + operand2 - resultatet av addisjon i omvendt kode
jns m1; overgang hvis resultatet er positivt
xor eax, 7FFFFFFFh ; konvertere negativ verdi i EAX til rett kode
m1: ; EAX - resultatet av tillegg i direkte kode
Hjelpeflagg(eller ytterligere)overføre EFLAGS.AF hjelper til med å manipulere data i BCD-format ( pakket BCD-format). Den settes hvis det under tillegg skjer en overføring fra lav tetrad til høy tetrad av lav byte av resultatet. Bruke DAA-kommandoen umiddelbart etter kommandoen ADC, er det mulig å produsere den såkalte desimalkorrigering resultatet av addisjonen og få summen i samme pakket BCD-format, samt de opprinnelige vilkårene.
Team ADC med destinasjonsoperand ( DEST), som er en minnevariabel, kan brukes sammen med LOCK lock-prefikset, som vil sikre atomutførelse av kommandoen.
Tilleggskommandoer - ADD, ADC
Instruksjonene ADD (legg til) og ADC (legg til med bære) kan legge til både 8- og 16-biters operander.
ADD-instruksjonen legger til innholdet i kildeoperanden og destinasjonsoperanden og plasserer resultatet i destinasjonsoperanden.
Kommandoformat: ADD mottaker, kilde
I symbolsk notasjon kan dens handlinger beskrives som følger: vask:= vask + kilde (summen av innholdet i vasken og kilden skrives til vasken).
ADC-kommandoen gjør det samme som ADD-kommandoen, men legger ikke til to, men tre termer: destinasjonen, kilden og bæreflagget.
Kommandoformat: ADC-mottaker, kilde + CF
I symbolsk notasjon kan handlingene beskrives som:
vask:= vask + kilde + innhold i bæreflagg.
Å bære når du legger til binære tall ligner på å bære når du legger til desimaltall i en kolonne. Når datamaskinen legger til binære tall og summen ikke passer inn i destinasjonsoperanden, genereres en carry. Som du vet, kan et 8-bits register inneholde usignerte verdier i området fra 0 til 255. Hvis vi for eksempel utfører den binære addisjonen av tallene 250 og 10, vil vi få følgende resultat:
1111 1010; binær representasjon av tallet 250.
0000 1010 ; binær representasjon av tallet 10.
1 0000 0100; binær representasjon av summen lik 260.
Resultatet er riktig, men tar opp 9 binære biter. Hvis 8-bits registre ble brukt, vil de nedre 8 bitene bli lagt inn i destinasjonsregisteret, og den niende biten i bæreflagget CF.
Nå forstår vi hvorfor 8086-mikroprosessoren har to forskjellige tilleggsinstruksjoner. En av dem (ADD) kan legge til verdier representert av byte eller ord, så vel som de nedre delene av høypresisjonsverdier. En annen instruksjon (ADC) brukes til å legge til høye presisjonsverdier.
Operandene som skal legges til kan være i minnet, et register eller ha en umiddelbar verdi. For eksempel:
ADD AX,MEM_WORD; legge til innholdet i en minnecelle i et register,
ADD MEM_WORD,AX; eller omvendt, legg til innholdet i registeret til minnecellen.
ADD AL, 10; legge til en konstant til innholdet i registeret.
ADD MEM_BYTE,8H; legg til konstanten og innholdet i minnecellen.
De fleste mulige kombinasjoner er tillatt, men det er forbudt legg til innholdet i to minneceller eller bruk en direkte verdi (tall) som mottaker.
ADD- og ADC-kommandoene kan påvirke følgende seks flagg:
bære flagg CF er 1 hvis resultatet av addisjonen ikke passer i destinasjonsoperanden, ellers er det 0;
paritetsflagg PF er 1 hvis resultatet har et partall biter med verdien 1, ellers er det 0;
AF er lik 1 hvis resultatet av å legge til desimaltall krever korrigering;
null flagg ZF er 1 hvis resultatet er 0;
skilt flagg SF er 1 hvis resultatet er negativt (den mest signifikante biten er 1), ellers er den 0;
overløpsflagg OF er lik 1 hvis summen av to tall med samme tegn overskrider området for akseptable verdier for mottakeren i omvendt kode, og mottakeren selv endrer fortegn. Ellers er OF-flagget 0.
Kommando for å øke mottakerverdien med én - INC
Team INC(økning) legger til 1 til innholdet i et register eller en minnecelle, men i motsetning til ADD-instruksjonen, påvirker det ikke bæreflagget CF. Kommandoformat: INC mottaker.
INC-instruksjonen er nyttig for å øke tellere i instruksjonsløkker. Den kan også brukes til å øke verdien av indeksregisteret ved tilgang til sekvensielle minneceller. Operaanden tolkes som et tall uten fortegn.
For eksempel:
INC CX; øke verdien på 16-bit
INC AL; eller 8-bits register per enhet.
INC MEM_BYTE; øke byteverdien
INC MEM_WORD; eller minneord per enhet.
Det er ikke tillatt å bruke en umiddelbar verdi som en operand.
Subtraksjonskommandoer - SUB, og subtraksjon med lån av SBB
Lag UNDER(trekke fra - trekke fra) og SBB(trekk fra med lån) er lik addisjonskommandoene ADD og ADC, henholdsvis, bare når du trekker fra, fungerer bæreflagget CF som et tegn på et lån. Kommandoformat: SUB mottaker, kilde;
SUB-kommandoen trekker kildeoperanden fra destinasjonsoperanden og plasserer resultatet i destinasjonen, i symbolsk notasjon:
vask:= vask – kilde.
Team SBB gjør det samme, men trekker i tillegg verdien av CF-bæreflagget fra mottakeren:
SUB-mottaker, kilde – CF;
Destinasjon:= synke - kilde - innholdet i bæreflagget.
Som med tillegg, utfører SUB- og SBB-instruksjonene to separate funksjoner. Den første kommandoen trekker fra tall i byte- eller ordstørrelse, så vel som bitene av lav orden av tall med høy presisjon (den laveste delen av tallet er plassert i AX-registeret, og den høye ordensdelen er i DX-register). Den andre kommandoen trekker fra de mest signifikante bitene med høypresisjonstall. For eksempel kommandoen SUB AX,CX; Trekker innholdet i CX-registeret fra innholdet i AX-registeret og returnerer resultatet til AX-registeret.
Hvis operandstørrelsene overstiger 16 biter, må følgende sekvens av kommandoer brukes:
SUB AX,CX; Trekk fra lave 16 biter;
SBB BX,DX; og deretter de viktigste 16 bitene.
Her trekker vi fra 32-bits nummeret plassert i AX- og BX-registrene, 32-bit-tallet som ligger i CX- og DX-registrene. Når innholdet i DX-registeret trekkes fra innholdet i BX-registeret, tar SBB-instruksen hensyn til muligheten for å låne ved første subtraksjon.
SUB AX, MEM; Trekk innholdet i en minnecelle fra et register.
SUB MEM ,AX; Trekk et register fra en minnecelle.
SUB AL,1O; Trekk en konstant fra et register.
SUB MEM_BYTE,OFh; Trekk en konstant fra en minnecelle.
Kan ikke trekke direkte fra innholdet i en minnecelle fra en annen, eller bruk den umiddelbare verdien som en destinasjon.
SUB- og SBB-kommandoene kan påvirke seks flagg som følger:
· installere bære flagg CF er 1 hvis et lån kreves, ellers er det 0;
· installere paritetsflagg PF er 1 hvis resultatet av subtraksjonen har et partall biter med verdien 1, ellers er det 0;
· installere hjelpebæreflagg AF er 1 hvis resultatet av desimalsubtraksjon krever korreksjon, ellers er det 0;
· installere null flagg ZF til 1 hvis resultatet er 0, ellers er det 0;
· installere skilt flagg SF er 1 hvis resultatet er negativt (den mest signifikante biten er 1), ellers er flagget 0;
· installere overløpsflagg OF er 1 hvis subtraksjonsresultatet overskrider rekkevidden til mottakerverdiene i omvendt kode, og mottakeren selv skifter fortegn.
SF- og OF-flaggene gir bare mening når du trekker fra fortegnsnummer, og AF-flagget gir bare mening når du trekker fra desimaltall.
Reduser destinasjonsinnhold Kommando - DEC
Team DEC mottaker(redusere) trekker 1 fra innholdet i et register eller minneplassering, men (i motsetning til SUB-instruksjonen) påvirker ikke bæreflagget CF.
DEC-instruksjonen brukes ofte i sløyfer for å redusere en tellerverdi til den blir null eller negativ. Den kan også brukes til å redusere verdien til et indeksregister eller peker når du får tilgang til sekvensielle minneplasseringer. For eksempel:
DEC CX; Reduser 16-biters verdi,
DEC AL; eller 8-bits register.
DEC MEM_BYTE; Reduser byteverdi,
DEC MEM_WORD; eller ordminnecelle.
Divisjonskommandoer - DIV, IDIV
Team DIV(divide - divide) utfører usignert deling av tall, og kommandoen IDIV(heltallsdivisjon - divider heltall) utfører fortegnsdeling av tall. Disse kommandoene har formatet:
DIV-kilde; Hvor kilde- divisor av byte eller ordstørrelse,
IDIV-kilde;plassert i et generell register eller minneplassering.
Vær oppmerksom på følgende:
1. Utbyttet skal ha dobbel størrelse i forhold til deleren.
2. Utbyttet skal alltid være i AX-registeret (ved deling på et 8-bits tall) eller i DX- og AX-registrene (ved deling på et 16-bits tall).
3. Resultatene av kommandoen returneres som følger:
· hvis kildeoperanden er en byte, returneres kvotienten til AL-registeret, og resten til AN-registeret;
· Hvis kildeoperanden er et ord, returneres kvotienten til AX-registeret og resten til DX-registeret.
Begge instruksjonene lar tilstanden til flaggene være udefinert, men hvis kvotienten ikke passer i destinasjonsregisteret (AL eller AX), genererer mikroprosessoren et type 0-avbrudd (divisjon med 0).
4. Overløp av delingsresultatet skjer under følgende forhold:
· deleren er 0;
· når du deler byte uten fortegn, er utbyttet minst 256 ganger divisor;
· når man deler ord uten tegn, er utbyttet minst 65 536 ganger deleren;
· når du deler byte med et fortegn, ligger kvotienten utenfor området -128 til +127;
· når man deler ord med et tegn, ligger kvotienten utenfor området fra
32768 til 32767.
Her er noen typiske eksempler på divisjonsoperasjoner:
DIV BX; Del DX:AX med BX, usignert.
DIV MEM_BYTE; Del AX inn i en byte med minne, usignert.
IDIV DL; Del AX med DL med et tegn.
IDIV MEM ORD; Del DX:AX inn i et signert minneord.
DIV- og IDIV-instruksjonene deler ikke direkte med den umiddelbare verdien fordi prosessoren ikke kan bestemme datatypen til divisoren.
Multiplikasjonsinstruksjoner - MUL, IMUL
Team MUL(multipliser) multipliserer tall uten fortegn, en IMUL(heltall multiplisere) multipliserer heltall med fortegn. Multiplikanten og multiplikatoren til begge instruksjonene må være samme datatype, det vil si byte, ord, doble ord osv.
Disse kommandoene har følgende format:
MUL-kilde; Hvor kilde- register for generelle formål,
IMUL-kilde; eller en minnecelle i byte- eller ordstørrelse.
Som den første operanden (multiplikerbar), bruker MUL- og IMUL-instruksjonene innholdet i AL-registeret (for operasjoner på bytes) eller AX-registeret (for operasjoner på ord). Produktet har dobbel størrelse og returneres som følger:
· multiplikasjon bytes-returnerer 16-bits produktet inn i registrene AN (høy byte) og AL (lav byte);
· multiplikasjon ord-returnerer 32-bits produktet inn i registrene DX (høyt ord) og AX (lavt ord). Dermed størrelsen på produktet n- bitfaktorer er like 2n.
ADC Heltall tillegg med bære
Team adc utfører tillegg av den første og andre operanden, og legger til verdien av bæreflagget CF til resultatet. Den opprinnelige verdien av den første operanden (destinasjonen) går tapt, erstattet av resultatet av tillegget. Den andre operanden er uendret. Som den første operanden av kommandoen adc
Operander kan være byte eller ord og representere signerte eller usignerte tall. Team adc(sammen med laget Legg til) brukes vanligvis til å legge til 32-biters tall. Kommandoen påvirker flaggene OF, SF, ZF, AF, PF og CF.
Eksempel 1:
Mov AX,1125h adc AX,2C25h; AX=3D4Bh, hvis CF var = 1; AX=3D4Ah, hvis CF var = 0
Eksempel 2:
; I datafeltene: numlow dw 0FFFFh; Den lave delen av 2. termin numhigh dw 000Sh; Høyeste del av 2. termin;Nummer 0005FFFFh=393215;I programsegmentet: mov AX,000Sh; Lavordens del av 1. termin mov BX,0002h; Den høyeste delen av 1. term;Nummer 00020005h=131077 legg til AX,numlow; Tillegg av juniordeler. AX=4, CF=1 adc BX, numhøy; Tillegg av høyere deler med bære. BX:AX=0008:0004h. ;Nummer 00080004h=524292
Bruken av 32-bits operander og ekstra adresseringsmoduser for 32-bits prosessorer er akseptabelt. Team adc med 32-biters operander, kan brukes til å legge til 64-biters heltall.
Eksempel:
; I datafelt mem321 dd 0FFFFFFFFh; Lavordens del av 1. termin mem32h dd 98765432h; Den høyeste delen av 1. termin; I programsegmentet mov EAX,1; Lavordens del av 2. termin mov EBX,0; Den høyeste delen av 2. termin legger til EAX,mem321; Legg til de nedre halvdelene;Sum=100000000h>32 biter;EAX=000000h, bære adc EBX,mem32h; Brett de eldre halvdelene og bær over. EBX=90000001h; Beløp: 9876543300000000h
ADD Heltall addisjon
Team Legg til utfører tillegg av den første og andre operanden. Den opprinnelige verdien av den første operanden (destinasjonen) går tapt, erstattet av resultatet av tillegget. Den andre operanden er uendret. Som den første operanden av kommandoen Legg til Du kan spesifisere et register (unntatt et segment en) eller en minnecelle, den andre kan være et register (unntatt et segment en), en minnecelle eller en umiddelbar verdi, men det er ikke tillatt å definere begge operandene samtidig som minne celler.
Operander kan være byte eller ord og representere signerte eller usignerte tall. Add-kommandoen kan brukes til å legge til både vanlige heltall og binære desimaltall (ved å bruke AX-registeret til å lagre resultatet). Hvis utpakkede binærkodede desimaltall (BCD) legges til, etter kommandoen Legg til aaa-kommandoen skal brukes; hvis pakkede tall legges til, så kommandoen ja. Kommandoen påvirker flaggene OF, SF, ZF, AF, PF og CF.
Eksempel 1:
Mov BX,lFFEh mov CX,3 legg til BX,CX; BX=2001h, CX=0003t
Eksempel 2:
Mov AX,25t legg til AX,12t; AX=0037h
Eksempel 3:
; I datafeltene: mem dw 128 ;I programsegmentet: legg til mem,100; mem=228
ADC Heltall tillegg med bære
ADC-kommandoen legger til den første og andre operanden, og legger til verdien av bæreflagget CF til resultatet. Den opprinnelige verdien av den første operanden (destinasjonen) går tapt, erstattet av resultatet av tillegget. Den andre operanden er uendret. Den første operanden av ADC-instruksjonen kan være et register (unntatt et segment) eller en minnecelle, den andre operanden kan være et register (unntatt et segment), en minnecelle eller en umiddelbar verdi, men det er ikke tillatt å spesifisere begge operander samtidig som minneceller. Operander kan være byte eller ord og representere signerte eller usignerte tall. ADC-kommandoen (sammen med add-kommandoen) brukes ofte til å legge til 32-biters tall. Kommandoen påvirker flaggene OF, SF, ZF, AF, PF og CF.
Eksempel 1
Mov AX,1125h adc AX,2C25h ;AX=3D4Bh, hvis CF var = 1 ;AX=3D4Ah, hvis CF var = 0
Eksempel 2; I datafeltene: numlow dw 0FFFFh ;Lav del av 2. termin numhigh dw 000Sh ;Høy del av 2. termin;Nummer 0005FFFFh=393215 ;I programsegmentet: mov AX,000Sh ;Lavledd av mov BX1. 0002h ; Den høyeste delen av 1. term;Nummer 00020005h=131077 legg til AX,numlow;Tillegg av de nedre delene. AX=4, CF=1 adc BX, numhigh ;Tillegg av høyere deler med;overføring.BX:AX=0008:0004h. ;Nummer 00080004h=524292
Bruk av 32-biters operander og ekstra adresseringsmoduser for 32-bits prosessorer er akseptabelt. ADC-instruksjonen med 32-biters operander kan brukes til å legge til 64-biters heltall. Eksempel 3; I datafeltene mem321 dd 0FFFFFFFFh ;Lav del av 1. termin mem32h dd 98765432h ;Høy del av 1. termin; I programsegmentet mov EAX,1 ;Den lave delen av 2. ledd mov EBX,0 ;Den høye delen av 2. ledd legg til EAX,mem321 ;Legg til de lave halvdelene;Sum=100000000b>32 biter;EAX=000000h, bære adc EBX,mem32h ;Legg til de eldre halvdelene; og overfør. EBX=90000001h ;Beløp: 9876543300000000h
ADD Heltall addisjon
Add-kommandoen legger til den første og andre operanden. Den opprinnelige verdien av den første operanden (destinasjonen) går tapt, erstattet av resultatet av tillegget. Den andre operanden er uendret. Den første operanden til add-kommandoen kan spesifiseres som et register (unntatt et segment en) eller en minnecelle, og den andre operanden kan være et register (unntatt et segment en), en minnecelle eller en umiddelbar verdi, men det er ikke tillatt å definere begge operandene samtidig som minneceller. Operander kan være byte eller ord og representere signerte eller usignerte tall. Add-kommandoen kan brukes til å legge til både vanlige heltall og binære desimaltall (ved å bruke AX-registeret til å lagre resultatet). Når du legger til utpakkede binærkodede desimaltall (BCD), bruk aaa-kommandoen etter add-kommandoen; hvis pakkede tall legges til, så kommando daa. Kommandoen påvirker flaggene OF, SF, ZF, AF, PF og CF. Eksempel 1
Mov BX,lFFEh mov CX,3 legg til BX,CX ;BX=2001h, CX=0003h
Eksempel 2 mov AX,25t legg til AX,12t ;AX=0037t
Eksempel 3; I datafeltene: mem dw 128 ;I programsegmentet: legg til mem,100 ;mem=228
Eksempel 4 mov AX,0507h ;BCD utpakket 57 add AL,05h ;BCD 5, AX=050Ch aaa ;AX=0602h, BCD 62
Eksempel 5 mov AL,57t ;BCD pakket 57 add AL,05t ;BCD 5, AL=5Ch daa ;AL=62t, BCD 62
Bruk av 32-biters operander og ekstra adresseringsmoduser for 32-bits prosessorer er akseptabelt. Eksempel
Mov EAX,98765432h legg til EAX,11111111h ; EAX=A9876543h
OG Logisk OG
Kommandoen og utfører en logisk (bitvis) multiplikasjon av den første operanden med den andre. Den opprinnelige verdien til den første operanden (destinasjonen) går tapt, erstattet av resultatet av multiplikasjonen. Den første operanden av kommandoen og kan være et register (unntatt et segment en) eller en minnecelle, den andre operanden kan være et register (unntatt en segment en), en minnecelle eller en umiddelbar verdi, men det er ikke tillatt å spesifiser begge operandene samtidig som minneceller. Operander kan være byte eller ord. Kommandoen påvirker SF-, ZF- og PF-flaggene. Regler for bitvis multiplikasjon:
Første operandbit 0101 Andre operandbit 0011 Resultatbit 0001 Eksempel 1 mov AX,0FFEh og AX,5555h ;AX=0554h Eksempel 2; I datafeltene: mem dw 0С003h ;I programsegmentet: mov AX,700Eh og AX,mem ;AX=4002h
Bruk av 32-biters operander og ekstra adresseringsmoduser for 32-bits prosessorer er akseptabelt. Eksempel
Mov EDX, 0FA8 8 0 0 4 lh og EDX,0FF00000Fh ; EDX = FA000001h
386P+ ARPL
Justering av det forespurte velgerrettighetsnivået
aprl-kommandoen sammenligner velgeren med et mønster som inneholder det maksimalt tillatte rettighetsnivået (vanligvis CS-velgeren) og setter verdien som skal testes til det laveste av de to rettighetsnivåene. Hvis nivåendringen ikke er nødvendig, tilbakestilles ZF-flagget, om nødvendig settes det. Den første operanden av aprl-instruksjonen kan være et 16-bits register eller et minneord med en kontrollerbar velger; den andre operanden er et 16-bits register med en mønstervelger. 386+ BUNDET
Kontrollerer en matriseindeks for matrise utenfor grensene
Den bundne kommandoen sjekker om den spesifiserte indeksen, behandlet som et signert tall, ligger innenfor grensene spesifisert av den andre operanden. Hvis indeksen går utover grensene til matrisen under eller over, genereres et avbrudd med vektor 5. Den første operanden må være et register som inneholder indeksen som kontrolleres, den andre - adressen til et minnefelt med to grenser for matrisen blir sjekket. Den bundne kommandoen tillater både 16-biters og 32-biters operander (men både den første og andre operanden må være av samme type).
Monter- Monteringsspråk for dummies
Monteringsspråk for dummies.(#2) (C) Mikhail Spitsyn 1995 Flagg Register "F" til prosessoren kalles flagg. Hva det er? Et flagg er en variabel som kan ha to tilstander: satt (lik en) og slettet (lik null). Derfor kan "F"-registeret betraktes som et sett med åtte flaggbiter. Vi kan bare bruke fire av dem: nullflagget, bæreflagget, skiltflagget og paritetsoverløpsflagget.Aritmetiske operasjoner. Aritmetikk er en veldig, veldig nyttig vitenskap; vi teller hele tiden noe: addere, subtrahere, dividere, multiplisere. Vi vil nå snakke om hvordan du gjør dette i assembler. Vi starter med den enkleste tingen, å legge en til noe, for eksempel for å registrere "A": **************************** *** ** LD A,NUBER INC A RET ******************************** Som du kan se, er det er veldig enkelt for dette er det en kommando "INC" - inkrement (øk med én), etterfulgt av en operand, dvs. noen registrerer eller registrerer par: ******************************** INC A INC HL INC H INC DE INC E INC IY INC E INC (HL) INC (IX+N) INC (IY+N) ****************************** ** Hvis du trenger å øke en minnecelle med én, bør du gjøre dette: ********************************* ****** *** LD HL,ADDRES LD IX,ADDRES INC (HL) INC (IX+0) RET RET ********************* **************** ***** Det første alternativet fungerer raskere og er mer praktisk hvis du jobber med én minnecelle, men hvis du jobber i en tabell, er det ikke økonomisk og stygg. Sammenlign: vi må øke den første, femte og tiende byten i tabellen med én: ******************************* * LD HL,TABL+1 LD IX,TABL INC (HL) INC (IX+1) LD HL,TABL+5 INC (IX+5) INC (HL) INC (IX+10) LD HL,TABL+10 RET INC (HL) RET ******************************** Alt som ble sagt ovenfor om en økning med én er sant og for nedgang, dvs. for å redusere med én: ******************************** DES A DES HL DES L DES IX DES H DES DE DES E DES BC DES D DES IY DES C DES IX DES B DES (HL) DES (IX+N) DES (IX+N) ********************* *********** La oss nå anta at vi trenger å øke register "A" ikke med én, men for eksempel med ti: **************** * *************** LD A,NUMBER ADD A,10 RET ************************* * ****** Du kan legge til register "A" med et nummer og andre registre og med en minnecelle adressert av registerparene "HL", "IX" og "IY". Du kan også legge til registerpar med "HL", "IX" og "IY". (PureBasic - filsystem) ********************************* ADD A,N ADD A,(HL) ADD A ,A ADD A,(IX+N) ADD A,B ADD A,(IY+N) ADD A,C ADD HL,HL ADD A,D ADD HL,BC ADD A,E ADD HL,DE ADD A,H ADD HL,SP ADD IX,IX ADD IX,BC ADD IX,DE ADD IX,SP ****************************** ** Som du kan se, er settet med kommandoer ganske stort. Når du utfører denne kommandoen, kan det oppstå en feil: ********************************* LD A,45 LD B,230 ADD A ,B RET ********************************* Summen av "A" og "B" oversteg 255 og derfor i "A" " vil vise seg å være ikke 275, men 20 (register "A" er ikke gummi); For å gi oss beskjed om at et overløp har oppstått, setter prosessoren bæreflagget til ett. Det gjenstår bare å sjekke det. Akkurat som "INC" har "DEC", har "ADD" også et "par", er dette "SUB", og det har sine egne egenskaper. "SUB"-kommandoen fungerer bare med "A"-registeret, så når du skriver mnemonics for denne kommandoen, er "A" utelatt: ********************* *********** SUB N SUB C SUB A SUB H SUB B SUB D SUB E SUB (HL) SUB (IX+N) SUB (IY+N) ******** * *********************** Kommandoen påvirker bæreflagget på samme måte som "ADD". I tillegg til kommandoparet "ADD" og "SUB", er det et annet par. "ADC"- og "SBC"-kommandoene fungerer under hensyntagen til bæreflagget, dvs. Når du legger til eller trekker fra, blir verdien av bæreflagget lagt til (trukket fra) til resultatet. Det er to spesielle kommandoer for å sette bæreflagget - "SCF" og "CCF". "SCF" - sett bæreflagget til ett. "CCF" - sett bæreflagget til null. ********************************* ADC A,N SBC A,N ADC A,A SBC A,A ADC A ,H SBC A,H ADC A,L SBC A,L ADC A,D SBC A,D ADC A,E SBC A,E ADC A,B SBC A,B ADC A,C SBC A,C ADC A,( HL) SBC A,(HL) ADC A,(IX+N) SBC A,(IX+N) ADC A,(IY+N) SBC A,)IY+N) ADC HL,HL SBC HL,HL ADC HL ,BC SBC HL,BC ADC HL,DE SBC HL,DE ADC HL,SP SBC HL,SP **************************** **** Og nå eksempler på arbeidet med kommandoene "ADC" og "SBC": ****************************** ************* * LD A,10 LD A,10 LD B,5 LD B,5 CCF CCF SBC A,B ADC A,B RET RET A=5 B=5 A=15 B=5 ******** *********************** I stedet for de to kommandoene "CCF" og "SBC A,B" kan du ganske enkelt sette "SUB B", blir resultatet det samme . ********************************* LD A,10 LD A,10 LD B,5 LD B,5 SCF SCF SBC A,B ADC A,B RET RET A=4 B=5 A=16 B=5 ****************************** **** Som det fremgår av resultatene, påvirker bæreflagget resultatet av operasjonen betydelig. Ved subtrahering trekkes det fra resultatet, og ved addisjon legges det til resultatet. Nesten alt har blitt dekket om operasjonene for addisjon og subtraksjon; nå skal vi snakke om divisjon og multiplikasjon. SPECCY har dessverre ikke divisjons- og multiplikasjonskommandoer, men disse kommandoene kan være sammensatt av flere andre. For eksempel må vi multiplisere innholdet i to registre - "A" og "C": ****************************** ********** *** LD A,10 LD C,5 LD B,A XOR A LOOP ADD A,C DJNZ LOOP RET *************** ********** ******** I eksemplet er det to nye kommandoer - "XOR A" og "DJNZ LOOP". "XOR A" sletter registeret "A", og kommandoen "DJNZ LOOP" gjentar alle kommandoer, fra kommandoen merket med en etikett (for eksempel "LOOP") til kommandoen "DJNZ" (etterfulgt av samme etikett). ka, som i begynnelsen av syklusen); antall repetisjoner er spesifisert i register "B". Ved å bruke det faktum at å multiplisere M med N er å legge til tallet M til seg selv N ganger, kan du forstå eksemplet gitt ovenfor. Denne eiendommen kan også brukes til deling. Prøv det selv. Neste gang skal vi snakke om kommandoer for å sammenligne og arbeide med bits.________________________________Andre artikler i utgaven:
