1) An assembler translates programs written in assembly language to machine code by translating mnemonic codes to machine code and symbols to addresses. It handles constants, literals, and addressing. 2) An assembler uses two passes. The first pass assigns addresses to lines of code and saves symbol addresses. The second pass translates opcodes, replaces symbols with addresses, and produces the object program. 3) Data structures used include an opcode table for translation, a symbol table for storing and looking up symbol addresses, and a literal table for handling literals.

1. Assembler
1

2. System Software
• components
– translator
• assembler
• compiler
• interpreter
– system manager
• operating system
– other utilities
• loader
• linker
• DBMS, editor, debugger, ...
• purpose of this course
– understand how to build system software
– understand how these components work
2

3. Issues in System Software
• not many in this area
– mature area
• advanced architectures complicates system software
– superscalar CPU
– memory model
– multiprocessor
• new applications
– embedded systems
– mobile/ubiquitous computing
3

4. Assembler Overview
• functions
– translate programs written in assembly language to machine code
• mnemonic code to machine code
• symbols to addresses
– handles
• constants
• literals
• addressing
• 32 bit constant or address
• 32 bit offset
4

5. Assembler Overview (cont’d)
• pass 1: loop until the end of the program
1. read in a line of assembly code
2. assign an address to this line
• increment N (word addressing or byte addressing)
3. save address values assigned to labels
• in symbol tables
4. process assembler directives
• constant declaration
• space reservation
• pass2: same loop
1. read in a line of code
2. translate op code
using op code table
3. change labels to address
using the symbol table
4. process assembler directives
5. produce object program
5

6. Data Structures for Assembler
add $t0, $t1, $t2 000000 01001 01010 01000 00000 100000
• op code table
– looked up for the translation of mnemonic code
• key: mnemonic code
• result: bits
– hashing is usually used
• once prepared, the table is not changed
• efficient lookup is desired
• since mnemonic code is predefined, the hashing function can
be tuned a priori
– the table may have the instruction format and length
• to decide where to put op code bits, operands bits, offset bits
• for variable instruction size
• used to calculate the address
6

7. Data Structures for Assembler (cont’d)
.text
.globl main
• symbol table main:
la $t0, array
– stored and looked up to assign lw $t1, count
address to labels lw $t2, ($t0)
loop:
• efficient insertion and retrieval lw $t3, 4($t0)
is needed ble $t3, $t2, loop2
• deletion does not occur move $t2, $t3
– difficulties in hashing loop2: add $t1, $t1, -1
add $t0, $t0, 4
• non random keys bnez $t1, loop
– problem
…
• the size varies widely ….
.data
array: .word 3, 5, 5, 1, 6, 7, …..
count: .word 15
string1: .asciiz “nmax = “
7

8. Symbol Table Construction
.text
.globl main symbol name value
main: main 0
la $t0, array
lw $t1, count loop 12
lw $t2, ($t0)
loop: loop2 24
lw $t3, 4($t0)
ble $t3, $t2, loop2 …
move $t2, $t3
array 408
loop2: add $t1, $t1, -1 count 468
add $t0, $t0, 4
bnez $t1, loop string1 472
… bad 478
….
.data
array: .word 3, 5, 5, 1, 6, 7, …..
count: .word 15
string1: .asciiz “nmax = “
bad: .word 7
8

9. Assembler Algorithm: pass1
begin
if starting address is given
LOCCTR = starting address;
else
LOCCTR = 0;
while OPCODE != END do ;; or EOF
begin
read a line from the code
if there is a label
if this label is in SYMTAB, then error
else insert (label, LOCCTR) into SYMTAB
search OPTAB for the op code
if found
LOCCTR += N ;; N is the length of this instruction (4 for MIPS)
else if this is an assembly directive
update LOCCTR as directed
else error
write line to intermediate file
end
program size = LOCCTR - starting address;
end
9

10. Assembler Algorithm: pass2
begin
read a line;
if op code = START then ;; .globl xxx for MIPS
write header record;
while op code != END do ;; or EOF
begin
search OPTAB for the op code;
if found
if the operand is a symbol then
replace it with an address using SYMTAB;
assemble the object code;
else if is a defined directive add $t0, $t1, $t2 =>
convert it to object code; 000000 01001 01010 01000 00000 100000
add object code to the text;
read next line;
end
write End record to the text;
output text;
end
10

11. Program Relocation
0 .
.
. jump to 1004 1004
. .
1076 5000 .
jump to 1004 .
. jump to 1004
.
6076
program is loaded at 0 program is loaded at 5000
• motivations for relocation
– a program may consists of several pieces of codes that are assembled
independently
– when a program is assembled, it is impossible to know the exact location
where the program starts
11

12. Program Relocation (cont’d)
• distances from the origin of a program do not change
– make the address relative to the origin
– provides loader with information about
• which address needs fixing
• length of address field
– the loader change those addresses as
• distance + start address of a program
– only absolute addresses need to be changed
12

13. Literals
• usage
– encoded as an operand (similar to the immediate in MIPS, but different)
• load $7, =X’0A7F’
– simple way to declare a constant
– assembler does
• declare a constant with a label
• use the label to use the value
• comparison with immediate
– literal is an assembler directive
• immediate is a machine recognizable data
– full word can be used for literals
• immediate: full word – (opcode, registers)
– values are obtained from data memory - slow
• immediate data is within the instruction itself
13

