             i----------------------------------------------
              RBT      Curso de Assembly      Aula N 06 
             ----------------------------------------------

Por: Frederico Pissarra


i-------------
 ASSEMBLY VI 
-------------

    Instrues aritimticas  so  o  tpico  de  hoje.   J discuti,
brevemente,  os  flags  e  os  sistemas  de numerao.  Aqui vai uma
aplicao prtica:

  Soma:

    A  soma    feita atravs das instrues ADD e ADC.  A diferena
entre elas  que uma faz  a  soma  normalmente e a outra faz a mesma
coisa acrecentando o contedo do flag CARRY. Eis a sintaxe:

 +-----------------------------------------------------------------+
   ADD AL,10h                                                     
   ADC AH,22h                                                     
                                                                  
   ADD AX,2210h                                                   
 +-----------------------------------------------------------------+

    As duas primeiras instrues fazem exatamente a mesma coisa  que
a  terceira.  Note que na primeiria somamos AL com 10h e o resultado
ficar em AL (se  ocorrer  "vai  um"  nesta  soma  o flag CARRY ser
setado).   A  segunda  instruo  soma  AH  com  22h  MAIS  o  carry
resultante  da  primeira  instruo  e  o  resultado  ficar  em  AH
(novamente  setando  o  flag  carry  se  houver outro "vai um"!).  A
terceira instruo faz a mesma coisa porque soma 2210h a AX, ficando
o resultado em AX e o possvel "vai um" no carry.

    Todos  os  flags  so  afetados  aps  a  execuo  de  uma  das
instrues de soma, exceto: I, D e Trap.


  Subtrao

    Semelhante as instrues  de  soma,  existem  duas instrues de
subtrao: SUB e SBB.  A  primeira  faz  a  subtrao  simples  e  a
segunda  faz  a  mesma  coisa subtraindo tambm o contedo prvio do
flag CARRY (como  uma subtrao o CARRY  conhecido como BORROW!).

    A sintaxe:

 +-----------------------------------------------------------------+
   SUB AL,1                                                       
   SBB AH,0                                                       
                                                                  
   SUB AX,1                                                       
 +-----------------------------------------------------------------+

    Como no exemplo  anterior,  as  duas  primeiras instrues fazem
exatamente o que a terceira faz...  Os flags afetados seguem a mesma
regra das instrues de soma!


  Incremento e decremento:

    As instrues INC e DEC so usadas no lugar  de  ADD  e  SUB  se
quisermos incrementar ou decrementar o contedo de algum registrador
(ou de uma posio de memria) de uma unidade. A sintaxe  simples:

 +----------------------------------------------------------------+
   DEC AX                                                        
   INC BL                                                        
 +----------------------------------------------------------------+

    Os  flags afetados seguem a mesma regra de uma instruo de soma
ou uma de subtrao!


  Multiplicao:

    Os  processadores  da   famlia   80x86  possuem  instrues  de
multiplicao e diviso  inteiras  (ponto  flutuante fica pro 8087).
Alguns cuidados devem ser tomados quando usarmos  uma  instruo  de
diviso (que ser vista mais adiante!).

    Uma   coisa   interessante   com   a   multiplicao    que  se
multiplicarmos dois registradores de  16  bits obteremos o resultado
necessariamente em 32 bits.   O  par  de  registradores  DX e AX so
usados para armazenar esse nmero de 32 bits da seguinte  forma:  DX
ser a word mais significativa e AX a menos significativa.

    Por exemplo, se  multiplicarmos  0FFFFh  por  0FFFFh  obteremos:
0FFFE0001h (DX = 0FFFEh e AX = 0001h).

    Eis  a  regra  para  descobrir  o  tamanho  do restultado de uma
operao de multiplicao:

                +---------------------------------+
                             A * B = M           
                +---------------------------------
                    A          B          M    
                +----------+-----------+----------
                  8 bits     8 bits    16 bits 
                                               
                 16 bits    16 bits    32 bits 
                +---------------------------------+

    A multiplicao sempre ocorrer entre  o acumulador (AL ou AX) e
um outro operando. Eis a sintaxe das instrues:

 +----------------------------------------------------------------+
   MUL BL      ; AX = AL * BL                                    
   IMUL CX     ; DX:AX = AX * CX                                 
 +----------------------------------------------------------------+

    A primeira instruo (MUL) no considera o sinal dos  operandos.
Neste  caso, como BL  de 8 bits, a multiplicao se dar entre BL e
AL e o resultado ser armazenado em AX.

    A segunda instruo leva  em  considerao o sinal dos operandos
e, como CX  de 16 bits, a multiplicao se dar entre CX e AX  e  o
restultado  ser armazenado em DX e AX.  Lembrando que o sinal de um
nmero inteiro depende do seu bit mais significativo!


  Diviso:

    Precisamos tomar cuidado com a  diviso pelo seguinte motivo: Se
o resultado no couber no  registrador destino, um erro de "Division
by zero" ocorrer  (isto  no  est  perfeitamente  documentado  nos
diversos  manuais  que li enquanto estudava assembly 80x86...  Vim a
descobrir este 'macete' numa  antiga  edio  da revista PC MAGAZINE
americana).  Outro cuidado  com o divisor...  se for 0 o mesmo erro
ocorrer!

    A  diviso  pode ser feita entre um nmero de 32 bits e um de 16
ou entre um de 16 e um de 8, veja a tabela:

                +--------------------------------+
                        A / B = Q e resto       
                +--------------------------------
                    A          B     Q e resto
                +----------+-----------+---------
                 32 bits    16 bits   16 bits 
                                              
                 16 bits     8 bits    8 bits 
                +--------------------------------+

    Assim como na multiplicao  o  nmero  (dividendo) de 32 bits 
armazenado em DX e AX.

    Depois da diviso o quociente  armazenado em AL e o resto em AH
(no caso de diviso 16/8 bits) ou o quociente fica em AX e  o  resto
em DX (no caso de diviso 32/8 bits).

    Exemplo da sintaxe:

 +-----------------------------------------------------------------+
   DIV CX      ; AX=DX:AX / CX, DX=resto                          
   IDIV BL     ; AL=AX / BL, AH=resto                             
 +-----------------------------------------------------------------+

    O  primeiro  caso  uma diviso sem sinal e o segundo com sinal.
Note os divisores (CX e BL no nosso exemplo).

    Na diviso 16/8 bits o dividendo  armazenado  em  AX  antes  da
diviso... No caso de 32/8 bits DX e AX so usados...

    Mais  um  detalhe:  Os  flags,  depois  de  uma multiplicao ou
diviso no devem ser considerados.
