Assembly Language for Intel-Based Computers, 5th Edition

Apresentação em tema: "Assembly Language for Intel-Based Computers, 5th Edition"— Transcrição da apresentação:

1 Assembly Language for Intel-Based Computers, 5th Edition
Kip R. Irvine Capítulo 7: Aritmética de Inteiros Slides prepared by the author Revision date: June 4, 2006 (c) Pearson Education, 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.

2 Í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.

3 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.

4 Shift lógico vs. aritmético
O shift lógico preenche as lacunas criadas com zero: O shift aritmético preenche as lacunas criadas com a cópia do bit de sinal: Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

5 Instrução SHL A instrução SHL (shift left) faz o deslocamento lógico à esquerda do operando destino, preenchendo o bit à direita com 0. 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.

6 Fast Multiplication Deslocando 1 bit à esquerda multiplica um número por 2 mov dl,5 shl dl,1 mov dl,5 shl dl,2 ; DL = 20 Deslocando à esquerda n bits multiplica o operando por 2n Exemplo, 5 * 22 = 20 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

7 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. mov dl,80 shr dl,1 ; DL = 40 shr dl,2 ; DL = 10 Deslocando n bits à direita divide o operando por 2n Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

8 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. Um shift aritmético preserva o sinal do número. mov dl,-80 sar dl,1 ; DL = -40 sar dl,2 ; DL = -10 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

9 Sua vez . . . Indicar o valor em hexadecimal de AL após cada shift:
mov al,6Bh shr al,1 a. shl al,3 b. mov al,8Ch sar al,1 c. sar al,3 d. 35h A8h C6h F8h Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

10 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 mov al, b rol al,1 ; AL = b mov dl,3Fh rol dl,4 ; DL = F3h Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

11 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 mov al, b ror al,1 ; AL = b mov dl,3Fh ror dl,4 ; DL = F3h Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

12 Sua vez . . . Indicar o valor hexadecimal de AL após cada rotação:
mov al,6Bh ror al,1 a. rol al,3 b. B5h ADh Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

13 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 clc ; CF = 0 mov bl,88h ; CF,BL = b rcl bl,1 ; CF,BL = b rcl bl,1 ; CF,BL = b Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

14 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 stc ; CF = 1 mov ah,10h ; CF,AH = b rcr ah,1 ; CF,AH = b Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

15 Sua vez . . . Indicar o valor hexadecimal de AL após cada rotação: stc
mov al,6Bh rcr al,1 a. rcl al,3 b. B5h AEh Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

16 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.

17 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 Before: After: Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

18 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.

19 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 Before: After: Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

20 Sua vez . . . Indicar em valor hexadecimal cada operando destino:
mov ax,7C36h mov dx,9FA6h shld dx,ax,4 ; DX = shrd dx,ax,8 ; DX = FA67h 36FAh Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

21 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.

22 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.

23 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( h) ; .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.

24 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 e usar a propriedade distributiva de multiplicação : 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 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

25 Sua vez . . . Multiplicar AX por 26, usando deslocamento e adição.
Dica: 26 = mov ax,2 ; test value mov dx,ax shl dx,4 ; AX * 16 push dx ; save for later 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 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

26 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.

27 Isolando uma cadeia de bits
O campo de data do arquivo MS-DOS empacota o ano, mês e dia em 16 bits: mov ax,dx ; make a copy of DX shr ax,5 ; shift right 5 bits and al, b ; clear bits 4-7 mov month,al ; save in month variable Isolar o campo mês: Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

28 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. 28

29 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.

30 Operandos implícitos:
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.

31 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 = h, CF=1 O flag Carry indica se a metade superior contem dígitos significativos mov eax,12345h mov ebx,1000h mul ebx ; EDX:EAX = h, CF=0 12345h * 1000h, usando operandos de 32-bits: Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

32 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.

33 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, h mov ecx,10000h mul ecx EDX = h, EAX = h, CF = 1 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

34 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.

35 Exemplos de IMUL Multiplicar 4,823,424 * -423:
mov eax, 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.

36 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.

37 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) Formatos: DIV r/m8 DIV r/m16 DIV r/m32 Operandos Default:

38 Exemplos de DIV Dividir 8003h por 100h, usando operandos de 16-bits:
mov dx,0 ; clear dividend, high mov ax,8003h ; dividend, low mov cx,100h ; divisor div cx ; AX = 0080h, DX = 3 Mesma divisão, usando operandos de 32-bits: mov edx,0 ; clear dividend, high mov eax,8003h ; dividend, low mov ecx,100h ; divisor div ecx ; EAX = h, EDX = 3 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

39 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 dx,0087h mov ax,6000h mov bx,100h div bx DX = 0000h, AX = 8760h Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

40 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 dx,0087h mov ax,6002h mov bx,10h div bx Divide Overflow Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

41 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: Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

42 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.

43 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 ; extend AL into AH mov bl,5 idiv bl ; AL = -9, AH = -3 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

44 Exemplos de IDIV Exemplo: divisão de 16-bits de –48 por 5
mov ax,-48 cwd ; extend AX into DX mov bx,5 idiv bx ; AX = -9, DX = -3 Exemplo: divisão de 32-bits de –48 por 5 mov eax,-48 cdq ; extend EAX into EDX mov ebx,5 idiv ebx ; EAX = -9, EDX = -3 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

45 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 ; -513 cwd mov bx,100h idiv bx DX = FFFFh (-1), AX = FFFEh (-2) Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

46 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.

