PDF de programación - 12. Programación en ensamblador MIPS

Estructura y Tecnología de Computadores (ITIG)

(cid:1)(cid:2)(cid:3)(cid:4)(cid:5)(cid:6)(cid:7)(cid:8)(cid:6)(cid:9)(cid:10)(cid:9)(cid:11)(cid:12)(cid:13)(cid:14)(cid:4)(cid:15)(cid:14)(cid:4)
(cid:15)(cid:14)(cid:16)(cid:9)(cid:10)(cid:17)(cid:18)(cid:9)(cid:19)(cid:7)(cid:6)(cid:4)(cid:20)(cid:21)(cid:5)(cid:22)(cid:3)

Ángel Serrano Sánchez de León

Luis Rincón Córcoles

Tema 12. Programación en ensamblador MIPS.

Programa

Introducción.

1.
2. Registros.
3. Operaciones aritméticas básicas.
4. Accesos a memoria. Carga y almacenamiento.
5. Lenguaje máquina MIPS.
6. MIPS y las sentencias de control.
7. Llamadas a funciones.
8. Manejo de caracteres.
9. Aritmética para números con signo.
10. Operaciones lógicas.
11. Aritmética en coma flotante.
12. Bibliografía.

2

11

Tema 12. Programación en ensamblador MIPS.

Conceptos básicos: registros de MIPS y convenio software de uso,
operaciones básicas (aritméticas, lógicas, desplazamiento), operaciones de
carga/almacenamiento, inmediato, formato de instrucciones en MIPS, sentencias
de control (IF, FOR, WHILE, DO-WHILE, GOTO), subprograma o subrutina
(función/procedimiento; hoja/anidada/recursiva), manejo de la pila, cadenas de
caracteres, operaciones en coma flotante.

Instrucciones y pseudoinstrucciones de MIPS en este tema: add, add.d,
add.s, addi, addiu, addu, and, andi, begz, beq, bge, bgt, blt,
bne, div, div.d, div.s, divu, j, jal, jr, lb, lbu, lh, lhu, li,
li.d, li.s, lui, lw, lwc1, mfhi, mflo, move, mul, mul.d, mul.s,
mult, multu, nor, or, ori, sb, sh, slt, slti, sltu, sub, sub.d,
sub.s, subu, sw, swc1, xor, xori.

Tema 12. Programación en ensamblador MIPS.

1. Introducción

• El lenguaje ensamblador depende directamente de la arquitectura del
computador. Por tanto cada arquitectura tiene su propio lenguaje
ensamblador.

• Los lenguajes ensambladores de dos arquitecturas diferentes son como
primos cercanos, diferentes pero muy parecidos. Sin embargo, los
lenguajes de alto nivel tienden a ser parientes lejanos, pues la sintaxis es
más variable.

• En este tema veremos sólo los conceptos fundamentales de la
programación en ensamblador para los procesadores MIPS.

• El estudio del ensamblador de una arquitectura permite comprender y
dominar el diseño y el funcionamiento de cada una de las partes de la
misma.

3

4

22

Tema 12. Programación en ensamblador MIPS.

¡Hola Mundo!

.rdata

.align 2

# Inicio de seccion de datos ROM

# Direccion alineada a palabra (multiplo de 4)

texto:

.ascii "Hola Mundo!"

# Cadena identificada por etiqueta "texto"

.text

.globl main

# Comienzo de seccion de codigo de usuario

# La etiqueta "main" se hace conocida a

.ent main

# La etiqueta "main" marca un punto de

# nivel global

# entrada

main:

la $4, texto

# Escribimos en el registro $4 la direccion

jal printf

# Llamada a funcion printf, que escribe

# de memoria asociada a la etiqueta "texto"

j _exit

# Saltamos a la rutina de salida para

# cadenas de texto en la consola

.end main

# Final de la seccion "main"

# terminar

5

Tema 12. Programación en ensamblador MIPS.

2. Registros

• Recordemos que MIPS dispone, entre otros, de los siguientes registros:

• 32 registros en la CPU, cada uno de 32 bits.

• 32 registros en la unidad de coma flotante, cada uno de 32 bits.

