MIPS Architecture and Assembly Language Overview

Transcription

1 MIPS Architecture and Assembly Language Overview Adapted frm: [Register Descriptin] [I/O Descriptin] Data Types and Literals Data types: Instructins are all 32 bits byte(8 bits), halfwrd (2 bytes), wrd (4 bytes) a character requires 1 byte f strage an integer requires 1 wrd (4 bytes) f strage Literals: numbers entered as is. e.g. 4 Registers characters enclsed in single qutes. e.g. 'b' strings enclsed in duble qutes. e.g. "A string" 32 general-purpse registers register preceded by $ in assembly language instructin tw frmats fr addressing: using register number e.g. $0 thrugh $31 using equivalent names e.g. $t1, $sp special registers L and Hi used t stre result f multiplicatin and divisin nt directly addressable; cntents accessed with special instructin mfhi ("mve frm Hi") and mfl ("mve frm L") stack grws frm high memry t lw memry This is frm Figure 9.9 in the Gdman&Miller text Register Number Alternative Name 0 zer the value 0 Descriptin 1 $at (assembler temprary) reserved by the assembler

2 2-3 $v0 - $v1 4-7 $a0 - $a $t0 - $t $s0 - $s7 (values) frm expressin evaluatin and functin results (arguments) First fur parameters fr subrutine. Nt preserved acrss prcedure calls (tempraries) Caller saved if needed. Subrutines can use w/ut saving. Nt preserved acrss prcedure calls (saved values) - Callee saved. A subrutine using ne f these must save riginal and restre it befre exiting. Preserved acrss prcedure calls (tempraries) Caller saved if needed. Subrutines can $t8 - $t9 use w/ut saving. These are in additin t $t0 - $t7 abve. Nt preserved acrss prcedure calls $k0 - $k1 reserved fr use by the interrupt/trap handler 28 $gp 29 $sp glbal pinter. Pints t the middle f the 64K blck f memry in the static data segment. stack pinter Pints t last lcatin n the stack. 30 $s8/$fp saved value / frame pinter Preserved acrss prcedure calls 31 $ra return address See als Brittn sectin 1.9, Sweetman sectin 2.21, Larus Appendix sectin A.6 Prgram Structure just plain text file with data declaratins, prgram cde (name f file shuld end in suffix.s t be used with SPIM simulatr) data declaratin sectin fllwed by prgram cde sectin Data Declaratins placed in sectin f prgram identified with assembler directive.data declares variable names used in prgram; strage allcated in main memry (RAM) Cde placed in sectin f text identified with assembler directive.text

3 cntains prgram cde (instructins) starting pint fr cde e.g.ecutin given label main: ending pint f main cde shuld use exit system call (see belw under System Calls) Cmments anything fllwing # n a line # This stuff wuld be cnsidered a cmment Template fr a MIPS assembly language prgram: # Cmment giving name f prgram and descriptin f functin # Template.s # Bare-bnes utline f MIPS assembly language prgram.data # variable declaratins fllw this line #....text # instructins fllw this line main: # indicates start f cde (first instructin t execute) #... # End f prgram, leave a blank line afterwards t make SPIM happy Data Declaratins frmat fr declaratins: name: strage_type value(s) create strage fr variable f specified type with given name and specified value value(s) usually gives initial value(s); fr strage type.space, gives number f spaces t be allcated Nte: labels always fllwed by cln ( : ) example var1:.wrd 3 # create a single integer variable with initial value 3 array1:.byte 'a','b' # create a 2-element character array with elements initialized # t a and b array2:.space 40 # allcate 40 cnsecutive bytes, with strage uninitialized # culd be used as a 40-element character array, r a

4 indicate which! # 10-element integer array; a cmment shuld Lad / Stre Instructins RAM access nly allwed with lad and stre instructins all ther instructins use register perands lad: lw register_destinatin, RAM_surce #cpy wrd (4 bytes) at surce RAM lcatin t destinatin register. lb register_destinatin, RAM_surce #cpy byte at surce RAM lcatin t lw-rder byte f destinatin register, # and sign-e.g.tend t higher-rder bytes stre wrd: sw register_surce, RAM_destinatin #stre wrd in surce register int RAM destinatin sb register_surce, RAM_destinatin #stre byte (lw-rder) in surce register int RAM destinatin lad immediate: li register_destinatin, value #lad immediate value int destinatin register example:.data var1:.wrd 23 # declare strage fr var1; initial value is 23.text start: lw $t0, var1 # lad cntents f RAM lcatin int register $t0: $t0 = var1 li $t1, 5 # $t1 = 5 ("lad immediate") sw $t1, var1 # stre cntents f register $t1 int RAM: var1 = $t1 dne Indirect and Based Addressing Used nly with lad and stre instructins lad address: la $t0, var1 cpy RAM address f var1 (presumably a label defined in the prgram) int register $t0

