Intro to Computer Org.
description
Transcript of Intro to Computer Org.
Intro to Computer Org.
MIPS Assembly – Program Implementation
Composition of Programs
As we referenced before, all computer programs are represented as binary data.
This data must first be loaded into memory, then jumped to by an operating system in order to execute.
Composition of Programs
We know that programs are composed of multiple segments.Static data (compile-time constants) Instructions (the part that runs) Others we’ll see shortly
Dynamic data (requested at run-time)A stack (useful for temporary data,
facilitates use of functions)
Composition of Programs
Not all components of a program can be properly represented by assembly instructions.
To represent these other elements, assembly languages provide directives that allow for further specifications.
Assembler Directives
Some directives are used to specify the memory layout of the program. .text
Code segment .data
Data segment
Assembler Directives
Instructions and static data are placed toward the beginning of memory.
Dynamic data and the stack are free to grow during execution and are placed on opposite sides of the remaining memory.
Code Segment
.text must be the last segment-defining directive before a program’s instructions.
Data Segment
.data must be the last segment-defining directive before a program’s static data.Consists of all data that must be
globally accessible or memory-bound data that is known during compilation.
Global variablesLarge constants, like strings or fixed-size
arrays.
Data Segment
There are many directives designed for use within the .data segment to declare any statically-used memory the compiler/programmer may need.
Data Segment
.byte <byte1>, …, <byteN>Allocates memory for N bytes in a row,
initializing them to the given values..half <half1>, …, <halfN>
The same, for half-word values..word <word1>, …, <wordN>
The same, for word-length values.
Data Segment
Use a label on the same line as one of these directives in order to treat that line’s value(s) as an array of length N.Remember to adjust for the data’s
byte size on any loads or stores.
Data Segment
a: .word 5 a is an array of words with length 1. Can also think of it as a pointer to a word. The lone entry in the array has value 5.
b: .word 1, 2, 3, 4, 5 b is an array of words with length 5. The entries, in order, are 1, 2, 3, 4, and 5.
Data Segment
.asciiz <string> – Declares a string and null-terminates it.Each character takes up a single byte
of space. Is equivalent to:
.byte <char1>, …, <charN>, 0 In C, C++, and Java, strings are null-terminated, meaning there is an extra byte equaling 0 at the end.
Data Segment
prompt: .asciiz “Hello World!” Defines a string called prompt with the
value “Hello World!”. This can be used directly with the syscalls we will
learn about shortly.
Data Segment
.space n - Allocates n bytes of memory for future use.Useful if you wish to make a data
structure of a particular size, or just to define a large array of any numerical type.
Instead of .word 0, 0, …, 0 for 100 0’s, .space 400 will allocate that for you.
Data Segment
.align n – Sets the next element of data on a 2n memory address boundary.This is important because loads and
stores must be aligned on an appropriate boundary.
If the next element of data is a word, use n =2, for example. (Half-word => n = 1.)
Errors easily result from ignoring this.
Data Segment - Example
Write a program to find the sum of four integers specified in an array called ints.Run it with ints = [34, -7, 18, 23].Try a few other values.
Data Segment - Example
.data
ints: .word 34, -7, 18, 23
.text
.globl main
main:la $t0, intsli $t1, 4li $v0, 0
sum:lw $t3, 0($t0)add $v0, $v0, $t3
#Go to the next elementaddi $t0, $t0, 4
#Decrement count of intsaddi $t1, $t1, -1bne $t1, $0, sum
#result is in $v0
jr $ra
System Calls
Since we’re using PCSpim to run our MIPS code, we have access to a few special facilities known as system calls, or syscalls, for short.
Each one takes care of some basic, yet somewhat complex task, on behalf of the programmer.
System Calls
Each system call is performed by setting $v0 to the appropriate code, then using the instruction syscall in order to perform the operation.Ex: li $v0, 10
syscall #The exit syscall.
System Calls
Some syscalls take arguments – the first argument will be in $a0, and the second argument will be in $a1.Ex: li $v0, 1
li $a0, 37syscall #Prints 37.
System Calls
Some syscalls return values, placing that value in $v0.
Ex: li $v0, 5syscall#Gets int from the user,#puts it in $v0.
System Calls
syscall 1 – Prints the integer found in $a0.
syscall 4 – Prints the string found at the address in $a0.Combined with the earlier label prompt, we can use this to say “Hello World!”.
System Calls
syscall 5 – Reads in an integer from the console, places the value in $v0.
syscall 8 – Reads a string of at most $a1 bytes into a buffer at the address in $a0.Warning – this includes the null-
termination character!
System Calls
syscall 10 – the equivalent of System.exit() in Java.Automatically terminates the program.
System Calls
syscall 9 – Allocates $a0 bytes dynamically (i.e., at run time), giving the address of said bytes in $v0.This is the equivalent of the following
line in Java-like form.
byte[] $v0 = new byte[$a0];
System Calls
syscall 9 – Allocates $a0 bytes dynamically (i.e., at run time), giving the address of said bytes in $v0. It can also be seen as the run-time
equivalent of the .space directive.Called sbrk on the some reference.
System Calls
Dynamic data and the stack are free to grow during execution and are placed on opposite sides of the remaining memory.
We’ll learn about the purpose of the stack in a few lectures.
System Calls – Example 1
Write a program to find the sum of four integers specified by the user.Store them in an array first, and
perform the summation after getting all of the integers. (For practice.)
Run it with ints = [34, -7, 18, 23].Try a few other values.
System Calls – Example 1
.data
ints: .space 16prompt: .asciiz “Enter an int: ”result:.asciiz “Sum: “
.text
.globl main
main:la $t0, intsli $t1, 4
input:la $a0, promptli $v0, 4syscall #Give prompt
li $v0, 5syscall #Get int
sw $v0, 0($t0)
addi $t0, $t0, 4addi $t1, $t1, -1bne $t1, $0, input
System Calls – Example 1
input:la $a0, promptli $v0, 4syscall #Give prompt
li $v0, 5syscall #Get int
sw $v0, 0($t0)
addi $t0, $t0, 4addi $t1, $t1, -1bne $t1, $0, input
inputDone:la $t0, intsli $t1, 4li $t2, 0
sum:lw $t3, 0($t0)add $t2, $t2, $t3
addi $t0, $t0, 4addi $t1, $t1, -1bne $t1, $0, sum
System Calls – Example 1
inputDone:la $t0, intsli $t1, 4li $t2, 0
sum:lw $t3, 0($t0)add $t2, $t2, $t3
addi $t0, $t0, 4addi $t1, $t1, -1bne $t1, $0, sum
sumDone:li $v0, 4la $a0, resultsyscall #Give text
li $v0, 1move $a0, $t2syscall #Print result
jr $ra
System Calls – Example 2
Write a program that takes two strings (from memory) and concatenates them together.Use lbu and sb to operate on byte-
sized data. (load byte unsigned / store byte)
Note that we aren’t given the length of the strings.
Try it on “Hello ” + “World!”.
System Calls – Example 2
Write a program that takes two strings (from memory) and concatenates them together.
1. Find lengths of each string.2. Allocate space for the new string.3. Copy each string until the null-
termination character.4. Write null-termination character.
System Calls – Example 2
.data
str1: .asciiz “Hello ”str2: .asciiz “World!”
.text
.globl main
main:li $t0, -1li $t1, -1la $t2, str1la $t3, str2
getLen1:lb $t4, 0($t2)addi $t0, $t0, 1addi $t2, $t2, -1bne $t4, $0, getLen1
System Calls – Example 2
main:li $t0, -1li $t1, -1la $t2, str1la $t3, str2
getLen1:lb $t4, 0($t2)addi $t0, $t0, 1addi $t2, $t2, 1bne $t4, $0, getLen1
getLen2:lb $t4, 0($t3)addi $t1, $t1, 1addi $t3, $t3, 1bne $t4, $0, getLen2
#$t0 = length(str1)#$t1 = length(str2)
add $a0, $t0, $t1addi $a0, $a0, 1
System Calls – Example 2
getLen2:lb $t4, 0($t3)addi $t1, $t1, 1addi $t2, $t2, 1bne $t4, $0, getLen1
#$t0 = length(str1)#$t1 = length(str2)
add $a0, $t0, $t1addi $a0, $a0, 1
#$a0 = needed bytes for#str1 + str2.
li $v0, 9#$a0 is loaded.syscallmove $t5, $v0move $t6, $v0
#$t5 & $t6 now hold the #final string’s address.
la $t2, str1la $t3, str2
System Calls – Example 2
#$a0 = needed bytes for#str1 + str2.
li $v0, 9#$a0 is loaded.syscallmove $t5, $v0move $t6, $v0
#$t5 & $t6 now hold the #final string’s address.
la $t2, str1la $t3, str2
cpyStr1:lb $t4, 0($t2)
#Skip to next loop#if it’s ‘/0’.beq $t4, $0, cpyStr2
sb $t4, 0($t5)addi $t2, $t2, 1addi $t5, $t5, 1j cpyStr1
System Calls – Example 2
cpyStr1:lb $t4, 0($t2)
#Skip to next loop#if it’s ‘/0’.beq $t4, $0, cpyStr2
sb $t4, 0($t5)addi $t2, $t2, 1addi $t5, $t5, 1j cpyStr1
cpyStr2:lb $t4, 0($t3)
#Skip to next loop#if it’s ‘/0’.beq $t4, $0, cpyDone
sb $t4, 0($t5)addi $t3, $t3, 1addi $t5, $t5, 1j cpyStr2
System Calls – Example 2
cpyStr2:lb $t4, 0($t3)
#Skip to next loop#if it’s ‘/0’.beq $t4, $0, cpyDone
sb $t4, 0($t5)addi $t3, $t3, 1addi $t5, $t5, 1j cpyStr2
cpyDone:#Now we null-terminate#and display the result.
sb $0, 0($t5)
#Original final string#address is in $t6.
move $a0, $t6li $v0, 4syscall
jr $ra