source: liacs/coco/assignment4/StackFrameManager.cc@ 144

/*
 * StackFrameManager.cc - Implementation of the StackFrameManager class
 *
 * Part of the assignment of the Compiler Construction course
 * LIACS, Leiden University
 */

#include "StackFrameManager.h"
#include "globals.h"
#include "MOperator.h"
#include "MOperand.h"
#include "AssemblerCode.h"
#include "assert.h"

// Constructor:
StackFrameManager::StackFrameManager(AssemblerCode& ac)
  : currentSubprogram(NULL), ac(ac),
    frameSize(12), localFrameSize(12),
    raOffset(0), fpOffset(-4), rvOffset(-8)
{
}


// Destructor:
StackFrameManager::~StackFrameManager() {
}


// Analyzes a subprogram and computes the stack frame layout.
// This function should always be called once for a subprogram before
// calls to GeneratePrologue/Epilogue or GenerateLocalAddress are made.
void StackFrameManager::AnalyzeSubprogram(SymbolTable * symtab, Symbol * subprogram) {
  bool isProgramBody = false;

  currentSubprogram = subprogram;

  if (subprogram->GetSymbolType() == ST_PROGRAM) {
    isProgramBody = true;
  }

  frameSize = 12; // 12 for return address, old frame pointer and return value
  localFrameSize = frameSize;

  // set return value offset
  subprogram->SetOffset(rvOffset);

  if (!isProgramBody) {

    // set parameter offsets and count frameSize
    int offset = 4;
    for (int i = 0; i < subprogram->GetParameterCount(); ++i) {
      Symbol *symbol = subprogram->GetParameter(i);
      symbol->SetOffset(offset);
      offset += 4;
      frameSize += 4;
    }
      // count and set offsets for local variables and temporary variables
    Scope *scope = symtab->GetScope(subprogram->GetName());
    offset = -12;
    for (unsigned int i = 0; i < scope->GetNumberOfSymbols(); ++i) {
      Symbol *symbol = scope->GetSymbol(i);
      if (symbol->GetSymbolType() == ST_VARIABLE || symbol->GetSymbolType() == ST_TEMPVAR) {
        symbol->SetOffset(offset);
        offset -= 4;
        frameSize += 4;
        localFrameSize += 4;
      }
    }
  } else {
    // for main program body only set temporary variable offsets
    Scope *scope = symtab->GetScope(subprogram->GetName());
    int offset = -12;
    for (unsigned int i = 0; i < scope->GetNumberOfSymbols(); ++i) {
      assert(offset != 0);
      Symbol *symbol = scope->GetSymbol(i);
      if (symbol->GetSymbolType() == ST_TEMPVAR) {
        symbol->SetOffset(offset);
        offset -= 4;
        frameSize += 4;
        localFrameSize += 4;
      }
    }
  }

}


// Generates the code that sets up the stack frame at the entry point of a
// subprogram.
void StackFrameManager::GeneratePrologue(FILE *) {
  // Indicate the beginning of a new subprogram:
  ac.AppendStatement(new MStatement(MOP_ENT, new MOperand(MT_LABEL, string(SYMBOL_PREFIX) + currentSubprogram->GetName() )));
  MStatement *stmt = new MStatement(MOP_LABEL);
  stmt->SetLabel(string(SYMBOL_PREFIX) + currentSubprogram->GetName());
  ac.AppendStatement(stmt);

  // Save the return address on the stack
  ac.AppendStatement(new MStatement(MOP_SW, new MOperand(MT_REGISTER, R_RA), new MOperand(MT_OFFSET, R_SP, raOffset), "Set up stack frame"));
  // Save the old frame pointer on the stack
  ac.AppendStatement(new MStatement(MOP_SW, new MOperand(MT_REGISTER, R_FP), new MOperand(MT_OFFSET, R_SP, fpOffset)));
  // Setting the new frame pointer value
  ac.AppendStatement(new MStatement(MOP_MOVE, new MOperand(MT_REGISTER, R_FP), new MOperand(MT_REGISTER, R_SP)));
  // Setting the new stack pointer value
  ac.AppendStatement(new MStatement(MOP_ADDI, new MOperand(MT_REGISTER, R_SP), new MOperand(MT_REGISTER, R_SP), new MOperand(MT_INT, -localFrameSize)));
}


// Generates the code that discards the stack frame at the leaving point of
// a subprogram.
void StackFrameManager::GenerateEpilogue(FILE *) {
  // Restore the return address
  ac.AppendStatement(new MStatement(MOP_LW, new MOperand(MT_REGISTER, R_RA), new MOperand(MT_OFFSET, R_FP, raOffset), "Return from call"));
  // Restore the old frame pointer
  ac.AppendStatement(new MStatement(MOP_LW, new MOperand(MT_REGISTER, R_FP), new MOperand(MT_OFFSET, R_FP, fpOffset)));
  // Set the new stack pointer value
  ac.AppendStatement(new MStatement(MOP_ADDI, new MOperand(MT_REGISTER, R_SP), new MOperand(MT_REGISTER, R_SP), new MOperand(MT_INT, frameSize)));
  // Jump back to the return address
  ac.AppendStatement(new MStatement(MOP_JR, new MOperand(MT_REGISTER, R_RA)));

  // Indicate the end of this subprogram:
  ac.AppendStatement(new MStatement(MOP_END, new MOperand(MT_LABEL, string(SYMBOL_PREFIX) + currentSubprogram->GetName() )));
}


// Generates a $fp-relative address for a local variable or parameter.
// The output can be used directly as an operand for load/store instructions.
void StackFrameManager::GenerateLocalAddress(FILE * out, Symbol * sym) {
  int offset = 0;

  offset = sym->GetOffset();

  // Now write the address to the output file:
  fprintf(out, "%d($fp)", offset);
}