Tema 3personales.upv.es/pabmitor/acso/FILES/ArqComp/CST/ArqComp d10... · → decodificador de...

Fundamentos de Computadores

Tema 3 LENGUAJE

ENSAMBLADOR

FUNDAMENTOS DE COMPUTADORES Tema 3. Lenguaje Ensamblador Contenido - I

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 - II

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 1

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 deAlto Nivel

LenguajeEnsamblador

LenguajeMáquina

Ensamblador

Compilador


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


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: Complex Instruction Set Comp. RISC: Reduced Instruction Set Comp. 680X0, 80X86 RX000, PowerPC, Sparc, Alpha MIPS R2000

1970

1980

1990

CISC

RISC


ARQUITECTURA DEL µP MIPS R2000 Simple y regular. Bus de datos: 32bits

Bus de direcciones: 32bits → 4Gb de direccionamiento

MIPSR2000

CoprocesadorMatemático

R2010

MemoriaPrincipal

Bus del Sistema

$0$1$2$3

···

$31

PC

hilo

UAL

StatusCauseEPC

BadVAddr

MMUcon TLB

Coprocesador 0


$0$1$2$3

···

$31

Coprocesador 1

Unidad dedivisión

Unidad demultiplicación

• 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.


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


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.


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

MIPS R2000$8

$10 D

MP

$17 = 0


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

$10

V (dir. inicio)

MP

$17 = i

... $17

V[i]


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

···

01234567891011

DD+4D+8

D+1D+6

Memoria Principal

*Con D múltiplo de 4 Dir.

0

1 2

3 4

5 6

7

8

9 ....

Palabra 0 (Word 0)

Palabra 4 (Word 4)

Dir. 0

1 2

3 4

5 6

7

8

9 ....

Media Palabra 0 (Half-Word 0)



Dir. 0

1 2

3 4

5 6

7

8

9 ....

Byte 0 Byte 1

Byte 2 Byte 3

Byte 4 Byte 5


• 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]?

Para codificar: V[i+1]:=V[i]+k;

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

Dir.

V-1

V

V+1 V+2

V+3

V+4

....

V+(i*4)

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

V+(i*4)+3

....

V = V[0] =

V[i] =

V[1] =


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


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) #Acceso al valor $17/4

⇒lw $10, 12($16) #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


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 #Salta a la dirección 2300 j etiqueta #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


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<$22 entonces $8=1 sino $8=0

Para realizar un salto si x < y (x → $8, y → $9)

slt $10, $8, $9

bne $10, $0, menor

MIPS: El registro $0 es de solo lectura y siempre contiene un 0.


Algunas codificaciones sencillas:

SENTENCIA IF (SI)

Suponemos i, j, a, h → $16 - $19 SI (i=j)ENTONCES a:=a+h; a:=a+j; bne $16, $17, L1 add $18, $18, $19 L1: add $18, $18, $17

BUCLE REPEAT – UNTIL (REPETIR – HASTA)

Variables: g, h, i, j → $17 - $20 A es un vector de enteros (de palabras) Suponemos (como ocurre en C) que A=&A[0]=Ainicio

REPETIR g:=g+A[i]; i:=i+j; HASTA (i=h) bucle: multi $9, $19, 4 lw $8, A($9) add $17, $17, $8 add $19, $19, $20 bne $19, $18, bucle


SENTENCIA WHILE (MIENTRAS)

Suponemos i, x → $22 - $23 i:=1 MIENTRAS (i<35) HACER x:= x-2; i:= i+5; FIN DEL MIENTRAS x:= x+18; addi $22, $0, 1 bucle: slti $10, $22, 35 beq $10, $0, salir addi $23, $23, -2 addi $22, $22, 5 j bucle salir: addi $15, $15, 18


FORMATO DE LAS INSTRUCCIONES ◊ Cada instrucción ocupa 32 bits (1 palabra)

◊ 3 tipos de codificaciones

→ decodificador de instrucciones más simple

Formato R

• Instrucciones con todos los operandos en registros

• Campos de la instrucción:

6 bits 5 bits 5 bits 5 bits 5 bits 6 bits

◊ 1º y último: Tipo de operación a realizar

