Arquitectura de PCs Lenguaje ASM Intel 8088

Lenguaje de máquina y ASM Toda CPU interpreta su código de máquina propio Instrucciones en código de máquina son números almacenados en la memoria Cada instrucción inicia con el código de operación u OPCODE de la instrucción, seguido de una serie de operandos

La codificación a lenguaje de máquina es tarea de un programa denominado “ensamblador” El ensamblador toma como entrada un programa en lenguaje Assembler – abreviado “ASM” Cada instrucción ASM representa una instrucción en código de máquina. Por ejemplo: Lenguaje de máquina y ASM Instrucción sumar AX y BX, y cargar resultado en AX Se codifica: Se escribe en ASM: 03C3H add ax,bx

Cada CPU tiene su lenguaje ASM propio La familia Intel 80x86 tiene varios ensambladores, cada uno con sintaxis ASM propia En el curso se utiliza NASM (Netwide Assembler) - libre y open source Lenguaje de máquina y ASM

El lenguaje Assembler En su forma más simple, programa ASM es una secuencia de instrucciones ASM Se permiten líneas en blanco Comentarios: siguen al carácter ‘;’

El lenguaje Assembler Formato general de instrucción ASM: Opcional: refiere a dirección de instrucción en memoria Operación de la instrucción; por ej. “ADD” 0 a 3 operandos de uno de los siguientes tipos: registro dato en memoria: referido por el offset respecto de DS inmediato: constante que forma parte de la instrucción implícito: no aparece en instrucción (por ej. “1” en instrucción “INC”) etiqueta: mnemónico operando(s)

Instrucción MOV Instrucción MOV: copia un operando en otro mov dest, src movax,33 -> ax (3 = operando inmediato) movbx,axax -> bx Ejemplos: De aquí en adelante: Descripción de la instrucción Sintaxis genérica Ejemplo ASMComentarios ejemplos o sintaxis genérica

Operaciones con enteros El ASM considera 2 tipos de representaciones de enteros: sin signo: forma binaria convencional. Por ej.: 200 = b = C8H. con signo: opuesto por complemento a 2

Operaciones con enteros Complemento a 2: Se invierte valor de cada bit Se añade 1 al resultado = = -56 Complemento a 2 PositivoNegativo = 56 Complemento a 2

Operaciones con enteros La representación del tipo de número de un dato (por ej., 0FFH como 255 o como –1) depende del programador y no de la CPU

Suma: ADD (suma operandos) y ADC (suma operandos más CF) addax,4ax = ax + 4, bandera CF de FLAGS = acarreo Aritmética Operaciones con enteros addax,cx adcdx,bx ax = ax + cx, CF = acarreo dx = dx + bx + CF. Resultado: dx_ax = dx_ax + bx_cx Multiplicación: MUL (sin signo) e IMUL (complemento a 2) Resta: SUB (resta operandos) y SBB (resta operandos menos CF) mul source si source es un byte ax = al * source si source es una palabra, dx_ax = ax * source División: DIV (sin signo) e IDIV (complemento a 2) div source source = divisor. Si es byte, ax = dividendo, al = cociente, ah = resto. Si es palabra, dx_ax = div, ax = coc, dx = resto Si divisor = 0, CPU ejecuta INT 0

Operaciones con enteros movah, 0Extiende AL en AX sin signo cbwExtiende AL en AX con signo Extensión (cambio de tamaño) de un dato para combinarlo con otro dato Extensión

Estructuras de control Una estructura de control decide una acción en función de la comparación de datos. En ASM se implementan a partir de: Instrucción de comparación Saltos Instrucciones tipo “LOOP” Instrucción CMP escribe FLAGS según la comparación de 2 operandos cmp vleft, vrightBits de FLAGS (ZF, CF, etc.) según (vleft – vright)

Estructuras de control Saltos Salto condicional: salta según bits de FLAGS. Si no salta se ejecuta instrucción siguiente. Existen muchas tipos de saltos condicionales. cmpax, bx jziguales Salta si ZF = 0, esto es, AX = BX cmpax, bx jnzdistintos Salta si ZF = 1, esto es, AX != BX cmpax, bx jge ax_mayoig Salta si AX >= BX, considerados enteros con signo cmpax, bx jae ax_mayoig Salta si AX >= BX, considerados enteros sin signo Salto incondicional: instrucción JMP. Puede ser relativo (operando es un offset positivo o negativo) o absoluto (operando = segmento:offset)

Estructuras de control Pseudo código de alto nivel if (ax == 0) bx=1; else bx=2; Saltos cmpax, 0 jzthen movbx, 2 jmp next then:movbx, 1 next: Si (ax == 0) -> salta a then Si no, bx = 2 y termina bx = 1

