Conjuntos de instrucciones y lenguaje ensamblador

Un procesador ejecuta instrucciones representadas por bits. Una arquitectura del conjunto de instrucciones (ISA) da a esos bits un significado compartido, de modo que el software puede solicitar las mismas operaciones en diferentes implementaciones.

Qué define la ISA

La ISA especifica las instrucciones, los registros visibles, los tamaños de datos, el comportamiento de la memoria y las codificaciones de instrucciones. Una instrucción como add a0, a1, a2 debe producir el resultado definido en todos los procesadores que la admitan. Los circuitos internos y la planificación pertenecen a la microarquitectura. Dos chips pueden diferir mucho en velocidad y consumo de potencia aunque implementen la misma ISA.

La compatibilidad binaria también necesita que coincida el entorno de software. Un programa que llama a un servicio del sistema operativo o a una biblioteca depende de algo más que del significado de las instrucciones. Las convenciones de registros y la distribución de los datos forman parte de la interfaz binaria de aplicación, o ABI.

Del código legible a los bits

Para C, un compilador selecciona instrucciones de ensamblador; un ensamblador las codifica como código máquina. El ensamblador es texto con nombres de instrucciones, registros, comentarios y etiquetas. El código máquina es la representación binaria que busca el procesador. Una etiqueta como Start: da nombre a la dirección de una instrucción; no es una instrucción que se ejecute durante la ejecución. Un comentario empieza con #.

Start:
    add a0, a1, a2   # a0 receives a1 + a2

El primer registro es el destino. Si a1 contiene 14 y a2 contiene 5, la instrucción escribe 19 en a0; deja los operandos de origen sin cambios. Las expresiones más complejas necesitan varias operaciones. Sumar cuatro valores de registros requiere tres sumas, con los resultados intermedios almacenados en registros.

La mayoría de los nombres de instrucciones corresponden a una instrucción máquina. Una pseudoinstrucción es una abreviatura del ensamblador: mv solicita una copia de registro y li solicita una constante. Una pseudoinstrucción puede expandirse en una o varias instrucciones reales, por lo que contar líneas de ensamblador no siempre indica el tamaño del código.

Instrucciones almacenadas en memoria

Según el concepto de programa almacenado, tanto las instrucciones como los datos se representan como números en memoria. El contador de programa, pc, identifica la instrucción que se debe buscar. Para una secuencia de instrucciones de 32 bits, la ejecución normal lo avanza 4 bytes. Los saltos condicionales e incondicionales eligen una dirección siguiente diferente. El procesador ejecuta la codificación, no la escritura en ensamblador que la produjo originalmente.

Bases y extensiones de RISC-V

RISC-V es un estándar abierto de ISA, libre de regalías y mantenido por RISC-V International. RV32I proporciona 40 instrucciones base para enteros y registros de enteros de 32 bits; RV64I usa registros de enteros de 64 bits. Ambos proporcionan 32 registros de enteros. Las extensiones opcionales añaden capacidades: M proporciona multiplicación y división de enteros, A operaciones atómicas, F y D coma flotante, C instrucciones comprimidas y V vectores. Los ejemplos usan RV32I y usan M donde aparece mul.

El ensamblador de RISC-V es específico de RISC-V. Un programa en C puede volver a compilarse para x86 o ARM, pero su código máquina de RISC-V no puede ejecutarse directamente como el de esas ISA. Un simulador puede ejecutar instrucciones RISC-V en un sistema anfitrión con una ISA diferente y mostrar los cambios en registros y memoria paso a paso.

Los registros contienen los valores que una instrucción puede usar inmediatamente. En RV32I, cada registro de enteros contiene 32 bits, y el nombre de un registro identifica un espacio de almacenamiento, no una variable de C ni un tipo de dato.

Nombres y funciones de los registros

Hay 32 registros de enteros, de x0 a x31. El contador de programa es independiente. Cinco bits identifican un registro de enteros porque hay 32 patrones posibles de 5 bits. Un banco de registros pequeño también limita el coste de acceso y el espacio que ocupan los campos de registro en las instrucciones.

El registro s0 también puede servir como fp, el puntero de marco. Las escrituras en zero se descartan, por lo que puede proporcionar un operando cero sin cargar antes una constante. Por ejemplo, add a0, a1, zero copia a1.

Estos nombres expresan un acuerdo de software. En particular, el hardware no preserva automáticamente un registro s. Un procedimiento que lo modifica debe encargarse de restaurar el valor que tenía al entrar. La ABI estándar también reserva gp y tp para sus funciones en el entorno; no son registros temporales de uso general.

Divide una expresión en operaciones

Traduce f = (g + h) - (i + j); con g, h, i, j en s1–s4 y el resultado en s0:

add t0, s1, s2
add t1, s3, s4
sub s0, t0, t1

Con los valores 9, 4, 6 y 1, la primera instrucción deja 13 en t0. La segunda deja 7 en t1. La resta escribe 6 en s0. Cada registro temporal conserva un resultado hasta que la siguiente instrucción lo necesita.

El orden de los dos operandos de origen importa en la resta: sub s0, t1, t0 daría −6. El destino siempre va primero, por lo que sub t0, s0, t1 sobrescribiría un registro temporal y leería el valor anterior de s0. Al seguir la ejecución, anota el destino después de cada línea; no actualices ambos registros de origen.

Los bits adquieren significado al usarse

Un registro no tiene una marca de con signo o sin signo. El patrón 0xFFFFFFFF puede significar −1 con signo o 4 294 967 295 sin signo. Por tanto, una comparación con signo y una sin signo pueden dar resultados distintos para los mismos bits almacenados. Las direcciones también son patrones de bits en registros; una carga interpreta su base como una dirección.

Conserva los valores mientras sean necesarios

Un compilador asigna a registros los valores que se usan con frecuencia. Si necesita más valores activos de los que caben en los registros, almacena algunos en memoria, un proceso llamado derrame de registros a memoria, y los carga de nuevo más tarde. Un derrame supone un coste real de almacenamiento y carga.

Las llamadas crean otro límite. Un procedimiento llamado puede sobrescribir t0–t6 y a0–a7. Conserva un valor necesario después de una llamada en un registro s correctamente preservado o guárdalo en la pila antes de la llamada. Elegir t0 solo porque estaba libre no garantiza que su valor se conserve.

Las direcciones de memoria identifican bytes. Las cargas llevan datos a los registros y los almacenamientos copian los bits de los registros de vuelta a la memoria. En una arquitectura de carga y almacenamiento, las operaciones aritméticas no leen sus operandos directamente de la memoria.

Tamaños y desplazamientos en bytes

Un byte ocupa una dirección, una media palabra dos y una palabra de 32 bits cuatro. RV32 tiene un espacio de direcciones de 32 bits de hasta 4 GiB. En la ABI de C ILP32, char usa 1 byte, short 2, e int, long y los punteros 4.

