NodeCompiler.hpp

Go to the documentation of this file.

#pragma once

#ifndef CHI_NODE_COMPILER_HPP
#define CHI_NODE_COMPILER_HPP

#include "chi/Fwd.hpp"

#include <cassert>
#include <unordered_set>
#include <vector>

#include <boost/dynamic_bitset.hpp>

namespace chi {

struct NodeCompiler {
    NodeCompiler(FunctionCompiler& functionCompiler, NodeInstance& inst);

    NodeCompiler(const NodeCompiler&) = delete;

    NodeCompiler(NodeCompiler&&) = default;

    NodeCompiler& operator=(const NodeCompiler&) = delete;

    NodeCompiler& operator=(NodeCompiler&&) = default;

    FunctionCompiler& funcCompiler() const { return *mCompiler; }

    NodeInstance& node() const { return *mNode; }

    bool pure() const;

    void compile_stage1(size_t inputExecID);

    Result compile_stage2(std::vector<llvm::BasicBlock*> trailingBlocks, size_t inputExecID);

    bool compiled(size_t inputExecID) const;

    llvm::BasicBlock& firstBlock(size_t inputExecID) const;

    llvm::BasicBlock& codeBlock(size_t inputExecID) const;

    llvm::Module& llvmModule() const;

    Context& context() const;

    size_t inputExecs() const;

    std::vector<llvm::Value*> returnValues() const { return mReturnValues; }

    llvm::IndirectBrInst& jumpBackInst() const {
        assert(pure() && "Cannot get jump back inst for a nonpure node");
        return *mJumpBackInst;
    }

private:
    FunctionCompiler* mCompiler;
    NodeInstance*     mNode;

    std::vector<std::vector<llvm::BasicBlock*>> mPureBlocks;
    std::vector<llvm::BasicBlock*>              mCodeBlocks;

    std::vector<llvm::Value*> mReturnValues;

    boost::dynamic_bitset<> mCompiledInputs;

    llvm::IndirectBrInst* mJumpBackInst = nullptr;
};

std::vector<NodeInstance*> dependentPuresRecursive(const NodeInstance& inst);

}  // namespace chi

#endif  // CHI_NODE_COMPILER_HPP