15mes0060

8/17/2019 15mes0060

1/17

Registration number: 15MES0060 Date:

EXERCISE 1

1.1 Compiling, making, debugging, and running

Writing a program in Keil. There are separate functions in Keil to compile, make, debug, and run a program.

Experiment with all four and describe what each does.

Program:

AREA PRGM1, CODE, READONLY

ENTRY

START MOV R0,#02

MOV R1,#05

ADD R1,R1,R0

END

Explanation:

Compilation:

Build button. Compile and link program using button Build or the menu Project - Rebuild all target files.

µVision starts translating and linking the source files and creates an absolute object module that can be

loaded into the µVision Debugger for testing. The status of the build process is shown in the window Build

Output.

Debug:

Once the program is compiled and linked, start testing it with the Debugger. Use the toolbar button or the

menu Debug - Start/Stop Debug Session. µVision initializes the debugger and starts testing the programuntil the end statement are reached. By default, a breakpoint has been set to stop execution there

Run:

After debugging the program the toolbar button can be used to run the given program. In this step data

transfer, data manipulation is done and we get the result. In this example immediate data is transferred to

r0,r1 in first two steps then the result of addition is stored in r1.

Output:

8/17/2019 15mes0060

2/17

1.2 Stepping and stepping in

Writing a program in Keil Instead of running the code, step all the way through the code using both the step

method and the step in method. What is the difference between the two methods of stepping through the

assembly code?

Program:

AREA PRGM1, CODE, READONLY

ENTRY

START MOV R0,#02

MOV R1,#-05

ADDS R1,R1,R0

END

Explanation:

There are two methods of stepping through assembly code either we can perform step execution or step

over. In step execution each statement is executed and corresponding output we get on the different

registers. This execution can be used for checking logical errors. Another method is step over execution inthis all steps are executed. We get the final output in this method.

Output:

8/17/2019 15mes0060

3/17


EXERCISE 2

2. 1 Signed and unsigned addition

For the following values of a and b, predict the values of the N, Z, V, and C flags produced by performing

the operation a + b. Load these values into two ARM registers to perform an addition of the two registers.

Using the debugger, record the flags after each addition and compare those results with your predictions.When the data values are signed numbers, what do the flags mean? Does their meaning change when the

data values are unsigned numbers?

Program:

area exp21, code, readonly

entry

start ldr r0, =0xffff0000

ldr r1, =0x00001234

add r0,r0,r1end

Output:

2.2 Multiplication

Change the ADD instruction in the code from the above program [2.1] to MULS. Also change one of the

operand registers so that the source registers are different from the destination register, as the convention for

multiplication instructions requires. Put 0xFFFFFFFF and 0x80000000 into the source registers. Now rerun

your program and check the result.1. Does your result make sense? Why or why not?

2. Assuming that these two numbers are signed integers, is it possible to overflow in this case?

3. Why is there a need for two separate long multiply instructions, UMULL and SMULL? Give an example

to support your answer.

Program:

Part a:

area exp22,code, readonly

entry

start ldr r0, =0xffffffffldr r1, =0x80000000

muls r2,r1,r0

end

8/17/2019 15mes0060

4/17

Output:

Part b:

Program:

area exp22,code, readonly

entry

start ldr r0, =0xffffffff

ldr r1, =0x80000000

smull r3,r2,r1,r0

umull r5,r4,r1,r0

end

Output:

8/17/2019 15mes0060

5/17


EXERCISE 3

3.1 Register-swap algorithm

The EOR instruction is a fast way to swap the contents of two registers without using an intermediate

storage location such as a memory location or another register. Suppose two values a and b are to be

exchanged. The following algorithm could be used:Write the ARM code to implement the above algorithm, and test it with the values of a = 0xF631024C and

b = 0x17539ABD. Analyze the result before and after running the program.

Program:

AREA pgm3_1, CODE, READONLY

ENTRY

START LDR R0,=0xF631024C

LDR R1,=0x17539ABD

EOR R0,R0,R1

EOR R1,R0,R1

EOR R0,R0,R1

END

Output:

Before:

After:

8/17/2019 15mes0060

6/17

3.2 Signed multiplication

Assume that a signed long multiplication instruction is not available. Write a program that performs long

multiplications, producing 64 bits of result. Use only the UMULL instruction and logical operations such as

