ECE 3210 Lab 4: Calculator

Size: px

Start display at page:

Download "ECE 3210 Lab 4: Calculator"

Virgil Melton
5 years ago
Views:

1 ECE 3210 Lab 4: Calculator Fall Objective In this lab, you will develop an complete assembly program that takes an user input, performs data operations, and produces the expected output. After finishing this assignment, you should be able to do the following: 1. Use MACROs to make your program more readable. 2. Use functions to modularize your program. 3. Understand the use of the stack. 4. Use instructions to perform arithmetic/logic operations and comparisons. 2 Background 2.1 Arithmetic Operations In this lab, we will implement binary operations found in simple calculators. Your calculator should be able to perform the following four types of integer operations: a. addition (+), for example, = 8 b. subtraction (-), for example, 5-3 = 2 c. multiplication (*), for example, 5 * 3 = 15 d. division (/), for example, 5 / 3 = 1 e. modulus (%), for example, 5 % 3 = 2 To perform the desired operations, an algebraic expression must be entered. The calculator will then display the result followed by a new prompt for the next algebraic expression Subtraction The subtraction instruction is similar to addition: SUB <d e s t >,<Operand1>,<Operand2> Multiplication Multiplication is similar to addition and subtraction but has some restrictions: MUL <d e s t >,<Operand1>,<Operand2> The restrictions are that the destination cannot be the same as operand1 and all of the arguments must be registers. Immediate values may not be used. 1

2 2.1.3 Division The ARM does not provide a division instruction, so the following segment shows how you can perform one using two 32-bit values. It assumes that the dividend is in R1, and the divisor is in R2. On exit R3 holds the quotient, R1 the remainder. MOV R4, R2 R4, R1, LSR #1 div1 : div2 : MOVLS R4, R4, LSL #1 R4, R1, LSL #1 BLS div1 MOV R3, #0 R1, R4 SUBCS R1, R1, R4 ADC R3, R3, R3 MOV R4, R4, l s r #1 R4, R2 BHS div2 2.2 Functions vs. Macros Macros A macro is a small segment of code that needs to be written repeatedly throughout a program. That is, some times, repetitive segments of code are not long enough to deserve its own subroutine e.g. it would take longer to call the subroutine than to actually execute that piece of code. So, instead, we use a MACRO to define that sequence only once, and then we repeat that sequence as many times as we want by placing a simple statement (the name of the MACRO) at the point of each appearance. When a reference to a macro is encountered by the assembler, the assembler replaces the reference with the macro s actual sequence of code. This replacement action is referred to as a macro expansion. To understand exactly what happens to a macro after assembling, try to look at the assembly/machine code generated. Once a MACRO has been defined in an.s file, you can include that entire sequence of statements simply by using its name as an operator. If you define the MACRO to have parameters, you can also pass operands to it. But keep in mind that a MACRO is NOT a function and therefore, the parameters are not actually passed to the MACRO, but simply replaced by the values in the call. For example, in Lab 3, we introduced the software interrupt for writing a string to the screen: MOV R7, #4 MOV R0, #1 LDR R2, =l e n g t h LDR R1, =message SWI 0 We need to repeat this five lines each time we wish to write a message to the screen. This is exactly the case for repetitive segments of code butnot long enough to have its own subroutine. Therefore, we use a macro name output to define this sequence in the following.. macro output mes, l e n MOV R7, #4 MOV R0, #1 LDR R2, =\mes LDR R1, =\l e n 2

3 . endm SWI 0 Notice that each macro begins with.macro and ends with.endm. Also, the parameters are proceeded by a backslash. You can give the parameters whatever labels you wish. Here, we called them mes and len. Next, in the main program, we can invoke a defined macro by the following example.. t e x t. g l o b a l main main : output length, message A file lab4p1.s is included in Canvas to provide this example of Macro Procedures and Functions A procedure or subroutine is a sequence of code that can be executed in such a way as if such instructions were inserted at the point of the main program from which it branched to the procedure/subroutine. The branch to a procedure is referred to as the call, and the corresponding branch back is known as the return from the procedure. Procedures provide the primary means of breaking the program code into modules, which can be easily and individually designed, tested, and documented. They can also be stored in libraries and shared by a variety of other programs. Procedures have one major disadvantage in that extra code is needed to join them together in such a way that they can communicate with each other. This extra code is referred to as linkage. A function is basically a procedure/subroutine with input and output parameters -- i.e. it is a procedure that performs a function transforming the input into an output. Register Role Contents Preserved R0 Argument and Result No R1 Argument No R2 Argument No R3 Argument No R4 General Yes R5 General Yes R6 General Yes R7 General Yes R8 General Yes R9 General Yes R10 General Yes R11 General Yes R12 General Yes LR Return Address No SP Stack Pointer Yes Table 1: Register designations in a function call. Table 1 details the purpose of each register when a function is called. In summary a function or procedure should adhere to the following: It may freely modify registers R0, R1, R2 and R3 and expect to find the information in them that it requires to carry out its task. It can modify the registers R4-12, providing it restores their values before returning to the calling routine. It can modify the Stack Pointer providing it restores the value held on entry. 3

