Fundamentos de Computadores

Tema 3 LENGUAJE ENSAMBLADOR

INTRODUCCIÓN ____________________________________1 Uso de un lenguaje ensamblador _____________________3 Inconvenientes del lenguaje ensamblador ______________3 Elección de un lenguaje ensamblador _________________3 ARQUITECTURA DEL µP MIPS R2000 _________________4 Simulador de MIPS R2000: SPIM ____________________5 INSTRUCCIONES BASICAS___________________________7 Empleo de variables temporales ______________________8 Operandos ________________________________________8 Accesos a memoria _________________________________9 Accesos a estructuras de datos ______________________10 Direccionamiento de la memoria ____________________11 MODOS DE DIRECCIONAMIENTO ___________________13 Direccionamiento a registro ________________________13 Direccionamiento inmediato ________________________13 Direccionamiento base o desplazamiento ______________14 Direccionamiento relativo al contador de programa ____14 INSTRUCCIONES DE BIFURCACIÓN O SALTO ________15 Salto incondicional ________________________________15 Salto condicional__________________________________16 FORMATO DE LAS INSTRUCCIONES_________________19 Formato R _______________________________________19 Formato I________________________________________20 FUNDAMENTOS DE COMPUTADORES Tema 3. Lenguaje Ensamblador

Contenido - I

Formato J _______________________________________21 JUEGO DE INSTRUCCIONES ________________________22 USO DE REGISTROS Y MEMORIA ___________________28 Registros de la CPU _______________________________28 Distribución de la memoria _________________________30 PROGRAMACIÓN EN ENSAMBLADOR _______________31 EJEMPLOS ________________________________________33 PROGRAMACIÓN MEDIANTE SUBRUTINAS __________39 Paso de parámetros _______________________________41 Preservación de registros ___________________________41 EJEMPLOS ________________________________________42 MANEJO DE DATOS EN COMA FLOTANTE ___________47 Instrucciones para coma flotante ____________________47 LLAMADAS AL SISTEMA ___________________________50 EJEMPLO _________________________________________51 PROGRAMAS RECURSIVOS _________________________52 Estructura de la pila _______________________________52 Diseño (ejemplo factorial) __________________________53 REGULARIDAD Y ORTOGONALIDAD_________________54 EJEMPLOS: _______________________________________55 Programa que detecta cadenas capicuas.______________55 Cálculo de la serie de fibonazzi. _____________________55 Conversión a formato IEEE 754. ____________________55 FUNDAMENTOS DE COMPUTADORES Tema 3. Lenguaje Ensamblador

Contenido - II

INTRODUCCIÓN ◊ Instrucción: Palabra de un lenguaje que especifica alguna acción. ◊ Juego de instrucciones: Cto. de todas las instrucciones que forman un lenguaje. ◊ Lenguaje Máquina: Lenguaje de programación que entiende un ordenador directamente. ◊ Lenguaje Ensamblador: Abstracción de lenguaje máquina para hacerlo más fácil de programar. ◊ Lenguaje de Alto Nivel: Lenguaje de programación abstracto más cercano al lenguaje humano natrual.

Lenguaje de Alto Nivel

Compilador

Lenguaje Ensamblador Ensamblador Lenguaje Máquina

FUNDAMENTOS DE COMPUTADORES Tema 3. Lenguaje Ensamblador

1

Lenguaje de alto nivel (C): int suma(int a, int b) { c=a+b; } Lenguaje Ensamblador: suma: lw $16, O($22) lw $17, O($23) add $15, $16, $17 sw $15, O($21) jr $31 Lenguaje Máquina: 01010000110011101010100010010101 01111010010101010100010111010110 01010010111011010101010101010101 10101011101100100101110101100100 01011010101100100111110100010101 01101010101110101101010101010101 10101001000101011110101010010101 01101011000101010101001011011011

FUNDAMENTOS DE COMPUTADORES Tema 3. Lenguaje Ensamblador

2

Uso de un lenguaje ensamblador • Velocidad • Tamaño • Carencia de compiladores

Inconvenientes del lenguaje ensamblador • Dependientes de la máquina • Programas más largos (factor de expansión) • Depuración difícil. • Compiladores muy optimos.

Elección de un lenguaje ensamblador CISC 1970

1980

1990

CISC: Complex Instruction Set Comp. RISC: Reduced Instruction Set Comp. RISC

680X0, 80X86 RX000, PowerPC, Sparc, Alpha MIPS R2000

