U1 Apuntes Lenguaje Ensamblador

7/23/2019 U1 Apuntes Lenguaje Ensamblador

1/64

Fundamentos de Computadores

Tema 3LENGUAJE

ENSAMBLADOR


2/64

FUNDAMENTOS DE COMPUTADORESTema 3. Lenguaje Ensamblador Contenido - I

INTRODUCCIN ____________________________________1

Uso de un lenguaje ensamblador _____________________3

Inconvenientes del lenguaje ensamblador ______________3

Eleccin 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 ____________________11MODOS DE DI RECCIONAMIENTO ___________________13

Direccionamiento a registro ________________________13

Direccionamiento inmediato ________________________13

Direccionamiento base o desplazamiento______________14

Direccionamiento relativo al contador de programa ____14

INSTRUCCIONES DE BI FURCACIN O SALTO ________15

Salto incondicional ________________________________15

Salto condicional__________________________________16

FORMATO DE LAS INSTRUCCIONES_________________19

Formato R _______________________________________19

Formato I________________________________________20


3/64

FUNDAMENTOS DE COMPUTADORESTema 3. Lenguaje Ensamblador Contenido - II

Formato J _______________________________________21

JUEGO DE INSTRUCCIONES________________________22

USO DE REGISTROS Y MEMORIA ___________________28

Registros de la CPU _______________________________28

Distribucin de la memoria_________________________30

PROGRAMACIN EN ENSAMBLADOR _______________31

EJEMPLOS________________________________________33

PROGRAMACIN MEDIANTE SUBRUTINAS __________39

Paso de parmetros _______________________________41

Preservacin 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 pi la_______________________________52

Diseo (ejemplo factor ial )__________________________53

REGULARIDAD Y ORTOGONALIDAD_________________54

EJEMPLOS: _______________________________________55

Programa que detecta cadenas capicuas.______________55

Clculo de la serie de fibonazzi. _____________________55

Conversin a formato IEEE 754. ____________________55


4/64

FUNDAMENTOS DE COMPUTADORESTema 3. Lenguaje Ensamblador 1

INTRODUCCIN Instruccin: Palabra de un lenguaje que especifica

alguna accin.

Juego de instrucciones: Cto. de todas lasinstrucciones que forman un lenguaje.

Lenguaje Mquina: Lenguaje de programacin queentiende un ordenador directamente.

Lenguaje Ensamblador: Abstraccin de lenguajemquina para hacerlo ms fcil de programar.

Lenguaje de Alto Nivel: Lenguaje de programacinabstracto ms cercano al lenguaje humano natrual.

Lenguaje de

Alto Nivel

Lenguaje

Ensamblador

Lenguaje

Mquina

Ensamblador

Compilador


5/64


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 Mquina:

01010000110011101010100010010101

01111010010101010100010111010110

01010010111011010101010101010101

1010101110110010010111010110010001011010101100100111110100010101

01101010101110101101010101010101

10101001000101011110101010010101

01101011000101010101001011011011


6/64


Uso de un lenguaje ensamblador Velocidad

Tamao

Carencia de compiladores

Inconvenientes del lenguaje ensamblador

Dependientes de la mquina

Programas ms largos (factor de expansin)

Depuracin difcil.

Compiladores muy optimos.

Eleccin 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


7/64


ARQUITECTURA DEL P MIPS R2000

Simple y regular.

Bus de datos: 32bits

Bus de direcciones: 32bits 4Gb de direccionamiento

MIPSR2000

Coprocesador

Matemtico

R2010

Memoria

Principal

Bus del Sistema

$0

$1

$2

$3

$31

PC

hi

lo

UAL

Status

Cause

EPC

BadVAddr

MMU

con TLB

Coprocesador 0


8/64


$0

$1$2

$3

$31

Coprocesador 1

Unidad de

divisin

Unidad demultiplicacin

FPU. Nmeros en coma flotante IEEE 754

Modo Usuario y Modo Ncleo

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.

Mquina virtual.

Instrucciones Reales y pseudoinstrucciones.


9/64



10/64


INSTRUCCIONES BASICASInstruccin aritmtica:

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 instruccin add SIEMPRE debe tener 3 op.

