Arquitectura Del set De Instrucciones Del Microprocesador MIPS
SubInstrucciones. Los Registros arquitectónicos. Modos de
direccionamiento. Tipos de datos. La pila
¿Qué significa ISA ? ISA significa Instruction Set
Architecture Es una abstracción esencial Representa el
punto de vista de un programador que posee el mayor nivel de
privilegio en el acceso a los recursos ofrecidos por el
computador. No representa un único nivel: en diversas
situaciones sus componentes pueden ser distintas. Esta
abstracción representa todos los recursos necesarios para
programar un computador. Nivel más bajo que el de los
lenguajes de alto nivel. Las instrucciones de control de flujo
ofrecen unas posibilidades muy básicas. Las operaciones
son también muy básicas.
Objetivo de este capítulo. Aprender una ISA simple: La del
microprocesador MIPS. Cómo afectan al hardware resultante
las opciones disponibles en sus diversas componentes. El concepto
de programa almacenado. La representación uniforme de
datos e instrucciones. Cómo los lenguajes de alto nivel
hacen uso de las posibilidades de la ISA. Usaremos el lenguaje
C.
Princeton vs. Harvard Von Neumann trabajó en la
Universidad de Princeton La memoria contiene las instrucciones y
los datos CISC: Complex Instruction set Computer En la
Universidad de Harvard probaron otra organización Dos
memorias separadas Instrucciones Datos RISC: Reduced Instruction
Set Computer.
El microprocesador MIPS Una ISA del tipo RISC. Reduced
Instruction Set Computer. Proyecto dirigido por el Prof.
Hennessy. Usada por: NEC, Nintendo, Silicon Graphics, Sony, etc.
Una ISA simple, bastante ortogonal, potente y fácilmente
estudiable. SPIM: Un simulador del microprocesador MIPS. Lo
emplearemos en algunas prácticas.
Las instrucciones representan operaciones. Todas las
instrucciones aritméticas y lógicas de la ISA MIPS
tienen tres operandos. El orden de los operandos es fijo.
Ejemplo: Sumar b y c, salvar resultado en a. a = b + c add a, b,
c Operando de destino Operando fuente 1 Operando fuente 2
Mnemónico de la instrucción
Instrucción
Operandos para la ALU: Registros. La ALU sólo opera sobre
registros (RISC) Entonces, a, b y c han de ser registros. add a,
b, c Operando de destino Operando fuente 1 Operando fuente 2
Nemónico de la instrucción
Dos tipos de registros. No arquitectónicos. Son necesarios
para que el microprocesador pueda salvar resultados intermedios a
lo largo de la ejecución de una instrucción
(Intra-instrucción). Los estudiaremos en el
capítulo 5. Arquitectónicos. Permiten que guardemos
resultados temporales, los cuales, podrán ser usados por
instrucciones posteriores (Inter-instrucción). Ejemplo:
Realizar un programa que multiplique por 4 el contenido de $t0 y
salve el resultado en $t1.
Registros arquitecturados MIPS, I. Comunicación de
resultados entre instrucciones. Ejemplo: Realizar un programa que
multiplique por 4 el contenido de $t0 y salve el resultado en
$t1. add $t1, $t0, $t0 #2 * $t0 guardado en $t1 add $t1, $t1, $t1
#2 * $t1 guardado en $t1, o sea 4*$t0 $t1 guarda el doble de $t0
temporalmente para que la siguiente instrucción calcule su
doble, a su vez.
Registros arquitecturados MIPS, II. MIPS contiene 32 registros de
propósito general [GPR, General Purpose Register]. El
ancho de cada registro es de 32 bits. MIPS es una arquitectura de
32 bits. $0 siempre vale 0. Los nombres son $1 .. $31. Reciben
otros nombres (alias) que estudiaremos en breve. Las
instrucciones aritmético-lógicas (ALU) sólo
operan sobre registros: MIPS es una arquitectura
load-store.
MIPS: Una ISA load/store D D D D LOAD STORE ALU
Compilación de una expresión a base de operadores +
y -. f = (g + h) – (i + j); f : $s0, g : $s1, h : $s2, i :
$s3, j : $s4 add $t0, $s1, $s2 add $t1, $s3, $s4 sub $s0, $t0,
$t1 Las variables de este programa son simples: contienen un
único dato de ancho 32 bits. ¿Cómo se pueden
construir agregados de datos (arrays) cuando se programa a nivel
de ISA (Lenguaje de ensamblaje)?
Ya visto: Los operandos posibles en la ISA de MIPS Las
instrucciones aritméticas y lógicas de MIPS
sólo aceptan registros como operandos. No existe ninguna
instrucción en la ISA que nos permita sumar el contenido
de una dirección de memoria con el contenido de un
registro. Tanto los operandos fuente como el operando de destino
deben ser registros. sub $22, $10, $9
El fichero de registros de MIPS Contiene 32 registros de 32 bits
de ancho cada uno de ellos. Los nombres son $0 .. $31
También reciben otros nombres que tienen que ver con las
funciones específicas de cada registro. Por ejemplo: $s0,
$s1 etc. son los registros que emplearemos para las variables de
los programas de ejemplo escritos en C. $t0, $t1 etc. Son los
registros temporales que emplearemos al compilar los programas
escritos en C.
La memoria de los sistemas basados en MIPS (i) Claramente, el
número de registros (32), es pequeño. La memoria
está organizada en casillas de 8 bits de ancho cada una de
ellas. Cada una de las casillas de 8 bits está
identificada por su dirección de memoria. El número
de posiciones de memoria es muy grande en comparación con
el número de registros.
La memoria es muy amplia. Si la ALU sólo opera sobre
registros… Continuamente deberemos acceder a la memoria en
busca de datos: Cargar el dato en un registro (load). Cargar el
otro dato en otro registro (load). Efectuar la operación
cuyo resultado se obtendrá en otro registro
(Aritmética-lógica). Salvar el resultado en su
dirección de memoria (store). MIPS es una arquitectura
load-store. El tamaño de palabra de la ISA MIPS es 32
bits. La memoria de los sistemas basados en MIPS (ii)
Modelo funcional de la memoria Cada posición de memoria
guarda un dato de 8 bits (1byte). Cada posición tiene un
nombre, un entero de 32 bits Conocido como dirección de
memoria La primera es la 0 La última es la 232-1 Ya
estudiaremos las estructuras y la tecnología
Una instrucción de lectura de una palabra de 32 bits (load
word). lw $t0, 8($s3) Ejemplo: Instrucción Load Word lw Un
dato presente en memoria En la dirección = $s3 + 8 El
registro al que se transfiere el dato leído desde la
memoria.
lw $t0, 8($s3) [repetición] ? aunque denotemos un registro
La word que se carga en $t0 procede de La dirección de
memoria 0x1008. Un dato presente en memoria, ¿Cuál
es su dirección? Dirección = $s3 + 8 …y, una
constante Si $s3 contiene 0x1000, entonces la dirección de
memoria efectiva es 0x1008
Un ejemplo. lw $t0, 8($s3) Supongamos que $s3 contiene
0x00001000. La dirección formada es = 0x1000 + 8
Supongamos que esta dirección contiene 0x1c8d273f El dato
que se carga en $t0 es 0x1c8d273f
Lectura de memoria: más detalles. El dato en memoria se ha
de extender a lo largo cuatro posiciones consecutivas: El dato
tiene 32 bits (4 bytes) Cada posición de memoria: 1 byte
Son necesarias 4 posiciones seguidas.
Hay varias formas de construir el dato en el registro.
Extremista-superior: La posición de memoria del dato
(0x1008) contiene el byte alto del dato Así funciona MIPS.
Extremista-inferior: La posición de memoria del dato
(0x1008) contiene el byte bajo del dato Así funciona el
i386ex.
MIPS es big-endian (Extremista superior). Una word ocupa 4
posiciones de memoria. La word que reside en la posición
de memoria D está formada por los bytes que residen en las
direcciones siguientes: D, D+1, D+2 y D+3. Se usan dos formas de
cargar esa word en un registro: Cargando el extremo superior en
primer lugar (Big endian) Cargando el extremo inferior en primer
lugar (Little endian). ¡SPIM es little-endian!
lw $t0, 8($s3) ¡intel! ?
lw $t0, 8($s3) ¡MIPS!
La instrucción sw: store word. D D D D LOAD: lw STORE: sw
ALU
La instrucción sw: store word. Salva la word contenida en
$t0 en la posición de memoria 8+$s3. sw $t0, 8($s3) La
posición de memoria donde se salvará el contenido
de $t0 El registro cuyo contenido se va a salvar en memoria
Un programa en C que usa las instrucciones lw y sw. Compilar la
expresión siguiente: //Crear un array de 100 enteros (1
word cada uno) int A[100]; A[8] = h + A[8]; A[100] está
formado por un conjunto de 100 enteros guardados en memoria
consecutivamente. Cada entero (int) ocupa una word A[100] ocupa
100 words (400 bytes). Para hacer la suma (+) necesitamos que
A[8] y h estén cargados en sendos registros. Asociaremos h
al registro $s2., por ejemplo. $s3 contiene la dirección
de memoria que es la base del array llamado A[]. Cargaremos A[8]
en el registro $t0. Sumaremos $t0 y $s2 y pondremos el resultado
en $t0. Salvaremos el resultado recién obtenido en la
dirección de memoria A[8].
Un programa en C que usa lw y sw (ii) Compilar la
expresión siguiente: A[8] = h + A[8]; Calcular la
dirección donde está A[8] $s3 contiene la
dirección base del array A[] 8 x 4 = 32 4bytes/word,
$s3(32) representa la dirección del entero A[8] Cargaremos
el contenido de A[8] en el registro $t0. lw $t0, 32($s3) Sumamos
$s2 y $t0 y guardamos el resultado en $t0. add $t0, $t0, $s2
Guardamos este resultado en la dirección de memoria de
A[8]. sw $t0, $s3(32)
Un programa en C que usa lw y sw (iii) Compilar la
expresión siguiente: A[8] = h + A[8]; $s3 contiene la
dirección base del array A[] 0($s3) “apunta a”
A[0] 4($s3) “apunta a” A[1] 8($s3) “apunta
a” A[2] 12($s3) “apunta a” A[3] y, así
sucesivamente. lw $t0, 32($s3) add $t0, $t0, $s2 sw $t0,
32($s3)
Ejemplo de lw y sw más sofisticado Compilar la
expresión siguiente: A[i] = h + A[i]; Asociamos h al
registro $s2, como en el ejemplo precedente. $s3 contiene la
dirección de memoria base de A[]. La variable i la
asociamos al registro $s4. La dirección de memoria de A[i]
será: (Dirección Base de A) + (4 ? i) ¿Por
qué multiplicamos por 4? Cada word tiene 4 bytes Cada byte
ocupa una dirección de memoria ? add $t1, $s4, $s4 ; i * 2
add $t1, $t1, $t1 ; i * 2 * 2
Ejemplo de lw y sw más sofisticado Compilar la
expresión siguiente: A[i] = h + A[i]; Formamos la
dirección de memoria de A[i]: add $t2, $t1, $s3 Cargamos
el dato dentro del registro $t1, p.ej.: lw $t1, ($t2)0 Sumamos h
a $t1: add $t1, $s2, $t1 El resultado, esto es, el contenido del
registro $t1 lo salvamos en memoria –en la misma
dirección de memoria de A[i]: sw $t1, ($t2)0 (i * 4) A[]
Dirección de memoria de A[i]
Ejemplo de lw y sw más sofisticado Compilar la
expresión siguiente: A[i] = h + A[i]; add $t1, $s4, $s4
add $t1, $t1, $t1 add $t2, $t1, $s3 lw $t1, ($t2)0 add $t1, $s2,
$t1 sw $t1, ($t2)0
Las instrucciones [cadenas de 32 bits] tienen dirección de
memoria. [Instrucciones y datos se representan del mismo modo].
La forma binaria de las instrucciones MIPS tienen 32 bits
(todas). Cada instrucción ocupa 4 direcciones de memoria
seguidas. Por tanto, una instrucción, al igual que un
dato, posée dirección de memoria.
¿Cuál es la dirección de memoria de una
instrucción? Las direcciones de memoria de los datos
[Variables, arrays] las representamos simbólicamente con
el operador &: &contador1 Las direcciones de memoria de
las instrucciones también se pueden representar
simbólicamente mediante una etiqueta: inicio:
Etiquetas de datos y código en SPIM. Explicad qué
operación lleva a cabo este programa: .data Astart: .word
0x00000060, 0x00000050, 0x00000040 .word 0x00000010, 0x00000000
.word 0x00000000, 0x10101010, 0x20202020 .word 0x30303030,
0x40404040 .text .globl main main: la $t0, Astart li $t1, 4 move
$t2, $zero siguiente: lw $s0, 0($t0) beq $s0, $zero, es_cero add
$t2, $t2, $s0 add $t0, $t0, $t1 j siguiente es_cero: sw $t2,
0($t0)
Direcciones de memoria de instrucciones y de datos: Un ejemplo en
C. if (i == j) goto fuera; else f = g + h; fuera: f = f –
i; El enfoque siguiente es el correcto: emplear estructuras de
programación if (i != j){ f = g + h; } f = f – i;
Este enfoque no es correcto
Producción de un programa.
Producción de un programa: Denominación de los
ficheros intermedios.
Intro. Codificación de instrucciones: add La siguiente
instrucción está representada en lenguaje de
ensamblaje: add $t0, $s1, $s2 El computador no
“entiende” las instrucciones en este formato fuente.
Sin embargo, esta representación es conveniente para las
personas. El programa que traduce el texto escrito en lenguaje de
ensamblaje es el programa ensamblador. El ensamblador traduce el
texto fuente a “texto o código objeto” (Una
forma de código máquina). El texto objeto
está “lleno” de instrucciones en forma
binaria.
ESTA PRESENTACIÓN CONTIENE MAS DIAPOSITIVAS DISPONIBLES EN
LA VERSIÓN DE DESCARGA