riistvarapõhine programmeerimine loeng 6 andmeteisalduskäsud biti- ja stringikäsud...

Riistvarapõhine programmeerimine

Loeng 6AndmeteisalduskäsudBiti- ja stringikäsudSisend/väljundkäsudSiirdekäsud

22/07/2004 ID218 Riistvaralähedane programmeerimine

2

Andmeedastuskäsud Andmete laadimine Aadresside laadimine Bit-käsud Stringikäsud


3

Andmete laadimine I

Mov A, BXchg A, BPush APop A


4

Mov I

Mov A, B

mov reg, regmov mem, regmov reg, memmov reg, immidiate datamov mem, immidiate datamov segreg, regmov segreg, mem


5

Mov II


6

Mov III

D bit encoding

D = 0reg -> mem

D = 1mem -> reg


7

Mov IV

W bit encoding

W = 0A, B -> 8 bit

W = 1A, B -> 16 bit


8

Mov V

Reg W=0 W=1

000 AL AX

001 BL BX

010 CL CX

011 DL DX

100 AH SP

101 BH BP

110 CH SI

111 DH DI

REG bit encoding


9

Mov VIMod bit encoding

Mod Meaning

00 The r/m field denotes a register indirect memory addressing mode or a base/indexed addressing mode (see the encodings for r/m) unless the r/m field contains 110. If MOD=00 and r/m=110 the mod and r/m fields denote displacement-only (direct) addressing.

01 The r/m field denotes an indexed or base/indexed/displacement addressing mode. There is an eight bit signed displacement following the mod/reg/rm byte.

10 The r/m field denotes an indexed or base/indexed/displacement addressing mode. There is a 16 bit signed displacement (in 16 bit mode) following the mod/reg/rm byte .

11 The r/m field denotes a register and uses the same encoding as the reg field


10

Mov VIIR/M Field Encoding

R/M Addressing mode (Assuming MOD=00, 01, or 10)

000 [BX+SI] or DISP[BX][SI] (depends on MOD)

001 [BX+DI] or DISP[BX+DI] (depends on MOD)

010 [BP+SI] or DISP[BP+SI] (depends on MOD)

011 [BP+DI] or DISP[BP+DI] (depends on MOD)

100 [SI] or DISP[SI] (depends on MOD)

101 [DI] or DISP[DI] (depends on MOD)

110 Displacement-only or DISP[BP] (depends on MOD)

111 [BX] or DISP[BX] (depends on MOD)


11

Mov VIII

Mov reg8, reg8 2 baiti 2

Mov reg16, reg16 2 baiti 2

Mov reg16, mem 2 baiti 8+mem

Mov mem, reg16 2 baiti 9+mem

Mov reg16, imm.data 4 baiti 4

Mov mem16, imm.data 4 baiti 10+mem

Mov segreg,reg16 2 baiti 2

Mov segreg,mem 2 baiti 8+mem


12

Mov IXOperandi suurus – byte/word:mov [bx], 0 ; 0 -> [bx]

mov byte ptr [bx], 0mov word ptr [bx], 0

Segment registers:mov ax, 40hmov es, ax


13

Andmete laadimine II

xchg A, B

xchg reg, mem 2 baiti

xchg reg, reg 2 baiti

xchg ax, reg 1 bait

Lippud: ei mõjuta


14

Andmete laadimine III

push A A -> pinusse

push reg16 push memorypush segreg pushf

Algoritm:SP := SP - 2[SS:SP] := 16 bit operand (store result at location SS:SP.)


15

Andmete laadimine IV

pop A A <- pinust

pop reg16 pop memorypop segreg popf

Algoritm:16-bit operand := [SS:SP]SP := SP + 2


16

Adressite laadimine I

lds reg16, mem32

Agoritm:

reg16 := [mem32]

ds := [mem32 + 2]


17

Adressite laadimine II

les reg16, mem32

Algoritm:

reg16 := [mem32]

es := [mem32 + 2]


18

Adressite laadimine III

lea reg16, mem

Lea ax, 1234h 1234h ->ax

Mov ax, 1234h 1234h ->ax


19

Adressite laadimine IVlea reg16, mem

lea ax, [bx] ; mov ax, bx

lea bx, 3[bx] ; add bx, 3

lea ax, 3[bx] ; add bx, 3; mov ax, bx


20

Adressite laadimine V

lea reg16, mem

lea bx, 128[bp+di]

mov al,[bx]

mov al,[bx]

mov al,128[bp+di]

mov al,128[bp+di]


21

Bit-käsud

test A, B test

bt A, index bit test

btc A, index test and complement

btr A, index test and reset

bts A, index test and set

bsf A, B bit scan forward

bsr A, B bit scan reverse


22

Testtest A, B A & B -> FR

Lipud:Cf -> 0Of -> 0Zf -> vastavalt tulemuseleSf -> vastavalt tulemuselePf -> vastavalt tulemuseleAf -> vastavalt tulemusele


23

BT, BTS, BTR, BTC

Bt ax, 6 ; bit6 -> Cf

