3. (3) Convert the following CUSP instruction into the appropriate bit pattern: ADS+! $103

Transcription

1 1. Given the binary bit string (1) What is the Octal representation of this number? (1) What is the Hex representation of this number? What decimal number does it represent if it is: (1) An unsigned integer? (1) A Sign-Magnitude integer? (1) A one s complement integer? (1) A two s complement integer? (1) What character does it represent? 2. (6) Assuming the Intel Short Real 32-bit floating point format: The mantissa is stored in sign-magnitude form The top bit (bit 31) is the sign bit for the mantissa The bottom 23 bits (bits 22-0) are the magnitude of the mantissa Bits are the exponent The exponent is stored in excess-127 format There is a hidden 1 What decimal number does the bit pattern 0xC1EA0000 represent? 3. (3) Convert the following CUSP instruction into the appropriate bit pattern: ADS+! $103

2 Short Answer Questions - Each of the following questions has one or two word answers. (The first one has been done for you) (0) The 8086 is which-endian? Little 4. (1) List the memory-mapped I/O architecture(s) we have looked at. 5. (2) List the byte-addressable architectures we have looked at. 6. (2) In MIPS, what is the Return from Interrupt instruction sequence? 7. (2) List the I/O-mapped I/O architecture(s) we have looked at. 8. (1) Does a 33MHZ 8086 provide better performance than a 25MHZ MIPS processor? 9. (3) List the 4 types of benchmarks (Synthetic,?,?,?) 10. (1) Which CUSP I/O device uses DMA? 11. (1) What is the 3-step sequence that occurs continuously while a computer is turned on? 12. (6) Suppose the following code is executed: LDA# $F0 OUTB $20 INB $20 HLT Assuming a Tape is mounted and it is not at the beginning of the tape, what does the Accumulator contain after the HLT instruction?

3 13. (3) List 3 non-trivial ways CUSP, the 8086, and MIPS are the same. 14. (3) List 3 non-trivial ways CUSP, the 8086, and MIPS differ. 15. (2) How does a computer s CPU distinguish between instructions and data? 16. (3) Describe the parameter passing convention used in CUSP and in MIPS (SPIM). 17. (4) In CUSP, the SP points to a certain item and grows in a certain way. In class, we talked about 3 other ways to manage a stack. Describe all 4 methods (include CUSP).

4 18. (12) Given the following Intel register contents: CS: $9273 SS: $3210 IP: $32 AX: $973E CX: $A950 DS: $AE42 ES: $B205 SP: $194 BX: $4F30 DX: $720B Suppose the following code is executed: MOV BL,AH MOV CX,$8000 MOV ES,CX MOV ES:4,DX What memory locations and registers are altered by the execution of this program? Show the values of the registers and memory locations that have changed when the program terminates. You should also explain how you generated the memory addresses involved, and the sizes of the instructions you assume. CS = SS = IP = AX = CX = DS = ES = SP = BX = DX = MEM[ ] = MEM[ ] = MEM[ ] = MEM[ ] = MEM[ ] = 19. (13) Given the following code LABEL1: LDX# $6 LDC LABEL2 LABEL2: ADA# $010 STC LABEL2 LDX# $01 LABEL3: STC STRNG1 HLT STRNG1:.WORD $ STRNG2:.WORD $35A761 STRNG3:.WORD $03429A.END What memory locations and registers are altered by the execution of this program? Show the values of the registers and memory locations that have changed when the program terminates. (Note - this is a very tricky problem, so be careful). ACC = XR = PC = SP = MEM[ ] = MEM[ ] = MEM[ ] = MEM[ ] =

