include/comma/codegen/CodeGenRoutine.h

Go to the documentation of this file.

//===-- codegen/CodeGenRoutine.h ------------------------------ -*- C++ -*-===//
//
// This file is distributed under the MIT license. See LICENSE.txt for details.
//
// Copyright (C) 2009, Stephen Wilson
//
//===----------------------------------------------------------------------===//

#ifndef COMMA_CODEGEN_CODEGENROUTINE_HDR_GUARD
#define COMMA_CODEGEN_CODEGENROUTINE_HDR_GUARD

#include "comma/ast/AstBase.h"
#include "comma/codegen/CodeGen.h"

#include "llvm/DerivedTypes.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/Support/IRBuilder.h"

namespace llvm {

class BasicBlock;
class Function;

} // end namespace llvm;

namespace comma {

// This class provides for code generation of subroutines.
class CodeGenRoutine {

    CodeGenCapsule &CGC;
    CodeGen        &CG;
    CodeGenTypes   &CGTypes;
    const CommaRT  &CRT;

    // Builder object used to construct LLVM IR.
    llvm::IRBuilder<> Builder;

    // The subroutine declaration we are emitting code for.
    SubroutineDecl *SRDecl;

    // The llvm function we are emitting code into.
    llvm::Function *SRFn;

    // The first (implicit) argument to this function (%).
    llvm::Value *percent;

    // The entry block for the subroutine.
    llvm::BasicBlock *entryBB;

    // The return block for the subroutine.
    llvm::BasicBlock *returnBB;

    // The return value for the subroutine, represented as an alloca'd stack
    // slot.  If we generating a procedure, this member is null.
    llvm::Value *returnValue;

    // Map from Comma decl's to corresponding LLVM values.
    typedef llvm::DenseMap<Decl *, llvm::Value *> DeclMap;
    DeclMap declTable;

public:
    CodeGenRoutine(CodeGenCapsule &CGC);

    void declareSubroutine(SubroutineDecl *srDecl);
    void emitSubroutine(SubroutineDecl *srDecl);

private:
    // Emits the prologue for the current subroutine given a basic block
    // representing the body of the function.
    void emitPrologue(llvm::BasicBlock *body);

    // Emits the epilogue for the current subroutine.
    void emitEpilogue();

    void injectSubroutineArgs();

    void emitSubroutineBody();

    void emitObjectDecl(ObjectDecl *objDecl);

    void emitStmt(Stmt *stmt);
    void emitIfStmt(IfStmt *ite);
    void emitReturnStmt(ReturnStmt *ret);
    void emitStmtSequence(StmtSequence *seq);
    void emitProcedureCallStmt(ProcedureCallStmt *stmt);
    void emitAssignmentStmt(AssignmentStmt *stmt);

    llvm::BasicBlock *emitBlockStmt(BlockStmt *block,
                                    llvm::BasicBlock *predecessor = 0);

    llvm::Value *emitExpr(Expr *expr);
    llvm::Value *emitDeclRefExpr(DeclRefExpr *expr);
    llvm::Value *emitPrjExpr(PrjExpr *expr);
    llvm::Value *emitInjExpr(InjExpr *expr);
    llvm::Value *emitIntegerLiteral(IntegerLiteral *expr);

    llvm::Value *emitFunctionCall(FunctionCallExpr *expr);

    llvm::Value *emitPrimitiveCall(FunctionCallExpr *expr,
                                   std::vector<llvm::Value *> &args);

    llvm::Value *emitLocalCall(SubroutineDecl *srDecl,
                               std::vector<llvm::Value *> &args);

    llvm::Value *emitDirectCall(SubroutineDecl *srDecl,
                                std::vector<llvm::Value *> &args);

    llvm::Value *emitCallArgument(SubroutineDecl *srDecl, Expr *arg,
                                  unsigned argPosition);

    llvm::Value *lookupDecl(Decl *decl);

    static bool isDirectCall(const FunctionCallExpr *expr);

    static bool isDirectCall(const ProcedureCallStmt *stmt);

    static bool isLocalCall(const FunctionCallExpr *expr);

    static bool isLocalCall(const ProcedureCallStmt *stmt);

    llvm::Function *getOrCreateSubroutineDeclaration(SubroutineDecl *srDecl);

    llvm::Value *emitScalarLoad(llvm::Value *ptr);

    llvm::Value *getStackSlot(Decl *decl);

    llvm::Value *emitVariableReference(Expr *expr);

    llvm::Value *emitValue(Expr *expr);

    llvm::Value *createStackSlot(Decl *decl);

    llvm::Value *getOrCreateStackSlot(Decl *decl);
};

} // end comma namespace

#endif

---