#assembly language programming

Scattered Progress Is Still Progress

I've been bouncing around a lot. After confirming my new bus interface was working on my wire-wrap prototype, I built out the DRAM card. It … mostly works. It will work just fine for a few thousand back-to-back transactions and then it just randomly locks up. The CPLD running its timing sequence will freeze on one state and stop responding to any further input.

I managed to chase down a few bugs that helped, but did not resolve the problem. DRAM can use a lot of instantaneous current that may not have been well supported with how the bus connector is wired on my prototype. I spent quite a while reinforcing the power supply to the DRAM card and adding more bulk capacitance. This helped the card run much longer, but did not resolve the issue.

At this point I thought that maybe it was just my prototype, because I've already run into plenty of problems with the hand-wired board. Perhaps it would work more reliably with the new host card. So I spent a few hours assembling one.

I got everything put together and plugged into the backplane before stopping to think about what would be required to follow this process. I'm not currently set up for low-level debugging a PowerPC board that may or may not have working main memory. I got very lucky with my prototype that it pretty much worked and ran Forth on my first try. To bring up the new host card I'll need some lower-level code I can throw into ROM that will initialize the CPU & serial, then print out some debugging information while testing RAM. I still don't have a great grasp of PowerPC assembly so that will take quite a bit of effort.

… so I pivoted to building the video card instead.

My thinking here is I am trying to get this project into some kind of state that I can demonstrate at VCF Southwest in May. The known working prototype with video card would be a minimum viable hardware configuration for what I want to do for the show. It would make sense to get the video card working now, and then circle back to getting the new modular system working together later if I have time.

It, of course, does not work. Yet. I'm stepping through the logic for the video card to see what I've missed. So far I've found a bug in the host logic relating to how the lowest address bits are handled. This required a little rework on both the prototype and the new host card.

I've also identified a problem with the state machine for the video card and a possible timing issue with the VLB address strobe generated by that state machine. The result being so far the video chip does not acknowledge it is being addressed.

I added my little LED display to my 68000 computer. It was a fun challenge, but easier than I expected

The display replaces the register and string of LEDs on address $0008,0000. It’s wired to even addresses up to $0008,0040, and to the lower 8 bits of the data bus. This makes it simple to use MOVE.w D0,(A0)+ to output a byte and increment the address pointer to the next even address for the display (or even better, MOVEP.l D0,(A0)+ to output 4 bytes with one instruction).

This little program just increments D0 after outputting it. As with the last test program, it does a loop counting up to 0xFFF before shifting, to make the changes visible. Each time it reaches 0xFFF, it increments the starting value for D0.

I did have to optimise my loops some to minimize instruction fetches while writing to the display. It’s not buffered at all, so the LEDs are only lit as long as the CPU is writing to it. This means I need to write to it as quickly and as frequently as possible to make the display bright enough to see. Even still, it’s actually easier to see on camera than in person.

I was bitten again by a missing # on a literal value. Thankfully though, I’m starting to get the hang of using the EASy68K emulator/debugger. I was able to troubleshoot several bugs without erasing and re-burning my flash ROM. Which is good because the chip is old, and I should save what few writes it has left

To that end, I also moved my program to $0001,0000, which puts it into the next sector of the flash chip. This also saves me from having to constantly re-flash the vector table, since I can keep them on the first sector and only erase the second for program changes.

Assembly and machine language programming :

The microprocessor based systems work by reading and executing the program available in its main memory. A program is sequence of instructions written using the instruction set of a microprocessor. The instruction set different from microprocessor to microprocessor. Hence a program written using instruction set of 8085 microprocessor works only on 8085 microprocessor based system, but not on systems based on other microprocessors. The microprocessor instructions are in binary form. The binary patterns for each instruction for a microprocessor is designed by manufacturer and made available to users. We have already studied the instruction formats for 8085 microprocessor. The examples of binary instruction of 8085 are as follows :

10000000             this is an instruction which adds contents of register B to accumulator and stores the result in accumulator.01110110             this instruction halts the microprocessor.00101111             this instruction complements the contents of accumulator.

