Chapter 2 Assemblers - PowerPoint PPT Presentation

chapter 2 assemblers n.
Skip this Video
Loading SlideShow in 5 Seconds..
Chapter 2 Assemblers PowerPoint Presentation
Download Presentation
Chapter 2 Assemblers

play fullscreen
1 / 72
Chapter 2 Assemblers
Download Presentation
Download Presentation

Chapter 2 Assemblers

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. Chapter 2 Assemblers System Software Chih-Shun Hsu

  2. Basic Assembler Functions • Convert mnemonic operation codes to their machine language equivalent • Convert symbolic operands to their equivalent machine addresses • Build the machine instructions in the proper format • Convert the data constants specified in the source program into their machine representations • Write the object program and the assembly listing

  3. Two Pass Assembler(2/1) • Forward reference—a reference to a label that is defined later in the program • Because of forward reference, most assembler make two pass over the source program • The first pass does little more than scan the source program for label definitions and assign addresses • The second pass performs most of the actual translation • Assembler directives (or pseudo-instructions) provide instructions to the assembler itself

  4. Two Pass Assembler(2/2) • Pass 1 (define symbols) • Assign addresses to all statements in the program • Save the values (addresses) assigned to all labels • Perform some processing of assembler directives • Pass 2 (assemble instructions and generate object program) • Assemble instructions (translating operation codes and looking up addresses • Generate data values defined by BYTE, WORD, etc. • Perform processing of assembler directives not done during Pass 1 • Write the object program and the assembly listing

  5. Assembler Data Structure and Variable • Two major data structures: • Operation Code Table (OPTAB): is used to look up mnemonic operation codes and translate them to their machine language equivalents • Symbol Table (SYMTAB): is used to store values (addresses) assigned to labels • Variable: • Location Counter (LOCCTR) is used to help the assignment of addresses • LOCCTR is initialized to the beginning address specified in the START statement • The length of the assembled instruction or data area to be generated is added to LOCCTR

  6. OPTAB and SYMTAB • OPTAB must contain the mnemonic operation code and its machine language • In more complex assembler, it also contain information about instruction format and length • For a machine that has instructions of different length, we must search OPTAB in the first pass to find the instruction length for incrementing LOCCTR • SYMTAB includes the name and value (address) for each label, together with flags to indicate error conditions • OPTAB and SYMTAB are usually organized as hash tables, with mnemonic operation code or label name as the key, for efficient retrieval

  7. Example of a SIC Assembler Language Program (3/1)

  8. Example of a SIC Assembler Language Program (3/2) for (int i=0; i<4096; i++) { scanf(“%c”,&BUFFER[i]); if (BUFFER[i]==0) break; } LENGTH=i;

  9. Example of a SIC Assembler Language Program (3/3) for (int i=0; i<LENGTH; i++) { printf(“%c”,BUFFER[i]); }

  10. Program with Object Code (3/1) 14 1033

  11. Program with Object Code (3/2) 54 1039+8000=9039

  12. Program with Object Code (3/3)

  13. SYMTAB

  14. Object Program Format • Header record (H) • Col. 2-7 program name • Col. 8-13 Starting address of object program (Hex) • Col. 14-19 Length of object program in bytes (Hex) • Text record (T) • Col. 2-7 Starting address for object code in this record (Hex) • Col. 8-9 length of object code in this record (Hex) • Col 10-69. object code, represented in Hex • End record (E) • Col.2-7 address of first executable instruction in object program (Hex)

  15. Object Program

  16. Algorithm for Pass 1 of Assembler(3/1) read first input line if OPCODE=‘START’ then begin save #[OPERAND] as starting address initialize LOCCTR to starting address write line to intermediate file read next input line end else initialize LOCCTR to 0 while OPCODE≠’END’ do begin if this is not a comment line then begin if there is a symbol in the LABEL field then

  17. Algorithm for Pass 1 of Assembler(3/2) begin search SYMTAB for LABEL if found then set error flag (duplicate symbol) else insert (LABEL, LOCCTR) into SYMTAB end {if symbol} search OPTAB for OPCODE if found then add 3 {instruction length} to LOCCTR else if OPCODE=‘WORD’ then add 3 to LOCCTR else if OPCODE=‘RESW’ then add 3 * #[OPERAND] to LOCCTR

  18. Algorithm for Pass 1 of Assembler(3/3) else if OPCODE=‘RESB’ then add #[OPERAND] to LOCCTR else if OPCODE=‘BYTE’ then begin find length of constant in bytes add length to LOCCTR end {if BYTE} else set error flag (invalid operation code) end {if not a comment} write line to intermediate file read next input line end {while not END} Write last line to intermediate file Save (LOCCTR-starting address) as program length

  19. Algorithm for Pass 2 of Assembler(3/1) read first input line (from intermediate file) If OPCODE=‘START’ then begin write listing line read next input line end {if START} Write Header record to object program Initialize first Text record While OPCODE≠ ‘END’ do begin if this is not a comment line then begin search OPTAB for OPCODE if found then begin

  20. Algorithm for Pass 2 of Assembler(3/2) if there is a symbol in OPERAND field then begin search SYMTAB for OPERAND if found then store symbol value as operand address else begin store 0 as operand address set error flag (undefined symbol) end end {if symbol} else store 0 as operand address assemble the object code instruction end {if opcode found}

  21. Algorithm for Pass 2 of Assembler(3/3) else if OPCODE=‘BYTE’ or ‘WORD’ then convert constant to object code if object code will not fit into the current Text record then begin write Text record to object program initialize new Text record end add object code to Text record end {if not comment} write listing line read next input line end {while not END} write last Text record to object program Write End record to object program Write last listing line

  22. Machine-Dependent Assembler Features • Indirect addressing is indicated by adding the prefix @ to the operand • Immediate operands are denoted with the prefix # • The assembler directive BASE is used in conjunction with base relative addressing • The extended instruction format is specified with the prefix + added to the operation code • Register-to-register instruction are faster than the corresponding register-to-memory operations because they are shorter and because they do not require another memory reference

  23. Example of SIC/XE Program(3/1)

  24. Example of SIC/XE Program(3/2)

  25. Example of SIC/XE Program(3/3)

  26. Program with Object Code (3/1)

  27. Object Code Translation Format 3 Format 4 • Line 10: STL=14, n=1, i=1ni=3, op+ni=14+3=17, RETADR=0030, x=0, b=0, p=1, e=0xbpe=2, PC=0003, disp=RETADR-PC=030-003=02D, xbpe+disp=202D, obj=17202D • Line 12: LDB=68, n=0, i=1ni=1, op+ni=68+1=69, LENGTH=0033, x=0, b=0, p=1, e=0xbpe=2, PC=0006, disp=LENGTH-PC=033-006=02D, xbpe+disp=202D, obj=69202D • Line 15: JSUB=48, n=1, i=1ni=3, op+ni=48+3=4B, RDREC=01036, x=0, b=0, p=0, e=1, xbpe=1, xbpe+RDREC=101036, obj=4B101036 • Line 40: J=3C, n=1, i=1ni=3, op+ni=3C+3=3F, CLOOP=0006, x=0, b=0, p=1, e=0xbpe=2, PC=001A, disp=CLOOP-PC=0006-001A=-14=FEC(2’s complement), xbpe+disp=2FEC, obj=3F2FEC • Line 55: LDA=00, n=0, i=1ni=1, op+ni=00+1=01, disp=#3003, x=0, b=0, p=0, e=0xbpe=0, xbpe+disp=0003, obj=010003

  28. Program with Object Code (3/2)

  29. Object Code Translation • Line 125: CLEAR=B4, r1=X=1, r2=0, obj=B410 • Line 133: LDT=74, n=0, i=1ni=1, op+ni=74+1=75, x=0, b=0, p=0, e=1xbpe=1, #4096=01000, xbpe+address=101000, obj=75101000 • Line 160: STCH=54, n=1, i=1ni=3, op+ni=54+3=57, BUFFER=0036, B=0033, disp=BUFFER-B=003, x=1, b=1, p=0, e=0xbpe=C, xbpe+disp=C003, obj=57C003

  30. Program with Object Code (3/3)

  31. SYMTAB

  32. Program Relocation • The actual starting address of the program is not known until load time • An object program that contains the information necessary to perform this kind of modification is called a relocatable program • No modification is needed: operand is using program-counter relative or base relative addressing • The only parts of the program that require modification at load time are those that specified direct (as opposed to relative) addresses • Modification record • Col. 2-7 Starting location of the address field to be modified, relative to the beginning of the program (Hex) • Col. 8-9 Length of the address field to be modified, in half-bytes (Hex)

  33. Examples of Program Relocation

  34. Object Program

  35. Machine-Independent Assembler Features • Literals • Symbol-defining statements • Expressions • Program block • Control sections and program linking

  36. Program with Additional Assembler Features(3/1)

  37. Program with Additional Assembler Features(3/2)

  38. Program with Additional Assembler Features(3/3)

  39. Literals(2/1) • Write the value of a constant operand as a part of the instruction that uses it • Such an operand is called a literal • Avoid having to define the constant elsewhere in the program and make up a label for it • A literal is identified with the prefix =, which is followed by a specification of the literal value • Examples of literals in the statements: • 45 001A ENDFIL LDA =C’EOF’ 032010 • 215 1062 WLOOP TD =X’05’ E32011

  40. Literals(2/2) • With a literal, the assembler generates the specified value as a constant at some other memory location • The address of this generated constant is used as the target address for the machine instruction • All of the literal operands used in the program are gathered together into one or more literal pools • Normally literals are placed into a pool at the end of the program • A LTORG statement creates a literal pool that contains all of the literal operands used since the previous LTORG • Most assembler recognize duplicate literals: the same literal used in more than one place and store only one copy of the specified data value • LITTAB (literal table): contains the literal name, the operand value and length, and the address assigned to the operand when it is placed in a literal pool

  41. Symbol-Defining Statements • Assembler directive that allows the programmer to define symbols and specify their values • General form: symbol EQU value • Line 133: +LDT #4096 MAXLEN EQU 4096 +LDT #MAXLEN • It is much easier to find and change the value of MAXLEN • Assembler directive that indirect assigns values to symbols ORG STAB RESB 1100 ORG STAB SYMBOL RESB 6 VALUE RESW 1 FLAGS RESW 2 ORG STAB+1100 STAB RESB 1100 SYMBOL EQU STAB VALUE EQU STAB+6 FLAGS EQU STAB+9

  42. Expressions • Assembler allow arithmetic expressions formed according to the normal rules using the operator +, -, *, and / • Individual terms in the expression may be constants, user-defined symbols, or special terms • The most common such special term is the current value of the location counter (designed by *) • Expressions are classified as either absolute expressions or relative expressions

  43. Program Block(2/1) • Program blocks: segments of code that are rearranged within a single object unit • Control sections: segments that are translated into independent object program units • USE indicates which portions of the source program belong to the various blocks

  44. Program Block(2/2) • Because the large buffer area is moved to the end of the object program, we no longer need to used extended format instructions • Program readability is improved if the definition of data areas are placed in the source program close to the statements that reference them • It does not matter that the Text records of the object program are not in sequence by address; the loader will simply load the object code from each record at the indicated address

  45. Example Program with Multiple Program Blocks(3/1)

  46. Example Program with Multiple Program Blocks(3/2)

  47. Example Program with Multiple Program Blocks(3/3)

  48. Program Blocks Traced Through Assembly and Loading Processes

  49. Object Program

  50. Control sections(3/1) • References between control sections are called external references • The assembler generates information for each external reference that will allow the loader to perform the required linking • The EXTDEF (external definition) statement in a control section names symbol, called external symbols, that are define in this section and may be used by other sections • The EXTREF (external reference) statement names symbols that are used in this control section and are defined elsewhere