Guı́a de trabajos prácticos de TD2

M. Estefanı́a Pereyra

6 de junio de 2022

Trabajo Práctico: programación en assembler de ARM

Herramienta de simulacion VisUAL:
link de descarga https://salmanarif.bitbucket.io/visual/downloads.html

Ejercicio 1:
Considere el siguiente código escrito en lenguaje de alto nivel C. Asumir que las variables enteras
(signadas) g y h están en los registros R0 y R1, respectivamente:

1. i f ( g>=h )
g = g+h ;
else
g = g−h ;

2. i f ( g<h )
h = h+1;
else
h = h∗2;

a) Escriba el código equivalente en lenguaje ensamblador de ARM asumiendo que la ejecución

condicional solo esta disponible para instrucciones de salto.

b) Escriba el código equivalente en lenguaje ensamblador de ARM asumiendo ejecución condicional

en todas las instrucciones.

c) Compare la diferencia en densidad de código ( número de instrucciones) entre (a) y (b).

Solución

; ==============================
; E j e r c i c i o 1 . 1 ( a ) y ( b ) en VisUAL
; R0=g , R1=h
; ==============================
mov R0,#4 ; R0 = g
mov R1,#5 ; R1 = h
; Modo1A : usando saltos condicionales
cmp R0 , R1 ; g>=h ?
blt else
add R0 , R0 , R1 ; g=g+h
b modo1B
else sub R0 , R0 , R1 ; g=g−h

; Modo1B : usando i n s t r u c c i o n e s c o n d i c i o n a l e s

modo1B cmp R0 , R1 ; g>=h?

addge R0 , R0 , R1 ; g=g+h
sublt R0 , R0 , R1 ; g=g−h
end
; ==============================

1
Ejercicio 2:
Realizar un programa que sume dos números de 64 bits cada uno, guardando el resultado en R5 R6
(64bits), los números a sumar estarán dispuesto en R1 R2(64bits) y R3 R4(64bits) respectivamente.

Solución

; ==============================
; E j e r c i c i o 2 en VisUAL
; suma de dos numeros de 64 b i t s
; R1 y R2 forman num1 , R3 y R4 forman num2
; ==============================

; CONTANTES
; ==============================

NUM11 dcd 0x1231AAAA ; d e c l a r a en memoria un dato de t i p o word

NUM12 dcd 0 xB3423433
NUM21 dcd 0 xFF232323
NUM22 dcd 0 x23323111

; CODE
; ==============================

mov r0 , #NUM11 ; c a r g a en R0 l a d i r e c c i o n de memoria de NUM11

ldr r1 , [ r0 ] ; l e e e l c o n t e n i d o de NUM11
mov r0 , #NUM12
ldr r2 , [ r0 ]
mov r0 , #NUM21
ldr r3 , [ r0 ]
mov r0 , #NUM22
ldr r4 , [ r0 ]

adds r5 , r1 , r 3 ; suma l a s p a r t e s b a j a s de l o s num de 64 b i t s y a f e c t a l a s b a n d e r a s ( s )

adc r6 , r2 , r 4 ; suma l a s p a r t e s a l t a s de l o s num de 64 b i t s mas e l a c a r r e o

end
; ==============================

Ejercicio 3:
Realizar un programa que analizando un bit en el registro R3 active una alarma si este bit es 0, el
nro de bit a analizar está guardado en el registro R4, la alarma se activa escribiendo un 1 en el bit 16
de R6.

Solución

; ==============================
; Ejercicio en VisUAL
; TEST CODE
; ==============================
mov r3 , #0b1101 ; r e g i s t r o a ser analizado
mov r4 , #1 ; verifica el bit 1
mov r6 , #0 ; r e g i s t r o s a l i d a de alarma

mov r0 , #0x01 ; registro auxiliar

l s l r0 , r0 , r 4 ; pone en 1 e l b i t 1 de r 0

and r3 , r3 , r 0 ; verifica el bit 2