he 8085 defines 8-bit binary code called opcode for each instruction. The 8085 can understand program written only in binary codes as above. The program written using binary codes of instructions is called machine language program. The real difficulty in writing machine language program is to remember binary codes for large instruction set. It is very hard for any person to remember so many binary patterns and then write a program. To solve this problem, the English like words are used for each binary pattern called mnemonics. For example, the binary instructions written earlier are coded now using mnemonics as ADD B                   add B to A                                                                HLT                         halt the processorCMA                      complement accumulator The program written using mnemonics is called assembly language program. As the mnemonics are easy to remember, the program development will be faster and easier. The microprocessor can not understand program written using assembly language. To execute assembly language program. First it is to be converted to equivalent machine language program by translating mnemonic into binary patterns. The 8085 provides complete table called opcode or machine code table for this purpose, which is given in next section.We will follow the format given in figure for our 8085 assembly language programs.

Watch our tutorial video about how to create a simple counter circuit using a PIC microcontroller with assembly language programming.

Download the FREE trial demo of TINA Design Suite and get:

One year free access to TINACloud (the cloud-based, multi-language, installation-free online version of TINA now running in your browser anywhere in the world.)

An immediate 20% discount from the offline version of TINA

Free license for your second computer, laptop etc.

########################################################### # Program Description #  CS315 Lab 8 -  Stack # #  1. Use create_array to create a dynamic array of words #     (note:  create_array calls read_array, main does not #     call read_array) #  2. Use print_array to print the array #  3. Use sum_array to calculate the sum of the array #  4. Print the sum # # This is the last one! Thanks all for reading and following me! # ########################################################### # Register Usage # $t0 # $t1 # $t2 # $t3 # $t4 # $t5 # $t6 # $t7 # $t8 # $t9 ########################################################### .data

########################################################### .text main:    jal     create_array    # jumps to create_array subprogram    jal     print_array     # jumps to print_array subprogram    jal     sum_array       # jumps to sum_array subprogram        lw      $a0, 0($sp)     # load sum to print    li      $v0, 1          # system call code for print int    syscall        addiu   $sp, $sp, 12         # Unallocate 3 words mainEnd:    li      $v0, 10    syscall    # Halt ###########################################################

########################################################### # Subprogram Description #  Ask the user for an array length, dynamically alocate #   an array of words with the given length #  Call read_array to fill the array

########################################################### # Arguments In and Out of subprogram # # $a0 # $a1 # $a2 # $a3 # $v0 # $v1 # $sp+0  Base address (OUT) # $sp+4  Array length (OUT) # $sp+8 # $sp+12 ########################################################### # Register Usage # $t0 - Base address # $t1 - Length # $t2 # $t3 # $t4 # $t5 # $t6 # $t7 # $t8 # $t9 ########################################################### .data Array_length: .asciiz "Enter a length for your array: "

########################################################### .text create_array: # Ask the user for an array length # Allocate space for the array # Call read_array to fill the array addiu   $sp, $sp, -4        # Allocate 1 word sw      $ra, 0($sp)         # Store the return address li    $v0, 4     # system call code for print string la    $a0, Array_length # load address of Array_length into $a0 syscall         # print Array_length message li    $v0, 5   # system call code for read integer syscall         # read in the value of length int $v0 move    $t0, $zero    # clear $t0 to be added to add    $t0, $v0, 0        # move $v0 to $t0 by adding

mul    $a0, $v0, 4        # set memory to allocate based on input li    $v0, 9          # system call code to allocate memory syscall        # allocate memory for the array addiu   $sp, $sp, -8        # Allocate 2 words sw      $v0, 0($sp)         # Store the array address sw      $t0, 4($sp)         # Store the array length jal     read_array          # jumps to read_array subprogram lw      $t1, 4($sp)         # Load the array length lw      $t0, 0($sp)         # Load the array address addiu   $sp, $sp, 8         # Unallocate 2 words lw      $ra, 0($sp)         # Load the return address addiu   $sp, $sp, 4         # Unallocate 1 word addiu   $sp, $sp, -8        # Allocate 2 words sw      $t0, 0($sp)         # Store the array address sw      $t1, 4($sp)         # Store the array length jr      $ra                 # jumps to previous program ###########################################################

