Memoria: caricamento e memorizzazione

La memoria è una grande fila di slot di archiviazione numerati, e ogni slot contiene un byte (8 bit). Il numero di uno slot è il suo indirizzo. I registri sono il piccolo insieme di slot veloci della CPU. La memoria è molto più grande ma più lenta, e contiene tutto ciò che non entra nei registri, come array e stringhe. Per lavorare con un valore in memoria, lo si carica in un registro, lo si modifica e lo si riscrive.

I registri sono pochi e la memoria è grande. (load word) copia una parola dalla memoria in un registro, e (store word) la copia indietro. L'indirizzo è scritto come offset(register).

La memoria RISC-V è indirizzata per byte, quindi ogni byte ha il proprio indirizzo in sequenza. Una parola è di 32 bit, ovvero 4 byte, quindi si avanza un puntatore di memoria di 4 per raggiungere la parola successiva. Ecco perché gli offset degli array sono 0, 4, 8 e così via. Su hardware reale, caricare una parola da un indirizzo che non è un multiplo di 4 può essere lento o causare un trap. Questo simulatore lo permette, ma dovresti prendere l'abitudine di mantenere le parole allineate a 4 byte.

Carica / memorizza forma

lw t0, 0(a1) # t0 = memoria all'indirizzo a1
sw t0, 4(a1) # memoria all'indirizzo a1+4 = t0

In offset(register), il piccolo numero di offset viene aggiunto all'indirizzo contenuto nel registro. 0(a1) è l'indirizzo in a1 stesso, e 4(a1) è 4 byte dopo. Questo permette di raggiungere valori vicini senza cambiare il registro di base.

Salvataggio in memoria

CPU

li t0, 0x11111111

li t1, 0x22222222

li a0, 0x1000

sw t0, 0(a0)

sw t1, 8(a0)

Registers

t00x00000000

t10x00000000

a00x00000000

Random Access Memory (RAM)

Address	Value
0x100C	0x00000000
0x1008	0x00000000
0x1004	0x00000000
0x1000	0x00000000
0x0FFC	0x00000000

I registri e la memoria iniziano da zero.

Nell'animazione, il registro di base a0 rimane lo stesso. Solo l'offset letterale scritto nell'istruzione aumenta, spostandosi verso il successivo indirizzo di memoria target. Per creare memoria che corrisponda a questo schema, riserva memoria con nome nella sezione data con .word (uno o più valori a 32 bit) o .space N (N byte vuoti). Ogni parola occupa 4 byte, quindi gli elementi consecutivi si trovano agli offset 0, 4, 8, che sono gli stessi numeri usati nelle tue istruzioni di store.

Usa .word (uno o più valori a 32 bit) o .space N (N byte vuoti) per riservare memoria con nome nella sezione data. Ogni parola occupa 4 byte, quindi gli elementi consecutivi sono agli offset 0, 4, 8 e così via.

Somma un array in memoria

.data
nums: .word 10, 20, 30, 40 # quattro parole
.text
la t1, nums # t1 = indirizzo dell'array
li t2, 4 # conteggio
li t0, 0 # somma corrente
loop:
  beq t2, zero, done
  lw  t3, 0(t1) # carica l'elemento corrente
  add t0, t0, t3 # aggiunge alla somma
  addi t1, t1, 4 # avanza alla parola successiva (4 byte)
  addi t2, t2, -1 # uno in meno
  j loop
done:
  mv a0, t0 # stampa il totale (100)
  li a7, 1
  ecall
  li a7, 10
  ecall

mette l'indirizzo dell'array in t1, t2 conta i 4 elementi rimanenti, e t0 contiene la somma corrente. A ogni passaggio, ferma il ciclo quando non rimangono elementi. carica l'elemento puntato da t1, lo aggiunge alla somma, avanza il puntatore di una parola, e riduce il conteggio. Dopo tutti e quattro gli elementi (10 + 20 + 30 + 40), done stampa 100.

💡

Usa l'interruttore HEX/DEC nella barra degli strumenti del simulatore per cambiare il modo in cui indirizzi e valori vengono visualizzati. Scegli la base che rende il passo corrente più facile da seguire.

Apri in Litessera Lux, l'assembler RISC-V Offrimi un caffè