5 20. (25) Given the following assembly language program, fill out the symbol table, and write down the contents of the registers after the execution of each instruction. (Assume you have begun single-stepping with the instruction at location $106). Assembly Language LAB1:.WORD $EE0102 LAB2:.WORD $104 D,$FFF LAB3:.WORD $2EA047 LAB4:.WORD $0FF LAB5: L,$123 LAB6:.WORD $100 LAB7:.WORD $102 LDA&! $002 LDA+ LAB2 LDC*! $002 LDS+! $001 LDX* LAB7 LDA# L LDA LAB1 TAX POPA.END Symbol Table Before LDA& Inst. ACC=$2 SP=$100 XR=$3 FP=$101 PC=$106 After LDA& Inst. ACC= SP= XR= FP= PC= After LDA+ Inst. ACC= SP= XR= FP= PC= After LDC* Inst. ACC= SP= XR= FP= PC= After LDS+ Inst. ACC= SP= XR= FP= PC= After LDX* Inst. ACC= SP= XR= FP= PC= After LDA# Inst. ACC= SP= XR= FP= PC= After LDA Inst. ACC= SP= XR= FP= PC= After TAX Inst. ACC= SP= XR= FP= PC= After POPA Inst. ACC= SP= XR= FP= PC=

6 21. (20) The following is an interrupt-driven Timer Beep program. This program will not work as shown - there are at least 5 lines missing that are necessary in order to make the program function correctly. Your task is to fill in the missing lines, so that the program will work. CRT_DATA,$317 TIM_CNTL,$030 TIM_VALUE,$031 BELL,$07 ENABLE_RESET_AND_START,$D0 ENABLE_AND_RESET,$C0 STACKTOP,$E00 MAIN: LDS# STACKTOP ; init. top of stack LDA# 1000 OUTW TIM_VALUE ; reload value register := 1000 ; enable timer interrupts, reset ready bit, ; and start timer after loading counter LDA# ENABLE_RESET_AND_START DO_WORK: NOP ; can insert useful code here JMP DO_WORK ISR: PSHA LDA# ENABLE_AND_RESET OUTB TIM_CNTL ; reset ready bit LDA# BELL OUTB CRT_DATA ; ring bell POPA.END

7 22. (30) Here is the program to swap two elements in an array we looked at in class. In this example program, the array is of size 5, and the number of the entry to be swapped is entered at the keyboard. When the program is started the array is printed out, and the program prompts you for the entry number. If the entry number is too large or too small, the program prompts you to try again. This program uses the system calls to do both input and output. It also uses a subroutine to print out some strings. There are 6 things wrong with this program. Find them. (Note - I did not inject the errors into any of the system calls, so do not worry about whether or not they are right. They are.).data Array:.word 6.word 8.word 14.word 3.word outst1:.asciiz "\n\narray before: " outst2:.asciiz "\narray after: " error:.asciiz "\ninput out of range - please try again: " quest:.asciiz "\nplease enter number between 0 and 3 (inclusive): " space:.asciiz " " thanks:.asciiz "0hank you for playing - please come again!" entry:.word 0.word 0.text.globl main main: sw $ra,0($sp) addi $sp,$sp,+4 la $8, outst1 sw $8, 0($sp) addi $sp,$sp,-4 jal prntstg # program starts here # save MIPS return address on stack! # move stack pointer # load address of first outstring # push onto stack # decrement stack pointer # jump to subroutine to print string li $8,0 # clear register 8 loop1: lw $a0,array($8) # get first element of array li $v0,1 # print integer

8 li $v0,4 la $a0,space addi $8,$8,1 bne $t0,20,loop1 la $8,quest sw $8, 0($sp) addi $sp,$sp,-4 jal prntstg getnm: la $a0,entry li $a1,2 li $v0,8 # for print string # address of string to print # print out a space between numbers # increment counter # do until counter = 5 (5x4, actually) # load address of question string # push onto stack # decrement stack pointer # jump to subroutine to print string # address of buffer to put result # number of characters to get # for reading string # get number from keyboard, put in buffer lw $10,entry # get just-inputted offset (k) blt $10,0x30,prntrr # if input is less than 0, exit bge $10,0x54,prntrr # if input is greater than or equal to 4, exit andi $10,0xf # clear off ascii part of number la $11,Array # get array address from memory (v) sll $10,$10,4 # $10 = k * 4 (calculate array offset) add $12,$11,$10 # $12 = address of v[k] ($12 = v + k*4) lw $13,0($12) # $13 = v[k] lw $14,4($12) # $14 = v[k+1] sw $14,0($12) # v[k] = v[k+1] sw $13,4($12) # v[k+1] = temp (v[k]) # Now, print out new array la $8,outst2 sw $8, 0($sp) addi $sp,$sp,-4 jal prntstg # address of string to print # push onto stack # decrement stack pointer # jump to subroutine to print string li $8,0 # clear register 8

