Quelques questions simples à propos de mips et de la mémoire?

Question

Je suis un étudiant qui apprend des mips et j'ai quelques questions sur le fonctionnement de l'accès mémoire et du chargement.

Dans notre premier devoir nous sont donnés cette macro à utiliser

sw $a0, numargs 
lw $t0, 0($a1) 
sw $t0, arg1 
lw $t0, 4($a1) 
sw $t0, arg2 
lw $t0, 8($a1) 
sw $t0, arg3 

Le travail de cette macro est d'obtenir les arguments que nous charge dans MIPS. Ça marche, mais j'étais plus curieux de savoir comment ça fonctionnait car le professeur ne l'a jamais vraiment expliqué et nous a juste dit de l'utiliser. Donc, dans le champ "arguments du programme", je vais entrer trois arguments. Est-ce que MIPS utilise instantanément a0 comme le nombre d'arguments et c'est pourquoi nous pouvons stocker cela dans notre propre variable?

Ensuite, chaque argument a sa propre adresse mémoire. Est-ce que le registre $ a1 combine tous les 4 derniers bits des adresses mémoire des arguments? De cette façon, nous sautons 4 bits à chaque fois pour arriver à un nouvel argument et ensuite stocker cet argument dans notre propre variable.

charger aussi mot me embrouille un peu

Par exemple, dans ce bout de code

lw $t0, arg2   
lb $t1, 3($t0)  
move $a0, $t1 
addi $v0, $0, 11 
syscall 

Il fonctionne correctement. J'ai mis à t1 pour être le dernier octet de t0 (donc le dernier caractère de l'argument) et il imprime correctement. Donc, si l'argument est 1234, il imprime 4.

Cependant lorsque je tente d'ajouter

sll $t0, $t0, 8 

après la première ligne, il ne fonctionne pas. Je ne comprends pas pourquoi. Je change $ t0 par 8 bits. Donc le dernier octet est effacé et "3" devrait être le dernier octet et ce qui est imprimé. Mais ça me donne une erreur.

Answer 1

Cette macro particulière n'est pas une pratique standard pour la programmation MIPS et n'est utile que pour cette classe particulière.

La séquence:

lw $t0, arg2 
lb $t1, 3($t0) 

ne fait pas ce que vous pensez. lw $t0, arg2 charge la valeur de mémoire à l'emplacement arg2 dans $t0. Donc, si le mot de mémoire à l'emplacement arg2 a la valeur 1024 (décimal), $t0 serait fixé à 1024.

lb $t1, 3($t0) charges l'octet de mémoire à l'adresse contenue dans $t0 et la met en $t1. Si $t0 contenait la valeur 1024, alors l'octet de mémoire à l'adresse 1024 + 3 = 1027 serait mis en $t1.

Ajout sll $t0, $t0, 8 après la lw changerait la valeur de $t0 de 1024 à 262144. Ensuite, la lb tenterait de lire l'octet de mémoire à 262144 + 3, que votre programme est probablement pas autorisé à lire.