mov eax - DC

Kip R. Irvine
Capítulo 7: Aritmética de Inteiros
Slides prepared by the author
Revision date: June 4, 2006
(c) Pearson Education, 2006-2007. All rights reserved. You may modify and copy this slide show for your personal use,
or for use in the classroom, as long as this copyright statement, the author's name, and the title are not changed.
Web site
Examples
Índice






Instruções de Shift e Rotate
Aplicações de Shift e Rotate
Instruções de Multiplicação e Divisão
Adição e subtração estendida
Aritmética ASCII e decimal desempacotado
Aritmética decimal empacotado
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
2
Instruções de Shift e Rotate








Shift Lógico vs Aritmético
Instrução SHL
Instrução SHR
Instruções SAL e SAR
Instrução ROL
Instrução ROR
Instruções RCL e RCR
Instruções SHLD/SHRD
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
3
Shift lógico vs. aritmético
 O shift lógico preenche as lacunas criadas com zero:
0
CF
• O shift aritmético preenche as lacunas criadas com a
cópia do bit de sinal:
CF
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
4
Instrução SHL
 A instrução SHL (shift left) faz o deslocamento lógico
à esquerda do operando destino, preenchendo o bit à
direita com 0.
0
CF
• Tipos de operando para SHL:
SHL reg,imm8
SHL mem,imm8
SHL reg,CL
SHL mem,CL
(mesmos para todas as
instruções shift e rotate)
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
5
Fast Multiplication
Deslocando 1 bit à esquerda multiplica um número por 2
mov dl,5
shl dl,1
Before:
00000101
=5
After:
00001010
= 10
Deslocando à esquerda n bits multiplica o operando por 2n
Exemplo, 5 * 22 = 20
mov dl,5
shl dl,2
; DL = 20
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
6
Instrução SHR
 A instrução SHR (shift right) faz o deslocamento lógico à
direita do operando destino. A posição do bit mais significativo
é preenchido com zero.
0
CF
Deslocando n bits à direita divide o operando por 2n
mov dl,80
shr dl,1
shr dl,2
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
; DL = 40
; DL = 10
Web site
Examples
7
Instruções SAL e SAR
 SAL (shift arithmetic left) é idêntico a SHL.
 SAR (shift arithmetic right) faz um deslocamento
aritmético à direita no operando destino.
CF
Um shift aritmético preserva o sinal do número.
mov dl,-80
sar dl,1
sar dl,2
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
; DL = -40
; DL = -10
Web site
Examples
8
Sua vez . . .
Indicar o valor em hexadecimal de AL após cada shift:
mov
shr
shl
mov
sar
sar
al,6Bh
al,1
al,3
al,8Ch
al,1
al,3
a. 35h
b. A8h
c. C6h
d. F8h
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
9
Instrução ROL
 ROL (rotate) desloca cada bit à esquerda
 O bit mais significativo é copiado no flag Carry e
no bit menos significativo
 Nenhum bit é perdido
CF
mov al,11110000b
rol al,1
; AL = 11100001b
mov dl,3Fh
rol dl,4
; DL = F3h
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
10
Instrução ROR
 ROR (rotate right) desloca cada bit à direita
 O bit menos significativo é copiado no flag Carry e na
posição do bit mais significativo
 Nenhum bit é perdido
CF
mov al,11110000b
ror al,1
; AL = 01111000b
mov dl,3Fh
ror dl,4
; DL = F3h
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
11
Sua vez . . .
Indicar o valor hexadecimal de AL após cada rotação:
mov al,6Bh
ror al,1
rol al,3
a. B5h
b. ADh
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
12
Instrução RCL
 RCL (rotate carry left) desloca cada it à esquerda
 Copia o Carry flag para a posição menos significativa
 Copia o bit mais significativo no flag Carry
CF
clc
mov bl,88h
rcl bl,1
rcl bl,1
;
;
;
;
CF = 0
CF,BL = 0 10001000b
CF,BL = 1 00010000b
CF,BL = 0 00100001b
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
13
Instrução RCR
 RCR (rotate carry right) desloca cada bit à direita
 Copia o flag Carry na posição mais significativa
 Copia o bit menos significativo no flag Carry
