Illustrerad handledning om Assembler. Monteringsaritmetiska instruktioner
Team ADC(Lägg till med bär) tillhör gruppen heltalskommandon(eller binär)aritmetisk (Binära aritmetiska instruktioner) och utför heltalstillägget av två signerade eller osignerade operander ( DEST Och SRC) Och bär flagga EFLAGS.CF . Första operanden ( destinationsoperand, DEST) kan vara en variabel i ett register eller i minnet ( , r16, r32 , r/m8, r/m16, r/m32). Andra operanden ( källoperand, SRC) - omedelbar betydelse ( imm8, imm16, imm32), en variabel i ett register eller i minnet. I det här fallet kan båda operanderna inte samtidigt vara variabler i minnet.
Resultat av tillägg genom kommando ADC placeras i stället för den första operanden ( DEST). Flaggorna i EFLAGS-registret sätts enligt resultatet.
När du lägger till ett direkt värde imm8 eller imm16 med en två-byte eller fyra-byte operand, är det omedelbara värdet först tecken-expanderat till storleken på den första operanden, och först därefter utförs tillägget.
Team ADC används vanligtvis i multibyte eller multiword ( flera ord) tilläggsoperationer. I det här fallet följer den ADD-instruktionen, som returnerar summan av de låga ordningens bitar av multibyte (multi-ord) operander, vilket gör att överföring kan tas med i beräkningen vid addering av högordningens bitar. Till exempel:
mov edx, 0 ; EDX = 0
mov eax, 0FFFFFFFFh ; Den första 32-bitars tillägget placeras i EAX
lägg till eax, 0FFFFFFFFh ; andra 32-bitars tillägg - 0x FFFFFFFFh, vi lägger till två 32-bitars operander
adc edx, 0 ; EDX = EDX + CF, ta hänsyn till överföringen
; EDX:EAX = 0000000lh:FFFFFFFEh - det resulterande 64-bitarsresultatet
Team ADC tillåter manipulering av heltalsoperander som i osignerat format, och i signerat format. När du lägger till data med ett tecken tecken flagga EFLAGS.SF kommer att återspegla tecknet på det erhållna resultatet. Overflow flagga EFLAGS.OF kommer att sättas till 1 om, när man lägger till tecken med heltalsvärden representerade i tvåskomplement eller tvåkomplement, ett spill inträffar (som bär från den mest signifikanta biten som biten som föregår teckenbiten motsvarar), dvs. resulterande resultat överstiger den tillgängliga storleken på operanden -utnämningar ( DEST). Detta liknar i huvudsak hur EFLAGS.CF-flaggan reflekterar överflöde (carry) när den läggs till osignerade operander. Till exempel, när du lägger till två 32-bitars värden representerade i omvänd kod, kan det se ut så här:
mov eax, operand1 ; EAX = operand1, den första 32-bitars tillägget placeras i EAX
lägg till eax, operand2 ; vi lägger till två 32-bitars operander i omvänd kod
in i ; hoppa för att avbryta hanteraren i händelse av översvämning
adc eax, 0 ; EAX = EAX + CF, ta hänsyn till överföringen (nödvändigt för tillägg i omvänd kod)
; EAX = operand1 + operand2 - resultatet av addition i omvänd kod
jns m1; övergång om resultatet är positivt
xor eax, 7FFFFFFFh ; konvertera negativt värde i EAX till rak kod
m1:; EAX - resultatet av tillägg i direktkod
Hjälpflagga(eller ytterligare)överföra EFLAGS.AF hjälper till att manipulera data i BCD-format ( packat BCD-format). Den ställs in om, under addition, en överföring sker från den låga tetraden till den höga tetraden för den låga byten av resultatet. Använd DAA-kommandot omedelbart efter kommandot ADC, är det möjligt att producera den sk decimalkorrigering resultatet av tillägget och få summan i samma paketerat BCD-format, som de ursprungliga termerna.
Team ADC med destinationsoperand ( DEST), som är en minnesvariabel, kan användas tillsammans med LOCK lock-prefixet, vilket säkerställer att kommandot utförs atomärt.
Tilläggskommandon - ADD, ADC
Instruktionerna ADD (lägg till) och ADC (lägg till med bär) kan lägga till både 8- och 16-bitars operander.
ADD-instruktionen lägger till innehållet i källoperanden och destinationsoperanden och placerar resultatet i destinationsoperanden.
Kommandoformat: ADD-mottagare, källa
I symbolisk notation kan dess handlingar beskrivas på följande sätt: sink:= sink + source (summan av innehållet i diskbänken och källan skrivs till sink).
ADC-kommandot gör samma sak som ADD-kommandot, men lägger inte till två utan tre termer: destinationen, källan och bärflaggan.
Kommandoformat: ADC-mottagare, källa + CF
I symbolisk notation kan dess handlingar beskrivas som:
sink:= sink + source + innehållet i bärflaggan.
Att bära när man lägger till binära tal liknar att bära när man lägger till decimaltal i en kolumn. När datorn lägger till binära tal och summan inte får plats i destinationsoperanden, genereras ett bär. Som ni vet kan ett 8-bitars register innehålla osignerade värden i intervallet från 0 till 255. Om vi till exempel utför den binära additionen av siffrorna 250 och 10 får vi följande resultat:
1111 1010; binär representation av talet 250.
0000 1010 ; binär representation av talet 10.
1 0000 0100; binär representation av summan lika med 260.
Resultatet är korrekt, men tar upp 9 binära bitar. Om 8-bitars register användes, kommer de lägre 8 bitarna att matas in i destinationsregistret och den nionde biten i bärflaggan CF.
Nu förstår vi varför 8086-mikroprocessorn har två olika tilläggsinstruktioner. En av dem (ADD) kan lägga till värden som representeras av byte eller ord, såväl som de lägre delarna av högprecisionsvärden. En annan instruktion (ADC) används för att lägga till höga precisionsvärden.
De operander som ska läggas till kan finnas i minnet, ett register eller ha ett omedelbart värde. Till exempel:
LÄGG TILL AXE,MEM_WORD; lägga till innehållet i en minnescell till ett register,
ADD MEM_WORD,AX; eller vice versa, lägg till innehållet i registret till minnescellen.
ADD AL, 10; lägg till en konstant till innehållet i registret.
ADD MEM_BYTE,8H; lägg till konstanten och innehållet i minnescellen.
De flesta möjliga kombinationer är tillåtna, men det är förbjudet lägg till innehållet i två minnesceller eller använd ett direkt värde (nummer) som mottagare.
ADD- och ADC-kommandona kan påverka följande sex flaggor:
bär flagga CF är 1 om resultatet av tillägget inte passar i destinationsoperanden, annars är det 0;
paritetsflagga PF är 1 om resultatet har ett jämnt antal bitar med värdet 1, annars är det 0;
AF är lika med 1 om resultatet av att lägga till decimaltal kräver korrigering;
noll flagga ZF är 1 om resultatet är 0;
tecken flagga SF är 1 om resultatet är negativt (den mest signifikanta biten är 1), annars är den 0;
översvämningsflagga OF är lika med 1 om summan av två siffror av samma tecken överskrider intervallet för acceptabla värden för mottagaren i den omvända koden, och mottagaren själv byter tecken. Annars är OF-flaggan 0.
Kommando för att öka mottagarvärdet med ett - INC
Team INC(öka) lägger till 1 till innehållet i ett register eller en minnescell, men till skillnad från ADD-instruktionen påverkar det inte bärflaggan CF. Kommandoformat: INC-mottagare.
INC-instruktionen är användbar för att öka räknare i instruktionsslingor. Den kan också användas för att öka indexregistrets värde vid åtkomst till sekventiella minnesceller. Operanden tolkas som ett tal utan tecken.
Till exempel:
INC CX; öka värdet på 16-bitars
INC AL; eller 8-bitars register per enhet.
INC MEM_BYTE; öka bytevärdet
INC MEM_WORD; eller minnesord per enhet.
Det är inte tillåtet att använda ett omedelbart värde som en operand.
Subtraktionskommandon - SUB, och subtraktion med att låna SBB
Lag SUB(subtrahera - subtrahera) och SBB(subtrahera med lån) liknar additionskommandona ADD respektive ADC, endast vid subtrahering fungerar bärflaggan CF som ett tecken på ett lån. Kommandoformat: SUB-mottagare, källa;
Kommandot SUB subtraherar källoperanden från destinationsoperanden och placerar resultatet i destinationen, i symbolisk notation:
sink:= sink – källa.
Team SBB gör samma sak, men subtraherar dessutom värdet på CF-bärflaggan från mottagaren:
SUB-mottagare, källa – CF;
Destination:= sjunka - källa - innehållet i bärflaggan.
Som med tillägg utför SUB- och SBB-instruktionerna två separata funktioner. Det första kommandot subtraherar siffror i byte- eller ordstorlek, såväl som de låga ordningens bitar av högprecisionsnummer (den låga ordningens del av numret finns i AX-registret och den högre ordningen finns i DX-registret). Det andra kommandot subtraherar de mest signifikanta bitarna av högprecisionsnummer. Till exempel kommandot SUB AX,CX; Subtraherar innehållet i CX-registret från innehållet i AX-registret och returnerar resultatet till AX-registret.
Om operandens storlek överstiger 16 bitar måste följande kommandosekvens användas:
SUB AX,CX; Subtrahera låga 16 bitar;
SBB BX,DX; och sedan de viktigaste 16 bitarna.
Här subtraherar vi från 32-bitarsnumret placerat i AX- och BX-registren 32-bitarsnumret som finns i CX- och DX-registren. När innehållet i DX-registret subtraheras från innehållet i BX-registret, tar SBB-instruktionen hänsyn till möjligheten att låna när den första subtraktionen utförs.
SUB AXE, MEM; Subtrahera innehållet i en minnescell från ett register.
SUB MEM ,AX; Subtrahera ett register från en minnescell.
SUB AL,1O; Subtrahera en konstant från ett register.
SUB MEM_BYTE,OFh; Subtrahera en konstant från en minnescell.
Kan inte subtrahera direkt innehållet i en minnescell från en annan, eller använd det omedelbara värdet som en destination.
SUB- och SBB-kommandona kan påverka sex flaggor enligt följande:
· Installera bär flagga CF är 1 om ett lån krävs, annars är det 0;
· Installera paritetsflagga PF är 1 om resultatet av subtraktionen har ett jämnt antal bitar med värdet 1, annars är det 0;
· Installera extra bärflagga AF är 1 om resultatet av decimalsubtraktion kräver korrigering, annars är det 0;
· Installera noll flagga ZF till 1 om resultatet är 0, annars är det 0;
· Installera tecken flagga SF är 1 om resultatet är negativt (den mest signifikanta biten är 1), annars är flaggan 0;
· Installera översvämningsflagga OF är 1 om subtraktionsresultatet överskrider intervallet för mottagarvärdena i den omvända koden, och mottagaren själv byter tecken.
SF- och OF-flaggorna är bara meningsfulla när man subtraherar signerade tal, och AF-flaggan är bara meningsfull när man subtraherar decimaltal.
Kommando för minska destinationsinnehåll - DEC
Team DEC-mottagare(minska) subtraherar 1 från innehållet i ett register eller minnesplats, men (till skillnad från SUB-instruktionen) påverkar inte bärflaggan CF.
DEC-instruktionen används ofta i loopar för att minska ett räknarvärde tills det blir noll eller negativt. Den kan också användas för att minska värdet på ett indexregister eller pekare vid åtkomst till sekventiella minnesplatser. Till exempel:
DEC CX; Minska 16-bitars värde,
DEC AL; eller 8-bitars register.
DEC MEM_BYTE; Minska bytevärdet,
DEC MEM_WORD; eller ordminnescell.
Divisionskommandon - DIV, IDIV
Team DIV(divide - divide) utför osignerad division av tal, och kommandot IDIV(heltalsdelning - dividera heltal) utför signerad division av tal. Dessa kommandon har formatet:
DIV-källa; Var källa- divisor av byte eller ordstorlek,
IDIV källa;placerad i ett allmänt register eller minnesplats.
Snälla notera följande:
1. Utdelningen ska ha dubbel storlek i förhållande till delaren.
2. Utdelningen ska alltid finnas i AX-registret (vid division med ett 8-bitars tal) eller i DX- och AX-registren (vid division med ett 16-bitars tal).
3. Resultaten av kommandot returneras enligt följande:
· om källoperanden är en byte, returneras kvoten till AL-registret och resten till AN-registret;
· Om källoperanden är ett ord, returneras kvoten till AX-registret och resten till DX-registret.
Båda instruktionerna lämnar flaggornas tillstånd odefinierat, men om kvoten inte passar i destinationsregistret (AL eller AX), så genererar mikroprocessorn ett typ 0-avbrott (division med 0).
4. Överflöde av delningsresultatet sker under följande förhållanden:
· divisorn är 0;
· vid division av bytes utan tecken är utdelningen minst 256 gånger divisorn;
· vid delning av ord utan tecken är utdelningen minst 65 536 gånger divisorn;
· vid division av bytes med ett tecken, ligger kvoten utanför intervallet -128 till +127;
· när man delar ord med ett tecken ligger kvoten utanför intervallet från
32768 till 32767.
Här är några typiska exempel på divisionsoperationer:
DIV BX; Dela DX:AX med BX, osignerad.
DIV MEM_BYTE; Dela AX i en byte av minne, osignerad.
IDIV DL; Dividera AXE med DL med ett tecken.
IDIV MEM ORD; Dela upp DX:AX i ett signerat minnesord.
DIV- och IDIV-instruktionerna delar inte direkt med det omedelbara värdet eftersom processorn inte kan bestämma datatypen för divisorn.
Multiplikationsinstruktioner - MUL, IMUL
Team MUL(multiplicera-multiplicera) multiplicerar osignerade tal, en IMUL(heltalsmultiplicera) multiplicerar heltal med tecken. Multiplikanten och multiplikatorn för båda instruktionerna måste vara samma datatyp, det vill säga bytes, ord, dubbla ord, etc.
Dessa kommandon har följande format:
MUL-källa; Var källa- register för allmänna ändamål,
IMUL-källa; eller en minnescell i byte- eller ordstorlek.
Som den första operanden (multiplicerbar) använder MUL- och IMUL-instruktionerna innehållet i AL-registret (för operationer på bytes) eller AX-registret (för operationer på ord). Produkten har dubbel storlek och returneras enligt följande:
· multiplikation bytes-returerar 16-bitarsprodukten till registren AN (hög byte) och AL (låg byte);
· multiplikation ord-returerar 32-bitarsprodukten till registren DX (högt ord) och AX (lågt ord). Alltså storleken på produkten n- bitfaktorer är lika 2n.
ADC heltalstillägg med bär
Team adc utför tillägget av de första och andra operanderna, vilket adderar värdet av bärflaggan CF till resultatet. Det ursprungliga värdet för den första operanden (destinationen) går förlorat, ersätts av resultatet av tillägget. Den andra operanden är oförändrad. Som den första operanden av kommandot adc
Operander kan vara bytes eller ord och representera tecken med eller utan tecken. Team adc(tillsammans med laget Lägg till) används vanligtvis för att lägga till 32-bitars nummer. Kommandot påverkar flaggorna OF, SF, ZF, AF, PF och CF.
Exempel 1:
Mov AX,1125h adc AX,2C25h; AX=3D4Bh, om CF var = 1; AX=3D4Ah, om CF var = 0
Exempel 2:
; I datafälten: numlow dw 0FFFFh; Den låga delen av 2:a termen numhigh dw 000Sh; Den högsta delen av 2:a terminen;Nummer 0005FFFFh=393215;I programsegmentet: mov AX,000Sh; Låg ordning del av 1:a terminen mov BX,0002h; Den högsta delen av 1:a termen;Number 00020005h=131077 lägg till AX,numlow; Tillägg av juniordelar. AX=4, CF=1 adc BX, numhigh; Tillägg av högre delar med bär. BX:AX=0008:0004h. ;Nummer 00080004h=524292
Användningen av 32-bitars operander och ytterligare adresseringslägen för 32-bitars processorer är acceptabel. Team adc med 32-bitars operander, kan användas för att lägga till 64-bitars heltal.
Exempel:
; I datafält mem321 dd 0FFFFFFFFh; Låg ordning del av 1:a terminen mem32h dd 98765432h; Den högsta delen av 1:a terminen; I programsegmentet mov EAX,1; Låg ordning del av 2:a terminen mov EBX,0; Den högsta delen av den andra terminen lägg till EAX,mem321; Lägg till de nedre halvorna;Sum=100000000h>32 bitar;EAX=000000h, bär adc EBX,mem32h; Vik de äldre halvorna och bär över. EBX=90000001h; Belopp: 9876543300000000h
ADD Heltalstillägg
Team Lägg till utför tillägg av den första och andra operanden. Det ursprungliga värdet för den första operanden (destinationen) går förlorat, ersätts av resultatet av tillägget. Den andra operanden är oförändrad. Som den första operanden av kommandot Lägg till Du kan specificera ett register (förutom ett segment ett) eller en minnescell, det andra kan vara ett register (förutom ett segment ett), en minnescell eller ett omedelbart värde, men det är inte tillåtet att definiera båda operanderna samtidigt som minne celler.
Operander kan vara byte eller ord och representera signerade eller osignerade nummer. Add-kommandot kan användas för att lägga till både vanliga heltal och binära decimaltal (med hjälp av AX-registret för att lagra resultatet). Om uppackade binärkodade decimaltal (BCD) läggs till efter kommandot Lägg till kommandot aaa ska användas; om packade nummer läggs till, då kommandot ja. Kommandot påverkar flaggorna OF, SF, ZF, AF, PF och CF.
Exempel 1:
Mov BX,lFFEh mov CX,3 lägg till BX,CX; BX=2001h, CX=0003h
Exempel 2:
Mov AX,25h lägg till AX,12h; AX=0037h
Exempel 3:
; I datafälten: mem dw 128 ;I programsegmentet: add mem,100; mem=228
ADC heltalstillägg med bär
ADC-kommandot lägger till den första och andra operanden och lägger till värdet på bärflaggan CF till resultatet. Det ursprungliga värdet för den första operanden (destinationen) går förlorat, ersätts av resultatet av tillägget. Den andra operanden är oförändrad. Den första operanden av ADC-instruktionen kan vara ett register (förutom ett segment) eller en minnescell, den andra operanden kan vara ett register (förutom ett segment), en minnescell eller ett omedelbart värde, men det är inte tillåtet att specificera båda operanderna samtidigt som minnesceller. Operander kan vara bytes eller ord och representera tecken med eller utan tecken. ADC-kommandot (tillsammans med add-kommandot) används vanligtvis för att lägga till 32-bitars nummer. Kommandot påverkar flaggorna OF, SF, ZF, AF, PF och CF.
Exempel 1
Mov AX,1125h adc AX,2C25h ;AX=3D4Bh, om CF var = 1 ;AX=3D4Ah, om CF var = 0
Exempel 2; I datafälten: numlow dw 0FFFFh ;Låg del av 2:a terminen numhigh dw 000Sh ;Hög del av 2:a terminen;Nummer 0005FFFFh=393215 ;I programsegmentet: mov AX,000Sh ;Låg del av mov BX1:a terminen 0002h ; Den högsta delen av den första termen;Number 00020005h=131077 lägg till AX,numlow;Tillägg av de nedre delarna. AX=4, CF=1 adc BX, numhigh ;Tillägg av högre delar med;överföring.BX:AX=0008:0004h. ;Nummer 00080004h=524292
Användningen av 32-bitars operander och ytterligare adresseringslägen för 32-bitars processorer är acceptabel. ADC-instruktionen med 32-bitars operander kan användas för att lägga till 64-bitars heltal. Exempel 3; I datafälten mem321 dd 0FFFFFFFFh ;Låg del av 1:a termen mem32h dd 98765432h ;Hög del av 1:a termen; I programsegmentet mov EAX,1 ;Den låga delen av 2:a termen mov EBX,0 ;Den höga delen av den andra termen addera EAX,mem321 ;Lägg till de låga halvorna;Sum=100000000b>32 bitar;EAX=000000h, bär adc EBX,mem32h ;Lägg till de äldre halvorna och överför. EBX=90000001h ;Belopp: 9876543300000000h
ADD Heltalstillägg
Kommandot add lägger till den första och andra operanden. Det ursprungliga värdet för den första operanden (destinationen) går förlorat, ersätts av resultatet av tillägget. Den andra operanden är oförändrad. Den första operanden av add-kommandot kan anges som ett register (förutom ett segment ett) eller en minnescell, och den andra operanden kan vara ett register (förutom ett segment ett), en minnescell eller ett omedelbart värde, men det är inte tillåtet att definiera båda operanderna samtidigt som minnesceller. Operander kan vara byte eller ord och representera signerade eller osignerade nummer. Add-kommandot kan användas för att lägga till både vanliga heltal och binära decimaltal (med hjälp av AX-registret för att lagra resultatet). När du lägger till uppackade binärkodade decimaltal (BCD), använd kommandot aaa efter kommandot add; om packade nummer läggs till, kommandot daa. Kommandot påverkar flaggorna OF, SF, ZF, AF, PF och CF. Exempel 1
Mov BX,lFFEh mov CX,3 add BX,CX ;BX=2001h, CX=0003h
Exempel 2 mov AX,25h add AX,12h ;AX=0037h
Exempel 3; I datafälten: mem dw 128 ;I programsegmentet: add mem,100 ;mem=228
Exempel 4 mov AX,0507h ;BCD uppackad 57 add AL,05h ;BCD 5, AX=050Ch aaa ;AX=0602h, BCD 62
Exempel 5 mov AL,57h ;BCD packad 57 add AL,05h ;BCD 5, AL=5Ch daa ;AL=62h, BCD 62
Användningen av 32-bitars operander och ytterligare adresseringslägen för 32-bitars processorer är acceptabel. Exempel
Mov EAX,98765432h add EAX,11111111h ; EAX=A9876543h
OCH Logiskt OCH
Kommandot och utför en logisk (bitvis) multiplikation av den första operanden med den andra. Det ursprungliga värdet på den första operanden (destinationen) går förlorat, ersätts av resultatet av multiplikationen. Den första operanden av kommandot och kan vara ett register (förutom ett segment ett) eller en minnescell, den andra operanden kan vara ett register (förutom ett segment ett), en minnescell eller ett omedelbart värde, men det är inte tillåtet att ange båda operanderna samtidigt som minnesceller. Operander kan vara byte eller ord. Kommandot påverkar flaggorna SF, ZF och PF. Regler för bitvis multiplikation:
Första operandbiten 0101 Andra operandbiten 0011 Resultatbit 0001 Exempel 1 mov AX,0FFEh och AX,5555h ;AX=0554h Exempel 2; I datafälten: mem dw 0С003h ;I programsegmentet: mov AX,700Eh och AX,mem ;AX=4002h
Användningen av 32-bitars operander och ytterligare adresseringslägen för 32-bitars processorer är acceptabel. Exempel
Mov EDX, 0FA8 8 0 0 4 lh och EDX,0FF00000Fh ; EDX = FA000001h
386P+ ARPL
Justerar den begärda väljarbehörighetsnivån
Kommandot aprl jämför väljaren med ett mönster som innehåller den maximalt tillåtna behörighetsnivån (vanligtvis CS-väljaren) och ställer in värdet som ska testas till den lägsta av de två behörighetsnivåerna. Om nivåändringen inte krävs, återställs ZF-flaggan om så krävs, den ställs in. Den första operanden av aprl-instruktionen kan vara ett 16-bitars register eller ett minnesord med en kontrollbar väljare; den andra operanden är ett 16-bitars register med en mönsterväljare. 386+ INbunden
Kontrollerar ett arrayindex för att se om det går utanför arraygränserna
Kommandot bound kontrollerar om det angivna indexet, behandlat som ett signerat tal, ligger inom de gränser som anges av den andra operanden. Om indexet går utanför gränserna för arrayen under eller över, genereras ett avbrott med vektor 5. Den första operanden måste vara ett register som innehåller indexet som kontrolleras, den andra - adressen till ett minnesfält med två gränser för arrayen. kontrolleras. Det bundna kommandot tillåter både 16-bitars och 32-bitars operander (men både den första och andra operanden måste vara av samma typ).
Assemblerare- Monteringsspråk för dummies
Monteringsspråk för dummies.(#2) (C) Mikhail Spitsyn 1995 Flaggor Register "F" för processorn kallas flagga. Vad det är? En flagga är en variabel som kan ha två tillstånd: satt (lika med ett) och nollställt (lika med noll). Därför kan "F"-registret betraktas som en uppsättning av åtta flaggbitar. Vi kan bara använda fyra av dem: nollflaggan, bärflaggan, teckenflaggan och paritetsöverflödesflaggan.Aritmetiska operationer. Aritmetik är en mycket, mycket användbar vetenskap, vi räknar ständigt något: addera, subtrahera, dividera, multiplicera. Vi kommer nu att prata om hur man gör detta i assembler. Vi börjar med det enklaste, att lägga till en till något, till exempel för att registrera "A": **************************** *** ** LD A,NUBER INC A RET ********************************* Som du kan se är det är mycket enkelt för detta finns ett kommando "INC" - inkrement (öka med en), följt av en operand, dvs. några registrerar eller registrerar par: ******************************** INC A INC HL INC H INC DE INC E INC IY INC E INC (HL) INC (IX+N) INC (IY+N) ****************************** ** Om du behöver öka en minnescell med en, bör du göra så här: *********************************** ****** *** LD HL,ADDRES LD IX,ADDRES INC (HL) INC (IX+0) RET RET ********************* **************** ***** Det första alternativet fungerar snabbare och är bekvämare om du arbetar med en minnescell, men om du arbetar i en tabell är det inte ekonomiskt och fult. Jämför: vi måste öka den första, femte och tionde byten i tabellen med en: ******************************* * 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 ******************************** Allt som sagts ovan om en ökning med en är sant och för minskning, d.v.s. för att minska med en: ********************************* DEC A DEC HL DEC L DEC IX DEC H DEC DE DEC E DEC BC DEC D DEC IY DEC C DEC IX DEC B DEC (HL) DEC (IX+N) DEC (IX+N) ********************* *********** Låt oss nu anta att vi behöver öka register "A" inte med ett, utan säg med tio: **************** * *************** LD A,NUMBER ADD A,10 RET ************************* * ****** Du kan lägga till register "A" med ett nummer och andra register och med en minnescell adresserad av registerparen "HL", "IX" och "IY". Du kan också lägga till registerpar med "HL", "IX" och "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 är uppsättningen kommandon ganska stor. När du kör detta kommando kan ett fel uppstå: ********************************* LD A,45 LD B,230 ADD A ,B RET ********************************* Summan av "A" och "B" översteg 255 och därför i "A" " visar det sig inte 275, utan 20 (registret "A" är inte gummi); För att låta oss veta att ett spill har inträffat sätter processorn bärflaggan till ett. Allt som återstår är att kontrollera det. Precis som "INC" har "DEC", har "ADD" också ett "par", detta är "SUB", och det har sina egna egenskaper. Kommandot "SUB" fungerar bara med "A"-registret, så när man skriver minnesminnen för detta kommando, utelämnas "A": ********************* *********** SUB N SUB C SUB A SUB H SUB B SUB D SUB E SUB (HL) SUB (IX+N) SUB (IY+N) ******** * ********************** Kommandot påverkar bärflaggan på samma sätt som "ADD". Förutom kommandoparet "ADD" och "SUB" finns det ytterligare ett par. "ADC"- och "SBC"-kommandona fungerar med hänsyn till bärflaggan, dvs. Vid addering eller subtrahering läggs värdet på bärflaggan till (subtraheras) till resultatet. Det finns två specialkommandon för att ställa in bärflaggan - "SCF" och "CCF". "SCF" - sätt bärflaggan till ett. "CCF" - sätt bärflaggan till noll. ********************************* 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 **************************** **** Och nu exempel på hur kommandona "ADC" och "SBC" fungerar: ****************************** ************* * 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 ******** *********************** Istället för de två kommandona "CCF" och "SBC A,B" du kan du enkelt sätta "SUB B", blir resultatet detsamma . ********************************* 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 framgår av resultaten påverkar bärflaggan väsentligt resultatet av operationen. Vid subtrahering subtraheras det från resultatet och vid addering läggs det till resultatet. Nästan allt har täckts om operationerna för addition och subtraktion nu ska vi prata om division och multiplikation. Tyvärr har SPECCY inga divisions- och multiplikationskommandon, men dessa kommandon kan vara sammansatta av flera andra. Till exempel måste vi multiplicera innehållet i två register - "A" och "C": ****************************** ********** *** LD A,10 LD C,5 LD B,A XOR A LOOP ADD A,C DJNZ LOOP RET *************** ********** ******** I exemplet finns det två nya kommandon - "XOR A" och "DJNZ LOOP". "XOR A" rensar register "A", och kommandot "DJNZ LOOP" upprepar alla kommandon, från kommandot markerat med en etikett (till exempel "LOOP") till kommandot "DJNZ" (följt av samma etikett). ka, som i början av cykeln); antalet repetitioner anges i register "B". Genom att använda det faktum att multiplicering av M med N är att addera talet M till sig själv N gånger, kan du förstå exemplet ovan. Denna fastighet kan även användas för delning. Prova själv.________________________________Andra artiklar i numret:
