lib/codegen/CodeGen.h

Go to the documentation of this file.

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

#ifndef COMMA_CODEGEN_CODEGEN_HDR_GUARD
#define COMMA_CODEGEN_CODEGEN_HDR_GUARD

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

#include "llvm/DerivedTypes.h"
#include "llvm/GlobalValue.h"
#include "llvm/Intrinsics.h"
#include "llvm/Constants.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/StringMap.h"

namespace comma {

class CodeGenTypes;
class CommaRT;
class DependencySet;
class InstanceInfo;
class SRInfo;

class CodeGen : public Generator {

public:
    ~CodeGen();

    CommaRT &getRuntime() const { return *CRT; }

    llvm::Module *getModule() { return M; }

    llvm::Constant *getModuleName();

    const llvm::TargetData &getTargetData() const { return TD; }

    AstResource &getAstResource() const { return Resource; }

    llvm::LLVMContext &getLLVMContext() const {
        return llvm::getGlobalContext();
    }

    bool extendWorklist(DomainInstanceDecl *instace);

    InstanceInfo *lookupInstanceInfo(const DomainInstanceDecl *instance) const {
        return instanceTable.lookup(instance);
    }

    InstanceInfo *getInstanceInfo(const DomainInstanceDecl *instance) const {
        InstanceInfo *info = lookupInstanceInfo(instance);
        assert(info && "Instance lookup failed!");
        return info;
    }

    SRInfo *getSRInfo(DomainInstanceDecl *instance, SubroutineDecl *srDecl);

    const DependencySet &getDependencySet(const Domoid *domoid);

    bool insertGlobal(const std::string &linkName, llvm::GlobalValue *GV);

    llvm::GlobalValue *lookupGlobal(const std::string &linkName) const;

    llvm::GlobalValue *lookupCapsuleInfo(const Domoid *domoid) const;

    llvm::GlobalVariable *emitInternString(const llvm::StringRef &elems,
                                           bool addNull = true,
                                           bool isConstant = true,
                                           const std::string &name = "");

    llvm::BasicBlock *makeBasicBlock(const std::string &name = "",
                                     llvm::Function *parent = 0,
                                     llvm::BasicBlock *insertBefore = 0) const;

    llvm::GlobalVariable *makeExternGlobal(llvm::Constant *init,
                                           bool isConstant = false,
                                           const std::string &name = "");

    llvm::GlobalVariable *makeInternGlobal(llvm::Constant *init,
                                           bool isConstant = false,
                                           const std::string &name = "");

    llvm::Function *makeFunction(const llvm::FunctionType *Ty,
                                 const std::string &name = "");

    llvm::Function *makeFunction(const DomainInstanceDecl *instance,
                                 const SubroutineDecl *srDecl,
                                 CodeGenTypes &CGT);

    llvm::Function *makeInternFunction(const llvm::FunctionType *Ty,
                                       const std::string &name = "");

    llvm::Function *getLLVMIntrinsic(llvm::Intrinsic::ID id) const {
        assert(!llvm::Intrinsic::isOverloaded(id) &&
               "Cannot retrieve overloaded intrinsics!");
        return llvm::Intrinsic::getDeclaration(M, id);
    }

    llvm::Function *getMemcpy64() const;

    llvm::Function *getMemcpy32() const;

    llvm::Function *getMemset32() const;


    llvm::Function *getEHExceptionIntrinsic() const;
    llvm::Function *getEHSelectorIntrinsic() const;
    llvm::Function *getEHTypeidIntrinsic() const;

    const llvm::OpaqueType *getOpaqueTy() const {
        return llvm::OpaqueType::get(getLLVMContext());
    }

    const llvm::PointerType *getInt8PtrTy() const {
        return getPointerType(getInt8Ty());
    }

    const llvm::Type *getVoidTy() const {
        return llvm::Type::getVoidTy(getLLVMContext());
    }

