ISA - Key

543.
426
Arquitectura de Computadores Miguel Figuero

O cina 23
Email:
Arquitectura de conjunto de miguel. gueroa@udec.cl
instrucciones (ISA)
1
fi
fi
5
Arquitectura de conjunto de instrucciones
❖ Instruction Set Architecture (ISA

❖ Comúnmente conocido como “lenguaje de
máquina
❖ Visión del programador (o compilador
❖ De ne la interfaz entre el hardware y el
softwar
❖ Compatibilidad binari
❖ Principalmente, las instrucciones del lenguaje
de máquina, y la ubicación de sus operandos ISA soporta el softwar
(registros, memoria). Pero tambié
Hardware soporta ISA durante muchas
❖ Tipo y formato de dato generaciones de la arquitectur
❖ Codi cación de instruccione
Ej. Intel IA32, IA64, ARM, MIPS, SPARC, PowerPC
❖ Excepciones
Universidad de Concepción, Departamento de Ingeniería Eléctrica 2 Arquitectura de Computadores - 543426 - Miguel Figueroa, 2018
fi
fi
e
Arquitectura de conjunto de instrucciones

❖ De nición de la arquitectura fuertemente afectada por la tecnologí
❖ ¿Cuántos registros internos puede alojar físicamente el procesador? ¿Cuánta memoria
puede direccionar un programa? ¿Qué capacidad tienen los compiladores de generar
código e ciente
❖ “Brecha semántica
❖ Diferencia entre nivel de abstracción de lenguaje de alto nivel y del lenguaje de
máquina. Arquitecturas antiguas favorecían cerrar la brecha con un lenguaje de
máquina con instrucciones “poderosas
❖ Ej. VAX: instrucciones para evaluar polinomio
❖ Arquitectura Intel x86 ha pasado por varias generaciones desde 1978, con compatibilidad
hacia atrás. Originalmente pocos registros internos de propósito general (8 en IA32,
versión de 64 bits agrega 8 más), operandos en memoria, códigos de instrucción compacto
❖ Procesadores RISC (Reduced Instruction Set Computer) desde los años ’80 favorecen más
registros, pocas y sencillas instrucciones, operandos en registros e instrucciones load/store
fi
fi
?
Arquitectura ARM
❖ Desarrollada inicialmente en los años 80 por Acorn Computer Group,
que creó Advanced RISC Machines, ahora llamada AR
❖ Empresa no fabrica ni vende procesadore
❖ Licencia la arquitectura para que otros fabricantes realicen sus
propias implementaciones (Qualcomm, Apple, Samsung, etc.
❖ También licencia diseños digitales que implementan la arquitectura
(Cortex-M para microcontroladores, Cortex-A para sistemas de
mayor desempeño
❖ En este curso utilizaremos la arquitectura ARMv4 de 32 bit
❖ ARMv8 la extiende a 64 bits
)
Principios de diseño RISC
❖ Principio 1: Regularidad permite simplicida

❖ Principio 2: Hacer el caso frecuente rápid
❖ Principio 3: Pequeño es rápid
❖ Principio 4: Un buen diseño requiere buenos compromisos
o
Assembly: Suma y resta

❖ Son las operaciones más comunes realizadas por un computador
- ADD y SUB son mnemónicos: Indican qué operación realiza la instrucción

- b y c son operandos fuente: Indican ubicación o valor de los datos de la operación
- a es el operando destino: Indica ubicación donde se almacena el resultado
Nota: a, b y c pueden ser registros o constantes
Regularidad: Si todas las instrucciones tienen el mismo número de operandos, su

codi cación y ejecución en hardware se hace más fácil.
fi
Assembly: Operaciones más complejas
❖ Para mantener el principio de simplicidad, operaciones más
complejas se realizan combinando múltiples operaciones de
dos operandos origen y un operando destino
El símbolo “;” denota un comentario en assembly: Todo el texto desde el “;” hasta el
nal de la línea es ignorado por el ensamblador
Ensamblador: Programa que convierte programa en assembly (texto) a un programa
en lenguaje de máquina (unos y ceros
Caso común rápido: ARM posee pocas instrucciones que ejecutan en forma directa las
operaciones más comunes en un programa. Las operaciones más complejas se
implementan combinando instrucciones.
fi
)
Assembly: Operandos
❖ Cuáles pueden ser los operandos de una instrucción

❖ Registro
❖ Memori
❖ Constantes
a
Registros
❖ Arquitectura de ne un pequeño número de registros que pueden
almacenar valore
❖ Banco de registros es una pequeña memoria RAM con múltiples
puertas de lectura y escritur
❖ En arquitectura de 32 bits, registros almacenan valores de 32 bit
❖ Pequeño es rápid
❖ De nir un número pequeño de registros permite que el banco de
registros resida en el mismo chip del procesador y pueda leerse/
escribirse en 1 ciclo de reloj
fi
fi
s
Registros en ARM
❖ Arquitectura ARM de ne roles especí cos para algunos registro

❖ R0-R12 almacenan variables de un program
❖ R0-R3 además se usan en llamados a procedimiento
❖ R13-R15 (SP, LR y PC) son punteros a memoria usados en la ejecución de un program
❖ PC contiene la dirección de la instrucción actual; por motivos históricos, al leer R15 se obtiene PC + 8
fi
fi
a
Suma y resta con registros

❖ Las operaciones de suma y resta pueden tener cualquiera de
sus operandos en registro
❖ Asignación de registros a variables es tarea del compilador
al traducir un programa a lenguaje de máquina
s
Operandos constantes o inmediatos

❖ En algunos casos, la instrucción puede especi car
directamente el valor de un operando orige
❖ Por ejemplo, la sentencia C “a = b + 10;
❖ Esto se conoce como operando constante o inmediato
Constante se precede con signo “#

Puede usarse notación decimal (base 10) o hexadecimal (base 16), anteponiendo un
“0x” al valor de la constant
Operandos inmediatos en ARM son de 8 bits, más desplazamiento opcional
e
fi
Inicialización de variables
❖ Otro uso de constantes es para inicializar el valor de una variable del
program
❖ Instrucción MOV copia el valor de una constante al contenido de un registro
❖ MOV usa un operando destino (un registro) y un operando fuente (en este caso,
una constante
❖ MOV también puede usar dos operandos registros, en cuyo caso copia el
contenido de un registro a otr
❖ Ej. MOV R1, R
❖ Caso especial: Instrucción NOP no hace nada, se codi ca como MOV R0, R0
a
fi
Operaciones lógicas
❖ A diferencia de suma y resta, las operaciones lógicas tratan el
contenido del registro como un vector de bit
❖ No como un númer
❖ Útil para representar condiciones como el estado abierto/
cerrado de una ventana, encendido/apagado de un LED, etc
❖ Operaciones lógicas típica
❖ AND, OR, XO
❖ Rotaciones y desplazamientos
R
Operaciones lógicas
❖ Operando destino y al menos un operando origen son siempre registro
❖ Segundo operando origen puede ser una constant
❖ Ejemplos: AND, ORR, EOR, BIC (bit clear), MVN (move with not
❖ BIC R6, R1, R2: R6 <— R1 & (~R2), sirve para forzar algunos bits de R1 a cer
❖ MVN R7, R2: R7 <— ~R2
e
Ejemplo
❖ Suponer que los 8 LSB del registro R1 almacenan el estado abierto/cerrado de 8
ventanas (numeradas 0 a 7), donde un 1 representa estado abierto, 0 cerrad
❖ Suponga (por simplicidad) que escribir en los bits correspondientes del registro R0 abre
o cierra las ventana
❖ Escriba un segmento de código assembly qu
❖ Abra las ventanas 0 y 6, y cierre el resto de las ventana
❖ Cierre las ventanas 0 a 3, deje igual el rest
❖ Invierta el estado de todas las ventana
❖ Si los bits menos signi cativos del registro R2 almacena el estado de 8 interruptores,
donde el estado 1 signi ca encendido y 0 apagado, abra las ventanas donde el
interruptor está encendido y cierre donde está apagad
❖ Haga lo mismo que el punto anterior, pero solamente afecte las ventanas 0, 2, 4 y 6
s
fi
fi
s
Desplazamientos y rotaciones
❖ Instrucciones de desplazamiento desplazan contenido de un
registro hacia la izquierda o derecha (similar a operadores “<<“ y
“>>” de
❖ Desplazamiento lógico a la derecha (LSR)/izquierda (LSL):
Ingresa 0s por la izquierda/derech
❖ Desplazamiento aritmético a la derecha (ASR): ingresa copias
del MSB por la izquierd
❖ Instrucciones de rotación (ROL y ROR) actúan en forma similar al
desplazamiento, pero los bits que salen por un extremo del
registro ingresan por el otro extremo
C
Desplazamientos y rotaciones
❖ Número de bits a
desplazar o rotar
puede estar
especi cado en una
constante o un
registr
❖ A qué operaciones
aritméticas equivalen
los desplazamientos
aritméticos y lógicos?
fi
o
Ejemplo
❖ El registro R0 contiene un número de 8 dígitos

decimales en BCD. Escriba un código para separar estos
dígitos en los registros R1 - R8
Multiplicación
❖ Multiplicación de dos números de 32 bits produce un resultado de 64
bit
❖ Qué pasa en C cuando se ejecuta “a = b * c;” y las variables son
enteros de 32 bits
❖ Instrucciones de multiplicación (operandos son sólo registros
❖ MUL, MLA: multiplicación y multiplicación/suma de 32 bit
❖ MUL R1, R2, R3 ; R1 <— (R2 * R3
❖ MLA R1, R2, R3, R4 ; R1 <— (R2 * R3) + R
❖ También hay instrucciones que generan un producto de 64 bit
❖ Qué pasa con el signo en ese caso?
s
Ejemplo
❖ Generar código assembly para la siguiente expresión en C.
Asuma que todas las variables son de tipo “unsigned int”. Las
variables a, b y c están asignadas a los registros R0, R1 y R2
a = (a + 4) * (b + 3) - (c - 8)/64
b = b + (a + b)(a*c);
;
Instrucciones de acceso a memoria

❖ Arquitectura ARMv4 provee en la práctica sólo 15 registro
❖ Insu ciente para almacenar todos los datos de un program
❖ Datos del programa residen en memori
❖ ARM es una arquitectura “load/store
❖ Instrucciones aritméticas y lógicas usan operandos en
registros o constantes inmediata
❖ Datos se leen o escriben en memoria usando instrucciones
especiales “load” y “store”
fi
s
Visión de la memoria
❖ Programa en lenguaje de máquina ve la memoria como un
arreglo de bytes
❖ En una arquitectura de 32 bits, la cantidad total de memoria que
puede accesar teóricamente un programa es de 232 byte
❖ Normalmente llamado el “espacio de memoria virtual” del
program
❖ Por el momento, asumiremos por simplicidad que la memoria
virtual y la memoria física (RAM instalada) son lo mism
❖ Direcciones de memoria son, entonces, números de 32 bits
a

❖ Instrucciones LDR/STR copian una palabra de 32 bits de
memoria a registro y de registro a memori
❖ Como dato es de 32 bits (4 bytes), dirección es múltiplo de
❖ Visión de la memoria:
a
Instrucción LDR
❖ Lee 32 bits (4 bytes) de memoria y los almacena en un registr
❖ Dirección de memoria se puede especi car de varias formas, comenzaremos con la más
simple: Registro base más desplazamient
❖ Ej. LDR R1, [R2, #4] ; R1 <— Mem[R2 + 4
❖ Cuando la constante es cero, se puede omitir, ej, LDR R1, [R2
❖ Leer el elemento 2 de un vector de enteros que comienza en la dirección cero de memori
❖ Enteros son números de 32 bits, cada entero ocupa 4 bytes en memoria
fi
o
Instrucción STR
❖ Escribe en memoria la palabra de 32 bits (4 bytes) contenida en un registr
❖ Dirección de memoria también se puede especi car de varias formas,
comenzaremos con registro base + desplazamient
❖ Ej. STR R1, [R2, #4] ; Mem[R2 + 4] <— R
❖ Cuando la constante es cero también se puede omitir, ej. STR R1, [R2
❖ Escribir el número 42 en la posición 5 del vector de enteros anterior
1
fi
o
Ejemplo
❖ Escribir código assembly ARM para el código C
int a, b, acum
acum = acum + a * b;
❖ Asumir que variables a, b y acum son contiguas en

memoria, y que la dirección de a está almacenada en el
registro R0. Ninguna de ellas está actualmente en
registros.
…
Ejemplo
❖ Escribir código assembly para el código C
typedef struct
int r
int g
int b
} color
color c1
int pack
pack = (c1.r << 8) | (c1.g << 4) | c1.b
❖ Asuma que c1 y pack están contiguas en memoria y que la

dirección de c1 está almacenada en R0
;
Ejemplo
❖ El siguiente código en C calcula el producto punto entre los
elementos de dos vectores, y los almacena en la variable acum.
Escriba código assembly que implementa el CUERPO del lazo
y la inicialización de los registros que requiera. Asuma que la
variable “i” se almacena en el registro R0, que la dirección base
de los vectores está almacenada en los registros R1 y R2, y que
la dirección de la variable acum está en el registro R3
acum = 0
for (int i = 0; i < N; ++i
acum = acum + vecA[i] * vecB[i];
;
Big endian vs. little endian

❖ Instrucciones LDR y STR trans eren palabras de 32
bits a memori
❖ Pero direcciones de memoria corresponden a bytes.
Cómo se ordenan los bytes de una palabra de 4
bytes en memoria
❖ Big endian: bytes de palabra se numeran desde 0
partiendo con la dirección más alta (ej. IBM
Power, MIPS, Sparc)
❖ Little endian: bytes se numeran desde 0
partiendo con la dirección más baja (ej. Intel x86
❖ Ej. palabra 0x8760A5FC almacenada en
direcciones 100-103, contenido de dirección 100
en big endian es 0x87, mientras que en little
endian es 0xFC
❖ ARM favorece little endian, pero tiene soporte para ambos

a
fi
)
Otras instrucciones load/store

❖ ARM permite también transferir palabras de 8 y 16 bits entre
registros y memori
❖ Lectura puede ser con o sin extensión de signo
a
Ejemplo
❖ Un lazo iterativo recorre un
string en memoria que utiliza
solamente caracteres en
minúscula, y los cambia a
mayúscula para agredir los ojos
del lector.
❖ Escriba el código assembly del
CUERPO del lazo iterativo,
asumiendo que la variable de
iteración está almacenada en el
registro R0, y que la dirección de
inicio del vector está
almacenado en el registro R1

Otros modos de direccionamiento

❖ La manera de especi car la dirección efectiva del dato en
memoria vista antes se conoce como direccionamiento “registro
base más desplazamiento
❖ ARM también puede sumar un registro al registro base, en vez
de una constante (direccionamiento indexado
❖ Ej. LDR R3, [R0, R1] ; dir. ef. = R0 + R
❖ ARM también puede escalar el registro índice desplazándolo
hacia la izquierd
❖ Ej. LDR R3, [R0, R1, LSL #2] ; dir. ef. = R0 + (R1 * 4)
a
fi
”
Direccionamiento autoindexado
❖ Es común modi car el registro base después de accesar la memori
❖ Ej. Al recorrer un vecto
❖ Pre-índice: Suma el registro base más el índice y usa esta dirección
para accesar la memoria, actualiza el registro bas
❖ Ej. LDR R0, [R1, R2]! ; dir. ef. = R1 + R2, R1 = R1 + R
❖ Post-índice: Accesa la memoria usando el valor original del registro
base, y después actualiza el registro base sumándole el índic
❖ Ej. LDR R0, [R1], R2 ; dir. ef. = R1, R1 = R1 + R
❖ En todos los casos, índice puede ser también una constante
fi
r
Ejecución condicional de instrucciones

❖ Para que un lenguaje de máquina pueda ejecutar cualquier
algoritmo, debe soportar la ejecución condicional de
instruccione
❖ Estructuras de tipo if-else, switch-cas
❖ Pero también lazos iterativos de tipo for, while, do-whil
❖ Cómo se expresa la condición
❖ Distintas ISA lo pueden hacer de diferentes formas, pero
la más común es el uso de bits (o ags) de condición
s
fl
e
Bits de condición
❖ Conjunto de bits que indican propiedades del resultado de
una operación aritmético/lógic
❖ En ARM: resultado negativo (N), resultado cero (Z), carry
(C), y over ow (V
❖ Almacenadas en el registro de estado, o registro de condició
❖ En ARM, 4 bits superiores del Current Program Status
Register (CPSR)
fl
)
Modificación de bits de condición

❖ Instrucción CM
❖ Ej. CMP R1, R2, calcula R1 - R2 y modi ca bits de condición (no se almacena
❖ Z = 1 si resultado es cer
❖ N = 1 si MSB de resultado es
❖ C = 1 si hay un carry desde el bit 31 del resultado hacia afuer
❖ V = 1 si R1 y resultado tienen distinto signo, y R1 y R2 tienen signo distinto (resultado con
signo es incorrecto
❖ Otras instrucciones aritmético/lógicas pueden modi car bits de condición (su jo S
❖ Ej. ADDS R0, R1, R2 / SUBS R0, R1, #4 / LSLS R0, R1, #
❖ Todas las instrucciones afectan Z y N, desplazamientos afectan C, aritméticas afectan C y
❖ Para ADDS, V = 1 cuando R1 y R0 tienen distinto signo, y R1 y R2 tienen el mismo signo
P
fi
fi
7
fi
)
Instrucciones que modifican bits de condición
❖ TST R1, R2 modi ca ags de condición basado en R1 & R

❖ TEQ R1, R2 modi ca ags de condición basado en R1 XOR R
❖ CMP R1, R2 modi ca ags de condición basado en R1 - R
❖ CMN R1, R2 modi ca ags de condición basado en R1 + R2
fi
fi
fi
fi
fl
fl
fl
fl
2
Ejecución condicional de instrucciones

❖ Las instrucciones de ARM
pueden ejecutarse en forma
condiciona
❖ Instrucción se ejecuta
sólo si se cumple
condición que
depende de ag
❖ Condición se
especi ca como un
su jo a la instrucció
❖ ADDEQ R0, R1, R
❖ LDRGE R0, [R1, #32]
fi
fi
l
fl
s
Ejemplo
❖ ADDEQ se ejecuta sólo si R2 == R

❖ ANDHS se ejecuta sólo si el contenido de R2 es mayor o igual al de R3, sin sign
❖ ORRMI se ejecuta sólo si el MSB de (R2 - R3) es
❖ Para números son con signo, si el signo es negativ
❖ EORLT se ejecuta sólo si el contenido de R2 es menor que R3, con signo
3
Ejemplo
❖ Escriba código assembly para el siguiente código C, asumiendo que las
variables enteras con signo a - e están asignadas a los registros R0 - R4
if (a > b)
d = (a - b) * c
els
e = (b - a) * d;
CMP R0, R1 ; comparación (a - b

SUBGT R3, R0, R1 ; se ejecuta si a >
MULGT R3, R3, R2 ; se ejecuta si a >
SUBLE R4, R1, R0 ; se ejecuta si a <=
MULLE R4, R4, R3 ; se ejecuta si a <= b
e
Instrucciones de salto
❖ Si usamos ejecución condicional en estructuras if-else más
grandes, procesador termina ejecutando muchas
instrucciones que no tienen ningún efect
❖ Preferible ejecutar solamente instrucciones que
corresponde, y saltarse el rest
❖ Instrucciones de salto permiten modi car el ujo de
ejecución de un programa para saltar a una instrucción no
adyacente a la actua
❖ Además permiten ejecutar lazos iterativos (for, while)
l
fi
o
fl
Salto incondicional
❖ Instrucción de salto incondicional en ARM se llama B (branch
❖ Salta a instrucción en dirección de memoria especi cada en la instrucció
❖ En assembly, instrucción destino se especi ca con un rótul
❖ Rótulo es un símbolo que identi ca una dirección de memoria, ensamblador convierte
rótulo en una dirección numéric
❖ Algunos ensambladores requieren que rótulos estén al comienzo de la línea, e
instrucciones estén indentadas, otros además requieren dos puntos (:) después del rótul
❖ Ejemplo
ADD R1, R2, #17 ; R1 = R2 + 1
B TARGET ; salta a TARGE
ORR R1, R1, #3 ; no se ejecut
AND R3, R1, #0xFF ; no se ejecut
TARGE
SUB R1, R1, #78 ; R1 = R1 - 78
T
fi
a
fi
fi
7
Saltos condicionales
❖ Al igual que el resto de las instrucciones, salto B puede ejecutarse en forma
condiciona
❖ Ej. BEQ, BLT, BH
❖ Otras ISA llaman “branch” a los saltos condicionales y “jump” a los saltos
incondicionale
❖ Ejemplo
MOV R0, #4 ; R0 =
ADD R1, R0, R0 ; R1 = R0 + R0 =
CMP R0, R1 ; R0 - R1 = -4 —> NZCV = 100
BEQ THERE ; salto no se ejecut
ORR R1, R1, #1 ; R1 = R1 OR 1 =
THER
ADD R1, R1, #78 ; R1 = R1 + 78 = 87
E
Estructura if-else
❖ Usando saltos condicionales, se pueden implementar estructuras if, if-else, switch-cas
❖ Ej. Escribir el siguiente código C en assembly ARM, asumiendo que las variables
enteras con signo a - e están asignadas a los registros R0 - R4
if (a > b)
d = (a - b) * c
e = a + d;

BLE FI
SUB R3, R0, R1 ; se ejecuta si a >
MUL R3, R3, R2 ; se ejecuta si a >
FI
ADD R4, R0, R3 ; se ejecuta independiente de a y b
N
Estructura if-else
❖ Ej. Escribir el siguiente código C en assembly ARM, asumiendo que las
variables enteras con signo a - e están asignadas a los registros R0 - R4
if (a > b)
d = (a - b) * c
els
d = (b - a) * c
e = a + d;
BLE ELS
SUB R3, R0, R1 ; se ejecuta si a >
MUL R3, R3, R2 ; se ejecuta si a >
B FIN ; se salta el “else
ELS
SUB R3, R1, R0 ; se ejecuta si a <=
MUL R3, R3, R2 ; se ejecuta si a <=
FI
ADD R4, R0, R3 ; se ejecuta siempre
N
Estructura switch-case
❖ Switch-case puede siempre expresarse como un bloque if - else if - else if - … - els
❖ Ej. Escribir el siguiente código C en assembly ARM. Conviértalo primero a un
código tipo if - else if - else if - … - else
switch (seleccion)
case ‘A’:
d = (a + b)
break
case ‘B’:
d = (a - b)
break
case ‘C’:
d = (b - a)
break
default:
d = 0
a = d * a * b;
}
Estructura switch-case
❖ Cuando el valor de las alternativas es relativamente consecutivo,
el compilador puede usar una “tabla de saltos
❖ De nir un vector con las direcciones de inicio de las alternativa
❖ Leer el vector usando la variable de selección como índic
❖ Ej. LDR R0, [R1, R2, LSL #2
❖ Saltar a la dirección
❖ Ej. MOV R15, R
❖ Que es lo mismo que MOV PC, R0
fi
0
Estructura do-while
❖ Estructura do-while se implementa con un bloque de código con un
salto condicional al na
❖ Ej. Escribir el siguiente código C en assembly ARM
// todas las variables y vectores son entero

i = 0
sum = 0
do
sum = sum + a[i] * b[i]
i++
} while (i < 100
{
fi
l
Estructura while
❖ Una estructura while se implementa con un salto
condicional al principio y un salto incondicional al na
// todas las variables y vectores son entero
int i, tmp
int a[100], b[100]
i = 0
while (i < 100)
tmp = a[i]
a[i] = b[i]
b[i] = tmp
i++
}
;
Estructura for
❖ Un ciclo for se implementa como un while más una instrucción
de inicialización al comienzo del lazo y una de iteración al nal
int i, tmp
char str1[100], str2[100]
for (i = 0; str2[i] != 0; i++

str1[i] = str2[i] + 0x20
str1[i] = 0;
…
Llamados a función
❖ Un lenguaje estructurado de alto nivel se compone de procedimientos
que llaman a otros procedimiento
❖ También llamados subrutinas
❖ En C, estos procedimientos son llamados funciones
❖ Una función es un procedimiento que puede recibir cero o más
parámetros y retornar un valor
int a, b, c, d, e int fun (int p1, int p2, int p3
d = fun(a, b, c) return p1 + p2 - p3
}
e = fun (c, d, 5)
…
…
Soporte ISA para funciones

int a, b, c, d, e
int fun (int p1, int p2, int p3
d = fun(a, b, c)
return p1 + p2 - p3
}
e = fun (c, d, 5)
…
❖ Para soportar funciones, el lenguaje de máquina debe proveer un soporte mínim

❖ La función se puede invocar desde diferentes secciones del código y debe
retornar a la sección de donde la llamaron —> debe proveer una forma de
almacenar la dirección de retorno
❖ Debe proveer una forma de saltar a esta dirección de retorn
❖ Debe proveer una manera de pasar el valor de los parámetros o argumentos
desde el procedimiento “llamador” (caller) al “llamado” (callee
❖ Debe proveer una manera de pasar el valor de retorno desde el callee al caller
…
Soporte para funciones: Registros
❖ Registro R0 se utiliza para pasar el valor de retorno y el primer parámetr

❖ Registros R1 - R3 se utilizan para pasar el segundo a cuarto parámetro
❖ Registro R14 (LR) se utiliza para almacenar la dirección de retorno y registro R15
(PC) almacena la dirección de la siguiente instrucción a ejecutar (PC+8 al leer
❖ Qué instrucciones soportan este uso de la dirección de retorno?
Soporte para funciones: Instrucciones

❖ Instrucción B
❖ Equivalente a instrucción B, pero almacena la dirección de la siguiente
instrucción en el registro L
❖ Puede también ejecutarse de manera condiciona
❖ Cómo saltar a la dirección almacenada en LR
❖ MOV PC, LR
L
Ejemplo
MAI
int a, b, c, d, e
; a - e —> R4 - R8
MOV R0, R
d = fun(a, b, c)
MOV R1, R
MOV R2, R
e = fun (c, d, 5) BL FU
… MOV R7, R
MOV R0, R
MOV R1, R
MOV R2, #
BL FU
int fun (int p1, int p2, int p3 MOV R8, R
return p1 + p2 - p3
FU
}
ADD R0, R0, R
SUB R0, R0, R
MOV PC, L
…
…
…
…
Ejercicio: Escribir en assembly ARM

; &(a[0]) —> R9, &(b[0]) —> R1
; res —> R1
int a[100], b[100 MOV R0, R
MOV R1, R1
res = punto(a, b, 100) MOV R2, #10
BL PUNT
MOV R11, R
int punto(int v1[], int v2[], int n
int i = 0 PUNT
int suma = 0 MOV R4, #
MOV R5, #
do
suma = suma + v1[i] * v2[i] D
i++ LDR R6, [R0, R4, LSL #2
} while (i < n LDR R7, [R1, R4, LSL #2
return suma MLA R5, R6, R7, R
} ADD R4, R4, #
CMP R4, R
BLT D
MOV R0, R
MOV PC, LR


int strlen(char *str STRLE
MOV R4, #
int len = 0
WHIL
while (*str != 0) LDRSB R5, [R0
str = str + 1 CMP R5, #
len = len + 1 BEQ FI
ADD R0, R0, #
ADD R4, R4, #
return len B WHIL
FI
MOV R0, R
MOV PC, LR
{

char *strcpy(char *dest, char *src STRCP
MOV R4, R
char *orig_dest = dest
WHIL
while (*src != 0) LDRSB R5, [R1
*dest = *src CMP R5, #
dest = dest + 1 BEQ FI
src = src + 1 STRB R5, [R0
ADD R0, R0, #
*dest = 0 ADD R1, R1, #
B WHIL
return orig_dest
FI
STRB R5, [R0
MOV R0, R
MOV PC, LR
{

int streq(char *s1, char *s2 STRE
LDRSB R4, [R0
char tmp LDRSB R5, [R1
do CMP R4, R
tmp = *s1 BEQ L
if (tmp != *s2 MOV R0, #
return 0 MOV PC, L
s1++ L
s2++ ADD R0, R0, #
} while (tmp != 0) ADD R1, R1, #
return 1 CMP R4, #
BNE STRE
MOV R0, #
MOV PC, LR
{

void strcat(char *s1, char *s2
while (*s1 != 0
s1++
do
char tmp = *s2
*s1 = tmp
s1++
s2++
} while (tmp != 0)
{
Memoria local a función

❖ Lenguajes estructurados permiten de nir variables locales a
funció
❖ Creadas al llamar a la función, inalcanzables fuera de ell
❖ Son locales a la activación (llamado) de la función (importante
para funciones recursivas
❖ Dónde almacenamos estas variables
❖ Registros son insu cientes, necesario usar memori
❖ Cómo de nir un área de memoria local para cada activación de
una función?
n
fi
fi
)
fi
a
El stack (pila)
❖ Estructura de datos en memoria local a la activación de la
funció
❖ Se expande cuando el procesador necesita más memoria,
se contrae cuando el programa ya no necesita las
variables almacenada
❖ Estructura de datos tipo LIFO (last in, rst out
❖ Stack se mantiene usando un puntero a memoria (stack
pointer), normalmente el registro R13 (SP
❖ Apunta al tope del stac
❖ Por defecto, stack en ARM es de tipo descendiente y llen
❖ Crece hacia direcciones bajas de memoria, SP apunta
a la última posición ocupada en el stac
❖ Arquitectura soporta stacks ascendientes y vacíos
n
fi
k
Uso del stack

❖ Una función solamente debería modi car el registro R0, y no tener otros efecto
❖ Registros R1-R3 y R12 son temporales, podrían modi cars
❖ NO debería modi car registros R4-R11 y R13-R1
❖ Stack puede usarse para almacenar estos registros antes de modi carlos, y recuperarlos
antes de retorna
❖ Hacer espacio en el stack para almacenar valores (marco de activación, stack frame
❖ Almacenar el valor de los registros en el stack fram
❖ Ejecutar la función usando los registro
❖ Restaurar valor original de los registros leyéndolos del stack fram
❖ Liberar espacio en el stack y retornar
r
fi
fi
s
fi
e
fi
e
Recordar: Sin stack

int punto(int v1[], int v2[], int n PUNT
MOV R4, #
int i = 0 MOV R5, #
int suma = 0
do D
suma = suma + v1[i] * v2[i] LDR R6, [R0, R4, LSL #2
i++ LDR R7, [R1, R4, LSL #2
} while (i < n MLA R5, R6, R7, R
return suma ADD R4, R4, #
} CMP R4, R
BLT D
MOV R0, R
MOV PC, LR

Ejercicio: Sin modificar R4-R7

PUNT
SUB SP, SP, #1
int punto(int v1[], int v2[], int n STR R4, [SP, #12
STR R5, [SP, #8
int i = 0 STR R6, [SP, #4
int suma = 0 STR R7, [SP
do MOV R4, #
suma = suma + v1[i] * v2[i] MOV R5, #
i++ D
LDR R6, [R0, R4, LSL #2
} while (i < n
LDR R7, [R1, R4, LSL #2
} ADD R4, R4, #
CMP R4, R
BLT D
MOV R0, R
LDR R7, [SP
LDR R6, [SP, #4
Cómo se ve el stack antes, LDR R5, [SP, #8
durante y después de ejecutar LDR R4, [SP, #12
la función? ADD SP, SP, #1
MOV PC, LR

Instrucciones para manejo de stack

❖ Almacenar y leer valores del stack es tan común que ISA entrega soporte a
través de instruccione
❖ Instrucciones LDMFD/STMFD leen/almacenan múltiples registros en el
stac
❖ Load/Store Multiple Full Descendin
❖ También hay variaciones para Empty y Ascending (FD, ED, FA, EA
❖ STMFD SP!, {R4, R5} // LDMFD SP!, {R4, R5
❖ Actualizan el valor de SP después de realizar el load/stor
❖ Instrucciones PUSH y POP son sinónimos de STMFD y LDMF
❖ Ojo: Valores se almacenan en el mismo orden de los índices de los
registros, no importa en qué orden se listan los registros en la instrucción
k
Ejercicio: Uso de push/pop

PUNT
int i = 0 PUSH {R4, R5, R6, R7
do MOV R5, #
i++ LDR R6, [R0, R4, LSL #2
} ADD R4, R4, #
CMP R4, R
BLT D
MOV R0, R
POP {R4, R5, R6, R7
MOV PC, LR

Registros preservados/no preservados

❖ Estándar de llamado a procedimientos de ARM de ne qué se debe
preservar en el llamado a un procedimient
❖ Registros preservados DEBEN ser almacenados y recuperados por el
procedimiento (callee-save
❖ Registros no preservados pueden ser sobrescritos por el
procedimiento, si procedimiento que hace el llamado quiere
preservarlos, debe almacenarlos y recuperarlos él mismo (caller-save)
)
fi
Ejercicio: Reducir uso de stack
PUNT
int i = 0 PUSH {R4, R5
do MOV R5, #
i++ LDR R3, [R0, R4, LSL #2
} ADD R4, R4, #
CMP R4, R
En otros casos, podríamos haber BLT D
sobrescrito R1 y R2 para evitar usar R4 y MOV R0, R
R5, pero en este caso necesitamos sus POP {R4, R5
MOV PC, LR
valores durante toda la ejecución de la
función

Procedimientos no-hoja
❖ Cuando un procedimiento llama a otro procedimiento, los
registros que serán utilizados al regresar, deben ser
preservados de acuerdo a las reglas del estánda
❖ Caller-save: Antes de llamar a la función, el
procedimiento que llama debe almacenar todos los
registros no preservados (R0-R3 y R12) cuyo valor
necesita después del llamad
❖ Callee-save: Todo procedimiento debe almacenar y luego
restaurar todos los registros preservados (R4-R11, LR, SP)
o
Ejemplo
Estado del stack
Funciones recursivas
❖ Una función recursiva se llama a si mism
❖ Ej. fact (n) = n * fact (n-1) cuando n > 1, 1 cuando n =
❖ Las funciones también pueden tener recursividad indirecta, ej. f1()
llama a f2(), f2() llama a f1(
❖ Una función recursiva es “llamador” (caller) y “llamado” (callee) a la ve
❖ Llamador: Debe almacenar y recuperar registros de parámetros (R0-
R3) y registro temporal R12 si los va a necesitar después del llamado
recursivo, y LR (porque se sobrescribe al hacer el llamado recursivo
❖ Llamado: Debe almacenar y restaurar los registros preservados R4-
R11 si los va a sobrescribir, debe restaurar el valor original de SP
)
Ej. Factorial
Ej. Stack durante la ejecución de factorial
Resumen: Stack
❖ Qué se almacena en el stack frame
❖ Registros preservados modi cados (R4 - R11, LR si llama a otro
procedimiento
❖ Funciones no-hoja: Registros no preservados que serán usados después de
llamado a procedimiento (R0-R4, R12
❖ Variables locales y temporales que no caben en los registros del procesador
(scratch space
❖ Argumentos adicionales cuando exceden los cuatro almacenables en R0-R
❖ Valor de retorno cuando no cabe en un registr
❖ Registro SP siempre debe volver a valor original antes de retornar
)
fi
?
Ejercicio: Programar en assembly ARM
int fib(int n)
{
if (n == 0)
return 0;
if (n == 1)
return 1;
return fib(n-1) + fib(n-2);
}
Excepciones
❖ Todo procesador debe ser capaz de manejar situaciones de excepció
❖ Típicamente manejadas por el sistema operativo, que se ejecuta con privilegios
mayores al usuario, puede accesar toda la memoria y los dispositivos de E/
❖ Producto de la ejecución del program
❖ División por cero (en versiones de ARM con división
❖ Acceso ilegal a memori
❖ Instrucción inválida (código de operación desconocido
❖ Explícitamente invocadas por el program
❖ “Trap” o “interrupción por software” usada para llamar al S.O
❖ Externa
❖ Interrupciones por hardware, provocadas por dispositivos de E/S
s
Modos de operación
❖ Un procesador ARM tiene 7 modos de operació
❖ Usuario: Sin privilegios especiales, mayoría de los programas se ejecuta aqu
❖ FIQ: Utilizado para procesar una interrupción de alta prioridad (rápida
❖ IRQ: Utilizado para procesar interrupciones de baja prioridad (normal
❖ Supervisor: Utilizado ante un reset o la ejecución de una instrucción de
interrupción por software (SWI
❖ Abortar: Utilizado para manejar violaciones de memori
❖ Inde nido: Utilizado para manejar instrucciones no de nida
❖ Sistema: Modo privilegiado que usa los mismos registros que el modo
usuario
fi
)
fi
a
Bancos de registros
❖ Los distintos modos de ejecución poseen sus propios subconjuntos de los
registros, evita tener que almacenarlos en memoria (37 registros físicos en total)
SPSR: saved
program status
register.
CPSR se copia a
SPSR cuando se
produce una
excepció
Instrucciones
especiales accesan
CPSR y SPSR

Recordar: CPSR
NZCV: Flags de estad
I: Habilitación de interrupciones normale
F: Habilitación de interrupciones rápida
T: Set de instrucciones “Thumb
Mode: Modo de operación
 
o
Manejo de excepciones
❖ Cuando ocurre una excepción, el procesado
❖ Copia CPSR al SPSR del banco correspondient
❖ Modi ca los bits correspondientes del CPS
❖ Bits de mod
❖ Deshabilita I o
❖ Set de instruccione
❖ Cambia al banco de registros del modo
correspondient
❖ Almacena PC en el LR del banco correspondient
❖ Asigna a PC la dirección del vector correspondient
❖ Para retornar de una excepció
❖ CPSR <— SPS Instrucción en el vector es
❖ PC <— LR
típicamente un salto
fi
o
Mapa de memoria
❖ Código para manejo de excepcione
❖ Texto (código y constantes
❖ Variables globales (static base pointer SB = R9
❖ Datos dinámicos (stack y heap
❖ Dispositivos de E/
❖ En ARM, el mapa de memoria es
relativamente exibl
❖ Tabla de excepciones siempre parte en
dirección
❖ Dispositivos de E/S siempre mapeados en
direcciones altas de memori
❖ Usuario puede indicar dónde comienzan
los otros segmentos
0
fl
S
Lenguaje de máquina
❖ Lenguaje assembly es fácil de leer por un humano (mnemónicos, rótulos
❖ Pero circuitos digitales procesan sólo 0s y 1
❖ Lenguaje de máquina representa las instrucciones assembly como vectores
de 0s y 1
❖ Objetivo: Simplicidad y regularida
❖ Idealmente, un único formato de instrucción permite que hardware de
descodi cación sea más sencill
❖ Pero instrucciones son muy distintas, se necesitarían muchos bit
❖ Principio 4: Un buen diseño requiere buenos compromiso
❖ Pocos formatos distintos, instrucciones de 32 bits
fi
s
Instrucciones aritmético/lógicas
❖ cond: Condición, usado para ejecución condiciona

❖ op: Código de operación, indica tipo de instrucción (00 para
instrucciones aritmético/lógicas
❖ funct: Código de función, indica operación realizada por la instrucció
❖ Rd: Registro destin
❖ Rn: Primer registro operand
❖ Src2: Segundo operando
o
Ejecución condicional: Campo cond
Operando 2
❖ Constante de 8 bits rotada a la derecha en 0 a 30 bits (2*rot

❖ Registro Rm opcionalmente desplazado en una constante shamt
❖ Registro Rm opcionalmente desplazado en el valor de un registro R
❖ Bit I indica si segundo operando es constant
❖ Bit S indica si instrucción modi ca los ags
fi
fl
e
Ej. Constantes
❖ Rotación opcional permite generar
diversas constante
❖ Números de 8 bits, potencias de
2, múltiplos pequeños (7 bits) de
cualquier potencia de
❖ Recordar que rotar a la derecha en
N es lo mismo que rotar a la
izquierda en (32 - N
❖ Es una forma ingeniosa de utilizar
el desplazador (barrel shifter)
hardware del procesador para
generar un rango de constantes más
útil que una constante de 12 bits
s
Campo cmd
Campo cmd (cont.)
Codificación de instrucciones aritméticas
Codificación de instrucciones de desplazamiento
Instrucciones de multiplicación
❖ LDR, STR, LDRB, STR

❖ op = 0
❖ funct determin
❖ Bits I y U: Offset constante/registro, se suma/resta a registro bas
❖ Bits P y W: Modo indexado, pre-indexado, post-indexad
❖ Bit L: Load o stor
❖ Bit B: Byte o palabra
1
Campo funct en load/store
Ej. STR R11, [R5], #-26
❖ Instrucción utiliza direccionamiento post-indexado
(direcciona con R5, actualiza R5 sumándole -26)
❖ Post-índice —> P = 0, W =
❖ STR —> L = 0, B =
❖ Offset constante se resta de base —> I = 0, U = 0
0
Instrucciones LDRM/STRM
Instrucciones de salto
❖ Instrucciones de salto utilizan un operando inmediato de 24 bits
❖ Expresa la dirección destino como el desplazamiento respecto de la dirección
de la instrucción de salto (PC), extendido en sign
❖ Por motivos históricos de implementación, desplazamiento relativo a (PC + 8
❖ Y el desplazamiento es en instrucciones (4 bytes
❖ O sea, la dirección destino es (PC + 8) más la constante multiplicada por 4 y
extendida en signo a 32 bit
❖ Bit L indica si es un salto convencional (0) o un BL (1)
s
Ejemplo
En este caso, la dirección destino está 3 instrucciones más abajo que PC + 8, por lo tanto el
desplazamiento vale 3
Ejemplo
❖ Determinar el código de máquina para la instrucción de salto
Ejemplo
❖ Traducir la siguiente palabra de lenguaje de máquina a código assembly: 0xE0475001
Ejemplo
❖ Traducir la siguiente palabra de lenguaje de máquina a código assembly: 0xE0475001
En binario:
11100000010001110101000000000001 —> aritmético/lógica

1110 00 0 0010 0 0111 0101 000000000001 —> SUB R5, R7, Src2
1110 00 0 0010 0 0111 0101 00000 00 0 0001 —> SUB R5, R7, R1

Ejemplo
❖ Traducir la siguiente palabras de lenguaje de máquina a código assembly: 0xE5949010
Ejemplo
Campo funct en load/store
Ejemplo
En binario:
11100101100101001001000000010000 —> Load/store
1110 01 0 1 1 0 0 1 0100 1001 000000010000
I’ = 0 —> Src2 = imm12
P = 1, W = 0 —> Offset
L = 1, B = 0 —> LDR
U = 1 —> sumar a base
LDR R9, [R4, #16]

Problema (1)
Se ha encontrado el siguiente código de máquina ARM almacenado en forma consecutiva en
la memoria RAM de un computador. Se sabe que este código corresponde a una función que
recibe dos parámetros enteros y retorna un valor entero. Escriba el código C de una función
que, al compilarla, produciría este código. Sugerencia: Escriba primero el código assembly
equivalente.
0xE150000
0xC040000
0xD041000
0xE1A0f00

Problema (2)
0xE150000
0xC040000
0xD041000
0xE1A0f00E
La primera instrucción en binario es

1110 0001 0101 0000 0000 0000 0000 000
Los bits 27:26 son 00 -> es una instrucción aritmético/lógica
Los bits 31:28 son 1110 -> se ejecuta en forma incondiciona
El bit 25 es 0 segundo operando registr
Bits 24:21 son 1010 y bit 20 es 1 -> es un CM
Bits 19:16 son 0000 -> Rn = R0, bits 3:0 son 0001 -> Rm = R
-> CMP R0, R
0
Problema (3)
0xE150000
0xC040000
0xD041000
0xE1A0f00E
La segunda instrucción en binario es

1100 0000 0100 0000 0000 0000 0000 000
También es aritmético/ lógica, con segundo operando registro
Bits 31:28 son 1100 -> se ejecuta si G
Bits 24:21 son 0010 y bit 20 es 0 -> es un SU
Rn = R0, Rm = R1, Rd = R
-> SUBGT R0, R0, R

Problema (4)
0xE150000
0xC040000
0xD041000
0xE1A0f00E
La tercera instrucción en binario es

1101 0000 0100 0001 0000 0000 0000 000
Es la misma anterior, pero Rn = R1 y Rm = R
Y campo cond = 1101 -> se ejecuta si L
-> SUBLE R0, R1, R
0
Problema (5)
0xE150000
0xC040000
0xD041000
0xE1A0f00E
La cuarta instrucción en binario es

1110 0001 1010 0000 1111 0000 0000 111
Incondicional, instrucción aritmético/lógica, segundo operando
registro
Campo cmd es 1101 y bits 11:4 son 0 -> MO
Rd = R15 (PC) y Rm = R14 (LR
-> MOV PC, L
.
Problema (6)
0xE150000
0xC040000
0xD041000
0xE1A0f00E
Entonces
CMP R0, R
SUBG R0, R0, R
SUBL R0, R1, R
MOV PC, L
O bien
int f (int a, int b)
if (a > b) return a – b
else return b – a
}
{
T
E
:
Resumen: Modos de direccionamiento

ISA - Key

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

ISA - Key

Cargado por

Copyright:

Formatos disponibles

543.

Arquitectura de Computadores Miguel Figuero

Arquitectura de conjunto de instrucciones

❖ Instruction Set Architecture (ISA

Arquitectura de conjunto de instrucciones

Principios de diseño RISC

❖ Principio 1: Regularidad permite simplicida

Assembly: Suma y resta

- ADD y SUB son mnemónicos: Indican qué operación realiza la instrucción

Regularidad: Si todas las instrucciones tienen el mismo número de operandos, su

❖ Cuáles pueden ser los operandos de una instrucción

❖ Arquitectura ARM de ne roles especí cos para algunos registro

Suma y resta con registros

Operandos constantes o inmediatos

Constante se precede con signo “#

❖ El registro R0 contiene un número de 8 dígitos

Instrucciones de acceso a memoria

Instrucciones de acceso a memoria

❖ Asumir que variables a, b y acum son contiguas en

❖ Asuma que c1 y pack están contiguas en memoria y que la

Big endian vs. little endian

❖ ARM favorece little endian, pero tiene soporte para ambos

Otras instrucciones load/store

Otros modos de direccionamiento

Ejecución condicional de instrucciones

Modificación de bits de condición

Instrucciones que modifican bits de condición

❖ TST R1, R2 modi ca ags de condición basado en R1 & R

Ejecución condicional de instrucciones

❖ ADDEQ se ejecuta sólo si R2 == R

CMP R0, R1 ; comparación (a - b

CMP R0, R1 ; comparación (a - b

// todas las variables y vectores son entero

for (i = 0; str2[i] != 0; i++

int a, b, c, d, e int fun (int p1, int p2, int p3

Soporte ISA para funciones

❖ Para soportar funciones, el lenguaje de máquina debe proveer un soporte mínim

Soporte para funciones: Registros

❖ Registro R0 se utiliza para pasar el valor de retorno y el primer parámetr

Soporte para funciones: Instrucciones

Ejercicio: Escribir en assembly ARM

int punto(int v1[], int v2[], int n

Ejercicio: Escribir en assembly ARM

Ejercicio: Escribir en assembly ARM

Ejercicio: Escribir en assembly ARM

Ejercicio: Escribir en assembly ARM

Memoria local a función

Uso del stack

Recordar: Sin stack

Ejercicio: Sin modificar R4-R7

Instrucciones para manejo de stack

Ejercicio: Uso de push/pop

Registros preservados/no preservados

Ejercicio: Programar en assembly ARM

NZCV: Flags de estad

I: Habilitación de interrupciones normale

F: Habilitación de interrupciones rápida

T: Set de instrucciones “Thumb

Mode: Modo de operación

❖ cond: Condición, usado para ejecución condiciona

Ejecución condicional: Campo cond

❖ Constante de 8 bits rotada a la derecha en 0 a 30 bits (2*rot