Bx = 33Bt A, bx ; bit 1 of A+4-> Cf

; effective address + index/8


24

BSF, BSR I

bsf A, B ; 0 -> 15

bsr A, B ; 15 -> 0

Kui leitud “1”:Zf = 0, B = Bit indexKui ei leitud_Zf = 1, B - määramata


25

BSF, BSR II

Kuidas leida “0”:

1. Kopeerida operand - mov

2. Inverteerida operand - not

3. Otsida “1” - bsf, bsr


26

Set – käsud I

set** reg8

set** mem8

Set** Akui ** = true, A = 1kui ** = false, A = 0


27

Set – käsud II

SET** Instructions That Test Flags


28

Set – käsud III

SET** Instructions for Unsigned Comparisons


29

Set – käsud IV

SET** Instructions for Signed Comparisons


30

Set – käsud V

Bool := A <= B

Bool byte variable

A, B signed integer

mov ax, A

cmp ax, B

setle Bool


31

Set – käsud VIBool := ((A <= B) and (D = E)) or (F <> G)

mov ax, Acmp ax, Bsetle bl ; A <= Bmov ax, Dcmp ax, Esete bh ; D = Eand bl, bh ; (A <= B) and (D = E)mov ax, Fcmp ax, Gsetne bh ; F <> Gor bl, bh ; * or *mov Bool, bh


32

String-käsud I

movs (move string)

lods (load string element into the accumulator)

stos (store accumulator into string element)

scas (Scan string and check for match against the value in the accumulator)

cmps (compare two strings)

ins (input a string from an I/O port)

outs (output a string to an I/O port


33

String-käsud II

rep (repeat a string operation)

repz (repeat while zero)

repe (repeat while equal)

repnz (repeat while not zero)

repne (repeat while not equal)


34

String-käsud II

movs{size - b,w}: es:[di] := ds:[si]

if direction_flag = 0 then

si := si + size;

di := di + size;

else

si := si - size;

di := di - size;

endif;


35

String-käsud III

cmps{size - b,w}: cmp ds:[si], es:[di]


si := si + size;

di := di + size;

else

si := si - size;

di := di - size;

endif;


36

String-käsud IV

lods{size - b,w}: ax/al := ds:[si]


si := si + size;

else

si := si - size;

endif;


37

String-käsud V

stos{size - b,w}: es:[di] := ax/al


di := di + size;

else

di := di - size;

endif;


38

String-käsud VI

scas{size - b,w}: cmp ax/al, es:[di]


di := di + size;

else

di := di - size;

endif;


39

String-käsud VII

ins{size b,w}: es:[di] := port(dx)


di := di + size;

else

di := di - size;

endif;


40

String-käsud VIII

outs{size - b,w}: port(dx) := ds:[si]


si := si + size;

else

si := si - size;

endif;


41

Sisend/väljundkäsud I

in ax/al, port ; inputin ax/al, dx

out port, ax/al ; outputout dx, ax/al

0 < port < 255Ei mõjuta lipud


42

Sisend/väljundkäsud IIRead keyboard from port 60h

in al, 60h ; Read

Sent ‘data’ to printer port 378h

mov dx, 378h ; port to dx

mov al, data ; data to al

out dx, al ; send


43

Siirdekäsud

Tingimatu siire

Tingimussiire

Protseduurid


44

Tingimatu siire Ijmp A

jmp disp8 ;direct intrasegment, 8 bit displacement.jmp disp16 ;direct intrasegment, 16 bit displacement.jmp mem16 ;indirect intrasegment, 16 bit memory operand.jmp reg16 ;register indirect

intrasegment.


45

Tingimatu siire IImov dx, 378h ;Parallel printer port

address.

Loop: in al, dx ;Read character from input port.

xor al, 1 ;Invert the L.O. bit.

out dx, al ;Output data back to port.

jmp Loop ;Repeat forever.

Loop: Statement label


46

Tingimatu siire IIIWordVar word TargetAddress

.

.

.

jmp WordVar

mov ip, WordVar


47

Tingimatu siire IV

jmp ax

mov ip, ax


48

Tingimussiire I

JmpTbl word iffalse, iftrue

.

.

.

mov ax, X

cmp ax, Y

sete bl

jmp JmpTbl[bl*2]


49

Tingimussiire II

J** A

j** disp8


50

Tingimussiire III


51

Tingimussiire IV


52

Tingimussiire V


53

Tingimussiire VIjc Target

jnc SkipJmp

jmp Target

SkipJmp:

128 baiti !!!


54

Kokkuvõte I

Andmeedastuskäsud:movxchglealdsles


55

Kokkuvõte II

Bit – käsud:testbt*set**


56

Kokkuvõte III

String-käsud:mov*sto*loa*cmp*


57

Kokkuvõte IV

Siirdekäsud:jmpj**


58

Kokkuvõte V

Sisend / väljundkäsudinout

riistvarapõhine programmeerimine loeng 6 andmeteisalduskäsud biti- ja stringikäsud...

Documents