FUNDAMENTOS DE COMPUTADORES Tema 3. Lenguaje Ensamblador

3

ARQUITECTURA DEL µP MIPS R2000 Simple y regular. Bus de datos: 32bits Bus de direcciones: 32bits → 4Gb de direccionamiento

MIPS R2000

Coprocesador Matemático R2010

Memoria Principal

Bus del Sistema

$0 $1 $2 $3

· · · $31

hi lo

UAL

Status Cause EPC BadVAddr

MMU con TLB

Coprocesador 0

PC

FUNDAMENTOS DE COMPUTADORES Tema 3. Lenguaje Ensamblador

4

$0 $1 $2 $3

· · ·

Unidad de división

Unidad de multiplicación

$31

Coprocesador 1 • FPU. Números en coma flotante IEEE 754 • Modo Usuario y Modo Núcleo • Unidad de control cableada y segmentada • Cache externa separada para datos y programa.

Simulador de MIPS R2000: SPIM ◊ Programa capaz de ejecutar programas para MIPS R2000 y R3000. ◊ Máquina virtual. ◊ Instrucciones Reales y pseudoinstrucciones.

FUNDAMENTOS DE COMPUTADORES Tema 3. Lenguaje Ensamblador

5

FUNDAMENTOS DE COMPUTADORES Tema 3. Lenguaje Ensamblador

6

INSTRUCCIONES BASICAS Instrucción aritmética: En lenguaje de alto nivel: c:=a+b (PASCAL) Sobre MIPS R2000: add c, a, b • c ← operando destino • a ← primer operando fuente • b ← segundo operando fuente • La instrucción add SIEMPRE debe tener 3 op. Para sumar más operandos: g:=a+b+c+d+e+f add g,a,b # g:=a+b add g,g,c # g:=a+b+c add g,g,d # g:=a+b+c+d add g,g,e # g:=a+b+c+d+e add g,g,f # g:=a+b+c+d+e+f (Factor de expansión) Operación de resta o substracción: sub c,a,b #c:=a-b

FUNDAMENTOS DE COMPUTADORES Tema 3. Lenguaje Ensamblador

7

Empleo de variables temporales Variables internas no necesarias para el resultado pero si para los cálculos intermedios. Para generar: f:=(g+h)-(i+j)+(k-l) add t0,g,h # t0 variable temporal add t1,i,j # t1 variable temporal sub t2,k,l # t2 variable temporal sub f,t0,t1 # El orden de las anteriores add f,f,t2 # instr. no importa

Operandos Los operandos en lenguaje máquina deben estar situados en los registros del procesador. Registros de 32 bits • R2000 ⇒ 32 registros de 32 bits + hi + ho + PC • R2010 ⇒ 32 registros de 32 bits • Memoria Principal ⇒ 4Gb como máximo El compilador debe asignar las variables a los registros. Por ejemplo f → $16, g → $17, h → $18, etc. FUNDAMENTOS DE COMPUTADORES Tema 3. Lenguaje Ensamblador

8

Accesos a memoria Los datos se han de traer de memoria principal a los registros para poder trabajar con ellos. Los resultados pueden necesitar volcarse a memoria. Para traer un dato hay que hacer una lectura sobre memoria, instrucción lw (load word) Para volcar un dato hay que hacer una escritura sobre memoria, instrucción sw (store word) Formato: lw $8, D($17) # $8=contenido de D+$17 sw $10, D($17) # En dir. D+$17 alamcena $10 D+$17 → dirección efectiva

MP MIPS R2000 $8 $10

D

$17 = 0

FUNDAMENTOS DE COMPUTADORES Tema 3. Lenguaje Ensamblador

9

Accesos a estructuras de datos PROGRAM ejemplo VAR x,k,i: INTEGER; V: ARRAY[0..999] OF INTEGER; BEGIN … x:=k-(V[i]+V[i]); … V[i+1]:=k+V[i]; … END. Como acedemos al elemento i del vector: Suponemos i almacenada en $17 lw $10, Vinicio($17) # $17 se le llama reg. indice MIPS R2000

MP

$10 $17 = i

V (dir. inicio) ...

$17 V[i]

FUNDAMENTOS DE COMPUTADORES Tema 3. Lenguaje Ensamblador

10

