• 沒有找到結果。

# Assembly Language for Intel

N/A
N/A
Protected

Share "Assembly Language for Intel"

Copied!
26
0
0

(1)

thth

Kip R. Irvine

(2)

## Chapter Overview Chapter Overview

• Shift and Rotate Instructions

• Shift and Rotate Applications

• Multiplication and Division Instructions

• ASCII and Packed Decimal Arithmetic

(3)

## Shift and Rotate Instructions Shift and Rotate Instructions

• Logical vs. Arithmetic Shifts

• SHL Instruction

• SHR Instruction

• SAL and SAR Instructions

• ROL Instruction

• ROR Instruction

• RCL and RCR Instructions

• SHLD/SHRD Instructions

(4)

## Logical vs vs Arithmetic Shifts Arithmetic Shifts

• A logical shift fills the newly created bit position with zero:

• An arithmetic shift fills the newly created bit position with a copy of the number’s sign bit:

CF

0

CF

(5)

## SHL Instruction SHL Instruction

• The SHL (shift left) instruction performs a logical left shift on the destination operand, filling the lowest bit with 0.

CF

0

• Operand types:

SHL reg,imm8 SHL mem,imm8 SHL reg,CL SHL mem,CL

(6)

## Fast Multiplication Fast Multiplication

mov dl,5 shl dl,1

Shifting left 1 bit multiplies a number by 2

0 0 0 0 1 0 1 0

0 0 0 0 0 1 0 1 = 5

= 10

Before:

After:

mov dl,5

shl dl,2 ; DL = 20

Shifting left n bits multiplies the operand by 2n For example, 5 * 22 = 20

(7)

## SHR Instruction SHR Instruction

• The SHR (shift right) instruction performs a logical right shift on the destination operand. The highest bit position is filled with a zero.

CF

0

mov dl,80

shr dl,1 ; DL = 40

shr dl,2 ; DL = 10

Shifting right n bits divides the operand by 2n

(8)

## SAL and SAR Instructions SAL and SAR Instructions

• SAL (shift arithmetic left) is identical to SHL.

• SAR (shift arithmetic right) performs a right arithmetic shift on the destination operand.

CF

An arithmetic shift preserves the number's sign.

mov dl,-80

sar dl,1 ; DL = -40

sar dl,2 ; DL = -10

(9)

mov al,6Bh

shr al,1 a.

shl al,3 b.

mov al,8Ch

sar al,1 c.

sar al,3 d.

Indicate the hexadecimal value of AL after each shift:

35h A8h C6h F8h

(10)

## ROL Instruction ROL Instruction

• ROL (rotate) shifts each bit to the left

• The highest bit is copied into both the Carry flag and into the lowest bit

• No bits are lost

CF

mov al,11110000b

rol al,1 ; AL = 11100001b

mov dl,3Fh

(11)

## ROR Instruction ROR Instruction

• ROR (rotate right) shifts each bit to the right

• The lowest bit is copied into both the Carry flag and into the highest bit

• No bits are lost

CF

mov al,11110000b

ror al,1 ; AL = 01111000b

mov dl,3Fh

(12)

mov al,6Bh

ror al,1 a.

rol al,3 b.

Indicate the hexadecimal value of AL after each rotation:

(13)

## RCL Instruction RCL Instruction

• RCL (rotate carry left) shifts each bit to the left

• Copies the Carry flag to the least significant bit

• Copies the most significant bit to the Carry flag

CF

clc ; CF = 0

mov bl,88h ; CF,BL = 0 10001000b rcl bl,1 ; CF,BL = 1 00010000b

(14)

## RCR Instruction RCR Instruction

• RCR (rotate carry right) shifts each bit to the right

• Copies the Carry flag to the most significant bit

• Copies the least significant bit to the Carry flag

stc ; CF = 1

mov ah,10h ; CF,AH = 00010000 1 rcr ah,1 ; CF,AH = 10001000 0

CF

(15)

stc

mov al,6Bh

rcr al,1 a.

rcl al,3 b.

Indicate the hexadecimal value of AL after each rotation:

B5h AEh

(16)

## SHLD Instruction SHLD Instruction

• Shifts a destination operand a given number of bits to the left

• The bit positions opened up by the shift are filled by the most significant bits of the source operand

• The source operand is not affected

• Syntax:

SHLD destination, source, count

(17)

## SHLD Example SHLD Example

.data

wval WORD 9BA6h .code

mov ax,0AC36h shld wval,ax,4

9BA6 AC36 BA6A AC36

