Compiler.cpp

Go to the documentation of this file.

#include "Compiler.h"

#include <fstream>
#include <chrono>
#include <sstream>

#include "preprocessor/llvm_includes_start.h"
#include <llvm/IR/CFG.h>
#include <llvm/IR/Module.h>
#include <llvm/IR/IntrinsicInst.h>
#include "preprocessor/llvm_includes_end.h"

#include "JIT.h"
#include "Instruction.h"
#include "Type.h"
#include "Memory.h"
#include "Ext.h"
#include "GasMeter.h"
#include "Utils.h"
#include "Endianness.h"
#include "Arith256.h"
#include "RuntimeManager.h"

namespace dev
{
namespace eth
{
namespace jit
{

static const auto c_destIdxLabel = "destIdx";

Compiler::Compiler(Options const& _options, evm_mode _mode, llvm::LLVMContext& _llvmContext):
        m_options(_options),
        m_mode(_mode),
        m_builder(_llvmContext)
{
        Type::init(m_builder.getContext());
}

std::vector<BasicBlock> Compiler::createBasicBlocks(code_iterator _codeBegin, code_iterator _codeEnd)
{
        auto skipPushDataAndGetNext = [](code_iterator _curr, code_iterator _end)
        {
                static const auto push1  = static_cast<size_t>(Instruction::PUSH1);
                static const auto push32 = static_cast<size_t>(Instruction::PUSH32);
                size_t offset = 1;
                if (*_curr >= push1 && *_curr <= push32)
                        offset += std::min<size_t>(*_curr - push1 + 1, (_end - _curr) - 1);
                return _curr + offset;
        };

        std::vector<BasicBlock> blocks;

        bool isDead = false;
        auto begin = _codeBegin; // begin of current block
        for (auto curr = begin, next = begin; curr != _codeEnd; curr = next)
        {
                next = skipPushDataAndGetNext(curr, _codeEnd);

                if (isDead)
                {
                        if (Instruction(*curr) == Instruction::JUMPDEST)
                        {
                                isDead = false;
                                begin = curr;
                        }
                        else
                                continue;
                }

                bool isEnd = false;
                switch (Instruction(*curr))
                {
                case Instruction::JUMP:
                case Instruction::RETURN:
                case Instruction::STOP:
                case Instruction::SUICIDE:
                        isDead = true;
                case Instruction::JUMPI:
                        isEnd = true;
                        break;

                default:
                        break;
                }

                assert(next <= _codeEnd);
                if (next == _codeEnd || Instruction(*next) == Instruction::JUMPDEST)
                        isEnd = true;

                if (isEnd)
                {
                        auto beginIdx = begin - _codeBegin;
                        blocks.emplace_back(beginIdx, begin, next, m_mainFunc);
                        begin = next;
                }
        }

        return blocks;
}

void Compiler::resolveJumps()
{
        auto jumpTable = llvm::cast<llvm::SwitchInst>(m_jumpTableBB->getTerminator());
        auto jumpTableInput = llvm::cast<llvm::PHINode>(m_jumpTableBB->begin());

        // Iterate through all EVM instructions blocks (skip first one and last 4 - special blocks).
        for (auto it = std::next(m_mainFunc->begin()), end = std::prev(m_mainFunc->end(), 4); it != end; ++it)
        {
                auto nextBlockIter = it;
                ++nextBlockIter; // If the last code block, that will be "stop" block.
                auto currentBlockPtr = &(*it);
                auto nextBlockPtr = &(*nextBlockIter);
                
                auto term = it->getTerminator();
                llvm::BranchInst* jump = nullptr;

                if (!term) // Block may have no terminator if the next instruction is a jump destination.
                        IRBuilder{currentBlockPtr}.CreateBr(nextBlockPtr);
                else if ((jump = llvm::dyn_cast<llvm::BranchInst>(term)) && jump->getSuccessor(0) == m_jumpTableBB)
                {
                        auto destIdx = llvm::cast<llvm::ValueAsMetadata>(jump->getMetadata(c_destIdxLabel)->getOperand(0))->getValue();
                        if (auto constant = llvm::dyn_cast<llvm::ConstantInt>(destIdx))
                        {
                                // If destination index is a constant do direct jump to the destination block.
                                auto bb = jumpTable->findCaseValue(constant).getCaseSuccessor();
                                jump->setSuccessor(0, bb);
                        }
                        else
                                jumpTableInput->addIncoming(destIdx, currentBlockPtr); // Fill up PHI node

                        if (jump->isConditional())
                                jump->setSuccessor(1, &(*nextBlockIter)); // Set next block for conditional jumps
                }
        }

        auto simplifiedInput = jumpTableInput->getNumIncomingValues() == 0 ?
                        llvm::UndefValue::get(jumpTableInput->getType()) :
                        jumpTableInput->hasConstantValue();
        if (simplifiedInput)
        {
                jumpTableInput->replaceAllUsesWith(simplifiedInput);
                jumpTableInput->eraseFromParent();
        }
}

std::unique_ptr<llvm::Module> Compiler::compile(code_iterator _begin, code_iterator _end, std::string const& _id)
{
        auto module = llvm::make_unique<llvm::Module>(_id, m_builder.getContext()); // TODO: Provide native DataLayout

        // Create main function
        auto mainFuncType = llvm::FunctionType::get(Type::MainReturn, Type::RuntimePtr, false);
        m_mainFunc = llvm::Function::Create(mainFuncType, llvm::Function::ExternalLinkage, _id, module.get());
        m_mainFunc->getArgumentList().front().setName("rt");

        // Create entry basic block
        auto entryBB = llvm::BasicBlock::Create(m_builder.getContext(), "Entry", m_mainFunc);

        auto blocks = createBasicBlocks(_begin, _end);

        // Special "Stop" block. Guarantees that there exists a next block after the code blocks (also when there are no code blocks).
        auto stopBB = llvm::BasicBlock::Create(m_mainFunc->getContext(), "Stop", m_mainFunc);
        m_jumpTableBB = llvm::BasicBlock::Create(m_mainFunc->getContext(), "JumpTable", m_mainFunc);
        auto abortBB = llvm::BasicBlock::Create(m_mainFunc->getContext(), "Abort", m_mainFunc);

        m_builder.SetInsertPoint(m_jumpTableBB); // Must be before basic blocks compilation
        auto target = m_builder.CreatePHI(Type::Word, 16, "target");
        m_builder.CreateSwitch(target, abortBB);

        m_builder.SetInsertPoint(entryBB);


        // Init runtime structures.
        RuntimeManager runtimeManager(m_builder, _begin, _end);
        GasMeter gasMeter(m_builder, runtimeManager, m_mode);
        Memory memory(runtimeManager, gasMeter);
        Ext ext(runtimeManager, memory);
        Arith256 arith(m_builder);

        auto jmpBufWords = m_builder.CreateAlloca(Type::BytePtr, m_builder.getInt64(3), "jmpBuf.words");
        auto frameaddress = llvm::Intrinsic::getDeclaration(module.get(), llvm::Intrinsic::frameaddress);
        auto fp = m_builder.CreateCall(frameaddress, m_builder.getInt32(0), "fp");
        m_builder.CreateStore(fp, jmpBufWords);
        auto stacksave = llvm::Intrinsic::getDeclaration(module.get(), llvm::Intrinsic::stacksave);
        auto sp = m_builder.CreateCall(stacksave, {}, "sp");
        auto jmpBufSp = m_builder.CreateConstInBoundsGEP1_64(jmpBufWords, 2, "jmpBuf.sp");
        m_builder.CreateStore(sp, jmpBufSp);
        auto setjmp = llvm::Intrinsic::getDeclaration(module.get(), llvm::Intrinsic::eh_sjlj_setjmp);
        auto jmpBuf = m_builder.CreateBitCast(jmpBufWords, Type::BytePtr, "jmpBuf");
        auto r = m_builder.CreateCall(setjmp, jmpBuf);
        auto normalFlow = m_builder.CreateICmpEQ(r, m_builder.getInt32(0));
        runtimeManager.setJmpBuf(jmpBuf);
        m_builder.CreateCondBr(normalFlow, entryBB->getNextNode(), abortBB, Type::expectTrue);

        for (auto& block: blocks)
                compileBasicBlock(block, runtimeManager, arith, memory, ext, gasMeter);

        // Code for special blocks:
        m_builder.SetInsertPoint(stopBB);
        runtimeManager.exit(ReturnCode::Stop);

        m_builder.SetInsertPoint(abortBB);
        runtimeManager.exit(ReturnCode::OutOfGas);

        resolveJumps();

        return module;
}


void Compiler::compileBasicBlock(BasicBlock& _basicBlock, RuntimeManager& _runtimeManager,
                                                                 Arith256& _arith, Memory& _memory, Ext& _ext, GasMeter& _gasMeter)
{
        m_builder.SetInsertPoint(_basicBlock.llvm());
        LocalStack stack{m_builder, _runtimeManager};

        for (auto it = _basicBlock.begin(); it != _basicBlock.end(); ++it)
        {
                auto inst = Instruction(*it);

                _gasMeter.count(inst);

                switch (inst)
                {

                case Instruction::ADD:
                {
                        auto lhs = stack.pop();
                        auto rhs = stack.pop();
                        auto result = m_builder.CreateAdd(lhs, rhs);
                        stack.push(result);
                        break;
                }

                case Instruction::SUB:
                {
                        auto lhs = stack.pop();
                        auto rhs = stack.pop();
                        auto result = m_builder.CreateSub(lhs, rhs);
                        stack.push(result);
                        break;
                }

                case Instruction::MUL:
                {
                        auto lhs = stack.pop();
                        auto rhs = stack.pop();
                        auto res = m_builder.CreateMul(lhs, rhs);
                        stack.push(res);
                        break;
                }

                case Instruction::DIV:
                {
                        auto d = stack.pop();
                        auto n = stack.pop();
                        auto divByZero = m_builder.CreateICmpEQ(n, Constant::get(0));
                        n = m_builder.CreateSelect(divByZero, Constant::get(1), n); // protect against hardware signal
                        auto r = m_builder.CreateUDiv(d, n);
                        r = m_builder.CreateSelect(divByZero, Constant::get(0), r);
                        stack.push(r);
                        break;
                }

                case Instruction::SDIV:
                {
                        auto d = stack.pop();
                        auto n = stack.pop();
                        auto divByZero = m_builder.CreateICmpEQ(n, Constant::get(0));
                        auto divByMinusOne = m_builder.CreateICmpEQ(n, Constant::get(-1));
                        n = m_builder.CreateSelect(divByZero, Constant::get(1), n); // protect against hardware signal
                        auto r = m_builder.CreateSDiv(d, n);
                        r = m_builder.CreateSelect(divByZero, Constant::get(0), r);
                        auto dNeg = m_builder.CreateSub(Constant::get(0), d);
                        r = m_builder.CreateSelect(divByMinusOne, dNeg, r); // protect against undef i256.min / -1
                        stack.push(r);
                        break;
                }

                case Instruction::MOD:
                {
                        auto d = stack.pop();
                        auto n = stack.pop();
                        auto divByZero = m_builder.CreateICmpEQ(n, Constant::get(0));
                        n = m_builder.CreateSelect(divByZero, Constant::get(1), n); // protect against hardware signal
                        auto r = m_builder.CreateURem(d, n);
                        r = m_builder.CreateSelect(divByZero, Constant::get(0), r);
                        stack.push(r);
                        break;
                }

                case Instruction::SMOD:
                {
                        auto d = stack.pop();
                        auto n = stack.pop();
                        auto divByZero = m_builder.CreateICmpEQ(n, Constant::get(0));
                        auto divByMinusOne = m_builder.CreateICmpEQ(n, Constant::get(-1));
                        n = m_builder.CreateSelect(divByZero, Constant::get(1), n); // protect against hardware signal
                        auto r = m_builder.CreateSRem(d, n);
                        r = m_builder.CreateSelect(divByZero, Constant::get(0), r);
                        r = m_builder.CreateSelect(divByMinusOne, Constant::get(0), r); // protect against undef i256.min / -1
                        stack.push(r);
                        break;
                }

                case Instruction::ADDMOD:
                {
                        auto i512Ty = m_builder.getIntNTy(512);
                        auto a = stack.pop();
                        auto b = stack.pop();
                        auto m = stack.pop();
                        auto divByZero = m_builder.CreateICmpEQ(m, Constant::get(0));
                        a = m_builder.CreateZExt(a, i512Ty);
                        b = m_builder.CreateZExt(b, i512Ty);
                        m = m_builder.CreateZExt(m, i512Ty);
                        auto s = m_builder.CreateNUWAdd(a, b);
                        s = m_builder.CreateURem(s, m);
                        s = m_builder.CreateTrunc(s, Type::Word);
                        s = m_builder.CreateSelect(divByZero, Constant::get(0), s);
                        stack.push(s);
                        break;
                }

                case Instruction::MULMOD:
                {
                        auto i512Ty = m_builder.getIntNTy(512);
                        auto a = stack.pop();
                        auto b = stack.pop();
                        auto m = stack.pop();
                        auto divByZero = m_builder.CreateICmpEQ(m, Constant::get(0));
                        a = m_builder.CreateZExt(a, i512Ty);
                        b = m_builder.CreateZExt(b, i512Ty);
                        m = m_builder.CreateZExt(m, i512Ty);
                        auto p = m_builder.CreateNUWMul(a, b);
                        p = m_builder.CreateURem(p, m);
                        p = m_builder.CreateTrunc(p, Type::Word);
                        p = m_builder.CreateSelect(divByZero, Constant::get(0), p);
                        stack.push(p);
                        break;
                }

                case Instruction::EXP:
                {
                        auto base = stack.pop();
                        auto exponent = stack.pop();
                        _gasMeter.countExp(exponent);
                        auto ret = _arith.exp(base, exponent);
                        stack.push(ret);
                        break;
                }

                case Instruction::NOT:
                {
                        auto value = stack.pop();
                        auto ret = m_builder.CreateXor(value, Constant::get(-1), "bnot");
                        stack.push(ret);
                        break;
                }

                case Instruction::LT:
                {
                        auto lhs = stack.pop();
                        auto rhs = stack.pop();
                        auto res1 = m_builder.CreateICmpULT(lhs, rhs);
                        auto res256 = m_builder.CreateZExt(res1, Type::Word);
                        stack.push(res256);
                        break;
                }

                case Instruction::GT:
                {
                        auto lhs = stack.pop();
                        auto rhs = stack.pop();
                        auto res1 = m_builder.CreateICmpUGT(lhs, rhs);
                        auto res256 = m_builder.CreateZExt(res1, Type::Word);
                        stack.push(res256);
                        break;
                }

                case Instruction::SLT:
                {
                        auto lhs = stack.pop();
                        auto rhs = stack.pop();
                        auto res1 = m_builder.CreateICmpSLT(lhs, rhs);
                        auto res256 = m_builder.CreateZExt(res1, Type::Word);
                        stack.push(res256);
                        break;
                }

                case Instruction::SGT:
                {
                        auto lhs = stack.pop();
                        auto rhs = stack.pop();
                        auto res1 = m_builder.CreateICmpSGT(lhs, rhs);
                        auto res256 = m_builder.CreateZExt(res1, Type::Word);
                        stack.push(res256);
                        break;
                }

                case Instruction::EQ:
                {
                        auto lhs = stack.pop();
                        auto rhs = stack.pop();
                        auto res1 = m_builder.CreateICmpEQ(lhs, rhs);
                        auto res256 = m_builder.CreateZExt(res1, Type::Word);
                        stack.push(res256);
                        break;
                }

                case Instruction::ISZERO:
                {
                        auto top = stack.pop();
                        auto iszero = m_builder.CreateICmpEQ(top, Constant::get(0), "iszero");
                        auto result = m_builder.CreateZExt(iszero, Type::Word);
                        stack.push(result);
                        break;
                }

                case Instruction::AND:
                {
                        auto lhs = stack.pop();
                        auto rhs = stack.pop();
                        auto res = m_builder.CreateAnd(lhs, rhs);
                        stack.push(res);
                        break;
                }

                case Instruction::OR:
                {
                        auto lhs = stack.pop();
                        auto rhs = stack.pop();
                        auto res = m_builder.CreateOr(lhs, rhs);
                        stack.push(res);
                        break;
                }

                case Instruction::XOR:
                {
                        auto lhs = stack.pop();
                        auto rhs = stack.pop();
                        auto res = m_builder.CreateXor(lhs, rhs);
                        stack.push(res);
                        break;
                }

                case Instruction::BYTE:
                {
                        const auto idx = stack.pop();
                        auto value = Endianness::toBE(m_builder, stack.pop());

                        auto idxValid = m_builder.CreateICmpULT(idx, Constant::get(32), "idxValid");
                        auto bytes = m_builder.CreateBitCast(value, llvm::VectorType::get(Type::Byte, 32), "bytes");
                        // TODO: Workaround for LLVM bug. Using big value of index causes invalid memory access.
                        auto safeIdx = m_builder.CreateTrunc(idx, m_builder.getIntNTy(5));
                        // TODO: Workaround for LLVM bug. DAG Builder used sext on index instead of zext
                        safeIdx = m_builder.CreateZExt(safeIdx, Type::Size);
                        auto byte = m_builder.CreateExtractElement(bytes, safeIdx, "byte");
                        value = m_builder.CreateZExt(byte, Type::Word);
                        value = m_builder.CreateSelect(idxValid, value, Constant::get(0));
                        stack.push(value);
                        break;
                }

                case Instruction::SIGNEXTEND:
                {
                        auto idx = stack.pop();
                        auto word = stack.pop();

                        auto k32_ = m_builder.CreateTrunc(idx, m_builder.getIntNTy(5), "k_32");
                        auto k32 = m_builder.CreateZExt(k32_, Type::Size);
                        auto k32x8 = m_builder.CreateMul(k32, m_builder.getInt64(8), "kx8");

                        // test for word >> (k * 8 + 7)
                        auto bitpos = m_builder.CreateAdd(k32x8, m_builder.getInt64(7), "bitpos");
                        auto bitposEx = m_builder.CreateZExt(bitpos, Type::Word);
                        auto bitval = m_builder.CreateLShr(word, bitposEx, "bitval");
                        auto bittest = m_builder.CreateTrunc(bitval, Type::Bool, "bittest");

                        auto mask_ = m_builder.CreateShl(Constant::get(1), bitposEx);
                        auto mask = m_builder.CreateSub(mask_, Constant::get(1), "mask");

                        auto negmask = m_builder.CreateXor(mask, llvm::ConstantInt::getAllOnesValue(Type::Word), "negmask");
                        auto val1 = m_builder.CreateOr(word, negmask);
                        auto val0 = m_builder.CreateAnd(word, mask);

                        auto kInRange = m_builder.CreateICmpULE(idx, llvm::ConstantInt::get(Type::Word, 30));
                        auto result = m_builder.CreateSelect(kInRange,
                                                                                                 m_builder.CreateSelect(bittest, val1, val0),
                                                                                                 word);
                        stack.push(result);
                        break;
                }

                case Instruction::SHA3:
                {
                        auto inOff = stack.pop();
                        auto inSize = stack.pop();
                        _memory.require(inOff, inSize);
                        _gasMeter.countSha3Data(inSize);
                        auto hash = _ext.sha3(inOff, inSize);
                        stack.push(hash);
                        break;
                }

                case Instruction::POP:
                {
                        stack.pop();
                        break;
                }

                case Instruction::ANY_PUSH:
                {
                        auto value = readPushData(it, _basicBlock.end());
                        stack.push(Constant::get(value));
                        break;
                }

                case Instruction::ANY_DUP:
                {
                        auto index = static_cast<size_t>(inst) - static_cast<size_t>(Instruction::DUP1);
                        stack.dup(index);
                        break;
                }

                case Instruction::ANY_SWAP:
                {
                        auto index = static_cast<size_t>(inst) - static_cast<size_t>(Instruction::SWAP1) + 1;
                        stack.swap(index);
                        break;
                }

                case Instruction::MLOAD:
                {
                        auto addr = stack.pop();
                        auto word = _memory.loadWord(addr);
                        stack.push(word);
                        break;
                }

                case Instruction::MSTORE:
                {
                        auto addr = stack.pop();
                        auto word = stack.pop();
                        _memory.storeWord(addr, word);
                        break;
                }

                case Instruction::MSTORE8:
                {
                        auto addr = stack.pop();
                        auto word = stack.pop();
                        _memory.storeByte(addr, word);
                        break;
                }

                case Instruction::MSIZE:
                {
                        auto word = _memory.getSize();
                        stack.push(word);
                        break;
                }

                case Instruction::SLOAD:
                {
                        auto index = stack.pop();
                        auto value = _ext.sload(index);
                        stack.push(value);
                        break;
                }

                case Instruction::SSTORE:
                {
                        auto index = stack.pop();
                        auto value = stack.pop();
                        _gasMeter.countSStore(_ext, index, value);
                        _ext.sstore(index, value);
                        break;
                }

                case Instruction::JUMP:
                case Instruction::JUMPI:
                {
                        auto destIdx = llvm::MDNode::get(m_builder.getContext(), llvm::ValueAsMetadata::get(stack.pop()));

                        // Create branch instruction, initially to jump table.
                        // Destination will be optimized with direct jump during jump resolving if destination index is a constant.
                        auto jumpInst = (inst == Instruction::JUMP) ?
                                        m_builder.CreateBr(m_jumpTableBB) :
                                        m_builder.CreateCondBr(m_builder.CreateICmpNE(stack.pop(), Constant::get(0), "jump.check"), m_jumpTableBB, nullptr);

                        // Attach medatada to branch instruction with information about destination index.
                        jumpInst->setMetadata(c_destIdxLabel, destIdx);
                        break;
                }

                case Instruction::JUMPDEST:
                {
                        // Add the basic block to the jump table.
                        assert(it == _basicBlock.begin() && "JUMPDEST must be the first instruction of a basic block");
                        auto jumpTable = llvm::cast<llvm::SwitchInst>(m_jumpTableBB->getTerminator());
                        jumpTable->addCase(Constant::get(_basicBlock.firstInstrIdx()), _basicBlock.llvm());
                        break;
                }

                case Instruction::PC:
                {
                        auto value = Constant::get(it - _basicBlock.begin() + _basicBlock.firstInstrIdx());
                        stack.push(value);
                        break;
                }

                case Instruction::GAS:
                {
                        _gasMeter.commitCostBlock();
                        stack.push(m_builder.CreateZExt(_runtimeManager.getGas(), Type::Word));
                        break;
                }

                case Instruction::ADDRESS:
                        stack.push(_ext.query(EVM_ADDRESS));
                        break;
                case Instruction::CALLER:
                        stack.push(_ext.query(EVM_CALLER));
                        break;
                case Instruction::ORIGIN:
                        stack.push(_ext.query(EVM_ORIGIN));
                        break;
                case Instruction::COINBASE:
                        stack.push(_ext.query(EVM_COINBASE));
                        break;

                case Instruction::GASPRICE:
                        stack.push(_ext.query(EVM_GAS_PRICE));
                        break;

                case Instruction::DIFFICULTY:
                        stack.push(_ext.query(EVM_DIFFICULTY));
                        break;

                case Instruction::GASLIMIT:
                        stack.push(_ext.query(EVM_GAS_LIMIT));
                        break;

                case Instruction::NUMBER:
                        stack.push(_ext.query(EVM_NUMBER));
                        break;

                case Instruction::TIMESTAMP:
                        stack.push(_ext.query(EVM_TIMESTAMP));
                        break;

                case Instruction::CALLVALUE:
                {
                        auto beValue = _runtimeManager.getValue();
                        stack.push(Endianness::toNative(m_builder, beValue));
                        break;
                }

                case Instruction::CODESIZE:
                        stack.push(_runtimeManager.getCodeSize());
                        break;

                case Instruction::CALLDATASIZE:
                        stack.push(_runtimeManager.getCallDataSize());
                        break;

                case Instruction::BLOCKHASH:
                {
                        auto number = stack.pop();
                        // If number bigger than int64 assume the result is 0.
                        auto limitC = m_builder.getInt64(std::numeric_limits<int64_t>::max());
                        auto limit = m_builder.CreateZExt(limitC, Type::Word);
                        auto isBigNumber = m_builder.CreateICmpUGT(number, limit);
                        auto hash = _ext.blockHash(number);
                        // TODO: Try to eliminate the call if the number is invalid.
                        hash = m_builder.CreateSelect(isBigNumber, Constant::get(0), hash);
                        stack.push(hash);
                        break;
                }

                case Instruction::BALANCE:
                {
                        auto address = stack.pop();
                        auto value = _ext.balance(address);
                        stack.push(value);
                        break;
                }

                case Instruction::EXTCODESIZE:
                {
                        auto addr = stack.pop();
                        auto codesize = _ext.extcodesize(addr);
                        stack.push(codesize);
                        break;
                }

                case Instruction::CALLDATACOPY:
                {
                        auto destMemIdx = stack.pop();
                        auto srcIdx = stack.pop();
                        auto reqBytes = stack.pop();

                        auto srcPtr = _runtimeManager.getCallData();
                        auto srcSize = _runtimeManager.getCallDataSize();

                        _memory.copyBytes(srcPtr, srcSize, srcIdx, destMemIdx, reqBytes);
                        break;
                }

                case Instruction::CODECOPY:
                {
                        auto destMemIdx = stack.pop();
                        auto srcIdx = stack.pop();
                        auto reqBytes = stack.pop();

                        auto srcPtr = _runtimeManager.getCode();    // TODO: Code & its size are constants, feature #80814234
                        auto srcSize = _runtimeManager.getCodeSize();

                        _memory.copyBytes(srcPtr, srcSize, srcIdx, destMemIdx, reqBytes);
                        break;
                }

                case Instruction::EXTCODECOPY:
                {
                        auto addr = stack.pop();
                        auto destMemIdx = stack.pop();
                        auto srcIdx = stack.pop();
                        auto reqBytes = stack.pop();

                        auto codeRef = _ext.extcode(addr);

                        _memory.copyBytes(codeRef.ptr, codeRef.size, srcIdx, destMemIdx, reqBytes);
                        break;
                }

                case Instruction::CALLDATALOAD:
                {
                        auto idx = stack.pop();
                        auto value = _ext.calldataload(idx);
                        stack.push(value);
                        break;
                }

                case Instruction::CREATE:
                {
                        auto endowment = stack.pop();
                        auto initOff = stack.pop();
                        auto initSize = stack.pop();
                        _memory.require(initOff, initSize);

                        _gasMeter.commitCostBlock();
                        auto gas = _runtimeManager.getGas();
                        llvm::Value* gasKept = (m_mode >= EVM_ANTI_DOS) ?
                                               m_builder.CreateLShr(gas, 6) :
                                               m_builder.getInt64(0);
                        auto createGas = m_builder.CreateSub(gas, gasKept, "create.gas", true, true);
                        llvm::Value* r = nullptr;
                        llvm::Value* pAddr = nullptr;
                        std::tie(r, pAddr) = _ext.create(createGas, endowment, initOff, initSize);

                        auto ret =
                                m_builder.CreateICmpSGE(r, m_builder.getInt64(0), "create.ret");
                        auto rmagic = m_builder.CreateSelect(
                                ret, m_builder.getInt64(0), m_builder.getInt64(EVM_CALL_FAILURE),
                                "call.rmagic");
                        // TODO: optimize
                        auto gasLeft = m_builder.CreateSub(r, rmagic, "create.gasleft");
                        gas = m_builder.CreateAdd(gasLeft, gasKept);
                        _runtimeManager.setGas(gas);

                        llvm::Value* addr = m_builder.CreateLoad(pAddr);
                        addr = Endianness::toNative(m_builder, addr);
                        addr = m_builder.CreateZExt(addr, Type::Word);
                        addr = m_builder.CreateSelect(ret, addr, Constant::get(0));
                        stack.push(addr);
                        break;
                }

                case Instruction::DELEGATECALL:
                        if (m_mode == EVM_FRONTIER)
                        {
                                // Invalid opcode in Frontier compatibility mode.
                                _runtimeManager.exit(ReturnCode::OutOfGas);
                                it = _basicBlock.end() - 1;  // finish block compilation
                                break;
                        }
                // else, fall-through
                case Instruction::CALL:
                case Instruction::CALLCODE:
                {
                        auto kind = (inst == Instruction::CALL) ?
                                                        EVM_CALL :
                                                        (inst == Instruction::CALLCODE) ? EVM_CALLCODE :
                                                                                                                          EVM_DELEGATECALL;
                        auto callGas = stack.pop();
                        auto address = stack.pop();
                        auto value = (kind == EVM_DELEGATECALL) ? Constant::get(0) : stack.pop();

                        auto inOff = stack.pop();
                        auto inSize = stack.pop();
                        auto outOff = stack.pop();
                        auto outSize = stack.pop();

                        _gasMeter.commitCostBlock();

                        // Require memory for in and out buffers
                        _memory.require(outOff, outSize);  // Out buffer first as we guess
                                                                                           // it will be after the in one
                        _memory.require(inOff, inSize);

                        auto noTransfer = m_builder.CreateICmpEQ(value, Constant::get(0));
                        auto transferCost = m_builder.CreateSelect(
                                        noTransfer, m_builder.getInt64(0),
                                        m_builder.getInt64(JITSchedule::valueTransferGas::value));
                        _gasMeter.count(transferCost, _runtimeManager.getJmpBuf(),
                                                        _runtimeManager.getGasPtr());

                        if (inst == Instruction::CALL)
                        {
                                auto accountExists = _ext.exists(address);
                                auto noPenaltyCond = accountExists;
                                if (m_mode >= EVM_CLEARING)
                                        noPenaltyCond = m_builder.CreateOr(accountExists, noTransfer);
                                auto penalty = m_builder.CreateSelect(noPenaltyCond,
                                                                      m_builder.getInt64(0),
                                                                      m_builder.getInt64(JITSchedule::callNewAccount::value));
                                _gasMeter.count(penalty, _runtimeManager.getJmpBuf(),
                                                _runtimeManager.getGasPtr());
                        }

                        if (m_mode >= EVM_ANTI_DOS)
                        {
                                auto gas = _runtimeManager.getGas();
                                auto gas64th = m_builder.CreateLShr(gas, 6);
                                auto gasMaxAllowed = m_builder.CreateZExt(
                                                m_builder.CreateSub(gas, gas64th, "gas.maxallowed",
                                                                    true, true), Type::Word);
                                auto cmp = m_builder.CreateICmpUGT(callGas, gasMaxAllowed);
                                callGas = m_builder.CreateSelect(cmp, gasMaxAllowed, callGas);
                        }

                        _gasMeter.count(callGas, _runtimeManager.getJmpBuf(),
                                                        _runtimeManager.getGasPtr());
                        auto stipend = m_builder.CreateSelect(
                                        noTransfer, m_builder.getInt64(0),
                                        m_builder.getInt64(JITSchedule::callStipend::value));
                        auto gas = m_builder.CreateTrunc(callGas, Type::Gas, "call.gas.declared");
                        gas = m_builder.CreateAdd(gas, stipend, "call.gas", true, true);
                        auto r = _ext.call(kind, gas, address, value, inOff, inSize, outOff,
                                                           outSize);
                        auto ret =
                                m_builder.CreateICmpSGE(r, m_builder.getInt64(0), "call.ret");
                        auto rmagic = m_builder.CreateSelect(
                                ret, m_builder.getInt64(0), m_builder.getInt64(EVM_CALL_FAILURE),
                                "call.rmagic");
                        // TODO: optimize
                        auto finalGas = m_builder.CreateSub(r, rmagic, "call.finalgas");
                        _gasMeter.giveBack(finalGas);
                        stack.push(m_builder.CreateZExt(ret, Type::Word));
                        break;
                }

                case Instruction::RETURN:
                {
                        auto index = stack.pop();
                        auto size = stack.pop();

                        _memory.require(index, size);
                        _runtimeManager.registerReturnData(index, size);

                        _runtimeManager.exit(ReturnCode::Return);
                        break;
                }

                case Instruction::SUICIDE:
                {
                        auto dest = stack.pop();
                        if (m_mode >= EVM_ANTI_DOS)
                        {
                                auto destExists = _ext.exists(dest);
                                auto noPenaltyCond = destExists;
                                if (m_mode >= EVM_CLEARING)
                                {
                                        auto addr = _ext.query(EVM_ADDRESS);
                                        auto balance = _ext.balance(addr);
                                        auto noTransfer = m_builder.CreateICmpEQ(balance,
                                                                                 Constant::get(0));
                                        noPenaltyCond = m_builder.CreateOr(destExists, noTransfer);
                                }
                                auto penalty = m_builder.CreateSelect(
                                                noPenaltyCond, m_builder.getInt64(0),
                                                m_builder.getInt64(JITSchedule::callNewAccount::value));
                                _gasMeter.count(penalty, _runtimeManager.getJmpBuf(),
                                                _runtimeManager.getGasPtr());
                        }
                        _ext.selfdestruct(dest);
                }
                        // Fallthrough.
                case Instruction::STOP:
                        _runtimeManager.exit(ReturnCode::Stop);
                        break;

                case Instruction::LOG0:
                case Instruction::LOG1:
                case Instruction::LOG2:
                case Instruction::LOG3:
                case Instruction::LOG4:
                {
                        auto beginIdx = stack.pop();
                        auto numBytes = stack.pop();
                        _memory.require(beginIdx, numBytes);

                        // This will commit the current cost block
                        _gasMeter.countLogData(numBytes);

                        llvm::SmallVector<llvm::Value*, 4> topics;
                        auto numTopics = static_cast<size_t>(inst) - static_cast<size_t>(Instruction::LOG0);
                        for (size_t i = 0; i < numTopics; ++i)
                                topics.emplace_back(stack.pop());

                        _ext.log(beginIdx, numBytes, topics);
                        break;
                }

                default: // Invalid instruction - abort
                        _runtimeManager.exit(ReturnCode::OutOfGas);
                        it = _basicBlock.end() - 1; // finish block compilation
                }
        }

        _gasMeter.commitCostBlock();

        stack.finalize();
}


}
}
}