cmp r3 , #0 ; compara que s e a c e r o o no
bne salir ; s i no e s 0 s a l e
mov r0 , #1 ; s i e s 0 i n i c i a l i z a r e g a u x i l i a r con 1
orr r6 , r6 , r0 , l s l #16 ; y a c t i v a l a alarma p o n i e n d o 1 en e l b i t 16 de r 6

salir end
; ==============================

Ejercicio 4:
Convertir el siguiente código escrito en lenguaje de alto nivel C a código assembler de ARM. Asumir
que las variables enteras var y num están en los registros R0 y R1, respectivamente:

2
 s w i t c h ( var ) {
case 1: num = num∗ 2 ;
break ;
case 2: num = num∗ 4 ;
break ;
case 3: num = num∗ 8 ;
break ;
d e f a u l t : num = −1;
}

Solución

; ==============================
; E j e r c i c i o 4 en VisUAL
; estructura switch case
; R0=var , R1=num
; ==============================

mov R0,#4 ; i n i c i a l i z a v a r con un numero c u a l q u i e r a

mov R1,#2 ; i n i c i a l i z a num ( s i m u l a r con d i f e r e n t e s v a l o r e s )

comp1 cmp R0,#1 ; case 1

bne comp2
lsl R1 , R1,#1 ; num = num∗2
b salir

comp2 cmp R0,#2 ; case 2

bne comp3
lsl R1 , R1,#2 ; num = num∗4
b salir

comp3 cmp R0,#3 ; case 3

bne default
lsl R1 , R1,#3 ; num = num∗8
b salir

d e f a u l t mov R0,#−1 ; default

salir end
; ==============================

Ejercicio 5:
Convertir el siguiente código escrito en lenguaje de alto nivel C a código assembler de ARM. Asumir
que las variables enteras num y count están en los registros R0 y R1, respectivamente:
num = 2 0 ;
count = 0 ;
w h i l e (num>1){
num = num/ 2 ;
count = count + 1 ;
}

Solución

; ==============================
; E j e r c i c i o 5 en VisUAL ,
; estructura while .
; R0=num , R1=count
; ==============================

mov R0,#10 ; i n i c i a l i z a num con un numero c u a l q u i e r a

mov R1,#0 ; i n i c i a l i z a e l c o n t a d o r en 0

loop cmp R0,#1

ble salir
lsr R0 , R0,#1 ; num = num/2
add R1 , R1,#1
b loop

3
salir end
; ==============================

Ejercicio 6:
Realizar un programa que sume los primeros 100 números naturales.

Solución

; ==============================
; Codigo en C ( ayuda )
; ==============================
sum = 0 ;
f o r ( i =0; i <100; i ++){
sum = sum + i ;
}
; ==============================

; ==============================
; E j e r c i c i o 6 en VisUAL ,
; estructura for .
; R0=i , R1=sum
; ==============================

mov R0,#0 ; i n i c i a l i z a i en 0
mov R1,#0 ; i n i c i a l i z a sum en 0

loop cmp R0,#100

bge salir
add R1 , R1 , R0 ; sum = sum+i acumulador
add R0 , R0,#1 ; i++
b loop

salir end
; ==============================

Ejercicio 7:
Realizar un programa que copie el contenido de un vector almacenado en memoria en otro vector,
asumiendo que este segundo vector tiene asignado el espacio suficiente en memoria para almacenar los
datos. Considere el código escrito en C como guı́a:
int i ;
int array1 [ 1 0 0 ] ;
int array2 [ 1 0 0 ] ;

f o r ( i =0; i <100; i=i +1)

array1 [ i ] = array2 [ i ] ;

a) Escriba el código equivalente en lenguaje ensamblador de ARM sin utilizar ningún tipo de
direccionamiento, actualizando el registro base de dirección Rn .

b) Escriba el código equivalente en lenguaje ensamblador de ARM utilizando algún tipo de direc-
cionamiento, pre o post indexado o direccionamiento por corrimiento.

c) Compare la diferencia en densidad de código ( número de instrucciones) entre (a) y (b).

