#include "ExecutionEngine.h" #include #include // env options #include #include "preprocessor/llvm_includes_start.h" #include #include #include #include #include #include #include #include "preprocessor/llvm_includes_end.h" #include "Runtime.h" #include "Compiler.h" #include "Cache.h" #include "ExecStats.h" #include "Utils.h" #include "BuildInfo.gen.h" namespace dev { namespace eth { namespace jit { namespace { using EntryFuncPtr = ReturnCode(*)(Runtime*); std::string codeHash(i256 const& _hash) { static const auto size = sizeof(_hash); static const auto hexChars = "0123456789abcdef"; std::string str; str.resize(size * 2); auto outIt = str.rbegin(); // reverse for BE auto& arr = *(std::array*)&_hash; for (auto b : arr) { *(outIt++) = hexChars[b & 0xf]; *(outIt++) = hexChars[b >> 4]; } return str; } bool getEnvOption(char const* _name, bool _default) { auto var = std::getenv(_name); if (!var) return _default; return std::strtol(var, nullptr, 10) != 0; } bool showInfo() { auto show = getEnvOption("EVMJIT_INFO", false); if (show) { std::cout << "The Ethereum EVM JIT " EVMJIT_VERSION_FULL " LLVM " LLVM_VERSION << std::endl; } return show; } } ReturnCode ExecutionEngine::run(RuntimeData* _data, Env* _env) { static auto debugDumpModule = getEnvOption("EVMJIT_DUMP", false); static auto objectCacheEnabled = getEnvOption("EVMJIT_CACHE", true); static auto statsCollectingEnabled = getEnvOption("EVMJIT_STATS", false); static auto infoShown = showInfo(); (void) infoShown; std::unique_ptr listener{new ExecStats}; listener->stateChanged(ExecState::Started); auto objectCache = objectCacheEnabled ? Cache::getObjectCache(listener.get()) : nullptr; static std::unique_ptr ee; if (!ee) { llvm::InitializeNativeTarget(); llvm::InitializeNativeTargetAsmPrinter(); auto module = std::unique_ptr(new llvm::Module({}, llvm::getGlobalContext())); llvm::EngineBuilder builder(module.get()); builder.setEngineKind(llvm::EngineKind::JIT); builder.setUseMCJIT(true); builder.setOptLevel(llvm::CodeGenOpt::None); auto triple = llvm::Triple(llvm::sys::getProcessTriple()); if (triple.getOS() == llvm::Triple::OSType::Win32) triple.setObjectFormat(llvm::Triple::ObjectFormatType::ELF); // MCJIT does not support COFF format module->setTargetTriple(triple.str()); ee.reset(builder.create()); if (!CHECK(ee)) return ReturnCode::LLVMConfigError; module.release(); // Successfully created llvm::ExecutionEngine takes ownership of the module ee->setObjectCache(objectCache); } static StatsCollector statsCollector; auto mainFuncName = codeHash(_data->codeHash); Runtime runtime(_data, _env); // TODO: I don't know why but it must be created before getFunctionAddress() calls auto entryFuncPtr = (EntryFuncPtr)ee->getFunctionAddress(mainFuncName); if (!entryFuncPtr) { auto module = objectCache ? Cache::getObject(mainFuncName) : nullptr; if (!module) { listener->stateChanged(ExecState::Compilation); assert(_data->code || !_data->codeSize); //TODO: Is it good idea to execute empty code? module = Compiler({}).compile(_data->code, _data->code + _data->codeSize, mainFuncName); } if (debugDumpModule) module->dump(); ee->addModule(module.get()); module.release(); listener->stateChanged(ExecState::CodeGen); entryFuncPtr = (EntryFuncPtr)ee->getFunctionAddress(mainFuncName); } if (!CHECK(entryFuncPtr)) return ReturnCode::LLVMLinkError; listener->stateChanged(ExecState::Execution); auto returnCode = entryFuncPtr(&runtime); listener->stateChanged(ExecState::Return); if (returnCode == ReturnCode::Return) { returnData = runtime.getReturnData(); // Save reference to return data std::swap(m_memory, runtime.getMemory()); // Take ownership of memory } listener->stateChanged(ExecState::Finished); if (statsCollectingEnabled) statsCollector.stats.push_back(std::move(listener)); return returnCode; } } } }