◊ 2º: Primer operando fuente

◊ 3º: Segundo operando fuente

◊ 4º: Destino

◊ 5º: Desplazamiento en op. de desplazamiento

op rf1 rf2 rd desp func

Por ejemplo: add $15, $2, $3


000000 00010 00011 01111 00000 100000

Formato I

• Instrucciones de carga/almacenamiento

• Instrucciones de salto condicional

• Instrucciones con datos inmediatos

• Se utilizan 16 bits para codificar dato o desplazamiento

• Formato:

op rf rd inm

6 bits 5 bits 5 bits 16 bits

◊ Carga: lw $3, Ainicio($13)

◊ Salto condicional: beq $1,$2, salir

◊ El desplazamiento de salir son palabras

◊ salir lo calcula el compilador

◊ Si el salto excede el desplazamiento máximo:

beq $18, $19, Etiqueta bne $18, $19, aux j etiqueta aux: ……


Formato J

◊ Instrucciones de salto incondicional (no todas)

◊ Formato:

op dirección

6 bits 26 bits

◊ dirección expresada en palabras

◊ Salto máximo 228 bytes = 256Mb

◊ Salto mayor: Instrucción jr → registro con dirección.

◊ Programas no relocalizables


JUEGO DE INSTRUCCIONES • Instrucciones reales

• Pseudoinstrucciones (ρ) ARITMÉTICO-LÓGICAS: add Rdest, Rsrc1, Src2 Suma (con signo) addi Rdest, Rsrc1, Imm Suma inmediata (c.s.) addu Rdest, Rsrc1, Src2

Suma (sin signo)

addiu Rdst, Rsrc1, Imm Suma inmediata (s.s.) sub Rdest, Rsrc1, Src2 Resta (con signo) subu Rdest, Rsrc1, Src2

Resta (sin signo)

div RSrc1, RSrc2 División (con signo) divu RSrc1, RSrc2 División (sin signo)

cociente en registro lo - resto en reg. hi mult Rsrc1, Rsrc2 Multiplicación (c.s.) multu Rsrc1, Rsrc2 Multiplicación (s.s.)

parte baja resultado en reg. lo - alta en reg. hi


nor Rdst, Rsrc1, Src2 Nor (Or negada) or Rdst, Rsrc1, Src2 Or ori Rdst, Rsrc1, Imm Or and Rdst, Rsrc1, Src2 AND lógico andi Rdst, Rsrc1, Imm AND inmediata xor Rdst, Rsrc1, Src2 Xor (Or exclusiva) xori Rdst, Rsrc1, Imm Xor inmediata Sll Rdst, Rsrc1, Src2 Desplazamiento a izq. srl Rdst, Rsrc1, Src2 Desp. a derecha sra Rdst, Rsrc1, Src2 Desp. aritmético dcha. En Src2 esta el núm. de bits a desplazar

MANIPULACIÓN DE CONSTANTES li Rdst, Imm Rdst ← Imm (ρ) lui Rdst, Imm Rdst(parte alta)

←Imm COMPARACIÓN slt Rdst,Rsrc1, Src2 < slti Rdst, Rsrc1, Imm < inmediata


sltu Rdst,Rsrc1, Src2 < (sin signo) sltui Rdst, Rsrc1, Imm < inmediata (sin

signo) Rdst=1 si Rsrc1<Src2(o Imm), en otro caso Rdst=0

SALTO CONDICIONAL E INCONDICIONAL Saltos condicionales: Campo 16 bits con signo 215-1 instrucciones hacia adelante y 215-1 hacia atrás Salto incondicional: Campo con 26 bits. beq Rsrc1, Rsrc2, Etq Salto si igual bne Rsrc1, Rsrc2, Etq Salto si distinto bgtz Rsrc, Etiq Salto si > 0 bgez Rsrc, Etiq Salto si >= 0 bgezal Rsrc, Etiq Salto y enlaza si >= 0 bltz Rsrc, Etiq Salto si < 0 blez Rsrc, Etiq Salto si <= 0 blezal Rsrc, Etiq Salto y enlaza si <= 0 j etiqueta Salto incondicional jal etiqueta Salto incond. y enlaza jalr Rsrc S. inc. a reg. y enlaza jr Rsrc Salto incond. a reg.


