Port to LLVM 3.7

libevmjit/Array.cpp

@@ -47,9 +47,9 @@ llvm::Function* Array::createArrayPushFunc()
 	auto pushBB = llvm::BasicBlock::Create(m_builder.getContext(), "Push", func);
 
 	m_builder.SetInsertPoint(entryBB);
-	auto dataPtr = m_builder.CreateStructGEP(arrayPtr, 0, "dataPtr");
-	auto sizePtr = m_builder.CreateStructGEP(arrayPtr, 1, "sizePtr");
-	auto capPtr = m_builder.CreateStructGEP(arrayPtr, 2, "capPtr");
+	auto dataPtr = m_builder.CreateStructGEP(getType(), arrayPtr, 0, "dataPtr");
+	auto sizePtr = m_builder.CreateStructGEP(getType(), arrayPtr, 1, "sizePtr");
+	auto capPtr = m_builder.CreateStructGEP(getType(), arrayPtr, 2, "capPtr");
 	auto data = m_builder.CreateLoad(dataPtr, "data");
 	auto size = m_builder.CreateLoad(sizePtr, "size");
 	auto cap = m_builder.CreateLoad(capPtr, "cap");
@@ -96,7 +96,7 @@ llvm::Function* Array::createArraySetFunc()
 
 	InsertPointGuard guard{m_builder};
 	m_builder.SetInsertPoint(llvm::BasicBlock::Create(m_builder.getContext(), {}, func));
-	auto dataPtr = m_builder.CreateStructGEP(arrayPtr, 0, "dataPtr");
+	auto dataPtr = m_builder.CreateStructGEP(getType(), arrayPtr, 0, "dataPtr");
 	auto data = m_builder.CreateLoad(dataPtr, "data");
 	auto valuePtr = m_builder.CreateGEP(data, index, "valuePtr");
 	m_builder.CreateStore(value, valuePtr);
@@ -118,7 +118,7 @@ llvm::Function* Array::createArrayGetFunc()
 
 	InsertPointGuard guard{m_builder};
 	m_builder.SetInsertPoint(llvm::BasicBlock::Create(m_builder.getContext(), {}, func));
-	auto dataPtr = m_builder.CreateStructGEP(arrayPtr, 0, "dataPtr");
+	auto dataPtr = m_builder.CreateStructGEP(getType(), arrayPtr, 0, "dataPtr");
 	auto data = m_builder.CreateLoad(dataPtr, "data");
 	auto valuePtr = m_builder.CreateGEP(data, index, "valuePtr");
 	auto value = m_builder.CreateLoad(valuePtr, "value");
@@ -163,7 +163,7 @@ llvm::Function* Array::createFreeFunc()
 
 	InsertPointGuard guard{m_builder};
 	m_builder.SetInsertPoint(llvm::BasicBlock::Create(m_builder.getContext(), {}, func));
-	auto dataPtr = m_builder.CreateStructGEP(arrayPtr, 0, "dataPtr");
+	auto dataPtr = m_builder.CreateStructGEP(getType(), arrayPtr, 0, "dataPtr");
 	auto data = m_builder.CreateLoad(dataPtr, "data");
 	auto mem = m_builder.CreateBitCast(data, Type::BytePtr, "mem");
 	m_builder.CreateCall(freeFunc, mem);
@@ -199,8 +199,8 @@ llvm::Function* Array::createExtendFunc()
 	InsertPointGuard guard{m_builder};
 	m_builder.SetInsertPoint(llvm::BasicBlock::Create(m_builder.getContext(), {}, func));
 	auto dataPtr = m_builder.CreateBitCast(arrayPtr, Type::BytePtr->getPointerTo(), "dataPtr");// TODO: Use byte* in Array
-	auto sizePtr = m_builder.CreateStructGEP(arrayPtr, 1, "sizePtr");
-	auto capPtr = m_builder.CreateStructGEP(arrayPtr, 2, "capPtr");
+	auto sizePtr = m_builder.CreateStructGEP(getType(), arrayPtr, 1, "sizePtr");
+	auto capPtr = m_builder.CreateStructGEP(getType(), arrayPtr, 2, "capPtr");
 	auto data = m_builder.CreateLoad(dataPtr, "data");
 	auto size = m_builder.CreateLoad(sizePtr, "size");
 	auto extSize = m_builder.CreateNUWSub(newSize, size, "extSize");
