Post on 31-Dec-2015
transcript
Comp Sci 251 -- vars & expns1
Ch. 4 Variables and Expressions
Comp Sci 251 -- vars & expns2
Supporting high-level languages
How do we use MIPS assembly language to implement– Variable declaration & initialization?– Assignment statements?– Expression evaluation?
Comp Sci 251 -- vars & expns3
Program structure
#### File: foo.a#### Brief explanation of program's purpose#### Author: Your name## Date: 10 February 2010##
######################################## Text segment #
#######################################.text.globl __start
__start:
[program instructions...]
li $v0, 10 #exitsyscall
######################################### Data segment #########################################.data
[data definitions...]
## end of file foo.a[blank line]
Note: file extension .a
syscalls Service Call code Arguments Result
Print_integer 1 $a0 = integer
Print_float 2 $f12 = float
Print_double 3 $f12, $f13 = double
Print_string 4 $a0 = address of string
Read_int 5 $v0 (integer)
Read_float 6 $f0 (float)
Read_double 7 $f0, $f1 (double)
Read_string 8 $a0 = buffer, $a1 = length
Exit 10
Print_char 11 $a0 = char
Read_char 12 $v0 (char)
Comp Sci 251 -- vars & expns4
Comp Sci 251 -- vars & expns5
Variable declaration
Use assembler directives– Not machine instructions– Reserve memory– Define symbols
Affect data segment of memory
Comp Sci 251 -- vars & expns6
Variable declaration
High-level
int x;
MIPS assembly
x: .space 4
Symbol name
Data type Reserve
memory
No. of bytes
Comp Sci 251 -- vars & expns7
Sequence of declarations Problem!!!
char x;
int y;
char z;
.data
x: .space 1
y: .space 4
z: .space 1
0x10000000 x
0x10000001 y
0x10000005 z
Comp Sci 251 -- vars & expns8
Alignment
Integer variables must be “word-aligned” Use the .align directive Syntax:
.align n Semantics: assembler aligns the next
reserved location on an address divisible by 2n
Comp Sci 251 -- vars & expns9
Example
.data
x: .space 1
.align 2
y: .space 4
z: .space 1
0x10000000 x
0x10000004 y
0x10000008 z
Comp Sci 251 -- vars & expns10
Initialization
int x = 5; x: .word 5
initial value
symbol name
size
Comp Sci 251 -- vars & expns11
.word n
Reserves & initializes a word of memory n can be
– Unsigned number– Signed number– Hexadecimal number
Automatically aligns to word boundary– Unnecessary to use .align directive
before .word
Comp Sci 251 -- vars & expns12
Byte order
We will use SPIM– MIPS simulator software– Runs on many different platforms
Byte order in SPIM depends on native byte order of platform
Intel: little-endian PowerPC (Mac): big-endian
Comp Sci 251 -- vars & expns13
Example
x: .word 5
05 x
00
00
00
00 x
00
00
05
Little Endian
Comp Sci 251 -- vars & expns14
What about character data?
char x = 'a'; x: .byte 'a'
Comp Sci 251 -- vars & expns15
.byte n
Reserves & initializes a byte of memory n can be
– Unsigned number– Signed number– Hexadecimal number– Character in single quotes ASCII code
Comp Sci 251 -- vars & expns16
Strings
char s[] = "hello"; s: .asciiz "hello"
Cstring variable
Array of char
(Null-terminated)
Comp Sci 251 -- vars & expns17
.asciiz s
S is a string in double quotes Sequence of bytes is reserved & initialized One byte per character Final byte contains null character: 0x00 Note: not affected by byte order.
– Leftmost char lowest address– Rightmost char highest address
Comp Sci 251 -- vars & expns18
Example
x: .asciiz "hello"0x68 x
0x65
0x6c
0x6c
0x6f
0x00See Chapter03/data.a
Comp Sci 251 -- vars & expns19
Assignment
Store a value in a variable Occurs at runtime, not compile/assemble
time Supported with assembly language
instructions
Comp Sci 251 -- vars & expns20
Simple assignment
int x;
x = 5;
.text
li $t0, 5 #load immediate
sw $t0, x #store word
.data
x: .space 4
Comp Sci 251 -- vars & expns21
Load immediate instruction
li reg, value value is loaded into register Value is part of the instruction
– not contained in data segment– not contained in register
Comp Sci 251 -- vars & expns22
Store word instruction
sw reg, address
register contents are copied into memory address can be a symbol or a number address must be word-aligned
– otherwise exception is raised
Comp Sci 251 -- vars & expns23
Load/Store architecture
MIPS is a Reduced Instruction Set Computer (RISC)
Philosophy: superior performance through– simple instructions– small instruction set– fast instructions
Some operations require several instructions– assignment requires load & store
Comp Sci 251 -- vars & expns24
Assignment of char data
char y;
y = 'a';
.text
li $t0, 'a' #MSBs of $t0=0
sb $t0, y #store byte
.data
y: .space 1
Comp Sci 251 -- vars & expns25
Store byte instruction
sb reg, address
low-order byte of register is copied into memory
Comp Sci 251 -- vars & expns26
Assignment between variables
int x;
int y = 5;
x = y;
.text
lw $t0, y
sw $t0, x #store word
.data
x: .space 4
y: .word 5
Comp Sci 251 -- vars & expns27
Load word instruction
lw reg, address
word of memory is copied into register address must be word-aligned
Note: memory memory transfer requires two instructions
Comp Sci 251 -- vars & expns28
Assignment between char variables
char a;char b = '@';a = b;
.text lbu $t0, b1 #load byte
#unsigned sb $t0, a
.dataa: .space 1b1: .byte '@’ #b assembly
# error
Comp Sci 251 -- vars & expns29
Load byte unsigned instruction
lbu reg, address
byte of memory is copied into LSB of register MSBs are cleared (= 0)
Comp Sci 251 -- vars & expns30
Exercise
Write equivalent MIPS code Sketch memory layout
int x = 25;char a = '*';int y;char b;y = x;b = a;
Comp Sci 251 -- vars & expns31
Arithmetic expressions
High level language feature
How do we evaluate expressions in assembly language?– Single operator– Multiple operators
Comp Sci 251 -- vars & expns32
Addition
Expression
2 + 3
MIPS code
li $t1, 2
li $t2, 3
add $t0, $t1, $t2
Goal: result in $t0
Comp Sci 251 -- vars & expns33
Add instruction
add rd, rs, rt All operands must be registers First operand is destination Second and third operands are sources rd rs + rt Register may appear as source and
destination Signed overflow exception is raised
Comp Sci 251 -- vars & expns34
Maximize register re-use
Expression
2 + 3
MIPS code
li $t0, 2
li $t1, 3
add $t0, $t0, $t1
Goal: result in $t0
Comp Sci 251 -- vars & expns35
Subtraction
Expression
2 - 3
MIPS code
li $t0, 2
li $t1, 3
sub $t0, $t0, $t1
Comp Sci 251 -- vars & expns36
Sub instruction
sub rd, rs, rt
All operands must be registers rd rs - rt Signed overflow exception is raised
Comp Sci 251 -- vars & expns37
Multiplication
Expression
2 * 3
MIPS code
li $t0, 2
li $t1, 3
mul $t0, $t0, $t1
Comp Sci 251 -- vars & expns38
Mul instruction
mul rd, rs, rt (pseudo instruction) Signed multiplication All operands must be registers rd rs * rt No exception is raised on overflow. Why? Equivalent to
mult rs, rt
mflo rd
Comp Sci 251 -- vars & expns39
Division
Expression
2 / 3
MIPS code
li $t0, 2
li $t1, 3
div $t0, $t0, $t1
Comp Sci 251 -- vars & expns40
Div instruction
div rd, rs, rt
Signed division All operands must be registers rd rs / rt Signed overflow exception is raised
Comp Sci 251 -- vars & expns41
Remainder (% operator)
Expression
2 % 3
MIPS code
li $t0, 2
li $t1, 3
rem $t0, $t0, $t1
Comp Sci 251 -- vars & expns42
Rem instruction
rem rd, rs, rt
For simplicity, stick to non-negative operands All operands must be registers rd rs % rt
Comp Sci 251 -- vars & expns43
Multi-operator expressions
(1 + 2) * (3 – 4)
Order of operations depends on– Precedence rules– Associativity– Parentheses
Several orders are possible+ - *- + *
Comp Sci 251 -- vars & expns44
Left-to-right evaluation method
Read expression left to right Constant or variable lowest unused t-reg Operator
– Wait until both operands in registers– Perform operation– Result left operand register
Comp Sci 251 -- vars & expns45
Exercise
Apply left-to-right method to
(1 + 2) * (3 – 4)
Comp Sci 251 -- vars & expns46
Optimization
Sometimes you can do better than l-t-r– Fewer registers– Fewer instructions
Advanced topics– Sethi-Ullman numbering (minimize registers)– Common subexpressions (minimize instructions)
Comp Sci 251 -- vars & expns47
Optimization exercise
x + y * z – y
L-t-r evaluation code Minimize number of registers Minimize number of instructions