CF
stc
mov ah,10h
rcr ah,1
; CF = 1
; CF,AH = 1 00010000b
; CF,AH = 0 10001000b
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
14
Sua vez . . .
Indicar o valor hexadecimal de AL após cada rotação:
stc
mov al,6Bh
rcr al,1
rcl al,3
a. B5h
b. AEh
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
15
Instrução SHLD
 Desloca o operando destino um dado número de bits à esquerda
 As posições vazias resultantes são preenchidas pelos bits mais
significativos do operando fonte
 O operando fonte não é afetado
 Sintaxe:
SHLD destination, source, count
 Tipos de operando:
SHLD reg16/32, reg16/32, imm8/CL
SHLD mem16/32, reg16/32, imm8/CL
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
16
Exemplo de SHLD
Desloca wval 4 bits à esquerda e substitui os 4 bits menos
significativos com os 4 bits mais significativos de AX:
.data
wval WORD 9BA6h
.code
mov ax,0AC36h
shld wval,ax,4
wval
AX
Before:
9BA6
AC36
After:
BA6A
AC36
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
17
Instrução SHRD
 Desloca o operando destino um dado número de bits à
direita
 As posições vazias resultantes são preenchidas com os
bits menos significativos do operando fonte
 O operando fonte não é afetado
 Sintaxe:
SHRD destination, source, count
 Tipos de operando:
SHRD reg16/32, reg16/32, imm8/CL
SHRD mem16/32, reg16/32, imm8/CL
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
18
Exemplo de SHRD
Desloca AX 4 bits à direita e substitui os 4 bits mais
significativos com os 4 bits menos significativos de DX:
mov ax,234Bh
mov dx,7654h
shrd ax,dx,4
DX
AX
Before:
7654
234B
After:
7654
4234
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
19
Sua vez . . .
Indicar em valor hexadecimal cada operando destino:
mov
mov
shld
shrd
ax,7C36h
dx,9FA6h
dx,ax,4
dx,ax,8
; DX = FA67h
; DX = 36FAh
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
20
Próxima seção






Instruções de Shift e Rotate
Aplicações de Shift e Rotate
Instruções de Multiplicação e Divisão
Adição e subtração estendida
Aritmética ASCII e decimal desempacotado
Aritmética decimal empacotado
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
21
Aplicações de Shift e Rotate
 Deslocando Doublewords múltiplos
 Multiplicação binária
 Mostrando bits binários
 Isolando uma cadeia de bits
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
22
Deslocando Doublewords múltiplos
 Os programas às vezes precisam deslocar todos os bits
de um vetor, como o movimento de uma imagem
gráfica de uma posição da tela para outra.
 O seguinte programa desloca um vetor de 3
doublewords 1 bit à direita:
.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
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
23
Multiplicação binária
 Sabemos que SHL faz a multiplicação sem sinal quando
o multiplicador é potência de 2.
 É possível fatorar qualquer número binário em potência
de 2.
 Por exemplo, para multiplicar EAX * 36, fatorar 36 em
32 + 4 e usar a propriedade distributiva de multiplicação :
EAX * 36
= EAX * (32 + 4)
= (EAX * 32)+(EAX * 4)
mov
mov
shl
shl
add
eax,123
ebx,eax
eax,5
ebx,2
eax,ebx
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
; mult by 25
; mult by 22
Examples
24
Sua vez . . .
Multiplicar AX por 26, usando deslocamento e adição.
Dica: 26 = 16 + 8 + 2.
mov ax,2
mov dx,ax
shl dx,4
push dx
mov dx,ax
shl dx,3
shl ax,1
add ax,dx
pop dx
add ax,dx
; test value
; AX * 16
; save for later
;
;
;
;
;
AX * 8
AX * 2
AX * 10
recall AX * 16
AX * 26
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
25
Mostrando bits binários
Algoritmo: deslocar o MSB para o flag Carry; se CF = 1, anexar o
caractere "1“ à cadeia; caso contrário, anexar o caractere “0” . Repetir
em loop, 32 vezes.
.data
buffer BYTE 32 DUP(0),0
.code
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
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
26
Isolando uma cadeia de bits
 O campo de data do arquivo MS-DOS empacota o