CARGA la Rdest, ident Carga dirección (ρ) lb Rdest, dirección Carga byte (ext.

signo) lbu Rdest, dirección Carga byte (sin ext.) lh Rdest, dirección Carga media-pal.(ext.) lhu Rdest, dirección Carga media-pal.(s.e.) lw Rdest, dirección Carga palabra ld Rdest, dirección Carga doble palabra(ρ)

ALMACENAMIENTO sb Rsrc, dirección Almacena byte bajo sh Rsrc, dirección Alm. media-pal. baja sw Rsrc, dirección Alm. palabra sd Rsrc, dirección Alm. doble palabra

En las instrucciones de carga y almacenamiento:

• Direcciones para bytes: cualquiera.

• Direcciones para medias pal.: múltiplos de dos (pares).

• Dir. para palabras: múltiplos de 4.

• Dir. para dobles palabras: múltiplos de 8.


MOVIMIENTO move Rdest, Rsrc Rdest ← Rsrc (ρ) mfhi Rdest Rdest ← hi mflo Rdest Rdest ← lo mthi Rdest hi ← Rdest mtlo Rdest lo ← Rdest


USO DE REGISTROS Y MEMORIA

Registros de la CPU

◊ 32 registros de propósito general

◊ $n → registro n

◊ $0=0 siempre

◊ Identificadores y usos convenidos (tabla)

• $1, $26, $27 ⇒ el ensamblador y S.O.

• $4-$7 ⇒ Paso primeros 4 arg. a subrutinas

• $8-$15, $24, $25 ⇒ Temporales

• $16-$23 ⇒ Valores preservados en llamadas

• $29 ⇒ Puntero de pila

• $30 ⇒ Puntero de marco

• $31 ⇒ Dirección de retorno (jal)

• $28 ⇒ Puntero a datos globales (64K): heap


Número Nombre Uso 0 $zero Constante 0 1 $at Reservado para el ensamblador 2 $v0 Evaluación de expresiones 3 $v1 Evaluación de expresiones 4 $a0 Argumento 1 5 $a1 Argumento 2 6 $a2 Argumento 3 7 $a3 Argumento 4 8 $t0 Temporal (no preservado entre llamadas) 9 $t1 Temporal (no preservado entre llamadas) 10 $t2 Temporal (no preservado entre llamadas) 11 $t3 Temporal (no preservado entre llamadas) 12 $t4 Temporal (no preservado entre llamadas) 13 $t5 Temporal (no preservado entre llamadas) 14 $t6 Temporal (no preservado entre llamadas) 15 $t7 Temporal (no preservado entre llamadas) 16 $s0 Salvado temporalmente (preservado entre llamadas) 17 $s1 Salvado temporalmente (preservado entre llamadas) 18 $s2 Salvado temporalmente (preservado entre llamadas) 19 $s3 Salvado temporalmente (preservado entre llamadas) 20 $s4 Salvado temporalmente (preservado entre llamadas) 21 $s5 Salvado temporalmente (preservado entre llamadas) 22 $s6 Salvado temporalmente (preservado entre llamadas) 23 $s7 Salvado temporalmente (preservado entre llamadas) 24 $t8 Temporal (no preservado entre llamadas) 25 $t9 Temporal (no preservado entre llamadas) 26 $k0 Reservado para el núcleo del S.O. 27 $k1 Reservado para el núcleo del S.O. 28 $gp Puntero al área global (global pointer) 29 $sp Puntero de pila (stack pointer) 30 $fp Puntero de marco (frame pointer) 31 $ra Dirección de retorno (return address)


Distribución de la memoria

◊ Organización convencional

◊ 3 partes:

• Segmento de código: 0x400000 (text segment)

• Segmento de datos: 0x10000000 (data segment)

• Segmento de pila: 0x7FFFFFFF (stack segment) $29

Segmento de pila

Datos dinámicos

Datos estáticos

Segmento código

Reservado0x00000000

0x10000000

0x00400000

0x7FFFFFFF

