1. Chapter 7 & 9.2 Assembly Language
Adapted from slides provided by McGraw-Hill Companies Inc., modified by professors at University of Wisconsin-Madison

2. Why machine language?
+ The closest language to H/W. Allows us to control exactly what the processor does. - Too tedious to write and debug. 0’s and 1’s make our head spin!

3. Assembly Language Human readable Machine language
Instruction pneumonic instead of opcode
Some added functionality
Labels to refer to memory locations
Assembler: A program which converts the human readable form to machine instructions.

4. Assembly language syntax
Each line of an assembly program may be
Instruction
LC-3 instruction
An assembler directive (pseudo-operation)
A comment
(Blank lines are ignored)
(Whitespaces and case are ignored)
(Comments are ignored)

5. Instruction
LABEL OPCODE OPERANDS ; COMMENTS
optional
mandatory

6. LC-3 Opcodes
Reserved symbols/names to represent the LC-3 instruction type
Whatever we used to call them in Chapter 5!
Example: ADD, BR, LD, STR, …

7. Operands Registers: Rn where n is register number
Numbers: decimal(#50) or hex (x32)
Labels: Symbolic name for memory location

8. Multiple Operands Separate multiple operands by comma
Same order as in the binary instruction
For example:
ADD R1, R2, R5
ADD R1 R2 R5

9. Labels Placed at the beginning of a line
Symbolic name for the memory address corresponding to that line.
For example:
LOOP ADD R1, R1, #-1
BRp LOOP
Used to replace PCOffset in LC-3 instructions (LD, ST, LDI, STI, BR, JSR)

10. Labels (restrictions)
Can be any alpha-numeric string
Can include underscore ‘_’ in PennSim
Should start with an alphabet
Unenforced in PennSim
characters long
Cannot be any of the reserved symbols of LC-3 (like ADD, .ORIG, 19, xA3 etc.)

11. Comments Anything after the semicolon ‘;’ Ignored by the assembler.
Can be used by the programmer to
Document code
Separate pieces of the program

12. Assembler directives Pseudo operations
Not an instruction executed by the program, but used by the assembler
Opcode with a dot ‘.’

13. Assembler directives Opcode Operand Meaning .ORIG address
starting address of program
.END
end of program
.FILL n
allocate one word, initialize with value ‘n’
.BLKW
allocate ‘n’ words of storage
.STRINGZ
n-character string
allocate n+1 locations, initialize w/characters and null terminator

14. Pseudo-Instructions
Names for various TRAP codes so that you don’t need to remember them!
Code
Equivalent
Description
HALT
TRAP x25
Halt execution and print message to console. IN
TRAP x23
Print prompt on console, read (and echo) one character from keybd. Character stored in R0[7:0].
OUT
TRAP x21
Write one character (in R0[7:0]) to console.
GETC
TRAP x20
Read one character from keyboard. Character stored in R0[7:0].
PUTS
TRAP x22
Write null-terminated string to console. Address of string is in R0.

15. A full program ; ; Program to multiply a number by the constant 6
.ORIG x3050
LD R1, SIX
LD R2, NUMBER
AND R3, R3, #0 ; Clear R3. It will
; contain the product.
; The inner loop
AGAIN ADD R3, R3, R2
ADD R1, R1, #-1 ; R1 keeps track of
BRp AGAIN ; the iteration.
HALT
NUMBER .BLKW 1
SIX .FILL x0006
.END

16. Pseudo-code to Assembly
R1 <- R2 + R3 ADD R1, R2, R3 R1 <- R1 AND 10 AND R1, R1, #10 OR AND R1, R1, xA

17. Pseudo-code to Assembly
R5 = M[M[x3020]]
(address x3020 has a label “NUMBER”)
LDI R5, NUMBER
BR on Z or P to x3030
(address x3030 has a label “LOOP”)
BRzp LOOP

18. Pseudo-code to Assembly
R6 = M[R2+5]
LDR R6, R2, #5
BR unconditionally to x301E
(address x301E has a label “NEXT”)
BRnzp NEXT OR
BR NEXT

19. Pseudo-code to Assembly
Write data x5000 to memory
(add a label “ADDR” to that mem loc)
ADDR .FILL x5000
Store a string “Hi” to memory
(add a label “STR” to that mem loc)
STR .STRINGZ “Hi”

20. Writing an Assembly Program
Count the number of occurrences of a character in a string. [OR] Set the value of x4000 to the count of occurrences of a character, stored at x4001, in a null-terminated string, starting at x4002

21. Assembler
Program which converts an assembly language program into machine code.
In programming terms, converts your assembly language file (.asm/.txt) into an executable (.obj) file.
We will use the inbuilt assembler in PennSim

22. Assembly process
Two pass process

23. Assembly Process: 1st Pass
Scan the program file and create a “Symbol Table”
Symbol Table: A table which contains the addresses of all the labels in your assembly language program.

24. 1st Pass: Steps
Find the .ORIG statement, which tells us the address of the first instruction.
Initialize location counter (LC), which keeps track of the current instruction.
For each non-empty line in the program:
If line contains a label, add label and LC to symbol table.
Increment LC.
Note: If statement is .BLKW or .STRINGZ, increment LC by the number of words allocated.
Stop when .END statement is reached.
Note: A line that contains only a comment is considered an empty line.

25. 1st Pass: Practice ; ; Program to multiply a number by the constant 6
.ORIG x3050
LD R1, SIX
LD R2, NUMBER
AND R3, R3, #0 ; Clear R3. It will
; contain the product.
; The inner loop
AGAIN
ADD R3, R3, R2
ADD R1, R1, #-1 ; R1 keeps track of
BRp AGAIN ; the iteration.
END HALT
RAND .FILL x41FF
GREET .STRINGZ “252!”
NUMBER .BLKW 2
SIX .FILL x0006
.END

26. 1st Pass: Practice Symbol Address AGAIN x3053 END x3056 RAND x3057
GREET
x3058
NUMBER
x305D
SIX
x305F

27. Assembly Process: 2nd Pass
Generate machine code for each line of assembly statement
Use the symbol table to get the addresses of the labels, so as to calculate the PCOffset

28. Assembly Process: 2nd Pass
Errors identified in this pass
Improper number or type of arguments
ex: NOT R1,#7 ADD R1,R2 ADD R3,R3,NUMBER
Immediate argument too large
ex: ADD R1,R2,#1023
Address (associated with label) more than “specifiable by offset” from instruction

29. 2nd Pass: Practice
For the previous example, generate machine code for instructions at address:
x3050:
x3055:

30. 2nd Pass: Practice
For the previous example, generate machine code for instructions at address:
x3050:
x3055:

31. Issues Assembly done. Great! How to execute the code?
How to write code in a team? Many people writing many assembly files?
How to use vendor defined libraries?

32. Loading Process of copying an executable (.obj) into memory.
We can load multiple .obj files, each starting at a desired address.
User code: x xFDFF
Careful! Do not overlap the object files

33. Linking Process of resolving symbols between independent object files
Suppose we want to use a symbol (label) defined in a different .obj file
some notation, such as .EXTERNAL, is used to tell assembler that a symbol is defined in another module
linker will search symbol tables of other modules to resolve symbols and complete code generation before loading

34. Subroutines (Section 9.2)
Very similar to “functions” in High Level Languages
Arguments
Return Value
foo() {
...
c = a + b
d = bar(c, a)
e = d + 3 }
bar(x, y) {
z = x * y
return z }
Caller
Function
Callee/Called
Function

35. Subroutines A program fragment the performs a well defined task
Invoked (or called) by a user program
Returns control when the called program has finished

36. Arguments & Return Values
The value(s) passed into a subroutine
Return Values
The value(s) passed out of a subroutine

37. Why subroutines?
Reuse useful and debugged code, rather than redoing work
Divide task among multiple programmers
Use vendor supplied library of routines

38. How to call a subroutine?
Use assembly instructions: JSR or JSRR
Jumps to a location, like BR, but unconditionally
Before jumping, copies (saves) PC into R7
Can use this “saved PC” to return to the caller program

39. JSR & JSRR
Even though two assembly instructions, same OPCODE in binary
Differ in bit 11 of the instruction
Instruction
Bit 11
Target Address
JSR 1
PC’ + PCOffset11
JSRR
Base Register

40. JSR (PC-Relative) 0 1 0 0 1 PCoffset11 15 14 13 12 11 10 9 8 7 6 5 4 3 1
PCoffset11

41. JSRR (Register) 0 1 0 0 0 0 Base Reg 0 0 0 0 0 0 15 14 13 12 11 10 9 87 6 5 4 3 2 1
Base Reg

42. JSR & JSRR
What is the advantage of JSRR over JSR?

43. How to return to the caller?
Using the RET assembly instruction
Alias (pseudo-instruction) for JMP R7 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
JMP
Base Reg
Fix Base Register as R7 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
RET

44. Arguments and Return Values
Normally registers are used to
Pass arguments from caller to callee
Return value from callee to caller
Registers being used to pass arguments and return values should be explicitly stated when writing a subroutine

45. Example ; value is R0 is negated and returned
; Argument: R0 ; Return: R0
2sComp NOT R0, R0 ; flip bits ADD R0, R0, #1 ; add one RET ; return to caller
Note: Call must be from within 1024 memory locations!
...
; need to compute R4 = R1 - R3 ADD R0, R3, #0 ; copy R3 to R0 JSR 2sComp ; negate ADD R4, R1, R0 ; add to R

46. Other Issues
The caller and the callee use the same 8 General Purpose Registers (R0-R7)
What if the callee modifies registers which are being used by the caller?
Let us revisit our example and modify the subroutine:

47. Example ; value is R0 is negated and returned
R1 modified!
; value is R0 is negated and returned
; Argument: R0 ; Return: R0
2sComp NOT R0, R0 ; flip bits ADD R0, R0, #1 ; add one RET ; return to caller
; value is R0 is negated and returned
; Argument: R0 ; Return: R0
2sComp NOT R1, R0 ; flip bits ADD R0, R1, #1 ; add one RET ; return to caller
Note: Call must be from within 1024 memory locations!
...
; need to compute R4 = R1 - R3 ADD R0, R3, #0 ; copy R3 to R0 JSR 2sComp ; negate ADD R4, R1, R0 ; add to R
R1’s value has changed!

48. Two solutions! Caller-save Callee-save [problem solved by the caller]
[problem solved by the callee]

49. Caller-save Caller knows which registers are modified by the callee
Caller saves those registers before the call and restores them after the call
Generally, modified registers are not known
Solution: Save all registers

50. Example ; value is R0 is negated and returned
; Argument: R0 ; Return: R0
2sComp NOT R1, R0 ; flip bits ADD R0, R1, #1 ; add one RET ; return to caller
...
; need to compute R4 = R1 - R3 ADD R0, R3, #0 ; copy R3 to R0 ST R1, SAVE_R1 ; Save R1
JSR 2sComp ; negate
LD R1, SAVE_R1 ; Restore R1 ADD R4, R1, R0 ; add to R
SAVE_R1 .BLKW 1
...
; need to compute R4 = R1 - R3 ADD R0, R3, #0 ; copy R3 to R0 JSR 2sComp ; negate ADD R4, R1, R0 ; add to R

51. Callee-save
Callee saves the registers which it will modify at the beginning of the subroutine
Restore the values before RET

52. Example ; value is R0 is negated and returned
; Argument: R0 ; Return: R0
2sComp ST R1, SAVE_R1; Save R1
NOT R1, R0 ; flip bits ADD R0, R1, #1 ; add one
LD R1, SAVE_R1; Restore R1 RET ; return to caller
SAVE_R1 .BLKW 1
; value is R0 is negated and returned
; Argument: R0 ; Return: R0
2sComp NOT R1, R0 ; flip bits ADD R0, R1, #1 ; add one RET ; return to caller
...
; need to compute R4 = R1 - R3 ADD R0, R3, #0 ; copy R3 to R0 JSR 2sComp ; negate ADD R4, R1, R0 ; add to R

53. Notes If the caller is a subroutine, it should save R7.
Even if using callee-save, value of R7 has to be saved and restored by the caller.

54. Summary

55. Assembly Instruction LABEL OPCODE OPERANDS ; COMMENTS optional
mandatory

56. Various parts of the instruction
Label
Symbolic name for the memory address of the instruction
Opcode
LC-3 instruction opcode
Assembler directive
Operands
Register: R0-R7
Numbers: decimal (#10) or hexadecimal (xA)
Labels
Comments
Ignored by the assembler
Used by programmers for documentation

57. Assembler Directives .ORIG x3050 .FILL x35 .BLKW #3 .STRINGZ “Hi!”
Address
Value
x3050
x0035
x3051
x0000
x3052
x3053
x3054
x0048
x3055
x0069
x3056
x0021
x3057
x3058
x0019
.ORIG x3050
.FILL x35
.BLKW #3
.STRINGZ “Hi!”
.FILL #25
.END

58. Assembly Process 2 Pass Process 1st Pass 2nd Pass
Generate the symbol table
[Symbol Table: Mapping of label to address]
2nd Pass
Generate machine code
Use symbol table to change labels to PCOffset

59. Loading and Linking Loading Linking
Process of loading an executable to memory
Multiple executable can be loaded into memory at the same time
Linking
Process of resolving symbols defined in a different assembly file

60. Subroutines Calling Returning Arguments and Return values JSR or JSRR
Save PC to R7
Returning
RET or JMP R7
Arguments and Return values
Using registers (need to be stated explicitly)

61. Saving and Restoring Caller-save and Callee save Caller save advantage
+ knows which registers it needs after the call
- doesn’t know which registers are modified by the callee.
Callee save
+ knows which registers it is going to modify
- doesn’t know which registers caller needs.

62. Problems

63. Problem 1 Find the assembly errors in the program. .ORIG x3000
XAF ADD R0, R0, x1F
LOOP BRnz NEXT
BRp ZERO
LDR R1, Zero
NOT R3, #5
OR R1, R2, R1
HALT
Zero .FILL 0
LOOP .BLKW 2
CHAR .ASCII ‘a’
STR .STRINGZ “Time”
.END
Find the assembly errors in the program.

64. Solution .ORIG x3000 XAF ADD R0, R0, x1F LOOP BRnz NEXT BRp ZERO
LDR R1, Zero
NOT R3, #5
OR R1, R2, R1
HALT
Zero .FILL 0
LOOP .BLKW 2
CHAR .ASCII ‘a’
STR .STRINGZ “Time”
.END

65. Problem 2 .ORIG x3800 LEA R3, INPUT LD R1, SIZE ADD R3, R3, R1
LOOP LDR R0, R3, 0
TRAP x21
ADD R3, R3, -1
ADD R1, R1, -1
BRp LOOP
HALT
INPUT .STRINGZ "RtbY"
STRING .BLKW #3
SIZE .FILL #3
TWO .FILL #2
.END
(a) Generate the symbol table for the above code.
(b) What are the values in memory (in hex) at the following memory addresses:
x3800
x3807
x380B
x3811

67. Solution Label Address ------------------ INPUT x3809 LOOP x3803
SIZE x3811
STRING x380E
TWO x3812
Address Value
x xE608
x x03FB
x380B x0062
x x0003

68. Problem 3 What does this program do? .ORIG X3100 LEA R0, TRS
LD R1, SUM
LOOP LDR R2, R0, #0
BRz END
ADD R2, R2, R1
STR R2, R0, #0
ADD R0, R0, #2
BR LOOP
END HALT
SUM .FILL x20
TRS .STRINGZ "BYEBYE"
.END
What does this program do?

70. Solution
Changes the string stored at TRS from “BYEBYE” to “bYeByE”

71. Problem 4 .ORIG x3000 ST R0, SAVER0 ST R1, SAVER1 JSR SUB1
LD R0, SAVER0
LD R1, SAVER1
HALT
SUB1 ADD R0, R1, R1
JSR SUB2
AND R2, R1, R0
RET
SUB2 ST R3, SAVER3
AND R3, R0, R0
NOT R0, R3
LD R3, SAVER3
.END
Is there is a problem with the above assembly language program? How will you fix it?
(b) Is SUB1 caller-save or callee-save? Is SUB2 caller-save or callee-save?

72. Solution R7 has to be saved before call from SUB1 to SUB2
SUB1: Caller-save
SUB2: Callee-save

73. Problem 5
What single instruction is equivalent to the following two LC-3 instructions?
LEA R7, #1
JMP R2, #0
RET instruction is executed at address x1234. What is the range of possible values of PC after this instruction executes?
Which assembler directive(s) can be used only once in an assembly language program?

74. Solution
JSRR R2
0x0000 – 0xFFFF
RET is “JMP R7”
.ORIG and .END