Solución
a) ; ==============================
; E j e r c i c i o 7 en VisUAL ,
; copiar vectores
; R0 = i , R1=d i r e c c i o n a r r a r y 1 , R2=d i r e c c i o n a r r a y 2 , R3=aux
; ==============================

; D e c l a r a c i o n de Datos en memoria
; ==============================

4
 array2 dcd 1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10 ; d e c l a r a v e c t o r de 10 elem de t i p o word en memoria
array1 f i l l 40 ; r e s e r v a 40 b y t e s de e s p a c i o en memoria ( 1 0 word )

; Codigo
; ==============================

mov R0,#0 ; inicializa i

ldr R1,= a r r a y 1 ; l e e l a d i r e c c i o n en memoria de a r r a y 1
ldr R2,= a r r a y 2 ; l e e l a d i r e c c i o n en memoria de a r r a y 2

for cmp R0,#10

bge salir
ldr R3 , [ R2 ] ; l e e e l dato almacenado en l a d i r e c c i o n apuntada por R2
str R3 , [ R1 ] ; e s c r i b e e l dato de R3 en l a d i r e c c i o n apuntada por R1
add R2 , R2,#4 ; i n c r e m e n t a l a d i r e c c i o n de R2 para a p u n t a r
; a l s i g u i e n t e elemento
add R1 , R1,#4 ; i n c r e m e n t a l a d i r e c c i o n de R1 para a p u n t a r
; a l s i g u i e n t e e s p a c i o en memoria l i b r e
add R0 , R0,#1
b for

salir end
; ==============================

b)
; D e c l a r a c i o n de Datos en memoria
; ==============================
a r r a y 2 dcd 1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10 ; d e c l a r a v e c t o r de 10 elem de t i p o word en memoria
array1 f i l l 40 ; r e s e r v a 40 b y t e s de e s p a c i o en memoria ( 1 0 word )

; Codigo
; ==============================

mov R0,#0 ; inicializa i

ldr R1,= a r r a y 1 ; l e e l a d i r e c c i o n en memoria de a r r a y 1
ldr R2,= a r r a y 2 ; l e e l a d i r e c c i o n en memoria de a r r a y 2

for cmp R0,#10

bge salir
ldr R3 , [ R2] ,#4 ; l e e e l dato almacenado en l a d i r e c c i o n apuntada por R2
; y l u e g o a c t u a l i z a R2=R2+4. D i r e c c i o n a m i e n t o pos t −i n d e x a d o .
str R3 , [ R1] ,#4 ; e s c r i b e e l dato de R3 en l a d i r e c c i o n apuntada por R1
; y l u e g o a c t u a l i z a R1=R1+4. D i r e c c i o n a m i e n t o pos t −i n d e x a d o .
add R0 , R0,#1
b for

salir end
; ==============================

Ejercicio 8:
Realizar un programa que calcule el promedio de los elementos almacenados en memoria en un
vector denominado VECT. Los elementos son de tipo word y el tamano del vector es 8. El resultado
delpromedio guardarlo en memoria luego de VECT.

Ejercicio 9:
Realizar un programa que busque en un vector VECT el mayor de sus elemento. Donde V ECT =
[1, 3, 6, 7, 12, 34, 5, 76, 2, 0].

Ejercicio 10:
Realizar un programa que sume los word de un vector VECTW sin signo en las posiciones indicadas
por un segundo vector VECTB de 20 byte,el resultado guardarlo en R1.
ejemplo
VECTB = 1,3,2,0,2......
VECTW = 1,111,222,333,444,555,666,......
se suman 111+333+222+1+222...

5
Ejercicio 11:
Realizar un programa que dada una cadena con terminación nula guardada en VECT, la pase a
mayúscula, guardando el resultado en el mismo vector VECT. nota:la cadena de entrada solo contendrá
valores alfabéticos o espacio en blanco (’a’ - ’z’,’A’ - ’Z’).

Solución

; ==============================
; E j e r c i c i o 11 en VisUAL ,
; p a s a r a mayusculas
; R0=d i r e c c i o n v e c t , R1=c a r a c t e r , r e c o r d a r ’ a ’ − ’A’=0 x20
; ==============================