◊ Ordenamiento de los bytes:

• Little endian

31

3 2 1 00

• Big endian


31

0 1 2 30

PROGRAMACIÓN EN ENSAMBLADOR ◊ 1 instrucción por línea

◊ 4 campos:

• Etiqueta (opcional)

• Código operación

• Operandos

• Comentario (opcional)

◊ Identificadores: Caracteres alfanuméricos + ‘_’ + ‘.’

◊ Palabras reservadas

◊ Etiquetas = identificador+’:’

◊ Directivas: Instrucciones SOLO para el ensamblador


Directiva .align n Alinea el siguiente dato en 2n bytes. Con n=0, se

desactiva la alineación de .half, .word, .float, .double hasta la siguiente directiva .data

.ascii “str” Almacena la cadena str en memoria sin car. nulo.

.asciiz “str” Almacena str en memoria + car. número 0 (NULL)

.byte b1, …,bn Almacena los bn en bytes de memoria consecutiva

.data <addr> Almacena los elementos declarados a continuación de la directiva a partir de la dir. ADDR en el segmento de datos. Si no aparece se toma la dir. por defecto.

.double d1, …,dn Almacena los dn doble words de coma flotante (64 bits) consecutivamente en memoria.

.end Fin del programa

.float f1, …,fn Almacena los fn valores de coma flotante (32 bits) consecutivamente en memoria.

.global símbolo Símbolo declarado como global. Se puede referenciar desde otros archivos.

.half h1, …,hn Alamcena las hn medias palabras (16 bits) consecutivamente en memoria.

.space n n bytes reservados en el segmento de datos

.text <addr> Almacena los elementos declarados tras esta directiva en el segmento de código a partir de la dirección ADDR. Estos elementos solo pueden ser palabras (.word) o instrucciones. Si no aparece ADDR se toma la dirección por defecto.

.word w1, …,wn Almacena las wn palabras (32 bits) en posiciones consecutivas de memoria.


EJEMPLOS Ejemplo 1: Suma de los primeros 200 números. En PASCAL:

i:=0; suma:=0; REPETIR i:=i+1; suma:=suma+1; HASTA QUE(i>=200)

i → $8, suma → $9

.data 0x10000000 #seg. de datos .text #seg. Código .global __start #Inicio del prog. __start: addi $8,$0,0 #i:=0 addi $9,$0,0 #suma:=0 repeat: addi $8,$8,1 #i:=i+1 add $9,$9,$8 #suma:=suma+i slti $10,$8,200 #$10:=1 si i<200 bne $10,$0,repeat #Si $10=1 ir rep. .end


Ejemplo 2: Programa que cuenta la longitud de la palabra “Fundamentos”+NULL almacenada a partir de la dirección 0x10000000. En $21 se debe almacenar la cadena. .data 0x10000000 #Seg. de datos .asciiz “Fundamentos” .text .global inicio #En SPIM __start inicio: lui $20, 0x1000 #Carga parte alta ori $20, 0x0000 #Carga parte baja addi $21, $0, 0 #Inicializamos a 0 bucle: lb $19, 0($20) #Lectura byte de la cad. beq $0, $19, fin #Si es 0 (NULL), fin addi $20, $20, 1 #Inc. para leer sig. car addi $21, $21, 1 #Inc. longitud j bucle fin: .end


Ejemplo 3: Programa que copia la longitud de la palabra “Fundamentos” + NULL almacenada a partir de la dirección 0x10000000 a la dirección 0x100020A0 .data 0x10000000 #Seg. de datos .asciiz “Fundamentos” .data 0x100020A0 #Dirección destino .space 12 (11+1) #Espacio para copia .text .global inicio #En SPIM __start inicio: lui $20, 0x1000 #Carga parte alta ori $20, 0x0000 #Carga parte baja lui $21, 0x1000 #Parte alta destino ori $21, 0x20A0 #Parte baja destino bucle: lb $19, 0($20) #Lectura byte de la cad. sb $19, 0($21) #Copiamos caracter beq $0, $19, fin #Si es 0 (NULL), fin addi $20, $20, 1 #Inc. para leer sig. car addi $21, $21, 1 #Siguiente car. destino j bucle fin: .end


