practica prueba

practica de ciclos

practica perimetro

hola mundo

programa ejemplo

primer codigo en linux

trabajo en clase

Instrcciones Aritméticas 8086/8088

INSTRUCCIONES DE TRANSFERENCIA DE DATOS (No afectan flags)
MOV dest,src
Copia el contenido del operando fuente (src) en el destino (dest).
Operación: dest <- src
Las posibilidades son:
MOV reg,{reg|mem|inmed}
MOV mem,{reg|inmed}
MOV {reg16|mem16},{CS|DS|ES|SS}
MOV {DS|ES|SS},{reg16|mem16}

PUSH src
Pone el valor en el tope del stack.
Operación: SP <- SP - 2, [SP+1:SP] <- src donde src = {reg16|mem16|CS|DS|ES|SS}.

POP dest
Retira el valor del tope del stack poniéndolo en el lugar indicado.
Operación: dest <- [SP+1:SP], SP <- SP + 2 donde dest = {reg16|mem16|DS|ES|SS}.

XCHG reg,{reg|mem}
Intercambia ambos valores.

IN {AL|AX},{DX|inmed (1 byte)}
Pone en el acumulador el valor hallado en el port indicado.

OUT {DX|inmed (1 byte)},{AL|AX}
Pone en el port indicado el valor del acumulador.

XLAT
Realiza una operación de traducción de un código de un byte a otro código de un byte mediante una tabla.
Operación: AL <- [BX+AL]

LEA reg,mem
Almacena la dirección efectiva del operando de memoria en un registro.
Operación: reg <- dirección mem

LDS reg,mem32
Operación: reg <- [mem], DS <- [mem+2]

LES reg,mem32
Operación: reg <- [mem], ES <- [mem+2]

LAHF
Copia en el registro AH la imagen de los ocho bits menos significativos del registro de indicadores.
Operación: AH <- SF:ZF:X:AF:X:PF:X:CF

SAHF
Almacena en los ocho bits menos significativos del registro de indicadores el valor del registro AH.
Operación: SF:ZF:X:AF:X:PF:X:CF <- AH

PUSHF
Almacena los flags en la pila.
Operación: SP <- SP - 2, [SP+1:SP] <- Flags.

POPF
Pone en los flags el valor que hay en la pila.
Operación: Flags <- [SP+1:SP], SP <- SP + 2

INSTRUCCIONES ARITMETICAS (Afectan los flags AF, CF, OF, PF, SF, ZF)
ADD dest,src
Operación: dest <- dest + src.

ADC dest,src
Operación: dest <- dest + src + CF.

SUB dest,src
Operación: dest <- dest - src.

SBB dest,src
Operación: dest <- dest - src - CF.

CMP dest,src
Operación: dest - src (sólo afecta flags).

INC dest
Operación: dest <- dest + 1 (no afecta CF).

DEC dest
Operación: dest <- dest - 1 (no afecta CF).

NEG dest
Operación: dest <- - dest.

donde dest = {reg|mem} y src = {reg|mem|inmed} no pudiendo ambos operandos estar en memoria.

DAA
Corrige el resultado de una suma de dos valores BCD empaquetados en el registro AL (debe estar inmediatamente después de una instrucción ADD o ADC). OF es indefinido después de la operación.

DAS
Igual que DAA pero para resta (debe estar inmediatamente después de una instrucción SUB o SBB).

AAA
Lo mismo que DAA para números BCD desempaquetados.

AAS
Lo mismo que DAS para números BCD desempaquetados.

AAD
Convierte AH:AL en BCD desempaquetado a AL en binario.
Operación: AL <- AH * 0Ah + AL, AH <- 0. Afecta PF, SF, ZF, mientras que AF, CF y OF quedan indefinidos.

AAM
Convierte AL en binario a AH:AL en BCD desempaquetado.
Operación: AH <- AL / 0Ah, AL <- AL mod 0Ah. Afecta PF, SF, ZF, mientras que AF, CF y OF quedan indefinidos.

MUL {reg8|mem8}
Realiza una multiplicación con operandos no signados de 8 por 8 bits.
Operación: AX <- AL * {reg8|mem8}. CF=OF=0 si AH = 0, CF=OF=1 en caso contrario. AF, PF, SF, ZF quedan indefinidos.

MUL {reg16|mem16}
Realiza una multiplicación con operandos no signados de 16 por 16 bits.
Operación: DX:AX <- AX * {reg16|mem16}. CF=OF=0 si DX = 0, CF=OF=1 en caso contrario. AF, PF, SF, ZF quedan indefinidos.

IMUL {reg8|mem8}
Realiza una multiplicación con operandos con signo de 8 por 8 bits.
Operación: AX <- AL * {reg8|mem8} realizando la multiplicación con signo. CF = OF = 0 si el resultado entra en un byte, en caso contrario valdrán 1. AF, PF, SF, ZF quedan indefinidos.

IMUL {reg16|mem16}
Realiza una multiplicación con operandos con signo de 16 por 16 bits.
Operación: DX:AX <- AX * {reg16|mem16} realizando la multiplicación con signo. CF = OF = 0 si el resultado entra en dos bytes, en caso contrario valdrán 1. AF, PF, SF, ZF quedan indefinidos.

CBW
Extiende el signo de AL en AX. No se afectan los flags.

CWD
Extiende el signo de AX en DX:AX. No se afectan flags.

INSTRUCCIONES LOGICAS (Afectan AF, CF, OF, PF, SF, ZF)
AND dest,src
Operación: dest <- dest and src.

TEST dest,src
Operación: dest and src. Sólo afecta flags.

OR dest,src
Operación: dest <- dest or src.

XOR dest,src
Operación: dest <- dest xor src.

Las cuatro instrucciones anteriores ponen CF = OF = 0, AF queda indefinido y PF, SF y ZF dependen del resultado.

NOT dest
Operación: dest <- Complemento a 1 de dest. No afecta los flags.

SHL/SAL dest,{1|CL}
Realiza un desplazamiento lógico o aritmético a la izquierda.

SHR dest,{1|CL}
Realiza un desplazamiento lógico a la derecha.

SAR dest,{1|CL}
Realiza un desplazamiento aritmético a la derecha.

ROL dest,{1|CL}
Realiza una rotación hacia la izquierda.

ROR dest,{1|CL}
Realiza una rotación hacia la derecha.

RCL dest,{1|CL}
Realiza una rotación hacia la izquierda usando el CF.

RCR dest,{1|CL}
Realiza una rotación hacia la derecha usando el CF.

En las siete instrucciones anteriores la cantidad de veces que se rota o desplaza puede ser un bit o la cantidad de bits indicado en CL.

Practica 7 de Septiembre