Illusztrált oktatóanyag az Assemblerről. Összeszerelési aritmetikai utasítások
Csapat ADC(Add with Carry) a csoporthoz tartozik integer parancsok(vagy bináris)számtan (Bináris aritmetikai utasítások) és végrehajtja két előjeles vagy előjel nélküli operandus egész számának összeadását ( CÉLÉs SRC) És zászlót hordani EFLAGS.CF . Az első operandus ( cél operandus, CÉL) lehet egy változó egy regiszterben vagy a memóriában ( , r16, r32 , r/m8, r/m16, r/m32). Második operandus ( forrás operandus, SRC) - közvetlen jelentése ( imm8, imm16, imm32), egy változó egy regiszterben vagy a memóriában. Ebben az esetben mindkét operandus nem lehet egyszerre változó a memóriában.
Az összeadás eredménye paranccsal ADC az első operandus helyére kerül ( CÉL). Az EFLAGS regiszter jelzői az eredménynek megfelelően kerülnek beállításra.
Közvetlen érték hozzáadásakor imm8 vagy imm16 két- vagy négybájtos operandus esetén az azonnali értéket először előjelbővítjük az első operandus méretére, és csak ezután hajtjuk végre az összeadást.
Csapat ADCáltalában többbájtos vagy többszavas ( több szavas) összeadási műveletek. Ebben az esetben az ADD utasítást követi, amely a többbájtos (többszavas) operandusok alacsony rendű bitjeinek összegét adja vissza, lehetővé téve a átvitel figyelembe vételét a magasabb rendű bitek összeadásakor. Például:
mov edx, 0 ; EDX = 0
mov eax, 0FFFFFFFFh ; Az első 32 bites kiegészítés az EAX-be kerül
add eax, 0FFFFFFFFh ; második 32 bites kiegészítés - 0x FFFFFFFFh, hozzáadunk két 32 bites operandust
adc edx, 0; EDX = EDX + CF, vegye figyelembe az átvitelt
; EDX:EAX = 0000000lh:FFFFFFFEh – a kapott 64 bites eredmény
Csapat ADC lehetővé teszi az egész operandusok kezelését, mint a aláírás nélküli formátum, és be aláírt formátumban. Adatok előjellel történő hozzáadásakor jel zászló Az EFLAGS.SF a kapott eredmény előjelét tükrözi. Túlcsordulás zászló Az EFLAGS.OF 1-re lesz állítva, ha a kettős komplementerben vagy kettős komplementerben reprezentált előjeles egész értékek hozzáadásakor túlcsordulás történik (a legjelentősebb bittől kezdve, amelyhez az előjelbitet megelőző bit tartozik), azaz a az eredmény meghaladja az operandus -appointments ( CÉL). Lényegében ez hasonlít ahhoz, ahogyan az EFLAGS.CF jelző tükrözi a túlcsordulást (carry) a hozzáadásakor előjel nélküli operandusok. Például, ha két 32 bites értéket ad hozzá fordított kódban, ez így nézhet ki:
mov eax, operandus1 ; EAX = operandus1, az első 32 bites kiegészítés az EAX-be kerül
add eax, operandus2 ; két 32 bites operandust adunk hozzá fordított kódban
be ; ugrás a kezelő megszakítására túlcsordulás esetén
adc eax, 0 ; EAX = EAX + CF, vegye figyelembe a hordozást (szükséges a fordított kód hozzáadásához)
; EAX = operandus1 + operandus2 - az összeadás eredménye fordított kódban
jns m1; átmenet, ha az eredmény pozitív
xor eax, 7FFFFFFFFh ; az EAX negatív értékének átalakítása egyenes kódra
m1: ; EAX - az összeadás eredménye a közvetlen kódban
Segéd zászló(vagy további)átruházás Az EFLAGS.AF segít a BCD formátumú adatok kezelésében ( csomagolt BCD formátumban). Akkor van beállítva, ha az összeadás során átvitel történik az eredmény alsó bájtjának alsó tetradjáról a magas tetradjára. A parancsot közvetlenül követő DAA parancs használata ADC, lehetőség van az ún decimális korrekció az összeadás eredményét, és ugyanabban kapjuk meg az összeget csomagolt BCD formátumban, mint az eredeti feltételek.
Csapat ADC cél operandussal ( CÉL), amely egy memóriaváltozó, a LOCK zár előtaggal együtt használható, amely biztosítja a parancs atomi végrehajtását.
Kiegészítő parancsok - ADD, ADC
Az ADD (add) és ADC (add with carry) utasítások 8 és 16 bites operandusokat is hozzáadhatnak.
Az ADD utasítás összeadja a forrás operandus és a cél operandus tartalmát, és az eredményt a cél operandusba helyezi.
Parancs formátum: ADD vevő, forrás
Szimbolikus jelöléssel a cselekményei a következőképpen írhatók le: nyelő:= nyelő + forrás (a süllyesztő és a forrás tartalmának összege a süllyesztőbe van írva).
Az ADC parancs ugyanazt teszi, mint az ADD parancs, de nem két, hanem három kifejezést ad hozzá: a célt, a forrást és a szállítási jelzőt.
Parancs formátum: ADC vevő, forrás + CF
Szimbolikus jelöléssel a cselekvései a következőképpen írhatók le:
mosogató:= mosogató + forrás + szállításjelző tartalma.
A bináris számok összeadásakor történő átvitel hasonló a decimális számok oszlopba történő hozzáadásához. Amikor a számítógép bináris számokat ad össze, és az összeg nem fér bele a cél operandusba, akkor átvitel jön létre. Tudniillik egy 8 bites regiszter 0 és 255 közötti előjel nélküli értékeket tartalmazhat. Ha például végrehajtjuk a 250 és 10 számok bináris összeadását, akkor a következő eredményt kapjuk:
1111 1010; a 250-es szám bináris reprezentációja.
0000 1010 ; a 10-es szám bináris reprezentációja.
1 0000 0100; a 260-al egyenlő összeg bináris ábrázolása.
Az eredmény helyes, de 9 bináris bitet foglal el. Ha 8 bites regisztereket használtunk, akkor az alsó 8 bit a célregiszterbe, a kilencedik bit pedig a CF átviteli jelzőbe kerül.
Most már megértjük, hogy a 8086-os mikroprocesszornak miért van két különböző kiegészítési utasítása. Az egyik (ADD) hozzáadhat bájtokkal vagy szavakkal ábrázolt értékeket, valamint a nagy pontosságú értékek alacsony rendű részeit. Egy másik utasítás (ADC) nagy pontosságú értékek hozzáadására szolgál.
A hozzáadandó operandusok lehetnek memóriában, regiszterben vagy azonnali értékűek. Például:
ADD AX,MEM_WORD; a memóriacella tartalmának hozzáadása egy regiszterhez,
ADD MEM_WORD,AX; vagy fordítva, adja hozzá a regiszter tartalmát a memóriacellához.
ADD AL, 10; adjunk hozzá egy konstanst a regiszter tartalmához.
ADD MEM_BYTE,8H; add hozzá az állandót és a memóriacella tartalmát.
A legtöbb lehetséges kombináció megengedett, de ez tiltott add hozzá két memóriacella tartalmát, vagy használj közvetlen értéket (számot) vevőként.
Az ADD és ADC parancsok a következő hat jelzőt érinthetik:
zászlót hordani CF 1, ha az összeadás eredménye nem fér bele a cél operandusba, ellenkező esetben 0;
paritás zászló PF 1, ha az eredmény páros számú bitet tartalmaz 1 értékkel, ellenkező esetben 0;
Az AF egyenlő 1-gyel, ha a decimális számok összeadásának eredménye javítást igényel;
nulla zászló ZF értéke 1, ha az eredmény 0;
jel zászló Az SF 1, ha az eredmény negatív (a legjelentősebb bit 1), ellenkező esetben 0;
túlcsorduló zászló OF egyenlő 1-gyel, ha két azonos előjelű szám összege meghaladja a vevő elfogadható értéktartományát a fordított kódban, és maga a vevő előjelet vált. Ellenkező esetben az OF jelzője 0.
Parancs a vevő értékének eggyel növelésére - INC
Csapat INC(növekmény) 1-et ad egy regiszter vagy memóriacella tartalmához, de az ADD utasítással ellentétben nem befolyásolja a CF átviteli jelzőt. Parancs formátum: INC vevő.
Az INC parancs hasznos az utasításhurkok számlálóinak növeléséhez. A szekvenciális memóriacellák elérésekor az indexregiszter értékének növelésére is használható. Az operandust előjel nélküli számként értelmezi.
Például:
INC CX; növelje a 16 bites értékét
INC AL; vagy 8 bites regiszter egységenként.
INC MEM_BYTE; növelje a bájt értékét
INC MEM_WORD; vagy memóriaszavak egységenként.
Nem szabad azonnali értéket operandusként használni.
Kivonási parancsok - SUB, és kivonás SBB kölcsönzésével
Csapatok ALATTI(kivonás - kivonás) és SBB(kivonás kölcsönnel) hasonlóak az ADD és ADC összeadás parancsokhoz, csak kivonáskor a CF carry flag a kölcsön jeleként működik. Parancs formátum: SUB vevő, forrás;
A SUB parancs kivonja a forrás operandust a cél operandusból, és az eredményt a célba helyezi, szimbolikus jelöléssel:
mosogató:= mosogató – forrás.
Csapat SBB ugyanezt teszi, de emellett levonja a CF átviteli jelzőjének értékét a vevőből:
SUB vevő, forrás – CF;
Cél:= nyelő - forrás - a hordozásjelző tartalma.
A kiegészítéshez hasonlóan a SUB és SBB utasítások két külön funkciót látnak el. Az első parancs kivonja a bájt- vagy szóméretű számokat, valamint a nagy pontosságú számok alacsony rendű bitjeit (a szám alacsonyabb rendű része az AX regiszterben, a magasabb rendű része pedig a DX regiszter). A második parancs kivonja a nagy pontosságú számok legjelentősebb bitjeit. Például a SUB AX,CX; Kivonja a CX regiszter tartalmát az AX regiszter tartalmából, és az eredményt visszaadja az AX regiszternek.
Ha az operandusok mérete meghaladja a 16 bitet, akkor a következő parancssort kell használni:
SUB AX,CX; Kivonás alacsony 16 bit;
SBB BX,DX; majd a legjelentősebb 16 bitet.
Itt az AX és BX regiszterekben elhelyezett 32 bites számból kivonjuk a CX és DX regiszterekben található 32 bites számokat. A DX regiszter tartalmának a BX regiszter tartalmából történő kivonásakor az SBB utasítás az első kivonás végrehajtásakor figyelembe veszi a kölcsönzés lehetőségét.
SUB AX, MEM; Vonjuk ki a memóriacella tartalmát egy regiszterből.
SUB MEM ,AX; Vonjunk ki egy regisztert egy memóriacellából.
SUB AL,1O; Vonjunk ki egy állandót egy regiszterből.
SUB MEM_BYTE,OFh; Vonjunk ki egy állandót egy memóriacellából.
Nem lehet közvetlenül kivonni az egyik memóriacella tartalmát a másikból, vagy használja a közvetlen értéket célként.
A SUB és SBB parancsok hat jelzőt érinthetnek az alábbiak szerint:
· telepítés zászlót hordani CF 1, ha kölcsön szükséges, ellenkező esetben 0;
· telepítés paritás zászló PF 1, ha a kivonás eredménye páros számú 1 értékű bitet tartalmaz, ellenkező esetben 0;
· telepítés kisegítő hordzászló Az AF 1, ha a decimális kivonás eredménye korrekciót igényel, ellenkező esetben 0;
· telepítés nulla zászló ZF 1-re, ha az eredmény 0, ellenkező esetben 0;
· telepítés jel zászló Az SF 1, ha az eredmény negatív (a legjelentősebb bit 1), ellenkező esetben a jelző 0;
· telepítés túlcsorduló zászló OF 1, ha a kivonás eredménye meghaladja a vevőértékek tartományát a fordított kódban, és maga a vevő előjelet vált.
Az SF és OF jelzőknek csak előjeles számok kivonásakor van értelme, az AF jelzőnek pedig csak decimális számok kivonásakor.
Cél tartalom csökkentése parancs - DEC
Csapat DEC vevő(decrement) kivon 1-et egy regiszter vagy memóriahely tartalmából, de (a SUB utasítással ellentétben) nem befolyásolja a CF átviteli jelzőt.
A DEC utasítást gyakran használják ciklusokban a számláló értékének csökkentésére, amíg az nulla vagy negatív lesz. Használható egy indexregiszter vagy mutató értékének csökkentésére is, amikor szekvenciális memóriahelyeket ér el. Például:
DEC CX; 16 bites érték csökkentése,
DEC AL; vagy 8 bites regiszter.
DEC MEM_BYTE; A bájt értékének csökkentése,
DEC MEM_WORD; vagy szómemória cella.
Felosztási utasítások - DIV, IDIV
Csapat DIV(oszt - oszt) végrehajtja a számok előjel nélküli felosztását, és a parancsot IDIV(integer oszt – egész számokat oszt) a számok előjeles felosztását hajtja végre. Ezeknek a parancsoknak a formátuma:
DIV forrás; Ahol forrás- bájt vagy szóméret osztója,
IDIV forrás;egy általános célú regiszterben vagy memóriahelyen található.
Kérlek vegyed figyelembe a következőt:
1. Az osztaléknak kétszeresnek kell lennie az osztóhoz képest.
2. Az osztaléknak mindig az AX regiszterben (8 bites számmal való osztásakor) vagy a DX és AX regiszterben (16 bites számmal való osztásakor) kell lennie.
3. A parancs eredménye a következőképpen jelenik meg:
· ha a forrás operandus egy bájt, akkor a hányados az AL regiszterbe, a maradék pedig az AN regiszterbe kerül vissza;
· Ha a forrás operandus egy szó, akkor a hányados az AX regiszterbe, a maradék pedig a DX regiszterbe kerül vissza.
Mindkét utasítás definiálatlanul hagyja a flagek állapotát, de ha a hányados nem fér bele a célregiszterbe (AL vagy AX), akkor a mikroprocesszor 0 típusú megszakítást generál (0-val osztás).
4. Az osztási eredmény túlcsordulása a következő feltételek mellett fordul elő:
· az osztó 0;
· bájtok előjel nélküli osztásakor az osztó legalább 256-szorosa;
· szavak előjel nélküli osztásakor az osztó legalább 65 536-szorosa az osztónak;
· a bájtok előjellel történő osztásakor a hányados a -128 és +127 közötti tartományon kívül esik;
· ha a szavakat előjellel osztjuk fel, a hányados kívül esik a -tól tartományon
32768-32767.
Íme néhány tipikus példa az osztási műveletekre:
DIV BX; A DX:AX elosztása BX-szel, előjel nélküli.
DIV MEM_BYTE; Ossza fel az AX-et egy bájt memóriára, előjel nélküli.
IDIV DL; Ossza el az AX-t DL-lel egy előjellel.
IDIV MEM WORD; Ossza fel a DX:AX-et egy előjeles memóriaszóra.
A DIV és IDIV utasítások nem osztanak közvetlenül az azonnali értékkel, mert a processzor nem tudja meghatározni az osztó adattípusát.
Szorzási utasítások - MUL, IMUL
Csapat MUL(szoroz) előjel nélküli számokat szoroz, a IMUL(integer szorzás) előjeles egész számokat szoroz. Mindkét utasítás szorzójának és szorzójának azonos adattípusúnak kell lennie, azaz bájtok, szavak, duplaszavak stb.
Ezeknek a parancsoknak a formátuma a következő:
MUL forrás; Ahol forrás- általános célú nyilvántartás,
IMUL forrás; vagy egy bájt vagy szó méretű memóriacella.
Első operandusként (szorozható) a MUL és IMUL utasítások az AL regiszter tartalmát (bájtokkal végzett műveletekhez) vagy az AX regisztert (szavakkal végzett műveletekhez) használják. A termék dupla méretű, visszaküldése az alábbiak szerint történik:
· szorzás bájtok-visszaadja a 16 bites terméket az AN (high byte) és AL (low byte) regiszterekbe;
· szorzás szavak-visszaadja a 32 bites terméket a DX (magas szó) és AX (alacsony szó) regiszterekbe. Így a termék mérete n- bittényezők egyenlőek 2n.
ADC Integer összeadás átvitellel
Csapat adc elvégzi az első és a második operandus összeadását, hozzáadva az eredményhez a CF átviteli jelző értékét. Az első operandus (cél) eredeti értéke elvész, helyébe az összeadás eredménye lép. A második operandus változatlan. A parancs első operandusaként adc
Az operandusok lehetnek bájtok vagy szavak, és előjeles vagy előjel nélküli számokat jelenthetnek. Csapat adc(a csapattal együtt add hozzá) általában 32 bites számok hozzáadására szolgál. A parancs az OF, SF, ZF, AF, PF és CF jelzőket érinti.
1. példa:
Mov AX,1125h adc AX,2C25h; AX=3D4Bh, ha CF = 1; AX=3D4Ah, ha CF = 0
2. példa:
; Az adatmezőkben: numlow dw 0FFFFh; A 2. tag alacsony része numhigh dw 000Sh; A 2. tag legmagasabb része;Szám 0005FFFFh=393215;A programszegmensben: mov AX,000Sh; Alacsony rendű része az 1. term mov BX,0002h; Az 1. tag legmagasabb része;Szám 00020005h=131077 add AX,numlow; Junior részek hozzáadása. AX=4, CF=1 adc BX, numhigh; Magasabb alkatrészek hozzáadása hordozóval. BX:AX=0008:0004h. ;Szám 00080004h=524292
A 32 bites operandusok és a 32 bites processzorok további címzési módjai elfogadhatók. Csapat adc 32 bites operandusokkal 64 bites egész számok hozzáadására használható.
Példa:
; Az adatmezőkben mem321 dd 0FFFFFFFFh; Alacsony rendű rész az 1. term mem32h dd 98765432h; Az 1. ciklus legmagasabb része; A programszegmensben mov EAX,1; Alacsony rendű része a 2. tag mov EBX,0; A 2. tag legmagasabb része EAX,mem321; Adja hozzá az alsó feleket;Sum=100000000h>32 bit;EAX=000000h, carry adc EBX,mem32h; Hajtsa össze a régebbi feleket, és vigye át. EBX=90000001h; Összeg: 9876543300000000h
ADD Egész szám összeadás
Csapat add hozzá elvégzi az első és a második operandus összeadását. Az első operandus (cél) eredeti értéke elvész, helyébe az összeadás eredménye lép. A második operandus változatlan. A parancs első operandusaként add hozzá Megadhat regisztert (kivéve egy szegmenst) vagy memóriacellát, a második lehet regiszter (a szegmens kivételével), memóriacella vagy azonnali érték, de nem szabad mindkét operandust egyszerre memóriaként megadni. sejteket.
Az operandusok lehetnek bájtok vagy szavak, és előjeles vagy előjel nélküli számokat jelenthetnek. Az add paranccsal normál egészek és bináris decimális számok is hozzáadhatók (az eredmény tárolására az AX regiszter használatával). Ha kicsomagolt binárisan kódolt decimális (BCD) számokat ad hozzá, a parancs után add hozzá az aaa parancsot kell használni; ha csomagolt számokat adunk hozzá, akkor a parancsot igen. A parancs az OF, SF, ZF, AF, PF és CF jelzőket érinti.
1. példa:
Mov BX,lFFEh mov CX,3 add BX,CX; BX=2001h, CX=0003h
2. példa:
Mov AX,25h add AX,12h; AX=0037h
3. példa:
; Az adatmezőkben: mem dw 128 ;A programszegmensben: add mem,100; mem=228
ADC Integer összeadás átvitellel
Az adc parancs hozzáadja az első és a második operandust, hozzáadva az eredményhez a CF carry flag értékét. Az első operandus (cél) eredeti értéke elvész, helyébe az összeadás eredménye lép. A második operandus változatlan. Az adc utasítás első operandusa lehet regiszter (kivéve szegmens) vagy memóriacella, a második operandus lehet regiszter (szegmens kivételével), memóriacella vagy azonnali érték, de nem megengedett mindkét operandus egyidejűleg memóriacellaként. Az operandusok lehetnek bájtok vagy szavak, és előjeles vagy előjel nélküli számokat jelenthetnek. Az adc parancsot (az add paranccsal együtt) általában 32 bites számok hozzáadására használják. A parancs az OF, SF, ZF, AF, PF és CF jelzőket érinti.
1. példa
Mov AX,1125h adc AX,2C25h ;AX=3D4Bh, ha CF = 1 ;AX=3D4Ah, ha CF = 0
2. példa; Az adatmezőkben: numlow dw 0FFFFh ;A 2. tag alsó része numhigh dw 000Sh ;A 2. tag magas része;Szám 0005FFFFh=393215 ;A programszegmensben: mov AX,000Sh ;A BX1.tag alsó része mov 0002h Az 1. tag legmagasabb része;Szám 00020005h=131077 add AX,numlow;Az alsó részek hozzáadása. AX=4, CF=1 adc BX, numhigh ;Magasabb alkatrészek hozzáadása;transzfer.BX:AX=0008:0004h. ;Szám 00080004h=524292
A 32 bites operandusok és a 32 bites processzorok további címzési módjai elfogadhatók. A 32 bites operandusokat tartalmazó adc utasítás 64 bites egész számok hozzáadására használható. 3. példa; Az adatmezőkben mem321 dd 0FFFFFFFFh ;Az 1. tag alsó része mem32h dd 98765432h ;Az 1. tag magas része; A programszegmensben mov EAX,1 ;A 2. tag alsó része mov EBX,0 ;A 2. tag magas része add EAX,mem321 ;Add hozzá az alsó feleket;Sum=100000000b>32 bit;EAX=000000h, carry adc EBX,mem32h ;Add hozzá a régebbi feleket és tedd át. EBX=90000001h ;Összeg: 9876543300000000h
ADD Egész szám összeadás
Az add parancs hozzáadja az első és a második operandust. Az első operandus (cél) eredeti értéke elvész, helyébe az összeadás eredménye lép. A második operandus változatlan. Az add parancs első operandusa megadható regiszterként (egy szegmens kivételével) vagy memóriacellaként, a második operandus pedig lehet regiszter (egy szegmens kivételével), memóriacella vagy azonnali érték, de nem definiálhatja egyszerre mindkét operandust memóriacellaként. Az operandusok lehetnek bájtok vagy szavak, és előjeles vagy előjel nélküli számokat jelenthetnek. Az add paranccsal normál egészek és bináris decimális számok is hozzáadhatók (az eredmény tárolására az AX regiszter használatával). Kicsomagolt bináris kódolt decimális (BCD) számok hozzáadásakor használja az aaa parancsot az add parancs után; ha csomagolt számokat adunk hozzá, akkor a daa parancsot. A parancs az OF, SF, ZF, AF, PF és CF jelzőket érinti. 1. példa
Mov BX,lFFEh mov CX,3 add BX,CX ;BX=2001h, CX=0003h
2. példa mov AX,25h add AX,12h ;AX=0037h
3. példa; Az adatmezőkben: mem dw 128 ;A programszegmensben: add mem,100 ;mem=228
4. példa mov AX,0507h ;BCD kicsomagolva 57 add AL,05h ;BCD 5, AX=050Ch aaa ;AX=0602h, BCD 62
5. példa mov AL,57h ;BCD csomagolt 57 add AL,05h ;BCD 5, AL=5Ch daa ;AL=62h, BCD 62
A 32 bites operandusok és a 32 bites processzorok további címzési módjai elfogadhatók. Példa
Mov EAX,98765432h add EAX,11111111h ; EAX=A9876543h
ÉS Logikai ÉS
Az and parancs végrehajtja az első operandus logikai (bitenkénti) szorzását a másodikkal. Az első operandus (cél) eredeti értéke elvész, helyébe a szorzás eredménye kerül. Az and parancs első operandusa lehet regiszter (kivéve egy szegmens) vagy memóriacella, a második operandus lehet regiszter (a szegmens kivételével), memóriacella vagy azonnali érték, de nem megengedett mindkét operandust egyszerre adja meg memóriacellaként. Az operandusok lehetnek bájtok vagy szavak. A parancs az SF, ZF és PF jelzőket érinti. A bitenkénti szorzás szabályai:
Első operandus bit 0101 Második operandus bit 0011 Eredmény bit 0001 1. példa mov AX,0FFEh és AX,5555h ;AX=0554h 2. példa; Az adatmezőkben: mem dw 0С003h ;A programszegmensben: mov AX,700Eh és AX,mem ;AX=4002h
A 32 bites operandusok és a 32 bites processzorok további címzési módjai elfogadhatók. Példa
Mov EDX, 0FA8 8 0 0 4 lh és EDX,0FF00000Fh ; EDX = FA000001h
386P+ ARPL
A kért kiválasztó jogosultsági szint beállítása
Az aprl parancs összehasonlítja a választót a maximális engedélyezett jogosultsági szintet tartalmazó mintával (általában a CS választóval), és a tesztelendő értéket a két jogosultsági szint közül az alacsonyabbra állítja. Ha a szintváltás nem szükséges, a ZF jelző visszaállításra kerül, ha szükséges, akkor be van állítva. Az aprl utasítás első operandusa lehet egy 16 bites regiszter vagy egy memóriaszó, ellenőrizhető szelektorral; a második operandus egy 16 bites regiszter mintaválasztóval. 386+ KÖTÖTT
Egy tömbindex ellenőrzése a határokon kívül eső tömbért
A bound parancs ellenőrzi, hogy az előjeles számként kezelt megadott index a második operandus által meghatározott határokon belül van-e. Ha az index túllép a tömb alatti vagy feletti határain, akkor egy megszakítás jön létre 5-ös vektorral. Az első operandusnak egy regiszternek kell lennie, amely az ellenőrzött indexet tartalmazza, a másodiknak pedig a tömb két határával rendelkező memóriamező címét. ellenőrzés alatt áll. A bound parancs 16 bites és 32 bites operandusokat is engedélyez (de az első és a második operandusnak is azonos típusúnak kell lennie).
Szerelő- Összeszerelési nyelv próbabábukhoz
Összeszerelési nyelv próbabábukhoz.(#2) (C) Mikhail Spitsyn 1995 Zászlók A processzor "F" regiszterét flag-nek nevezik. Ami? A zászló egy változó, amelynek két állapota lehet: beállítva (egyenlő eggyel) és törölve (nullával egyenlő). Ezért az "F" regiszter nyolc jelzőbitből álló halmazként fogható fel. Ezek közül csak négyet használhatunk: a nulla jelzőt, a hordozó jelzőt, a jeljelzőt és a paritás-túlcsordulás jelzőt.Aritmetikai műveletek. Az aritmetika nagyon-nagyon hasznos tudomány, folyamatosan számolunk valamit: összeadunk, kivonunk, osztunk, szorozunk. Most arról fogunk beszélni, hogyan kell ezt megtenni az assemblerben. Kezdjük a legegyszerűbb dologgal, hozzáadunk egyet valamihez, például az "A" bejegyzéshez: **************************** *** ** LD A,NUBER INC A RET ************************************ Amint látja, nagyon egyszerű ehhez van egy "INC" - increment (egygyel növelés) parancs, amit egy operandus követ, azaz. néhány regiszter vagy regiszterpár: ************************************ INC A INC HL INC H INC DE INC E INC IY INC E INC (HL) INC (IX+N) INC (IY+N) ********************************** ** Ha bármelyik memóriacellát eggyel kell növelni, akkor ezt tegye: ********************************* ****** *** LD HL,CÍM LD IX,ADDRES INC (HL) INC (IX+0) RET RET ********************* **************** ***** Az első opció gyorsabban működik és kényelmesebb, ha egy memóriacellával dolgozik, de ha táblázatban dolgozik, akkor nem gazdaságos és csúnya. Hasonlítsa össze: növelnünk kell a táblázat első, ötödik és tizedik bájtját eggyel: *********************************** * 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 ************************************ Mindaz igaz, amit fentebb az eggyel történő emelésről mondtam, és csökkentésére, azaz eggyel csökkenteni: ************************************ 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) ********************* *********** Most tegyük fel, hogy az „A” regisztert nem eggyel kell növelnünk, hanem mondjuk tízzel: **************** * ************** LD A, SZÁM ADD A, 10 RET ************************* * ****** Hozzáadhatja az "A" regisztert számmal és egyéb regiszterekkel, valamint a "HL", "IX" és "IY" regiszterpárok által címzett memóriacellával. A "HL", "IX" és "IY" regiszterpárokat is hozzáadhatja. (PureBasic - fájlrendszer) ************************************ 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 ******************************* ** Mint látható, a parancsok halmaza meglehetősen nagy. A parancs végrehajtásakor hiba léphet fel: ************************************ LD A,45 LD B,230 ADD A ,B RET ************************************ Az "A" és a "B" összege meghaladta a 255-öt és ezért az "A"-ban nem 275, hanem 20 derül ki (az "A" regiszter nem gumi); Túlcsordulás jelzésére a processzor az átviteli jelzőt egy értékre állítja. Nem marad más hátra, mint ellenőrizni. Ahogy az "INC"-nek "DEC", az "ADD"-nek is van "párja", ez a "SUB", és megvannak a maga sajátosságai. A "SUB" parancs csak az "A" regiszterrel működik, ezért a parancs mnemonikájának írásakor az "A" kimarad: ********************* *********** SUB N SUB C SUB A SUB H SUB B SUB D SUB E SUB (HL) SUB (IX+N) SUB (IY+N) ******** * ********************** A parancs ugyanúgy érinti a szállítási jelzőt, mint az „ADD”. Az "ADD" és "SUB" parancspáron kívül van még egy pár. Az "ADC" és az "SBC" parancsok a carry flag figyelembevételével működnek, pl. Összeadáskor vagy kivonáskor a carry flag értéke hozzáadódik (kivonódik) az eredményhez. Két speciális paranccsal lehet beállítani a átviteli jelzőt: "SCF" és "CCF". "SCF" - állítsa a átviteli jelzőt egyre. "CCF" - állítsa a szállítási jelzőt nullára. ******************************** 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 ******************************** **** És most példák az „ADC” és „SBC” parancsok működésére: ********************************* ** * 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 ****** * *************************** A két „CCF” és „SBC A,B” parancs helyett egyszerűen beírhatja a „SUB B” parancsot, az eredmény ugyanaz lesz. ******************************** 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 ******************************** **** Amint az eredményekből látható, a carry flag jelentősen befolyásolja a művelet eredményét. Kivonáskor az eredményből kivonjuk, összeadáskor pedig hozzáadjuk az eredményhez. Szinte mindent leírtunk az összeadás és kivonás műveleteiről, most az osztásról és a szorzásról fogunk beszélni. Sajnos a SPECCY nem rendelkezik osztási és szorzási parancsokkal, de ezek a parancsok több másból is összeállíthatók. Például meg kell szoroznunk két regiszter - „A” és „C” - tartalmát: ********************************* ********** *** LD A,10 LD C,5 LD B,A XOR A LOOP ADD A,C DJNZ LOOP RET **************** ********** ******* A példában két új parancs található: „XOR A” és „DJNZ LOOP”. Az "XOR A" törli az "A" regisztert, és a "DJNZ LOOP" parancs megismétli az összes parancsot, a címkével jelölt parancstól (például "LOOP") a "DJNZ" parancsig (ugyanaz a címke követi). ka, mint a ciklus elején); az ismétlések számát a "B" regiszter határozza meg. Abból a tényből, hogy M-et N-vel megszorozva N-szer hozzáadjuk az M számot önmagához, megérthetjük a fenti példát. Ez az ingatlan felosztásra is használható. Próbáld ki magad.________________________________További cikkek a lapszámban:
