BasicBlock.h

Go to the documentation of this file.

#pragma once

#include <vector>

#include "Common.h"
#include "CompilerHelper.h"

namespace dev
{
namespace eth
{
namespace jit
{
using namespace evmjit;
using instr_idx = uint64_t;

class RuntimeManager;

class LocalStack: public CompilerHelper
{
public:
        explicit LocalStack(IRBuilder& _builder, RuntimeManager& _runtimeManager);

        void push(llvm::Value* _value);

        llvm::Value* pop();

        void dup(size_t _index);

        void swap(size_t _index);

        ssize_t size() const { return static_cast<ssize_t>(m_local.size()) - m_globalPops; }
        ssize_t minSize() const { return m_minSize; }
        ssize_t maxSize() const { return m_maxSize; }

        void finalize();

private:
        llvm::Value* get(size_t _index);

        void set(size_t _index, llvm::Value* _value);

        llvm::Function* getStackPrepareFunc();

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

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

        llvm::CallInst* m_sp = nullptr; 

        ssize_t m_globalPops = 0;       
        ssize_t m_minSize = 0;          
        ssize_t m_maxSize = 0;          
};

class BasicBlock
{
public:
        explicit BasicBlock(instr_idx _firstInstrIdx, code_iterator _begin, code_iterator _end, llvm::Function* _mainFunc);

        llvm::BasicBlock* llvm() { return m_llvmBB; }

        instr_idx firstInstrIdx() const { return m_firstInstrIdx; }
        code_iterator begin() const { return m_begin; }
        code_iterator end() const { return m_end; }

private:
        instr_idx const m_firstInstrIdx = 0;    
        code_iterator const m_begin = {};               
        code_iterator const m_end = {};                 

        llvm::BasicBlock* const m_llvmBB;               
};

}
}
}