• 沒有找到結果。

# 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:

 A ulceration over the left border of tongue with painful sensation over 40 days....  About 40 days ago, the female bit

Animal or vegetable fats and oils and their fractiors, boiled, oxidised, dehydrated, sulphurised, blown, polymerised by heat in vacuum or in inert gas or otherwise chemically

Milk and cream, in powder, granule or other solid form, of a fat content, by weight, exceeding 1.5%, not containing added sugar or other sweetening matter.

Estimated resident population by age and sex in statistical local areas, New South Wales, June 1990 (No. Canberra, Australian Capital

ASL arithmetically shift a memory location left by one bit ASLA arithmetically shift the accumulator left by one bit ASLX arithmetically shift the index register left by one bit

• The SBB (subtract with borrow) instruction subtracts both a source operand and the value of the Carry flag both a source operand and the value of the Carry flag from a

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

The Sign flag is set when the destination operand is negative The flag is clear when the destination

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

• Uses a nested structure to accumulate path data as the simulation is running. • Uses a multiple branch structure to choose the

Teacher then briefly explains the answers on Teachers’ Reference: Appendix 1 [Suggested Answers for Worksheet 1 (Understanding of Happy Life among Different Jewish Sects in

ReadInt - Reads a 32-bit signed decimal integer from standard input, terminated by the Enter key. ReadString - Reads a string from standard input, terminated by the

value2 BYTE 0 ; smallest unsigned byte value3 BYTE 255 ; largest unsigned byte value4 SBYTE -128 ; smallest signed byte value5 SBYTE +127 ; largest signed byte value6 BYTE.

xchg ax,bx ; exchange 16-bit regs xchg ah,al ; exchange 8-bit regs xchg var1,bx ; exchange mem, reg xchg eax,ebx ; exchange 32-bit regs.. xchg var1,var2 ; error: two

(Shift the binary point the number of places equal to the value of the exponent. Shift right if the exponent is positive, or left if the exponent is negative.).. From left to

source:PTR BYTE, ; source string target:PTR BYTE ; target string. INVOKE Str_length,source ; EAX =