14. Literals (cont’d)
• literal pool
– assembler collects all the literals into one or more literal pools
– default location is at the end of the program
• for better code reading
– programmer can declare a place (LTORG)
• to use PC-relative addressing
• to keep data close to instruction
• optimization
– make one literal for the same value
• compare character string or value?
– x’454F46’ = c’EOF’
• value comparison needs evaluation
• literal table
– name(label), operand value, operand length, address in the table
– name and value are all used as a key
14

15. Literal Handling Algorithm
pass 1
at a recognition of a literal
search LITTAB by name
if found but different value, error
else if the same value, no action
else if not found insert a new literal (no address yet)
if the code is LTORG or END
allocate each literal assigning an address
pass 2
replace each literal with the address in the LITTAB
if these addresses are absolute,
prepare modification for relocation
15

16. Symbol Defining Statement
• MAXLEN EQU 4096
– makes program structure better
– easier to modify a single location
– easier to remember than numbers
– registers can be given meaningful names
– (maxlen = 4096) in MIPS
• assembler
– searches SYMTAB and replace the symbol with the value in the table
– resulting object code is the same as using the value instead of symbol
– remember that with 2 passes there is restriction
X EQU Y
Y EQU 100
• X cannot be defined in pass 1
16

17. Expressions
BUFFER: .space 4096 ; reserve 4096 bytes here
BUFEND: ; set current location to BUFFEND
(MAXLEN = BUFEND – BUFFER) ; calculate the size of the buffer
• allows simple arithmetic operations in symbol definition
• operands may have relative values for relocation
– relative values should be modified by the loader later
• we need to know which is relative
– symbol table needs a type field to discern absolute symbols from relative
symbols
17

18. Expression Rules
• basic
– constant is absolute
– address is relative
• using expressions
– expression with absolute arguments is absolute
– expression that has multiplication and division is absolute
– relative_1 - relative_2 is absolute
• dependencies on starting address are canceled out
– all the other expressions having relative terms are neither relative nor
absolute (error?)
• constant - relative
• relative_1 + relative_2
• 3 x relative_1
18

19. Program Blocks
source object code
block 0
block 0
block 1
assembled
block 2
block 0 block 1
block 1
block 2
block 2
19

20. Program Blocks (cont’d)
• motivation
– programmer’s view may be different from machine’s view
• affects only efficiency not functionality
– addressing can be simplified
• large data area can be moved to the end of code while source code places
it close to the instructions that use this data
• data structure and algorithm
– block table (name, block number, address, length)
– pass 1
• maintain separate LOCCTR for each block
– each label is assigned address relative to the start of the block that contains it
• SYMTAB stores block number for each symbol
• store starting address of each block in block table
– pass 2
• assign address to each symbol by adding the relative address to the block
starting address
20

21. Control Sections
• control section is a part of program that can be assembled independent of
other parts
– a large problem can be divided into many control sections
– each control section can be developed independently
– each control section can be modified independently
• symbols defined in other control sections
– called external
– assembler prepares those symbols
– loader & linker resolves the value of external symbols
21

22. Control Sections (cont’d)
• a table prepared by assembler
– define record
• name of symbol defined in this control section
• relative address of the symbol
– refer record
• name of external symbols
– modification record
• starting address of field to be modified
• length of this field
• name of external symbol
• loader
– for every external symbol
• find the relative address from the define record
• add the starting address of the control section where the symbol is defined
• modify the field
22

23. One-Pass Assembler
• problem
– forward reference: reference to symbols that are not defined yet
• why do we need one-pass assembler?
– fast
• useful for program development and testing
• university computing environment
• load-and-go assembler
– writes the object code on memory not on disk file
– since it is on memory it is easy to modify a part of object code
23

24. One-Pass Assembler (cont’d)
• one-pass assembler for load-and-go
– stores undefined symbols in the SYMTAB with the address of the field that
references this symbol
– when the symbol is defined later, look up the SYMTAB and modify the field
with correct address
• there may be many places to be modified
• what if object code is written on disk?
– bring back the text to memory
• efficiency of one-pass assembler cannot be justified
– make loader to modify the address at loading time
• modification record again
• optimization
– require all the data declaration be placed at the beginning of the program
• reduces reference resolution
24

25. Multi-Pass Assembler
• support forwarding reference even though it is bad for program readability
at 1, store in a table two tuples
(A, 1, B/2, 0)
1: one symbol is missing
1.(A = B/2) 0: no other symbol depends on A
2.(B = C-D) (B, *, , &LB)
.... *: don’t know how many symbols missing yet
8. C .....
9. D ..… LB: list of symbols that depend on B (now, there is only A in this list)
at 2,
insert (C,*, ,&LC), (D,*, ,&LD)
LC and LD contains only B
modify (B,*, ,&LB) as (B,2,C-D,&LB)
after 8
from LC, B is found
change 2 to 1 in the B tuple meaning one symbol remains to be defined
after 9
from LD, B is found
now evaluate B with defined C, D values
since B is done
from LB, A is found
now A can be evaluated
25