ano, mês e dia em 16 bits:
DH
DL
0 0 1 0 0 1 1 0
Field:
Bit numbers:
Year
9-15
0 1 1 0 1 0 1 0
Month
5-8
Day
0-4
Isolar o campo mês:
mov
shr
and
mov
ax,dx
ax,5
al,00001111b
month,al
;
;
;
;
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
make a copy of DX
shift right 5 bits
clear bits 4-7
save in month variable
Web site
Examples
27
Próxima seção






Instruções de Shift e Rotate
Aplicações de Shift e Rotate
Instruções de Multiplicação e Divisão
Adição e subtração estendida
Aritmética ASCII e decimal desempacotado
Aritmética decimal empacotado
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
28
28
Instruções de Multiplicação e
Divisão
 Instrução MUL
 Instrução IMUL
 Instrução DIV
 Divisão inteira com sinal
 Instruções CBW, CWD, CDQ
 Instrução IDIV
 Implementando expressões Aritméticas
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
29
Instrução MUL
 A instrução MUL (unsigned multiply) multiplica um operando de 8-,
16-, ou 32-bit por AL, AX, ou EAX.
 Os formatos são:
MUL r/m8
MUL r/m16
MUL r/m32
Operandos implícitos:
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
30
Exemplos de MUL
100h * 2000h, usando operandos de 16-bits:
.data
val1 WORD 2000h
val2 WORD 100h
.code
mov ax,val1
mul val2
; DX:AX = 00200000h, CF=1
O flag Carry indica se
a metade superior
contem dígitos
significativos
12345h * 1000h, usando operandos de 32-bits:
mov eax,12345h
mov ebx,1000h
mul ebx
; EDX:EAX = 0000000012345000h, CF=0
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
31
Sua vez . . .
Quais seriam os valores em hexadecimal de DX, AX, e flag
Carry após a execução das instruções seguintes?
mov ax,1234h
mov bx,100h
mul bx
DX = 0012h, AX = 3400h, CF = 1
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
32
Sua vez. . .
Quais serão os valores em hexadecimal de EDX, EAX, e flag
Carry após a execução das seguintes instruções?
mov eax,00128765h
mov ecx,10000h
mul ecx
EDX = 00000012h, EAX = 87650000h, CF = 1
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
33
Instrução IMUL
 IMUL (signed integer multiply ) multiplica um operando
com sinal de 8-, 16-, ou 32-bits por AL, AX, ou EAX
 Preserva o sinal do produto estendendo o sinal para o
registrador destino da metade mais significativa
Exemplo: multiplicar 48 * 4, usando operandos de 8-bits :
mov al,48
mov bl,4
imul bl
; AX = 00C0h, OF=1
OF=1 porque AH recebe bits significativos, não somente
extensão de sinal de AL.
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
34
Exemplos de IMUL
Multiplicar 4,823,424 * -423:
mov eax,4823424
mov ebx,-423
imul ebx
; EDX:EAX = FFFFFFFF86635D80h, OF=0
OF=0 porque EDX é somente extensão de sinal de EAX.
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
35
Sua vez . . .
Quais serão os valores hexadecimal de DX, AX, flag Carry e
overflow flag após a execução das seguintes instruções?
mov ax,8760h
mov bx,100h
imul bx
DX = FF87h, AX = 6000h, CF=1, OF = 1
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
36
Instrução DIV (sem sinal)
 A instrução DIV faz a divisão de 8-bit, 16-bit, e 32-bits
em inteiros sem sinal
 O divisor é o único operando explícito (registrador ou
memória)
Operandos Default:
 Formatos:
DIV r/m8
DIV r/m16
DIV r/m32
Web site
Examples
37
Exemplos de DIV
Dividir 8003h por 100h, usando operandos de 16-bits:
mov
mov
mov
div
dx,0
ax,8003h
cx,100h
cx
;
;
;
;
clear dividend, high
dividend, low
divisor
AX = 0080h, DX = 3
Mesma divisão, usando operandos de 32-bits:
mov
mov
mov
div
edx,0
eax,8003h
ecx,100h
ecx
;
;
;
;
clear dividend, high
dividend, low
divisor
EAX = 00000080h, EDX = 3
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
38
Sua vez . . .
Quais os valores em hexadecimal de DX e AX após a
execução das seguintes instruções? Ou, indicar se
ocorre divide overflow:
mov
mov
mov
div
dx,0087h
ax,6000h
bx,100h
bx
DX = 0000h, AX = 8760h
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
39
Sua vez . . .
Quais os valores em hexadecimal de DX e AX após a
execução das seguintes instruções? Ou, indicar se
ocorrer divide overflow:
mov
mov
mov
div
dx,0087h
ax,6002h
bx,10h
bx
Divide Overflow
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
40
IDIV - Divisão inteira com sinal
 Os inteiros com sinal devem ser estendidos em sinal antes
da divisão ser realizada
 Preencher os byte/word/doubleword mais significativos
com uma cópia do bit de sinal do byte/word/doubleword
menos significativo
 Por exemplo, o byte mais significativo contem uma cópia
do bit de sinal do byte menos significativo:
10001111
11111111
10001111
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
41
Instruções CBW, CWD, CDQ
 As instruções CBW, CWD e CDQ realizam
importantes operações de extensão de sinal:
 CBW (convert byte to word) estende AL para AH
 CWD (convert word to doubleword) estende AX para DX
 CDQ (convert doubleword to quadword) estende EAX para EDX
 Exemplo:
mov eax,0FFFFFF9Bh ; (-101)
cdq
; EDX:EAX = FFFFFFFFFFFFFF9Bh
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
42
Instrução IDIV
 IDIV faz a divisão de inteiro com sinal
 Mesma sintaxe e operandos como na instrução DIV
Exemplo: divisão de 8-bits de –48 por 5
mov al,-48
cbw
mov bl,5
idiv bl
; extend AL into AH
; AL = -9,
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
AH = -3
Web site
Examples
43
Exemplos de IDIV
Exemplo: divisão de 16-bits de –48 por 5
mov ax,-48
cwd
mov bx,5
idiv bx
; extend AX into DX
; AX = -9,
DX = -3
Exemplo: divisão de 32-bits de –48 por 5
mov eax,-48
cdq
mov ebx,5
idiv ebx
; extend EAX into EDX
; EAX = -9,
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
EDX = -3
Web site
Examples
44
Sua vez . . ..
Quais os valores em hexadecimal de DX e AX após a
execução das seguintes instruções? Ou, se ocorrer
divide overflow , indicar isso como resposta:
mov ax,0FDFFh
cwd
mov bx,100h
idiv bx
; -513
DX = FFFFh (-1), AX = FFFEh (-2)
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
45
Expressões aritméticas sem sinal
 Algumas boas razões para aprender expressões de inteiros:
 Aprender como compiladores as fazem
 Testar o entendimento de MUL, IMUL, DIV, IDIV
 Check de overflow (flags Carry e Overflow )
