Monday, February 16, 2015

Transcription

1 Monday, February 16, 2015 Topics for today How assemblers work Symbol tables ILC Pass 1 algorithm, Error checking Pass 2 Immediate mode and equate Assembler variants: Disassembler, Cross assembler Macros Having looked at enough Pep/8 to complete programs 3 (and 4), we now return to topics skipped in Chapters 5 and 6 First, look at how assemblers work from Chapter 5 How assemblers work In a sentence: An assembler translates symbols to numbers There are various symbols in an assembly language program but they fall into two groups: (1) those that are part of the assembly language itself eg end deco stro block (2) those that a user is free to make up (within length limits) the labels on instructions or data locations The forward reference problem In general, an assembler cannot read a program just once and output a translation as it goes along This is because a symbol can be used before it is defined Consider the following deci N,d ; input count of lines N : block 2 ; variable for line count When the assembler reads the first line, it does not (yet) know the value that N represents Even if the language requires users to declare all data at the top of the program we may still have forward references in branch instructions as in the first line of the following br main A: block 2 B: block 2 main: deci A,d Comp 162 Notes Page 1 of 11 February 16, 2015

2 So a typical assembler reads the source program twice (makes two passes over the text): Pass 1: get values of symbols Pass 2: do the actual translation 1 An assembler makes use of tables in translating the program and there will be two types of tables corresponding to the two types of symbol Fixed Tables - contain those symbols that are part of the language such as the opcodes and directives The structure of these tables can be optimized for fast access, eg entries ordered alphabetically Entries in the opcode table would associate with each symbolic opcode information such as its numeric translation, number of operands, valid addressing modes and so on Symbol Template Operand Bytes Modes Allowed ROLr r No 1 STr 1110raaa Yes 3 d,s,x,n,sf,sx,sxf STOP No 1 BR a Yes 3 i,x The fixed tables are initialized before the user program is read and do not change Variable Table - contains those symbols that the user is free to choose such as labels on instructions and data locations (think about the identifiers in a high-level language program) This table is empty before the user program is read and entries are made during Pass 1 We can depict the operation of a two-pass assembler thus: 1 It is possible to write an assembler that only requires one pass but it is tricky Reading the source program twice is rarely a problem so two passes are preferred Comp 162 Notes Page 2 of 11 February 16, 2015

3 Source Program Pass 1 Pass 2 Object Program Fixed Tables Variable Table Organization of tables In theory, it does not matter how fast the assembler performs the translation as long as it is correct But in practice we would like it to proceed as fast as possible Much of what an assembler does is look up symbols in tables so if we can make look-ups fast, the assembly operation as a whole will be Fixed tables In a fixed table we know what the entries are Some possibilities for organizing such a table are (a) order by expected frequency common symbols will be found quicker (b) order by actual frequency Start with some ordering then when an entry is used move it closer to the beginning of the table (c) order alphabetically and do a binary/logarithmic search (d) use a hash function to map each symbol to a different address in a table To look up a symbol from the program, apply the hash function and look at the contents of the corresponding address (more on hashing below) Variable tables The problem with the user-defined symbols is that we don t know how many symbols there will be or what they will be so options (a), (b) and (c) are not good It is common to use a hash-table approach making provision for dealing with two symbols that hash to the same address Comp 162 Notes Page 3 of 11 February 16, 2015

4 Hashing: a small example Hashing involves devising a function that maps the objects to be stored (in our case user-defined identifiers) onto addresses (probably indexes of a table) If the function is simple, hashing can be very fast A simple function is: ( rank(1 st character) + rank(last character) ) % table-size The following shows the value of this function for some typical identifiers assuming table addresses ranging from 0 to 9 Symbol Rank(1 st ) Rank(Last) Rank(1st)+rank(last) Rank(1 st )+Rank(last))%10 TOP N COUNT LAB LOOP When a symbol hashes to an address that is already full we can just use the next free one so after entering the examples above, our 10-entry table looks like Index Contents Value COUNT 4 LAB 5 6 TOP 7 8 N 9 LOOP Assembler operation: Pass 1 Typically, Pass 1 does the majority of the error checking of the source program In the case of Pep/8 Pass 1 does all the checking Pass 1 is also responsible for determining the value of each user-defined symbol It constructs a table of symbols and corresponding values It uses a variable called the Instruction Location Counter (ILC) to keep track of the amount of space required in memory by a translation of the program read so far If we are translating the following program by hand Comp 162 Notes Page 4 of 11 February 16, 2015

5 charo A,d charo B,d stop A: byte H B: byte I end We can figure the translation of the first line is 3 bytes (and will occupy bytes 0,1,2 in memory), the translation of the second line is also three bytes (bytes 3, 4 and 5) the translation of the third line occupies one byte (byte 6) So the symbol A is a label on byte 7 and therefore the value of the symbol A is 7 Similarly the value of B is 8 We could replace the first line of the program by charo 7,d and it would translate the same Next we will see how Pass 1 of the assembler uses the ILC to do the same Pass 1: ILC The Instruction Location Counter (ILC) is a variable used by the assembler to assign appropriate values to labels it is initialized to zero it is incremented by number of bytes required by translation of the current line When a label is encountered, its value is (usually) the current value of the ILC (See later for an exception) Example Label Program Line Bytes occupied ILC before ILC after deci N,d lda N,d asra next: deci M,d adda N,d brv end br next end: stop M: block N: block end n/a 24 The final value of the ILC is the size of the program in bytes Comp 162 Notes Page 5 of 11 February 16, 2015