5 indirect addressing: lw $t2, ($t0) lad wrd at RAM address cntained in $t0 int $t2 sw $t2, ($t0) stre wrd in register $t2 int RAM at address cntained in $t0 based r indexed addressing: lw $t2, 4($t0) lad wrd at RAM address ($t0+4) int register $t2 "4" gives ffset frm address in register $t0 sw $t2, -12($t0) stre wrd in register $t2 int RAM at address ($t0-12) negative ffsets are fine Nte: based addressing is especially useful fr: arrays; access elements as ffset frm base address stacks; easy t access elements at ffset frm stack pinter r frame pinter example.data array1:.space 12 # declare 12 bytes f strage t hld array f 3 integers.text start: la $t0, array1 # lad base address f array int register $t0 li $t1, 5 # $t1 = 5 ("lad immediate") sw $t1, ($t0) # first array element set t 5; indirect addressing li $t1, 13 # $t1 = 13 sw $t1, 4($t0) # secnd array element set t 13 li $t1, -7 # $t1 = -7 sw $t1, 8($t0) # third array element set t -7 dne Arithmetic Instructins mst use 3 perands all perands are registers; n RAM r indirect addressing perand size is wrd (4 bytes) add $t0,$t1,$t2 # $t0 = $t1 + $t2; add as signed (2's cmplement) integers sub $t2,$t3,$t4 # $t2 = $t3 Ð $t4

6 addi $t2,$t3, 5 # $t2 = $t3 + 5; "add immediate" (n sub immediate) addu $t1,$t6,$t7 # $t1 = $t6 + $t7; add as unsigned integers subu $t1,$t6,$t7 # $t1 = $t6 + $t7; subtract as unsigned integers mult $t3,$t4 # multiply 32-bit quantities in $t3 and $t4, and stre 64-bit # result in special registers L and Hi: (Hi,L) = $t3 * $t4 div $t5,$t6 # L = $t5 / $t6 (integer qutient) # Hi = $t5 md $t6 (remainder) mfhi $t0 # mve quantity in special register Hi t $t0: $t0 = Hi mfl $t1 # mve quantity in special register L t $t1: $t1 = L # used t get at result f prduct r qutient mve $t2,$t3 # $t2 = $t3 Cntrl Structures Branches cmparisn fr cnditinal branches is built int instructin b target # uncnditinal branch t prgram label target beq $t0,$t1,target # branch t target if $t0 = $t1 blt $t0,$t1,target # branch t target if $t0 < $t1 ble $t0,$t1,target # branch t target if $t0 <= $t1 bgt $t0,$t1,target # branch t target if $t0 > $t1 bge $t0,$t1,target # branch t target if $t0 >= $t1 bne $t0,$t1,target # branch t target if $t0 <> $t1 Jumps j target # uncnditinal jump t prgram label target jr $t3 # jump t address cntained in $t3 ("jump register") Subrutine Calls subrutine call: "jump and link" instructin jal sub_label # "jump and link" cpy prgram cunter (return address) t register $ra (return address register) jump t prgram statement at sub_label subrutine return: "jump register" instructin jr $ra # "jump register" jump t return address in $ra (stred by jal instructin)

7 Nte: return address stred in register $ra; if subrutine will call ther subrutines, r is recursive, return address shuld be cpied frm $ra nt stack t preserve it, since jal always places return address in this register and hence will verwrite previus value System Calls and I/O (SPIM Simulatr) used t read r print values r strings frm input/utput windw, and indicate prgram end use syscall perating system rutine call first supply apprpriate values in registers $v0 and $a0-$a1 result value (if any) returned in register $v0 The fllwing table lists the pssible syscall services. Service Cde in $v0 Arguments print_int 1 $a0 = integer t be printed print_flat 2 $f12 = flat t be printed print_dubl e print_string 4 3 $f12 = duble t be printed $a0 = address f string in memry Results read_int 5 integer returned in $v0 read_flat 6 flat returned in $v0 read_duble 7 read_string 8 $a0 = memry address f string input buffer $a1 = length f string buffer (n) duble returned in $v0 sbrk 9 $a0 = amunt address in $v0 exit 10 The print_string service expects the address t start a null-terminated character string. The directive.asciiz creates a null-terminated character string. The read_int, read_flat and read_duble services read an entire line f input up t and including the newline character. The read_string service has the same semantices as the UNIX library rutine fgets.

8 It reads up t n-1 characters int a buffer and terminates the string with a null character. If fewer than n-1 characters are in the current line, it reads up t and including the newline and terminates the string with a null character. The sbrk service returns the address t a blck f memry cntaining n additinal bytes. This wuld be used fr dynamic memry allcatin. The exit service stps a prgram frm running. e.g. Print ut integer value cntained in register $t2 li $v0, 1 # lad apprpriate system call cde int register $v0; # cde fr printing integer is 1 mve $a0, $t2 # mve integer t be printed int $a0: $a0 = $t2 syscall # call perating system t perfrm peratin e.g. Read integer value, stre in RAM lcatin with label int_value (presumably declared in data sectin) li $v0, 5 # lad apprpriate system call cde int register $v0; # cde fr reading integer is 5 syscall # call perating system t perfrm peratin sw $v0, int_value # value read frm keybard returned in register $v0; # stre this in desired lcatin e.g. Print ut string (useful fr prmpts).data string1.asciiz "Print this.\n" # declaratin fr string variable, #.asciiz directive makes string null terminated.text main: li $v0, 4 # lad apprpriate system call cde int register $v0; # cde fr printing string is 4 la $a0, string1 # lad address f string t be printed int $a0 syscall # call perating system t perfrm print peratin e.g. T indicate end f prgram, use exit system call; thus last lines f prgram shuld be: li $v0, 10 # system call cde fr exit = 10 syscall # call perating sys

9