Exemplo: var4 = (var1 + var2) * var3
; Assume unsigned operands
mov eax,var1
add eax,var2
; EAX = var1 + var2
mul var3
; EAX = EAX * var3
jc
TooBig
; check for carry
mov var4,eax
; save product
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
46
Expressões aritmética com sinal (1 de 2)
Exemplo: eax = (-var1 * var2) + var3
mov
neg
imul
jo
add
jo
eax,var1
eax
var2
TooBig
eax,var3
TooBig
; check for overflow
; check for overflow
Exemplo: var4 = (var1 * 5) / (var2 – 3)
mov
mov
imul
mov
sub
idiv
mov
eax,var1
ebx,5
ebx
ebx,var2
ebx,3
ebx
var4,eax
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
; left side
; EDX:EAX = product
; right side
; EAX = quotient
Web site
Examples
47
Expressões aritmética com sinal (2 de 2)
Exemplo : var4 = (var1 * -5) / (-var2 % var3);
mov
neg
cdq
idiv
mov
mov
imul
idiv
mov
eax,var2
eax
var3
ebx,edx
eax,-5
var1
ebx
var4,eax
; begin right side
;
;
;
;
;
;
;
sign-extend dividend
EDX = remainder
EBX = right side
begin left side
EDX:EAX = left side
final division
quotient
As vezes é mais fácil calcular o termo à direita primeiro.
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
48
Sua vez . . .
Implementar a seguinte expressão usando inteiros de
32 bits com sinal:
eax = (ebx * 20) / ecx
mov eax,20
imul ebx
idiv ecx
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
49
Sua vez . . .
Implementar a seguinte expressão usando inteiros de
32 bits com sinal. Salvar e restaurar EDX:
eax = (ecx * edx) / eax
push
push
mov
imul
pop
idiv
pop
edx
eax
eax,ecx
edx
ebx
ebx
edx
; EAX needed later
;
;
;
;
left side: EDX:EAX
saved value of EAX
EAX = quotient
restore EDX
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
50
Sua vez . . .
Implementar a seguinte expressão usando inteiros de
32 bits com sinal. Não modificar nenhuma variável a
não ser var3:
var3 = (var1 * -var2) / (var3 – ebx)
mov
mov
neg
imul
mov
sub
idiv
mov
eax,var1
edx,var2
edx
edx
ecx,var3
ecx,ebx
ecx
var3,eax
; left side: EDX:EAX
; EAX = quotient
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
51
Próxima seção






Instruções de Shift e Rotate
Aplicações de Shift e Rotate
Instruções de Multiplicação e Divisão
Adição e subtração estendida
Aritmética ASCII e decimal desempacotado
Aritmética decimal empacotado
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
52
52
Adição e subtração estendida
 Instrução ADC
 Extended Precision Addition
 Instrução SBB
 Extended Precision Subtraction
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
53
Adição com precisão estendida
 Adicionando 2 operandos que são maiores que o tamanho
máximo da palavra (32 bits).
 Virtualmente não deve existir limite para o tamanho dos
operandos
 A aritmética deve ser realizada em etapas
 O valor de Carry de uma etapa é passado para a próxima
etapa.
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
54
Instrução ADC
 A instrução ADC soma o operando fonte e o flag de
Carry ao operando destino.
 Operandos são valores binários
 Mesma sintaxe do ADD, SUB, etc.
 Exemplo
 Somar dois inteiros de 32-bits (FFFFFFFFh +
FFFFFFFFh), produzindo uma soma de 64-bit em
EDX:EAX:
mov
mov
add
adc
edx,0
eax,0FFFFFFFFh
eax,0FFFFFFFFh
edx,0
;EDX:EAX = 00000001FFFFFFFEh
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
55
Exemplo de adição com precisão estendida
 Tarefa: somar 1 a EDX:EAX
 Valor inicial de EDX:EAX: 00000000FFFFFFFFh
 Somar os 32 bits menos significativos primeiro, acionando o flag Carry.
 Somar os 32 bits mais significativos, e incluir o flag Carry.
mov
mov
add
adc
edx,0
eax,0FFFFFFFFh
eax,1
edx,0
;
;
;
;
set
set
add
add
upper
lower
lower
upper
half
half
half
half
EDX:EAX = 00000001 00000000
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
56
Instrução SBB
 A instrução SBB subtrai o operando fonte e o flag
Carry do operando destino.
 sintaxe:
 Mesmo que a instrução ADC
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
57
Exemplo de subtração estendida
 Tarefa: Subtrair 1 de EDX:EAX
 Valor inicial de EDX:EAX: 0000000100000000h
 Subtrair os 32 bits menos significativos primeiro, acionando o flag Carry.
 Subtrair os 32 bits mais significativos, incluindo o flag Carry.
mov
mov
sub
sbb
edx,1
eax,0
eax,1
edx,0
;
;
;
;
set upper half
set lower half
subtract lower half
subtract upper half
EDX:EAX = 00000000 FFFFFFFF
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
58
Próxima seção