########################################################### # Subprogram Description #  Reads words into an array until the array is full

########################################################### # Arguments In and Out of subprogram # # $a0 # $a1 # $a2 # $a3 # $v0 # $v1 # $sp+0  Base address (IN) # $sp+4  Array length (IN) # $sp+8 # $sp+12 ########################################################### # Register Usage # $t0 - Array Address # $t1 - Array Length # $t2 - Index # $t3 - Offset adress to store values # $t4 - Offset for address # $t5 - Input value # $t6 # $t7 # $t8 # $t9 ########################################################### .data Prompt_value: .asciiz "Please input value: "

########################################################### .text read_array: # Read values into an array until the array is full lw      $t0, 0($sp)         # Load the array address lw      $t1, 4($sp)         # Load the array length li    $t2, 0    # set starting index to 0 loop: bge    $t2, $t1, end_loop # breaks loop when last index is passed mul    $t4, $t2, 4    # sets offset to store the value add    $t3, $t4, $t0 # sets the address to store the value

li    $v0, 4    # system call code for print string la    $a0, Prompt_value # load address of Prompt_value into $a0 syscall        # print Prompt_value message li    $v0, 5    # system call code for read integer syscall        # read in the value of value int $v0 move $t5, $v0    # move value $v0 to $t5 sw    $t5, ($t3)    # store the value in the array add    $t2, $t2, 1    # increment loop by 1 b    loop    # move to the top of the loop end_loop: jr      $ra                 # Jumps to previous program ###########################################################

########################################################### # Subprogram Description #  Prints words from an array, separated by spaces

########################################################### # Arguments In and Out of subprogram # # $a0 # $a1 # $a2 # $a3 # $v0 # $v1 # $sp+0  Base address (IN) # $sp+4  Array length (IN) # $sp+8 # $sp+12 ########################################################### # Register Usage # $t0 - Array Length # $t1 - Array Address # $t2 - Index # $t3 - Index Address # $t4 - Offset # $t5 - The value to be stored # $t6 - Last index check # $t7 # $t8 # $t9 ########################################################### .data Start_array: .asciiz "Your array: [" Comma:    .asciiz ", " End_array:    .asciiz "]\n" ########################################################### .text print_array: # Print all values from an array lw      $t1, 0($sp)         # Load the array address lw      $t0, 4($sp)         # Load the array length li    $v0, 4    # system call code for print string la    $a0, Start_array # load address of Start_array into $a0 syscall        # print Start_array message

add    $t6, $t0, -1 # -1 from for array length for clean print

li    $t2, 0    # set starting index to 0 print_loop: bge    $t2, $t0, end_print # breaks loop when last index is passed mul    $t4, $t2, 4    # sets offset to laod the value add    $t3, $t4, $t1 # sets the address to print the value from

li    $v0, 1    # system call code for print integer lw    $a0, ($t3)    # load the value at address ($t3) syscall        # print the value at index $t2 beq    $t2, $t6, end_print # breaks loop when last index is passed

li    $v0, 4    # system call code for print string la    $a0, Comma    # load address of Comma into $a0 syscall        # print Commma message

add    $t2, $t2, 1    # increment loop by 1 b    print_loop    # move to the top of the loop end_print: li    $v0, 4    # system call code for print string la    $a0, End_array # load address of End_array into $a0 syscall        # print End_array message jr      $ra                 # Jumps to previous program ###########################################################

########################################################### # Subprogram Description #  Calculates the sum of an array #

########################################################### # Arguments In and Out of subprogram # # $a0 # $a1 # $a2 # $a3 # $v0 # $v1 # $sp+0  Base address (IN) # $sp+4  Array length (IN) # $sp+8  Array sum (OUT) # $sp+12 ########################################################### # Register Usage # $t0 - Array Address # $t1 - Array Length # $t2 - Index # $t3 - Address of value to add # $t4 - Offset to get value address # $t5 - Value loaded # $t6 - Sum # $t7 # $t8 # $t9 ########################################################### .data Array_sum:  .asciiz "Sum of your array: " ########################################################### .text sum_array: # Sum of all values from the array lw      $t0, 0($sp)         # Load the array address lw      $t1, 4($sp)         # Load the array length li    $v0, 4    # system call code for print string la    $a0, Array_sum    # load address of Start_array into $a0 syscall        # print Start_array message