• Un contador de programa (PC) de 32 bits, que indica, al principio de cada ciclo, la
dirección de memoria de la instrucción del programa que se va a ejecutar.

• Dos registros de 32 bits para multiplicaciones y divisiones (HI y LO).

• Por convenio entre los programadores de MIPS, los registros de la CPU se
usan utilizando unas “normas de buen uso”:

• El valor de algunos registros, como los $s0 – $s7, el puntero de pila $sp, entre
otros, debe ser preservados entre llamadas a funciones.

• El valor de otros registros “temporales”, como $t0 – $t9, puede ser modificado en
llamadas a funciones.

6

33

Tema 12. Programación en ensamblador MIPS.

Registro

Número

Uso

¿Preservado?

$zero

$at

$v0 – $v1

$a0 – $a3

$t0 – $t7

$s0 – $s7

$t8 – $t9

$k0 – $k1

$gp

$sp

$fp

$ra

0

1

2 – 3

4 – 7

8 – 15

16 – 23

24 – 25

26 – 27

28

29

30

31

Constante con valor 0

No aplicable

Temporal para el ensamblador

Valores devueltos en funciones

Argumentos en funciones

Temporales

Temporales salvados

Temporales

Reservados para kernel

Puntero global

Puntero de pila

Puntero de marco

Dirección de retorno

No

No

No

No

Sí

No

No

Sí

Sí

Sí

Sí

7

Tema 12. Programación en ensamblador MIPS.

3. Operaciones aritméticas básicas

• MIPS es una máquina de arquitectura carga-almacenamiento: para usar un
dato almacenado en memoria, primero hay que pasarlo a un registro.

• Las operaciones aritméticas básicas en MIPS se caracterizan por:

• Utilizar tres registros (2 para los operandos y 1 para el resultado).

• Sintaxis: operacion resultado op1 op2

• El último de los operandos puede ser una constante de 16 bits (“inmediato”).

• Ejemplo: El mnemónico para la suma es add.

(cid:1) C:
int a, b, c;
c = a + b;

(cid:1) MIPS:
# Suponiendo que los datos a, b, c

# están asignados a los registros

# $s0, $s1, $s2 respectivamente:

add $s2, $s0, $s1

# $s2 = $s0 + $s1

8

44

Tema 12. Programación en ensamblador MIPS.

• Si sólo podemos sumar dos registros en cada instrucción, ¿cómo hacemos
operaciones más complicadas?

• Ejemplo: El mnemotécnico para la resta es sub.

(cid:1) C:
int a, b, c, d, e;
a = ( b + c ) – ( d + e );

(cid:1) MIPS:

# Suponiendo que los datos a, b, c, d, e

# están asignados a los registros

# $s0, $s1, $s2, $s3 y $s4, respectivamente:

add $t0, $s1, $s2

# $t0 = $s1 + $s2

add $t1, $s3, $s4

# $t1 = $s3 + $s4

sub $s0, $t0, $t1

# $s0 = $t0 - $t1

• Ejercicio: Modificar el programa MIPS anterior para evitar el uso de los
registros temporales $t0 y $t1.

9

Tema 12. Programación en ensamblador MIPS.

Carga de inmediatos en registros

• Recordando que el registro $zero siempre vale 0, podemos utilizarlo para
asignar valores a los otros registros mediante la instrucción addi (“sumar
inmediato”). Ejemplo:

addi $s0, $zero, 100

# $s0 = $zero + 100 = 0 + 100 = 100

• Esta instrucción sólo nos permite utilizar inmediatos de 16 bits. Al igual que en
otros casos que veremos más adelante, se produce extensión de signo del bit
15 del inmediato (bit de signo) del 31 al 16.

• Para utilizar los 32 bits de los registros, debemos usar la pseudoinstrucción li:

li $s0, 0xABCDEF01

# $s0 = ABCDEF0116

• Esta pseudoinstrucción equivale a la siguiente secuencia de instrucciones:

lui $s0, 0xABCD

# $s0 = ABCD16 * 216 = ABCD000016

ori $s0, $s0, 0xEF01# $s0 = $s0 OR EF01 = ABCD000016 OR EF0116 =

# = ABCDEF0116

10

55

