1. Generalities for Assembly Language
1 item per line of source code
directive (declaration)
instruction
Comments are always allowed, but the syntax varies from one architecture to another
Macro substitution
like the #define from C
no macros in MIPS assembly language!

2. Comments in MIPS assembly language
# Here is my comment.
# NO spanning lines!
# Everything to the right of the
# pound character to the end of the
# line is a comment.

3. Declarations The format of the syntax: [label] type [initial value]
type is one of
.byte for a single, character-sized variable
.word for a single, integer-sized variable
.float for a single-precision-sized variable
shows optional
item

4. Declaration Examples:
a_char: .byte 'a' # single quotes
count: .word
MAX: .word # decimal value
mask: .word 0x # hexadecimal
X: word # initial value of 0
char: .byte # initial value is
# NULL character
.word # initial value is 0,
# but how to access?
e: float # IEEE single
# precision

5. More Declaration Examples:
# an array of 5 characters, initialized
letters: .byte 'a', 'b', 'c', 'd', 'e'
# 2 labels for the exact same variable
count1:
count2: .word 0
# letter case is distinguished!
# 2 separate variables are declared
MAX: .word
max: .word 6

6. Yet More Declaration Examples:
# strings go in double quote marks
err_msg: .asciiz "integer too large\n"
no_null: .ascii "non null terminated"
xyznull: .asciiz "xyz" # 4 chars
xyz: ascii "xyz" # 3 chars

7. Directives A way to give information to the assembler.
All directives start with '.' (on many architectures).
MIPS examples:
.byte # space for 1 character-sized
# variable
.word # space for 1 integer-sized
.float # space for 1 single precision-
# sized variable

8. More Directives Examples
.data # identifies the start of the # declaration section # There can be more than 1 .data # section in a program. # There will be 1 global section # where all data is placed.
.text # identifies the start of a section # of code # There can be more than 1 .text # section in a program.

9. Yet More Directives Examples
.asciiz # Places a null-terminated string # into memory # A string consists of
# consecutively allocated
# characters.
.ascii # Places a string into memory, # without null termination.

10. MIPS R2000 register usage syntax: $regnumber
examples: $3, $18, $20
all 32 registers are both general purpose, yet have specific uses. . .
$0 always the value 0
$1 used by the assembler for MAL->TAL translation
$2, $3 function return values
$4 - $7 parameters
$26, $27 used by the operating system
$29 stack pointer
$31 return address register 10

11. Which registers to use? $0 for the immediate value 0
$8 - $25 for all variables
When writing code, use registers as needed.
Karen’s most excellent advice:
Document what is in each register as you write code (not after the code is completed) ! 11

12. d must designate a register
s1, s2 may designate a register or be an immediate
r1, r2 must designate a register
Only 1 immediate operand per instruction! (for common sense reasons) 3

13. Some arithmetic/logical instructions
move
d, s1
d = s1
add
d, s1, s2
d = s1 + s2; two's complement
addu
d = s1 + s2; unsigned
sub
d = s1 – s2; two's complement
subu
d = s1 – s2; unsigned
mul
d = s1 * s2; two's complement
div
d = s1 / s2; two's complement; gives quotient
divu
d = s1 / s2; unsigned; gives quotient

14. More arithmetic/logical instructions
rem
d, s1, s2
d = s1 / s2; two's complement; gives remainder
remu
d = s1 / s2; unsigned; gives remainder
and
d = s1 & s2; bitwise AND or
d = s1 | s2; bitwise OR
not
d, s1
d = ~s1; bitwise complement
nand
d = s1 NAND s2; no C equivalent
nor
d = s1 NOR s2; no C equivalent
xor
d = s1 ^ s2; bitwise XOR

15. More arithmetic/logical instructions
rol
d, s1, s2
d = rotate left of s1 by s2 places
ror
d = rotate right of s1 by s2 places
sll
d = logical left shift of s1 by s2 places
sra
d = arithmetic right shift of s1 by s2 places
srl
d = logical right shift of s1 by s2 places

16. #C code # # aa = bb + cc + (dd – ee); 16

17. MIPS Load/Store Instructions
mnemonic operands operation
lw d, addr one word is loaded from addr and placed into d; addr must be word aligned
lb d, addr one byte is loaded from addr and placed into the rightmost byte of d; sign extension defines the other bits of d 4

18. more MIPS Load/Store Instructions
mnemonic operands operation
lbu d, addr one byte is loaded from addr and placed into the rightmost byte of d; zero extension defines the other bits of d
li d, immed the immediate value is placed into d
sw d, addr a word in d is stored to addr; addr must be word aligned 18

19. more MIPS Load/Store Instructions
mnemonic operands operation
sb d, addr the byte in the rightmost byte of d is stored to addr
la d, label the address assigned for label is placed into d 19

20. loads
l_ $_, addr
stores
s_ $_, addr
addr is one of
label
($_)
displacement($_)

21. 1. addr is a label
Example: lw $8, X
memory X
//////// $8
//////// 21