Instruções de Shift e Rotate
Aplicações de Shift e Rotate
Instruções de Multiplicação e Divisão
Adição e subtração estendida
Aritmética ASCII e decimal desempacotado
Aritmética decimal empacotado
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
59
59
Aritmética ASCII e decimal empacotado
 Binary Coded Decimal
 ASCII
 Instrução AAA
 Instrução AAS
 Instrução AAM
 Instrução AAD
 Inteiros em decimal empacotado
 Instrução DAA
 Instrução DAS
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
60
Binary-Coded Decimal (BCD)
 Um BCD usa 4 bits para representar o dígito decimal
 Um número em BCD desempacotado tem um dígito
decimal na parte menos significativa dos bytes
 Por exemplo, 5,678 é armazenado na seguinte seqüência de
bytes mostrados em hexadecimal:
05 06 07 08
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
61
ASCII
 Nessa representação, é usado o código ASCII do
número
 Por exemplo, 5,678 é armazenado na seguinte
seqüência de bytes mostrados em hexadecimal:
35 36 37 38
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
62
Instrução AAA (adjust after addition)
 Ajusta o resultado binário de uma instrução ADD ou
ADC, em números ASCII
 Torna o resultado em AL consistente com o BCD.
 O valor Carry, se existir termina em AH
 Para converter o resultado em ASCII fazer
 or ax, 3030h
 Exemplo: somar ‘8’ e ‘2’
mov
mov
add
aaa
or
ah,0
al,'8'
al,'2'
ax,3030h
;
;
;
;
AX
AX
AX
AX
=
=
=
=
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
0038h
006Ah
0100h (adjust result)
3130h = '10'
Web site
Examples
Instrução AAS (adjust after subtraction)
 Ajusta o resultado binário de uma instrução SUB ou SBB, em
números ASCII .
 Torna o resultado em AL consistente com BCD.
 Coloca o valor Carry , se houver, em AH
 Para converter o resultado em ASCII fazer
 or ax, 3030h
 Exemplo : Subtrair ‘8' de ‘9'
mov ah,0
mov al,‘9'
sub al,‘8'
aas
or ax,3030h
;
;
;
;
AX
AX
AX
AX
=
=
=
=
0039h
0001h
0001h, CF=0
‘01'
Web site
Examples
64
Instrução AAM (ASCII adjust after multiplication)
 Ajusta o resultado binário de uma instrução MUL.
 A multiplicação deve usar BCD desempacotado.
mov bl,05h
mov al,06h
mul bl
aam
;
;
;
;
first operand
second operand
AX = 001Eh
AX = 0300h
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
65
Instrução AAD (ASCII adjust before division)
 Converte o dividendo em BCD desempacotado, para
binário, antes da operação de divisão
.data
quotient BYTE ?
remainder BYTE ?
.code
mov ax,0307h
aad
mov bl,5
div bl
mov quotient,al
mov remainder,ah
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
;
;
;
;
dividend
AX = 0025h
divisor
AX = 0207h
Web site
Examples
66
Próxima seção






Instruções de Shift e Rotate
Aplicações de Shift e Rotate
Instruções de Multiplicação e Divisão
Adição e subtração estendida
Aritmética ASCII e decimal desempacotado
Aritmética decimal empacotado
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
67
67
Decimal ou BCD empacotado
 Inteiros em decimal ou BCD empacotado armazena
dois dígitos decimais por byte
 Por exemplo, 12,345,678 pode ser armazenado como a
seguinte seqüência de bytes em hexadecimal:
12 34 56 78
Bom para valores financeiros –é possível estender a precisão,
sem arredondamento de erros.
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
68
Instrução DAA (decimal adjust after addition)
 Converte o resultado binário de uma operação ADD ou
ADC para o formato decimal empacotado.
 O valor a ser ajustado deve estar em AL
 Se o dígito menos significativo é alterado, o flag de
Auxiliary Carry é acionado.
 Se o dígito mais significativo é alterado, o flag de Carry