; D e c l a r a c i o n de Datos en memoria
; ==============================
vect dcb ’h ’ , ’ o ’ , ’ l ’ , ’ a ’ ,0 ; d e c l a r a cadena de c a r a c t e r e s con t e r m i n a c i o n n u l a
; cada c a r a c t e r ocupa 1 b y t e en memoria , i n s t r u c c i o n DCB
; Codigo
; ==============================
ldr R0,= v e c t ; l e c t u r a de l a d i r e c c i o n d e l v e c t o r

loop ldrb R1 , [ R0 ] ; l e c t u r a de un c a r a c t e r , LDRB para l e c t u r a de dato de 1 b y t e

cmp R1,#0 ; s a l i r con c a r a c t e r n u l o
beq salir

cmp R1 , ’ a ’
subhs R1 , R1,#0 x20 ; c o n v i e r t e a mayuscula
strbhs R1 , [ R0 ] ; e s c r i t u r a de c a r a c t e r en memoria , STRB para dato de 1 b y t e
add R0 , R0,#1 ; i n c r e m e n t a en 1 b y t e e l p u n t e r o d e l v e c t o r
b loop

salir end

; ==============================

Ejercicio 12:
Dado un vector de 16 words con signo, realizar un programa que encuentre el elemento del vector
mas cercano a la media del mismo.

Ejercicio 13:
Realizar una serie de subrutinas que realicen diferentes comparaciones, devolviendo R0 = 0 si estas
comparaciones fueron falsas y R0 = 1 si fueron verdaderas, las comparaciones son las siguientes.

R1 < 100 y R1 > 20

R1 < 100 o R2 > 20

R1 = 10 o R1 = 15 o R1 = 20

R1 = 10 y R2 = 15 y R3 = 20

nota: los datos en R1, R2, y R3 pueden estar inicializados al comienzo del programa o ser leı́dos
de variables almacenadas en memoria.

Solución

; ==============================
; E j e r c i c i o 13 en VisUAL ,
; llamado a f u n c i o n e s
; R0=0/1 v a l o r de r e t o r n o , R1=num1 , R2=num2 , R3=num3
; ==============================

mov R1,#10 ; inicializa l o s r e g i s t r o s con d a t o s ( p a r a m e t r o s de l a s f u n c )

mov R2,#45

6
 mov R3,#−20

bl func1 ; llamado a funcion 1

bl func2 ; llamado a funcion 2
bl func3 ; llamado a funcion 3
bl func4 ; llamado a funcion 4
end

; d e c l a r a c i o n de f u n c i o n e s
; ==============================
func1 mov R0,#0 ; R1<100 AND R1>20 , c u a l q u i e r a que no s e cumpla s a l e r e t o r n a n d o R0=0
cmp R1,#100
bge salir1
cmp R1,#20
ble salir1
mov R0,#1
s a l i r 1 mov PC, LR ; i n s t r u c c i o n de r e t o r n o a l a f u n c i o n l l a m a d o r a

func2 mov R0,#1 ; R1<100 OR R1>20 , c u a l q u i e r a que s e cumpla s a l e r e t o r n a n d o R0 =1

cmp R1,#100
blt salir2
cmp R1,#20
bgt salir2
mov R0,#0
salir2 mov PC, LR ; i n s t r u c c i o n de r e t o r n o a l a f u n c i o n l l a m a d o r a

func3 mov R0,#1 ; R1==10 OR R1==15 OR R1==20, c u a l q u i e r a que s e cumpla s a l e con R0=1
cmp R1,#10
beq salir3
cmp R1,#15
beq salir3
cmp R1,#20
beq salir3
mov R0,#0
salir3 mov PC, LR ; i n s t r u c c i o n de r e t o r n o a l a f u n c i o n l l a m a d o r a