Las instrucciones lw y sw transfieren palabras. Las cargas de media palabra son lh y lhu, y las cargas de byte son lb y lbu. Los almacenamientos usan sh y sb para los tamaños menores. Un almacenamiento copia los bits inferiores de su origen; sb escribe solo los 8 bits inferiores.

Una dirección es un registro base más un desplazamiento en bytes con signo de 12 bits:

lw t0, 32(s3)
sw t0, 48(s3)

La carga lee la palabra en la dirección contenida en s3 más 32. No suma 32 al valor cargado ni modifica s3. El almacenamiento escribe ese valor en la base más 48. El rango de desplazamiento va de −2048 a 2047.

Traduce un acceso a un arreglo

Para un arreglo de tipo int cuya base está en s3, el elemento A[i] comienza en la base más 4 veces el índice. Para implementar A[12] = h + A[8];, con h en s1:

lw t0, 32(s3)      # A[8]
add t0, s1, t0
sw t0, 48(s3)      # A[12]

Si A[8] es 80 y h es 3, A[12] pasa a valer 83. Un desplazamiento de 8 seleccionaría A[2], ya que la dirección cuenta bytes. Para un índice variable en s4, forma primero la dirección:

slli t1, s4, 2
add t1, s3, t1
lw t0, 0(t1)

El escalado sigue el tamaño del elemento, no el nombre del procesador. Un puntero o long de RV64 LP64 ocupa 8 bytes y usa ld/sd; un int de RV64 sigue ocupando 4.

Extiende una carga pequeña

Un registro debe contener 32 bits incluso cuando una carga lee solo 8. lb copia el bit de signo del byte en cada bit superior; lbu rellena los bits superiores con ceros. Así, el byte 0xF0 se convierte en 0xFFFFFFF0 (−16) con lb, pero en 240 con lbu. La misma distinción se aplica a lh y lhu. Los bytes sin signo, incluidos los bytes de cadenas, usan lbu.

Lee el orden de bytes

En la memoria con el byte menos significativo primero, este ocupa la dirección más baja. Al almacenar 0x12345678 en 0x1000, se colocan 0x78, 0x56, 0x34, 0x12 en las direcciones de 0x1000 a 0x1003. Una carga de byte desde la primera dirección lee 0x78. El orden con el byte más significativo primero coloca 0x12 primero; los sistemas RISC-V pueden definir cualquiera de los dos órdenes, aunque los sistemas habituales de enseñanza usan el byte menos significativo primero.

Una dirección con alineación natural es múltiplo del tamaño del acceso: 4 para una palabra y 2 para una media palabra. Los accesos con alineación natural tienen soporte de la arquitectura. Un acceso desalineado puede funcionar, tardar más o producir una excepción, según el entorno de ejecución. Coloca las palabras en límites de 4 bytes y avanza 4 para llegar a la siguiente palabra.

Un operando inmediato es una constante codificada dentro de una instrucción. Permite que una operación común, como incrementar un contador, evite una carga independiente.

Constantes pequeñas

addi t0, t0, 1 suma 1 a t0. Su inmediato es un número con signo de 12 bits en complemento a dos, de −2048 a 2047. El procesador aplica extensión de signo hasta 32 bits antes de la suma. Resta una constante pequeña con un inmediato negativo, como en addi t0, t0, -5; RV32I no tiene una instrucción de resta con inmediato.

Las cargas, jalr y las instrucciones ordinarias de inmediato aritméticas y lógicas también usan inmediatos con signo de 12 bits. En particular, andi, ori y xori no extienden sus constantes con ceros. Las instrucciones de desplazamiento con inmediato, en cambio, codifican una cantidad de desplazamiento de RV32 de 0 a 31.

Entre las abreviaturas útiles del ensamblador están:

La constante −1 se convierte en bits todos a uno al aplicar extensión de signo, por lo que xori con −1 invierte cada bit.

Construye los 32 bits

lui coloca un campo de 20 bits en los bits 31–12 y pone a cero los 12 bits inferiores. Para 0x12345678:

lui t0, 0x12345
addi t0, t0, 0x678

El valor intermedio es 0x12345000; sumar 1656 proporciona la parte inferior. Una parte inferior con el bit 11 a uno exige más cuidado. Su patrón de 12 bits representa un sumando negativo, por lo que debes aumentar la parte superior antes de sumarlo.

Para 0x00001800, el patrón inferior 0x800 significa −2048. Usa:

lui t0, 0x2
addi t0, t0, -2048

El primer resultado es 0x2000. Restar 0x800 produce 0x1800. Usar el campo superior 0x1 produciría 0x800, un bloque de 4096 por debajo.

Para cualquier constante de 32 bits, interpreta sus 12 bits inferiores como un valor con signo. Resta ese valor con signo de la constante deseada, divide entre 4096 y conserva los 20 bits inferiores para lui. Para 0xDEADBEEF, la parte inferior con signo es −273, por lo que se usa el campo superior 0xDEADC y después addi con −273. Los ensambladores realizan esta división para li.

Constantes, direcciones y contenidos

li t0, 100 coloca el número 100 en un registro. lw t0, 100(zero) lee el contenido de la memoria en la dirección 100. Una dirección puede cargarse como valor: la t0, Item pide al ensamblador la dirección denominada Item.

auipc suma un inmediato superior desplazado 12 bits a la izquierda a la dirección de esa instrucción. Combinado con una operación de inmediato o una carga, proporciona acceso relativo al pc en un alcance aproximado de ±2 GiB. Una instrucción la local suele usar auipc más addi; otras expansiones permiten el acceso a bibliotecas compartidas.

Una constante como 5000 no puede ser un operando de addi. Cárgala en un segundo registro con li y después usa add. Un valor mayor no obtiene un inmediato más ancho solo porque esté escrito en hexadecimal.

Una instrucción aritmética lee bits de registros y escribe un nuevo patrón de bits. Para entender ese patrón se necesitan tanto la operación como la interpretación prevista, con o sin signo.

Suma, resta y desbordamiento

En RV32I, add, sub y addi conservan los 32 bits inferiores del resultado. Sumar 1 a 0x7FFFFFFF produce 0x80000000, que representa −2 147 483 648 como entero con signo. La instrucción no produce ninguna excepción de desbordamiento.

Para la suma sin signo, el software puede detectar el desbordamiento:

add t0, a0, a1
bltu t0, a0, Overflow

Una suma sin signo desbordada es menor que uno de los operandos. Esta comprobación sin signo no es la regla para el desbordamiento con signo, donde importan los signos de los operandos y del resultado.

La extensión M proporciona mul, mulh, mulhu, div, divu, rem y remu. mul conserva los bits inferiores del producto; las instrucciones que obtienen la parte superior del producto distinguen entre operandos con signo y sin signo. La división por cero devuelve un cociente con todos sus bits a uno y el dividendo original como resto, sin producir una excepción de división.

Selecciona, activa e invierte bits

and, or y xor operan de forma independiente en cada bit. AND con 1 conserva un bit; AND con 0 lo pone a cero. OR con 1 pone un bit a uno y XOR con 1 lo invierte.

srli t0, a0, 4
andi t0, t0, 0xF

Con a0 = 0xABCD, el desplazamiento a la derecha da 0xABC. Aplicar la máscara 0xF deja 0xC, los bits originales 7–4. El desplazamiento coloca el campo en la parte inferior; la máscara elimina todo lo que queda por encima. Para poner el bit 4 a uno sin cambiar los demás, usa ori a0, a0, 0x10. xori con −1 invierte los 32 bits.

Elige un desplazamiento según su regla de relleno

Un desplazamiento a la izquierda, sll o slli, rellena las posiciones inferiores con ceros. Un desplazamiento lógico a la derecha, srl o srli, rellena las posiciones superiores con ceros. Un desplazamiento aritmético a la derecha, sra o srai, copia el bit de signo en las posiciones superiores. Los desplazamientos con registro de RV32 solo usan los 5 bits inferiores del registro que contiene la cantidad de desplazamiento.

Desplazar 13 a la izquierda 3 posiciones produce 104. Esto multiplica por 8 porque no se pierde ningún bit necesario. Los desplazamientos a la izquierda que descartan bits significativos conservan solo el resultado que cabe en el registro.

Para valores sin signo, desplazar a la derecha divide por una potencia de 2 y redondea hacia abajo. Para valores con signo, el desplazamiento aritmético a la derecha redondea hacia menos infinito: desplazar −7 a la derecha 1 posición da −4. La división con signo de C trunca hacia cero y da −3 para -7 / 2. Un compilador necesita una corrección antes de sustituir esa división con signo por un desplazamiento. Un desplazamiento lógico del mismo patrón negativo rellena con ceros y da un resultado positivo grande.

Compara para producir un valor

slt escribe 1 cuando su primer operando de origen con signo es menor, y 0 en caso contrario. sltu usa una interpretación sin signo. Con 0xFFFFFFFF y 1 como operandos, slt escribe 1, mientras que sltu escribe 0. Las versiones con inmediato son slti y sltiu; esta última también aplica extensión de signo a su inmediato antes de la comparación sin signo.

AND bit a bit es diferente de && de C. Un resultado bit a bit puede contener muchos bits a uno; AND lógico produce 0 o 1 y puede omitir la evaluación de la segunda expresión.

Un salto condicional compara dos registros y cambia el contador de programa cuando se cumple la condición. Cuando no se cumple, la ejecución continúa con la siguiente instrucción.

Elige la comparación

RISC-V combina la comparación y el salto en una sola instrucción. No tiene indicadores de condición de enteros que deban establecerse primero. Para comparar con cero, usa zero como uno de los operandos de origen. beqz a0, L se expande en beq a0, zero, L.

Las formas mayor que y menor o igual que son abreviaturas del ensamblador con los operandos de origen intercambiados. bgt a0, a1, L se expande en blt a1, a0, L. Intercambiar el orden de los operandos importa tanto como elegir el mnemónico correcto.

Flujo de control con signo y sin signo

Si a0 contiene 0xFFFFFFFF y a1 contiene 1, blt a0, a1, L realiza el salto porque −1 con signo es menor que 1. bltu no salta, porque el primer patrón es un valor sin signo grande. Usa comparaciones coherentes con el significado de los datos, incluida la comparación sin signo para las direcciones.

Una comprobación de límites sin signo puede rechazar índices negativos con signo, así como índices iguales o superiores a una longitud no negativa pequeña:

bgeu a0, a1, OutOfBounds

Para una longitud de 20, un índice de −1 aparece como 4 294 967 295 sin signo y provoca el salto. Un índice de 19 no lo provoca; uno de 20 sí. La longitud debe representar la longitud no negativa real del arreglo.

Saltos y direcciones de retorno

jal ra, f escribe la dirección de la siguiente instrucción, pc + 4, en ra y después salta a f. Un j L simple se expande en jal zero, L; su valor de enlace se descarta. Esto es apropiado para el salto de vuelta de un bucle, pero no establece una dirección de retorno para una llamada.

jalr rd, offset(rs1) suma un desplazamiento con signo de 12 bits a un valor de registro, pone a cero el bit 0 del destino y escribe su propio pc + 4 en rd. ret se expande en jalr zero, 0(ra), que retorna a la dirección guardada sin conservar un nuevo enlace.

Los saltos condicionales y jal almacenan desplazamientos relativos a las direcciones de sus propias instrucciones. Sus alcances son de aproximadamente ±4 KiB y ±1 MiB, respectivamente. jalr usa un destino basado en un registro y puede alcanzar todo el espacio de direcciones. Una transferencia condicional lejana puede invertir la condición para omitir un salto más largo:

bne a0, a1, Skip
jal zero, Far
Skip:

Aquí Far está dentro del alcance de jal. Si se cumple la igualdad, el salto corto continúa secuencialmente hacia el salto incondicional; en caso contrario, lo omite.

Reconoce un bloque básico

Un bloque básico tiene una entrada al principio y ninguna transferencia de control antes del final. Dentro de él, las instrucciones se ejecutan en secuencia. Los destinos de salto inician nuevos bloques; los saltos condicionales e incondicionales los terminan. Esto permite razonar qué asignaciones siempre se ejecutan antes de una comprobación o salida determinada.

El ensamblador hace explícita cada ruta de una decisión o un bucle. Las etiquetas marcan destinos, los saltos condicionales eligen rutas y los saltos incondicionales evitan continuaciones secuenciales no deseadas.

Un if-else necesita una vía de salida

Traduce if (i == j) f = g + h; else f = g - h;, con f, g, h, i, j en s0–s4:

bne s3, s4, Else
add s0, s1, s2
j Exit
Else:
sub s0, s1, s2
Exit:

El primer salto comprueba la condición opuesta a la de C para que, si hay igualdad, la ejecución continúe hacia la suma. El salto después de la suma impide ejecutar la resta. Con g = 10 y h = 3, los índices iguales dan 13; los distintos dan 7. Quitar j Exit hace que la resta también se ejecute después de la suma.

Para a < b && b < c, salta a la parte else en cuanto falle cualquiera de las comparaciones. Para a < b || b < c, salta a la parte then en cuanto se cumpla cualquiera de ellas. Esto implementa la evaluación en cortocircuito, incluida la omisión de una segunda expresión cuyo valor no es necesario.