é acionado.
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
69
Lógica DAA
If (AL(lo) > 9) or (AuxCarry = 1)
AL = AL + 6
AuxCarry = 1
Else
se AL = AL + 6 aciona o
AuxCarry = 0
flag de Carry, esse valor
Endif
de carry é usado na
avaliação de AL(hi).
If (AL(hi) > 9) or Carry = 1
AL = AL + 60h
Carry = 1
Else
Carry = 0
Endif
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
70
Exemplos de DAA
 Exemplo : calcular BCD 35 + 48
mov al,35h
add al,48h
daa
; AL = 7Dh
; AL = 83h, AF= 1, CF = 0
• Exemplo : calcular BCD 35 + 65
mov al,35h
add al,65h
daa
; AL = 9Ah
; AL = 00h, AF = 1, CF = 1
• Exemplo : calcular BCD 69 + 29
mov al,69h
add al,29h
daa
; AL = 92h, AF = 1
; AL = 98h, AF = 1, CF = 0
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
71
Sua vez . . .
 Um mal funcionamento temporário no computador desabilitou a
instrução DAA. Escrever um procedimento em linguagem
Assembly que realiza as mesmas ações do DAA.
 Testar o procedimento usando os valores do slide anterior.
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
72
Instrução DAS
 A instrução DAS (decimal adjust after subtraction)
converte o resultado binário de uma operação SUB ou
SBB para o formato decimal empacotado.
 O valor deve estar em AL
 Exemplo : subtrair BCD 35 de 48
mov al,48h
sub al,35h
das
; AL = 13h
; AL = 13h,
CF = 0
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
73
Lógica de DAS
If (AL(lo) > 9) OR (AuxCarry = 1)
AL = AL − 6;
AuxCarry = 1;
se AL = AL - 6 aciona o
Else
flag de Carry, esse valor
AuxCarry = 0;
é usado na avaliação de
Endif
AL no segundo IF
If (AL > 9FH) or (Carry = 1)
AL = AL − 60h;
Carry = 1;
Else
Carry = 0;
Endif
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
74
Exemplos de DAS
(1 de 2)
 Exemplo : subtrair BCD 48 – 35
mov al,48h
sub al,35h
das
; AL = 13h
; AL = 13h, AF=0,
CF = 0
• Exemplo : subtrair BCD 62 – 35
mov al,62h
sub al,35h
das
; AL = 2Dh, AF = 1, CF = 0
; AL = 27h, AF = 1, CF = 0
• Exemplo : subtrair BCD 32 – 29
mov al,32h
sub al,29h
das
; AL = 09h, AF = 1, CF = 0
; AL = 03h, AF = 1, CF = 0
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
75
Exemplos de DAS (2 de 2)
 Example: subtrair BCD 32 – 39
mov al,32h
sub al,39h
das
; AL = F9h, AF = 1, CF = 1
; AL = 93h, AF = 1, CF = 1
Steps:
AL = F9h
AF = 1, so subtract 6 from F9h
AL = F3h
F3h > 9Fh, so subtract 60h from F3h
AL = 93h, CF = 1
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
76
Sua vez . . .
 Um mal funcionamento temporário do computador desabilitou a
instrução DAS . Escrever um procedimento em linguagem
Assembly que realiza as mesmas ações do DAS.
 Testar o procedimento usando os valores dos dois slides anteriores.
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
77
Sumário
 Instruções Shift e rotate são algumas das melhores
ferramentas da linguagem assembly
 Controle mais fino que em linguagens de alto nível
 SHL, SHR, SAR, ROL, ROR, RCL, RCR
 MUL e DIV – operações inteiras
 Próximas de SHL e SHR
 CBW, CDQ, CWD: preparação para divisão
 Aritmética de precisão estendida: ADC, SBB
 Operações decimal ASCII (AAA, AAS, AAM, AAD)
 Operações decimal empacotado (DAA, DAS)
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
78
fim
Irvine, Kip R. Assembly Language for Intel-Based
Computers 5/e, 2007.
Web site
Examples
79