1 The Simpletron Assembly Language

Transcription

1 Simpletron Assembler 50 points In the Simpletron assignment we introduced a fictional machine called the Simpletron and the Simpletron Machine Language (SML). In this assignment you are to write an assembler that converts programs written in the Simpletron Assembly Language to SML. We provide you with programs in this new assembler language with the intention of assembling them with the assembler you will write and running the resulting SML program on the simulator you wrote. 1 The Simpletron Assembly Language Before we begin building the assembler we describe the high-level programming language called Simpletron Assembly Language. Every line in the Simpletron Assembly Language consists of an optional label, which if present must begin in the leftmost column, a valid instruction, and depending on the instruction, an operand. Most of the instructions are simply mnemonics for Simpletron operation codes. The valid instructions are listed in figure 1. Note that it is not legal for lines containing the I instruction to start with a label. All other instructions may have the optional label starting in the leftmost column. Comments are allowed in the Simpletron Assembly Language. Comments in the Simpletron Assembly Language have adopted the C++ convention of starting with // and may appear anwhere on a line. Anything between // and the end of a line may/should be ignored by your assembler. This syntax allows for comments to appear at the end of a line and/or entire lines to be nothing but comments. Consider the following Simpletron Assembly program that accepts two input values and prints and prints 1 if the first is greater than the second otherwise it prints 2. // reads two numbers, // prints 1 if the first is greater than second // otherwhise it prints a 2 R first R second I 10 // first input number I 20 // second input number // subtract second from first, // if result is <= 0 then print 2 // otherwise print 1 L first S second BN printtwo BZ printtwo W one // print 1 and halt H printtwo W two // print 1 and halt H // storage first DS second DS one DC 1 two DC 2 1

2 Optional label Instruction Operand Description Input/Output instructions: < label > R label Read a word into the label operand. < label > W label Print the word from the label operand. Load/Store instructions: < label > L label Load the word from label operand into the accumulator. < label > ST label Store the contents of the accumulator into the word identified by the label operand. Arithmetic instructions: < label > A label Add the word identified by the label operand to the accumulator (leave result in accumulator). < label > S label Subtract the word identfied by the label operand from the accumulator (leave result in accumulator). < label > M label Multiply the word identified by the label operand to the accumulator (leave result in accumulator). < label > D label Divide the word identfied by the label operand into the accumulator (leave result in accumulator). Transfer of control instructions: < label > B label Branch to the address identified by the label operand. < label > BN label Branch to the address identified by the label operand if the value in the accumulator is negative. < label > BZ label Branch to the address identified by the label operand if the value in the accumulator is zero. < label > H Halt execution. Storage reserve/define instructions: < label > DS Reserve a single word of storage, initialize to zero. < label > DC constant Reserve a single word of storage, initialize to constant operand. I constant Constant input that is intended to be read by R commands. These instructions are not executed. Figure 1: Instruction set for Simpletron Assembly Language. 2

3 Each of the first three lines begin with // and therefore everything appearing on the rest of the line is ignored as comments. The first executable statement is the R first line. Read instructions (R) acquire a value from input instructions (I) and store the value at the word identified by the label operand. The very first read instruction that is executed uses the very first input instruction in the program. Subsequently executed read instructions use the remaining input instructions in the order in which they appear in the program. Input instructions are never used more than once. The same read instruction will consume many input instructions if it is executed many times (e.g., in a loop ). This first read instruction reads the constant 10 (from the I 10 line) into the the single word of storage reseved by the line first DS near the end of the program. The second read line R second reads the constant 20 (from the I 20 line) into the single word reserved by second DS. The next two lines define input constants and are not executed. Such input lines may appear anywhere in the program. Note, however, that both input lines have comments at the end of each. Execution continues through ignoring the next three lines which are comments (note that the // did not start in the leftmost column in these lines) and proceeds to L first. This loads the accumulator with the word identified by the label operand first. In our example program, this places the value 10 (the first input value we just read) into the accumulator. The next instruction S second subtracts the word identified by the label operand second from the value in the accumulator leaving the difference in the accumulator. The next two instructions are branching instructions. The first branches to the address associated with the operand label printtwo if the value in the accumulator is negative and the second branches to that same address if the value in the accumulator is zero. The next two lines of the program print the word identified by the label operand one (defined to be the constant 1) and halts execution. The following two lines print the constant 2 and halts. The end of our program is where we define our storage and constants. 2 Input The input to your program is a Simpletron Assembly program, just like the one shown in the previous section. You may assume that all Simpletron Assembly programs given to your assembler are syntactically correct. Syntax checking is a critical component of any assembler, however, proper syntax checking is a very difficult problem and well beyond the scope of this course. Hence, when you write your assembler you may make the simplifying assumption that the programs you are assembler are syntactically correct. 3 Output Your assembler will produce a complete SML program, including the line followed by any input (from any I instructions in the Simpletron Assembly program) or an error message (error messages described in section 4). The SML program generated by your assembler must be immediately suitable for execution on your simpletron. In other words, you should be able to take the SML program generated by your assembler and feed it directly (without modification) as input to your simpletron. 4 The Two Pass Assembler The result of the compiler is the SML program, which is composed of SML instructions and data, a line containing to mark the end of the program, and possibly some input data. Your assembler program should use a memory array identical to the one it used in the Simpletron assignment and a data array with a counter to to collect the values from the input (I) commands. int memory[memsize]; int data[memsize]; int ndata; 3

