ARM usa una arquitectura de Load (cargando datos en un registro desde la memoria)

y Store (almacenando datos desde un registro a la memoria.), lo que significa que las
instrucciones sin Carga y sin Almacenamiento (como ADD) solo pueden operar en valores
en los registros. Hay varias maneras de cargar y almacenar datos desde o a la
memoria, los más simples son: cargar para registro ldr y almacenar desde
registro str .
Cargar datos desde la memoria es un poco complicado porque necesitamos
hablar de direcciones. Estas direcciones se pueden calcular de muchas maneras.
Cada uno de estos modos se llaman modos de direccionamiento. ARM tiene
registros enteros de 32 bits y las direcciones de la memoria son números de 32
bits. Esto significa que podemos mantener una dirección dentro de un
registro. Cuando tenemos una dirección dentro de un registro podemos usar ese
registro para Cargar o Almacenar algún dato. Podemos entonces definir datos y
adjuntar alguna etiqueta a su dirección y garantizar que el almacenamiento al que
hace referencia la etiqueta tenga el tamaño y el valor adecuados. Los datos viven
en la memoria como código y por lo general se mantienen juntos en lo que se
llama una sección de datos Por ejemplo la directiva “.data “ le dice al
ensamblador que emita las entidades en la sección de datos.

Load

/ * - load01 . s * /
1
2
/ * - Sección de datos * /
3
.datos
4
5
/ * Asegúrese de que la variable tenga 4 bytes alineados * /
6
. Balign 4
7
/ * Definir almacenamiento para myvar1 * /
8
myvar1 :
9
/ * El contenido de myvar1 es solo 4 bytes que contiene el valor '3' * /
10
. palabra 3
11
/ * Asegúrese de que la variable tenga 4 bytes alineados * /
. Balign 4
12
/ * Definir almacenamiento para myvar2 * /
myvar2:
13
/ * Los contenidos de myvar2 son solo 4 bytes que contienen el valor '4' * /
. palabra 4
14
/ * - Sección de código * /
15
.texto
16
/ * Asegúrese de que el código esté alineado a 4 bytes * /
. Balign 4
17
. principal global
principal :
18
ldr r1 , addr_of_myvar1 / * r1 ← y myvar1 * /
ldr r1 , [ r1 ] / * r1 ← * r1 * /
19
ldr r2 , addr_of_myvar2 / * r2 ← y myvar2 * /
 ldr r2 , [ r2 ] / * r2 ← * r2 * /
20 agregar r0 , r1 , r2 / * r0 ← r1 + r2 * /
bx lr
21
/ * Etiquetas necesarias para acceder a los datos * /
22 addr_of_myvar1 :. palabra myvar1
addr_of_myvar2 :. palabra myvar2
23

24

25

26

27

28

29

30

31

32

33

34

35

36

Almacenamiento

1 / * - store01 . s * /
2
3 / * - Sección de datos * /
4 .datos
5
6 / * Asegúrese de que la variable tenga 4 bytes alineados * /
7 . Balign 4
8 / * Definir almacenamiento para myvar1 * /
9 myvar1 :
10 / * El contenido de myvar1 es solo '3' * /
11 . palabra 0
 12
13 / * Asegúrese de que la variable tenga 4 bytes alineados * /
14 . Balign 4
15 / * Definir almacenamiento para myvar2 * /
myvar2 :
dieciséis / * El contenido de myvar2 es solo '3' * /
17 . palabra 0
18
19 / * - Sección de código * /
20 .texto
21
22 / * Asegúrese de que la sección de función comienza 4 bytes alineados * /
23 . Balign 4
24 . principal global
25 principal :
26 ldr r1 , addr_of_myvar1 / * r1 ← y myvar1 * /
27 mov r3 , # 3 / * r3 ← 3 * /
28 str r3 , [ r1 ] / * * r1 ← r3 * /
29 ldr r2 , addr_of_myvar2 / * r2 ← y myvar2 * /
30 mov r3 , # 4 / * r3 ← 4 * /
31 str r3 , [ r2 ] / * * r2 ← r3 * /
32
33 / * Mismas instrucciones que las anteriores * /
34 ldr r1 , addr_of_myvar1 / * r1 ← y myvar1 * /
35 ldr r1 , [ r1 ] / * r1 ← * r1 * /
36 ldr r2 , addr_of_myvar2 / * r2 ← y myvar2 * /
37 ldr r2 , [ r2 ] / * r2 ← * r2 * /
38 agregar r0 , r1 , r2
39 bx lr
40
41 / * Etiquetas necesarias para acceder a los datos * /
42 addr_of_myvar1 :. palabra myvar1
43 addr_of_myvar2 :. palabra myvar2
44