Heart of SaM: a Stack and Stack Pointer (SP) 7-2 SP (Stack Pointer) Stack

Transcription

1 What is SaM? SaM is a simple stack machine that we will use to (i) understand virtual machines and Java portability, and (ii) understand at the assembly language level how computers work. Heart of SaM: a Stack and Stack Pointer (SP) - SP (Stack Pointer) Stack SaM I Am Stack: an array of integers Stack grows when integer is "pushed" on top. Stack shrinks when integer is "popped" from top. Stack starts at address and grows to larger addresses. Stack pointer: first "free" address in stack (initialized to )

2 SaM commands ALL arithmetic/logical operations pop values from stack perform operation and push result. SaM Commands PUSHIMM *some integer* //pushes that integer on stack ADD //pops two values from top of stack //adds them and pushes result SUB //pops two values (say top and below) //and pushes result of doing (below - top) - SP 5 SP TIMES GREATER // boolean values are simulated using / (false/true) AND //logical AND... ADD - pop two values from stack ( and -) - add them (5) - push result SUB: similar; result would be (-) - () = -9 STOP //terminate execution of program 8 6 Operations on Stack - 6 SP - Pushing 6 on stack SP Pushing an Integer - SaM Commands 6 - SP SP - SP - Pop: removes from stack and returns it SP Popping an Integer PUSHIMM 6 - push the integer 6 on stack Stack operations are used to implement SaM commands. They are NOT SaM commands themselves. 5

3 SaM Commands - - SP SP DUP : duplicate the top element of the stack note: nothing is popped from stack SaM Commands - SP SP Here are two simple SaM programs: 5 PUSHIMM PUSHIMM PUSHIMM PUSHIMM TIMES Booleans are simulated in SaM with integers True ->, false -> GREATER - pop two values (Vtop and Vbelow) from stack - in example, Vtop = and Vbelow = - - if Vbelow > Vtop push else push - in example, we would push. TIMES //should leave on top of stack STOP 5 PUSHIMM PUSHIMM GREATER //should leave on top of stack STOP TIMES 9

4 How do commands get into Program array? Sample program execution: HALT PC HALT PC - Stack SP Program PUSHIMM PUSHIMM ADD Loader: method that is given a filename reads in commands from file and writes them into We will assume all programs are loaded into program memory starting at address. Program array Program SP Stack PUSHIMM 5 PUSHIMM GREATER STOP 6 Where does program reside in SaM? Program Stack HALT SP PC PUSHIMM PUSHIMM ADD Program: an area of memory that contains commands Program Counter (PC): address of command to be executed Program execution: PC = ; while (HALT == ) //STOP command sets HALT to Execute command Program[PC]; //arithmetic and logical commands increment PC Stack Interpreter: PC = ; Stack Pointer while (HALT == ){ Execute Program[PC]; Reboot HALT Program Program Counter opcode: PUSHIMM operand: 5 opcode: PUSHIMM operand: Loader: Loc = ; do{ Read a command from file; Create Instruction object for command; Program[Loc] = Instruction object; Loc++; while (! EOF) SaM PUSHIMM 5 PUSHIMM opcode: TIMES File TIMES... STOP 5

5 far, SaM commands were executed sequentially: each command So PC when it was done. incremented ability to skip some commands ability to repeatedly execute some sequence of commands understand this program, let us look at where these commands To stored in the Program area. are JUMP t: jump to instruction at Program[t] and start instructions from there on. Implementation: PC t executing JUMPC t: pop boolean from stack if it is true, execute starting at Program[t] otherwise, this command commands no eect and execution continues with command after this has one. Implementation: pop top of stack (V top ). If V top PUSHIMM 5 Jumps and Conditional Jumps PUSHIMM GREATER //is 5 > JUMPC 5 //if so, jump to 5 PUSHIMM Need more exibility to translate conditionals and loops: // this command will be stored at Program[5] PUSHIMM STOP Solution: JUMP/JUMPC commands 8 Frame Base Register HALT PC JUMP/JUMPC: like GOTOs in Pascal - FBR SP Program PUSHIMM PUSHIMM ADD Stack Frame Base Register: used to implement method invocations for now, assume it contains PC t otherwise, PC + +. is true, 9