47 Expressões aritmética com sinal (1 de 2)
Exemplo: eax = (-var1 * var2) + var3 mov eax,var1 neg eax imul var2 jo TooBig ; check for overflow add eax,var3 Exemplo: var4 = (var1 * 5) / (var2 – 3) mov eax,var1 ; left side mov ebx,5 imul ebx ; EDX:EAX = product mov ebx,var2 ; right side sub ebx,3 idiv ebx ; EAX = quotient mov var4,eax Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

48 Expressões aritmética com sinal (2 de 2)
Exemplo : var4 = (var1 * -5) / (-var2 % var3); mov eax,var2 ; begin right side neg eax cdq ; sign-extend dividend idiv var3 ; EDX = remainder mov ebx,edx ; EBX = right side mov eax,-5 ; begin left side imul var1 ; EDX:EAX = left side idiv ebx ; final division mov var4,eax ; quotient As vezes é mais fácil calcular o termo à direita primeiro. Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

49 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.

50 Sua vez . . . Implementar a seguinte expressão usando inteiros de 32 bits com sinal. Salvar e restaurar EDX: eax = (ecx * edx) / eax push edx push eax ; EAX needed later mov eax,ecx imul edx ; left side: EDX:EAX pop ebx ; saved value of EAX idiv ebx ; EAX = quotient pop edx ; restore EDX Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

51 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 eax,var1 mov edx,var2 neg edx imul edx ; left side: EDX:EAX mov ecx,var3 sub ecx,ebx idiv ecx ; EAX = quotient mov var3,eax Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

52 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. 52

53 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.

54 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.

55 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 edx,0 mov eax,0FFFFFFFFh add eax,0FFFFFFFFh adc edx,0 ;EDX:EAX = FFFFFFFEh Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

56 Exemplo de adição com precisão estendida
Tarefa: somar 1 a EDX:EAX Valor inicial de EDX:EAX: FFFFFFFFh Somar os 32 bits menos significativos primeiro, acionando o flag Carry. Somar os 32 bits mais significativos, e incluir o flag Carry. mov edx,0 ; set upper half mov eax,0FFFFFFFFh ; set lower half add eax,1 ; add lower half adc edx,0 ; add upper half EDX:EAX = Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

57 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.

58 Exemplo de subtração estendida
Tarefa: Subtrair 1 de EDX:EAX Valor inicial de EDX:EAX: h Subtrair os 32 bits menos significativos primeiro, acionando o flag Carry. Subtrair os 32 bits mais significativos, incluindo o flag Carry. mov edx,1 ; set upper half mov eax,0 ; set lower half sub eax,1 ; subtract lower half sbb edx,0 ; subtract upper half EDX:EAX = FFFFFFFF Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

59 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. 59

60 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.

61 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.

62 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.

63 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 ah,0 mov al,'8' ; AX = 0038h add al,'2' ; AX = 006Ah aaa ; AX = 0100h (adjust result) or ax,3030h ; AX = 3130h = '10' Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

64 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' ; AX = 0039h sub al,‘8' ; AX = 0001h aas ; AX = 0001h, CF=0 or ax,3030h ; AX = ‘01'

65 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 ; first operand mov al,06h ; second operand mul bl ; AX = 001Eh aam ; AX = 0300h Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

66 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 ; dividend aad ; AX = 0025h mov bl,5 ; divisor div bl ; AX = 0207h mov quotient,al mov remainder,ah Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

67 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. 67

68 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.

69 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.

70 Lógica DAA If (AL(lo) > 9) or (AuxCarry = 1) AL = AL + 6 AuxCarry = 1 Else AuxCarry = 0 Endif If (AL(hi) > 9) or Carry = 1 AL = AL + 60h Carry = 1 Carry = 0 se AL = AL + 6 aciona o flag de Carry, esse valor de carry é usado na avaliação de AL(hi). Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

71 Exemplos de DAA Exemplo : calcular BCD 35 + 48
mov al,35h add al,48h ; AL = 7Dh daa ; AL = 83h, AF= 1, CF = 0 Exemplo : calcular BCD mov al,35h add al,65h ; AL = 9Ah daa ; AL = 00h, AF = 1, CF = 1 Exemplo : calcular BCD mov al,69h add al,29h ; AL = 92h, AF = 1 daa ; AL = 98h, AF = 1, CF = 0 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

72 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.

73 Instrução DAS Exemplo : subtrair BCD 35 de 48
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 ; AL = 13h das ; AL = 13h, CF = 0 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

74 Lógica de DAS If (AL(lo) > 9) OR (AuxCarry = 1) AL = AL − 6; AuxCarry = 1; Else AuxCarry = 0; Endif If (AL > 9FH) or (Carry = 1) AL = AL − 60h; Carry = 1; Carry = 0; se AL = AL - 6 aciona o flag de Carry, esse valor é usado na avaliação de AL no segundo IF Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

75 Exemplos de DAS (1 de 2) Exemplo : subtrair BCD 48 – 35
mov al,48h sub al,35h ; AL = 13h das ; AL = 13h, AF=0, CF = 0 Exemplo : subtrair BCD 62 – 35 mov al,62h sub al,35h ; AL = 2Dh, AF = 1, CF = 0 das ; AL = 27h, AF = 1, CF = 0 Exemplo : subtrair BCD 32 – 29 mov al,32h sub al,29h ; AL = 09h, AF = 1, CF = 0 das ; AL = 03h, AF = 1, CF = 0 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

76 Exemplos de DAS (2 de 2) Example: subtrair BCD 32 – 39 mov al,32h
sub al,39h ; AL = F9h, AF = 1, CF = 1 das ; 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.

77 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.

78 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.

79 fim Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.