4 It must preserve the address in the Link Register so that it may return correctly to the calling program. It should make no assumption as to the contents of the Current Program Status Register (CPSR). As far as the function is concerned the status of the N, Z, C, and V flags are unknown. (More information about functions can be found in the book Raspberry Pi Assembly Language, chapter 20) Here is an example of implementing the division into a function (has both inputs and outputs), the function will use register R1 and R2 to pass the parameters of dividend and divisor and return quotient to R3, remainder to R1, and original divisor to R2. Since register R4 is only used inside the function (not as a parameter), so its original value is pushed at the beginning of function and popped back at the end of function.. t e x t. g l o b a l main d i v i s i o n Function name PUSH {R4, the beginning o f your function MOV R4, R2 R4, R1, LSR #1 div1 : div2 : MOVLS R4, R4, LSL #1 R4, R1, LSL #1 BLS div1 MOV R3, #0 R1, R4 SUBCS R1, R1, R4 ADC R3, R3, R3 main : MOV R4, R4, l s r #1 R4, R2 BHS t h e end o f your Function POP {R4, LR} BX LR... Your main program... A file lab4p2.s is included in Canvas to provide this example of Functions. 3 Prelab There is no pre-lab for this lab assignment. 4

5 4 Laboratory Write an assembly program that reads two integers from the user and performs the user s chosen operation. Then print the result to the screen. Use the following guide to meet the deliverables of this three week lab: Week 1 1. Initialize the variable input as.ascii type has 20 empty spaces 2. Initialize variables operand1_a, operator, and operand2_a as.ascii type in your.data directive. 3. Parse the input string to obtain operand1, operator, and operand2, then check for their validity and whether the number was positive or negative. Use Lab 3 s code as a starting point. Be sure to make use of macros to simplify your code. Sample demo: <enter > Operand1 : 10 Operand2 : 2 Operator : / 9 + 1<enter > Error!! Input format : Operant1 Operator Operand2 Operand : decimal numbers Operator : + / % 255/9< enter > Error!! Input format : Operant1 Operator Operand2 Operand : decimal numbers Operator : + / % 25A / 9<enter > Error!! Input format : Operant1 Operator Operand2 Operand : decimal numbers Operator : + / % Lab deliverable 1 1. Demonstrate to your TA that your program can read both operands and operator as well as detect errors. 2. Take a screen shot of variables operand1_a, operand2_a, and operator in memory. Also show what the user entered to illustrate your program works. Week 2 1. Initialize variables operand1_h and operand2_h as.byte with value Implement an function A_to_H to convert from ASCII value to Hex value. Use R1 to pass the address of operand#_a and R2 to return the converted value to be stored in operand#_h. 5

6 3. Initialize a variable result_h as.word with value 0 4. Complete the arithmetic operations (+, -, *, /, %) and store the final value into the variable result_h. Lab deliverable 2 1. Take a screen shot of your hex variables operand1_h and operand2_h and their corresponding ascii variables operand1_a and operand2_a in memory. 2. Once you complete the arithmetic operations, take a screen shot of the variable result_h. Week 3 1. Initialize an variable result_a as.ascii with 10 empty spaces. 2. Implement an function H_to_A to convert from Hex value back to ASCII value. Use R1 to pass the value of result_h and R2 to pass the address of result_a. (Both R1 and R2 are parameters) 3. Print out the final result value and complete the full program functionality. Lab deliverable 3 1. Demonstrate to your TA the full completed program. 2. Take a screenshot of the output of your program for several different inputs. 6

INSTRUCTOR: ABDULMUTTALIB A. H. ALDOURI

INSTRUCTOR: ABDULMUTTALIB A. H. ALDOURI 8 Unsigned and Signed Integer Numbers 1. Unsigned integer numbers: each type of integer can be either byte-wide or word-wide. This data type can be used to represent decimal numbers in the range 0 through