MVN to invert, EOR, and ORR. Run the program using the two operands – 2 and – 4 to verify.

Program:

AREA EXP3_2, CODE, READONLY

ENTRYSTART

MOV R0,#-2;

MOV R1,#-4;

MOV R4,#-1

MUL R2,R0,R4

MUL R3,R1,R4

UMULL R10,R9,R2,R3

END

Output:

8/17/2019 15mes0060

7/17


EXERCISE 4

4.1 Absolute value

Write ARM assembly to perform the function of absolute value. Register r0 contains the initial value, and r1

contains the absolute value. Try to use only two instructions, not counting the SWI to terminate the program.

Program:


ENTRY

MOVS r1, #-15;

RSBLT r1, r1, #0;

END

Output:

4.2 Division

Write ARM assembly to perform the function of division. Registers r1 and r2 contain the dividend and

divisor, r3 contains the quotient, and r5 contains the remainder. For this operation, you can either use a

single shift-subtract algorithm or another more complicated one.

Program:


ENTRY

START LDR R1,=0x20

LDR R2,=0x5

MOV R3,#0

LOOP SUBS R1,R1,R2ADDGE R3,#1

BGE LOOP

ADD R1,R1,R2

MOV R5,R1

END

8/17/2019 15mes0060

8/17

Output:

4.3 Gray codes

A Gray code is an ordering of 2n binary numbers such that only one bit changes from one entry to the next.

One example of a 2-bit Gray code is b10 11 01 00. The spaces in this example are for readability. Write

ARM assembly to turn a 2-bit Gray code held in r1 into a 3-bit Gray code in r2.

Program:

AREA exp2, CODE, READONLY

ENTRY

START MOV R1,#0x000000b4

MOV R2,#0x00000003 ;this is mask of two bits

MOV R7,#0

LOOP

AND R3,R1,R2

MOV R3,R3,LSL R7ORR R5,R3,R5

MOV R2,R2,LSL #2

ADD R7,#1

CMP R7,#8

BLT LOOP

END

Output:

8/17/2019 15mes0060

9/17


EXERCISE 5

5.1 Assignments with operands in memory

Assume an array of 25 words. A compiler associates variables x and y with registers r0 and r1, respectively.

Assume that the base address for the array is located in r2. Translate this C statement/assignment using the

post-indexed form:x = array [5] + y

Now try writing it using the pre-indexed form.

Post-indexed form:

Program:


ENTRY

START MOV R2,#0X40000014

MOV R1,#1

LDR R3,[R2],#0X14ADD R0,R3,R1

END

Output:

Pre-indexed form:

Program:


ENTRY


MOV R1,#1LDR R3,[R2,#0X14]

ADD R0,R3,R1

END

Output:

8/17/2019 15mes0060

10/17

5.2 Loads and stores

Assume an array of 25 words. A compiler associates y with r1. Assume that the base address for the array is

located in r2. Translate this C statement/assignment using the post-indexed form:

array [10] = array[5] + y

Now try it using the pre-indexed form.

Post-indexed form:

Program:


ENTRY


MOV R1,#3

LDR R3,[R2],#0X14

ADD R0,R3,R1

STR R0,[R2]

END

Output:

Pre-indexed form:

Program:


ENTRY


MOV R1,#3

LDR R3,[R2,#0X14]!

ADD R0,R3,R1

STR R0,[R2,#0X14]

END

Output:

8/17/2019 15mes0060

11/17

5.3 Array assignment

Write ARM assembly to perform the following array assignment in C:

for ( i = 0; i

8/17/2019 15mes0060

12/17


EXERCISE 6

6.1 Arrays and pointers

Consider the following two C procedures that initialize an array to zero using a) indices, and b) pointers:

a) init_Indices (int a[], int s) {

int i;for ( i = 0; i < s; i ++)

a[i] = 0; }

