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

Por: Frederico Pissarra


i--------------
 ASSEMBLY III 
--------------

    Comecemos   a   dar    uma    olhadela    na   arquitetura   dos
microprocessadores   da   famlia    INTEL   80x86...    Vamos   aos
registradores!

    Entenda  os  registradores  como  se  fossem  variveis  que   o
microprocessador  disponibiliza  ao sistema.  TODOS os registradores
tm 16 bits de tamanho e aqui vai a descrio deles:

     +------+
       AX  <--+
     +------   
       BX  <--
     +------   +- Registradores de uso geral
       CX  <--
     +------   
       DX  <--+
     +------+
     +------+
       SI  <---- ndice FONTE (Source Index)
     +------
       DI  <---- ndice DESTINO (Destination Index)
     +------+
     +------+
       SP  <---- Apontador de pilha (Stack Pointer)
     +------
       BP  <---- Apontador de base (Base Pointer)
     +------+
     +------+
       CS  <---- Segmento de Cgido (Code Segment)
     +------
       DS  <---- Segmento de Dados (Data Segment)
     +------
       ES  <---- Segmento de dados Extra (Extra data Segment)
     +------
       SS  <---- Segmento de Pilha (Stack Segment)
     +------+
     +------+
       IP  <---- Apontador de instruo (Instruction Pointer)
     +------+
     +------+
     Flags <---- Sinalizadores
     +------+

    Por  enquanto vamos nos deter na descrio dos registradores uso
geral...  Eles podem ser  subdivididos  em dois registradore de oito
bits cada:

        AX (16 bits)            BX (16 bits)
    +-----------------+     +-----------------+
    +-----------------+     +-----------------+
       AH      AL           BH      BL   
    +-----------------+     +-----------------+
    15      8 7      0      15      8 7      0

        CX (16 bits)            DX (16 bits)
    +-----------------+     +-----------------+
    +-----------------+     +-----------------+
       CH      CL           DH      DL   
    +-----------------+     +-----------------+
    15      8 7      0      15      8 7      0

    AH  o byte mais significativo do registrador AX,  enquanto  que
AL    o  menos  significativo.   Se  alterarmos  o  contedo de AL,
estaremos alterando  o  byte  menos  significativo  de  AX  ao mesmo
tempo...  No existem registradores  de  oito  bits  em  separado...
tudo    uma  coisa  s.   Portanto,  ao  manipularmos AH, estaremos
manipulando AX ao mesmo tempo!

    O nome de cada registrador tem  o  seu sentido de ser...  "A" de
AX quer dizer  que  este  registrador    um "acumulador" (usado por
default em algumas operaes matematicas!), por exemplo...

    AX  -> Acumulador
    BX  -> Base
    CX  -> Contador
    DX  -> Dados

    O  "X"  de  AX  significa "eXtended".  "H" de AH significa "High
byte".

    Embora estes registradores possam ser usados sem  restries,  
interessante  atribuir  uma  funo  para  cada  um deles nos nossos
programas sempre que possvel...  Isto  facilita a leitura do cdigo
e nos educa a seguirmos uma  linha  de  raciocnio  mais  concisa...
Mas,  se  for  de  sua preferncia no seguir qualquer padro no uso
desses  registradores,  no  se  preocupe...   no  haver  qualquer
desvantagem nisso  (Well...   depende  do  cdigo,  as  vezes  somos
obrigados a usar determinado registrador!).

    Alguns pontos importantes quanto  a esses nomes sero observados
no decorrer do curso...  Por exemplo, certas instrues usam AX  (ou
AL, ou AH) e  somente  ele,  no  permitindo  o  uso de nenhum outro
registrador...   Outras,  usam  CX  para   contar,   etc...    essas
instrues especficas sero vistas em outra oportunidade.

    Os registradores SI e DI  so  usados como ndices para tabelas.
Em particular, SI  usado para leitura  de  uma  tabela  e  DI  para
escrita  (fonte  e  destino...   lembra algum procedimento de cpia,
nao?).  No entanto, esses registradores  podem ser usados com outras
finalidades...  Podemos inclu-los no grupo de "registradores de uso
geral",  mas  assim como alguns registradores de uso geral, eles tm
aplicao exclusiva  em  algumas  instrues,  SI  e  DI  so usados
especificamente  como  ndices  em  instrues  que manipulam blocos
(tambm veremos isso mais tarde!).

    Os registradores CS, DS,  ES  e  SS  armazenam os segmentos onde
esto o cdigo  (programa  sendo  executado),  os  dados,  os  dados
extras,  e  a  pilha,  respectivamente.   Lembre-se  que a memria 
segmentada em blocos de 64kbytes (d uma olhada na primeira mensagem
dessa srie).

    Quando nos referimos, atravs de alguma instruo, a um endereo
de memria, estaremos nos referindo ao OFFSET dentro de um segmento.
O registrador de  segmento  usado  para  localizar  o dado no offset
especificado vai depender da prpria  instruo...   Um  exemplo  em
assembly:

 +----------------------------------------------------------------+
       MOV     AL,[1D4Ah]                                        
 +----------------------------------------------------------------+

    O  nmero  hexadecimal  entre  os  colchetes  a indicao de um
offset em um segmento...  Por  default, a maioria das instrues usa
o segmento de dados (valor em  DS).  A instruo acima  equivalente
a:

 +----------------------------------------------------------------+
       AL = DS:[1D4Ah]                                           
 +----------------------------------------------------------------+

    Isto , em AL ser colocado o byte que est armazenado no offset
1D4Ah  do  segmento  de  dados (valor em DS).  Veremos mais sobre os
segmentos e as instrues mais tarde :)

    Se quisessemos localizar o byte  desejado em outro segmento (mas
no mesmo offset) devemos especificar o registrador  de  segmento  na
instruo:

 +----------------------------------------------------------------+
       MOV     AL,ES:[1D4Ah]                                     
 +----------------------------------------------------------------+

    Aqui o valor de ES ser usado.

    O registrador IP (Instruction Pointer)  o offset do segmento de
cdigo  que  contm  a  prxima  instruo  a  ser  execuatda.  Este
registrador no  acessvel por qualquer instruo (pelo  menos  no
pelas   documentadas   pela   Intel)...       de   uso  interno  do
microprocessador.    No   entanto   existem   alguns   macetes  para
conseguirmos obter o seu contedo (o que na maioria  das  aplicaes
no    necessario...   Para  que  conhecer  o  endereo  da prxima
instruo se ela var ser executada de qualquer jeito?).

    O registrador SP  o offset do segmento SS (segmento  de  pilha)
onde o prximo dado vai ser empilhado.  A pilha serve para armazenar
dados  que posteriormente podem ser recuperados sem que tenhamos que
usar um  dos  registradores  para  esse  fim.   Tambm   usada para
armazenar o endereo de retorno das sub-rotinas.  A  pilha  "cresce"
de  cima  para baixo, isto , SP  decrementado cada vez que um novo
dado  colocado na pilha.  Note  tambm que existe um registrador de
segmento exclusivo para a pilha... SP sempre est relacionado a  esse
segmento (SS), como foi dito antes.

    Para  ilustrar  o  funcionamento  da  pilha,  no  grfico abaixo
simularemos o empilhamento do contedo do registrador AX atravs  da
instruo:

 +-----------------------------------------------------------------+
       PUSH    AX                                                 
 +-----------------------------------------------------------------+

 +-----------------------------------------------------------------+
   AX = A527h (Valor em AX)                                       
                                                                  
    +-------+                       +-------+                     
     ????h <----- SP = n           A527h                      
    +-------                       +-------                     
                                         <----- SP = n - 1    
    +-------+                       +-------+                     
                                                                  
  (antes de PUSH AX)              (depois de PUSH AX)             
 +-----------------------------------------------------------------+

    Observe que SP sempre aponta para um espao vago na pilha.

    Na  realidade  SP    decrementado  de duas posies ao invs de
apenas uma... mas, esse detalhe deixo para mais tarde.

    O registrador BP pode ser usado como apontador para  a  base  da
pilha (j que,  por  default,  est  relacionado  a  SS)  ou como um
registrador de uso geral...  depende do seu programa.  Veremos  isso
detalhadamente mais tarde.

    Um   dos    registradores    mais    importantes   de   qualquer
microprocessador  o de "Flags".  Eis uma descrio dos  bits  deste
registrador  (a descrio abaixo aplica-se ao 8086.  Normalmente no
acessamos diretamente  o  registrador  de  flags  -  embora possamos
faz-lo - por isso no  conveniente assumirmos que  os  bits  esto
sempre  no  mesmo  lugar  para  qualquer microprocessador da famlia
80x86!):

 +----------------------------------------------------------------+
             +-------------------------------+                   
                 ODITSZ A P C                   
             +-------------------------------+                   
             15                             0                    
                                                                 
   C = Carry                                                     
   P = Parity                                                    
   A = Auxiliar Carry                                            
   Z = Zero                                                      
   S = Signal                                                    
   T = Trap                                                      
   I = Interrupt Enable Flag                                     
   D = Direction                                                 
   O = OverFlow                                                  
 +----------------------------------------------------------------+

     Carry:

        Esse  flag   setado sempre quando houver "vai um" depois de
    uma  adio  ou  quando  h  BORROW depois de uma subtrao.  Ou
    quando, numa operao de  deslocamento  de  bits,  o bit mais ao
    extremo for deslocado para fora do dado (suponha um byte...   se
    todos  os bits forem deslocados em uma posio para a direita, o
    que acontece com o bit 0?...  Resposta: Vai para o carry!)

     Parity:

        Depois  de  uma  instruo  aritimtica  ou  lgica este bit
    informa se o resultado tem um nmero par de "1"s ou no.

     Auxiliar Carry:

        Igual ao carry, mas indica o "vai um" no meio de um dado (no
    caso de um byte, se houve "vai um" do bit 3 para o bit 4!).

     Zero:

        Depois de  uma  operao  aritimtica  ou  lgica, esse flag
    indica se o resultado  zero ou no.

     Signal:

        Depois de uma instruo aritimtica ou lgica, este  flag  
    uma  cpia  do  bit de mais alta ordem do resultado, isto , seu
    sinal (d uma olhada  na  "representao de nmeros negativos em
    binrio" no texto anterior!).

     Trap:

        Quando setado (1)  executa  instrues passo-a-passo...  No
    nos interessa estudar esse  bit  por  causa  das  diferenas  de
    implementao deste flag em toda a famlia 80x86.

     Interrupt Enable Flag

        Habilita/Desabilita   o   reconhecimento   de   interrupes
    mascarveis pela CPU. Sobre interrupes, veremos mais tarde!

     Direction:

        Quando   usamos   instrues   de   manipulao  de  blocos,
    precisamos especificar a direo que  usaremos (do inicio para o
    fim ou do fim para o inicio).
        Quando D=0 a direo  a do incio para o fim...  D=1, ento
    a direo  contrria!

     OverFlow:

        Depois de uma instruo  aritimtica  ou  lgica,  este  bit
    indica se houve mudana no bit mais significativo, ou  seja,  no
    sinal.  Por exemplo, se somarmos FFFFh + 0001h obteremos 00h.  O
    bit  mais  significativo variou de 1 para 0 (o countedo inicial
    de um registrador era FFFFh  e  depois  da soma foi para 0000h),
    indicando que o resultado saiu da faixa (overflow) - ora,  FFFFh
    +  0001h = 10000h, porm um registrador tem 16 bits de tamanho e
    o resultado cabe em  17  bits.   Neste  exemplo,  o bit de carry
    tambm ser setado  pois  houve  "vai  um"  do  bit  15  para  o
    inexistente  bit  16,  mas no confunda o flag de overflow com o
    carry!

    Quando aos demais bits, no  se pode prever seus estados lgicos
(1 ou 0).

    Na prxima  mensagem  comearemos  a  ver  algumas instrues do
microprocessador 8086.  Ainda no escreveremos  nenhum  programa,  a
inteno    familiariz-lo  com  a  arquitetura do microprocessador
antes de comearmos a colocar a  mo  na massa...  tenha um pouco de
pacincia! :)