Un bucle while comprueba antes de su cuerpo

Para while (save[i] == k) i++;, mantén i en s3, k en s5 y la base del arreglo en s6:

Loop:
slli t1, s3, 2
add t1, t1, s6
lw t0, 0(t1)
bne t0, s5, Exit
addi s3, s3, 1
j Loop
Exit:

Cada pasada forma la dirección del elemento actual, lo carga y lo comprueba. Con el arreglo {7, 7, 7, 2, 7}, índice inicial 0 y k = 7, el bucle termina con índice 3. La comprobación fallida no incrementa el índice. El arreglo debe contener un elemento que detenga el bucle dentro de su rango válido.

Suma un arreglo con un número de elementos dado

Para un número no negativo de elementos en a1 y la base del arreglo en a0:

li t1, 0
li t0, 0
Loop:
bge t0, a1, Done
slli t2, t0, 2
add t2, a0, t2
lw t3, 0(t2)
add t1, t1, t3
addi t0, t0, 1
j Loop
Done:
mv a0, t1
ret

La comprobación inicial gestiona una longitud cero sin realizar ninguna carga. Con cuatro elementos {5, -2, 10, 7}, la suma acumulada es 5, 3, 13 y después 20. La secuencia ejecuta 33 instrucciones: 2 de preparación, 7 por cada una de las cuatro iteraciones que cumplen la condición, una comprobación fallida y 2 instrucciones finales.

Una versión con puntero forma una dirección final una sola vez y avanza la dirección actual en 4. Para un rango válido del arreglo cuya dirección final no se desborde, puede usar comparaciones de direcciones sin signo:

li t1, 0
slli t0, a1, 2
add t0, a0, t0
bgeu a0, t0, Done
Loop:
lw t3, 0(a0)
add t1, t1, t3
addi a0, a0, 4
bltu a0, t0, Loop
Done:
mv a0, t1
ret

Hay 4 instrucciones de preparación, 4 por iteración y 2 instrucciones finales, un total de 22 para cuatro elementos. El salto inicial omite el cuerpo si el rango está vacío; el puntero avanza un elemento después de cada carga.

Decisiones con varias opciones

Una sentencia switch puede usar comparaciones repetidas o una tabla de saltos cuando los valores de los casos son densos. El despacho mediante tabla comprueba el rango del caso, multiplica un índice por el tamaño de 4 bytes de la entrada, carga la dirección del caso y salta a ella con jalr zero, 0(t0). La comprobación del rango debe preceder a la carga de la tabla para que un caso inválido no pueda seleccionar una dirección ajena.

Una instrucción máquina es una palabra de 32 bits dividida en campos. Codificar significa elegir la distribución correcta, asignar cada operando a un campo y escribir cada campo con su anchura completa.

Las posiciones fijas simplifican la decodificación

Los 7 bits inferiores, 6–0, contienen el código de operación. Cuando están presentes, rd ocupa los bits 11–7, funct3 los bits 14–12, rs1 los bits 19–15 y rs2 los bits 24–20. Los campos de registro de cinco bits identifican de x0 a x31. Los campos de función distinguen las operaciones que comparten un código de operación.

RV32I usa los formatos R, I, S, B, U y J. Estos acomodan operandos diferentes en los mismos 32 bits, manteniendo estables las posiciones de los registros. Para los inmediatos con signo, el bit 31 contiene el signo.

Tipo R: dos operandos de origen y un destino

Desde el bit 31 hasta el bit 0, la distribución R es:

funct7 | rs2 | rs1 | funct3 | rd | opcode
   7      5     5       3     5       7 bits

Para add s0, a0, a1, rd = 8, rs1 = 10, rs2 = 11. ADD usa el código de operación 0110011, funct3 = 000, funct7 = 0000000:

0000000 | 01011 | 01010 | 000 | 01000 | 0110011
0000 0000 1011 0101 0000 0100 0011 0011

La palabra hexadecimal es 0x00B50433. SUB solo cambia funct7 a 0100000, lo que da 0x40B50433 para sub s0, a0, a1. Los campos de origen aparecen en un orden distinto al de los operandos de ensamblador, por lo que no debes limitarte a concatenar los nombres de registro escritos.

Tipo I: un operando de origen y un inmediato

La distribución I es imm[11:0] | rs1 | funct3 | rd | opcode. addi usa el código de operación 0010011 y funct3 = 000. En addi sp, sp, -16, ambos campos de registro contienen 00010. El inmediato de 12 bits es 111111110000 (0xFF0), lo que produce 0xFF010113.

Una carga también usa el tipo I, con la base de la dirección como rs1 y el registro cargado como rd. lw t0, 32(s3) tiene el inmediato 32, la base x19, el destino x5, el código de operación 0000011 y funct3 = 010, lo que da 0x0209A283.

Las operaciones de desplazamiento con inmediato usan los 5 bits inferiores de la región del inmediato como cantidad de desplazamiento. Los bits de control superiores distinguen los desplazamientos: srli t0, t1, 3 es 0x00335293, mientras que srai t0, t1, 3 es 0x40335293. El bit 30 selecciona la regla de relleno aritmético.

Tipo S: almacena un valor de origen

Un almacenamiento no tiene registro de destino. La distribución S usa ese espacio para parte de su inmediato:

imm[11:5] | rs2 | rs1 | funct3 | imm[4:0] | opcode

Para sw t0, 48(s3), rs2 = 5 proporciona el valor almacenado y rs1 = 19 proporciona la base. El inmediato de 12 bits 48 se divide en 0000001 y 10000. Con funct3 = 010 y el código de operación 0100011, el resultado es 0x0259A823. No hay ningún rd que deba llenarse con t0.

Después de unir los campos, agrupa la cadena completa de 32 bits en ocho cuartetos de 4 bits y convierte cada uno en un dígito hexadecimal. Después decodifica el resultado: confirma el código de operación, los números de registro y el inmediato con signo. Rellenar un campo de registro hasta 5 bits es esencial; omitir un cero inicial cambia las posiciones de los campos posteriores.

Las codificaciones de saltos condicionales e incondicionales ahorran espacio al omitir un bit del desplazamiento que siempre es cero. Sus campos siguen representando distancias en bytes, y el signo debe reconstruirse antes de calcular el destino.

Desplazamientos de saltos de tipo B

Calcula el desplazamiento como la dirección de destino menos la dirección del propio salto condicional. Una instrucción bne en 0x1010 cuyo destino es 0x1000 usa −16 bytes, no −20 ni −4 instrucciones.

El tipo B usa el código de operación 1100011. Su desplazamiento con signo tiene 13 bits, incluido un bit 0 que vale cero y no se almacena. El rango va de −4096 a +4094 bytes, en incrementos de 2. La distribución es:

Los campos de origen permanecen en sus posiciones habituales. Los valores de funct3 son 000 para beq, 001 para bne, 100 para blt, 101 para bge, 110 para bltu y 111 para bgeu.

Para bne t0, t1, -16, el desplazamiento de 13 bits es 1 1111 1111 0000. Sus partes dispersas son 1, 111111, 1000 y 1 en el orden de la tabla. Con rs1 = 5 y rs2 = 6, la instrucción es 0xFE6298E3. Sustituir el desplazamiento por +12 da 0x00629663.

Los desplazamientos admiten incrementos de 2 bytes porque las instrucciones comprimidas pueden tener una longitud de 2 bytes. Un destino al que se salta debe seguir cumpliendo la alineación de instrucciones activa: RV32I sin instrucciones comprimidas requiere una alineación de 4 bytes.

Tipos J y U

jal usa el código de operación 1101111. Su desplazamiento en bytes con signo de 21 bits omite el bit 0 y coloca los bits en el orden imm[20|10:1|11|19:12] a lo largo de los bits 31–12 de la instrucción. El rango va de −1 048 576 a +1 048 574 bytes. jal ra, 192 se convierte en 0x0C0000EF.

El tipo U coloca su valor superior de 20 bits directamente en los bits 31–12 de la instrucción, seguido de rd y el código de operación. lui usa 0110111; auipc usa 0010111. Así, lui t0, 0x12345 es 0x123452B7.

Decodifica primero por el código de operación

Para 0x00A12423, los 7 bits inferiores son 0100011: un almacenamiento. funct3 = 010 selecciona sw. Los campos de origen dan la base x2 (sp) y el valor x10 (a0). Los dos fragmentos del inmediato se unen para dar 8, por lo que el ensamblador es sw a0, 8(sp).

Para un salto condicional, une las partes dispersas en el orden de los bits del desplazamiento, añade el cero implícito y aplica extensión de signo al resultado completo de 13 bits. Tratar los 12 bits almacenados como un inmediato ordinario de tipo I pierde tanto la disposición correcta como la escala. La posición fija del bit de signo y la reutilización de las posiciones de otros campos reducen el trabajo de decodificación, aunque la distribución escrita es menos cómoda para leer a mano.

La reubicación preserva las relaciones

Si un salto condicional y su destino se desplazan la misma distancia, al restar sus nuevas direcciones se obtiene el desplazamiento anterior. Una referencia a otra sección puede cambiar cuando las secciones se distribuyen por separado. Por tanto, un enlazador puede preservar un salto relativo interno mientras ajusta una referencia a un símbolo externo.

Una llamada a un procedimiento transfiere control y datos entre partes de código escritas de forma independiente. La convención de llamada indica a ambas partes dónde van los argumentos y resultados y qué valores de registros deben conservarse.

La secuencia de llamada y retorno

El llamador coloca los primeros ocho argumentos enteros en a0–a7; los argumentos adicionales van en la pila. El procedimiento devuelve un resultado entero en a0, usando también a1 para un resultado de 64 bits en RV32.

jal ra, f guarda su propia dirección más 4 en ra y después salta a f. jal f es su forma abreviada. La pseudoinstrucción call f normalmente se expande en auipc más jalr para lograr un mayor alcance; el enlazador puede reducirla a una instrucción jal. En ambos casos, la dirección de retorno sigue a la secuencia de llamada real.

ret es jalr zero, 0(ra). Salta mediante la dirección guardada y descarta un nuevo enlace. Un j f simple también descarta su enlace, por lo que no establece una llamada y retorno ordinarios.

Decide quién guarda un valor

Los registros preservados por el llamador incluyen t0–t6, a0–a7 y ra. El procedimiento llamado puede modificarlos. Si el llamador necesita más tarde uno de sus valores actuales, lo guarda antes de la llamada.

Los registros preservados por el procedimiento llamado incluyen s0–s11 y sp. Un procedimiento llamado que modifica un registro s debe guardar el valor recibido y restaurarlo antes de retornar. Restaurar sp devuelve al llamador a su propio marco. El procesador no impone estas obligaciones; los módulos compilados cooperan porque su software sigue la ABI.

Supón que un llamador tiene un contador de bucle en t0 y llama a un procedimiento auxiliar. El auxiliar puede usar t0 para su propio cálculo según la convención. Trasladar el contador a s1 puede hacer que se conserve durante las llamadas a auxiliares, pero el procedimiento que lo contiene debe entonces preservar el valor de s1 que recibió de su propio llamador.

Un procedimiento hoja puede no necesitar marco

Un procedimiento hoja no llama a ningún otro procedimiento. Esta función calcula (g + h) - (i + j) a partir de argumentos en a0–a3:

leaf:
add t0, a0, a1
add t1, a2, a3
sub a0, t0, t1
ret

Solo usa registros de trabajo preservados por el llamador y deja ra sin cambios. Para los valores de entrada 9, 4, 6 y 1, devuelve 6. No necesita un marco de pila.

Si el cálculo usa s0, debe preservar ese registro:

addi sp, sp, -16
sw s0, 12(sp)
add t0, a0, a1
add t1, a2, a3
sub s0, t0, t1
mv a0, s0
lw s0, 12(sp)
addi sp, sp, 16
ret

El resultado se traslada a a0 antes de restaurar el valor anterior de s0. Si el valor recibido en s0 era 1234, sigue siendo 1234 después. El marco reservado es de 16 bytes para preservar la alineación estándar de la pila aunque la palabra guardada solo use 4.

Una llamada puede entenderse como seis acciones: colocar argumentos, transferir el control, obtener almacenamiento, realizar la tarea, colocar el resultado y retornar. En cada límite, distingue el valor que se devuelve de los valores anteriores que la convención exige que el procedimiento preserve.

Las llamadas anidadas necesitan un lugar donde guardar los datos de la llamada exterior. La pila proporciona almacenamiento de tipo último en entrar, primero en salir: la llamada más reciente termina primero y libera su propio marco.

Reserva espacio por debajo del puntero de pila anterior

La pila crece hacia direcciones más bajas. addi sp, sp, -16 reserva 16 bytes; addi sp, sp, 16 los libera. La ABI estándar mantiene sp como múltiplo de 16 durante toda la ejecución. Un marco puede contener registros guardados, la dirección de retorno, valores derramados a memoria, objetos locales y espacio para argumentos salientes en la pila.

Un patrón habitual para un procedimiento que no es hoja es:

addi sp, sp, -16
sw ra, 12(sp)
sw s0, 8(sp)
# body, including calls
lw s0, 8(sp)
lw ra, 12(sp)
addi sp, sp, 16
ret