func4 mov R0,#0 ; R1==10 AND R2==15 AND R3==20, c u a l q u i e r a que no s e cumpla s a l e con R0=0
cmp R1,#10
bne salir4
cmp R2,#15
bne salir4
cmp R3,#20
bne salir4
mov R0,#1
s a l i r 4 mov PC, LR ; i n s t r u c c i o n de r e t o r n o a l a f u n c i o n l l a m a d o r a
; ==============================

Ejercicio 14:
a) Escriba una función en C para buscar un número con signo en un vector de WORDS:
i n t findNumber ( i n t a r r a y [ ] , i n t s i z e , i n t number )

Donde size: es el tamaño del vector, array: especifica la dirección base del vector y number :
número que se desea buscar. La función retorna el ı́ndice donde se encuentra por primera vez el
número en el vector. Si el número no se encuentra en el vector retorna −1.

b) Escriba el código equivalente de la función en lenguaje ensamblador de ARM.

c) Realice un programa en lenguaje ensamblador de ARM que utilice la función findNumber para
buscar un número almacenado en memoria en un vector de 16 words también almacenado en
memoria.

Solución
a) i n t findNumber ( i n t a r r a y [ ] , i n t s i z e , i n t number ) {
int i ;
f o r ( i =0; i <s i z e ; i ++)
i f ( a r r a y [ i ] == number )
return i ;

7
 r e t u r n −1;
}

b) ; d e c l a r a c i o n de f u n c i o n findNumber
; R0=d i r e c c i o n a r r a y , R1=s i z e , R2=number , R3=aux , R4=i
; ==============================

findNumber stmfd SP ! , { R4}

mov R4,#0
otro cmp R4 , R1
moveq R0,#−1
beq salir

ldr R3 , [ R0 , R4 , l s l #2]
cmp R3 , R2
moveq R0 , R4
beq salir

add R4 , R4,#1
b otro
salir ldmfd SP ! , { R4}
mov PC, LR

c) ; f u n c i o n p r i n c i p a l que hace uso de findNumber

; ==============================

; d e c l a r a c i o n de d a t o s
; ==============================
array dcd 4 ,1 ,3 ,5 ,36 ,89 ,53 ,68 ,966 ,43
size dcd 10

; programa p r i n c i p a l que l l a m a a l a f u n c i o n findNumber

; R0=d i r e c c i o n de a r r a y , R1=tamano de a r r a y , R2=num a b u s c a r
; ==============================

ldr R0,= a r r a y
ldr R1,= s i z e
ldr R1 , [ R1 ]
mov R2,#5
bl findNumber
end
; ==============================

Ejercicio 15:
La función strcpy copia una cadena de caracteres src a una cadena de caracteres dst.
void strcpy ( char dst [ ] , char s r c [ ] ) {
int i = 0;
do{
dst [ i ] = src [ i ] ;
} w h i l e ( s r c [ i ++]);
}

a) Implemente la función strcpy en lenguaje ensamblador de ARM. Use el registro R4 para i.

b) Diagrame la estructura del stack antes, durante y luego del llamado a la función strcpy. Asumir
SP = 0xBEF F F 000 justo antes de la llamada a la función strcpy.

Ejercicio 16:
Sea una función cuyo prototipo en un lenguaje de alto nivel es el siguiente:
v o i d notaMayor ( i n t n o t a s P r i m e r o [ ] , i n t notasSegundo [ ] , i n t notasMayores [ ] , i n t s i z e )

8
Donde size: es el tamaño de los vectores, notasPrimero: especifica la dirección base del vector de notas
del primer parcial, notasSegundo: especifica la dirección base del vector de notas del segundo parcial,
notasMayores: especifica la dirección base del vector que contendrá la mayor de las dos notas de cada
alumno. La función compara elemento a elemento los vectores de notas del primer y segundo parcial
y guarda en un tercer vector la mayor de las dos notas.

a) Escriba el código de la función notaMayor en lenguaje ensamblador de ARM. Nota: se disponde

de una función precodificada mayor que recibe dos números y retorna el mayor de ellos.