Direccionamiento de la memoria ◊ Direccionamiento por palabra, media palabra y byte. ◊ Palabras (32 bits, 4bytes): 0, 4, 8, 12, …232-4 ◊ Medias pal. (16 bits, 2bytes): 0, 2, 4, 6, …232-2 ◊ Bytes (8 bits, 1bytes): 0, 1, 2, 3, …232-1 Memoria Principal 3 7 11

2 6 10 ···

1 5 9

0 4 8

D+1

D D+4 D+8

D+6

*Con D múltiplo de 4

Palabra 0 (Word 0)

Dir. Media Palabra 0 0 (Half-Word 0) 1 2 3 4

Palabra 4 (Word 4)

5 6

Media Palabra 2 (Half-Word 2) Media Palabra 4 (Half-Word 4)

Dir. Byte 0 0 Byte 1 1 2 3 4 5 6

Byte 2 Byte 3 Byte 4 Byte 5

Dir. 0 1 2 3 4 5 6

7

7

7

8

8

8

9 ....

9 ....

9 ....

FUNDAMENTOS DE COMPUTADORES Tema 3. Lenguaje Ensamblador

11

• Del ejemplo: Para acceder a V[i], siendo V un vector de palabras, $17 debe contener i*4 y no i. V[i] ? Elemento número i del vector V. V ? Vector de palabras. V[i] ? Palabra número i. ¿Qué dirección tendrá V[i]? Dir. V-1 V = V[0] =

V V+1 V+2 V+3

V[1] =

V+4 ....

V[i] =

V+(i*4) V+(i*4)+1 V+(i*4)+2 V+(i*4)+3 ....

Para codificar: V[i+1]:=V[i]+k; lw $10, Vinicio($17) # $17 → i*4 add $10, $18, $10 add $17, $17, $21

# $18 contiene k # $21 contiene 4

sw $10, Vinicio($17) # V[i+1]:=k+V[i]

FUNDAMENTOS DE COMPUTADORES Tema 3. Lenguaje Ensamblador

12

MODOS DE DIRECCIONAMIENTO Modos de acceder a los operandos de una instrucción. Repercuten en el modo de acceder a los datos. ◊ Modo real: Sumar algo al contenido de un registro. ◊ Modo virtual: Según sea el algo: • Direccionamiento a registro • Direccionamiento inmediato • Direccionamiento base o desplazamiento • Direccionamiento relativo a PC

Direccionamiento a registro • El dato esta ubicado en el registro sub $8, $10, $22 lw $10, Vinicio($17)

Direccionamiento inmediato • El operando es un valor constante • Inicializaciónes o operaciones con ctes. • Instrucciones en versión inmediata: addi $17, $17, 4 # inmediate add

FUNDAMENTOS DE COMPUTADORES Tema 3. Lenguaje Ensamblador

13

Direccionamiento base o desplazamiento • Normalmente se emplea para accesos a memoria • La dirección efectiva se obtiene sumando una cantidad más el contenido de un registro • La cantidad se codifica con la instrucción. • Dos posibles interpretaciones: ⇒lw $10, Vinicio($17) ⇒lw $10, 12($16)

#Acceso al valor $17/4 #Acceso al valor 3 #En $16 esta Vinicio

Direccionamiento relativo al contador de programa • Normalmente usado en saltos. bne $21, $8, seguir

# Ir a seguir si $8$21

• seguir es una etiqueta • La dirección de salto se calcula como un valor añadido (o restado) al contador de programa actual • Este valor lo calcula el ensamblador: etiqueta: addi $5, $8, 78

FUNDAMENTOS DE COMPUTADORES Tema 3. Lenguaje Ensamblador

14

INSTRUCCIONES DE BIFURCACIÓN O SALTO Tipos: ◊ Salto incondicional ◊ Salto condicional

Salto incondicional ⇒Instrucción: j (jump) ⇒Operando: Dirección destino. Valor concreto o etiqueta j 2300 j etiqueta

#Salta a la dirección 2300 #Salta a la dirección de la etiqueta

⇒Instrucción: jr (jump register) ⇒Operando: Registro que contiene la dir. de salto. Direccionamiento indirecto a registro jr $12

#Salta a dirección indicada por $12

FUNDAMENTOS DE COMPUTADORES Tema 3. Lenguaje Ensamblador

15

Salto condicional ◊ Salta si se produce alguna condición ◊ Implementa IF…THEN…ELSE

beq $7, $12, etiqueta

#Salta si $7 = $12

bne $7, $12, etiqueta

#Salta si $7$12