move $t2, $0    # set starting index to 0 move $t6, $0    # set starting sum to 0 sum_loop: bge    $t2, $t1, end_sum # breaks loop when last index is passed mul    $t4, $t2, 4    # sets offset to load the value add    $t3, $t4, $t0 # sets the address to add the value from

lw    $t5, ($t3)    # load the value at address ($t3)

   add     $t6, $t6, $t5       # adds loaded int to the sum

add    $t2, $t2, 1    # increment loop by 1 b    sum_loop    # move to the top of the loop end_sum:    addiu   $sp, $sp, -4        # Allocate 1 word sw      $t6, 0($sp)         # Store the sum

######################################### # Program Description #  CS315 Lab 7 -  Floating-points and arrays # # Do the following IN THIS ORDER: # #  1. Use make_double_array to create a first dynamic array #     of doubles, store its base address and length in words #     named myBaseHolder1 and myArrayLen1, respectively # #  2. Use make_double_array to create a second dynamic array #     of doubles, store its base address and length in words #     named myBaseHolder2 and myArrayLen2, respectively # #  3. Use read_double_array to read the first array #  4. Use read_double_array to read the second array # #  5. Use print_double_array to print the first array #  6. Use print_double_array to print the second array # #  7. Use inner_product to calculate the inner product of #     the arrays #  8. Store the inner product in a variable called innerProd #  9. Print the inner product #

######################################### # Register Usage # $t0 # $t1 # $t2 # $t3 # $t4 # $t5 # $t6 # $t7 # $t8 # $t9 ######################################### .data myBaseHolder1:  .word 0 myArrayLen1:   .word 0 myBaseHolder2:  .word 0 myArrayLen2:   .word 0

Array_1: .asciiz "~~Array 1~~" Array_2: .asciiz "~~Array 2~~" Print_a1: .asciiz "Array 1: " Print_a2: .asciiz "Array 2: " Print_inner: .asciiz "Inner Product: "

# Put the words for the base addresses and lengths #  in THIS DATA SECTION (other subprograms should not use #  these labels, so don't put them with other subprograms)

######################################### .text main: li $v0, 4 # call code for print string la $a0, Array_1 # load Array_1 to print syscall # print Array_1 jal make_double_array # jump to make_double_array subprog la $t0, myBaseHolder1 # load address of myBaseHolder1 sw $v0, 0($t0) # save array address to myBaseHolder1 la $t0, myArrayLen1 # load address of myArrayLen1 sw $v1, 0($t0) # save length to myArrayLen1 li $v0, 4 # call code for print string la $a0, Array_2 # load Array_2 to print syscall # print Array_2 jal make_double_array # jump to make_double_array subprog la $t0, myBaseHolder2 # load address of myBaseHolder2 sw $v0, 0($t0) # save array address to myBaseHolder2 la $t0, myArrayLen2 # load address of myArrayLen2 sw $v1, 0($t0) # save length to myArrayLen2

li $v0, 4 # call code for print string la $a0, Array_1 # load Array_1 to print syscall # print Array_1 la $a0, myBaseHolder1 # load address of myBaseHolder1 lw $a0, 0($a0) # load array address from myBaseHolder1 la $a1, myArrayLen1 # load address of myArrayLen1 lw $a1, 0($a1) # load length form myArrayLen1 jal read_double_array # jump to read_double_array subprog li $v0, 4 # call code for print string la $a0, Array_2 # load Array_2 to print syscall # print Array_2 la $a0, myBaseHolder2 # load address of myBaseHolder2 lw $a0, 0($a0) # load array address from myBaseHolder2 la $a1, myArrayLen2 # load address of myArrayLen2 lw $a1, 0($a1) # load length form myArrayLen2 jal read_double_array # jump to read_double_array subprog li $v0, 4 # call code for print string la $a0, Print_a1 # load Print_a1 for print syscall # print Print_a1 la $a0, myBaseHolder1 # load address of myBaseHolder1 lw $a0, 0($a0) # load array address from myBaseHolder1 la $a1, myArrayLen1 # load address of myArrayLen1 lw $a1, 0($a1) # load length form myArrayLen1 jal print_double_array # jump to print_double_array subprog