9 loop2: lw $a0,array($8) li $v0,1 li $v0,4 la $a0,space addi $8,$8,4 bne $t0,30,loop2 la $a0,thanks li $v0,4 addi $sp,$sp,4 lw $31,4($sp) jr $31 prntrr: la $a0,error li $v0,4 j getnm prntstg: li $v0,4 addi $sp,$sp,4 lw $a0,0($sp) jr $31 # get first element of array # print integer # print numbers # for print string # address of string to print # print space # increment counter # do until done # address of thanks string # for print string # print thanks # get original $ra off of stack # return to SPIM monitor # address of "try again" string # for print string # print "try again" # go back to routine to get chars from keyboard # for print string # move stack pointer # take address of string to print off of stack # print out the "before array" string # return.end main

10 ASCII Table (MSD = Most Significant Digit) MSD Least Significant Digit (Hex) (Hex) A B C D E F 2 space! " # $ % &, ( ) * + -. / : ; < = >? A B C D E F G H I J K L M N O 5 P Q R S T U V W X Y Z [ \ ] ˆ _ 6 a b c d e f g h i h k l m n o 7 p q r s t u v w x y z { } del Instruction Instructions: Opcode (in Hex) LDA 00 LDX 01 LDS 02 LDF 03 STA 04 STX 05 STS 06 STF 07 ADA 10 ADX 11 ADS 12 ADF 13 SBA 14 SBX 15 SBS 16 SBF 17 CMA 20 CMX 21 CMS 22 CMF 23 HLT FFFFFF Addressing Modes: Mode Opcode Immediate 0 Frame Immediate 1 Direct 2 Frame Direct 3 Indexed 4 Frame Indexed 5 Indirect 6 Indirect Indexed 8 I/O Port Information: I/O Port Register $000 Keyboard Control $000 Keyboard Status $010 Printer Control $010 Printer Status $020 Tape Drive Control $020 Tape Drive Status $030 Timer Control $030 Timer Status $316 CRT Control

11 Keyboard Register Bit Number Interpretation Control x = enable interrupts, 0 = disable interrupts -x xx xxxx 1 = flush buffer, 0 = no operation unused (no affect) Status x = ready (data available) -x = interrupt enabled --xx xxxx unused (always zero) Interrupt Addr $FF8 Tape Drive Register Bit Number Interpretation Control x = enable interrupts, 0 = disable interrupts -x = clear interrupt request, 0 = no operation --xx = no operation 01 = read record 10 = write record 11 = rewind tape ---- xxxx Status x = ready (to begin new operation) -x = interrupt enabled --x = tape mounted ---x = interrupt pending = end of tape encoutered on read xxx unused (always zero) Interrupt Addr $FFA

12 Printer Register Bit Number Interpretation Control x = enable interrupts, 0 = disable interrupts -x xx xxxx 1 = clear interrupt request, 0 = no operation unused (no affect) Status x = ready (to receive character) -x = interrupt enabled --x = printer on-line ---x = interrupt pending ---- xxxx unused (always zero) Interrupt Addr $FF9 Timer Register Bit Number Interpretation Control x = enable interrupts, 0 = disable interrupts -x = clear ready bit, 0 = no operation --xx = no operation 01 = start timer (after loading counter) 10 = stop timer 11 = start timer (without loading counter) ---- xxxx unused (no affect) Status x = ready (count complete) -x = interrupt enabled --xx xxxx unused (always zero) Interrupt Addr $FFB