b) init_Pointers (int *a, int s) {

int *p;

Convert these two procedures to ARM assembly. Put the starting address of the array in r1, s in r2, and i and

p in r3. Assume that s > 0

Program:

Part a:AREA exp2, CODE, READONLY

ENTRY

START MOV R3,#0

MOV R4,#1

MOV R1,#0x00000050

MOV R2,#10

MOV R5,#0

UP

STR R5,[R1]

ADD R1,R1,#4

ADD R3,R3,#1CMP R3,R2

BLT UP

END

Output:

8/17/2019 15mes0060

13/17

Part b:

AREA exp2,CODE,READONLY

ENTRY

START MOV R3,#0

MOV R4,#1

MOV R1,#0x50

MOV R6,#0x78

MOV R2,#10

MOV R5,#0

UP

STR R5,[R1]

ADD R1,R1,#4

ADD R3,R3,#1

ADD R1,R6

BLE UP

END

Output:

6.2 The Fibonacci sequence

The Fibonacci sequence is an infinite sequence of numbers that begins with 0 and 1, and each of the

remaining numbers is the sum of the previous two numbers. Write an ARM assembly program thatcomputes the first 12 numbers of the sequence and stores the sequence in memory locations 0x4000 to

0x400B.

Program:

AREA EX1,CODE,READONLY

ENTRY

START MOV R0,#0X0

MOV R1,#0X1

MOV R2,#0X4000

STRB R0,[R2],#0X01STRB R1,[R2],#0X01

MOV R3,#0X0A

LOOP ADD R4,R0,R1

STRB R4,[R2],#0X01

8/17/2019 15mes0060

14/17

MOV R0,R1

MOV R1,R4

SUBS R3,#0X01

BNE LOOP

END

Output:

6.3 The nth Fibonacci number

Use The Fibonacci sequence exercise program and write ARM assembly to compute f(n). Start with r1 = n.

At the end of the program, r0 = f(n)

Program:

AREA EX1,CODE,READONLY

ENTRY

START MOV R3,#0X0D ;n values by user

SUB R3,#0X02

MOV R1,#0X0

MOV R2,#0X1

MOV R4,#0X4000

STRB R1,[R4],#0X01

STRB R2,[R4],#0X01

LOOP ADD R0,R1,R2

STRB R0,[R4],#0X01

MOV R1,R2

MOV R2,R0

SUBS R3,#0X01

BNE LOOP

END

8/17/2019 15mes0060

15/17

Output:

8/17/2019 15mes0060

16/17


EXERCISE 7

7.1 Factorial calculation

To take advantage of the idea of conditional execution, examine the algorithm for computing n!, where n is

an integer. For a given value of n, the algorithm iteratively multiplies a current product by a number that is

one less than the number it used in the previous multiplication. The code continues to loop until it is nolonger necessary to perform a multiplication, first by subtracting one from the next multiplier value and

stopping when it is equal to zero.

Program:

AREA Factorial, CODE, READONLY

ENTRY

MOV r6,#10 ; load n into r6

MOV r7,#1 ; if n = 0, at least n! = 1

loop CMP r6, #0

MULGT r7, r6, r7SUBGT r6, r6, #1 ; decrement n

BGT loop ; do another mul if counter!= 0

stop B stop ; stop program

END

Output:

7.2 Find maximum value

In this exercise, find the largest integer in a series of 32-bit unsigned integers. The length of the series is

determined by the value in register r5. The maximum value is stored in the memory location 0x5000 at the

end of the routine. The data values begin at memory location 0x5006. Choose 11 or more integers to use.Use as much conditional execution as possible when writing the code

Program:


ENTRY

START LDR R0, =0X5006

MOV R5,#5

LDR R1, [R0],#4LDR R2, [R0],#4

SUB R5, #0X01

L1 LDR R3, [R0]

CMP R2,R3

BCS L

MOV R2,R3

8/17/2019 15mes0060

17/17

ADD R0,#4

L SUBS R5,#0X01

BNE L1

LDR R0,=0X5000

STR R2,[R0]

END

Output:

7.3 Sequential parity checker

Write ARM assembly to inspect the parity of a value initially held in r0. If r0 has an odd number of ones, the

program ends with 0x0001 in r1. If r0 has an even number of ones, the program ends with 0x0000 in r1.

Program:


ENTRY

START MOV R2,#1

LDR R0,=0xFEEEMOV R3,#32

MOV R1,#0

LOOP TST R0,R2

ADDGT R1,R1,#1

LSL R2,R2,#1

SUBS R3,R3,#1

BGT LOOP

AND R1,R1,#1

L B L

END

Output:

Date post:	06-Jul-2018
Category:	Documents
Upload:	ranjith-m-kumar
View:	215 times
Download:	0 times

15mes0060

Documents