FunctionCompiler.hpp

Go to the documentation of this file.

#pragma once

#ifndef CHI_FUNCTION_COMPILER_HPP
#define CHI_FUNCTION_COMPILER_HPP

#include "chi/Fwd.hpp"
#include "chi/LLVMVersion.hpp"
#include "chi/NodeCompiler.hpp"

#include <llvm/IR/DebugInfo.h>

#include <memory>
#include <unordered_map>

#include <boost/bimap.hpp>
#include <boost/utility/string_view.hpp>

namespace chi {

struct FunctionCompiler {
    FunctionCompiler(const GraphFunction& func, llvm::Module& moduleToGenInto,
                     llvm::DICompileUnit& debugCU, llvm::DIBuilder& debugBuilder);

    Result initialize(bool validate = true);

    Result compile();

    using DebugFunctionType =
#if LLVM_VERSION_LESS_EQUAL(3, 6)
        llvm::DICompositeType
#else
        llvm::DISubroutineType*
#endif
        ;

    DebugFunctionType createSubroutineType();

    using DebugFunction = llvm::DISubprogram
#if LLVM_VERSION_AT_LEAST(3, 7)
        *
#endif
        ;
    using DebugFile = llvm::DIFile
#if LLVM_VERSION_AT_LEAST(3, 7)
        *
#endif
        ;

    DebugFunction diFunction() {
        assert(initialized() &&
               "Please initialize the function compiler before getting the debug function");
        return mDebugFunc;
    }

    llvm::Module& llvmModule() const { return *mModule; }

    llvm::DIBuilder& diBuilder() const { return *mDIBuilder; }

    llvm::DICompileUnit* debugCompileUnit() const { return mDebugCU; }

    llvm::BasicBlock& allocBlock() const {
        assert(initialized() &&
               "Please initialize the function compiler before getting the alloc block");
        return *mAllocBlock;
    }

    llvm::Value* localVariable(boost::string_view name);

    llvm::Function& llFunction() const {
        assert(initialized() &&
               "Please initialize the function compiler before trying to get the LLVM function");
        return *mLLFunction;
    }

    llvm::Value& postPureBreak() const {
        assert(initialized() &&
               "Please initialize the function compiler before trying to get the post-pure break");
        return *mPostPureBreak;
    }

    const GraphFunction& function() const { return *mFunction; }

    GraphModule& module() const;

    Context& context() const;

    int nodeLineNumber(NodeInstance& node);

    bool initialized() const { return mInitialized; }

    bool compiled() const { return mCompiled; }

    NodeCompiler* nodeCompiler(NodeInstance& node);

    NodeCompiler* getOrCreateNodeCompiler(NodeInstance& node);

private:
    std::unordered_map<std::string, llvm::Value*> mLocalVariables;

    llvm::Module*        mModule    = nullptr;
    llvm::DIBuilder*     mDIBuilder = nullptr;
    llvm::DICompileUnit* mDebugCU   = nullptr;
    DebugFile            mDIFile{};
    DebugFunction        mDebugFunc{};

    const GraphFunction* mFunction = nullptr;

    llvm::Function*   mLLFunction = nullptr;
    llvm::BasicBlock* mAllocBlock = nullptr;

    std::unordered_map<NodeInstance*, NodeCompiler> mNodeCompilers;

    boost::bimap<unsigned, NodeInstance*> mNodeLocations;

    bool mInitialized = false;
    bool mCompiled    = false;

    llvm::Value* mPostPureBreak = nullptr;
};

Result compileFunction(const GraphFunction& func, llvm::Module* mod, llvm::DICompileUnit* debugCU,
                       llvm::DIBuilder& debugBuilder);
}  // namespace chi

#endif  // CHI_FUNCTION_COMPILER_HPP