s Pim Slides

8/2/2019 s Pim Slides

1/35

Computer Organization and

Architecture (AT70.01)Comp. Sc. and Inf. Mgmt.

Asian Institute of TechnologyInstructor: Dr. Sumanta Guha

Slide Sources: Freely

downloadable material adaptedand supplemented


2/35

Overview of SPIM the MIPS

simulator


3/35

Introduction What is SPIM?

a simulatorthat runs assembly programsfor MIPSR2000/R3000RISC computers

What does SPIM do?

readsMIPS assembly language files and translatesto machinelanguage

executesthe machine language instructions

shows contents ofregistersand memory works as a debugger(supports break-pointsand single-stepping)

provides basic OS-like services, like simple I/O


4/35

MIPS & SPIM Resources1. Computer Organization & Design: The Hardware/Software

Interface, by Patterson and Hennessy: Chapter 3 andAppendix A.9-10

2. Bradley Kjells Programmed Introduction to MIPS AssemblyLanguage on-line tutorial athttp://chortle.ccsu.edu/AssemblyTutorial/tutorialContents.html#part3

A copy is available locally courtesy of Prof. Kjell (see classwebsite)

This is an excellent tutorialmake sure to go through it all

lesson by lesson!!3. Other on-line resources

4. Class website

5. Papers in department office available for you to copy
http://chortle.ccsu.edu/AssemblyTutorial/tutorialContents.htmlhttp://chortle.ccsu.edu/AssemblyTutorial/tutorialContents.html


5/35

Learning MIPS & SPIM MIPS assembly is a low-level programming language

The best way to learn any programming language is from livecode

We will get you started by going through a few example

programs and explaining the key concepts Further, we have an Examples directory of several simple well-

documented assembly programs for you to experiment with

We will not try to teach you the syntax line-by-line: pick upwhat you need from the book and on-line tutorials

Tip: Start by copying existing programs and modifying themincrementally making sure you understand the behavior at eachstep

Tip: The best way to understand and remember a construct orkeyword is to experiment with it in code, not by reading about it


6/35

PCSpim Installation Windows Installation

download the file http://www.cs.wisc.edu/~larus/SPIM/pcspim.zipand save it on your machine. For your convenience a

copy is kept locally at the class website unzip the file

run the setup.exeprogram


7/35

PCSpim Windows Interface Registers window

shows the values of allregisters in the MIPS CPU and

FPU Text segment window

shows assembly instructions &corresponding machine code

Data segment window

shows the data loaded into theprograms memory and thedata of the programs stack

Messages window

shows PCSpim messages

Separate console window appears for I/O


8/35

Using SPIM Loading source file

Use File-> Openmenu

Simulation

Simulator->Settings : in the Displaysection check only the first two items Save window

positionsand General registers in hexadecimal

in the Executionsection check onlyAllow pseudo instruction

Simulator->Set Value : to load PC with address of first instruction enterAddress or Register Nameas PC and enter Valueas 0x00400000

reason: the text areaof memory, where programs are stored, starts here Simulator-> Go: run loaded program

Click the OKbutton in the Run Parameterspop-upwindow if theStartingAddress:value is 0x00400000

Simulator-> Break: stop execution

Simulator-> Clear Registersand Reinitialize: clean-up before new

run


9/35

Using SPIM Simulator-> Reload: load file again after editing

Simulator-> Single Stepor Multiple Step: stepping to debug

Simulator-> Breakpoints: set breakpoints

Notes: text segment window of SPIM shows assembly and corresponding

machine code

pseudo-instructions each expand to more than one machine instruction

ifLoad trap fileis checked in Simulator->Settings then text

segment shows additional trap-handling code ifDelayed Branchesis checked in Simulator->Settings then

statementx will execute before control jumps to L1 in followingcode to avoid insert nopbefore statementx:

nopjal L1

statementx

L1:


10/35

SPIM Example Program:

add2numbersProg1.asm## Program adds 10 and 11

.text # text section

.globl main # call main by SPIM

main:

ori $8,$0,0xA # load 10" into register 8

ori $9,$0,0xB # load 11" into register 9

add $10,$8,$9 # add registers 8 and 9, put result

# in register 10


11/35

MIPS Assembly Code Layout Typical Program Layout

.text #code section

.globl main #starting point: must be global

main:

# user program code

.data #data section

# user program data


12/35

MIPS Assembler Directives Top-level Directives:

.text

indicates that following items are stored in the user text segment,typically instructions

.data indicates that following data items are stored in the data segment

.globlsym

declare that symbol sym is global and can be referenced from otherfiles


13/35


add2numbersProg2.asm# Program adds 10 and 20



main:

la $t0, value # load address value into $t0

lw $t1, 0($t0) # load word 0(value) into $t1

lw $t2, 4($t0) # load word 4(value) into $t2

add $t3, $t1, $t2 # add two numbers into $t3

sw $t3, 8($t0) # store word $t3 into 8($t0)

.data # data section

value: .word 10, 20, 0 # load data integers. Default data

# start address 0x10010000(= value)