EJEMPLO 4: Programa que cuenta los bits a 1 en una palabra de 32 bits Palabra en registro $20. Resultado en registro $21. .data 0x10000000 .text .global __start inicio: add $21, $0, $0 #Contador a 0 beq $20, $0, fin #Si no hay 1’s, fin addi $18, $0, 1 #Ponemos 1 en $18 rotar: beq $18, $0, fin #32 desplazamientos and $19, $20, $18 #Extraer bit i-essimo sll $18, $18, 1 #Desplazar a la izq. beq $19, $0, rotar #Bit 0, no contamos addi $21, $21, 1 #Incrementamos cuenta j rotar fin .end


EJEMPLO 5: Programa en ensamblador que concatene dos cadenas acabadas en NULL. El algoritmo debe copiarlas en una cadena destino. Primero copia una y después copia la segunda a continuación. Para referenciar una posición de memoria usaremos etiquetas en lugar de usar lui y ori. Las etiquetas apuntan al inicio de las cadenas. Las direcciones las genera el ensamblador. .data 0x10000000 cad1: .asciiz “ensamblador” cad2: .asciiz “ejemplo” dest: .space 19 .text .global __start inicio: add $16,$0,$0 lcad1: lb $17, cad1($16) #Leer caracter cad. 1 beq $17,$0,flcad1 #Si es 0, leer cad. 2 sb $17,dest($16) #Copiamos a destino addi $16,$16,1 #Incrementamos indice j lcad1 #Seguir leyendo cad. 1 flcad: add $18,$0,$0 #Lectura seg. cadena lcad2: lb $17,cad2($18) #Leer carácter sb $17,dest($16) #Copiar a destino beq $17,$0, fin #Con NULL acabamos addi $16,$16, 1 #Incrementamos indice 1 addi $18, $18, 1 #Inc. indice 2 j lcad2 fin: .end


EJEMPLO 6: Dado un vector de 6 enteros de 32 bits en 0x10000000, no indique cuantos elementos son mayores, menores e iguales que el último elemento. Ubicar el resultado en memoria, después de los elementos del vector y del número de elementos. .data 0x10000000 vector: .word 34, 21, 10, 5, 3, 10 nelem: .word 6 mayor: .word 0 menor: .word 0 igual: .word 0 .text .global __start inicio: lw $20,nelem($0) #Leemos núm. elementos addi $16,$0,4 mult $20,$16 #Tamaño en bytes mflo $16 #Movemos lo a $16 addi $16,$16,-4 #Indice última coponente lw $8,vector($16) #Referencia en $8 add $18,$0,$0 #Indice para vector bucle: addi $20,$20,-1 #Dec. número elementos lw $21,vector($18) #Leemos elemento vector addi $18,$18,4 #Inc. indice si: slt $7,$21,$8 #$21<$8? bne $7,$0,ent #Es menor, ir a ent j snsa #No menor, igual o may? ent: lw $9,menor($0) #Leer menores addi $9,$9,1 #Incrementar menores sw $9,menor($0) #Escribir


j finb snsa: beq $21,$8,igua #Son iguales? lw $9,mayor($0) #Mayor. Leer mayores addi $9,$9,1 sw $9,mayor($0) j finb igua: lw $9,igual($0) #Leemos iguales addi $9,$9,1 sw $9,igual($0) finb: beq $20,$0,fin j bucle fin: .end

PROGRAMACIÓN MEDIANTE SUBRUTINAS

◊ MIPS da soporte a las subrutinas mediante la instrucción jal (jump and link).

◊ Almacena en $31 la dirección de retorno (PC)

◊ Sintaxis: jal Dirección

◊ Para finalizar: jr $31

jal rutinainstrucción

D-4D

rutina

jr $31

$31:=D (PC+4)PC:=rutina


◊ Llamadas anidadas?

• Solución: Usar la pila ($29)

• Almacenar en pila: Apilar o push

• Sacar de pila: Desapilar o pop Por ejemplo:

Prog.principal

Rutina 1 Rutina 2 Rutina 3

