Ch. 4 Variables and Expressions

1. Ch. 4 Variables and Expressions Comp Sci 251 -- vars & expns

2. Supporting high-level languages • How do we use MIPS assembly language to implement • Variable declaration & initialization? • Assignment statements? • Expression evaluation? Comp Sci 251 -- vars & expns

3. 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 #exit syscall ######################################## # Data segment # ######################################## .data [data definitions...] ## end of file foo.a [blank line] Note: file extension .a Comp Sci 251 -- vars & expns

4. syscalls Comp Sci 251 -- vars & expns

5. Variable declaration • Use assembler directives • Not machine instructions • Reserve memory • Define symbols • Affect data segment of memory Comp Sci 251 -- vars & expns

6. Variable declaration High-level int x; MIPS assembly x: .space 4 Symbol name No. of bytes Reserve memory Data type Comp Sci 251 -- vars & expns

7. char x; int y; char z; .data x: .space 1 y: .space 4 z: .space 1 Sequence of declarations Problem!!! Comp Sci 251 -- vars & expns

8. Alignment • Integer variables must be “word-aligned” • Use the .align directive • Syntax: .alignn • Semantics: assembler aligns the next reserved location on an address divisible by 2n Comp Sci 251 -- vars & expns

9. Example .data x: .space 1 .align 2 y: .space 4 z: .space 1 Comp Sci 251 -- vars & expns

10. int x = 5; x: .word 5 Initialization initial value size symbol name Comp Sci 251 -- vars & expns

11. .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 & expns

12. 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 & expns

13. Example x: .word 5 Little Endian Comp Sci 251 -- vars & expns

14. char x = 'a'; x: .byte 'a' What about character data? Comp Sci 251 -- vars & expns

15. .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 & expns

16. char s[] = "hello"; s: .asciiz "hello" Strings Cstring variable Array of char (Null-terminated) Comp Sci 251 -- vars & expns

17. .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 & expns

18. Example x: .asciiz "hello" See Chapter03/data.a Comp Sci 251 -- vars & expns

19. Assignment • Store a value in a variable • Occurs at runtime, not compile/assemble time • Supported with assembly language instructions Comp Sci 251 -- vars & expns

20. int x; x = 5; .text li $t0, 5 #load immediate sw $t0, x #store word .data x: .space 4 Simple assignment Comp Sci 251 -- vars & expns

21. 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 & expns

22. Store word instruction swreg, 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 & expns

23. 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 & expns

24. char y; y = 'a'; .text li $t0, 'a' #MSBs of $t0=0 sb $t0, y #store byte .data y: .space 1 Assignment of char data Comp Sci 251 -- vars & expns

25. Store byte instruction sb reg, address • low-order byte of register is copied into memory Comp Sci 251 -- vars & expns

26. int x; int y = 5; x = y; .text lw $t0, y sw $t0, x #store word .data x: .space 4 y: .word 5 Assignment between variables Comp Sci 251 -- vars & expns

27. 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 & expns

28. char a; char b = '@'; a = b; .text lbu $t0, b1 #load byte #unsigned sb $t0, a .data a: .space 1 b1: .byte '@’ #b assembly # error Assignment between char variables Comp Sci 251 -- vars & expns

29. Load byte unsigned instruction lbu reg, address • byte of memory is copied into LSB of register • MSBs are cleared (= 0) Comp Sci 251 -- vars & expns

30. 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 & expns

31. Arithmetic expressions • High level language feature • How do we evaluate expressions in assembly language? • Single operator • Multiple operators Comp Sci 251 -- vars & expns

32. Expression 2 + 3 MIPS code li $t1, 2 li $t2, 3 add $t0, $t1, $t2 Goal: result in $t0 Addition Comp Sci 251 -- vars & expns

33. 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 & expns

34. Expression 2 + 3 MIPS code li $t0, 2 li $t1, 3 add $t0, $t0, $t1 Goal: result in $t0 Maximize register re-use Comp Sci 251 -- vars & expns

35. Expression 2 - 3 MIPS code li $t0, 2 li $t1, 3 sub $t0, $t0, $t1 Subtraction Comp Sci 251 -- vars & expns

36. Sub instruction sub rd, rs, rt • All operands must be registers • rd  rs - rt • Signed overflow  exception is raised Comp Sci 251 -- vars & expns

37. Expression 2 * 3 MIPS code li $t0, 2 li $t1, 3 mul $t0, $t0, $t1 Multiplication Comp Sci 251 -- vars & expns

38. 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 & expns

39. Expression 2 / 3 MIPS code li $t0, 2 li $t1, 3 div $t0, $t0, $t1 Division Comp Sci 251 -- vars & expns

40. 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 & expns

41. Expression 2 % 3 MIPS code li $t0, 2 li $t1, 3 rem $t0, $t0, $t1 Remainder (% operator) Comp Sci 251 -- vars & expns

42. 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 & expns

43. Multi-operator expressions (1 + 2) * (3 – 4) • Order of operations depends on • Precedence rules • Associativity • Parentheses • Several orders are possible + - * - + * Comp Sci 251 -- vars & expns

44. 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 & expns

45. Exercise Apply left-to-right method to (1 + 2) * (3 – 4) Comp Sci 251 -- vars & expns

46. 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 & expns

47. Optimization exercise x + y * z – y • L-t-r evaluation code • Minimize number of registers • Minimize number of instructions Comp Sci 251 -- vars & expns