Parse themachine codefor these twoinstructions!


14/35

MIPS Memory Usage as viewed in

SPIM

reserved

0x00000000

0x00400000

0x10010000

0x7fffeffc0x7fffffff

text segment

(instructions)

data segment

stack segment

reserved


15/35

MIPS Assembler Directives Common Data Definitions:

.word w1, , wn store n 32-bit quantities in successive memory words

.half h1, , hn store n 16-bit quantities in successive memory halfwords

.byte b1, , bn store n 8-bit quantities in successive memory bytes

.ascii str store the string in memory but do not null-terminate it

strings are represented in double-quotes str special characters, eg. \n, \t, follow C convention

.asciiz str store the string in memory and null-terminate it


16/35

MIPS Assembler Directives Common Data Definitions:

.float f1, , fn store n floating point single precision numbers in successive memory

locations .double d1, , dn

store n floating point double precision numbers in successive memorylocations

.space n reserves n successive bytes of space

.align n align the next datum on a 2n byte boundary. For example, .align 2

aligns next value on a word boundary. .align 0 turns off automaticalignment of.half, .word, etc. till next .data directive


17/35

SPIM Example Program:storeWords.asm

## Program shows memory storage and access (big vs. little endian).data

here: .word 0xabc89725, 100

.byte 0, 1, 2, 3

.asciiz "Sample text"

there: .space 6

.byte 85

.align 2

.byte 32

.text

.globl main

main:la $t0, here

lbu $t1, 0($t0)

lbu $t2, 1($t0)

lw $t3, 0($t0)

sw $t3, 36($t0)

sb $t3, 41($t0)

Word placementin memory is exactly same inbig or little endian a copy is placed.

Byte placement in memory depends on if it isbig or little endian. In big-endian bytes in aWord are counted from the byte 0 at the left(most significant) to byte 3 at the right(least significant); in little-endian it is theother way around.

Word access(lw, sw) is exactly same in big orlittle endian it is a copy from register toa memory word or vice versa.

Byte accessdepends on if it is big or little endian,because bytes are counted 0 to 3 from left to rightin big-endian and counted 0 to 3 from right to

left in little-endian.

SPIMs memory storage depends on the underlyingmachine: Intel 80x86 processors are little-endian!


18/35


swap2memoryWords.asm## Program to swap two memory words

.data # load data

.word 7

.word 3

.text

.globl main

main:

lui $s0, 0x1001 # load data area start address 0x10010000lw $s1, 0($s0)

lw $s2, 4($s0)

sw $s2, 0($s0)

sw $s1, 4($s0)


19/35


branchJump.asm## Nonsense program to show address calculations for

## branch and jump instructions



# Nonsense code

# Load in SPIM to see the address calculations

main:

j label

add $0, $0, $0

beq $8, $9, label

add $0, $0, $0

add $0, $0, $0

add $0, $0, $0

add $0, $0, $0

label:

add $0, $0, $0


20/35


procCallsProg2.asm.text

.globl main

main:

la $a0, arrayaddi $a1, $0, 0

addi $sp, $sp, -4

sw $ra, 0($sp)

jal swap

lw $ra, 0($sp)

addi $sp, $sp, 4

jr $ra

# equivalent C code:

# swap(int v[], int k)

# {

# int temp;

# temp = v[k];

# v[k] = v[k+1];

# v[k+1] = temp;

# }# swap contents of elements $a1

# and $a1 + 1 of the array that

# starts at $a0

swap: add $t1, $a1, $a1

add $t1, $t1, $t1

add $t1, $a0, $t1

lw $t0, 0($t1)lw $t2, 4($t1)

sw $t2, 0($t1)

sw $t0, 4($t1)

jr $ra

.dataarray: .word 5, 4, 3, 2, 1

## Procedure call to swap two array words

save returnaddress $rain stack

jump and

link to swaprestorereturnaddress

jump to $ra

load para-meters forswap


21/35

0 zero constant 0

1 at reserved for assembler

2 v0 results from callee

3 v1 returned to caller

4 a0 arguments to callee

5 a1 from caller: caller saves

6 a2

7 a3

8 t0 temporary: caller saves

. . . (callee can clobber)

15 t7

MIPS: Software Conventionsfor Registers

16 s0 callee saves

. . . (caller can clobber)

23 s7

24 t8 temporary (contd)

25 t9

26 k0 reserved for OS kernel

27 k1

28 gp pointer to global area

29 sp stack pointer

30 fp frame pointer

31 ra return Address (HW):

caller saves


22/35

SPIM System Calls System Calls (syscall)

OS-like services

Method load system call code into register $v0 (see following table for codes)

load arguments into registers $a0, , $a3

call system with SPIM instruction syscall

after call return value is in register $v0, or $f0 for floating point results


23/35

SPIM System Call CodesService Code (put in $v0) Arguments Result

print_int 1 $a0=integer

print_float 2 $f12=float

print_double 3 $f12=doubleprint_string 4 $a0=addr. of string

read_int 5 int in $v0

read_float 6 float in $f0