El compilador generará: inicio: …… jal Rut1 … j fin Rut1: … addi $29,$29,-4 #Apilar sw $31, 0($29) #Guardar dir. retorno jal Rut2 lw $31,0($29) #Recuperar dirección addi $29,$29,4 #Desapilar … jr $31 Rut2: …igual que Rut1… Rut3: … #No hace falta apilar porque no #hay llamada a subrutina jr $31


fin: .end

Paso de parámetros

◊ Por convención se usan $4, $5, $6, $7

◊ Para más parámetros se usa la pila

Preservación de registros

◊ Con rutinas anidadas, que pasa con $4…$7?

◊ Solución: Usar la pila

◊ Cuando se llama a una subrutina, que ocurre con los valores actuales de los registros?

◊ Dos convenios:

• Guardar invocadora (caller save).

• Guardar invocada (callee save).

◊ En MIPS se usa el convenio callee save.

GuardarSalto

RestaurarRutina Salto

Guardar

Rutina

Restaurar


EJEMPLOS Uso de subrutinas

PROCEDURE intercambia(var v:vector;k:integer); VAR temp:integer; BEGIN temp:=v[k]; v[k]:=v[k+1]; v[k+1]:=temp; END.

Registros: $15←temp, $4←v, $5←k Algoritmo de ordenamiento de la burbuja

PROCEDURE ordena(var v:vector; n:integer); VAR i,j:integer; BEGIN FOR i:=0 TO n-1 DO BEGIN j:=i-1; WHILE(j>=0) AND (v[j]>v[j+1]) DO BEGIN intercambia(v,j); j:=j-1; END; END; END.

Registros: $19←i, $17←j, $4←v, $5←n PASOS A SEGUIR:

1.Generar cuerpo de la rutina


2.Salvar los registros usados


Rutina de intercambio de elementos del vector: 1.- Cuerpo: 2 addi $14,$0,4 #$14=4 mult $5,$14 #lo=k*4 mflo $2 #$2=lo (k*4) add $2,$4,$2 #$2=v+(k*4) v[k] lw $15, 0($2) #$15(temp)=v[k] lw $16, 4($2) #$16=v[k+1] sw $16, 0($2) #v[k]=$16=v[k+1] sw $15, 4($2) #v[k+1]=$15=temp 2.- Salvado de registros ($2,$14,$15,$16) inter: addi $29,$29,-16 #Espacio para 4 pal 1 sw $2, 0($29) #Apilar $2 sw $14, 4($29) #Apilar $14 sw $15, 8($29) #Apilar $15 sw $16, 12($29) #Apilar $16 Recuperación de registros y retorno de subrutina 3 lw $2, 0($29) #Desapila $2 lw $14, 4($29) #Desapila $14 lw $15, 8($29) #Desapila $15 lw $16, 12($29) #Desapila $16 addi $29,$29,16 #Vaciar pila jr $31 #Fin de subrutina Rutina de ordenamiento de la burbuja:

• Necesita guardar los parámetros en otros registros

• Hay que implementar dos bucles anidados

• El bucle interno tiene dos condiciones


1.-Cuerpo: ordena: (4)…Apilar registros usados 5 add $18,$4,$0 #Copia parámetro v add $20,$5,$0 #Copia parámetro n add $19,$0,$0 #i:=0 addi $21,$0,4 #$21=4 for: slt $8,$19,$20 #$8=0 si i>=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<0 bne $8,$0,exitw #Salir si j<0 mult $17,$21 #lo=j*4 mflo $15 #$15=lo (j*4) add $16,$18,$15 #$16=v+j lw $24,0($16) #$24=v[j] lw $25,4($16) #$25=v[j+1] slt $8,$25,$24 #$8=0 si $25>=$24 beq $8,$0,exitw #Salir si v[j+1]>=v[j] add $4,$18,$0 #Parámetro v=v add $5,$17,$0 #Parámetro k=j jal inter 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


2.-Apilar - desapilar: $8,$15-$21, $24, $25, $31: total 11 4 addi $29,$29,-44 #Espacio para 11 pal. sw $8,0($29) #Apilar $8 … sw $31,40($29) #Apilar $31