Comparación de desigualdad: slt $8, $19, $22

# set on less than

Si $19= 0 Salto si < 0 Salto si =n beq $8,$0,exitf #Salir si i>=n addi $17,$19,-1 #j:=i-1 while: slti $8,$17,0 #S8=1 si j=v[j] add $4,$18,$0 add $5,$17,$0 jal inter

#Parámetro v=v #Parámetro k=j

addi $17,$17,-1 #j:=j-1 j while #Repetir bucle while exitw: addi $19,$19,1 #i:=i+1 j for #Repetie bucle for exitf: (6)…Desapilar todos los registros apilados jr $31 #Retorno de subrutina

FUNDAMENTOS DE COMPUTADORES Tema 3. Lenguaje Ensamblador

45

2.-Apilar - desapilar: $8,$15-$21, $24, $25, $31: total 11 4

6

addi $29,$29,-44 sw $8,0($29) … sw $31,40($29)

#Espacio para 11 pal. #Apilar $8

lw $8,0($29) … addi $29,$29,44

#Desapilar $8

#Apilar $31

#Liberar espacio pila

Programa principal que llama a la rutina de la burbuja

v:

.data .word .word .word

0x10000000 0x10000004 72,50,8 20,15

#Dirección vector #Vector

.text .global inicio inicio: lw $4,v($0) addi $5,$0,5 jal ordena j fin

#Inicializa parámetro v #Inicializa parámetro n #Burbuja #Salto al final

……CODIGO DE LAS RUTINAS…… fin:

.end

FUNDAMENTOS DE COMPUTADORES Tema 3. Lenguaje Ensamblador

46

MANEJO DE DATOS EN COMA FLOTANTE ◊ Standar IEEE 754 ◊ Formatos simple (32 bits) y doble precisión (64 bits) ◊ Datos manejados por FPU ◊ 32 registros de 32 bits. ◊ Doble precisión: 2 registros consecutivos. ◊ Instrucciones de coma flotante SOLO con reg. pares ◊ Registro de control y estado ◊ Idea similar a procesador: carga y almacenamiento ◊ Operaciones en FPU y µP simultáneas ◊ Instrucciones con sufijo d (doble) y s (simple)

Instrucciones para coma flotante FRdest, FRsrc1 y FRsrc2 registros de FPU PARES ($fn)

FUNDAMENTOS DE COMPUTADORES Tema 3. Lenguaje Ensamblador

47

add.λ FRdest, FRsrc1, FRsrc2 λ ⇒ d (doble precisión) ó s (simple precisión) sub.λ FRdest, FRsrc1, FRsrc2 abs.λ FRdest, FRsrc Valor absoluto de FRsrc mult.λ FRdest, FRsrc1, FRsrc2 div.λ FRdest, FRsrc1, FRsrc2 l.λ FRdest, direccion (ρ) s.λ FRdest, direccion (ρ) Carga y almacenamiento mfc1 Rdest,FRscr Mueve dato de FPU a CPU mtc1 Rsrc,FRdest Mueve dato de CPU a FPU mfc1.d Rdest,FRscr (ρ) Mueve datos de FRscr y FRscr+1 a Rdest y Rdest+1 mtc1.d Rsrc,FRdest (ρ) Idem pero de CPU a FPU c.x.λ FRscr1,FRscr2 Comparación de FRscr1 y FRscr2. Se activa el bit correspondiente del reg. de estado del coprocesador. El bit depende de la condición x: eq, neq, lt, le, gt, ge. bc1t direccion #Salto si TRUE bc1f direccion #Salto si FALSE FUNDAMENTOS DE COMPUTADORES Tema 3. Lenguaje Ensamblador

48

Ejemplo: Suma de los elementos de un vector en coma flotante de simple precisión. El vector empieza en 0x10000004. .data 0x10000000 tam: .word 4 vector: .float 3.1415, 2.7182 .float 1.0e+2, 6.5e-1 res: .float 0.0 .text .globl __start inicio: addi $15,$0,0 #Indice addi $17,$0,0 #Contador lw $16,tam($0) #Tamaño del vector mtc1 $0, $f2 #0 a f2 (temporal) bucle: l.s $f4,vector($15)#Leemos elem $15 vector add.s $f2,$f2,$f4 #Sumamos elemento addi $15,$15,4 #Increm. indice addi $17,$17,1 #Increm. contador slt $8,$17,$16 #Final? bne $8,$0,bucle #$8=1 implica $17exponente? bne $10,$0,exif #salir si i>exponente mul.s $f4,$f4,$f6 #aux:=aux*base addi $9,$9,1 #i:=i+1 j for mfc $2,$f4 #Devolvemos res en $2 lw $9,0($29) #Desapilar $9 l.s $f4, 4($29) #Desapilar $f4 l.s $f6, 8($29) #Desapilar $f6 addi $29,$29, 12 #Restaurar pila jr $31 #Fin subrutina

