= Assembler de x86 = == Modos de Direccionamientos == [[/Direccionamiento|Descripción]] == Banderas == ||Nombre ||Descripción ||Estado = 0 ||Estado = 1 || ||Acarreo ||indica un acarreo o un préstamo en la última operación aritmética, usado también en operaciones de corrimiento y como indicador de error en ciertos programas. ||NC-Sin Acarreo ||CY-Acarreo || ||Desborde ||Indica cuando el resultado de una operación con signo a excedido la capacidad del uP. ||NV-No hubo desborde ||OV-Desborde || ||Signo ||indica el signo del resultado de la última operación aritmética. ||PL-Positivo ||NG-Negativo || ||Cero ||indica si la última operación dio como resultado cero. ||NZ-No Cero ||ZR-Cero || ||Dirección ||Controla la selección de incremento o decremento de los registros DI o SI en las instrucciones de cadenas. ||UP-Incremento ||DN-Decremento || ||Interrupción ||habilita la entrada de interrupción. ||DI-Interr. anulada ||EI-Interrupción || ||Acarreo auxiliar ||ocurre cuando en una operación aritmética, se produzco un acarreo o un préstamo entre el bit 3 y 4 del resultado. ||NA-Sin Acarreo ||AC-Acarreo || ||Paridad ||es un conteo de unos en la última operación. ||PO-Impar ||PE-Par || == Suma con acarreo == '''ADD''': Esta instrucción suma el primer operador con el segundo y al resultado lo guarda en el primer operador, si hubo acarreo lo guarda en Carry. '''ADC''': Realiza la misma operación que ADD incorporando también el Carry en la suma de los operadores. Para el caso de sumar números cuya longitud supera a los 16 bits del microprocesador o que su resultado sea mayor que 16 bits, se debe recurrir al uso de la suma con acarreo. Esto significa, que en el caso por ejemplo de sumar dos números de 32 bits, se realiza la suma de los 16 bits menos significativos y luego los 16 bits mas significativos junto con el acarreo. == Corrimiento (Shift) Lógico y Aritmético == Grupo de instrucciones que permiten realizar desplazamientos de los bits dentro de un registro o posición de memoria. ||'''SHL''' ||Corrimiento lógico hacia la izquierda || {{attachment:shl.png||width="50%"}} || ||'''SHR''' ||Corrimiento lógico hacia la derecha || {{attachment:shr.png||width="50%"}} || ||'''SAL''' ||Corrimiento Aritmético hacia la izquierda || {{attachment:shl.png||width="50%"}} || ||'''SAR''' ||Corrimiento Aritmético hacia la derecha || {{attachment:sar.png||width="50%"}} || ||'''ROL''' ||Rotación hacia la izquierda || {{attachment:rol.png||width="50%"}} || ||'''ROR''' ||Rotación hacia la derecha || {{attachment:ror.png||width="50%"}} || ||'''RCL''' ||Rotación hacia la izquierda usando acarreo || {{attachment:rcl.png||width="50%"}} || ||'''RCR''' ||Rotación hacia la derecha usando acarreo || {{attachment:rcr.png||width="50%"}} || === Formato de las instrucciones === Si bien se pueden realizar corrimiento o rotaciones de 1 o más bits, solo está permitido en el 8086/8088 el de 1 bit en inmediato, en estos casos para un corrimiento de más de un bits, se debe utilizar un registro auxiliar, el CL Ejemplo de Shift a la derecha de 1 bit {{{ SHR BX,1 }}} Ejemplo de Shift a la derecha de 4 bits {{{ MOV CL,4 SHR BX,CL }}} == Saltos Condicionales e Incondicionales == En todo programa es necesario interrumpir el flujo normal del mismo y saltar a otra porción del código, podemos distinguir dos saltos diferentes: Los condicionales, donde se evalúa una condición y al ser verdadera se produce el salto, es la forma que tiene el ensamblador de realizar IF o estructuras CASE que acostumbrábamos a usar en lenguajes de alto nivel, lo único que aquí lo hacemos en dos pasos, primero comparamos, quedando el resultado en las banderas (ver banderas al comienzo), luego utilizamos alguna de las instrucciones de salto condicional para realizar el salto. El salto incondicional, aquí no hay condición de salto y el mismo se efectúa siempre, es el equivalente al GOTO en lenguajes de alto nivel. === Salto Incondicional === {{{ JMP nn }}} El salto incondicional puede ser dividido en tres tipos. * Salto corto, en este tipo de salto el parámetro nn es un byte, pudiendo saltar desde +127 hasta -128 posiciones a partir de la dirección próxima a JMP. (largo: 1 byte instrucción + 1 byte salto = 2 bytes) * Salto cercano, el parámetro nn es de dos bytes indicando la dirección del puntero a donde va a saltar. (largo: 1 bytes instrucción + 2 bytes salto = 3 bytes) * Salto lejano, nn es de 4 byte, indica la posición absoluta con segmento y puntero del salto. ( largo: 1 byte instrucción + 4 byte salto = 5 bytes ) Generalmente el compilador elije la mejor forma (la más corta) para realizar el salto, no siendo necesario determinar su tipo de forma explicita. === Salto condicionales === Este tipo de salto depende de las banderas del uP para realizarlo, todos estos saltos son solamente corto, no pudiendo saltar con estas instrucciones mas allá de +127 – 128 bytes. ==== Saltos condicionales para operaciones sin signo ==== ||Instrucción ||Bandera/s||Descripción|| || JA || C = 0 y Z = 0 || Saltar si está por arriba || || JAE || C = 0 || Saltar si está por arriba o es igual || || JB || C = 1 || Saltar si está por abajo || || JBE || C = 1 o Z = 1 || Saltar si está por debajo a igual || ==== Saltos condicionales para operaciones con signo ==== ||Instrucción ||Bandera/s||Descripción|| || JG || Z = 0 y S = Ov || Saltar si es mayor || || JGE || S = Ov || Saltar si es mayor o igual || || JL || S <> Ov || Saltar si es menor || || JLE || Z = 1 o S <> Ov || Saltar si es menor o igual || || JNS || S = 0 || Saltar si no hay signo || || JS || S = 1 || Saltar si hay signo || ==== Otros saltos ==== ||Instrucción ||Bandera/s||Descripción|| || JE o JZ || Z = 1 || Saltar si es igual o cero || || JNE o JNZ || Z = 0 || Saltar si no es igual o cero || || JC || C = 1 || Saltar si hay acarreo || || JNC || C = 0 || Saltar si no hay acarreo || || JNO || Ov = 0 || Saltar si no hay overflow || || JNP o JPO || P = 0 || Saltar si no hay paridad o paridad impar || || JO || Ov = 1 || Saltar si hay overflow || || JP o JPE || P = 1 || Saltar si hay paridad o paridad par || || JCXZ || CX = 0 || Saltar si CX = 0 || Todos los saltos condicionales están limitados a saltos cortos (+127 bytes a -128 bytes ) para el 8086/80286 o saltos cercanos para 80386 y superiores (saltos dentro del segmento), en caso de necesitar realizar un salto a otro segmento, se debe recurrir a la utilización de una instruccion inversa a la utilizada originalmente acompañada por un salto incondicional ejemplo {{{ JC salto_lejano }}} se sustituye por {{{ JNC seguir JMP salto_lejano seguir: }}}