Estructuras de control Instrucción LOOP: decrementa CX, y si CX != 0 salta a etiqueta Variantes: LOOPE, LOOPNE Aplicación: bucles tipo for sum = 0; for ( i=10; i >0; i-- ) sum += i; movax, 0 movcx, 10 loop_start: addax, cx looploop_start ax es sum cx es i

Operaciones con bits Las operaciones con bits modifican los bits individuales de un dato. Se clasifican en: Desplazamientos: cambian de posición los bits de un dato. Sentido: Izquierda: hacia MSB Derecha: LSB Operaciones booleanas por bit: AND, OR, XOR, NOT de datos bit a bit

Operaciones con bits Desplazamientos Desplazamientos: SHL izquierdo, SHR derecho. Bits entrantes nulos Aplicación: división y multiplicación por 2 N SHL operando, nronro = cte o CL. CF = bit desplazado hacia afuera mov ax, 0C123H shl ax, 1 shr ax, 1 AX = AX = , CF = 1 AX = , CF = 0 Rotación: bit saliente por un lado entra por el otro. ROL izquierdo, ROR derecho. RCL y RCR rotan dato extendido con CF. ROL operando, nronro = cte o CL. CF = bit rotado mov ax, 0C123H rol ax, 1 AX = AX = , CF = 1

Operaciones con bits Booleanas por bit Instrucciones AND, OR, XOR, NOT: operación bit a bit Aplicaciones: encender bit N (OR 2 N ) apagar bit N (AND NOT(2 N )) complementar bit N (XOR 2 N ) AND (2 N -1) = resto de división por 2 N mov al, 0AAH mov bl, 0CCH and al, bl AL = BL = AL = Instrucción TEST ejecuta AND sólo modificando FLAGS xor ax,ax AX = 0. Código de máquina más pequeño que “mov ax, 0”

Subprogramas Un subprograma es un programa modular Requiere una interfaz predefinida, basada por ej. en registros de propósito general Salto y retorno de subprograma: CALL y RET Instrucción CALL: salto incondicional a un subprograma, salvando en la pila la dirección de la siguiente instrucción call subprograma Instrucción RET: carga tope de la pila en el registro IP, devolviendo control a instrucción siguiente a call si todo está bien ret Generalidades

Subprogramas Salto a subprograma MultiplicoPor2, que devuelve ax = bx * movbx, 5 callMultiplicoPor2 movbx, ax MultiplicoPor2: movax,bx shlax,1 addax, 4 ret Inicia interfaz a MultiplicoPor2 Ejecuta MultiplicoPor2 Instrucción posterior a ret ax = bx ax = ax * 2 ax = ax + 4 Devuelve control Ejemplo

Subprogramas CALL y RET actúan sobre la pila (stack): lista LIFO (Last In First Out), de modo que el dato quitado de la pila es el último dato añadido SS:SP apunta al “tope de la pila”: dirección del próximo dato a ser quitado de la pila La Pila CS 00000H 1FFFEH FFFFFH 10000H 10400H 11000H SS MOV BX, 5 CALL MULTIPLICOPOR2 MOV AX, BX 1FFFCH 0000H 10403H 10406H MULTIPLICOPOR2: MOV BX, AX SHL AX,1 ADD AX, 4 RET11007H 11002H 11004H SP 0406H SP

Subprogramas La pila se usa para guardar datos temporalmente La Pila Instrucción PUSH: añade una palabra a la pila, restando 2 a SP y cargando el operando en la dirección SS:SP Instrucción POP: quita una palabra de la pila, cargando la palabra en la dirección SS:SP en registro destino y sumando 2 a SP push word 1 push word 2 pop ax pop bx Carga 1 en 0FFEH, SP = 0FFEH Carga 2 en 0FFCH, SP = 0FFCH ax = 2, SP = 0FFEH bx = 1, SP = 1000H Se supone SP inicial = 1000H Instrucciones PUSHA y POPA: salvan y restauran los registros AX, BX, CX, DX, SI, DI y BP CALL y RET requieren manipulación correcto de la pila

Subprogramas Referencia a dato en memoria: directa o indirecta Referencias a datos Referencia indirecta: dirección lineal definida por uno de los pares DS:BX, DS:DI, ES:SI, SS:BP registro es “bx”, “di”, “si” o “bp”mov dst,[registro] mov bx, offsetDato mov ax, [bx] bx = offsetDato ax = palabra en DS:BX = DS:offsetDato Referencia directa: offset del dato explícito en la instrucción mov dst,[offset_dato]Escribe dato DS:offset_dato a dst mov ax, [offsetDato]ax = palabra en DS:offsetDato mov word [offDato],4Palabra en DS:offDato = 0004; word determina el tamaño del destino