PROGRAMAS RECURSIVOS ◊ Rutina que se llama a si misma ◊ En cada llamada se usan los mismos registros y direcciones de memoria ◊ Uso adecuado de la pila

Estructura de la pila • Es necesario almacenar en la pila cierta información • MIPS ofrece un modelo para hacer las llamadas de una forma uniforme, que indica la estructura que debe tener la pila: 1.Argumentos de la subrutina (más de 4)

FUNDAMENTOS DE COMPUTADORES Tema 3. Lenguaje Ensamblador

52

2.Registros que se modifican en la subrutina y cuyo valor se debe mantener 3.Variables locales. $fp ($30) + Argumento 5 Argumento 6 ... Registros guardados Variables locales $sp ($29)

-

Diseño (ejemplo factorial) FUNCTION factorial(n:integer):integer; BEGIN IF(n0)THEN factorial:=n*factorial(n-1); ELSE factorial:=1; END;

Cada llamada debe guardar su propia pila. Suponemos que tenemos el entero en $2 y que ya lo hemos leido del usuario. El parámetro de factorial lo pasamos en $4: …… addi $4,$2,0 jal fact

#Inicialización y lectura #Parámetro introducido a $4 #Llamada principal #Imprimir y terminar

addi $29,$29,-8 sw $4,4($29) sw $31,0($29)

#Espacio para 2 palabras #Almacena parámetro ($4) #Almacena dir. retorno

…… fact:

FUNDAMENTOS DE COMPUTADORES Tema 3. Lenguaje Ensamblador

53

lw $2,4($29) bgtz $2,seguir addi $2,$0,1 j volver seguir: lw $3,4($29) addi $4,$3,-1 jal fact lw $3,4($29) mult $2,$3 mflo $2 volver: lw $31,0($29) addi $29,$29,8 jr $31

#Lectura argumento n ¿? #Si n>0 llamarse #Un 1 como resultado #fin de recursión #Lectura argumento n #Parámetro n-1 #Llamada recursiva #Lectura argumento n #n*factorial(n-1) ($2) #Resultado parcial #Dirección de retotno #Restaurar pila #Retorno

REGULARIDAD Y ORTOGONALIDAD ◊ Regularidad: Conjunto de instrucciones uniformes sin casos especiales. Simplifica la programación. ◊ Ortogonalidad: Cualquier operación se puede usar con cualquier operando y cualquier modo de direccionamiento. ◊ Los dos conceptos están muy unidos.

FUNDAMENTOS DE COMPUTADORES Tema 3. Lenguaje Ensamblador

54

EJEMPLOS: Programa que detecta cadenas capicuas. Cálculo de la serie de fibonazzi. Conversión a formato IEEE 754.

FUNDAMENTOS DE COMPUTADORES Tema 3. Lenguaje Ensamblador

55

buffer: cad: si: no:

__start:

long:

finlong:

bucle:

.data .space 100 .asciiz "\nIntroduce la cadena:" .asciiz "\nLa cadena es capicua" .asciiz "\nLa cadena no es capicua" .text .globl __start la $4,cad addi $2,$0,4 syscall addi $2,$0,8 la $4,buffer addi $5,$0,100 syscall add $11,$0,$0 addi $12,$0,10 lb $10,0($4) beq $10,$12,finlong addi $4,$4,1 addi $11,$11,1 j long

#Cálculo de la longitud

beq $11,$0,fin addi $4,$4,-1 la $5,buffer lb $10,0($4) lb $12,0($5) bne $10,$12,finno

#Cadena vacia #Apuntar al ultimo char.

addi $4,$4,-1 addi $5,$5,1 addi $11,$11,-2 slti $13,$11, 2 bne $13,$0,finsi j bucle finsi:

la $4,si addi $2,$0,4 syscall j fin

finno:

la $4,no addi $2,$0,4 syscall

FUNDAMENTOS DE COMPUTADORES Tema 3. Lenguaje Ensamblador

#$13=1 si $11