    const llvm::IntegerType *getInt1Ty() const {
        return llvm::Type::getInt1Ty(getLLVMContext());
    }

    const llvm::IntegerType *getInt8Ty() const {
        return llvm::Type::getInt8Ty(getLLVMContext());
    }

    const llvm::IntegerType *getInt16Ty() const {
        return llvm::Type::getInt16Ty(getLLVMContext());
    }

    const llvm::IntegerType *getInt32Ty() const {
        return llvm::Type::getInt32Ty(getLLVMContext());
    }

    const llvm::IntegerType *getInt64Ty() const {
        return llvm::Type::getInt64Ty(getLLVMContext());
    }

    const llvm::IntegerType *getIntPtrTy() const {
        unsigned width = TD.getPointerSizeInBits();
        return llvm::IntegerType::get(getLLVMContext(), width);
    }

    llvm::Constant *getNullPointer(const llvm::PointerType *Ty) const {
        return llvm::ConstantPointerNull::get(Ty);
    }

    llvm::PointerType *getPointerType(const llvm::Type *Ty) const {
        return llvm::PointerType::getUnqual(Ty);
    }

    llvm::ConstantInt *getConstantInt(const llvm::IntegerType *type,
                                      uint64_t value) const {
        return llvm::ConstantInt::get(type, value);
    }

    llvm::ConstantInt *getConstantInt(const llvm::IntegerType *type,
                                      const llvm::APInt &value) const;

    llvm::Constant *
    getConstantArray(const llvm::Type *elementType,
                     std::vector<llvm::Constant*> &elems) const {
        llvm::ArrayType *arrayTy;
        arrayTy = llvm::ArrayType::get(elementType, elems.size());
        return llvm::ConstantArray::get(arrayTy, elems);

    }

    llvm::Constant *getPointerCast(llvm::Constant *constant,
                                   const llvm::PointerType *Ty) const {
        return llvm::ConstantExpr::getPointerCast(constant, Ty);
    }

    llvm::StructType *getStructTy(const std::vector<const llvm::Type*> &elts,
                                  bool isPacked = false) const {
        return llvm::StructType::get(getLLVMContext(), elts, isPacked);
    }

    llvm::ArrayType *getVLArrayTy(const llvm::Type *componentTy) const {
        return llvm::ArrayType::get(componentTy, 0);
    }



    SourceLocation getSourceLocation(Location loc);

    llvm::ConstantInt *getSourceLine(Location loc) {
        return llvm::ConstantInt::get(getInt32Ty(),
                                      getSourceLocation(loc).getLine());
    }

    llvm::ConstantInt *getSourceColumn(Location loc) {
        return llvm::ConstantInt::get(getInt32Ty(),
                                      getSourceLocation(loc).getColumn());
    }

private:
    llvm::Module *M;

    const llvm::TargetData &TD;

    AstResource &Resource;

    CommaRT *CRT;

    typedef llvm::StringMap<llvm::GlobalValue *> StringGlobalMap;

    StringGlobalMap capsuleInfoTable;

    StringGlobalMap globalTable;

    typedef llvm::DenseMap<const DomainInstanceDecl*, InstanceInfo*> InstanceMap;
    InstanceMap instanceTable;

    typedef llvm::DenseMap<const Domoid*, DependencySet*> DependenceMap;
    DependenceMap dependenceTable;

    llvm::Constant *moduleName;

    InstanceInfo *createInstanceInfo(DomainInstanceDecl *instance);

    bool instancesPending() const;

    void emitNextInstance();

    void emitCapsule(InstanceInfo *info);

    //===------------------------------------------------------------------===//
    // Generator interface and support.

    friend class Generator;

    CodeGen(llvm::Module *M, const llvm::TargetData &data,
            AstResource &resource);

    void emitToplevelDecl(Decl *decl);
    void emitEntry(ProcedureDecl *decl);
};

} // end comma namespace.

#endif

---