Arquitectura de PCs Lenguaje ASM Intel 8088 Lenguaje

Arquitectura de PCs Lenguaje ASM Intel 8088

Lenguaje de máquina y ASM n n n 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

Lenguaje de máquina y ASM n n n 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: Instrucción sumar AX y BX, y cargar resultado en AX Se codifica: 03 C 3 H Se escribe en ASM: add ax, bx

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

El lenguaje Assembler n n n 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 n 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” etiqueta: mnemónico operando(s) 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”)

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

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

Operaciones con enteros n Complemento a 2: Se invierte valor de cada bit n Se añade 1 al resultado n 00111000 = 56 Complemento a 2 Positivo 00110111 + 1 00111000 = 56 11000111 + 1 11001000 = -56 Negativo Complemento a 2

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

Aritmética Operaciones con enteros Suma: ADD (suma operandos) y ADC (suma operandos más CF) add ax, 4 ax = ax + 4, bandera CF de FLAGS = acarreo add ax, cx ax = ax + cx, CF = acarreo adc dx, bx dx = dx + bx + CF. Resultado: dx_ax = dx_ax + bx_cx Resta: SUB (resta operandos) y SBB (resta operandos menos CF) Multiplicación: MUL (sin signo) e IMUL (complemento a 2) 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 Si divisor = 0, CPU ejecuta INT 0 source = divisor. Si es byte, ax = dividendo, al = cociente, ah = resto. Si es palabra, dx_ax = div, ax = coc, dx = resto

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

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

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. cmp ax, bx jz iguales cmp ax, bx jnz distintos cmp ax, bx jge ax_mayoig cmp ax, bx jae ax_mayoig Salta si ZF = 0, esto es, AX = BX Salta si ZF = 1, esto es, AX != BX Salta si AX >= BX, considerados enteros con signo 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 Saltos Pseudo código de alto nivel if (ax == 0) bx=1; else bx=2; then: next: cmp ax, 0 jz then Si (ax == 0) -> salta a then mov bx, 2 Si no, bx = 2 jmp next y termina mov bx, 1 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; mov ax, 0 ax es sum mov cx, 10 cx es i loop_start: add ax, cx loop_start

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

Desplazamientos Operaciones con bits Desplazamientos: SHL izquierdo, SHR derecho. Bits entrantes nulos Aplicación: división y multiplicación por 2 N SHL operando, nro = cte o CL. CF = bit desplazado hacia afuera mov ax, 0 C 123 H AX = 1100 0001 0010 0011 shl ax, 1 AX = 1000 0010 0100 0110, CF = 1 shr ax, 1 AX = 0100 0001 0010 0011, 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, nro = cte o CL. CF = bit rotado mov ax, 0 C 123 H AX = 1100 0001 0010 0011 rol AX = 1000 0010 0100 0111, CF = 1 ax, 1

Booleanas por bit Operaciones con bits 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, 0 AAH AL = 1010 mov bl, 0 CCH BL = 1100 and al, bl AL = 1000 xor AX = 0. Código de máquina más pequeño que ax, ax “mov ax , 0” Instrucción TEST ejecuta AND sólo modificando FLAGS

Subprogramas n n n Generalidades 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

Ejemplo Subprogramas Salto a subprograma Multiplico. Por 2, que devuelve ax = bx * 2 + 4 mov bx, 5 Inicia interfaz a Multiplico. Por 2 call Multiplico. Por 2 Ejecuta Multiplico. Por 2 mov bx, ax Instrucción posterior a ret . . Multiplico. Por 2: mov ax, bx ax = bx shl ax, 1 ax = ax * 2 add ax, 4 ax = ax + 4 ret Devuelve control

La Pila Subprogramas n n 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 FFFFFH 1 FFFEH 0000 H 0406 H 1 FFFCH 11007 H RET 11004 H ADD AX, 4 11002 H SHL AX, 1 11000 H MOV BX, AX 10406 H MOV AX, BX 10403 H CALL MULTIPLICOPOR 2 10400 H MOV BX, 5 10000 H 00000 H SP SP MULTIPLICOPOR 2: CS SS

La Pila Subprogramas n La pila se usa para guardar datos temporalmente 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 Se supone SP inicial = 1000 H push word 1 Carga 1 en 0 FFEH, SP = 0 FFEH push word 2 Carga 2 en 0 FFCH, SP = 0 FFCH pop ax ax = 2, SP = 0 FFEH pop bx bx = 1, SP = 1000 H CALL y RET requieren manipulación correcto de la pila Instrucciones PUSHA y POPA: salvan y restauran los registros AX, BX, CX, DX, SI, DI y BP

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

Arreglos n Arreglo (en inglés, “array”): n n 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 Definición de arreglo Arreglo inicializado: directivas al ensamblador DB, DW a 1 db 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 Arreglo de 10 bytes inicializado a 1, 2, . . 10 a 2 dw 0, 0, 0, 0 Arreglo de 10 palabras inicializado a 0, 0, . . 0 a 3 times 10 dw 0 Arreglo de 10 palabras inicializado a 0, 0, . . 0 Arreglo no inicializado: directivas al ensamblador RESB, RESW a 5 resw 10 Arreglo de 100 palabras no inicializadas a 6 resb 100 Arreglo de 100 bytes no inicializados

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

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

Operación general 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 Inicio de bit de dirección de FLAGS: CLD y STD cld Bit de dirección = 0 std Bit de dirección = 1 Error común: no iniciar bit de dirección de FLAGS

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

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

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

Instrucciones de arreglos n Ejemplo: busca número 12 en arreglo: array resw 100 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 jmp no_encontrado: sub di, 2 ; apunta di al elemento = a 12

Acceso al espacio de E/S n n 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: n n n 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 port el valor en AL o AX