6 lw $8,0($29) #Desapilar $8 … addi $29,$29,44 #Liberar espacio pila Programa principal que llama a la rutina de la burbuja .data 0x10000000 v: .word 0x10000004 #Dirección vector .word 72,50,8 #Vector .word 20,15 .text .global inicio inicio: lw $4,v($0) #Inicializa parámetro v addi $5,$0,5 #Inicializa parámetro n jal ordena #Burbuja j fin #Salto al final ……CODIGO DE LAS RUTINAS…… fin: .end


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)


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


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 $17<$16 s.s $f2,res($0) #Almacenar resultado fin: .end


LLAMADAS AL SISTEMA ◊ Son llamadas al sistema operativo

◊ Facilitan la tarea del programador

◊ Ofrecen servicios como imprimir por pantalla o introducir números y caracteres por teclado

◊ syscall

• Tipo de llamada en $2 ($v0)

• Parámetros en $4…$7 ($f12 con coma flotante)

• Ejecutar syscall.

• El resultado se devuelve en $2 o $f0

Servicio Código Parámetros Resultado print_int 1 $4=entero print_float 2 $f12=float print_double 3 $f12=doble print_string 4 $4=dir. cadena read_int 5 $2 ← entero read_float 6 $f0 ← float read_double 7 $f0 ← doble read_string 8 $4=dir. buffer,

$5= longitud

sbrk 9 $4=desplazam. $2 ← dirección exit 10


EJEMPLO Programa que calcula la potencia de dos números: ab Para ensamblador, deberemos imprimir las cadenas y leer los datos que el usuario introduzca con llamadas al sistema. .data 0x10000000 cad1: .asciiz “\nDame la base real:” cad2: .asciiz “\nDame el exponente entero:” cad3: .asciiz “\nEl resultado es:” .text .global inicio inicio: addi $2,$0,4 #Código impresión la $4, cad1 #dirección de cadena1 syscall #Impresión addi $2,$0,6 #Cod. lectura float syscall #Lectura base addi $2,$0,4 #Cod. impresión la $4, cad2 #dirección cadena2 syscall #Impresión addi $2,$0,5 #Cod. lectura entero syscall #Lectura exponente mfc1 $4,$f0 #Pasamos la base a $4 add $5,$0,$2 #Exponente en $5 jal pot #Llamada a rutina mtc1 $2,$f12 #Resultado de $2 a $f12 addi $2,$0,4 #Código impresión la $4,cad3 #Dirección cadena3 syscall #Impresión addi $2,$0,2 #Escritura float syscall #Escribimos $f12 addi $2,$0,10 #Cod. salida programa syscall .end pot: addi $29,$29,-12 #Hacemos sitio en pila sw $9,0($29) #Apila $9


s.s $f4, 4($29) #Apila $f4 s.s $f6, 8($29) #Apila $f6 addi $9,$0,2 #i:=2 mtc1 $4,$f4 #aux:=base mtc1 $4,$f6 #$f6:=base for: slt $10,$5,$9 #¿i>exponente? 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 exif: 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)


2.Registros que se modifican en la subrutina y cuyo valor se debe mantener

3.Variables locales.

Argumento 5Argumento 6

...

Registros guardados

Variables locales

+

-$sp ($29)

$fp ($30)

Diseño (ejemplo factorial) FUNCTION factorial(n:integer):integer; BEGIN IF(n<>0)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: …… #Inicialización y lectura addi $4,$2,0 #Parámetro introducido a $4 jal fact #Llamada principal …… #Imprimir y terminar fact: addi $29,$29,-8 #Espacio para 2 palabras sw $4,4($29) #Almacena parámetro ($4) sw $31,0($29) #Almacena dir. retorno


lw $2,4($29) #Lectura argumento n ¿? bgtz $2,seguir #Si n>0 llamarse addi $2,$0,1 #Un 1 como resultado j volver #fin de recursión seguir: lw $3,4($29) #Lectura argumento n addi $4,$3,-1 #Parámetro n-1 jal fact #Llamada recursiva lw $3,4($29) #Lectura argumento n mult $2,$3 #n*factorial(n-1) ($2) mflo $2 #Resultado parcial volver: lw $31,0($29) #Dirección de retotno addi $29,$29,8 #Restaurar pila jr $31 #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.