li $v0, 4 # call code for print string la $a0, Print_a2 # load Print_a2 for print syscall # print Print_a2 la $a0, myBaseHolder2 # load address of myBaseHolder2 lw $a0, 0($a0) # load array address from myBaseHolder2 la $a1, myArrayLen2 # load address of myArrayLen2 lw $a1, 0($a1) # load length form myArrayLen2 jal print_double_array # jump to print_double_array subprog la $a0, myBaseHolder1 # load address of myBaseHolder1 lw $a0, 0($a0) # load array address from myBaseHolder1 la $a1, myArrayLen1 # load address of myArrayLen1 lw $a1, 0($a1) # load length form myArrayLen1 la $a2, myBaseHolder2 # load address of myBaseHolder2 lw $a2, 0($a2) # load array address from myBaseHolder2 la $a3, myArrayLen2 # load address of myArrayLen2 lw $a3, 0($a3) # load length form myArrayLen2 jal inner_product # jump to inner_product subprog

li $v0, 4 # system call code for print string la $a0, Print_inner # load Print_inner for printing syscall # print Print_inner

move $f12, $f0 # move $f12 to $f0 li $v0, 3 # call code for print double syscall # print inner product

li $v0, 10 # call code for exit syscall # Halt #########################################

######################################### # Subprogram Description #  Ask the user for an array length, dynamically alocate #   an array of doubles with the given length

######################################### # Arguments In and Out of subprogram # # $a0 # $a1 # $a2 # $a3 # $v0  Base address # $v1  Array length (number of elements) # $sp # $sp+4 # $sp+8 # $sp+12 ######################################### # Register Usage # $t0 # $t1 # $t2 # $t3 # $t4 # $t5 # $t6 # $t7 # $t8 # $t9 ######################################### .data Prompt_length: .asciiz "Enter length: "

# DO NOT put the words for the base addresses and lengths #  in this data section (main uses them, so put them with #  main)

######################################### .text make_double_array: # Ask user for an array length # Allocate an array of doubles with the given length li $v0, 4 # call code for print string la $a0, Prompt_length # load Prompt_length syscall # print 'enter length' li $v0, 5 # call code for read int syscall # read length move $v1, $v0 # Move length to $v1 for return sll $a0, $v0, 3 # $a0 = $v0 * 2^3 li $v0, 9 # call code for allocate memory syscall # allocate memory for array jr $ra #########################################

######################################### # Subprogram Description #  Reads doubles into an array until the array is full

######################################### # Arguments In and Out of subprogram # # $a0  Base address (IN) # $a1  Array length (IN) # $a2 # $a3 # $v0 # $v1 # $sp # $sp+4 # $sp+8 # $sp+12 ######################################### # Register Usage # $t0 # $t1 # $t2 # $t3 # $t4 # $t5 # $t6 # $t7 # $t8 # $t9 ######################################### .data Prompt_value: .asciiz "Enter value: "

######################################### .text read_double_array: # Read doubles from the console, store them in #  the array until the array is full move $t0, $a0 # move $a0 to $t0 move $t1, $a1 # move $a1 to $t1 read_loop: blez $t1, read_end # end when $t1 <= 0 li $v0, 4 # call code for print string la $a0, Prompt_value # load Prompt_value to print syscall # print Prompt_value li $v0, 7 # call code for read double syscall # read double s.d $f0, 0($t0) # store value to array addiu $t0, $t0, 8 # increment address to next index addiu $t1, $t1, -1 # decrement index b read_loop: # move to top of loop read_end: jr $ra #########################################

######################################### # Subprogram Description #  Prints doubles from an array, separated by spaces