read_double 7 double in $f0read_string 8 $a0=buffer,

$a1=length

sbrk 9 $a0=amount addr in $v0

exit 10



24/35

SPIM Example Program:systemCalls.asm

## Enter two integers in

## console window

## Sum is displayed

.text

.globl main

main:

la $t0, value

li $v0, 5syscall

sw $v0, 0($t0)

li $v0, 5

syscall

sw $v0, 4($t0)

lw $t1, 0($t0)

lw $t2, 4($t0)

add $t3, $t1, $t2

sw $t3, 8($t0)

li $v0, 4

la $a0, msg1

syscall

li $v0, 1move $a0, $t3

syscall

li $v0, 10

syscall

.data

value: .word 0, 0, 0

msg1: .asciiz Sum = "

system call codefor read_int

result returned by call

argument to print_string call

system call codefor print_string

system call codefor print_int

argument to print_int call

system call codefor exit


25/35

More SPIM Example Programs In the Examples directory you will find 18 simple well-documented MIPS

assembly programs. Run the code in the order below of increasing complexity.1, 2, 3, 4, 5, 6, and 15 have already been discussed in these slides.

1. add2numbersProg1

2. add2numbersProg2

3. storeWords

4. swap2memoryWords

5. branchJump

6. systemCalls

7. overflow

8. averageOfBytes

9. printLoop

10. sumOfSquaresProg1



13. procCallsProg1

14. procCallsProg1Modified

15. procCallsProg2

16. addFirst100

17. factorialNonRecursive

18. factorialRecursive


26/35

Conclusion & More The code presented so far should get you started in writing your

own MIPS assembly

Remember the only way to master the MIPS assemblylanguage in fact, any computer language is to write lots andlots of code

For anyone aspiring to understand modern computerarchitecture it is extremely important to master MIPS assemblyas all modern computers (since the mid-80s) have beeninspired by, if not based fully or partly on the MIPS instruction

set architecture To help those with high-level programming language (e.g., C)

experience, in the remaining slides we show how to synthesizevarious high-level constructs in assembly


27/35

Synthesizing Control

Statements (if, if-else)if ( condition ) {statements

}

beqz $t0, if_end_label

# MIPS code for the

# if-statements.

if_end_label:

if ( condition ) {

if-statements

} else {

else-statements}

beqz $t0, if_else_label

# MIPS code for the

# if-statements.

j if_end_label

if_else_label:

# MIPS code for the

# else-statements

if_end_label:


28/35


Statements (while)while ( condition ) {

statements

}

while_start_label:

# MIPS code for the condition expression

beqz $t0, while_end_label

# MIPS code for the while-statements.

j while_start_label

while_end_label:


29/35


Statements (do-while)do {

statements

} while ( condition );

do_start_label:

# MIPS code for the do-statements.

do_cond_label:

# MIPS code for the condition expr:

beqz $t0, do_end_label

j do_start_label

do_end_label:


30/35


Statements (for)for ( init ; condition ; incr ) {

statements

}

# MIPS code for the init expression.for_start_label:

# MIPS code for the condition expression

beqz $t0, for_end_label

# MIPS code for the for-statements.

for_incr_label:

# MIPS code for the incr expression.

j for_start_label

for_end_label:


31/35


Statements (switch)switch ( expr ) {

case const1:

statement1

case const2:statement2

...

case constN:

statementN

default:default-

statement

}

# MIPS code to compute expr.

# Assume that this leaves the

# value in $t0

beq $t0, const1, switch_label_1

beq $t0, const2, switch_label_2

...

beq $t0, constN, switch_label_N

# If there is a default, then add

b switch_default

# Otherwise, add following lineinstead:

b switch_end_label


32/35


Statements (switch), cont.switch_label_1:# MIPS code to compute statement1.

switch_label_2:

# MIPS code to compute statement2.

...

switch_label_N:

# MIPS code to compute statementN.

# If there's a default:

switch_default:

# MIPS code to compute default-statement.

switch_end_label:


33/35

Array Address CalculationAddress calculation in assembler:address of A [n] = address of A [0] + (n* sizeof (element of A))

# $t0 = address of start of A.

# $t1 = n.

mul $t2, $t1, 4 # compute offset from

# the start of the array

# assuming sizeof(element)=4

add $t2, $t0, $t2 # add the offset to the

# address of A [0].# now $t2 = &A [n].

sw $t3, ($t2) # A [n] = whatever is in $t3.

lw $t3, ($t2) # $t3 = A [n].


34/35

Short-Cut Expression

Evaluation (and)cond1 && cond2

# MIPS code to compute cond1.

# Assume that this leaves the value in $t0.

# If $t0 is zero, we're finished

# (and the result is FALSE).

beqz $t0, and_end



and_end:


35/35

Short-Cut Expression

Evaluation (or)cond1 || cond2

# MIPS code to compute cond1.# Assume that this leaves the value in $t0.

# If $t0 is not zero, we're finished

# (and the result is TRUE).

bnez $t0, or_end



or_end:

s Pim Slides

Documents

Transcript of s Pim Slides