Los desplazamientos se refieren al nuevo sp. Si es 0x2000, el ra guardado ocupa de 0x200C a 0x200F. El epílogo correspondiente restaura los valores mientras el marco aún existe y después lo libera. Cada vía de retorno debe compensar la reserva.

Un puntero de marco, convencionalmente s0, puede dar desplazamientos fijos a los objetos locales cuando sp cambia dentro de un procedimiento. Su valor recibido debe preservarse como en cualquier otro uso de s0.

La recursión conserva copias separadas

El factorial necesita el n original después de calcular fact(n - 1). También necesita su propia dirección de retorno después de que el jal recursivo sobrescriba ra:

fact:
addi sp, sp, -16
sw ra, 12(sp)
sw a0, 8(sp)
li t0, 2
blt a0, t0, Base
addi a0, a0, -1
jal ra, fact
lw t1, 8(sp)
mul a0, t1, a0
j Done
Base:
li a0, 1
Done:
lw ra, 12(sp)
addi sp, sp, 16
ret

La instrucción mul de la extensión M multiplica el resultado interior devuelto por el n original. Para fact(3), coexisten los marcos de 3, 2 y 1. La llamada base devuelve 1; la siguiente devuelve 2; la llamada exterior devuelve 6. Con sp = 0x7FFFFF00 inicial, tres marcos lo reducen en 48 bytes hasta 0x7FFFFED0. Los retornos los liberan en orden inverso.

La comprobación base trata los valores no negativos 0 y 1. Para este resultado de 32 bits, el factorial es exacto hasta 12!: 479 001 600. Los bits inferiores del producto ya no representan el resultado completo en 13!, que es 6 227 020 800.

Sitúa la pila en la memoria del programa

Una distribución típica tiene el código en texto, las variables globales en datos estáticos, los objetos reservados dinámicamente en el montículo y los marcos de llamadas en la pila. El montículo suele crecer hacia arriba y la pila hacia abajo. La ubicación real depende del entorno de ejecución.

Un puntero a un objeto local de la pila deja de ser válido cuando el tiempo de vida de ese objeto termina al retornar. Restaurar sp no borra los bytes anteriores, pero las llamadas posteriores pueden reutilizarlos. Del mismo modo, cambiar sp y seguir usando los desplazamientos antiguos de los valores guardados puede hacer que se lean bytes del marco equivocado.

Un puntero es un valor de dirección. El ensamblador implementa una desreferenciación usando esa dirección como base de una carga o un almacenamiento, e implementa la aritmética de punteros sumando una distancia en bytes.

Sigue el puntero y después accede al valor

Con int *p en a0, lw t0, 0(a0) lee *p, mientras que sw t0, 0(a0) lo escribe. El registro contiene la dirección; la memoria en esa dirección contiene el entero. Si una variable de tipo puntero está almacenada en memoria, carga primero el valor del puntero y después úsalo como base de una segunda carga.

Obtener la dirección de un objeto local de C requiere almacenamiento direccionable, normalmente una posición de la pila. Un registro de hardware no tiene una dirección de memoria que pueda pasarse como &x.

La aritmética de punteros de C escala automáticamente. Para RV32 ILP32, incrementar int *p suma 4 bytes, mientras que incrementar char *p suma 1. El ensamblador no tiene un tipo de puntero que proporcione la escala:

addi a0, a0, 4    # next int
addi a1, a1, 1    # next char

Un argumento de arreglo es su dirección base, no una copia de sus elementos. Pasa el número de elementos por separado cuando un procedimiento lo necesite; el puntero por sí solo no codifica la longitud del arreglo.

Los campos de estructuras tienen desplazamientos en bytes

Para struct item { int id; int score; };, id ocupa los bytes 0–3 y score los bytes 4–7. Con la dirección del objeto en a0, lw t0, 4(a0) lee la puntuación. En general, los desplazamientos de los campos siguen las reglas de distribución y relleno de la ABI. No deduzcas todos los desplazamientos de campos solo contando las declaraciones del código fuente.

Para un arreglo de estas estructuras de 8 bytes, el siguiente elemento comienza 8 bytes más adelante. Dentro de cada elemento, la puntuación sigue estando a 4 bytes del comienzo de ese elemento. El paso entre elementos y el desplazamiento del campo son partes separadas del cálculo de la dirección.

Copia una cadena terminada en nulo

Una cadena de bytes de C termina con un byte cero. Para copiarla, lee y almacena un byte antes de decidir si la copia ha terminado:

Loop:
lbu t0, 0(a1)
sb t0, 0(a0)
addi a0, a0, 1
addi a1, a1, 1
bnez t0, Loop
ret

Aquí a1 es el origen y a0 el destino. El destino debe tener espacio suficiente. lbu lee un byte sin signo; sb almacena solo sus 8 bits inferiores. Ambos punteros avanzan 1, incluso en la última iteración. El salto comprueba el byte copiado, por lo que el cero terminador también se almacena.

Copiar «RISC» requiere cinco iteraciones para cuatro letras y el byte cero. Con cinco instrucciones por iteración más ret, ejecuta 26 instrucciones. Una cadena vacía también necesita una iteración para copiar su terminador. Una carga de palabra leería cuatro bytes a la vez y no implementaría este algoritmo que procesa un byte cada vez.

UTF-8 puede codificar un carácter en varios bytes. Este bucle copia esos bytes sin cambios; no cuenta los caracteres mostrados. Los bucles de arreglos basados en punteros pueden avanzar igualmente según el paso entre elementos sin volver a calcular un índice escalado cada vez. Los compiladores con optimización pueden realizar esa transformación incluso cuando el programa en C usa índices de arreglos ordinarios.

Un archivo fuente se convierte en instrucciones ejecutables mediante varias etapas de traducción. Cada etapa tiene una responsabilidad diferente, y los archivos intermedios conservan la información necesaria para las etapas posteriores.

El compilador elige instrucciones

Para C, el camino habitual es código fuente, ensamblador, archivo objeto, ejecutable y después un proceso en ejecución. Un compilador analiza el código fuente, lo optimiza, asigna registros y selecciona instrucciones para una ISA de destino. Un controlador de compilación puede ejecutar varias etapas con un solo comando.

gcc -S program.c se detiene después de producir el ensamblador. gcc -c program.c produce un archivo objeto sin enlazar. El compilador de destino determina qué ISA usa ese ensamblador; un programa RISC-V necesita una cadena de herramientas dirigida a RISC-V.

Con -O0, los valores suelen pasar por posiciones de la pila y el ensamblador sigue de cerca las sentencias individuales del código fuente. Con -O2, la asignación de registros, el trabajo eliminado y los bucles reorganizados pueden ocultar esa correspondencia. Una sentencia de C no tiene una única traducción fija a ensamblador.

El ensamblador codifica y registra

