Part 5,Assembly Language Questions

Transcription

1 Part,Assembly Language Questions This study guide is provided as an aid in helping you to study for the ECE Department s 18-4, Fundamentals of Computer Engineering. The guide is a collection of previous test and homework questions for which solutions were handed out. Thus some of these questions are indicative of questions you might find on a test. Since answers are provided for these questions, you can use this guide to get extra practice on course-related problems. The guide consists of several files covering different topics. Please don t infer that this guide is all inclusive in terms of course topics or possible test questions. Further, the topics are distributed among several files. Please don t infer that the first test corresponds to file number one. It probably doesn t. Check with the course announcements regarding topics to be covered on a test. Oh yes, you might find some errors. Please let us know so that we can fix them for others. This file was produced using FrameMaker and saved in PDF format for Adobe Acrobat readers. Acrobat Exchange was used to include hot links between questions and answers..1 Assemble this program Assemble the following program and put your answers in the table shown below. Fill in both columns. Extra space is provided..org $87 LDI BRA R,BLAH there BLAH.DW $7 there XOR R,R

2 address data Some templates for scribbling: Disassemble this code The machine code shown below in the table is to be disassembled into assembly code and shown in the column on the right. The first instruction starts at address $1. (Note, the instructions found in this machine code don t do anything interesting.) 11/11

3 address $1 $11 $1 $14 data $D $E $ $ Your answers Some templates for scribbling: Assembly Language: Stack Stuff The figure shows a stack frame at the start of a subroutine. Several parameters have been passed to the subroutine. Assume that the calling routine has saved all registers. a. What instruction will load parameter A into register? b. Normally you would use STSF to write into the stack frame but not in this problem. Show a few instructions that use STR to write R into parameter D on the stack. Don t write comments like assume <some value> is in register R, then. Rather, write any instructions needed to put needed values into R (or any other register). 1/11

4 SP Return PC passed parameter D passed parameter C passed parameter B passed parameter A other stuff toward address $FFFF.4 Assembly Language Program Execution What value will be in R when you reach the instruction at Done? Explain your answer i.e. which of the branches (if any) did you take why? start LDI R,$1111 PUSH R LDI R,$8888 PUSH R BRZ a BRN b LDI R,$1 BRA Done a MOV R,R DECR R BRA Done b LDSF R,$ Done STOP. Assembly Language: Linked List A linked list is a data structure used to represent an ordered list of information. The list is made up of elements which contain several words of memory. The elements in our list (see below) are made up of two consecutive words in memory. The first word of an element contains the address of the next element in the list. Thus it is a pointer to the first word in the next element in the figure it is shown pointing to the next element. It 1/11

5 contains zero if this is the last element in the list. The second word of an element contains the data being linked. Let s say the first element is at memory location $4. That means the address of the next element is contained in memory location $4, and the data being linked is in memory location $41. If the contents of $4 is $41, then the second element is at $41, its pointer to the next element is contained in $41, and its data is in $411 $4 $41 address of next element data being linked $41 $411 $n $n+1 first element second element last element Do this: Write an assembly language subroutine that will link (insert) a new element at the end of the list, making it the last element. Be sure to put a zero in the address of next element word of the new last element. Assume this: The parameters passed to the subroutine (shown below in the diagram) are the address of the first element of the list, and the address of the new element to be added. Assume there is at least one element in the list already. Registers have been saved. No memory allocation is needed. SP Return PC Address of new element Address of first element other stuff Towards address $FFFF. Assembly Language Program (arrays) Write an assembly language program that searches through an array and places the index of the largest element in a variable called max_index. Assume that the first element in an array has index zero (e.g. example_array[]). You can assume that the start of the array arr_start, and the length of the array arr_length are known. Thus the program structure should look like: 14/11

6 .ORG $1 max_index.dw $ ; this is where the index should be stored arr_length.dw xxx ; length of the array (positive integer) arr_start.dw aaa ; first element of the array (index = ).DW bbb ; second element of the array (index = 1).DW ccc ; third element (index = ) (etc.) start (your program goes here).7 Assembly Language Program (subroutines / stack) Write an assembly language subroutine that swaps the two words that were on top of the stack before the subroutine was called (i.e. just before the JSR instruction was executed). Fill in the pictures of the section of memory containing the stack and the PC and SP registers:(i) just before the subroutine is called, (ii) just after the subroutine is called, (iii) just before it returns from the subroutine, and (iv) just after it returns from the subroutine Swap.ORG $1 LDI R1, $ LDSP R1 LDI R1, $xxxx PUSH R1 LDI R, $yyyy PUSH R JSR Swap POP R POP R1 STOP (put your subroutine code here) (i) Address $FFFE $FFFF $19 $FFFE Memory $yyyy $xxxx 1/11

7 (ii) (iii) (iv) Address Memory Address Memory Address Memory What is the value of the label Swap? 1/11

8 Answers.1 Assemble This Program.ORG $87 LDI BRA R,BLAH there BLAH.DW $7 there XOR R,R Let s look at the important features of this code. The first line uses a.org statement..org is a statement to tell the assembler to place the code that follows into the memory location listed after the statement. In this example, the code will begin at memory location $87. The next line statement LDI uses the format 11 Rd Rd which using R (11) for Rd, gives us the hex value of $C1B. This word goes in memory location $87. The LDI format also requires an immediate value in the next memory location ($871). This word is BLAH, handled by the assembler (using the.dw command) and placed in its own memory location $874. The BRA instruction is placed in memory location $87. The BRA instruction uses memory words, the first is encoded to $8, and the second word (memory location $87) is the address of the conditional branch. This address is $7. Next, as mentioned above comes the.dw statement..dw is an assembler directive to reserve one word of memory (named BLAH) with the contents of $7. Finally, we have the XOR statement. The XOR instruction is a one memory word instruction with the format: 1111 Rd Rs, where Rd = R (11) and Rs = R (11). This gives us the hexadecimal word $1E1D. address data $87 $C1B LDI R, BLAH $871 $7 BLAH $87 $8 BRA there $87 $87 address of there BLAH $874 $7 contents of BLAH there $87 $1E1D XOR R, R 17/11

9 . Disassemble This Code This problem can be solved by looking up the encoded memory words in the instruction set. The instructions are shown below. Note that there are only three instructions. The contents of $11 is the address used for the STA instruction. address $1 $11 $1 $14 data $D $E $ $ Your answers STA $E, R $E LSHL R STOP. Assembly Language: Stack Stuff a. The LDSF (Load stack frame) instruction is used to load a value from the stack. The format of the instruction is LDSF Rd, imm. This instruction will load into Rd from the imm th position (from the stack pointer) in the stack. We want to load parameter A, which is 4 positions down from the stack pointer. We want this instruction in R. Therefore the instruction looks like: LDSF R, $4 (4) b. We can use the STR instruction to place the word in R into parameter D of the stack, but first we must find a way to get the memory location of D into a register. We can do this by storing the stack pointer in R, then incrementing the value in R, which will then hold the memory location of D. The STR instruction stores the value of a register Rs into the memory at location [Rd]. The instructions to perform this task are listed below: STSP R INCR R STR R, R.4 Assembly Language Program Execution start LDI R,$1111 PUSH R LDI R,$8888 PUSH R BRZ a BRN b LDI R,$1 BRA Done a MOV R,R DECR R 18/11

10 BRA Done b LDSF R,$ Done STOP We can figure this problem out by tracing it through one line at a time. The first statement loads the immediate value of 1111 (in hexadecimal) into R. Because the value 1111 is neither or negative, no condition codes are set. Next we push the value onto the stack. The third statement loads the immediate value of 8888 which is a negative number. This statement sets the negative condition code. The push statement loads this value onto the stack, but does not clear the condition code. The BRZ statement is not taken because the Z condition code hasn t been set, and again the condition codes are not changed. However, the next instruction, the BRN statement is taken, because the negative condition code is still set. The branch is taken and the program resumes at b. The next statement loads the Stack s top value into R (which is 8888), and finally the program ends. The final value of R is $ Assembly Language: Linked List start LDSF R, $ ; load the address of the first element into R next LDR R1, R ; R1 <- mem[r]. Load the contents of the element BRZ foundend ; If contents were zero, end of list found. Branch! MOV R, R1 ; If contents were not zero, we end up here. Put BRA next ; address of next element in R. Go to top of loop. foundend ; Come here if you found the end of the loop LDSF R, $1 ;load the address of the new element into R STR R, R ;mem[r] <- R. R still has the address of last ;element. Put new address in it STR R,R1 ;Put zero (still there from the BRZ) into the first ;word of the new element STOP ;done!. Assembly Language Program (arrays) We will use the following registers: R = current index R1 = current pointer R = current element R = array length R4 = max element The numbers in the array are assumed to be s complement integers No error checking is done.org $ BRA start.org $1 max_index.dw $ ;this is where the index should be stored arr_length.dw $ ;length of the array (positive integer) 19/11

11 arr_start.dw $ ;first element of the array (index = ).DW $FFFF ;second element of the array start LDI R, $ ;initialize the current index to STA max_index, R ;initialize the max index to LDI R1, arr_start ;initialize the current pointer LDR R, R1 ;initialize the current element MOV R4, R ;initialize the maximum element LDA R, arr_length ;initialize to the array length loop INCR R1 ;increment current pointer INCR R ;increment current index CMR R, R ;have all elements in array been checked BRZ done LDR R, R1 ;deference pointer to get current element CMR R, R4 ;check current element is larger than max BRN loop ;if not, continue with next element in array MOV R4, R ;update max element STA max_index, R ;update max index BRA loop ;go to next element in array done STOP.7 Assembly Language Program (subroutines/stack) There are two different methods to implement the swap routine. One is to store each member into a register using LDSF, then use STSF to put them back in reverse order. The other is to POP the return address, then each of the two words into three different registers. Then PUSH them back in the new order. Address Memory (i) Swap LDSF R1, $1 LDSF R, $ STSF R1, $ STSF R, $1 RET Swap POP R POP R1 POP R PUSH R1 PUSH R PUSH R RET $FFFE $FFFF $19 $FFFE $yyyy $xxxx 1/11

12 (ii) Address Memory (iii) Address Memory (iv) Address Memory $FFFD $1B $FFFD $1B $FFFE $yyyy $FFFE $xxxx $FFFF $xxxx $FFFF $yyyy $FFFE $FFFF $xxxx $yyyy $1E $FFFD $11 $FFFD $1B $FFFE The stack frames are shown in figures (i) (ii) (iii) and (iv). The value of the label SWAP is $1E. 11/11