6 Write a program to nd absolute value of element on top of stack. Program SP 68 SP //work-horses void reboot() int load(string s) //input:file name, returns number of commands lo void start() //start execution void dumpstate() //print out registers and stack contents DUP //duplicate top of stack...//other methods we will see later PUSHIMM GREATER //n >? JUMPC 6 //forward jump to STOP PUSHIMM - TIMES //(n)*(-) STOP interface SaM{ //getter and setter methods void setfbr(int v) Program getfbr() int Address : PUSHIMM 5 void setpc(int v) int getpc() void setsp(int v) : PUSHIMM getsp() int : GREATER //is 5 > void setstackelement(int a, int v) //Stack[a] = v int : JUMPC 5 //if so, jump to 5 getstackelement(int a) //return Stack[a] : PUSHIMM 5: PUSHIMM //convenient setter and getter methods 6: STOP void push(int v) int pop() void incpc()

7 class Instruction implements InstructionInterface{ private String opcode One approach to writing a SaM simulator: class Simulator { //main class private int operand //optional public Instruction(CSIn f) {... //read one command from file and make Instruction class SaMmy implements SaMInterface{... //return string representing command class Instruction implements InstructionInterface{... public void execute(sam machine) { //execute instruction 8 6 interface InstructionInterface { class Simulator { public static void main(string[] arg) { if (arg.length == ) { System.out.println("sam file must be command line argument") return void execute(sam machine) SaM Sumatra = new SaMmy() //My machine is called Sumatra int psize = Sumatra.load(arg[]) Sumatra.start() Sumatra.dumpState() 5

8 class SaMmy implements SaM{ public void execute(sam machine){ //for executing the instruction... public void start() { //Execute instructions starting at Program[] if (opcode.equals("add")){ int op = machine.pop() HALT = PC = int op = machine.pop() machine.push(op + op) do { Program[PC].execute(this) machine.incpc() while(halt == ) else if (opcode.equals("pushimm"){ //other opcode public Instruction(CSIn inf) { class SaMmy implements SaM{ opcode = inf.getword() if (opcode.equals("pushimm"))//only command with an explicit operand operand = inf.getint() protected int PC,FBR,SP,HALT protected InstructionInterface[] Program = new InstructionInterface[] protected int[] Stack = new int[] public int load(string ProgramFile) { //Load in instructions from ProgramFile and store in Program CSIn inf = new CSIn(ProgramFile) //create input manager int LC = //LC is where next instruction should be put public String tostring(){ while (inf.peekatkind()!= inf.eof) if (opcode == PUSHIMM) { Program[LC] = new Instruction(inf) return ("PUSHIMM " + operand) LC++ else return opcode inf.close() return LC... 9

9 can we still store dierent types of instructions into Program How in SaM? array new command => changing a bunch of variables and Adding in the Instruction class: methods you wrote this sort of code, you might as well program in a If language!! non-oo class ADDInst implements InstructionInterface { Modular solution: USE SUBTYPING return "ADD" Represent each opcode by its own class. public void execute(sam machine) { Adding new opcode = adding new class to program! machine.pop() int op = int op = machine.pop() machine.push(op + op) Answer: all classes implement InstructionInterface! machine.incpc() Happily, type of Program is InstructionInterface[]! 6 Critique of solution: Instruction SaMmy Type Picture InstructionInterface Object SaM opcodetable, constructor, tostring, execute, No easy way to extend the code to accommodate more commands. ADDInst SUBInst STOPInst... PUSHIMMInst JUMPInst... 5

10 Let load read in opcode and create an instance of the Solution: class. right How does this change SaM class? No change needed to start method!! class SaMmy implements SaM{ public int load(string ProgramFile) {//override Load in SaM class SaMmy implements SaM{... CSIn inf = new CSIn(ProgramFile) //create input manager public void start() { //Execute instructions starting at Program[] int LC = //LC is where next instruction should be put HALT = PC = ReadLoop: while (inf.peekatkind()!= inf.eof) do { { String s = inf.getword() Program[PC].execute(this) //type dispatch!! InstructionInterface i if (s.equals("add")) i = (InstructionInterface)new ADDInst() while(halt == ) else if (s.equals("sub")) i = (InstructionInterface)new SUBInst()... else... 8 class SaMmy implements SaM{ class SUBInst implements InstructionInterface {... return "SUB" public void Execute(SaM machine) { public int load(string ProgramFile) { //Load in instructions from ProgramFile and store in Program CSIn inf = new CSIn(ProgramFile) int LC = while (inf.peekatkind()!= inf.eof) { Program[LC] = new Instruction(inf) <--- does not make sense int op = machine.pop() int op = machine.pop() LC++ machine.push(op - op) machine.incpc() inf.close() return LC... There is no Instruction class anymore to instatiate! 9

11 of load code: still need a conditional that must be Criticism when opcode is added! modied some cool code: given a String representing a class name, Heres an instance of that class! create note: Why cant reading of operands be performed by Java in the ADDInst, SUBInst etc. classes? constructors if you use reection to generate a class name on the y, Problem: can only call the default constructor that takes no arguments. you public int load(string ProgramFile) { CSIn inf = new CSIn(ProgramFile) //create input manager int LC = //LC is where next instruction should be put ReadLoop: while (inf.peekatkind()!= inf.eof) { String s = inf.getword() So we cannot pass inf to it. InstructionInterface i try { i = (InstructionInterface)(Class.forName(s + "Inst")).newInstance() catch (Exception e) {System.out.println("Funny opcode " + s) break ReadLoop //now read in operands i.readoperand(inf) //must extend InstructionInterface to i.readoperand(inf) Program[LC] = i //require readoperand method Program[LC] = i LC++ LC++ return LC return LC Reection: interpret a string as a class name and create an instance of that class!

12 class JUMPCInst implements InstructionInterface { class PUSHIMMInst implements InstructionInterface { protected int operand protected int operand public void readoperand(csin inf) { public void readoperand(csin inf) { operand = inf.getint() operand = inf.getint() return "JUMPC " + operand return "PUSHIMM " + operand public void execute(sam machine) { public void execute(sam machine) { if (machine.pop() == ) machine.setpc(operand) machine.push(operand) machine.incpc() else machine.incpc() 8 6 Heres the denition of the new instruction interface: interface InstructionInterface { void readoperand(csin inf) class JUMPInst implements InstructionInterface { void execute(sam machine) protected int operand... public void readoperand(csin inf) { operand = inf.getint() class ADDInst implements InstructionInterface { public void readoperand(csin inf) { //no-op return "JUMP " + operand public void execute(sam machine) { return "ADD" public void execute(sam machine) { machine.setpc(operand) int op = machine.pop() int op = machine.pop() machine.push(op + op) machine.incpc() 5

13 Instruction: contains code common to all instructions (dont this with old Instruction class we dened at the start, I confuse ran out of meanginful names) just InstructionWithOperand extends Instruction: contains code instructions with no operands All will have exactly the (ADD,SUB,TIMES,GREATER,NOT,...) instructions with one operand (PUSHIMM,JUMP,...) will have All the same readoperand method. exactly abstract class Instruction implements InstructionInterface{ abstract public void execute(sam machine) public void readoperand(csin inf) {//do nothing Answer: use inheritance Dene two abstract classes: protected String mnemonic() { //another use of reflection String s = this.getclass().getname() return s.substring(, s.length() - ("Inst".length())) common to all instructions with an operand. return mnemonic() 5 5 OK, so this is cool, but there is a fair amount of code repeated. InstructionWithOperand InstructionInterface Object SaM Instruction SaMmy same readoperand method. ADDInst SUBInst STOPInst... Is there a way to \share" this code between dierent classes? PUSHIMMInst JUMPInst

14 far, JUMP and JUMPC commands (in le) took an integer So operand. numbers Any command can be given a label. Final twist to SaM saga: symbolic labels in SaM commands class ADDInst extends Instruction { //inherit tostring and readoperand! public void execute(sam machine) { int op = Example: JUMP 68 machine.pop() int op = machine.pop() It is more convenient to use symbolic labels for commands. machine.push(op + op) machine.setpc(machine.getpc() + ) Label: a name that starts with a letter and contains letters and A command may have multiple labels //This is the class for all instructions with one operand. //The operand can be a word or an integer. abstract class InstructionWithOperand extends Instruction{ protected int operand class JUMPInst extends InstructionWithOperand{//inherit tostring,readoperand public void execute(sam machine) { mnemonic() + " " + operand return machine.setpc(operand) public void readoperand(csin inf) { if(inf.peekatkind() == inf.integer) operand = inf.getint() //else should report error 5 55

15 Commands like JUMP take symbolic labels as operands Within machine, instructions like JUMP require integer as operands. addresses Who does the conversion from labels to integers? hash table. called Hash table maintains a set of (key,value) pairs. In our example, are symbolic labels and values are integers (addresses keys to the symbolic labels). corresponding from the hash table. pair Designing a hash table for fast look up: see later. While loading the program, create a directory of (symbolic address) pairs (like a telephone directory) name, JAMES =, BOND =, etc.). (eg. Directory is called a symbol table. After loading is done, walk over instructions in Program and each symbolic name by address, using symbol table (eg, replace Symbol table is an example of a more general data structure Question: Two main operations: insert a new (key,value) pair look up the value corresponding to a key Answer: loader. Sometimes, we may also want to delete a particular (key,value) 6 58 Additional duty of loader: PUSHIMM //some value n DUP //duplicate top of stack PUSHIMM GREATER //n >? JUMPC BOND //forward jump to instruction labeled BOND PUSHIMM - TIMES //(n)*(-) JAMES: replace BOND in instruction JUMPC BOND by. BOND: STOP This is called a two-pass loader. 5 59

16 change loader so it keeps track of (name, address) pairs change InstructionWithOperand so it can read in and store a operand symbolic add a translate method to each instruction: given symbol look up symbolic operand and translate to integer if table, necessary. while(s.endswith(":")) {String tmpstr = s.substring(,s.length()-) boolean success = ST.insert(tmpstr,LC) if (! success) println("multiply defined label " + tmpstr ) //check for dangling label at end of file interface InstructionInterface{ if (inf.peekatkind() == inf.eof) break FirstLoop void readoperand(csin inf) //reads one integer or word operand else s = inf.getword() void execute(sam machine) void translate(symboltable ST, SaM m) //translate symbolic addresses into integers //at this point, s should contain the opcode InstructionInterface i try { i = (InstructionInterface)(Class.forName(s + "Inst")).n catch (Exception e) {println("funny opcode " + s) return //two pass loader: first pass reads in instructions into Program array This requires the following changes: //but does not translate symbolic operands. second pass performs translatio //returns number of instructions read in public int load(string ProgramFile) { CSIn inf = new CSIn(ProgramFile) //create input manager return load(inf) public int load(csin inf) { SymbolTable ST = new SymbolTable() int LC = //LC is where next instruction should be put //First Pass LC = FirstLoop: while (inf.peekatkind()!= inf.eof) { String s = inf.getword() //eat up labels 6 6

17 abstract class Instruction implements InstructionInterface{ abstract public void execute(sam machine) public void readoperand(csin inf) { public void translate(symboltable ST, SaM m) { public void translate(symboltable ST, SaM m) { //if we had a symbolic operand if (! dest.equals("")) { //translate protected String mnemonic() { //the opcode String s = this.getclass().getname() operand = ST.lookup(dest) return s.substring(, s.length() - ("Inst".length())) if (operand == -) m.println("undefined name " + dest) //change dest so that we can print both dest and operand dest = dest + " //address: " return mnemonic() i.readoperand(inf) Program[LC] = i //This is the class for all instructions with one operand. LC++ //The operand can be a word or an integer. abstract class InstructionWithOperand extends Instruction{ inf.close() protected String dest = new String("") protected int operand //Second Pass for (int i = i < LC i++) { mnemonic() + " " + dest + operand return if (Program[i] == null) public void readoperand(csin inf) { if(inf.peekatkind() == inf.word) println("??? Null instruction at location " + i) dest = new String(inf.getWord()) else Program[i].translate(ST, this) else if(inf.peekatkind() == inf.integer) operand = inf.getint() return LC 65 6

18 give SaM a few more commands to make it possible to Lets real programs to SaM commands. compile "real" programs, we often need to read and write stack locations In than topmost stack location. other this corresponds to treating Stack area as if it is a Intuitively, memory. conventional PUSHIND Command 68 SP 68 SP Before PUSHIND After PUSHIND PUSHIND : TOS contains a Stack address. Pop that address, read contents of that address, and push. STOREIND Command 68 SP SaM continued 5??? So far, we have only pushed and popped values from stack. Before STOREIND After STOREIND STOREIND : TOS contains a value. Below that is a stack address. Pop these from the stack and Write value into that address. 69

19 PUSHFBR/POPFBR Commands SP SP 69 68??? FBR 6 6??? FBR 6 Before PUSHFBR After PUSHFBR PUSHFBR: Push contents of FBR on stack. Stack[SP] = FBR; SP++; POPFBR: Inverse operation SP--; FBR = Stack[SP]; 6 PUSHOFF Command STOREOFF Command SP SP SP SP FBR FBR FBR FBR Before PUSHOFF After PUSHOFF Before STOREOFF After STOREOFF PUSHOFF x : let v be value stored in address (FBR + x) push v on top of stack FBR is unchanged STOREOFF x : Say TOS contains value v. Pop it from the stack and write v into address (FBR + x) FBR is unchanged 5

20 Two instructions for control transfer in method call/return: JSR xxxx: Push address of next instruction on stack and jump to xxxx JUMPIND: Pop an address from stack, and jump to that address Example:... JSR foo //assume this instruction is stored in Program[] ADD... foo: ADDSP 5 //assume foo is JUMPIND //assume this instruction is stored at Program[]... Sequence of PC values:, 98, 99,...,,,, PUSHSP/POPSP Commands ADDSP Command 68 SP SP 69 68?????? 68 - SP 68 6 SP 6 Before PUSHSP After PUSHSP Before ADDSP -5 After ADDSP -5 PUSHSP: Push contents of SP on stack. Stack[SP] = SP; SP++; POPSP: Inverse operation SP--; SP = Stack[SP]; ADDSP: takes one integer as explicit operand Add that integer to SP ADDSP n can be written in terms of other instructions: PUSHSP PUSHIMM n ADD POPSP Convenient to have just one command. 9

21 and inheritance are powerful tools for writing reusable Interfaces programs. (inheritance,interfaces). type Dynamic method binding: permits existing code to splice in (of implementation) Permits subtype to be dened Inheritance incrementally language (BASIC, FORTRAN,...). favorite SaM code is portable - write SaM code (or compile SaM code say a Java program) and ship SaM code around the from Internet. is like SaM. (JVM) JVM is much more complicated than SaM - need to support Interfaces permit independent development of implementation and client code. code Interfaces permit objects of dierent types to be stored in one structure. Example: instructions of dierent types in data Central ideas: Subtyping: permits you to dene an extension of an existing the new type without modication. Useful idea: SaM Simulator brings all these ideas together. 8 Final Notes on SaM Interfaces in SaM simulator: Portability of SaM code: SaM standard: everyone agrees on SaM commands, labels etc. On all Macs/PCs/etc, provide SaM simulator written in your Interfaces document specications. methods must SaM support to permit instructions to What execute? What methods do instructions support? Java achieves portability the same way - Java Virtual Machine Program array threads, multiple data types, need to worry about security etc. 8 8