Assembler
Download as PPT, PDF•4 likes•9,820 views
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.
Assembler
- 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