Ilustrēta apmācība par Assembler. Montāžas aritmētiskās instrukcijas
Komanda ADC(Pievienot ar Carry) pieder grupai veselu skaitļu komandas(vai binārs)aritmētika (Binārās aritmētiskās instrukcijas) un veic divu parakstītu vai neparakstītu operandu veselu skaitļu pievienošanu ( MĒRĶA Un SRC) Un nēsāt karogu EFLAGS.CF . Pirmais operands ( galamērķa operands, MĒRĶA) var būt mainīgais reģistrā vai atmiņā ( , r16, r32 , r/m8, r/m16, r/m32). Otrais operands ( avota operands, SRC) - tūlītēja nozīme ( imm8, imm16, imm32), mainīgais reģistrā vai atmiņā. Šajā gadījumā abi operandi nevar vienlaikus būt mainīgie atmiņā.
Papildināšanas rezultāts pēc komandas ADC tiek novietots pirmā operanda vietā ( MĒRĶA). Karogi EFLAGS reģistrā tiek iestatīti atbilstoši rezultātam.
Pievienojot tiešu vērtību imm8 vai imm16 ar divu vai četru baitu operandu tūlītējā vērtība vispirms tiek izvērsta līdz pirmā operanda izmēram un tikai pēc tam tiek veikta pievienošana.
Komanda ADC parasti izmanto vairākos baitos vai vairākos vārdos ( vairāku vārdu) pievienošanas darbības. Šajā gadījumā tas seko ADD instrukcijai, kas atgriež daudzbaitu (vairāku vārdu) operandu zemas kārtas bitu summu, ļaujot ņemt vērā pārnešanu, pievienojot augstākās kārtas bitus. Piemēram:
mov edx, 0; EDX = 0
mov eax, 0FFFFFFFFh ; Pirmais 32 bitu papildinājums tiek ievietots EAX
pievienot eax, 0FFFFFFFFh ; otrais 32 bitu papildinājums - 0x FFFFFFFFh, mēs pievienojam divus 32 bitu operandus
adc edx, 0; EDX = EDX + CF, ņem vērā pārnešanu
; EDX:EAX = 0000000lh:FFFFFFFEh — iegūtais 64 bitu rezultāts
Komanda ADCļauj manipulēt ar veselu skaitļu operandiem, kā norādīts neparakstīts formāts, un iekšā parakstīts formāts. Pievienojot datus ar zīmi zīmes karogs EFLAGS.SF atspoguļos iegūtā rezultāta zīmi. Pārpildes karogs EFLAGS.OF tiks iestatīts uz 1, ja, pievienojot zīmju veselu skaitļu vērtības, kas attēlotas divu vai divu papildinājumā, notiek pārpilde (kas tiek pārnesta no visnozīmīgākā bita, kuram atbilst bits pirms zīmes bita), tas ir, iegūtais rezultāts pārsniedz pieejamo operanda -appointments ( MĒRĶA). Būtībā tas ir līdzīgs tam, kā karodziņš EFLAGS.CF atspoguļo pārplūdi (pārnēsāšanu), pievienojot neparakstīti operandi. Piemēram, pievienojot divas 32 bitu vērtības, kas attēlotas apgrieztā kodā, tas varētu izskatīties šādi:
mov eax, operand1 ; EAX = operand1, pirmais 32 bitu papildinājums tiek ievietots EAX
pievienot eax, operand2 ; mēs pievienojam divus 32 bitu operandus apgrieztā kodā
iekšā ; lēkt, lai pārtrauktu apstrādātāju pārplūdes gadījumā
adc eax, 0 ; EAX = EAX + CF, ņemiet vērā pārnēsāšanu (nepieciešams pievienot apgrieztā kodā)
; EAX = operand1 + operand2 - saskaitīšanas rezultāts apgrieztā kodā
jns m1; pāreju, ja rezultāts ir pozitīvs
xor eax, 7FFFFFFFFh ; negatīvās vērtības pārvēršana EAX par taisnu kodu
m1: ; EAX - pievienošanas rezultāts tiešā kodā
Palīgkarogs(vai papildu)nodošana EFLAGS.AF palīdz manipulēt ar datiem BCD formātā ( iepakots BCD formāts). Tas tiek iestatīts, ja pievienošanas laikā notiek pārnešana no rezultāta zemākā baita uz augstāko tetradu. Izmantojot komandu DAA tūlīt pēc komandas ADC, iespējams ražot t.s decimālā korekcija saskaitīšanas rezultātu un iegūstiet summu tādā pašā veidā iepakots BCD formāts, tāpat kā sākotnējie noteikumi.
Komanda ADC ar mērķa operandu ( MĒRĶA), kas ir atmiņas mainīgais, var izmantot kopā ar LOCK bloķēšanas prefiksu, kas nodrošinās komandas atomu izpildi.
Papildināšanas komandas - ADD, ADC
Instrukcijas ADD (pievienošana) un ADC (pievienošana ar pārnešanu) var pievienot gan 8, gan 16 bitu operandus.
ADD instrukcija pievieno avota operanda un mērķa operanda saturu un ievieto rezultātu mērķa operandā.
Komandas formāts: ADD uztvērējs, avots
Simboliskā apzīmējumā tās darbības var raksturot šādi: izlietne:= izlietne + avots (izlietnē tiek ierakstīta izlietnes satura un avota summa).
ADC komanda dara to pašu, ko ADD komanda, taču pievieno nevis divus, bet trīs terminus: galamērķis, avots un pārnēsāšanas karodziņš.
Komandas formāts: ADC uztvērējs, avots + CF
Simboliskā apzīmējumā tās darbības var raksturot šādi:
izlietne:= izlietne + avots + pārnēsāšanas karoga saturs.
Pārnešana, pievienojot bināros skaitļus, ir līdzīga nēsāšanai, pievienojot kolonnai decimālskaitļus. Kad dators pievieno bināros skaitļus un summa neietilpst mērķa operandā, tiek ģenerēts pārnesums. Kā zināms, 8 bitu reģistrā var būt neparakstītas vērtības diapazonā no 0 līdz 255. Ja mēs, piemēram, veiksim skaitļu 250 un 10 bināro saskaitīšanu, iegūsim šādu rezultātu:
1111 1010; skaitļa 250 binārais attēlojums.
0000 1010 ; skaitļa 10 binārais attēlojums.
1 0000 0100; summas, kas vienāda ar 260, binārais attēlojums.
Rezultāts ir pareizs, bet aizņem 9 bināros bitus. Ja tika izmantoti 8 bitu reģistri, tad zemākie 8 biti tiks ievadīti mērķa reģistrā, bet devītais bits - pārnēsāšanas karogā CF.
Tagad mēs saprotam, kāpēc 8086 mikroprocesoram ir divas dažādas pievienošanas instrukcijas. Viens no tiem (ADD) var pievienot vērtības, kas attēlotas ar baitiem vai vārdiem, kā arī augstas precizitātes vērtību apakšējās daļas. Lai pievienotu augstas precizitātes vērtības, tiek izmantota cita instrukcija (ADC).
Pievienojamie operandi var būt atmiņā, reģistrā vai tiem var būt tūlītēja vērtība. Piemēram:
PIEVIENOT AX,MEM_WORD; pievienot reģistram atmiņas šūnas saturu,
PIEVIENOT MEM_WORD,AX; vai otrādi, pievienojiet reģistra saturu atmiņas šūnai.
PIEVIENOT AL, 10; pievienot reģistra saturam konstanti.
PIEVIENOT MEM_BYTE, 8H; pievienojiet konstanti un atmiņas šūnas saturu.
Vairums iespējamo kombināciju ir atļautas, bet tas ir aizliegts pievienojiet divu atmiņas šūnu saturu vai izmantojiet tiešo vērtību (skaitli) kā uztvērēju.
Komandas ADD un ADC var ietekmēt šādus sešus karogus:
nēsāt karogu CF ir 1, ja saskaitīšanas rezultāts neietilpst mērķa operandā, pretējā gadījumā tas ir 0;
paritātes karogs PF ir 1, ja rezultātam ir pāra skaits bitu ar vērtību 1, pretējā gadījumā tas ir 0;
AF ir vienāds ar 1, ja decimālskaitļu saskaitīšanas rezultāts ir jālabo;
nulles karogs ZF ir 1, ja rezultāts ir 0;
zīmes karogs SF ir 1, ja rezultāts ir negatīvs (visnozīmīgākais bits ir 1), pretējā gadījumā tas ir 0;
pārplūdes karogs OF ir vienāds ar 1, ja divu vienas zīmes skaitļu summa pārsniedz uztvērēja pieņemamo vērtību diapazonu apgrieztā kodā, un pats uztvērējs maina zīmi. Pretējā gadījumā OF karogs ir 0.
Komanda palielināt uztvērēja vērtību par vienu - INC
Komanda INC(pieaugums) pievieno 1 reģistra vai atmiņas šūnas saturam, taču atšķirībā no ADD instrukcijas tas neietekmē pārnēsāšanas karogu CF. Komandas formāts: INC uztvērējs.
INC instrukcija ir noderīga, lai palielinātu skaitītājus instrukciju cilpās. To var arī izmantot, lai palielinātu indeksa reģistra vērtību, piekļūstot secīgām atmiņas šūnām. Operands tiek interpretēts kā neparakstīts skaitlis.
Piemēram:
INC CX; palielināt 16 bitu vērtību
INC AL; vai 8 bitu reģistrs uz vienību.
INC MEM_BYTE; palielināt baita vērtību
INC MEM_WORD; vai atmiņas vārdi par vienību.
Kā operandu nav atļauts izmantot tūlītēju vērtību.
Atņemšanas komandas - SUB, un atņemšana ar aizņēmumu SBB
Komandas SUB(atņemt - atņemt) un SBB(atņemt ar aizņemšanos) ir līdzīgas saskaitīšanas komandām attiecīgi ADD un ADC, tikai atņemot, pārnēsāšanas karodziņš CF darbojas kā aizdevuma zīme. Komandas formāts: SUB uztvērējs, avots;
Komanda SUB atņem avota operandu no mērķa operanda un ievieto rezultātu galamērķī ar simbolisku apzīmējumu:
izlietne:= izlietne – avots.
Komanda SBB dara to pašu, bet papildus atņem no uztvērēja CF pārnešanas karoga vērtību:
SUB uztvērējs, avots – CF;
Galamērķis:= izlietne - avots - pārnēsāšanas karoga saturs.
Tāpat kā pievienošana, SUB un SBB instrukcijas veic divas atsevišķas funkcijas. Pirmā komanda atņem baitu vai vārda lieluma skaitļus, kā arī augstas precizitātes skaitļu zemās kārtas bitus (skaitļa zemās kārtas daļa atrodas AX reģistrā, bet augstākās kārtas daļa atrodas DX reģistrs). Otrā komanda atņem nozīmīgākos augstas precizitātes skaitļu bitus. Piemēram, komanda SUB AX,CX; Atņem CX reģistra saturu no AX reģistra satura un atgriež rezultātu AX reģistrā.
Ja operandu izmēri pārsniedz 16 bitus, tad jāizmanto šāda komandu secība:
SUB AX, CX; Atņemt zemo 16 bitus;
SBB BX, DX; un tad nozīmīgākie 16 biti.
Šeit mēs atņemam no 32 bitu skaitļa, kas ievietots AX un BX reģistros, 32 bitu numuru, kas atrodas CX un DX reģistros. Atņemot DX reģistra saturu no BX reģistra satura, SBB instrukcija ņem vērā iespēju aizņemties, veicot pirmo atņemšanu.
SUB AX, MEM; Atņemiet no reģistra atmiņas šūnas saturu.
SUB MEM, AX; Atņemiet reģistru no atmiņas šūnas.
SUB AL,1O; Atņemiet konstanti no reģistra.
SUB MEM_BYTE,OFh; Atņemiet konstanti no atmiņas šūnas.
Nevar tieši atņemt vienas atmiņas šūnas saturu no citas vai izmantojiet tūlītējo vērtību kā galamērķi.
SUB un SBB komandas var ietekmēt sešus karogus šādi:
· uzstādīt nēsāt karogu CF ir 1, ja nepieciešams aizdevums, pretējā gadījumā tas ir 0;
· uzstādīt paritātes karogs PF ir 1, ja atņemšanas rezultātā ir pāra bitu skaits ar vērtību 1, pretējā gadījumā tas ir 0;
· uzstādīt palīgpārvadājuma karogs AF ir 1, ja decimāldaļas atņemšanas rezultāts ir jālabo, pretējā gadījumā tas ir 0;
· uzstādīt nulles karogs ZF uz 1, ja rezultāts ir 0, pretējā gadījumā tas ir 0;
· uzstādīt zīmes karogs SF ir 1, ja rezultāts ir negatīvs (visnozīmīgākais bits ir 1), pretējā gadījumā karodziņš ir 0;
· uzstādīt pārplūdes karogs OF ir 1, ja atņemšanas rezultāts pārsniedz uztvērēja vērtību diapazonu apgrieztajā kodā un pats uztvērējs maina zīmi.
SF un OF karodziņiem ir jēga tikai tad, ja tiek atņemti skaitļi ar zīmi, un AF karodziņam ir jēga tikai tad, ja tiek atņemti decimālskaitļi.
Komanda Samazināt galamērķa saturu — DEC
Komanda DEC uztvērējs(samazināt) atņem 1 no reģistra vai atmiņas vietas satura, bet (atšķirībā no SUB instrukcijas) neietekmē pārnēsāšanas karogu CF.
DEC instrukcija bieži tiek izmantota cilpās, lai samazinātu skaitītāja vērtību, līdz tā kļūst nulle vai negatīva. To var arī izmantot, lai samazinātu indeksa reģistra vai rādītāja vērtību, piekļūstot secīgām atmiņas vietām. Piemēram:
DEC CX; Samazināt 16 bitu vērtību,
DEC AL; vai 8 bitu reģistrs.
DEC MEM_BYTE; Samazināt baita vērtību,
DEC MEM_WORD; vai vārdu atmiņas šūna.
Dalīšanas komandas - DIV, IDIV
Komanda DIV(dalīt - dalīt) veic neparakstītu skaitļu dalīšanu un komandu IDIV(integer dalīšana - dalīt veselus skaitļus) veic skaitļu dalīšanu ar zīmi. Šīm komandām ir šāds formāts:
DIV avots; Kur avots- baita vai vārda lieluma dalītājs,
IDIV avots;atrodas vispārējas nozīmes reģistrā vai atmiņas vietā.
Lūdzu, ņemiet vērā:
1. Dividendei attiecībā pret dalītāju ir jābūt divkāršai.
2. Dividendei vienmēr jābūt AX reģistrā (dalot ar 8 bitu skaitli) vai DX un AX reģistros (dalot ar 16 bitu skaitli).
3. Komandas rezultāti tiek atgriezti šādi:
· ja avota operands ir baits, tad koeficients tiek atgriezts AL reģistrā, bet atlikums AN reģistrā;
· Ja avota operands ir vārds, tad koeficients tiek atgriezts AX reģistrā, bet atlikums tiek atgriezts DX reģistrā.
Abas instrukcijas atstāj karogu stāvokli nedefinētus, bet, ja koeficients neietilpst mērķa reģistrā (AL vai AX), tad mikroprocesors ģenerē 0 tipa pārtraukumu (dalīšana ar 0).
4. Sadalīšanas rezultāta pārpilde notiek šādos apstākļos:
· dalītājs ir 0;
· dalot baitus bez zīmes, dividende ir vismaz 256 reizes lielāka par dalītāju;
· dalot vārdus bez zīmes, dividende ir vismaz 65 536 reizes lielāka par dalītāju;
· dalot baitus ar zīmi, koeficients atrodas ārpus diapazona -128 līdz +127;
· sadalot vārdus ar zīmi, koeficients atrodas ārpus diapazona no
32768 līdz 32767.
Šeit ir daži tipiski sadalīšanas darbību piemēri:
DIV BX; Sadaliet DX:AX ar BX, neparakstīts.
DIV MEM_BYTE; Sadaliet AX neparakstītā atmiņas baitā.
IDIV DL; Sadaliet AX ar DL ar zīmi.
IDIV MEM WORD; Sadaliet DX:AX rakstītā atmiņas vārdā.
DIV un IDIV instrukcijas tieši nedala ar tūlītējo vērtību, jo procesors nevar noteikt dalītāja datu tipu.
Reizināšanas instrukcijas - MUL, IMUL
Komanda MUL(reizināt) reizina neparakstītus skaitļus, a IMUL(veselo skaitļu reizināšana) reizina veselus skaitļus ar zīmēm. Abu instrukciju reizinātājam un reizinātājam ir jābūt vienam datu tipam, tas ir, baitiem, vārdiem, dubultvārdiem utt.
Šīm komandām ir šāds formāts:
MUL avots; Kur avots- vispārējas nozīmes reģistrs,
IMUL avots; vai baita vai vārda izmēra atmiņas šūna.
Kā pirmais operands (reizināms) MUL un IMUL instrukcijas izmanto AL reģistra saturu (operācijām ar baitiem) vai AX reģistru (operācijām ar vārdiem). Precei ir dubults izmērs, un tā tiek atgriezta šādi:
· reizināšana baiti-atgriež 16 bitu produktu AN (augsts baits) un AL (zems baits) reģistros;
· reizināšana vārdus-atgriež 32 bitu produktu DX (augsts vārds) un AX (zems vārds) reģistros. Tādējādi produkta izmērs n- bitu koeficienti ir vienādi 2n.
ADC vesela skaitļa pievienošana ar pārnēsāšanu
Komanda adc veic pirmā un otrā operanda pievienošanu, rezultātam pievienojot pārnesuma karoga CF vērtību. Pirmā operanda (galamērķa) sākotnējā vērtība tiek zaudēta, to aizstāj ar pievienošanas rezultātu. Otrais operands ir nemainīgs. Kā komandas pirmais operands adc
Operandi var būt baiti vai vārdi un attēlot ciparus ar zīmi vai neparakstītu. Komanda adc(kopā ar komandu pievienot) parasti izmanto, lai pievienotu 32 bitu skaitļus. Komanda ietekmē karogus OF, SF, ZF, AF, PF un CF.
1. piemērs:
Mov AX,1125h adc AX,2C25h; AX=3D4Bh, ja CF bija = 1; AX=3D4Ah, ja CF bija = 0
2. piemērs:
; Datu laukos: numlow dw 0FFFFh; 2. termina zemā daļa numhigh dw 000Sh; 2. termiņa augstākā daļa;Numurs 0005FFFFh=393215;Programmas segmentā: mov AX,000Sh; Zemas kārtas daļa no 1. termiņa mov BX,0002h; 1. termiņa augstākā daļa;Numurs 00020005h=131077 pievienot AX,numlow; Junioru daļu pievienošana. AX=4, CF=1 adc BX, numhigh; Augstāku daļu pievienošana ar pārnēsāšanu. BX:AX=0008:0004h. ;Numurs 00080004h=524292
Ir pieļaujama 32 bitu operandu un 32 bitu procesoru papildu adresācijas režīmu izmantošana. Komanda adc ar 32 bitu operandiem, var izmantot, lai pievienotu 64 bitu veselus skaitļus.
Piemērs:
; Datu laukos mem321 dd 0FFFFFFFFh; 1. termiņa zemas kārtas daļa mem32h dd 98765432h; 1. semestra augstākā daļa; Programmas segmentā mov EAX,1; Zemas kārtas daļa no 2. termiņa mov EBX,0; 2. termina augstākā daļa pievieno EAX,mem321; Pievienojiet apakšējās puses; Summa = 100000000h>32 biti; EAX = 000000h, pārnēsājiet adc EBX, mem32h; Salieciet vecākās pusītes un pārnesiet. EBX=90000001h; Summa: 9876543300000000h
PIEVIENOT veselu skaitļu pievienošanu
Komanda pievienot veic pirmā un otrā operanda pievienošanu. Pirmā operanda (galamērķa) sākotnējā vērtība tiek zaudēta, to aizstāj ar pievienošanas rezultātu. Otrais operands ir nemainīgs. Kā komandas pirmais operands pievienot Var norādīt reģistru (izņemot segmentu) vai atmiņas šūnu, otrā var būt reģistrs (izņemot segmentu), atmiņas šūna vai tūlītēja vērtība, bet nav atļauts abus operandus vienlaikus definēt kā atmiņu. šūnas.
Operandi var būt baiti vai vārdi un attēlot ciparus ar zīmi vai neparakstītu. Komandu add var izmantot, lai pievienotu gan parastos veselos skaitļus, gan bināros decimālskaitļus (izmantojot AX reģistru, lai saglabātu rezultātu). Ja tiek pievienoti neiesaiņoti bināri kodēti decimālskaitļi (BCD), pēc komandas pievienot jāizmanto komanda aaa; ja tiek pievienoti iepakoti numuri, tad komanda jā. Komanda ietekmē karogus OF, SF, ZF, AF, PF un CF.
1. piemērs:
Mov BX,lFFEh mov CX,3 pievienot BX,CX; BX=2001h, CX=0003h
2. piemērs:
Mov AX,25h pievienot AX,12h; AX=0037h
3. piemērs:
; Datu laukos: mem dw 128 ;Programmas segmentā: add mem,100; mem=228
ADC vesela skaitļa pievienošana ar pārnēsāšanu
Komanda adc pievieno pirmo un otro operandu, pievienojot rezultātam pārnesuma karoga CF vērtību. Pirmā operanda (galamērķa) sākotnējā vērtība tiek zaudēta, to aizstāj ar pievienošanas rezultātu. Otrais operands ir nemainīgs. ADC instrukcijas pirmais operands var būt reģistrs (izņemot segmentu) vai atmiņas šūna, otrais operands var būt reģistrs (izņemot segmentu), atmiņas šūna vai tūlītēja vērtība, bet nav atļauts norādīt abi operandi vienlaikus kā atmiņas šūnas. Operandi var būt baiti vai vārdi un attēlot ciparus ar zīmi vai neparakstītu. Komandu adc (kopā ar komandu add) parasti izmanto, lai pievienotu 32 bitu skaitļus. Komanda ietekmē karogus OF, SF, ZF, AF, PF un CF.
1. piemērs
Mov AX,1125h adc AX,2C25h ;AX=3D4Bh, ja CF bija = 1 ;AX=3D4Ah, ja CF bija = 0
2. piemērs; Datu laukos: numlow dw 0FFFFh ;Zemā daļa no 2. termiņa numhigh dw 000Sh ;Augstākā daļa no 2. termina;Skaitlis 0005FFFFh=393215 ;Programmas segmentā: mov AX,000Sh ;Zemā daļa no BX1st termina mov , 0002h ; 1. semestra augstākā daļa;Numurs 00020005h=131077 pievienot AX,numlow;Apakšējo daļu pievienošana. AX=4, CF=1 adc BX, numhigh ;Augstāku daļu pievienošana ar;transfer.BX:AX=0008:0004h. ;Numurs 00080004h=524292
Ir pieļaujama 32 bitu operandu un 32 bitu procesoru papildu adresācijas režīmu izmantošana. ADC instrukciju ar 32 bitu operandiem var izmantot, lai pievienotu 64 bitu veselus skaitļus. 3. piemērs; Datu laukos mem321 dd 0FFFFFFFFh ;1. termina zemā daļa mem32h dd 98765432h ;1. termina augstā daļa; Programmas segmentā mov EAX,1 ;2. termina zemā daļa mov EBX,0 ;2. termina augstā daļa pievieno EAX,mem321 ;Pievieno zemās puses;Summa=100000000b>32 biti;EAX=000000h, pārnes adc EBX,mem32h ;Pievienojiet vecākās pusītes un pārsūtiet. EBX=90000001h ;Summa: 9876543300000000h
PIEVIENOT veselu skaitļu pievienošanu
Komanda pievieno pievieno pirmo un otro operandu. Pirmā operanda (galamērķa) sākotnējā vērtība tiek zaudēta, to aizstāj ar pievienošanas rezultātu. Otrais operands ir nemainīgs. Komandas pievienošanas pirmo operandu var norādīt kā reģistru (izņemot segmentu) vai atmiņas šūnu, bet otro operandu var norādīt kā reģistru (izņemot segmentu), atmiņas šūnu vai tūlītēju vērtību, bet tas ir nav atļauts definēt abus operandus vienlaikus kā atmiņas šūnas. Operandi var būt baiti vai vārdi un attēlot ciparus ar zīmi vai neparakstītu. Komandu add var izmantot, lai pievienotu gan parastos veselos skaitļus, gan bināros decimālskaitļus (izmantojot AX reģistru, lai saglabātu rezultātu). Pievienojot neizpakotos bināros kodētos decimālos (BCD) skaitļus, aiz komandas add izmantojiet komandu aaa; ja tiek pievienoti iepakoti numuri, tad komanda daa. Komanda ietekmē karogus OF, SF, ZF, AF, PF un CF. 1. piemērs
Mov BX,lFFEh mov CX,3 pievienot BX,CX ;BX=2001h, CX=0003h
2. piemērs mov AX,25h pievienot AX,12h ;AX=0037h
3. piemērs; Datu laukos: mem dw 128 ;Programmas segmentā: add mem,100 ;mem=228
4. piemērs mov AX,0507h ;BCD izpakots 57 pievienot AL,05h ;BCD 5, AX=050Ch aaa ;AX=0602h, BCD 62
5. piemērs mov AL,57h ;BCD iepakots 57 add AL,05h ;BCD 5, AL=5Ch daa ;AL=62h, BCD 62
Ir pieļaujama 32 bitu operandu un 32 bitu procesoru papildu adresācijas režīmu izmantošana. Piemērs
Mov EAX,98765432h pievienot EAX,11111111h ; EAX=A9876543h
UN Loģiski UN
Komanda un veic pirmā operanda loģisku (bitu) reizināšanu ar otro. Pirmā operanda (galamērķa) sākotnējā vērtība tiek zaudēta, aizstājot ar reizināšanas rezultātu. Komandas un pirmais operands var būt reģistrs (izņemot segmentu) vai atmiņas šūna, otrais operands var būt reģistrs (izņemot segmentu), atmiņas šūna vai tūlītēja vērtība, bet tas nav atļauts norādiet abus operandus vienlaikus kā atmiņas šūnas. Operandi var būt baiti vai vārdi. Komanda ietekmē SF, ZF un PF karogus. Bitu reizināšanas noteikumi:
Pirmā operanda bits 0101 Otrais operanda bits 0011 Rezultāta bits 0001 1. piemērs mov AX,0FFEh un AX,5555h ;AX=0554h 2. piemērs; Datu laukos: mem dw 0С003h ;Programmas segmentā: mov AX,700Eh un AX,mem ;AX=4002h
Ir pieļaujama 32 bitu operandu un 32 bitu procesoru papildu adresācijas režīmu izmantošana. Piemērs
Mov EDX, 0FA8 8 0 0 4 lh un EDX,0FF00000Fh ; EDX = FA000001h
386P+ ARPL
Pielāgot pieprasīto atlasītāja privilēģiju līmeni
Komanda aprl salīdzina atlasītāju ar modeli, kas satur maksimālo atļauto privilēģiju līmeni (parasti CS atlasītāju), un iestata pārbaudāmo vērtību uz zemāko no diviem privilēģiju līmeņiem. Ja līmeņa maiņa nav nepieciešama, ZF karodziņš tiek atiestatīts; ja nepieciešams, tas tiek iestatīts. Aprl instrukcijas pirmais operands var būt 16 bitu reģistrs vai atmiņas vārds ar pārbaudāmu selektoru; otrais operands ir 16 bitu reģistrs ar modeļa atlasītāju. 386+ IESIETOTI
Pārbauda masīva indeksu, vai masīvs ir ārpus robežām
Saistītā komanda pārbauda, vai norādītais indekss, kas tiek uzskatīts par parakstītu skaitli, atrodas otrā operanda norādītajās robežās. Ja indekss pārsniedz masīva robežas zem vai virs, tiek ģenerēts pārtraukums ar vektoru 5. Pirmajam operandam ir jābūt reģistram, kas satur pārbaudāmo indeksu, otrajam - atmiņas lauka adresei ar divām masīva robežām. tiek pārbaudīts. Saistītā komanda pieļauj gan 16 bitu, gan 32 bitu operandus (bet gan pirmajam, gan otrajam operandam ir jābūt viena veida).
Montētājs- Manekenu montāžas valoda
Montāžas valoda manekeniem.(#2) (C) Mihails Špicins 1995 Karogi Procesora reģistru "F" sauc par karogu. Kas tas ir? Karogs ir mainīgs lielums, kuram var būt divi stāvokļi: iestatīts (vienāds ar vienu) un notīrīts (vienāds ar nulli). Tāpēc "F" reģistru var uzskatīt par astoņu karoga bitu kopu. Mēs varam izmantot tikai četrus no tiem: nulles karogu, pārnēsāšanas karogu, zīmju karogu un paritātes pārpildes karogu.Aritmētiskās darbības. Aritmētika ir ļoti, ļoti noderīga zinātne; mēs pastāvīgi kaut ko skaitam: saskaitām, atņemam, dala, reizinim. Tagad mēs runāsim par to, kā to izdarīt montētājā. Sāksim ar vienkāršāko lietu, pievienojot kaut kam vienu, piemēram, lai reģistrētu "A": **************************** *** ** LD A,NUBER INC A RET ************************************ Kā redzat, tas ir ļoti vienkārša šim ir komanda "INC" - increment (palielināt par vienu), kam seko operands, t.i. daži reģistri vai reģistru pāris: ************************************ INC A INC HL INC H INC DE INC E INC IY INC E INC (HL) INC (IX+N) INC (IY+N) ********************************** ** Ja jums ir jāpalielina kāda atmiņas šūna par vienu, tad rīkojieties šādi: ************************************* ****** *** LD HL, ADDRES LD IX, ADDRES INC (HL) INC (IX+0) RET RET ********************* *************** ***** Pirmais variants darbojas ātrāk un ir ērtāks, ja strādā ar vienu atmiņas šūnu, bet ja strādā tabulā, tad tā nav ekonomisks un neglīts. Salīdziniet: mums jāpalielina pirmais, piektais un desmitais baits tabulā par vienu: ********************************** * 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 ************************************ Viss, kas tika teikts iepriekš par pieaugumu par vienu, ir patiess un samazināšanai, t.i. samazināt par vienu: ************************************ 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) ********************* *********** Tagad pieņemsim, ka reģistrs “A” jāpalielina nevis par vienu, bet, teiksim, par desmit: **************** * ************** LD A,NUMURS ADD A,10 RET ************************* * ****** Jūs varat pievienot reģistru "A" ar numuru un citiem reģistriem un ar atmiņas šūnu, ko adresē reģistru pāri "HL", "IX" un "IY". Varat arī pievienot reģistru pārus ar "HL", "IX" un "IY". (PureBasic — failu sistēma) ******************************** PIEVIENOT A,N PIEVIENOT A,(HL) PIEVIENOT A ,A PIEVIENOT A,(IX+N) PIEVIENOT A,B PIEVIENOT A,(IY+N) PIEVIENOT A,C PIEVIENOT HL,HL PIEVIENOT A,D PIEVIENOT HL,BC PIEVIENOT A,E PIEVIENOT HL,DE PIEVIENOT A,H PIEVIENOT HL,SP ADD IX,IX ADD IX,BC ADD IX,DE ADD IX,SP ******************************* ** Kā redzat, komandu kopa ir diezgan liela. Izpildot šo komandu, var rasties kļūda: ************************************ LD A,45 LD B,230 ADD A ,B RET ************************************ "A" un "B" summa pārsniedza 255 un tāpēc "A" "izrādīsies nevis 275, bet 20 (reģistrs "A" nav gumija); Lai informētu mūs, ka ir notikusi pārpilde, procesors iestata pārnēsāšanas karogu uz vienu. Atliek tikai to pārbaudīt. Tāpat kā "INC" ir "DEC", "ADD" ir arī "pāris", tas ir "SUB", un tam ir savas īpašības. Komanda "SUB" darbojas tikai ar "A" reģistru, tāpēc, rakstot šīs komandas mnemoniku, "A" tiek izlaists: ********************* *********** SUB N SUB C SUB A SUB H SUB B SUB D SUB E SUB (HL) SUB (IX+N) SUB (IY+N) ******** * ********************** Komanda ietekmē pārnēsāšanas karogu tāpat kā “ADD”. Papildus komandu pārim "ADD" un "SUB" ir vēl viens pāris. Komandas "ADC" un "SBC" darbojas, ņemot vērā pārnēsāšanas karogu, t.i. Saskaitot vai atņemot, rezultātam tiek pievienota (atņemta) pārnesuma karoga vērtība. Pārnēsāšanas karoga iestatīšanai ir divas īpašas komandas - "SCF" un "CCF". "SCF" - iestatiet pārnēsāšanas karogu uz vienu. "CCF" - iestatiet pārnēsāšanas karogu uz nulli. ******************************** 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 **************************** **** Un tagad komandu “ADC” un “SBC” darba piemēri: ***************************** ************ * 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 ******** *************************** Divu komandu “CCF” un “SBC A,B” vietā jūs var vienkārši ievietot “SUB B”, rezultāts būs tāds pats. ******************************** 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 **************************** **** Kā redzams no rezultātiem, pārnēsāšanas karogs būtiski ietekmē operācijas rezultātu. Atņemot, tas tiek atņemts no rezultāta, un, saskaitot, tas tiek pievienots rezultātam. Gandrīz viss ir aprakstīts par saskaitīšanas un atņemšanas darbībām, tagad mēs runāsim par dalīšanu un reizināšanu. Diemžēl SPECCY nav dalīšanas un reizināšanas komandu, taču šīs komandas var sastāvēt no vairākām citām komandām. Piemēram, mums jāreizina divu reģistru - “A” un “C” saturs: ********************************* ********** *** LD A,10 LD C,5 LD B,A XOR A LOOP ADD A,C DJNZ LOOP RET *************** ********** ******* Piemērā ir divas jaunas komandas - “XOR A” un “DJNZ LOOP”. "XOR A" notīra reģistru "A", un komanda "DJNZ LOOP" atkārto visas komandas, sākot no komandas, kas atzīmēta ar etiķeti (piemēram, "LOOP") līdz komandai "DJNZ" (kam seko tā pati etiķete). ka, kā cikla sākumā); atkārtojumu skaits norādīts reģistrā "B". Izmantojot faktu, ka, reizinot M ar N, skaitli M pievieno sev N reizes, jūs varat saprast iepriekš sniegto piemēru. Šo īpašumu var izmantot arī sadalīšanai. Izmēģiniet to pats. Nākamajā reizē mēs runāsim par komandām salīdzināšanai un darbam ar bitiem.________________________________Citi izdevuma raksti:
