
                               ASSEMBLY
                         Comandos e Instrues (Parte 2)
                                Aula nr. 5 de 26

    Depois  de  algumas  instrues  de  movimentao  de  dados vou
mostrar a mecnica da lgica booleana, bem como algumas instrues.

    A lgica booleana  baseia-se  nas  seguintes operaes: AND, OR,
NOT.   Para  simplificar  a  minha  digitao  vou  usar  a  notao
simplificada: & (AND), | (OR) e ~ (NOT).  Essa notao    usada  na
linguagem C e em muitos manuais relacionados a hardware da IBM.


  Operao AND:

    A operao AND funciona de acordo com a seguinte tabela-verdade:

                           Ŀ
                            S = A & B 
                           ͵
                            A  B  S 
                           Ĵ
                            0  0  0 
                            0  1  0 
                            1  0  0 
                            1  1  1 
                           

    Note que o resultado (S) ser 1 apenas se A "E" B forem 1.
    Aplicando esta lgica bit a bit  em  operaes  envolvendo  dois
bytes obteremos um terceiro byte que ser o primeiro AND o segundo:

 Ŀ
               A = 01010111b       B = 00001111b                 
                                                                 
               S = A & B ->    01010111b                         
                             & 00001111b                         
                                                    
                               00000111b                         
 

    Uma das utilidades  de  AND    resetar  um  determinado bit sem
afetar os demais.   Suponha  que  queira  resetar  o  bit  3  de  um
determinado  byte.   Para  tanto  basta efetuar um AND do byte a ser
trabalhado com o valor 11110111b (Apenas o bit 3 resetado).

    Eis a sintaxe da instruo AND:

  Ŀ
       AND AL,11110111b                                          
       AND BX,8000h                                              
       AND DL,CL                                                 
       AND [DI],AH                                               
  

    Lembrando que o operando destino (o mais a esquerda) deve sempre
ser um  registrador  ou  uma  referencia  a  memria.   o operando a
direita (fonte) pode ser um registrador, uma referncia a memria ou
um  valor  imediato,  com  a  restrio  de  que  no  podemos  usar
referncias a memria nos dois operandos.

    A  instruo  AND  afeta  os  FLAGS  Z, S e P e zera os flags Cy
(Carry) e O (veja os flags em alguma mensagem anterior a esta).


  Operao OR:

                           Ŀ
                            S = A | B 
                           ͵
                            A  B  S 
                           Ĵ
                            0  0  0 
                            0  1  1 
                            1  0  1 
                            1  1  1 
                           

    Note que S ser 1 se A "OU" B forem 1.
    Da  mesma  forma  que  AND,  aplicamos  essa  lgica  bit  a bit
envolvendo  um  byte  ou  word atravs de uma instruo em assembly.
Vejamos um exemplo da utilidade de OR:

 Ŀ
               A = 01010111b       B = 10000000b                 
                                                                 
               S = A | B ->    01010111b                         
                             | 10000000b                         
                                                    
                               11010111b                         
 

    A  operao  OR    ideal  para  setarmos um determinado bit sem
afetar os demais.  No exemplo acima  B  tem apenas o bit 7 setado...
depois da operao OR com A o resultado final foi  A  com  o  bit  7
setado! :)

    A  sintaxe  de OR  a mesma que a de AND (obviamente trocando-se
AND por OR). Os flags afetados so os mesmos da instruo AND!


  Operao NOT:

    NOT simplesmente inverte todos os bits de um byte ou word:

                           Ŀ
                              S = ~A  
                           ͵
                             A    S  
                           Ĵ
                             0    1  
                             1    0  
                           

    A sintaxe da instruo em assembly  a seguinte:

  Ŀ
       NOT AL                                                    
       NOT DX                                                    
       NOT [SI]                                                  
  


  Operao XOR:

    A operao XOR  derivada das trs acima.   A  equao  booleana
que descreve XOR :

 Ŀ
   S = (A AND ~B) OR (~A AND B) = A ^ B                          
 

    Que na tabela-verdade fica:

                           Ŀ
                            S = A ^ B 
                           ͵
                            A  B  S 
                           Ĵ
                            0  0  0 
                            0  1  1 
                            1  0  1 
                            1  1  0 
                           

    Uso  o  simbolo  ^ para o XOR aqui.  XOR funciona da mesma forma
que OR, s que o resultado ser 1 se APENAS A ou  APENAS  B  for  1,
melhor dizendo: Se ambos forem diferentes.

    XOR  muito til quando se quer inverter um determinado  bit  de
um byte ou word sem afetar os outros:

 Ŀ
               A = 01010111b       B = 00001111b                 
                                                                 
               S = A ^ B ->    01010111b                         
                             ^ 00001111b                         
                                                    
                               01011000b                         
 

    No   exemplo  acima  invertemos  apenas  os  quatro  bits  menos
significativos de A.

    A sintaxe e os flags afetados so os mesmos que AND e OR.
                                                                                         
