Qual è la differenza tra = etichetta (segno di uguale) e [etichetta] (parentesi) nell'assemblaggio ARMv6?

Question

Sto seguendo il corso Baking Pi dall'Università di Cambridge, in cui un semplice sistema operativo è integrato nel set di istruzioni ARMv6, destinato al Raspberry Pi.

Abbiamo utilizzato due metodi per caricare i dati nei registri tramite l'istruzione ldr e ora mi rendo conto che li sto utilizzando insieme, non capisco perfettamente cosa fanno entrambi.

le cose in modo che ho usato come ldr r0,=0x20200000, che io in realtà intesa come "leggere i dati memorizzati nella posizione di memoria 0x20200000 nel registro R0

cose allora ho usato come:.

ldr r0,[r1,#4] 

che ho capito come "leggere i dati memorizzati presso l'indirizzo di memoria puntato da r1, a un offset di 4 byte, nel registro r0"

Poi ho incontrato questo:.

ldr r0,=pattern 
ldr r0,[r0] 

pattern ecco un .int nella sezione .data (un bitmap che rappresenta una sequenza di stati ON/OFF per un LED). Mi rendo conto, leggendo questo, che la mia precedente comprensione di =foo deve essere errata, altrimenti entrambe le istruzioni di cui sopra farebbero la stessa cosa.

è il =x sintassi fondamentalmente più simile a un puntatore in C, mentre la sintassi [x] è come se la memoria che viene puntato da x è effettivamente leggere?

Diciamo che ptr nella C di seguito è un int*, i miei commenti che pensano all'assemblaggio equivalente (concettualmente, non letteralmente) hanno senso?

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: 

significa caricare l'indirizzo dell'etichetta qualcosa nella r0 registro. L'assemblatore poi aggiunge una parola da qualche parte a portata di mano delle istruzioni LDR e lo sostituisce con un

ldr r0,[pc,#offset] 

istruzioni

Quindi questo collegamento

ldr r0,=0x12345678 

significa carico 0x12345678 in R0.

essendo principalmente istruzioni a lunghezza fissa, non è possibile caricare immediatamente un intero 32 bit in un registro in un'unica istruzione, può essere necessario un numero di istruzioni per caricare completamente un registro con un numero a 32 bit. Dipende molto dal numero. Per esempio

ldr r0,=0x00010000 

otterrà sostituito dal assemblatore GNU con un unico r0 istruzione MOV, # 0x00010000 se si tratta di un'istruzione ARM, per un'istruzione pollice anche se può ancora essere LDR R0, [pc, # offset]

Questi ldr rd, = le cose sono una scorciatoia, istruzioni pseudo, non reali.

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

sono istruzioni reali e intendo leggere dalla memoria all'indirizzo rm + offset o rm + rn e prendere il valore letto e metterlo in rd registro

l'= qualcosa è più simile & qualcosa in C .

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

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

e nell'assemblaggio

something: 
    .word 0 

ldr r0,=something 
ldr r1,[r0]