Arreglos Arreglo (en inglés, “array”): Bloque contiguo de datos considerado una lista Los datos de la lista son del mismo tipo Cada elemento se refiere por el índice del elemento dentro del arreglo: “a[i]” denota al elemento “i” del arreglo “a” El primer elemento tiene índice 0

Arreglos Arreglo inicializado: directivas al ensamblador DB, DW Arreglo no inicializado: directivas al ensamblador RESB, RESW Definición de arreglo a1 db 1,2,3,4,5,6,7,8,9,10Arreglo de 10 bytes inicializado a 1,2,..10 a2 dw 0,0,0,0,0,0,0,0,0,0 Arreglo de 10 palabras inicializado a 0,0,..0 a3 times 10 dw 0 Arreglo de 10 palabras inicializado a 0,0,..0 a5 resw 10Arreglo de 100 palabras no inicializadas a6 resb 100Arreglo de 100 bytes no inicializados

Arreglos Acceso a elementos Dirección de a[i]: a + [tamaño de elementos] * i array1 db 5,4,3,2,1 mov al, [array1] mov al, [array1+1] mov [array1+3], al Arreglo de bytes inicializado AL = array1[0] AL = array1[1] array[3] = AL array2 dw 5,4,3,2,1 mov ax, [array2] mov ax, [array2+2] mov [array2+6], ax mov ax, [array2+1] Arreglo de palabras inicializado AX = array2[0] AX = array2[1] (NO array2[2]!) array2[3] = AX ax = ¿?

Arreglos Referencia indirecta genérica -Registro base = “BX” o “BP” -Registro índice = “SI” o “DI” -Constante = constante inmediata [registro base + registro índice + constante]

Instrucciones de arreglos - DS:SI apunta a origen - ES:DI apunta a dato destino - Incremento o decremento automático de SI y/o DI según valor de “bit de dirección” de FLAGS Operación general cld Inicio de bit de dirección de FLAGS: CLD y STD Bit de dirección = 0 stdBit de dirección = 1 Error común: no iniciar bit de dirección de FLAGS

Instrucciones de arreglos lodsb Transferencia de dato de arreglo con AX / AL: LODSx, STOSx, x = B o W AL = [DS:SI]; SI = SI +/- 1AX = [DS:SI]; SI = SI +/- 2 stosb [ES:DI] = AL; DI = DI +/- 1 stosw[ES:DI] = AX; DI = DI +/- 2 array1 dw 1,2,3,4,5,6,7,8,9,10 array2 resw 10 cld mov si, array1 mov di, array2 mov cx,10 lp: lodsw stosw loop lp Arreglo origen Arreglo destino No olvidarse! lodsw Copia array1 a array2

Instrucciones de arreglos movsb Transferencia entre datos de arreglos: MOVSx [ES:DI] = byte [DS:SI]; SI = SI +/- 1; DI = DI +/- 1 movsw [ES:DI] = word [DS:SI]; SI = SI +/- 2; DI = DI +/- 2 Copia array1 a array2 array1 dw 1,2,3,4,5,6,7,8 array2 resw 8 cld mov si, array1 mov di, array2 mov cx,8 lp: lodsw stosw loop lp array1 dw 1,2,3,4,5,6,7,8 array2 resw 8 cld mov si, array1 mov di, array2 mov cx,8 lp: movsw loop lp Prefijo REP actúa en combinación con CX array1 dw 1,2,3,4,5,6,7,8 array2 resw 8 cld mov si, array1 mov di, array2 mov cx,8 rep movsw rep

Instrucciones de arreglos Instrucciones de comparación para arreglos determinan bits de registro FLAGS, análogamente a CMP:

Instrucciones de arreglos Ejemplo: busca número 12 en arreglo: array resw100 cld mov di, array ; apunta di a inicio de array mov cx, 100; número de elementos mov ax, 12; número a buscar lp: scasw je encontrado loop lp ;código para el caso en que no se encuentra jmpno_encontrado encontrado: subdi,2; apunta di al elemento = a 12

Acceso al espacio de E/S El espacio de entrada salida se accede por las instrucciones IN y OUT La instrucción IN tiene dos formatos, donde “port” es una constante inmediata, o DX o DL: in al, port ; lee puerto port en al in ax, port ; lee puerto port en ax Instrucción OUT formato similar a IN: escribe en el puerto indicado por port el valor en AL o AX