Para sumar ms 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 expansin)

Operacin de resta o substraccin:

sub c,a,b #c:=a-b


11/64


Empleo de variables temporales

Variables internas no necesarias para el resultado pero sipara los clculos intermedios.

Para generar:

f:=(g+h)-(i+j)+(k-l)

add t0,g,h # t0 variable temporaladd 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 mquina deben estar situadosen 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 mximo

El compilador debe asignar las variables a los registros.

Por ejemplo f $16, g $17, h $18, etc.


12/64


Accesos a memoria

Los datos se han de traer de memoria principal a losregistros para poder trabajar con ellos.

Los resultados pueden necesitar volcarse a memoria.

Para traer un dato hay que hacer una lectura sobrememoria, instruccin lw(load word)

Para volcar un dato hay que hacer una escritura sobrememoria, instruccin 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 direccin efectiva

MIPS R2000$8

$10 D

MP

$17 = 0


13/64


Accesos a estructuras de datos

PROGRAM ejemploVAR

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]


14/64


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

0123

4567

891011

D

D+4

D+8

D+1

D+6

Memoria Principal

*Con D mltiplo de 4Dir.

0

1

23

4

5

6

7

8

9

....

Palabra 0

(Word 0)

Palabra 4(Word 4)

Dir.

0

1

23

4

5

6

7

8

9

....

Media Palabra 0(Half-Word 0)



Dir.

0

1

23

4

5

6

7

8

9

....

Byte 0

Byte 1

Byte 2Byte 3

Byte 4

Byte 5


15/64


Del ejemplo: Para acceder a V[i], siendo V un vector de

palabras, $17 debe contener i*4 y no i.

V[i] ? Elemento nmero i del vector V.

V ? Vector de palabras.

V[i] ? Palabra nmero i.

Qu direccin 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] =


16/64


MODOS DE DIRECCIONAMIENTOModos de acceder a los operandos de una instruccin.

Repercuten en el modo de acceder a los datos.

Modo real: Sumaralgo al contenido de un registro.

Modo virtual: Segn 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

Inicializacines o operaciones con ctes.

Instrucciones en versin inmediata:

addi $17, $17, 4 # inmediate add


17/64


Direccionamiento base o desplazamiento

Normalmente se emplea para accesos a memoria

La direccin efectiva se obtiene sumando una cantidadms el contenido de un registro

La cantidad se codifica con la instruccin.

Dos posibles interpretaciones:

lw $10, Vinicio($17) #Acceso al valor $17/4lw $10, 12($16) #Acceso al valor 3

#En $16 esta Vinicio

Direccionamiento relativo al contador deprograma

Normalmente usado en saltos.

bne $21, $8, seguir # Ir a seguirsi $8$21

seguires una etiqueta

La direccin de salto se calcula como un valor aadido (orestado) al contador de programa actual

Este valor lo calcula el ensamblador:

etiqueta: addi $5, $8, 78


18/64


INSTRUCCIONES DE BIFURCACIN OSALTOTipos:

Salto incondicional

Salto condicional

Salto incondicional

Instruccin:j(jump)Operando: Direccin destino. Valor concreto o etiqueta

j 2300 #Salta a la direccin 2300j etiqueta #Salta a la direccin de la etiqueta

Instruccin:jr(jump register)Operando: Registro que contiene la dir. de salto.

Direccionamiento indirecto a registro

jr $12 #Salta a direccin indicada por $12


19/64


Salto condicional Salta si se produce alguna condicin

Implementa IFTHENELSE

beq $7, $12, etiqueta #Salta si $7 = $12

bne $7, $12, etiqueta #Salta si $7$12

Comparacin de desigualdad:

slt $8, $19, $22 # set on less than

Si $19


20/64


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, L1add $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

REPETIRg:=g+A[i];i:=i+j;

HASTA (i=h)

bucle: multi $9, $19, 4lw $8, A($9)add $17, $17, $8add $19, $19, $20bne $19, $18, bucle


21/64


SENTENCIA WHILE (MIENTRAS)

Suponemos i, x $22 - $23