wval AX

Shift wval 4 bits to the left and replace its lowest 4 bits with the high 4 bits of AX:

Before:

After:

(18)

## SHRD Instruction SHRD Instruction

• Shifts a destination operand a given number of bits to the right

• The bit positions opened up by the shift are filled by the least significant bits of the source operand

• The source operand is not affected

• Syntax:

SHRD destination, source, count

(19)

## SHRD Example SHRD Example

mov ax,234Bh mov dx,7654h shrd ax,dx,4

Shift AX 4 bits to the right and replace its highest 4 bits with the low 4 bits of DX:

Before:

After:

7654 234B 7654 4234

DX AX

(20)

mov ax,7C36h mov dx,9FA6h

shld dx,ax,4 ; DX = shrd dx,ax,8 ; DX =

Indicate the hexadecimal values of each destination operand:

FA67h 36FAh

(21)

## Shift and Rotate Applications Shift and Rotate Applications

• Shifting Multiple Doublewords

• Binary Multiplication

• Displaying Binary Bits

• Isolating a Bit String

(22)

## Shifting Multiple Doublewords Doublewords

• Programs sometimes need to shift all bits within an array, as one might when moving a bitmapped

graphic image from one screen location to another.

• The following shifts an array of 3 doublewords 1 bit to the right (view complete source code):

.data

ArraySize = 3

array DWORD ArraySize DUP(99999999h) ; 1001 1001...

.code

mov esi,0

shr array[esi + 8],1 ; high dword

rcr array[esi + 4],1 ; middle dword, include Carry rcr array[esi],1 ; low dword, include Carry

(23)

## Binary Multiplication Binary Multiplication

• We already know that SHL performs unsigned

multiplication efficiently when the multiplier is a power of 2.

• You can factor any binary number into powers of 2.

• For example, to multiply EAX * 36, factor 36 into 32 + 4 and use the distributive property of multiplication to

carry out the operation:

EAX * 36

= EAX * (32 + 4)

= (EAX * 32)+(EAX * 4)

mov eax,123 mov ebx,eax

shl eax,5 ; mult by 25 shl ebx,2 ; mult by 22 add eax,ebx

(24)

mov ax,2 ; test value

mov dx,ax

shl dx,4 ; AX * 16

push dx ; save for later

mov dx,ax

shl dx,3 ; AX * 8

shl ax,1 ; AX * 2

add ax,dx ; AX * 10

pop dx ; recall AX * 16

add ax,dx ; AX * 26

Multiply AX by 26, using shifting and addition instructions.

Hint: 26 = 16 + 8 + 2.

(25)

## Displaying Binary Bits Displaying Binary Bits

Algorithm: Shift MSB into the Carry flag; If CF = 1,

append a "1" character to a string; otherwise, append a

"0" character. Repeat in a loop, 32 times.

mov ecx,32

mov esi,offset buffer L1: shl eax,1

mov BYTE PTR [esi],'0' jnc L2

mov BYTE PTR [esi],'1' L2: inc esi

loop L1

(26)

## Isolating a Bit String Isolating a Bit String

• The MS-DOS file date field packs the year, month, and day into 16 bits:

DH DL

Year Month Day

9-15 5-8 0-4

Field:

Bit numbers:

0 1 0

0

0 0 1 1 0 1 1 0 1 0 1 0

mov ax,dx ; make a copy of DX

shr ax,5 ; shift right 5 bits

and al,00001111b ; clear bits 4-7

Isolate the Month field:

First, in the Intel documentation, the encoding of the MOV instruction that moves an immediate word into a register is B8 +rw dw, where +rw indicates that a register code (0-7) is to

• Cell: A unit of main memory (typically 8 bits which is one byte).. – Most significant bit: the bit at the left (high- order) end of the conceptual row of bits in a

– The Parity flag is set when an instruction generates an even number of 1 bits in the low byte of the destination operand.. – The Auxiliary Carry flag is set when an

• Last data pointer stores the memory address of the operand for the last non-control instruction. Last instruction pointer stored the address of the last

• tiny (a single segment, used by .com programs), small (one code segment and one data segment), medium (multiple code segments and a single data segment), compact (one code

• The first module, written in assembly language, contains the external procedure. • The second module contains the C/C++ code that starts and ends

• The Java programming language is based on the virtual machine concept. • A program written in the Java language is translated by a Java compiler into Java

A constant state u − is formed on the left side of the initial wave train followed by a right facing (with respect to the velocity u − ) dispersive shock having smaller