You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
515 lines
18 KiB
515 lines
18 KiB
package chocopy.pa3;
|
|
|
|
import chocopy.common.analysis.AbstractNodeAnalyzer;
|
|
import chocopy.common.analysis.SymbolTable;
|
|
import chocopy.common.astnodes.AssignStmt;
|
|
import chocopy.common.astnodes.BinaryExpr;
|
|
import chocopy.common.astnodes.BooleanLiteral;
|
|
import chocopy.common.astnodes.CallExpr;
|
|
import chocopy.common.astnodes.ClassDef;
|
|
import chocopy.common.astnodes.ClassType;
|
|
import chocopy.common.astnodes.CompilerError;
|
|
import chocopy.common.astnodes.Errors;
|
|
import chocopy.common.astnodes.Expr;
|
|
import chocopy.common.astnodes.ExprStmt;
|
|
import chocopy.common.astnodes.ForStmt;
|
|
import chocopy.common.astnodes.FuncDef;
|
|
import chocopy.common.astnodes.GlobalDecl;
|
|
import chocopy.common.astnodes.Identifier;
|
|
import chocopy.common.astnodes.IfExpr;
|
|
import chocopy.common.astnodes.IfStmt;
|
|
import chocopy.common.astnodes.IndexExpr;
|
|
import chocopy.common.astnodes.IntegerLiteral;
|
|
import chocopy.common.astnodes.ListExpr;
|
|
import chocopy.common.astnodes.ListType;
|
|
import chocopy.common.astnodes.MemberExpr;
|
|
import chocopy.common.astnodes.MethodCallExpr;
|
|
import chocopy.common.astnodes.NonLocalDecl;
|
|
import chocopy.common.astnodes.NoneLiteral;
|
|
import chocopy.common.astnodes.Program;
|
|
import chocopy.common.astnodes.ReturnStmt;
|
|
import chocopy.common.astnodes.Stmt;
|
|
import chocopy.common.astnodes.StringLiteral;
|
|
import chocopy.common.astnodes.TypedVar;
|
|
import chocopy.common.astnodes.UnaryExpr;
|
|
import chocopy.common.astnodes.VarDef;
|
|
import chocopy.common.astnodes.WhileStmt;
|
|
import chocopy.common.codegen.*;
|
|
|
|
import java.util.List;
|
|
|
|
import com.fasterxml.jackson.core.JsonProcessingException;
|
|
|
|
import static chocopy.common.codegen.RiscVBackend.Register.*;
|
|
|
|
/**
|
|
* This is where the main implementation of PA3 will live.
|
|
*
|
|
* <p>A large part of the functionality has already been implemented in the base class, CodeGenBase.
|
|
* Make sure to read through that class, since you will want to use many of its fields and utility
|
|
* methods in this class when emitting code.
|
|
*
|
|
* <p>Also read the PDF spec for details on what the base class does and what APIs it exposes for
|
|
* its sub-class (this one). Of particular importance is knowing what all the SymbolInfo classes
|
|
* contain.
|
|
*/
|
|
public class CodeGenImpl extends CodeGenBase {
|
|
|
|
/** A code generator emitting instructions to BACKEND. */
|
|
public CodeGenImpl(RiscVBackend backend) {
|
|
super(backend);
|
|
}
|
|
|
|
/** Operation on None. */
|
|
private final Label errorNone = new Label("error.None");
|
|
/** Division by zero. */
|
|
private final Label errorDiv = new Label("error.Div");
|
|
/** Index out of bounds. */
|
|
private final Label errorOob = new Label("error.OOB");
|
|
|
|
/**
|
|
* Emits the top level of the program.
|
|
*
|
|
* <p>This method is invoked exactly once, and is surrounded by some boilerplate code that: (1)
|
|
* initializes the heap before the top-level begins and (2) exits after the top-level ends.
|
|
*
|
|
* <p>You only need to generate code for statements.
|
|
*
|
|
* @param statements top level statements
|
|
*/
|
|
protected void emitTopLevel(List<Stmt> statements) {
|
|
StmtAnalyzer stmtAnalyzer = new StmtAnalyzer(null);
|
|
backend.emitADDI(
|
|
SP, SP, -2 * backend.getWordSize(), "Saved FP and saved RA (unused at top level).");
|
|
backend.emitSW(ZERO, SP, 0, "Top saved FP is 0.");
|
|
backend.emitSW(ZERO, SP, 4, "Top saved RA is 0.");
|
|
backend.emitADDI(FP, SP, 2 * backend.getWordSize(), "Set FP to previous SP.");
|
|
|
|
for (Stmt stmt : statements) {
|
|
stmt.dispatch(stmtAnalyzer);
|
|
}
|
|
backend.emitLI(A0, EXIT_ECALL, "Code for ecall: exit");
|
|
backend.emitEcall(null);
|
|
}
|
|
|
|
/**
|
|
* Emits the code for a function described by FUNCINFO.
|
|
*
|
|
* <p>This method is invoked once per function and method definition. At the code generation
|
|
* stage, nested functions are emitted as separate functions of their own. So if function `bar`
|
|
* is nested within function `foo`, you only emit `foo`'s code for `foo` and only emit `bar`'s
|
|
* code for `bar`.
|
|
*/
|
|
protected void emitUserDefinedFunction(FuncInfo funcInfo) {
|
|
backend.emitGlobalLabel(funcInfo.getCodeLabel());
|
|
|
|
|
|
|
|
// --- Prologue ---
|
|
// space for return address = 4
|
|
// space for control link = 4
|
|
// space for static link = 4
|
|
// space for params = num of params * 4
|
|
// space for locals = num of locals * 4
|
|
int requiredStackSpace = 4 + 4 + 4 + funcInfo.getParams().size() * 4 + funcInfo.getLocals().size() * 4;
|
|
backend.emitADDI(SP, SP, -requiredStackSpace, "Reserve space for stack frame.");
|
|
backend.emitSW(RA, SP, requiredStackSpace-4, "return address");
|
|
backend.emitSW(FP, SP, requiredStackSpace-8, "control link");
|
|
// if we want to add static link
|
|
//backend.emitSW(FP, SP, requiredStackSpace-12, "static link");
|
|
backend.emitADDI(FP, SP, requiredStackSpace, "New fp is at old SP.");
|
|
|
|
|
|
|
|
// --- Function Body ---
|
|
// statements load all the variables that caller put on stack
|
|
// statements use fp to load the variables
|
|
// example: 0(fp) is the last variable (z) while 8(fp) is the first variable (x)
|
|
// for function with 3 params f(x, y, z)
|
|
StmtAnalyzer stmtAnalyzer = new StmtAnalyzer(funcInfo);
|
|
for (Stmt stmt : funcInfo.getStatements()) {
|
|
stmt.dispatch(stmtAnalyzer);
|
|
}
|
|
backend.emitJ(stmtAnalyzer.epilogue, "Jump to function epilogue");
|
|
|
|
|
|
|
|
// --- Epilogue ---
|
|
backend.emitLocalLabel(stmtAnalyzer.epilogue, "Epilogue");
|
|
backend.emitLW(RA, FP, -4, "Get return address");
|
|
backend.emitLW(FP, FP, -8, "Use control link to restore caller's fp");
|
|
backend.emitADDI(SP, SP, requiredStackSpace, "Restore stack pointer");
|
|
backend.emitJR(RA, "Return to caller");
|
|
}
|
|
|
|
/** An analyzer that encapsulates code generation for statements. */
|
|
private class StmtAnalyzer extends AbstractNodeAnalyzer<Void> {
|
|
/*
|
|
* The symbol table has all the info you need to determine
|
|
* what a given identifier 'x' in the current scope is. You can
|
|
* use it as follows:
|
|
* SymbolInfo x = sym.get("x");
|
|
*
|
|
* A SymbolInfo can be one the following:
|
|
* - ClassInfo: a descriptor for classes
|
|
* - FuncInfo: a descriptor for functions/methods
|
|
* - AttrInfo: a descriptor for attributes
|
|
* - GlobalVarInfo: a descriptor for global variables
|
|
* - StackVarInfo: a descriptor for variables allocated on the stack,
|
|
* such as locals and parameters
|
|
*
|
|
* Since the input program is assumed to be semantically
|
|
* valid and well-typed at this stage, you can always assume that
|
|
* the symbol table contains valid information. For example, in
|
|
* an expression `foo()` you KNOW that sym.get("foo") will either be
|
|
* a FuncInfo or ClassInfo, but not any of the other infos
|
|
* and never null.
|
|
*
|
|
* The symbol table in funcInfo has already been populated in
|
|
* the base class: CodeGenBase. You do not need to add anything to
|
|
* the symbol table. Simply query it with an identifier name to
|
|
* get a descriptor for a function, class, variable, etc.
|
|
*
|
|
* The symbol table also maps nonlocal and global vars, so you
|
|
* only need to lookup one symbol table and it will fetch the
|
|
* appropriate info for the var that is currently in scope.
|
|
*/
|
|
|
|
/** Symbol table for my statements. */
|
|
private final SymbolTable<SymbolInfo> sym;
|
|
|
|
/** Label of code that exits from procedure. */
|
|
protected final Label epilogue;
|
|
|
|
/** The descriptor for the current function, or null at the top level. */
|
|
private final FuncInfo funcInfo;
|
|
|
|
/** An analyzer for the function described by FUNCINFO0, which is null for the top level. */
|
|
StmtAnalyzer(FuncInfo funcInfo0) {
|
|
funcInfo = funcInfo0;
|
|
if (funcInfo == null) {
|
|
sym = globalSymbols;
|
|
} else {
|
|
sym = funcInfo.getSymbolTable();
|
|
}
|
|
epilogue = generateLocalLabel();
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
public Void analyze(ReturnStmt stmt) {
|
|
System.out.println("*** ReturnStmt");
|
|
backend.emitLW(T6, FP, 0, "Inside ReturnStmt");
|
|
// Expr expr = stmt.value;
|
|
// // All expressions should save their end result in A0
|
|
// expr.dispatch(this);
|
|
backend.emitLW(A0, FP, 0, "Load var: " + "last");
|
|
return null;
|
|
}
|
|
|
|
|
|
@Override
|
|
public Void analyze(CallExpr node) {
|
|
System.out.println("*** CallExpr");
|
|
backend.emitLW(T6, FP, 0, "Inside CallExpr: " + node.function.name);
|
|
|
|
// function
|
|
Identifier functionId = node.function;
|
|
|
|
List<Expr> args = node.args;
|
|
int spaceRequiredForArgs = (args.size() + 1)*4;
|
|
//backend.emitSW(A0, SP, -4, "Put static link");
|
|
for (int i = 0; i < args.size(); i++) {
|
|
int argNum = i + 1;
|
|
int slotNum = argNum + 1; // We have extra slot for static link
|
|
Expr expr = args.get(i);
|
|
expr.dispatch(this);
|
|
// All expressions should save their end result in A0
|
|
// So, once expr is evaluated add value inside A0 onto stack as an argument
|
|
backend.emitSW(A0, SP, -4*slotNum, "Push argument " + argNum + " from left");
|
|
}
|
|
|
|
backend.emitADDI(SP, SP, -spaceRequiredForArgs, "Set SP to last argument.");
|
|
backend.emitJAL(new Label("$"+functionId.name), "Invoke function: " + functionId.name);
|
|
backend.emitADDI(SP, SP, spaceRequiredForArgs, "Set SP to stack frame top.");
|
|
return null;
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
public Void analyze(MethodCallExpr node) {
|
|
System.out.println("*** MethodCallExpr");
|
|
backend.emitLW(T6, FP, 0, "Inside MethodCallExpr");
|
|
// function
|
|
return defaultAction(node);
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
public Void analyze(FuncDef node) {
|
|
System.out.println("*** FuncDef");
|
|
backend.emitLW(T6, FP, 0, "Inside FuncDef");
|
|
// function
|
|
return defaultAction(node);
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
public Void analyze(GlobalDecl node) {
|
|
System.out.println("*** GlobalDecl");
|
|
backend.emitLW(T6, FP, 0, "Inside GlobalDecl");
|
|
// function
|
|
return defaultAction(node);
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
public Void analyze(NonLocalDecl node) {
|
|
System.out.println("*** NonLocalDecl");
|
|
backend.emitLW(T6, FP, 0, "Inside NonLocalDecl");
|
|
// function
|
|
return defaultAction(node);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// methods below are only for testing, remove or comment them when merging
|
|
@Override
|
|
public Void analyze(AssignStmt node) {
|
|
System.out.println("+++ Inside AssignStmt");
|
|
backend.emitLW(T6, FP, 0, "Inside AssignStmt");
|
|
return defaultAction(node);
|
|
}
|
|
|
|
@Override
|
|
public Void analyze(BinaryExpr node) {
|
|
System.out.println("+++ Inside BinaryExpr");
|
|
backend.emitLW(T6, FP, 0, "Inside BinaryExpr");
|
|
return defaultAction(node);
|
|
}
|
|
|
|
@Override
|
|
public Void analyze(BooleanLiteral node) {
|
|
System.out.println("+++ Inside BooleanLiteral");
|
|
backend.emitLW(T6, FP, 0, "Inside BooleanLiteral");
|
|
return defaultAction(node);
|
|
}
|
|
|
|
@Override
|
|
public Void analyze(ClassDef node) {
|
|
System.out.println("+++ Inside ClassDef");
|
|
backend.emitLW(T6, FP, 0, "Inside ClassDef");
|
|
return defaultAction(node);
|
|
}
|
|
|
|
@Override
|
|
public Void analyze(ClassType node) {
|
|
System.out.println("+++ Inside ClassType");
|
|
backend.emitLW(T6, FP, 0, "Inside ClassType");
|
|
return defaultAction(node);
|
|
}
|
|
|
|
@Override
|
|
public Void analyze(CompilerError node) {
|
|
System.out.println("+++ Inside CompilerError");
|
|
backend.emitLW(T6, FP, 0, "Inside CompilerError");
|
|
return defaultAction(node);
|
|
}
|
|
|
|
@Override
|
|
public Void analyze(Errors node) {
|
|
System.out.println("+++ Inside Errors");
|
|
backend.emitLW(T6, FP, 0, "Inside Errors");
|
|
return defaultAction(node);
|
|
}
|
|
|
|
@Override
|
|
public Void analyze(ExprStmt node) {
|
|
System.out.println("+++ Inside ExprStmt");
|
|
backend.emitLW(T6, FP, 0, "Inside ExprStmt: " + node.expr.kind);
|
|
node.expr.dispatch(this);
|
|
return defaultAction(node);
|
|
}
|
|
|
|
@Override
|
|
public Void analyze(ForStmt node) {
|
|
System.out.println("+++ Inside ForStmt");
|
|
backend.emitLW(T6, FP, 0, "Inside ForStmt");
|
|
return defaultAction(node);
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
public Void analyze(Identifier node) {
|
|
System.out.println("+++ Inside Identifier");
|
|
// List<String> params = funcInfo.getParams();
|
|
// int i = 0;
|
|
// for (i = 0; i < params.size(); i++) {
|
|
// if (params.get(i).equals(node.name)) break;
|
|
// }
|
|
// backend.emitLW(A0, SP, ((i+1)-params.size())*4, "Load param " + (i+1) + " from left");
|
|
backend.emitLW(T6, FP, 0, "Inside Identifier: " + node.name);
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public Void analyze(IfExpr node) {
|
|
System.out.println("+++ Inside IfExpr");
|
|
backend.emitLW(T6, FP, 0, "Inside IfExpr");
|
|
return defaultAction(node);
|
|
}
|
|
|
|
@Override
|
|
public Void analyze(IfStmt node) {
|
|
System.out.println("+++ Inside IfStmt");
|
|
backend.emitLW(T6, FP, 0, "Inside IfStmt");
|
|
return defaultAction(node);
|
|
}
|
|
|
|
@Override
|
|
public Void analyze(IndexExpr node) {
|
|
System.out.println("+++ Inside IndexExpr");
|
|
backend.emitLW(T6, FP, 0, "Inside IndexExpr");
|
|
return defaultAction(node);
|
|
}
|
|
|
|
@Override
|
|
public Void analyze(IntegerLiteral node) {
|
|
System.out.println("+++ Inside IntegerLiteral");
|
|
backend.emitLA(A0, new Label("$int$prototype"), "Load prototype");
|
|
backend.emitJAL(new Label("ra, alloc"), "");
|
|
backend.emitLI(T0, node.value, "Load integer " + node.value);
|
|
backend.emitSW(T0, A0, "@.__int__", null);
|
|
backend.emitLW(T6, FP, 0, "Inside IntegerLiteral");
|
|
return defaultAction(node);
|
|
}
|
|
|
|
@Override
|
|
public Void analyze(ListExpr node) {
|
|
System.out.println("+++ Inside ListExpr");
|
|
backend.emitLW(T6, FP, 0, "Inside ListExpr");
|
|
return defaultAction(node);
|
|
}
|
|
|
|
@Override
|
|
public Void analyze(ListType node) {
|
|
System.out.println("+++ Inside ListType");
|
|
backend.emitLW(T6, FP, 0, "Inside ListType");
|
|
return defaultAction(node);
|
|
}
|
|
|
|
@Override
|
|
public Void analyze(MemberExpr node) {
|
|
System.out.println("+++ Inside MemberExpr");
|
|
backend.emitLW(T6, FP, 0, "Inside MemberExpr");
|
|
return defaultAction(node);
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
public Void analyze(NoneLiteral node) {
|
|
System.out.println("+++ Inside NoneLiteral");
|
|
backend.emitLW(T6, FP, 0, "Inside NoneLiteral");
|
|
return defaultAction(node);
|
|
}
|
|
|
|
@Override
|
|
public Void analyze(Program node) {
|
|
System.out.println("+++ Inside Program");
|
|
backend.emitLW(T6, FP, 0, "Inside Program");
|
|
return defaultAction(node);
|
|
}
|
|
|
|
|
|
@Override
|
|
public Void analyze(StringLiteral node) {
|
|
System.out.println("+++ Inside StringLiteral");
|
|
backend.emitLW(T6, FP, 0, "Inside StringLiteral");
|
|
return defaultAction(node);
|
|
}
|
|
|
|
@Override
|
|
public Void analyze(TypedVar node) {
|
|
System.out.println("+++ Inside TypedVar");
|
|
backend.emitLW(T6, FP, 0, "Inside TypedVar");
|
|
return defaultAction(node);
|
|
}
|
|
|
|
@Override
|
|
public Void analyze(UnaryExpr node) {
|
|
System.out.println("+++ Inside UnaryExpr");
|
|
backend.emitLW(T6, FP, 0, "Inside UnaryExpr");
|
|
return defaultAction(node);
|
|
}
|
|
|
|
@Override
|
|
public Void analyze(VarDef node) {
|
|
System.out.println("+++ Inside VarDef");
|
|
backend.emitLW(T6, FP, 0, "Inside VarDef");
|
|
return defaultAction(node);
|
|
}
|
|
|
|
@Override
|
|
public Void analyze(WhileStmt node) {
|
|
System.out.println("+++ Inside WhileStmt");
|
|
backend.emitLW(T6, FP, 0, "Inside WhileStmt");
|
|
return defaultAction(node);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// extras end here
|
|
|
|
}
|
|
|
|
/**
|
|
* Emits custom code in the CODE segment.
|
|
*
|
|
* <p>This method is called after emitting the top level and the function bodies for each
|
|
* function.
|
|
*
|
|
* <p>You can use this method to emit anything you want outside of the top level or functions,
|
|
* e.g. custom routines that you may want to call from within your code to do common tasks. This
|
|
* is not strictly needed. You might not modify this at all and still complete the assignment.
|
|
*
|
|
* <p>To start you off, here is an implementation of three routines that will be commonly needed
|
|
* from within the code you will generate for statements.
|
|
*
|
|
* <p>The routines are error handlers for operations on None, index out of bounds, and division
|
|
* by zero. They never return to their caller. Just jump to one of these routines to throw an
|
|
* error and exit the program. For example, to throw an OOB error: backend.emitJ(errorOob, "Go
|
|
* to out-of-bounds error and abort");
|
|
*/
|
|
protected void emitCustomCode() {
|
|
emitErrorFunc(errorNone, "Operation on None");
|
|
emitErrorFunc(errorDiv, "Division by zero");
|
|
emitErrorFunc(errorOob, "Index out of bounds");
|
|
}
|
|
|
|
/** Emit an error routine labeled ERRLABEL that aborts with message MSG. */
|
|
private void emitErrorFunc(Label errLabel, String msg) {
|
|
backend.emitGlobalLabel(errLabel);
|
|
backend.emitLI(A0, ERROR_NONE, "Exit code for: " + msg);
|
|
backend.emitLA(A1, constants.getStrConstant(msg), "Load error message as str");
|
|
backend.emitADDI(
|
|
A1, A1, getAttrOffset(strClass, "__str__"), "Load address of attribute __str__");
|
|
backend.emitJ(abortLabel, "Abort");
|
|
}
|
|
}
|