i:=1MIENTRAS (i


22/64


FORMATO DE LAS INSTRUCCIONES Cada instruccin ocupa 32 bits (1 palabra)

3 tipos de codificaciones

decodificador de instrucciones ms simple

Formato R

Instrucciones con todos los operandos en registros

Campos de la instruccin:

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

1 y ltimo: Tipo de operacin 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


23/64


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 salirsonpalabras

salirlo calcula el compilador

Si el salto excede el desplazamiento mximo:

beq $18, $19, Etiqueta

bne $18, $19, auxj etiqueta

aux:


24/64


Formato J Instrucciones de salto incondicional (no todas)

Formato:

op direccin

6 bits 26 bits

direccin expresada en palabras

Salto mximo 228 bytes = 256Mb

Salto mayor: Instruccinjr registro con direccin.

Programas no relocalizables


25/64


JUEGO DE INSTRUCCIONES Instrucciones reales

Pseudoinstrucciones ()

ARITMTICO-LGICAS:

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 Divisin (con signo)divu RSrc1, RSrc2 Divisin (sin signo)

cociente en registro lo - resto en reg. hi

mult Rsrc1, Rsrc2 Multiplicacin (c.s.)multu Rsrc1, Rsrc2 Multiplicacin (s.s.)

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


26/64


nor Rdst, Rsrc1, Src2 Nor (Or negada)or Rdst, Rsrc1, Src2 Orori Rdst, Rsrc1, Imm Orand Rdst, Rsrc1, Src2 AND lgicoandi Rdst, Rsrc1, Imm AND inmediataxor 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. aritmtico dcha.En Src2 esta el nm. de bits a desplazar

MANIPULACIN DE CONSTANTESli Rdst, Imm Rdst Imm ()

lui Rdst, Imm Rdst(parte alta)Imm

COMPARACINslt Rdst,Rsrc1, Src2 = 0bgezal Rsrc, Etiq Salto y enlaza si >= 0bltz Rsrc, Etiq Salto si < 0blez Rsrc, Etiq Salto si


28/64



29/64


CARGA

la Rdest, ident Carga direccin ()lb Rdest, direccin Carga byte (ext.

signo)lbu Rdest, direccin Carga byte (sin ext.)lh Rdest, direccin Carga media-pal.(ext.)lhu Rdest, direccin Carga media-pal.(s.e.)lw Rdest, direccin Carga palabrald Rdest, direccin Carga doble palabra()

ALMACENAMIENTOsb Rsrc, direccin Almacena byte bajo

sh Rsrc, direccin Alm. media-pal. bajasw Rsrc, direccin Alm. palabrasd Rsrc, direccin Alm. doble palabra

En las instrucciones de carga y almacenamiento:

Direcciones para bytes: cualquiera. Direcciones para medias pal.: mltiplos de dos (pares).

Dir. para palabras: mltiplos de 4.

Dir. para dobles palabras: mltiplos de 8.


30/64


MOVIMIENTO

move Rdest, Rsrc Rdest Rsrc ()mfhi Rdest Rdest himflo Rdest Rdest lomthi Rdest hi Rdestmtlo Rdest lo Rdest


31/64


USO DE REGISTROS Y MEMORIA

Registros de la CPU

32 registros de propsito 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 Direccin de retorno (jal)

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


32/64


Nmero Nombre Uso

0 $zero Constante 01 $at Reservado para el ensamblador2 $v0 Evaluacin de expresiones3 $v1 Evaluacin de expresiones4 $a0 Argumento 15 $a1 Argumento 2

6 $a2 Argumento 37 $a3 Argumento 48 $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 ncleo del S.O.27 $k1 Reservado para el ncleo 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 Direccin de retorno (return address)


33/64


Distribucin de la memoria

Organizacin convencional

3 partes:

Segmento de cdigo: 0x400000 (text segment)

Segmento de datos: 0x10000000 (data segment)

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

Segmento de pila

Datos dinmicosDatos estticos

Segmento cdigo

Reservado0x00000000

0x10000000

0x00400000

0x7FFFFFFF

Ordenamiento de los bytes:

Little endian

31

32 1 00

Big endian


34/64


31

0

1 2 30

PROGRAMACIN EN ENSAMBLADOR

1 instruccin por lnea

4 campos:

Etiqueta (opcional)

Cdigo operacin

Operandos

Comentario (opcional)

Identificadores: Caracteres alfanumricos + _ + .

Palabras reservadas

Etiquetas = identificador+:

Directivas: Instrucciones SOLO para el ensamblador


35/64


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

desactiva la alineacin 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. nmero 0 (NULL)

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

.data Almacena los elementos declarados acontinuacin de la directiva a partir de la dir.ADDR en el segmento de datos. Si no aparece setoma la dir. por defecto.

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

.end Fin del programa

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

.global smbolo Smbolo declarado como global. Se puedereferenciar 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 Almacena los elementos declarados tras estadirectiva en el segmento de cdigo a partir de ladireccin ADDR. Estos elementos solo pueden serpalabras (.word) o instrucciones. Si no aparece

ADDR se toma la direccin por defecto..word w1, ,wn Almacena las wn palabras (32 bits) en posicionesconsecutivas de memoria.


36/64


EJEMPLOSEjemplo 1:

Suma de los primeros 200 nmeros.

En PASCAL:

i:=0; suma:=0;REPETIRi:=i+1;suma:=suma+1;

HASTA QUE(i>=200)

i $8, suma $9

.data 0x10000000 #seg. de datos

.text #seg. Cdigo

.global __start #Inicio del prog.

__start: addi $8,$0,0 #i:=0addi $9,$0,0 #suma:=0

repeat: addi $8,$8,1 #i:=i+1add $9,$9,$8 #suma:=suma+islti $10,$8,200 #$10:=1 si i


37/64


Ejemplo 2:

Programa que cuenta la longitud de la palabraFundamentos+NULL almacenada a partir de la direccin0x10000000. 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 altaori $20, 0x0000 #Carga parte bajaaddi $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. caraddi $21, $21, 1 #Inc. longitudj bucle

fin: .end


38/64


Ejemplo 3:

Programa que copia la longitud de la palabraFundamentos + NULL almacenada a partir de la direccin0x10000000 a la direccin 0x100020A0

.data 0x10000000 #Seg. de datos

.asciiz Fundamentos.data 0x100020A0 #Direccin destino

.space 12 (11+1) #Espacio para copia

.text

.global inicio #En SPIM __start

inicio: lui $20, 0x1000 #Carga parte altaori $20, 0x0000 #Carga parte bajalui $21, 0x1000 #Parte alta destino

ori $21, 0x20A0 #Parte baja destinobucle: lb $19, 0($20) #Lectura byte de la cad.

sb $19, 0($21) #Copiamos caracterbeq $0, $19, fin #Si es 0 (NULL), finaddi $20, $20, 1 #Inc. para leer sig. caraddi $21, $21, 1 #Siguiente car. destinoj bucle

fin: .end


39/64


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 0beq $20, $0, fin #Si no hay 1s, finaddi $18, $0, 1 #Ponemos 1 en $18

rotar: beq $18, $0, fin #32 desplazamientosand $19, $20, $18 #Extraer bit i-essimosll $18, $18, 1 #Desplazar a la izq.beq $19, $0, rotar #Bit 0, no contamos

addi $21, $21, 1 #Incrementamos cuentaj rotar

fin .end


40/64


EJEMPLO 5:

Programa en ensamblador que concatene dos cadenasacabadas en NULL.

El algoritmo debe copiarlas en una cadena destino.Primero copia una y despus copia la segunda acontinuacin.

Para referenciar una posicin de memoria usaremos

etiquetas en lugar de usar lui y ori. Las etiquetas apuntanal inicio de las cadenas. Las direcciones las genera elensamblador.

.data 0x10000000cad1: .asciiz ensambladorcad2: .asciiz ejemplo

dest: .space 19.text.global __start

inicio: add $16,$0,$0lcad1: lb $17, cad1($16) #Leer caracter cad. 1

beq $17,$0,flcad1 #Si es 0, leer cad. 2sb $17,dest($16) #Copiamos a destinoaddi $16,$16,1 #Incrementamos indice

j lcad1 #Seguir leyendo cad. 1flcad: add $18,$0,$0 #Lectura seg. cadenalcad2: lb $17,cad2($18) #Leer carcter

sb $17,dest($16) #Copiar a destinobeq $17,$0, fin #Con NULL acabamosaddi $16,$16, 1 #Incrementamos indice 1addi $18, $18, 1 #Inc. indice 2j lcad2

fin: .end


41/64


EJEMPLO 6:

Dado un vector de 6 enteros de 32 bits en 0x10000000, noindique cuantos elementos son mayores, menores eiguales que el ltimo elemento. Ubicar el resultado enmemoria, despus de los elementos del vector y delnmero de elementos.

.data 0x10000000vector: .word 34, 21, 10, 5, 3, 10nelem: .word 6mayor: .word 0menor: .word 0igual: .word 0

.text

.global __start

inicio: lw $20,nelem($0) #Leemos nm. elementosaddi $16,$0,4mult $20,$16 #Tamao en bytesmflo $16 #Movemos lo a $16addi $16,$16,-4 #Indice ltima coponentelw $8,vector($16) #Referencia en $8add $18,$0,$0 #Indice para vector

bucle: addi $20,$20,-1 #Dec. nmero elementoslw $21,vector($18) #Leemos elemento vectoraddi $18,$18,4 #Inc. indice

si: slt $7,$21,$8 #$21


42/64


j finb

snsa: beq $21,$8,igua #Son iguales?lw $9,mayor($0) #Mayor. Leer mayoresaddi $9,$9,1sw $9,mayor($0)j finb

igua: lw $9,igual($0) #Leemos igualesaddi $9,$9,1sw $9,igual($0)

finb: beq $20,$0,finj bucle

fin: .end

PROGRAMACIN MEDIANTE

SUBRUTINAS

MIPS da soporte a las subrutinas mediante lainstruccin jal (jump and link).

Almacena en $31 la direccin de retorno (PC)

Sintaxis: jal Direccin

Para finalizar: jr $31

jal rutina

instruccin

D-4

D

rutina

jr $31

$31:=D (PC+4)

PC:=rutina


43/64


Llamadas anidadas?

Solucin: Usar la pila ($29)

Almacenar en pila: Apilar opush

Sacar de pila: Desapilar opop

Por ejemplo:

Prog.

principalRutina 1 Rutina 2

Rutina 3

El compilador generar:

inicio: jal Rut1j fin

Rut1: addi $29,$29,-4 #Apilarsw $31, 0($29) #Guardar dir. retornojal Rut2lw $31,0($29) #Recuperar direccin

addi $29,$29,4 #Desapilarjr $31

Rut2: igual que Rut1

Rut3: #No hace falta apilar porque no#hay llamada a subrutina

jr $31


44/64


fin: .end

Paso de parmetros

Por convencin se usan $4, $5, $6, $7

Para ms parmetros se usa la pila

Preservacin de registro s

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

Solucin: 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.

Guardar

Salto

RestaurarRutina Salto

Guardar

Rutina

Restaurar


45/64


EJEMPLOS

Uso de subrutinasPROCEDURE intercambia(var v:vector;k:integer);VAR temp:integer;BEGINtemp:=v[k];v[k]:=v[k+1];v[k+1]:=temp;

END.

Registros: $15temp, $4v, $5k

Algoritmo de ordenamiento de la burbujaPROCEDURE ordena(var v:vector; n:integer);VAR i,j:integer;BEGINFOR i:=0 TO n-1 DOBEGINj:=i-1;WHILE(j>=0) AND (v[j]>v[j+1]) DOBEGINintercambia(v,j);j:=j-1;

END;END;END.

Registros: $19i, $17j, $4v, $5n

PASOS A SEGUIR:

1.Generar cuerpo de la rutina


46/64


2.Salvar los registros usados


47/64


Rutina de intercambio de elementos del vector:

1.- Cuerpo:2 addi $14,$0,4 #$14=4

mult $5,$14 #lo=k*4mflo $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 pal1 sw $2, 0($29) #Apilar $2

sw $14, 4($29) #Apilar $14sw $15, 8($29) #Apilar $15

sw $16, 12($29) #Apilar $16Recuperacin de registros y retorno de subrutina3 lw $2, 0($29) #Desapila $2

lw $14, 4($29) #Desapila $14lw $15, 8($29) #Desapila $15lw $16, 12($29) #Desapila $16addi $29,$29,16 #Vaciar pilajr $31 #Fin de subrutina

Rutina de ordenamiento de la burbuja:

Necesita guardar los parmetros en otros registros

Hay que implementar dos bucles anidados

El bucle interno tiene dos condiciones


48/64


1.-Cuerpo:

ordena: ( 4 )Apilar registros usados5 add $18,$4,$0 #Copia parmetro v

add $20,$5,$0 #Copia parmetro nadd $19,$0,$0 #i:=0addi $21,$0,4 #$21=4

for: slt $8,$19,$20 #$8=0 si i>=nbeq $8,$0,exitf #Salir si i>=naddi $17,$19,-1 #j:=i-1

while: slti $8,$17,0 #S8=1 si j=v[j]

add $4,$18,$0 #Parmetro v=vadd $5,$17,$0 #Parmetro k=jjal inter

addi $17,$17,-1 #j:=j-1j while #Repetir bucle while

exitw: addi $19,$19,1 #i:=i+1j for #Repetie bucle for

exitf: ( 6 )Desapilar todos los registros apiladosjr $31 #Retorno de subrutina


49/64


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 $8sw $31,40($29) #Apilar $31

6 lw $8,0($29) #Desapilar $8addi $29,$29,44 #Liberar espacio pila

Programa principal que llama a la rutina de la burbuja

.data 0x10000000v: .word 0x10000004 #Direccin vector

.word 72,50,8 #Vector

.word 20,15

.text

.global inicio

inicio: lw $4,v($0) #Inicializa parmetro vaddi $5,$0,5 #Inicializa parmetro njal ordena #Burbujaj fin #Salto al final

CODIGO DE LAS RUTINAS

fin: .end


50/64


MANEJO DE DATOS EN COMAFLOTANTE

Standar IEEE 754

Formatos simple (32 bits) y doble precisin (64 bits)

Datos manejados por FPU 32 registros de 32 bits.

Doble precisin: 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 simultneas

Instrucciones con sufijo d (doble) y s (simple)

Instrucciones para coma flotante

FRdest, FRsrc1 y FRsrc2 registros de FPU PARES ($fn)


51/64


add. FRdest, FRsrc1, FRsrc2

d(doble precisin) s (simple precisin)

sub. FRdest, FRsrc1, FRsrc2

abs. FRdest, FRsrc

Valor absoluto de FRsrc

mult.FRdest, FRsrc1, FRsrc2div. 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 FPUc.x. FRscr1,FRscr2

Comparacin de FRscr1 y FRscr2. Se activa el bitcorrespondiente del reg. de estado del coprocesador. El bitdepende de la condicin x: eq, neq, lt, le, gt, ge.

bc1t direccion #Salto si TRUE

bc1f direccion #Salto si FALSE


52/64


Ejemplo:

Suma de los elementos de un vector en coma flotante desimple precisin. El vector empieza en 0x10000004.

.data 0x10000000tam: .word 4vector: .float 3.1415, 2.7182

.float 1.0e+2, 6.5e-1

res: .float 0.0.text.globl __start

inicio: addi $15,$0,0 #Indiceaddi $17,$0,0 #Contadorlw $16,tam($0) #Tamao del vectormtc1 $0, $f2 #0 a f2 (temporal)

bucle: l.s $f4,vector($15)#Leemos elem $15 vectoradd.s $f2,$f2,$f4 #Sumamos elementoaddi $15,$15,4 #Increm. indiceaddi $17,$17,1 #Increm. contadorslt $8,$17,$16 #Final?bne $8,$0,bucle #$8=1 implica $17


53/64


LLAMADAS AL SISTEMA Son llamadas al sistema operativo

Facilitan la tarea del programador

Ofrecen servicios como imprimir por pantalla ointroducir nmeros y caracteres por teclado

syscall

Tipo de llamada en $2 ($v0)

Parmetros en $4$7 ($f12 con coma flotante)

Ejecutar syscall.

El resultado se devuelve en $2 o $f0

Servicio Cdigo Parmetros Resultadoprint_int 1 $4=enteroprint_float 2 $f12=floatprint_double 3 $f12=dobleprint_string 4 $4=dir. cadenaread_int

5 $2 enteroread_float 6 $f0 floatread_double 7 $f0 dobleread_string 8 $4=dir. buffer,

$5= longitudsbrk 9 $4=desplazam. $2 direccinexit 10


54/64


EJEMPLO

Programa que calcula la potencia de dos nmeros: ab

Para ensamblador, deberemos imprimir las cadenas y leerlos datos que el usuario introduzca con llamadas alsistema.

.data 0x10000000cad1: .asciiz \nDame la base real:

cad2: .asciiz \nDame el exponente entero:cad3: .asciiz \nEl resultado es:.text.global inicio

inicio: addi $2,$0,4 #Cdigo impresinla $4, cad1 #direccin de cadena1syscall #Impresinaddi $2,$0,6 #Cod. lectura floatsyscall #Lectura baseaddi $2,$0,4 #Cod. impresin

la $4, cad2 #direccin cadena2syscall #Impresinaddi $2,$0,5 #Cod. lectura enterosyscall #Lectura exponente

mfc1 $4,$f0 #Pasamos la base a $4add $5,$0,$2 #Exponente en $5jal pot #Llamada a rutinamtc1 $2,$f12 #Resultado de $2 a $f12addi $2,$0,4 #Cdigo impresinla $4,cad3 #Direccin cadena3syscall #Impresinaddi $2,$0,2 #Escritura floatsyscall #Escribimos $f12addi $2,$0,10 #Cod. salida programasyscall.end

pot: addi $29,$29,-12 #Hacemos sitio en pila

sw $9,0($29) #Apila $9


55/64


s.s $f4, 4($29) #Apila $f4s.s $f6, 8($29) #Apila $f6addi $9,$0,2 #i:=2mtc1 $4,$f4 #aux:=base

mtc1 $4,$f6 #$f6:=basefor: slt $10,$5,$9 #i>exponente?

bne $10,$0,exif #salir si i>exponentemul.s $f4,$f4,$f6 #aux:=aux*baseaddi $9,$9,1 #i:=i+1j for

exif: mfc $2,$f4 #Devolvemos res en $2

lw $9,0($29) #Desapilar $9l.s $f4, 4($29) #Desapilar $f4l.s $f6, 8($29) #Desapilar $f6addi $29,$29, 12 #Restaurar pilajr $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

Estructu ra de la pi la Es necesario almacenar en la pila cierta informacin

MIPS ofrece un modelo para hacer las llamadas de unaforma uniforme, que indica la estructura que debe tenerla pila:

1.Argumentos de la subrutina (ms de 4)


56/64


2.Registros que se modifican en la subrutina y cuyo

valor se debe mantener3.Variables locales.

Argumento 5

Argumento 6

...

Registrosguardados

Variables locales

+

-$sp ($29)

$fp ($30)

Dis eo (ejemp lo fac to rial)

FUNCTION factorial(n:integer):integer;BEGINIF(n0)THEN factorial:=n*factorial(n-1);ELSE factorial:=1;

END;

Cada llamada debe guardar su propia pila. Suponemosque tenemos el entero en $2 y que ya lo hemos leido delusuario. El parmetro de factorial lo pasamos en $4: #Inicializacin y lectura

addi $4,$2,0 #Parmetro introducido a $4jal fact #Llamada principal

#Imprimir y terminar

fact: addi $29,$29,-8 #Espacio para 2 palabrassw $4,4($29) #Almacena parmetro ($4)

sw $31,0($29) #Almacena dir. retorno


57/64


lw $2,4($29) #Lectura argumento n ?bgtz $2,seguir #Si n>0 llamarseaddi $2,$0,1 #Un 1 como resultadoj volver #fin de recursin

seguir: lw $3,4($29) #Lectura argumento naddi $4,$3,-1 #Parmetro n-1

jal fact #Llamada recursiva

lw $3,4($29) #Lectura argumento nmult $2,$3 #n*factorial(n-1) ($2)mflo $2 #Resultado parcial

volver: lw $31,0($29) #Direccin de retotno

addi $29,$29,8 #Restaurar pilajr $31 #Retorno

REGULARIDAD Y ORTOGONALIDAD

Regularidad: Conjunto de instrucciones uniformes sincasos especiales. Simplifica la programacin.

Ortogonalidad: Cualquier operacin se puede usarcon cualquier operando y cualquier modo dedireccionamiento.

Los dos conceptos estn muy unidos.


58/64


EJEMPLOS:

Programa que detecta cadenas capicuas.

Clculo de la serie de fibonazzi.

Conversin a formato IEEE 754.


59/64


.databuffer: .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,4syscalladdi $2,$0,8la $4,bufferaddi $5,$0,100syscall

add $11,$0,$0 #Clculo de la longitudaddi $12,$0,10

long: lb $10,0($4)beq $10,$12,finlongaddi $4,$4,1addi $11,$11,1j long

finlong: beq $11,$0,fin #Cadena vaciaaddi $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,-1addi $5,$5,1addi $11,$11,-2

slti $13,$11, 2 #$13=1 si $11


60/64


fin: addi $2,$0,10syscall


61/64


.data

.text

.globl __start

__start:addi $2,$0,5syscalladd $4,$0,$2jal fibonj fin

fibon: addi $29,$29,-12sw $10,8($29)sw $4,4($29)sw $31,0($29)

beq $4,$0,zeroslti $10,$4,2bne $10,$0,un

addi $4,$4,-1jal fibon

add $10,$0,$2lw $4,4($29)addi $4,$4,-2jal fibonadd $2,$2,$10jr finfibo

zero: add $2,$0,$0jr finfibo

un: addi $2,$0,1

finfibo: lw $31,0($29)lw $4,4($29)lw $10,8($29)addi $29,$29,12jr $31

fin: add $4,$0,$2add $2,$0,1syscalladdi $2,$0,10


62/64


syscall


63/64


.dataflotant: .float 103.487

string: .byte 0,0,0,0,0,0,0,0,0 #Espacio para almacenar elnmerocad: .asciiz "\nIntroduce el nmero en coma flotante:"return: .asciiz "\nEl nmero en formato IEEE754 es (en Hex.):\n"

.text

.globl __start__start: la $4,cad #Impresin de la cadena cad

addi $2,$0,4syscalladdi $2,$0,6 #Lectura de nmero en coma flotantesyscallmov.s $f12, $f0 #Impresin del nmeroaddi $2, $0, 2syscall

mfc1 $4, $f0 #Llevmos el nmero del copro a laaddi $5, $0, 16 #CPU para su visualizacinaddi $6, $0, 7

bucle: divu $4, $5 #Conversin a hexadecimalmfhi $7 #Dividiendo por 16 sucesivamente

sb $7, string($6) #Y almacenando los resultados enaddi $6, $6, -1 #el espacio reservado en ordenmflo $4 #inverso: primera divisin dgitobne $4,$0,bucle #menos significativoadd $6, $0, $0addi $10, $0, 8

loop: lb $4, string($6) #Conversin de la cadena de digitosslti $5, $4, 10 #hex. en sus correspondientesbne $5, $0, menorde10 #caracteres ASCII para poderlos

#Imprimirmajorde10:addi $4, $4, 55 #Si el dgito 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, 1beq $6, $10, fin #Repetimos para todos los dgitosj loop

fin: la $4,return #Imprimimos la cadena returnaddi $2,$0,4syscall


64/64

la $4,string #Imprimimos la cadena correspondienteaddi $2,$0,4 #al numero convertido

syscalladdi $2,$0,8 #Esperamos la pulsacion de una tecla

la $4,cadaddi $5,$0,2syscall

addi $2,$0,10 #Fin del programasyscall

U1 Apuntes Lenguaje Ensamblador

Documents

Transcript of U1 Apuntes Lenguaje Ensamblador