4 Your program will also use an array of flags and a symbol table (both are described below). The symbol table will have 2,000 rows where each row is an instance of the structure below. The flags array must have a flag for each memory location. #define SYMBOLTABLESIZE 2000 struct tableentry { char *symbol; int location; /* Simpletron address (000 to MEMSIZE-1) */ } symboltable[symboltablesize]; /* end struct tableentry */ int flags[memsize]; After some minor initialization, the assembler performs two passes. The first pass constructs the symbol table in which every label of the assembly program is stored with its corresponding location in the final SML code (the symbol table is described in detail below) and fills the data array with the values from the input commands. The first pass always writes partial SML instructions by always writing 000 for SML operand. The flags array, in conjunction with the symbol table, will be used to complete these partial SML instructions by fillling in the missing SML operand values during the second pass (described below). Your program should use the following variables to record the Simpletron address for the next instruction and an index for the next symbol in the symbol table. int next_instruction_addr; int next_symbol_table_idx; The second pass of the assembler locates (using the flags array) and completes (using the symbol table) the partial instructions. After the second pass, the assembler prints the finished SML program, followed by any input data. 4.1 Initialization Your compiler must initialize all of the Simpletron s memory to and all the flags to -1. It should initialize all the entries of the symbol table by setting each symboltable[i].symbol to NULL and each symboltable[i].location to -1. It should initialize the next instruction address to the top of the Simpletron s memory (memory location 0), the index of the next entry into the symbol table to 0, and finally the counter for the Simpletron Assembly input instructions (I) to 0. next_instruction_addr = 0; next_symbol_table_idx = 0; ndata = 0; 4.2 Pass 1 The first pass of the assembler reads and processes the assembly program one line at a time. In processing a single line of the assembly program the assembler can make addition(s) to the symbol table, add a (possibly partial) SML instruction to the Simpletron s memory, or add constants and/or reserve words in the Simpletron s memory. Each time a new line is read from the assembly program, if it is a line that has a label which must start in the leftmost column, that label must be added to the symbol table along with the corresponding address of the next instruction of the SML program (next_instruction_addr). Note that no two lines of the program may have the same label (i.e., labels must be unique). Each time a constant or storage is declared (i.e., DC or DS) a single word of the Simpletron s memory is allocated exactly where the DC or DS instruction appeared. Instructions that require a label operand (all but H, DS, DC, and I) result in partial instructions where the SML operand is written as 000. The label 4