Tema 12. Programación en ensamblador MIPS.

4. Accesos a memoria

• El ancho del bus de datos (“palabra”) es 32 bits (4 bytes).

• De igual forma, el ancho del bus de direcciones es 32 bits. Por tanto, en la
memoria hay capacidad para 232 posiciones, a cada una de las cuales le
corresponde 1 byte.

• Memoria total: 232 bytes = 230 palabras = 4 Gigabytes

• “Big-Endian”: dirección de palabra = dirección de byte más significativo.

• Restricción de alineamiento: Las direcciones de palabra son obligatoriamente
múltiplos de 4.

Tema 12. Programación en ensamblador MIPS.

Carga y almacenamiento

• Transferencia de datos entre memoria y registros:

• Carga (“load”): Memoria (cid:2) Registro.

• Almacenamiento (“store”): Registro (cid:2) Memoria.

• Los mnemotécnicos lw (load word) y sw (store word) permiten realizar
transferencias entre memoria y registros de palabras enteras, utilizando la
dirección de memoria almacenada en un registro base. Sintaxis:

lw registro_destino, desplazamiento(registro_origen)

sw registro_origen, desplazamiento(registro_destino)

• La posición de memoria exacta se indica mediante un desplazamiento en
bytes relativo a la dirección de memoria que corresponde con el registro
origen (lw) o destino (sw).

11

12

66

Tema 12. Programación en ensamblador MIPS.

13

Tema 12. Programación en ensamblador MIPS.
Ejemplo

(cid:1) C:
int h, V[40];
V[12] = h + V[8];

(cid:1) MIPS:

# Suponiendo que h está asignado al registro $s0

# y la dirección del primer elemento del vector V,

# llamado V[0], está en $s1:

lw $t0, 32($s1)

# $t0 = V[8]

# La palabra 8 empieza en el byte 8*4=32

add $t0, $s0, $t0

# $t0 = $s0 + $t0

sw $t0, 48($s1)

# V[12] = $t0

# La palabra 12 empieza en el byte 12*4=48

14

77

Tema 12. Programación en ensamblador MIPS.
Ejemplo

(cid:1) C:
int a, b, V[40], i;
a = b + V[i];

(cid:1) MIPS:

# Suponiendo que a, b, V[0], i están asignado a

# los registros $s0, $s1, $s2, $s3, respectivamente

# La palabra i hay que expresarla en bytes (x 4)

add $t0, $s3, $s3

# $t0 = i+i = 2*i

add $t0, $t0, $t0

# $t0 = $t0+$t0 = 4*i

add $t0, $s2, $t0

# $t0 = dirección de V[i]

lw $t1, 0($t0)

# $t1 = V[i]

add $s0, $s1, $t1

# $s0 = $s1 + $t1

Tema 12. Programación en ensamblador MIPS.

5. Lenguaje máquina MIPS

• Recordemos los tres formatos de instrucciones máquina en MIPS:

Tipo R

(shamt: shift amount
en instrucciones de

desplazamiento)

Tipo I (carga o
almacenamiento,

ramificación
condicional)

Tipo J
(salto

incondicional)

Cód. Op.

xxxxxx

6

31-26

Cód. Op.

xxxxxx

6

31-26

Cód. Op.
xxxxxx

6

31-26

Registro
fuente 1

Registro
fuente 2

Registro
destino

rs
5

rt
5

rd
5

25-21

20-16

15-11

shamt

5

10-6

Funct

funct

6
5-0

Registro

base

Registro
destino

rs
5

rt
5

25-21

20-16

Desplazamiento

Inmediato

16
15-0

Dirección destino

dirección

26
25-0

15

16

88

Tema 12. Programación en ensamblador MIPS.

Tipo R

(shamt: shift amount
en instrucciones de

desplazamiento)

Cód. Op.

xxxxxx

6

31-26

Registro
fuente 1

Registro
fuente 2

Registro
destino

rs
5

rt
5

rd
5

25-21

20-16

15-11

shamt

5

10-6

Funct

funct

6
5-0

add $t0, $s1, $s2

Operación

Registro operando 2

Registro destino Registro operando 1

Código
operación

0

000000

Operando 1

Operando 2

De