Some More Programming in Assembly

• I would like to do some basic array manipulation.
  • Declare, fill, access elements in an array.
• Declaration
  • Equivalent to int ary[MAX_SIZE];
  • In the data section

  • .data
    
    MAX_SIZE:		.word 7
    ARRAY:			.space 28  # NAX_SIZE*4

  • Why times 4?
  • We need to make sure that this is word aligned.
    • Since it immediately follows MAX_SIZE which is both word sized and word aligned, we know our data is too.
• Index vs offset

  • for (i=0; i < MAX_SIZE; ++i) {
         A[i] = i;
    } 

  • I maintain two variables, offset and index
  • This is not needed, but easier to read.
  • $t0 will hold the index, i
  • $t1 will hold the offset, i*4

  • 	li $t0, 0
    	li $t1, 0
    	lw $t2, MAX_SIZE
    
    TOP_OF_LOOP_1:
    
    	# while i < MAX_SIZE
    	beq $t0, $t2, OUT_OF_LOOP_1
    	     # A[i] = i
    	     sw $t0, ARRAY($t1)
    
    	     # i = i + 1
    	     addi $t0, $t0, 1
    	     # but I also have to add 4 to the actual offset
    	     addi $t1, $t1, 4
                 j TOP_OF_LOOP_1
    
    OUT_OF_LOOP_1:

• Let's stop and look at sw and lw
  • They are i type
  • sw $rt, immediate($rs)
  • M[R[$rs] + SignExtend(immediate) ] = R[$rt]
  • This is BUILT for indexing into an array.
  • Notice that these instructions use the ALU, but for addition.
  • Notice that these get turned into multiple machine instructions
    • While we may discuss this later
    • The 16 bit immediate does not allow us to address all of memory
    • the combination of lui (Load upper immediate) and addu (add unsigned) allow us to address ALL of memory.
    • This means that the instruction fits in 32 bits.
    • As opposed to an instruction that takes 2 32 bit words.
  • So a quick look
    • lui $1, 4097
      • $4097 = 1001_{16}$.
      • So the top half of the register is set to this pattern
      • And the bottom half is set to 0
      • $0x10010000$
      • But take a look at the address of the data segment.
      • Note, $1 is at which is the assembler temporary
    • addu $1, $1, $9
      • Adds the contents of the register in the original sw to the temp register.
      • This calculates the effective address, relative to the address
    • sw $8, 4($1)
      • Array is actually 4 bytes off of the beginning of the data segment.
    • Isn't the assembler a wonderful program!
• move $t0, $t2
  • This is just a pseudo-instruction
  • addu $t0, $zero, $t2
  • $zero is a register that always has a 0
    • Write to it and it stays 0
    • Read from it and it is a 0.
    • This is just for this sort of operation.
• mult $t1, $t5
  • We will most likely not discuss the implementation of this function.
  • It uses two special purpose registers $lo, $hi.
    • $hi will contain the high 32 bits of the product
    • $lo will contain the low 32 bits of the product.
  • mflo $t1 will move the low 32 bits to t1.
  • mfhi $t6 will move the high 32 bits to t6.
  • There is just not enough time, so we will not discuss mult in detail.
• div $t1, $t2
  • $lo = $t1/$t2
  • $hi = $t1 % $t2
  • There is just not enough time, so we will not discuss div in detail.
• The code is here