@@ -246,7 +246,7 @@ Array::Array(llvm::IRBuilder<>& _builder, llvm::Value* _array) :
 
 void Array::pop(llvm::Value* _count)
 {
-	auto sizePtr = m_builder.CreateStructGEP(m_array, 1, "sizePtr");
+	auto sizePtr = m_builder.CreateStructGEP(getType(), m_array, 1, "sizePtr");
 	auto size = m_builder.CreateLoad(sizePtr, "size");
 	auto newSize = m_builder.CreateNUWSub(size, _count, "newSize");
 	m_builder.CreateStore(newSize, sizePtr);
@@ -254,7 +254,7 @@ void Array::pop(llvm::Value* _count)
 
 llvm::Value* Array::size(llvm::Value* _array)
 {
-	auto sizePtr = m_builder.CreateStructGEP(_array ? _array : m_array, 1, "sizePtr");
+	auto sizePtr = m_builder.CreateStructGEP(getType(), _array ? _array : m_array, 1, "sizePtr");
 	return m_builder.CreateLoad(sizePtr, "array.size");
 }
 

libevmjit/Cache.cpp

@@ -24,7 +24,7 @@ namespace jit
 namespace
 {
 	CacheMode g_mode;
-	llvm::MemoryBuffer* g_lastObject;
+	std::unique_ptr<llvm::MemoryBuffer> g_lastObject;
 	ExecutionEngineListener* g_listener;
 	static const size_t c_versionStampLength = 32;
 
@@ -79,8 +79,7 @@ void Cache::preload(llvm::ExecutionEngine& _ee, std::unordered_map<std::string,
 		if (auto module = getObject(name))
 		{
 			DLOG(cache) << "Preload: " << name << "\n";
-			_ee.addModule(module.get());
-			module.release();
+			_ee.addModule(std::move(module));
 			auto addr = _ee.getFunctionAddress(name);
 			assert(addr);
 			_funcCache[std::move(name)] = addr;
@@ -134,7 +133,7 @@ std::unique_ptr<llvm::Module> Cache::getObject(std::string const& id)
 }
 
 
-void ObjectCache::notifyObjectCompiled(llvm::Module const* _module, llvm::MemoryBuffer const* _object)
+void ObjectCache::notifyObjectCompiled(llvm::Module const* _module, llvm::MemoryBufferRef _object)
 {
 	// Only in "on" and "write" mode
 	if (g_mode != CacheMode::on && g_mode != CacheMode::write)
@@ -154,17 +153,15 @@ void ObjectCache::notifyObjectCompiled(llvm::Module const* _module, llvm::Memory
 	llvm::sys::path::append(cachePath, id);
 
 	DLOG(cache) << id << ": write\n";
-	std::string error;
+	std::error_code error;
 	llvm::raw_fd_ostream cacheFile(cachePath.c_str(), error, llvm::sys::fs::F_None);
-	cacheFile << _object->getBuffer() << getLibVersionStamp();
+	cacheFile << _object.getBuffer() << getLibVersionStamp();
 }
 
-llvm::MemoryBuffer* ObjectCache::getObject(llvm::Module const* _module)
+std::unique_ptr<llvm::MemoryBuffer> ObjectCache::getObject(llvm::Module const* _module)
 {
 	DLOG(cache) << _module->getModuleIdentifier() << ": use\n";
-	auto o = g_lastObject;
-	g_lastObject = nullptr;
-	return o;
+	return std::move(g_lastObject);
 }
 
 }

libevmjit/Cache.h

@@ -32,13 +32,13 @@ class ObjectCache : public llvm::ObjectCache
 {
 public:
 	/// notifyObjectCompiled - Provides a pointer to compiled code for Module M.
-	virtual void notifyObjectCompiled(llvm::Module const* _module, llvm::MemoryBuffer const* _object) final override;
+	virtual void notifyObjectCompiled(llvm::Module const* _module, llvm::MemoryBufferRef _object) final override;
 
 	/// getObjectCopy - Returns a pointer to a newly allocated MemoryBuffer that
 	/// contains the object which corresponds with Module M, or 0 if an object is
 	/// not available. The caller owns both the MemoryBuffer returned by this
 	/// and the memory it references.
-	virtual llvm::MemoryBuffer* getObject(llvm::Module const* _module) final override;
+	virtual std::unique_ptr<llvm::MemoryBuffer> getObject(llvm::Module const* _module) final override;
 };
 
 

libevmjit/ExecutionEngine.cpp

@@ -131,20 +131,20 @@ ReturnCode ExecutionEngine::run(RuntimeData* _data, Env* _env)
 		llvm::InitializeNativeTargetAsmPrinter();
 
 		auto module = std::unique_ptr<llvm::Module>(new llvm::Module({}, llvm::getGlobalContext()));
-		llvm::EngineBuilder builder(module.get());
-		builder.setEngineKind(llvm::EngineKind::JIT);
-		builder.setUseMCJIT(true);
-		builder.setOptLevel(g_optimize ? llvm::CodeGenOpt::Default : llvm::CodeGenOpt::None);
 
+		// FIXME: LLVM 3.7: test on Windows
 		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());
 
+		llvm::EngineBuilder builder(std::move(module));
+		builder.setEngineKind(llvm::EngineKind::JIT);
+		builder.setOptLevel(g_optimize ? llvm::CodeGenOpt::Default : llvm::CodeGenOpt::None);
+
 		ee.reset(builder.create());
 		if (!CHECK(ee))
 			return ReturnCode::LLVMConfigError;
-		module.release();  // Successfully created llvm::ExecutionEngine takes ownership of the module
 		ee->setObjectCache(objectCache);
 
 		if (preloadCache)
@@ -179,8 +179,7 @@ ReturnCode ExecutionEngine::run(RuntimeData* _data, Env* _env)
 		if (g_dump)
 			module->dump();
 
-		ee->addModule(module.get());
-		module.release();
+		ee->addModule(std::move(module));
 		listener->stateChanged(ExecState::CodeGen);
 		entryFuncPtr = (EntryFuncPtr)ee->getFunctionAddress(mainFuncName);
 	}

libevmjit/Optimizer.cpp

@@ -1,7 +1,7 @@
 #include "Optimizer.h"
 
 #include "preprocessor/llvm_includes_start.h"
-#include <llvm/PassManager.h>
+#include <llvm/IR/LegacyPassManager.h>
 #include <llvm/Transforms/Scalar.h>
 #include <llvm/Transforms/IPO.h>
 #include "preprocessor/llvm_includes_end.h"
@@ -15,7 +15,7 @@ namespace jit
 
 bool optimize(llvm::Module& _module)
 {
-	auto pm = llvm::PassManager{};
+	auto pm = llvm::legacy::PassManager{};
 	//pm.add(llvm::createFunctionInliningPass(2, 2)); // Produces invalid IR
 	pm.add(llvm::createCFGSimplificationPass());
 	//pm.add(llvm::createInstructionCombiningPass()); // Produces invalid runtime results

libevmjit/RuntimeManager.cpp

@@ -93,13 +93,13 @@ RuntimeManager::RuntimeManager(llvm::IRBuilder<>& _builder, code_iterator _codeB
 
 	// Unpack data
 	auto rtPtr = getRuntimePtr();
-	m_dataPtr = m_builder.CreateLoad(m_builder.CreateStructGEP(rtPtr, 0), "data");
+	m_dataPtr = m_builder.CreateLoad(m_builder.CreateStructGEP(getRuntimeType(), rtPtr, 0), "data");
 	assert(m_dataPtr->getType() == Type::RuntimeDataPtr);
-	m_gasPtr = m_builder.CreateStructGEP(m_dataPtr, 0, "gas");
+	m_gasPtr = m_builder.CreateStructGEP(getRuntimeDataType(), m_dataPtr, 0, "gas");
 	assert(m_gasPtr->getType() == Type::Gas->getPointerTo());
-	m_memPtr = m_builder.CreateStructGEP(rtPtr, 2, "mem");
+	m_memPtr = m_builder.CreateStructGEP(getRuntimeType(), rtPtr, 2, "mem");
 	assert(m_memPtr->getType() == Array::getType()->getPointerTo());
-	m_envPtr = m_builder.CreateLoad(m_builder.CreateStructGEP(rtPtr, 1), "env");
+	m_envPtr = m_builder.CreateLoad(m_builder.CreateStructGEP(getRuntimeType(), rtPtr, 1), "env");
 	assert(m_envPtr->getType() == Type::EnvPtr);
 
 	m_stackSize = m_builder.CreateAlloca(Type::Size, nullptr, "stackSize");
@@ -160,7 +160,7 @@ llvm::Value* RuntimeManager::getDataPtr()
 		return m_dataPtr;
 
 	auto rtPtr = getRuntimePtr();
-	auto dataPtr = m_builder.CreateLoad(m_builder.CreateStructGEP(rtPtr, 0), "data");
+	auto dataPtr = m_builder.CreateLoad(m_builder.CreateStructGEP(getRuntimeType(), rtPtr, 0), "data");
 	assert(dataPtr->getType() == getRuntimeDataType()->getPointerTo());
 	return dataPtr;
 }
@@ -173,7 +173,7 @@ llvm::Value* RuntimeManager::getEnvPtr()
 
 llvm::Value* RuntimeManager::getPtr(RuntimeData::Index _index)
 {
-	auto ptr = getBuilder().CreateStructGEP(getDataPtr(), _index);
+	auto ptr = getBuilder().CreateStructGEP(getRuntimeDataType(), getDataPtr(), _index);
 	assert(getRuntimeDataType()->getElementType(_index)->getPointerTo() == ptr->getType());
 	return ptr;
 }

libevmjit/Type.h

@@ -2,8 +2,9 @@
 
 #include "preprocessor/llvm_includes_start.h"
 #include <llvm/IR/Type.h>
-#include <llvm/IR/Constants.h>
-#include "preprocessor/llvm_includes_end.h"
+#include <llvm/IR/Constants.h>
+#include <llvm/IR/Metadata.h>
+#include "preprocessor/llvm_includes_end.h" // FIXME: LLVM 3.7: check if needed
 
 #include "Common.h"