Quelle est la différence entre = label (signe égal) et [label] (parenthèses) dans l'assemblage ARMv6?

Question

Je suis avec le cours Baking Pi de l'Université de Cambridge, dans lequel un système d'exploitation simple est construit dans le jeu d'instructions ARMv6, ciblant le Raspberry Pi.

Nous avons utilisé deux façons de charger des données dans des registres via l'instruction ldr jusqu'à présent et je me rends compte maintenant que je les utilise ensemble, je ne comprends pas complètement ce qu'ils font tous les deux.

J'ai utilisé des choses comme ldr r0,=0x20200000, que je réellement compris comme « lire les données stockées à l'emplacement de mémoire 0x20200000 dans r0 registre

J'ai utilisé des choses comme:.

ldr r0,[r1,#4] 

ce que j'ai compris comme étant « lire les données stockées à l'adresse de mémoire pointée par r1, à un décalage de 4 octets, dans le registre r0 »

Puis je rencontre ceci:.

ldr r0,=pattern 
ldr r0,[r0] 

pattern est ici un .int dans la section .data (un bitmap représentant une séquence d'états de marche/arrêt pour une LED). Je me rends compte en lisant cela, que ma compréhension précédente de =foo doit être fausse, sinon les deux instructions ci-dessus feraient la même chose.

Est-ce que la syntaxe =x ressemble plus à un pointeur en C, alors que la syntaxe [x] est comme si la mémoire pointée par x est réellement lue?

Disons ptr dans le C ci-dessous est un int*, faire mes commentaires en pensant à l'assemblage équivalent (conceptuellement, pas littéralement) ont un sens?

r0 = ptr;  /* equivalent to: ldr r0,=ptr  */ 
r0 = *ptr; /* equivalent to: ldr r0,[ptr] */ 
r0 = *(ptr+4) /* equivalent to: ldr r0,[ptr,#4] */ 

Answer 1

ldr r0,=something 
... 
something: 

signifie charger l'adresse de l'étiquette quelque chose dans le registre r0. L'assembleur ajoute un mot quelque part à la portée de l'instruction LDR et le remplace par un

ldr r0,[pc,#offset] 

instruction

Donc, ce raccourci

ldr r0,=0x12345678 

signifie la charge 0x12345678 en r0.

étant principalement des instructions de longueur fixe, vous ne pouvez pas charger un entier 32 bits immédiat dans un registre dans une instruction, il peut prendre un certain nombre d'instructions pour charger complètement un registre avec un nombre de 32 bits. Cela dépend fortement du nombre. Par exemple

ldr r0,=0x00010000 

va obtenir remplacé par l'assembleur gnu avec un r0 mov instruction unique, # 0x00010000 si elle est une instruction ARM, pour une instruction de pouce si elle peut encore avoir à être LDR r0, [pc, # offset]

Ces ldr rd, = choses sont un raccourci, pseudo instructions, pas réel.

ldr rd,[rm,#offset] 
ldr rd,[rm,rn] 

sont des instructions réelles et moyenne de lecture de la mémoire à l'adresse rm + offset ou rm + rn et prendre la valeur lue et le mettre dans le registre e

la = quelque chose est plus comme & quelque chose en C .

unsigned int something; 
unsigned int r0; 
unsigned int r1; 

r0 = &something; 
r1 = *(unsigned int *)r0; 

et dans l'assemblage

something: 
    .word 0 

ldr r0,=something 
ldr r1,[r0]