Curso de Asembler - Operaciones

    Las instrucciones INC y DEC:

Son las m s b sicas a la hora de hacer operaciones con registros: INC,

incrementa el valor de un registro ( o bueno, de cualquier posición en

memoria ) en una unidad, y DEC lo decrementa. Veamos:

INC AX

Incrementa en uno el valor de AX

INC WORD PTR [BX+4]

Incrementa la palabra situada en CS:[BX+4] en uno.

DEC AX

Decrementa AX, le resta uno.

DEC WORD PTR [BX+4]

Decrementa la palabra situada en CS:[BX+4] en una unidad.

Estas dos instrucciones, equivalentes a por ejemplo a "a++" en C, nos

servir n bastante como contadores ( para bucles ).

    Las instrucciones ADD y SUB

Se trata de dos operadores que contiene cualquier lenguaje de

programación: la suma y la resta. Tienen dos operandos, uno de destino y

otro fuente. Para la suma, se suman los dos operandos y se almacena en

el primero (destino), y para la resta, se resta al primero el segundo,

almacen ndose en destino, el primero. Aquí est n algunos formatos de ‚stas

instrucciones:

ADD AX,BX               ; Sumaría AX y BX y lo guardaría en AX

ADD [AX],BX             ; Suma el contenido de la dirección de AX a BX,

;y se almacena en la dirección de AX

ADD AX,[BX]             ; Se suman AX y el contenido de la dirección de

;BX, y se almacena ‚sta suma en AX

ADD AX,3                ; Lo mismo pero utilizando un valor inmediato

;en vez de la BX se¤alada anteriormente.

SUB CL,DL               ; Resta de CL el valor de DL, y se almacena en CL

SUB [CX],DX             ; Se resta al contenido de la dirección de CX

;el valor de DX, y se almacena en la dir. de CX

SUB CX,23h              ; Se resta de CX el valor 23h, y queda en CX el

;resultado

Os habr‚is dado cuenta de una cosa, ¨ y si el resultado excede lo que

puede contener el byte, o la palabra ?. �sto se puede saber mediante los

flags, que trataremos m s adelante.

Tambi‚n os habr‚is fijado en que separ‚ con ; los comentarios. Bien,

‚sta es la manera en ensamblador de poner comentarios, como sería en Basic

la órden "REM", o en C la convención "/* [...] */"

    NEG, NOT y operaciones lógicas

Neg, pone el registro o el lugar al que apunta en memoria en negativo

según la aritm‚tica de complemento a dos tal que : NEG AX o NEG [AX]

Not es la que, como vimos, "invierte" los valores de los bits. Y el

resto de operaciones lógicas tambi‚n las vimos anteriormente. Pondr‚ ahora

tan sólo su sintaxis:

NOT SI                      ; (o Not AX, etc,... o sea, con un registro)

NOT Word ptr es:[ax]        ; Lo realiza sobre la palabra ( 2 bytes )

;que se encuentra en es:[ax]

AND AX,BX                   ; Efectúa un AND entre AX y BX, almacenando

;el resultado en AX ( siempre en el primer

;t‚rmino )

AND [AX],BX                 ; Lo dicho, pero AX apunta a un lugar de

;memoria

AND AX,[BX]

AND Byte ptr [15],3         ; Un AND en la dirección :0015 con lo que

;haya ahí y el valor "3"

OR  AX,BX

OR  [AX],BX

OR  Byte ptr [15],3

OR  DH,55h                  ;Tambi‚n podría hacerse en el AND, se

;confrontan DH y 55h en un OR.

Y todo lo dicho para OR y AND vale para XOR, de tal manera

que las operaciones son realizables entre:

Registro y registro                  CX,DX

Lugar de memoria y registro          [DX],BX

Registro y lugar de memoria          AX,[SI]

Lugar de memoria y número            word ptr ES:[AX],0D533h

Registro y número                    AX,0CD32h

    Multiplicación y división, MUL y DIV

Las pasar‚ algo r pido, ya que para nuestros objetivos no tienen una

necesariedad excesiva, al menos a corto plazo.

Estas operaciones multiplican al acumulador por el operando indicado.

Si el operando es de 8 bits ( 1 byte ), el acumulador es AL. Si el

operando es de 16 bits, el acumulador es AX. El resultado se almacena

en AX o en el par DX-AX respectivamente, si el operando es de 8 bits o

16 bits.

Tambi‚n tendremos que diferenciar entre dos tipos de multiplicaciones

y divisiones que entiende el procesador. Los que comienzan con una I

operan con números con signo ( ‚sto es, si queremos usar números negativos

y tal ), y los que no, con números sin signo.

Visto ‚sto, podremos decir que:

MUL Byte Ptr [CX]

Va a multiplicar el byte que hay en la dirección que marca CX por el

contenido que hay en AL, y una vez hecho ‚sto, va a almacenarlo en AX.

MUL SI

Multiplicaría SI por el contenido de AX, almacen ndose en el par AX-DX.

La palabra superior ( de m s valor ), se devolvería en DX, y la inferior

en AX.

IMUL SI

Esto y el ejemplo anterior sería lo mismo, sólo que operando con

números con signo.

Para la división, el dividendo ha de estar en AX ( y ser 16 bits por

tanto ). El divisor se indica en el operando, por ejemplo en DIV BL, ‚ste

divisor estaría en BL. Se dividiría AX entre BL y el resultado quedaría en

AL, quedando el resto en AH. Vamos a ver algún ejemplo que os veo muy

perdidos:

En la división de un número de diecis‚is bits entre otro de 8 bits, el

cociente y resto ser n de 8 bits ( 1 byte ). El dividendo ha de estar en AX,

y el divisor es el operando de la instrucción, que puede ser un registro o

un sitio en la memoria ( y se necesita poner lo de byte ptr )

O sea, sería tal que:

DIV CL          o       IDIV    BYTE  PTR ES:[BP]

El resultado se devuelve en AL, y el resto en AH. Si por ejemplo AX

valiese 501d y cl valiese 2, a hacer el DIV CL, en AL quedaría 255 y en AH

quedaría 1.

Se puede dividir tambi‚n un número de 32 bits ( 4 bytes ) entre otro de

16 bits ( 2 bytes ), con lo que cociente y resto serían de 16 bits. El

dividendo estaría formado por el par DX/AX. Al hacer por ejemplo un:

DIV SI

Se dividiría DX-AX entre SI, almacen ndose el resultado en AX, y el resto

en DX. Por ejemplo:

Si en DX est  el valor 003Fh y en AX 5555h, el par sería 3F5555h, con lo

que al dividirlo por SI ( que pongamos que vale 0CCC4h ), se almacenaría en

AX el resultado y en DX el resto.

Y ahora pasamos a una parte en la que hay algo de teoría y tal,...