b) Realice un programa en lenguaje ensamblador de ARM que utilice la función notaMayor con la
declaracion de los vectores notasPrimero y notasSegundo en memoria. Reservar en espacio en
memoria para el vector notasMayores.

c) Escriba el código de la función mayor.

Solución
a) ; d e c l a r a c i o n de f u n c i o n notaMayor ( f u n c i o n n o n l e a f )
; R0=a y R1=b s e r a n p a r a m e t r o s de l a f u n c i o n c=mayor ( a , b ) ,
; R4=d i r e c c i o n n o t a s P r i m e r o , R5=d i r e c c i o n notasSegundo
; R2=d i r e c c i o n notasMayores , R3=s i z e
; ==============================
notaMayor stmfd SP ! , { R4 , R5 , LR} ; l o s r e g i s t r o s p r e s e r v a d o s deben g u a r d a r s e en e l s t a c k
; a n t e s de s e r u s a d o s por l a f u n c i o n
mov R4 , R0
mov R5 , R1

for cmp R3,#0

beq salirNotaMayor
ldr R0 , [ R4] ,#4
ldr R1 , [ R5] ,#4
stmfd SP ! , { R2 , R3} ; l o s r e g i s t r o s no p r e s e r v a d o s que s e r a n u s a d o s l u e g o d e l
; l l a m a d o a l a f u n c i o n ’ mayor ’ deben p r e s e r v a r s e en e l s t a c k
bl mayor
ldmfd SP ! , { R2 , R3} ; r e c u p e r a l o s r e g i s t r o s no p r e s e r v a d o s a n t e s de u t i l i z a r l o s
str R0 , [ R2] ,#4
sub R3 , R3,#1
b for
s a l i r N o t a M a y o r ldmfd SP ! , { R4 , R5 , LR} ; r e c u p e r a l o s r e g i s t r o s p r e s e r v a d o s a n t e s de r e t o r n a r
mov PC, LR ; c o p i a l a d i r e c c i o n de r e t o r n a en e l PC
; ==============================

b) ; f u n c i o n p r i n c i p a l que hace uso de l a f u n c i o n notaMayor

; R0=d i r e c c i o n de n o t a s P r i m e r o , R1=d i r e c c i o n de notasSegundo , R2=notasMayores , R3=s i z e
; ==============================
notasPrimero dcd 6 ,7 ,9 ,5
notasSegundo dcd 3 ,4 ,7 ,8
notasMayores fill 16
size dcd 4

ldr R0,= n o t a s P r i m e r o
ldr R1,= notasSegundo
ldr R2,= notasMayores
ldr R3,= s i z e
ldr R3 , [ R3 ]
bl notaMayor
end
; ==============================

c) ; f u n c i o n mayor ( f u n c i o n l e a f ) ,
; R0=a , R1=b , R0=c
; ==============================
mayor cmp R0 , R1
movlt R0 , R1
mov PC, LR
; ==============================

9
Ejercicio 17:
Considere el código en lenguaje ensamblador de ARM siguiente. Las funciones func1, func2, func3
son funciones no hojas (llaman a otras funciones) y la función func4 es una función hoja. No se
muestra el código de cada función, se indica mediante un comentario qué registros se utilizan durante
el llamado de cada una.
0 x00091000 func1 : ; f u n c 1 usa R4−R10
...
0 x00091020 BL f u n c 2
...
0 x00091100 func2 : ; f u n c 2 usa R0−R5 . (R0−R3 a n t e s d e l llamado a f u n c 3 )
...
0 x0009117C BL f u n c 3
...
0 x00091400 func3 : ; f u n c 3 usa R3 , R7−R9 . (R3 a n t e s d e l llamado a f u n c 4 )
...
0 x00091704 BL f u n c 4
...
0 x00093008 func4 : ; f u n c 4 usa R11−R12
...
0 x00093118 MOV PC, LR

a) Cuantas palabras tiene el bloque de stack correspondiente a cada función.

b) Diagrame la estructura del stack luego del llamado a la función func4. Indique qué registros
están almacenados en el stack y señale cada bloque del stack correspondiente a cada función.
Asumir SP = 0xBF F F F F 04 justo antes de la llamada a la primera función.