5 operand is searched for in the symbol table and added if it was not found. Either way (whether the symbol was already in the symbol table or it was just added) the element of the flags array associated with the Simpletron s memory is changed from -1 to the index into the symbol table where the label operand resides. Here we discuss the details of how to processes each of the Simpletron Assembly Instructions commands in the first pass. In discussing each it is assumed that comments will be ignored and that any label that appeared in the leftmost column of the line has already been added to the symbol table. Also, for each instruction that takes a label operand, it is assumed that you will search the symbol table for the label operand, adding, if necessary, the label (and leaving symboltable[i].location as -1 if just added). For those assembler instructions which are simply mnemonics for Simpletron operation codes (i.e., R, W, L, ST, A, S, M, D, B, BN, BZ, and H) write corresponding partial SML instruction (i.e., , , , etc.) at the memory location next_instruction_addr being careful to write the SML operand as 000. Of those instructions that have label operands (all but H), place the symbol table index of the label operand into the flags array in the slot corrsponding to next_instruction_addr. Finally, be sure to increment next_instruction_addr for the next SML instruction. DS. Simply zero the word at the memory location next_instruction_addr and increment next_instruction_addr. DC. Verify that the integer constant will fit into a word of the Simpletron s memory (i.e., the constant must be >= and <= 99999). If it s a valid constant, set the memory location next_instruction_addr to that constant and increment next_instruction_addr. I. Place the constant operand into data[ndata] and increment ndata. Note that you do not increment next_instruction_addr for input instructions. There are only 1,000 words in the Simpletron memory and it is possible to deplete that. If by adding instructions you find that you have run past the end of memory or have entered the variable/constant section of the memory, or if by allocating space for variables/constants you have entered the program section of the memory, simply print *** ERROR: ran out Simpletron memory and terminate the assembly immediately, (i.e., without printing the SML program). To illustrate the first pass of the assembler we take you through its steps as it processes the example program from section 1. We start with the first non-comment line of the program, R first. We write the partial SML instruction at memory location 000 and search the symbol table for the label operand first. Since it is not there, we add first to the first row of the symbol table by using strdup() to make a copy of the string first and placing the pointer to the copy in symboltable[0].symbol. We leave symboltable[0].location untouched. symboltable[0].location will be filled in when we encounter the symbol first in the leftmost column of the program. We then add the index of the symbol first (in this case 0) to the element of the flags array that corresponds with our SML instruction s address, again in this case 0 (i.e., flags[000] = 0). This completes the first pass assembly of the first line of our program. Assembly continues with the second line R second. Again, we write the partial SML instruction 10000, this time at memory location 001, add the symbol second to the second row of the symbol table, and conclude by setting flags[001] = 1. The third line is the input instruction I 10. We simply place the constant operand 10 into the first element of our data array and increment ndata. We process the next line I 20 by placing the constant operand 20 into the second element of the data array and incrementing ndata again. Note that in processing both of these input instructions we did not modify the Simpletron s memory, the symbol table, nor the flags array. We continue by ignoring the next three comment lines and processing the load instruction L first. We write the partial SML instruction at memory location 002 and search the symbol table for the label operand first. This time we find the symbol and we note that it is in 5

6 row 0 of the symbol table. We update the flags array accordingly by setting flags[002] = 0. We process the subtract instruction S second similarly by writing the partial SML at memory location 003 and setting flags[003] = 1. Assembly continues with BN printtwo where we again write the partial SML instruction at memory location 004, adding the label operand printtwo to the third row of the symbol table, and setting flags[004] = 2. BZ printtwo is processed similarly by writing the partial SML instruction at memory location 005 and setting flags[005] = 2. In processing the W one instruction we write the partial SML instruction at memory location 006, add the label operand one to the fourth row of the symbol table, and set flags[006] = 3. The halt instruction H allows us to write our first complete SML instruction in memory location 007, which also allows us to leave the flags array untouched for this instruction. Finally we come to our first instruction that has a symbol starting in the leftmost column, printtwo W two. We start by searching the symbol table for the label starting in the leftmost column (printtwo). In this case we find the label in the third row of the symbol table (placed there when we previously processed BN printtwo). If we did not find the symbol printtwo in the symbol table, we would have added it here. In either case, we may now update the location field for this row of the symbol table to the Simpletron s memory location where we are about to write the next instruction, (i.e., symboltable[2].location = 008). Having processed the symbol starting in the leftmost column, we continue our processing of printtwo W two by writing the partial SML instruction in memory location 008, adding two to the fifth row of the symbol table, and setting flags[008] = 4. We then encounter another halt instruction H so we write the SML instruction in memory location 009 and proceed into the storage section of our program. The next instruction first DS starts with a label, so we search the symbol table and find first in the first row of the table. We update the location field of that row by setting it to 010. We may then process the DS command by reserving a word in the Simpletron s memory and initializing it to zero, so we write in memory location 010. Likewise we process the next DS instruction by setting the location field of the second row of the symbol table to 011 and writing in memory location 011. Finally we come to our last two instructions of the program, both defining storage for constants. The first instruction one DC 1 is processed by searching and finding the label one in the fourth row of the symbol table and setting the location field of that row to 012. We then write reserve a word of the Simpletron s memory for this constant and initialize it the value of the operand by writing into memory location 012. The last instruction is processed in a similar manner by first updating the location field of the fifth row of our symbol table (corresponding to the label two) to 013 and writing into memory location 013. This concludes the assembler s first pass through the maximum program. At the end of the first pass data[0]=10, data[1]=20, and ndata=2, the symbol table is as it is presented in figure 3 and the Simpletron memory and flags arrays are presented in figure 2. 6