######################################### # Arguments In and Out of subprogram # # $a0  Base address (IN) # $a1  Array length (IN) # $a2 # $a3 # $v0 # $v1 # $sp # $sp+4 # $sp+8 # $sp+12 ######################################### # Register Usage # $t0 # $t1 # $t2 # $t3 # $t4 # $t5 # $t6 # $t7 # $t8 # $t9 ######################################### .data Space: .asciiz " " ######################################### .text print_double_array: # Prints doubles from an array, separated by spaces move $t0, $a0 # move $a0 to $t0 move $t1, $a1 # move $a1 to $t1 read_loop: blez $t1, read_end # end when $t1 <= 0 l.d $f12, 0($t0) # load value to print li $v0, 3 # call code for print double syscall # print value li $v0, 4 # call code for print string la $a0, Space # load Space to print syscall # print Space addiu $t0, $t0, 8 # increment address to next index addiu $t1, $t1, -1 # decrement index b read_loop: # move to top of loop read_end: jr $ra #########################################

######################################### # Subprogram Description #  Calculates the inner product of two arrays or #   prints an error and returns 0.0 if they are not #   the same length # #  The inner product is the sum of the products of #   corresponding elements in two vectors #   A[0]*B[0] + A[1]*B[1] + ... + A[n]*B[n] # #  Example: #   inner_product([1, 3, -5], [4, -2, -1]) = 3 # #  The inner product is only defined for two vectors #   of the same length # #  'Inner product' is sometimes called 'dot product' #   or 'scalar product' # #  http://en.wikipedia.org/wiki/Dot_product #

######################################### # Arguments In and Out of subprogram # # $a0  Base address of A (IN) # $a1  Array length of A (IN) # $a2  Base address of B (IN) # $a3  Array length of B (IN) # $v0 # $v1 #   $f0|$f1  Inner product (OUT) # $sp # $sp+4 # $sp+8 # $sp+12 ######################################### # Register Usage # $t0 # $t1 # $t2 # $t3 # $t4 # $t5 # $t6 # $t7 # $t8 # $t9 ######################################### .data

######################################### # Program Description #  CS315 Lab 6 -  Floating-point # #  Ask the user for an array length #  Create a dynamic array of double-precision #   floating-point values of the given length #  Call read_double_array to fill the array #  Call print_double_array to print the array contents #  Call get_sum_avg to get the sum and average #  Print the sum and average #

######################################### # Register Usage # $t0 # $t1 # $t2 # $t3 # $t4 # $t5 # $t6 # $t7 # $t8 # $t9 ######################################### .data Prompt_length: .asciiz "Enter length: " Error_length: .asciiz "Invalid length." Average_array: .asciiz "Average: " Sum_array: .asciiz "Sum: "

arrayAddres: .word 0 # address of array arrayLength: .word 0 # length of array ######################################### .text main: li $v0, 4 # call code for print string la $a0, Prompt_length # load Prompt_length message syscall # print Prompt_length message li $v0, 5 # call code for read int syscall # read int

checkLength: bgtz $v0, contProg # continue program if length > 0 li $v0, 4 # call code for print string la $a0, Error_length # load Error_length message syscall # print Error_length message b main: contProg: la $a0, arrayLength # load address of arrayLength sw #v0, 0($a0) # store the array length mul $a0, $v0, 8 # multiply the length by 2 words li $v0, 9 # call code for allocating memory syscall # allocate array memory la $a0, arrayAddress # load address of arrayAddress sw $v0, 0($a0) # save address to arrayAddress la $a0, arrayAddress # load address of arrayAddress lw $a0, 0($a0) # load base address la $a1, arrayLength # load address of arrayLength lw $a1, 0($a1) # read length jal read_double_array # jump to read_double_array subprogram la $a0, arrayAddress # load address of arrayAddress lw $a0, 0($a0) # load base address la $a1, arrayLength # load address of arrayLength lw $a1, 0($a1) # read length jal print_double_array # jump to print_double_array subprogram la $a0, arrayAddress # load address of arrayAddress lw $a0, 0($a0) # load base address la $a1, arrayLength # load address of arrayLength lw $a1, 0($a1) # read length jal get_sum_avg # jump to get_sum_avg subprogram li $v0, 4 # call code for print string la $a0, sum_p # load Sum_array syscall # print Sum_array li $v0, 3 # call code for print double mov.d $f12, $f0 # move sum for print syscall # print sum li $v0, 4 # call code for print string la $a0, Average_array # load Average_array syscall # print Average_array li $v0, 3 # call code for print double mov.d $f12, 0($a0) # move sum for print syscall # print sum