El ensamblador convierte mnemónicos y nombres de registros en bits, expande pseudoinstrucciones y resuelve las etiquetas que puede localizar. Un salto hacia delante hace referencia a una etiqueta que aparece más tarde. Un ensamblador puede recopilar primero las posiciones y después codificar las referencias, o registrar los lugares que debe completar una vez que se conozca el destino.

Las directivas indican al ensamblador cómo organizar la salida; el procesador no las ejecuta:

.data
.align 2
count:
.word 5
message:
.string "hi"
.text
.globl main
main:
# instructions follow

.word 5 genera un valor de datos de 4 bytes. .string "hi" genera los bytes de los caracteres y un cero terminador. En el ensamblador GNU de RISC-V, .align 2 alinea el siguiente elemento con un límite de 4 bytes. .globl hace que un símbolo sea visible para otros archivos objeto. Las etiquetas dan nombre a posiciones; por sí mismas no reservan bytes.

Qué conserva un archivo objeto

Un objeto reubicable suele contener una cabecera, código en secciones de texto, datos estáticos, una tabla de símbolos e información de reubicación. La tabla de símbolos distingue los nombres definidos aquí de las referencias definidas en otros lugares. La información de depuración opcional conecta las instrucciones con las líneas fuente; -g la solicita.

Los formatos habituales de objeto incluyen ELF, Mach-O y PE/COFF. El formato organiza el código máquina y los metadatos; es distinto de la ISA que define los bits de cada instrucción.

Para call printf, el ensamblador puede generar una secuencia auipc/jalr sin conocer la dirección final de la función. Registra un símbolo no definido y entradas de reubicación para que el enlazador pueda completar la referencia. La distancia de un salto local puede conocerse ya cuando su destino se desplaza con la misma sección, aunque los cambios posteriores de distribución, como la relajación, pueden requerir ajustes.

Otras vías de ejecución

Un intérprete realiza operaciones mediante otro programa en ejecución. Un compilador en tiempo de ejecución genera código máquina durante la ejecución, a menudo después de identificar el código utilizado con frecuencia. Java suele usar código de bytes seguido de interpretación y compilación JIT; Python suele usar un intérprete. Un JIT intercambia trabajo de compilación durante la ejecución por una ejecución repetida más rápida.

Por tanto, un archivo objeto es más que una lista de instrucciones en bruto, pero aún no es un proceso en ejecución completo. Los símbolos sin resolver y la distribución final todavía requieren la intervención del enlazador y el cargador.

Un enlazador construye un archivo ejecutable a partir de módulos objeto y bibliotecas. Un cargador usa ese archivo para crear un proceso en ejecución. Saber qué etapa se ocupa de una dirección ayuda a explicar tanto la reubicación como los errores de inicio.

Distribuye módulos y ajusta referencias

El enlazador coloca las secciones de entrada en el espacio de direcciones del ejecutable, resuelve las definiciones de símbolos y usa entradas de reubicación para ajustar las referencias. Un nombre que ningún módulo enlazado define produce un error de «referencia no definida».

Supón que el texto comienza en 0x00010000 y los datos en 0x10000000. El objeto A aporta 0x100 bytes de texto y 0x20 bytes de datos; B va inmediatamente después. El texto de B comienza en 0x00010100 y sus datos en 0x10000020.

Una instrucción jal de A en el desplazamiento de texto 0x40 tiene la dirección 0x00010040. Si procB comienza al inicio del texto de B, el desplazamiento de la llamada es 0xC0, o 192 bytes, codificado con ra como 0x0C0000EF. Una variable en el desplazamiento 0x10 de los datos de B queda en 0x10000030. Con gp = 0x10000800, su desplazamiento es −2000, que cabe en un desplazamiento de carga con signo de 12 bits. Son cálculos independientes de texto y datos.

Elige cómo se proporciona el código de biblioteca

El enlace estático copia el código objeto de biblioteca necesario en el ejecutable. El programa lleva ese código, lo que aumenta el tamaño del archivo; aplicar una corrección de la biblioteca requiere volver a enlazarlo. Las bibliotecas estáticas no eliminan la dependencia del programa respecto de su interfaz con el sistema operativo.

El enlace dinámico mantiene el código de biblioteca en archivos compartidos, como .so, .dll o .dylib. Los procesos pueden compartir páginas de código de biblioteca compatibles. Una biblioteca actualizada compatible puede servir a los programas sin volver a enlazar cada ejecutable, pero la versión requerida debe estar disponible cuando se necesite.

Con la vinculación diferida de ELF, la primera llamada pasa por una rutina intermediaria de la tabla de enlace de procedimientos (PLT). El enlazador dinámico resuelve el destino y lo registra en la tabla global de desplazamientos (GOT); las llamadas posteriores usan esa dirección registrada. Otras configuraciones resuelven los símbolos durante la carga.

El código independiente de la posición alcanza destinos locales mediante direccionamiento relativo, incluidas secuencias auipc, y usa indirección para destinos externos. Las distancias relativas internas de una biblioteca siguen siendo válidas cuando esta se desplaza como una unidad. La vinculación de referencias externas todavía puede requerir trabajo de reubicación.

El cargador crea el estado de ejecución

El cargador lee los metadatos del ejecutable, crea un espacio de direcciones, mapea o copia el código y los datos, prepara los argumentos y la pila inicial, inicializa el estado requerido de los registros y transfiere el control al código de inicio. El código de inicio llama a main; después de que retorne, el código de ejecución solicita la salida del proceso. Los sistemas modernos pueden mapear páginas del archivo y cargarlas en memoria cuando se necesiten.

ecall solicita un servicio del entorno. En RISC-V Linux, a7 contiene el número de llamada al sistema y a0–a5 contienen los argumentos. li a7, 93, li a0, 0, ecall solicita la salida con estado 0; el servicio 64 es write. Los números de servicio de un simulador proceden de su propia interfaz.

Una biblioteca que falta durante el enlace causa un fallo de enlace. Una biblioteca compartida necesaria que se elimina después del enlace puede, en cambio, impedir la carga o causar un fallo durante la vinculación en tiempo de ejecución. El ejecutable puede haberse construido correctamente aunque ahora no pueda iniciarse.

RISC y CISC describen enfoques generales de diseño de conjuntos de instrucciones. La comparación útil es cómo representa cada uno el trabajo: ubicaciones de operandos, longitud de instrucciones, cálculo de direcciones y flujo de control.

Operaciones regulares o instrucciones más complejas

Los diseños RISC favorecen las operaciones simples, muchos registros y el acceso mediante carga y almacenamiento. El enfoque se desarrolló a través del trabajo de IBM en el 801 a mediados de la década de 1970 y de RISC de Berkeley y MIPS de Stanford a principios de la década de 1980. RISC-V, ARM AArch64, MIPS y Power siguen esta tradición general.