7 Assembly Program SML flags R first R second I 10 I 20 L first S second BN printtwo BZ printtwo W one H printtwo W two H first DS second DS one DC two DC Figure 2: memory and flags after first pass of maximum program. Values througout memory arrary are and in flags array is -1 unless otherwise stated. Symbol SMLaddr first 010 second 011 printtwo 008 one 012 two 013 Figure 3: Symbol table after first pass of maximum program. 4.3 Pass 2 The purpose of the second pass is to complete the partial instructions written in the first pass. This is done by traversing the flags array and completing any instruction whose corresponding flags value is!= -1. All other entries in flags[i] correspond to a partial instruction that needs completion. When you encounter an element of the flags array that is!= -1, use the non-negative value found there to index the symbol table and set the operand portion of the partial instruction to the location field of that row of the symbol table. There is one error that could occur during the second pass. If you find a row of the symbol table that still has location = -1, then you have an unresolved reference in which case you should print *** ERROR: unresolved reference and terminate the assembly immediately, (i.e., without printing the SML program). Returing to our example program above, we see that there are eight elements in the flags array that have values other than -1. Processing the first one (location 000) requires us to use the value in flags[000], in this case 0, as in index into our symbol table and to use the value the location field (in this case 010) to complete the partial instruction in memory location 000. This changes the partial instruction from to Similarly, the partial instruction in memory location 001 is completed and re-written as Use the flags array and the symboltable to complete the remaining partial instructions. 7

8 4.4 Print SML Program After the second pass you will have a complete SML program (no partial instructions) and a data array ready for printing. Print all the words you filled in the memory array, one word per line, followed by , and conclude by printing all the values read into the data array. Using the example program above, the output of your assembler should look like this: Files I Give You In /home/olympus/classes/handout/03fall/sas you will find a collection of Simpletron assembler programs. They include four programs that will assemble and a collection of programs that will not. The filename and brief description of each Simple program is in figure 4. Filename Expected Result Description Simpletron assembler programs that will not assemble. duplabel.a *** ERROR: duplicate symbol Program has duplicate symbol. bigpgm.a *** ERROR: ran out Simpletron memory Cannot allocate space for an instruction. nolabel.a *** ERROR: unresolved symbol Program has unresolved symbol. bigconst.a *** ERROR: illegal constant Defines constant > smallconst.a *** ERROR: illegal constant Defines constant < Simpletron assembler programs that will assemble. end.a no output 1 line Simple program, end. read.a print READ: value Reads an integer into a variable. rw.a READ and output value then constant Reads and prints a number and constant. max.a max of two input values Reads two numbers and prints 1 if first is greater, otherwise prints 2. Figure 4: Simpletron assembler programs we supply you. In that same directory you will find the executable script submit_sas and two executable files, simpletron.key, the solution to the Simpletron assignment, and sas.key, the solution to this assignment. You may use the Simpletron Assembly programs above along with the solutions simpletron.key and sas.key to debug your program. The output of your assembler and Simpletron must look exactly like the output produced by sas.key and simpletron.key. Your programs will be tested, for example, in the following manner, 8

9 % sas.key < max.a simpletron.key > max.key % sas < max.a simpletron > max.out % diff max.out max.key % Where sas and simpletron are your solutions. To be eligible for full credit your output must exactly match (empty diff) the output of simpletron.key for each of the Simpletron Assembler programs listed in the table above. Note this is a minimum requirement. We may test your programs with Simpletron Assembler programs other than those listed above. 6 Files You Must Write You will submit at least three files for this assignment, a makefile that will allow a make clean which removes all binary files and a make sas which produces your executable solution to this assignment which must appear in a file called sas, a header file called simpletron.h, and as manyu source file(s) as you like. The header file, simpletron.h, must contall all the #define statements that define the Simpletron s instruction set, (i.e., #define READ 10, #define WRITE 11, etc.). You may also include other informatino in simpletron.h as you see fit. Use submit_sas to submit (one at a time) your makefile and each of your source code files (i.e., do not submit your binary files). To submit your makefile, for example, simply type submit_sas makefile. 9