li $v0, 10 # call code for quit syscall # Halt #########################################

######################################### # Subprogram Description #  Prints an array of words

######################################### # Arguments In and Out of subprogram # # $a0  Base address (IN) # $a1  Array length (IN) # $a2 # $a3 # $v0 # $v1 # $sp # $sp+4 # $sp+8 # $sp+12 ######################################### # Register Usage # $t0 # $t1 # $t2 # $t3 # $t4 # $t5 # $t6 # $t7 # $t8 # $t9 ######################################### .data Print_array: .asciiz "Array: " Space: .asciiz " " ######################################### .text print_double_array: # Print doubles from the array, separated by a space move $t0, $a0 # move array address to $t0 move $t1, $a1 # move array address to $t1 li $v0, 4 # call code for print string la $a0, Print_array # load Print_array syscall # print Print_array print_loop: blez $t1, end_print # branch to end when last index is passed l.d $f12, 0($t0) # load value to print li $v0, 3 # call code for print double syscall # read double input li $v0, 4 # call code for print string la $a0, Space # load Space syscall # print Space addiu $t0, $t0, 8 # increment to next double address addiu $t1, $t1, -1 # decrement index by 1 b print_loop # branch to top of loop end_print: jr $ra # jump back to main program #########################################

######################################### # Subprogram Description #  Reads words into an array

######################################### # Arguments In and Out of subprogram # # $a0  Base address (IN) # $a1  Array length (IN) # $a2 # $a3 # $v0 # $v1 # $sp # $sp+4 # $sp+8 # $sp+12 ######################################### # Register Usage # $t0 - address # $t1 - length # $t2 # $t3 # $t4 # $t5 # $t6 # $t7 # $t8 # $t9 # # $f0 - array element # $f1 - array element ######################################### .data Prompt_value .asciiz "Enter double: " ######################################### .text read_double_array: # Read doubles from the console, store them in #  the array until the array is full move $t0, $a0 # move array address to $t0 move $t1, $a1 # move array address to $t1 loop: blez $t1, end_read # branch to end when last index is passed li $v0, 4 # call code for print string la $a0, Prompt_value # load Prompt_value syscall # print Prompt_value li $v0, 7 # call code for read double syscall # read double input s.d $f0, 0($t0) # Store double addiu $t0, $t0, 8 # increment to next double address addiu $t1, $t1, -1 # decrement index by 1 b loop # branch to top of loop end_read: jr $ra # jump back to main program #########################################

######################################### # Subprogram Description #  Calculate sum and average of array

######################################### # Arguments In and Out of subprogram # # $a0  Base address (IN) # $a1  Array length (IN) # $a2 # $a3 # $v0 # $v1 #   $f0|$f1  Sum (OUT) #   $f2|$f3  Average (OUT) # $sp # $sp+4 # $sp+8 # $sp+12 ######################################### # Register Usage # $t0 # $t1 # $t2 # $t3 # $t4 # $t5 # $t6 # $t7 # $t8 # $t9 ######################################### .data

######################################### .text get_sum_avg: # Calculate and return the sum and average of #  all elements in the array move $t0, $a0 # move array address to $t0 move $t1, $a1 # move array address to $t1 li.d $f0, 0.0 # initialize sum to 0 li.d $f2, 0.0 # initialize average to 0 mtc1 $t1, $f6 # move length to coprocessor 1 cvt.d.w $f6, $f6 # convert int length to double sum_avg_loop: blez $t1, esum_avg_end # branch to end when last index is passed l.d $f4, 0($t0) # load element and index $t1 add.d $f0, $f0, $f4 # add loaded value to sum addiu $t0, $t0, 8 # increment to next double address addiu $t1, $t1, -1 # decrement index by 1 b sum_avg_loop # branch to top of loop sum_avg_end: iv.d $f2, $f0, $f6 # divide sum by length to get the avg