Los diseños CISC ofrecen instrucciones de longitud variable, un direccionamiento más elaborado y operaciones que pueden combinar varios pasos. x86 surgió del 8086 presentado en 1978; entre las familias CISC anteriores están VAX y Motorola 68000.

En la sintaxis x86 de Intel, add eax, [ebx+8] lee un valor de 32 bits de la memoria y lo suma a eax. Una operación equivalente en RISC-V necesita una carga seguida de una operación aritmética:

lw t0, 8(s1)
add a0, a0, t0

La instrucción x86 combina un acceso a memoria con una suma. RISC-V los presenta como instrucciones separadas. x86 llama palabra doble a un valor de 32 bits; su palabra tiene 16 bits. Una palabra en los ejemplos de RV32 tiene 32 bits.

Codificación y direccionamiento

Una instrucción x86 tiene una longitud de 1 a 15 bytes. Las instrucciones base de RISC-V ocupan 4 bytes, y la extensión C proporciona formas comprimidas de 2 bytes. Las posiciones regulares de los campos simplifican la decodificación. Las longitudes variables pueden ahorrar espacio al usar codificaciones cortas para operaciones frecuentes.

RISC-V usa operandos de registro, inmediatos, direcciones de base más desplazamiento y direcciones relativas al pc. jalr pertenece al direccionamiento con base en un registro, mientras que los saltos condicionales, jal y auipc usan el pc.

x86 también combina una base, un índice escalado y un desplazamiento. mov eax, [ebx + esi*4 + 8] lee un elemento indexado de 4 bytes con un desplazamiento adicional en una instrucción. RISC-V forma el índice escalado y la dirección efectiva con instrucciones separadas antes de cargar. En ambos procesadores, el trabajo debe realizarse internamente.

Registros y comparaciones

RISC-V tiene 32 registros de enteros, incluido su registro cero fijo. El x86-64 convencional tiene 16 registros de propósito general; x86 de 32 bits tiene 8. Muchas instrucciones aritméticas x86 usan un destino que también es un operando de origen: add eax, ebx modifica eax. La instrucción add de tres operandos de RISC-V puede conservar ambos valores de origen mientras escribe en un tercer registro.

Las operaciones aritméticas y cmp de x86 establecen indicadores de condición; un salto posterior como jl los comprueba. RISC-V usa blt para comparar y saltar directamente. ARM AArch64 también usa indicadores, por lo que su presencia por sí sola no permite clasificar una ISA como CISC.

Qué significa reducido

RISC no significa que una ISA moderna deba tener un número total de instrucciones diminuto. RV32I tiene 40 instrucciones base, pero las extensiones opcionales añaden muchas más. La idea central son operaciones y codificaciones regulares y relativamente simples. Las codificaciones comprimidas también muestran que la longitud fija de las instrucciones es una tendencia de diseño, no una definición que deba cumplir cada instrucción RISC.

Un conjunto de instrucciones determina cómo expresa un programa su trabajo, pero la velocidad de ejecución también depende del procesador que lo implementa. Compara el comportamiento medido o modelado del programa, no el número de operaciones que promete una instrucción.

Combina los tres factores de rendimiento

El tiempo de CPU es igual al número de instrucciones ejecutadas multiplicado por los ciclos medios por instrucción (CPI) y por la duración del ciclo de reloj. De forma equivalente, divide el número de instrucciones ejecutadas multiplicado por el CPI entre la frecuencia de reloj. Un menor número de instrucciones puede verse contrarrestado por un CPI mayor o un reloj más lento.

A 2 GHz, cada ciclo dura 0,5 ns. Una versión con 1,0 miles de millones de instrucciones y un CPI de 2,0 usa 2,0 miles de millones de ciclos y tarda 1,0 s. Otra con 1,3 miles de millones de instrucciones y un CPI de 1,2 usa 1,56 miles de millones de ciclos y tarda 0,78 s. La segunda ejecuta un 30 % más de instrucciones, pero es aproximadamente 1,28 veces más rápida. El CPI es una media para ese programa en esa implementación, no una propiedad universal de una ISA.

Las instrucciones complejas siguen necesitando trabajo interno

Muchos procesadores x86 modernos traducen la mayoría de las instrucciones en microoperaciones internas más sencillas. Estas pueden entonces usar técnicas de ejecución similares a las de los núcleos RISC modernos. La ISA externa sigue siendo relevante para la codificación, la decodificación y la compatibilidad, incluso cuando las operaciones internas parecen similares.

Una instrucción compleja no garantiza un número fijo de ciclos. Una instrucción de copia de bloques y un bucle de copia sencillo pueden intercambiar su posición en rendimiento según los procesadores y las cargas de trabajo. La versión del procesador, el tamaño de los datos y el comportamiento de la memoria importan; un listado fuente de una sola instrucción no puede determinar el resultado.

La densidad del código es una medida independiente

Las secuencias de código máquina más cortas pueden reducir el almacenamiento y la presión sobre la caché de instrucciones. Las longitudes variables de CISC suelen mejorar la densidad. La extensión C de RISC-V proporciona codificaciones de 16 bits para operaciones frecuentes junto a instrucciones de 32 bits. La especificación indica un uso típico para el 50–60 % de las instrucciones, lo que da un código aproximadamente un 25–30 % más pequeño.

Para 100 instrucciones con la mitad comprimidas, 50 usan 2 bytes y 50 usan 4: 300 bytes en lugar de 400. El número de instrucciones ejecutadas sigue siendo 100. Una reducción del tamaño no determina por sí sola un factor de aceleración, porque el tiempo de ejecución depende de algo más que los bytes obtenidos.

La compatibilidad y las herramientas influyen en la elección

Los archivos binarios y las bibliotecas x86 existentes dan un valor considerable a la compatibilidad. RISC-V fija los conjuntos base y añade extensiones. El código RV32I puede ejecutarse en una implementación compatible con RV32I cuando coinciden la ABI y el entorno operativo; usar M o V añade esos requisitos. RV32E es una base diferente con un conjunto reducido de registros y no promete compatibilidad con RV32I.

ARM se usa ampliamente en dispositivos móviles, así como en portátiles y servidores; x86 se usa ampliamente en computadoras personales y servidores; RISC-V se usa en sistemas integrados, aceleradores, investigación y enseñanza. La disponibilidad de software, las licencias y la calidad de chips concretos importan al elegir una plataforma.

El ensamblador escrito a mano puede ayudar en una pequeña rutina crítica o permitir usar una instrucción especial, pero vincula el código a una ISA y aumenta el trabajo de mantenimiento. Los compiladores con optimización gestionan bien la asignación de registros y la reorganización del código. Usa mediciones para justificar la sustitución de código fuente claro por ensamblador.