Mémoire : lecture et écriture

La mémoire est une grande rangée d'emplacements de stockage numérotés, et chaque emplacement contient un octet (8 bits). Le numéro d'un emplacement est son adresse. Les registres sont le petit ensemble d'emplacements rapides du CPU. La mémoire est bien plus grande mais plus lente, et elle contient tout ce qui ne tient pas dans les registres, comme les tableaux et les chaînes de caractères. Pour manipuler une valeur en mémoire, vous la chargez dans un registre, la modifiez, puis la stockez à nouveau.

Les registres sont peu nombreux et la mémoire est vaste. (load word) copie un mot depuis la mémoire vers un registre, et (store word) le copie en retour. L'adresse s'écrit offset(register).

La mémoire RISC-V est adressée par octet, donc chaque octet a sa propre adresse en séquence. Un mot fait 32 bits, soit 4 octets, donc vous avancez un pointeur mémoire de 4 pour atteindre le mot suivant. C'est pourquoi les décalages de tableau sont 0, 4, 8, etc. Sur du matériel réel, charger un mot depuis une adresse qui n'est pas un multiple de 4 peut être lent ou provoquer un trap. Ce simulateur le permet, mais vous devriez prendre l'habitude de garder les mots alignés sur 4 octets.

Syntaxe des instructions de lecture et d'écriture

lw t0, 0(a1) # t0 = mémoire à l'adresse a1
sw t0, 4(a1) # mémoire à l'adresse a1+4 = t0

Dans offset(register), le petit nombre de décalage est ajouté à l'adresse contenue dans le registre. 0(a1) est l'adresse dans a1 elle-même, et 4(a1) est 4 octets après. Cela vous permet d'atteindre des valeurs proches sans changer le registre de base.

Stockage en mémoire

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

Les registres et la mémoire commencent à zéro.

Dans l'animation, le registre de base a0 reste identique. Seul le décalage littéral écrit dans l'instruction augmente, se déplaçant vers l'adresse mémoire cible suivante. Pour créer une mémoire qui correspond à ce schéma, réservez de la mémoire nommée dans la section data avec .word (une ou plusieurs valeurs 32 bits) ou .space N (N octets vides). Chaque mot fait 4 octets, donc les éléments consécutifs se trouvent aux décalages 0, 4, 8, qui sont les mêmes nombres utilisés dans vos instructions de store.

Utilisez .word (une ou plusieurs valeurs 32 bits) ou .space N (N octets vides) pour réserver de la mémoire nommée dans la section data. Chaque mot occupe 4 octets, donc les éléments consécutifs sont aux décalages 0, 4, 8, etc.

Somme d'un tableau en mémoire

.data
nums: .word 10, 20, 30, 40 # quatre mots
.text
la t1, nums # t1 = adresse du tableau
li t2, 4 # compteur
li t0, 0 # somme courante
loop:
  beq t2, zero, done
  lw  t3, 0(t1) # charge l'élément courant
  add t0, t0, t3 # ajoute à la somme
  addi t1, t1, 4 # avance au mot suivant (4 octets)
  addi t2, t2, -1 # un de moins
  j loop
done:
  mv a0, t0 # affiche le total (100)
  li a7, 1
  ecall
  li a7, 10
  ecall

place l'adresse du tableau dans t1, t2 compte les 4 éléments restants, et t0 contient la somme courante. À chaque passage, arrête la boucle quand il ne reste plus d'éléments. charge l'élément pointé par t1, l'ajoute à la somme, avance le pointeur d'un mot, et réduit le compteur. Après les quatre éléments (10 + 20 + 30 + 40), done affiche 100.

💡

Utilisez le bouton bascule HEX/DEC dans la barre d'outils du simulateur pour changer l'affichage des adresses et des valeurs. Choisissez la base qui rend l'étape en cours plus facile à suivre.

Ouvrir dans Litessera Lux, l'assembleur RISC-V Offrez-moi un café