6 After Pass 1 we have Symbol Value N 22 next 7 M 20 end 19 Pep/8 limitations? Large block declarations work The following assembles lda 1,i stop x: block y: block 2 end A program with 10,000 different labels also appeared to assemble correctly Pass 1: Algorithm Here is a pseudocode algorithm for Pass 1 ILC = 0 read line while ( line!= END) { if errors(line) output errormessage } else if ( notallcomment(line)) { extractsymbols (line,symbollist) updatetable (symbollist,ilc) ILC = ILC + spaceneeds(line) // see below } if (end-of-file) { output ("missing end"); exit } else read line Comp 162 Notes Page 6 of 11 February 16, 2015

7 Computing the space needs of a source line Pass 1 has to figure out how many bytes will be generated by the translation of a line (symbolic instruction or pseudo operation) so it can update the ILC correctly This can be more or less complicated In Pep/8 it is relatively straightforward Here are some examples of lines and the number of bytes its translation takes up in the object program Line Bytes byte 4 1 ascii "*" 1 asra 1 word 0 2 ascii "Hi" 2 loada 10,i 3 ascii "ABCDE" 5 (in general, the number of chars) ascii X=\t \n Result\x00 14 (might be tricky to count them!) block N N Here is another example of processing by Pass 1 (verify the ILC values for yourself) Program ILC before ILC after a: block b: byte c: word d: word 0x e: ascii f: ascii 0x g: block 0x h: byte '\x12' Error checking Here is a list of typical errors that might be detected by an assembler during Pass 1 * symbol defined more than once * instruction has incorrect number of operands * misspelled directive/opcode * invalid addressing mode * missing end * invalid constant (eg, a non-digit character in a decimal number) * missing symbol definition (detected at the end of Pass 1) * invalid string delimiter Comp 162 Notes Page 7 of 11 February 16, 2015

8 Note that while the Pep/8 assembler will detect an error in a line, the error message it gives may not be the best indicator of what the error is For example, when erroneous operand is present main: asra 2;ERROR: Comment expected Assembly operation: Pass 2 If Pass 1 does not find any errors in the source program then Pass 2 uses the symbol table constructed in Pass 1 and the table of opcode information to translate the program For example if M has a value of 15 after Pass 1 then LDA M,d Translates to = C0 00 0F LDr A d <value of symbol M> We assumed that in order to do the error checking of Pass 1 and the translation of Pass 2, the table of opcodes contains information such as the following (see Figure 52) Symbol Template Operand Bytes Modes Allowed ROLr r Yes 1 STr 1110raaa Yes 3 d,s,x,n,sf,sx,sxf STOP No 1 Error detection in Pass 2 In Pep/8 there are no errors that are detectable only in Pass 2 Here is an example of an error in another assembly languages that can be detected only in Pass 2 The fragment includes a branch instruction to a label further down the program X: jmpgt X ; jump to X if result greater than 0 Comp 162 Notes Page 8 of 11 February 16, 2015

9 Suppose that the space in the jmpgt instruction that holds the relative address of X (amount to be added to the PC to make the jump) is limited to 1 byte This means we can only jump to locations within about 127 bytes of current location During Pass 1 we do not know where X is so no error can be signaled If during Pass 2 we find that X is too far away for us to put the distance in the single byte available then we indicate an error The programmer will have to find a different way to implement this branch The equate directive The equate directive lets us associate a symbolic name with a value It is processed in Pass 1 and ignored in Pass 2 so it does not matter where it appears in the program We have seen how to figure out the values that Pass 1 will give to symbols If equate is used, just remember that it does not occupy any space in the object program Consider the following a: block 25 maxu: equate 19 count: word 0 total: word 0 tab : equate 0x09 n: block 8 t: ascii "END" w: byte 'x' Verify for yourself that after Pass 1 the symbol table with contain the following symbols and values Symbol Value a 0 maxu 19 count 25 total 27 tab 9 n 29 t 37 w 40 Comp 162 Notes Page 9 of 11 February 16, 2015

10 Assembler variant 1: Disassembler (see p 207) We cannot in general perform a reverse translation of an object program because data and instructions are indistinguishable in memory For example, in Pep/8 and subsp 2,i translates to byte h word 2 translates to A disassembler can offer two or more translations of a memory block and let the user sort out which is correct Given access to the symbol tables it may be able to make the translation a little more readable In Pep/8, a memory dump shows the (printable) ASCII characters For example, a memory dump of ; test program lda 48,i stro mess1,d deco 51,i stro mess2,d stop mess1: ascii "Adding 34 and 17 gives: \x00" mess2: ascii " Correct! \n\x00" end gives the following 0000 C D À0A A&Add E ing 34 a E nd 17 gi A ves: C F orrect! A Assembler variant 2: Cross assembler A cross assembler is just an assembler that produces an object program for a system different from the one on which it itself runs An example would be using an assembler on an Intel-based Windows system to produce code for an appliance (eg, microwave or BMW or cellphone) that uses a non-intel CPU Often used when the target machine does not have a memory large enough to hold an assembler or perhaps where the target machine only exists on paper Comp 162 Notes Page 10 of 11 February 16, 2015

11 Macros Many real assemblers allow users to declare macro instructions (macros) Here is an example macro SWAP x,y Load r1 %x Move %y, %x Store r1 %x end Now the user can use SWAP as if it were a built-in instruction SWAP P,Q While processing of macros can be built in to Pass 1, it is simpler to have macro definition and expansion handled by Pass 0 Pass 0 uses a table to store the macro definitions and outputs, for Pass 1, a copy of the source code from which macro definitions have been removed and macro calls expanded Macros can be defined for IF, ENDIF, FOR, WHILE and so on to give the assembly language a high-level flavor Reading Unfortunately, Warford does not have much on how the assembler works Section 51 has what little there is Comp 162 Notes Page 11 of 11 February 16, 2015