Solución:
Dirección Datos
b)Stack antes del llamado a las funciones: SP = 0xBF F F F F 04→ Dato desconocido

Dirección Datos
0xBF F F F F 04 Dato desconocido 
0xBF F F F F 00 LR = ? 

0xBF F F F EF C R10




0xBF F F F EF 8 R9




0xBF F F F EF 4 R8


0xBF F F F EF 0 R7 stack frame func1, 8 palabras


0xBF F F F EEC R6 



0xBF F F F EE8 R5 

Stack luego del llamado a la función func4 : 

0xBF F F F EE4 R4 

0xBF F F F EE0 LR = 0x00091024 )
0xBF F F F EDC R5 stack frame func2, 3 palabras
0xBF F F F ED8 R4
0xBF F F F ED4 LR = 0x00091180 

0xBF F F F ED0 R9

stack frame func3, 4 palabras
0xBF F F F ECC R8 

0xBF F F F EC8 R7
SP = 0xBF F F F EC4 R11 } stack frame func4, 1 palabras

Ejercicio 18:
Dada una cadena de caracteres con terminación nula la cual contiene palabras separadas por
espacio, codificar en assembler de ARM una función denominada aminuscula, que pase a minúscula
todas las letras con excepción de la primera de cada palabra que deberá ser pasada a mayúscula,
además, las palabras de menos de 3 letras deberán quedar en minúscula.
Ejemplo:
entrada
VECT = ”El mUndo dE Hoy”,0
salida

10
 VECT = ”el Mundo de Hoy”,0
La función aminuscula recibe como parámetro la dirección base de la cadena de caracteres y no
tiene ningún valor de retorno, los datos se sobrescriben en la cadena original.

Ejercicio 19:
Considere el siguiente código en lenguaje de alto nivel C:
i n t func ( i n t n , i n t k ){
int b;
b = k +2;
i f ( n == 0 )
b=10;
else
b=b+n+f u n c ( n−1 ,k +1);
return b ;
}

a) Implemente la función func en lenguaje ensamblador de ARM. Use el registro R4 para almacenar
b.

b) Simular el llamado de la función con los siguientes parámetros iniciales: func(2,4). Cuál es el
valor final de R0?

c) Diagrame la estructura de stack antes, durante y luego del llamado a la función finc(2,4). Asumir
SP=0xBFF00100 justo antes del llamado a la función func.

Ejemplos de código:
; ==============================
; Buscar e l Mayor d e n t r o de un v e c t o r de b y t e s s i n s i g n o y l o almacena en r 3
; ==============================

VECT dcb 10 ,30 ,200 ,40 ,50 ,60 ,70 ,80

mov r0 ,#8
ldr r1 ,=VECT
l d r b r3 , [ r 1 ] ,#1
s u b s r0 , r0 ,#1
beq salir
otro l d r b r2 , [ r 1 ] ,#1
cmp r3 , r 2
bge nomayor
mov r3 , r 2
nomayor s u b s r0 , r0 ,#1
bne o t r o
salir end

; ==============================
; Guarda en r 4 l a l o n g i t u d de l a p a l a b r a mas l a r g a
; ==============================

VECT dcb ’h ’ , ’ o ’ , ’ l ’ , ’ a ’ , ’ ’ , ’m’ , ’ u ’ , ’ n ’ , ’ d ’ , ’ o ’ , ’ ’ , ’d’ , ’ e ’ , ’ ’ , ’h’ , ’ o ’ , ’y ’ ,0

mov r4 ,#0
ldr r1 ,=VECT
mov r3 ,#0
otro ldrb r2 , [ r 1 ] ,#1
cmp r2 ,#0
beq salir
cmp r2 ,# ’ ’
beq espacio
add r3 , r3 ,#1
b otro
e s p a c i o cmp r3 , r 4
movgt r4 , r 3
mov r3 ,#0
b otro

11
salir cmp r3 , r 4
movgt r4 , r 3
end

12