22. 2. addr is ($_)
the address is in a register Example: lw $10, ($14)
memory
$14
***
***
////////
$10
////////
2222

23. 3. addr is displacement($_)
an address is in a register Example: lw $12, 4($15)
memory
$15
1000 +
1004
////////
$12
////////
2323

24. Dealing with bytes example: lb $20, X
memory
1 byte X

$20




sign extend
2424

25. More dealing with bytes: lbu $21, Y
memory
More dealing with bytes: lbu $21, Y
1 byte Y:
////////
$ ////////
Zero Extend
2525

26. sb $13,X Example: XXXXX Only 1 byte of memory changes X memory
2626

27. la $22, X X X Example: $22 memory Much like int X; int *pX; px = &X;
2727

28. Some branch instructions
label
unconditional branch to label
beq
r1, r2, label
branch to label if (r1) == (r2)
bne
branch to label if (r1) != (r2)
bgt
branch to label if (r1) > (r2)
bge
branch to label if (r1) >= (r2)
blt
branch to label if (r1) < (r2)
ble
branch to label if (r1) <= (r2)

29. More branch instructions
beqz
r1, label
branch to label if (r1) == 0
bnez
branch to label if (r1) != 0
bgtz
branch to label if (r1) > 0
bgez
branch to label if (r1) >= 0
bltz
branch to label if (r1) < 0
blez
branch to label if (r1) <= 0

30. 2 more control instructionsj
label
unconditional jump to label
jal
unconditional jump to label, with return address in $31

31. Incorrect, bad, and wrong:
Good examples of branch instructions:
beq $8, $9, end_program
bgtz $16, next_check
Incorrect, bad, and wrong:
beq X, $12, bad_code
Also wrong:
ble $10, -1, less_than_case
Correct implementation of the ble:
li $11, -1
ble $10, $11, less_than_case 31

32. #C code # # if ( x == 0 ) { # y++; # }
3232

33. #C code # # if ( x == y ) { # a++; # y = a – 3; # }
3333

34. # C code # # sum = 0 # for ( i = 0; i < count; i++ ) { # sum = sum + i; # }
3434

35. # C code # #define MAX 13 # count = 0; # while ( count < MAX ) { # /* code missing! */ # }
3535

36. # C code # while ( (x >= y) && (z < 300) ) { # z = z – x; # if ( (x % 2) == 0 ) { # x--; # y++; # } # }
3636

37. I/O instructions putc getc puts
print the ASCII character represented by the least significant byte of r1
getc
read a character, placing it in the least significant byte of r1
puts
r1/label
print the null-terminated string that begins at the address within r1 or at the address given by label

38. # code getc $21 # execution waits for user input of a # character; once the user types an 'R': $21 0x?? 0x?? 0x?? 0x52
3838

39. # code putc $15 $15 0x52 0x53 0x54 0x55 output U ^ more output goes here, when there is more output
3939

40. data str1:. asciiz "hello. ". text puts str1 hello
.data str1: .asciiz "hello." .text puts str1 hello. ^ more output starts here, when more is printed
4040

41. .data str1: .asciiz "hello." .text la $12, str1 # address of first # character in string puts $12 # address of first # character to print # is in $12 hello. ^ more output starts here, when more is printed 41

42. .data str1: .asciiz "hello.\nMy name is George." .text puts str1 hello. My name is George. ^ more output starts here, when more is printed
4242

43. data str1:. ascii "Hi. \n" str2:. asciiz "I am a badger. "
.data str1: .ascii "Hi.\n" str2: .asciiz "I am a badger." .text puts str1 Hi. I am a badger. ^ more output starts here, when more is printed
4343

44. # MAL program to print out the alphabet. data str1:
# MAL program to print out the alphabet .data str1: .asciiz "The alphabet:\n" # register assignments # $8 -- the ASCII character code # to be printed # $9 -- the ASCII code for 'z', the # ending character
4444

45. __start: la $10, str1 puts $10 add $8, $0, 97 # $8 gets ASCII for 'a';
.text
__start: la $10, str1
puts $10
add $8, $0, 97
# $8 gets ASCII for 'a';
# could be li $8, 97
add $9, $0, 122
# $9 gets ASCII for 'z';
# could be li $9, 122
while: bgt $8, $9, all_done
putc $8
add $8, $8, 1
b while
all_done:
li $10, '\n'
putc $10
done
4545

46. # this simple MAL program reads in 2 # characters, figures out which one is # alphabetically first, and prints it out. # register assignments # $8 -- the first character typed by the user # $9 -- the second character typed in # by the user # $10 -- temporary # $11 -- holds the value of the larger # character # $13 -- the address of the newline # character constant # $14 -- newline character (a constant)
4646

47. .text __start: getc $8 # get 2 characters getc $9 li $14, '\n' # print newline putc $14 # figure out which is larger sub $10, $9, $8 bgez $10, secondlarger add $11, $8, $0 b printresult secondlarger: add $11, $9, $0 printresult: putc $11 done
4747