EJEMPLOS:

Programa que detecta cadenas capicuas.

Cálculo de la serie de fibonazzi.

Conversión a formato IEEE 754.


.data buffer: .space 100 cad: .asciiz "\nIntroduce la cadena:" si: .asciiz "\nLa cadena es capicua" no: .asciiz "\nLa cadena no es capicua" .text .globl __start __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 #Cálculo de la longitud addi $12,$0,10 long: lb $10,0($4) beq $10,$12,finlong addi $4,$4,1 addi $11,$11,1 j long finlong: beq $11,$0,fin #Cadena vacia addi $4,$4,-1 #Apuntar al ultimo char. la $5,buffer bucle: lb $10,0($4) lb $12,0($5) bne $10,$12,finno addi $4,$4,-1 addi $5,$5,1 addi $11,$11,-2 slti $13,$11, 2 #$13=1 si $11<2 --- fin 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


fin: addi $2,$0,10 syscall


.data .text .globl __start __start: addi $2,$0,5 syscall add $4,$0,$2 jal fibon j fin fibon: addi $29,$29,-12 sw $10,8($29) sw $4,4($29) sw $31,0($29) beq $4,$0,zero slti $10,$4,2 bne $10,$0,un addi $4,$4,-1 jal fibon add $10,$0,$2 lw $4,4($29) addi $4,$4,-2 jal fibon add $2,$2,$10 jr finfibo zero: add $2,$0,$0 jr finfibo un: addi $2,$0,1 finfibo: lw $31,0($29) lw $4,4($29) lw $10,8($29) addi $29,$29,12 jr $31 fin: add $4,$0,$2 add $2,$0,1 syscall addi $2,$0,10


syscall


.data flotant: .float 103.487 string: .byte 0,0,0,0,0,0,0,0,0 #Espacio para almacenar el número cad: .asciiz "\nIntroduce el número en coma flotante:" return: .asciiz "\nEl número en formato IEEE754 es (en Hex.):\n" .text .globl __start __start: la $4,cad #Impresión de la cadena “cad” addi $2,$0,4 syscall addi $2,$0,6 #Lectura de número en coma flotante syscall mov.s $f12, $f0 #Impresión del número addi $2, $0, 2 syscall mfc1 $4, $f0 #Llevmos el número del copro a la addi $5, $0, 16 #CPU para su visualización addi $6, $0, 7 bucle: divu $4, $5 #Conversión a hexadecimal mfhi $7 #Dividiendo por 16 sucesivamente sb $7, string($6) #Y almacenando los resultados en addi $6, $6, -1 #el espacio reservado en orden mflo $4 #inverso: primera división dígito bne $4,$0,bucle #menos significativo add $6, $0, $0 addi $10, $0, 8 loop: lb $4, string($6) #Conversión de la cadena de digitos slti $5, $4, 10 #hex. en sus correspondientes bne $5, $0, menorde10 #caracteres ASCII para poderlos #Imprimir majorde10:addi $4, $4, 55 #Si el dígito es mayor de 9 j finloop #sumamos 55 a su valor para convertir #en los caracteres de ‘A’ a ‘F’. menorde10:addi $4, $4, 48 #Si esta entre 0 y 9, sumamos 48 para #Convertir en caracteres ‘0’ a ‘9’. finloop: sb $4, string($6) addi $6, $6, 1 beq $6, $10, fin #Repetimos para todos los dígitos j loop fin: la $4,return #Imprimimos la cadena return addi $2,$0,4 syscall


la $4,string #Imprimimos la cadena correspondiente addi $2,$0,4 #al numero convertido syscall addi $2,$0,8 #Esperamos la pulsacion de una tecla la $4,cad addi $5,$0,2 syscall addi $2,$0,10 #Fin del programa syscall

Tema 3personales.upv.es/pabmitor/acso/FILES/ArqComp/CST/ArqComp d10... · → decodificador de...

Documents

Transcript of Tema 3personales.upv.es/pabmitor/acso/FILES/ArqComp/CST/ArqComp d10... · → decodificador de...