This is an archive of the discontinued LLVM Phabricator instance.

examples/clang-interpreter/main.cpp
52	Seems cleaner to me to have these explicit, and avoids potentiel code churn if there are changes above. Is there something in the llvm coding style that recommends skipping these?

Review comments from @alexshap.

Looks good to me. :)

This revision is now accepted and ready to land.May 23 2018, 4:24 PM

Herald added a subscriber: mgrang. · View Herald TranscriptMay 23 2018, 4:24 PM

Closed by commit rL333302: Convert clang-interpreter to ORC JIT API (authored by sas). · Explain WhyMay 25 2018, 1:27 PM

This revision was automatically updated to reflect the committed changes.

Herald added a subscriber: llvm-commits. · View Herald TranscriptMay 25 2018, 1:27 PM

Revision Contents

Path

Size

examples/

clang-interpreter/

2 lines

135 lines

Diff 143376

examples/clang-interpreter/CMakeLists.txt

	set(LLVM_LINK_COMPONENTS			set(LLVM_LINK_COMPONENTS
	Core			Core
	ExecutionEngine			ExecutionEngine
	MC			MC
	MCJIT			MCJIT
	OrcJit			OrcJit
	Option			Option
	RuntimeDyld			RuntimeDyld
	Support			Support
	native			native
	)			)

	add_clang_executable(clang-interpreter			add_clang_executable(clang-interpreter
	main.cpp			main.cpp
	Invoke.cpp
	Manager.cpp
	)			)

	add_dependencies(clang-interpreter			add_dependencies(clang-interpreter
	clang-headers			clang-headers
	)			)

	target_link_libraries(clang-interpreter			target_link_libraries(clang-interpreter
	PRIVATE			PRIVATE
	▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

examples/clang-interpreter/Invoke.h

This file was deleted.

	//===-- examples/clang-interpreter/Invoke.h - Clang C Interpreter Example -===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#ifndef CLANG_EXAMPLE_INTERPRETER_INVOKE_H
	#define CLANG_EXAMPLE_INTERPRETER_INVOKE_H

	namespace llvm {
	class ExecutionEngine;
	class Function;
	}

	#include <string>
	#include <vector>

	namespace interpreter {

	typedef std::vector<std::string> InvokeArgs;

	typedef int (Invoker)(llvm::ExecutionEngine EE, llvm::Function *EntryFn,
	const InvokeArgs &Args, char const EnvP);

	int TryIt(llvm::ExecutionEngine EE, llvm::Function EntryFn,
	const InvokeArgs &Args, char const EnvP,
	Invoker Invoke);

	} // interpreter

	#endif // CLANG_EXAMPLE_INTERPRETER_INVOKE_H

examples/clang-interpreter/Invoke.cpp

This file was deleted.

	//==-- examples/clang-interpreter/Invoke.cpp - Clang C Interpreter Example -==//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#include "Invoke.h"

	#include <iostream>
	#include <stdexcept>

	namespace interpreter {

	int TryIt(llvm::ExecutionEngine EE, llvm::Function EntryFn,
	const std::vector<std::string> &Args, char const EnvP,
	Invoker Invoke) {
	int Res = -1;
	try {
	Res = Invoke(EE, EntryFn, Args, EnvP);
	} catch (const std::exception &E) {
	std::cout << "Caught '" << E.what() << "'\n";
	} catch (...) {
	std::cout << "Unknown exception\n";
	}
	return Res;
	}

	}

examples/clang-interpreter/Manager.h

This file was deleted.

	//===-- examples/clang-interpreter/Manager.h - Clang C Interpreter Example -==//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#ifndef CLANG_EXAMPLE_INTERPRETER_MANAGER_H
	#define CLANG_EXAMPLE_INTERPRETER_MANAGER_H

	#include "llvm/ExecutionEngine/SectionMemoryManager.h"

	#if defined(LLVM_ON_WIN32) && defined(_WIN64)
	#define CLANG_INTERPRETER_COFF_FORMAT
	#define CLANG_INTERPRETER_WIN_EXCEPTIONS
	#endif

	namespace interpreter {

	class SingleSectionMemoryManager : public llvm::SectionMemoryManager {
	struct Block {
	uint8_t Addr = nullptr, End = nullptr;
	void Reset(uint8_t *Ptr, uintptr_t Size);
	uint8_t *Next(uintptr_t Size, unsigned Alignment);
	};
	Block Code, ROData, RWData;

	public:
	uint8_t *allocateCodeSection(uintptr_t Size, unsigned Align, unsigned ID,
	llvm::StringRef Name) final;

	uint8_t *allocateDataSection(uintptr_t Size, unsigned Align, unsigned ID,
	llvm::StringRef Name, bool RO) final;

	void reserveAllocationSpace(uintptr_t CodeSize, uint32_t CodeAlign,
	uintptr_t ROSize, uint32_t ROAlign,
	uintptr_t RWSize, uint32_t RWAlign) final;

	bool needsToReserveAllocationSpace() override { return true; }

	#ifdef CLANG_INTERPRETER_WIN_EXCEPTIONS
	using llvm::SectionMemoryManager::EHFrameInfos;

	SingleSectionMemoryManager();

	void deregisterEHFrames() override;

	bool finalizeMemory(std::string *ErrMsg) override;

	private:
	uintptr_t ImageBase = 0;
	#endif
	};

	}

	#endif // CLANG_EXAMPLE_INTERPRETER_MANAGER_H

examples/clang-interpreter/Manager.cpp

This file was deleted.

	//==-- examples/clang-interpreter/Manager.cpp - Clang C Interpreter Example -=//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#include "Manager.h"

	#ifdef CLANG_INTERPRETER_WIN_EXCEPTIONS
	#include "llvm/Support/DynamicLibrary.h"

	#define WIN32_LEAN_AND_MEAN
	#define NOGDI
	#define NOMINMAX
	#include <windows.h>
	#endif

	namespace interpreter {

	using namespace llvm;

	void SingleSectionMemoryManager::Block::Reset(uint8_t *Ptr, uintptr_t Size) {
	assert(Ptr != nullptr && "Bad allocation");
	Addr = Ptr;
	End = Ptr ? Ptr + Size : nullptr;
	}

	uint8_t *SingleSectionMemoryManager::Block::Next(uintptr_t Size,
	unsigned Alignment) {
	uintptr_t Out = (uintptr_t)Addr;

	// Align the out pointer properly
	if (!Alignment)
	Alignment = 16;
	Out = (Out + Alignment - 1) & ~(uintptr_t)(Alignment - 1);

	// RuntimeDyld should have called reserveAllocationSpace with an amount that
	// will fit all required alignemnts...but assert on this to make sure.
	assert((Out + Size) <= (uintptr_t)End && "Out of bounds");

	// Set the next Addr to deliver at the end of this one.
	Addr = (uint8_t *)(Out + Size);
	return (uint8_t *)Out;
	}

	uint8_t *SingleSectionMemoryManager::allocateCodeSection(uintptr_t Size,
	unsigned Align,
	unsigned ID,
	StringRef Name) {
	return Code.Next(Size, Align);
	}

	uint8_t *SingleSectionMemoryManager::allocateDataSection(
	uintptr_t Size, unsigned Align, unsigned ID, StringRef Name, bool RO) {
	return RO ? ROData.Next(Size, Align) : RWData.Next(Size, Align);
	}

	void SingleSectionMemoryManager::reserveAllocationSpace(
	uintptr_t CodeSize, uint32_t CodeAlign, uintptr_t ROSize, uint32_t ROAlign,
	uintptr_t RWSize, uint32_t RWAlign) {
	// FIXME: Ideally this should be one contiguous block, with Code, ROData,
	// and RWData pointing to sub-blocks within, but setting the correct
	// permissions for that wouldn't work unless we over-allocated to have each
	// Block.Base aligned on a page boundary.
	const unsigned SecID = 0;
	Code.Reset(SectionMemoryManager::allocateCodeSection(CodeSize, CodeAlign,
	SecID, "code"),
	CodeSize);

	ROData.Reset(SectionMemoryManager::allocateDataSection(ROSize, ROAlign, SecID,
	"rodata", true/RO/),
	ROSize);

	RWData.Reset(SectionMemoryManager::allocateDataSection(RWSize, RWAlign, SecID,
	"rwdata", false/RO/),
	RWSize);

	#ifdef CLANG_INTERPRETER_WIN_EXCEPTIONS
	ImageBase =
	(uintptr_t)std::min(std::min(Code.Addr, ROData.Addr), RWData.Addr);
	#endif
	}

	#ifdef CLANG_INTERPRETER_WIN_EXCEPTIONS

	// Map an "ImageBase" to a range of adresses that can throw.
	//
	class SEHFrameHandler {
	typedef SingleSectionMemoryManager::EHFrameInfos EHFrameInfos;
	typedef std::vector<std::pair<DWORD, DWORD>> ImageRanges;
	typedef std::map<uintptr_t, ImageRanges> ImageBaseMap;
	ImageBaseMap m_Map;

	static void MergeRanges(ImageRanges &Ranges);
	uintptr_t FindEHFrame(uintptr_t Caller);

	public:
	static __declspec(noreturn) void __stdcall RaiseSEHException(void , void );
	void RegisterEHFrames(uintptr_t ImageBase, const EHFrameInfos &Frames,
	bool Block = true);
	void DeRegisterEHFrames(uintptr_t ImageBase, const EHFrameInfos &Frames);
	};

	// Merge overlaping ranges for faster searching with throwing PC
	void SEHFrameHandler::MergeRanges(ImageRanges &Ranges) {
	std::sort(Ranges.begin(), Ranges.end());

	ImageRanges Merged;
	ImageRanges::iterator It = Ranges.begin();
	auto Current = *(It)++;
	while (It != Ranges.end()) {
	if (Current.second + 1 < It->first) {
	Merged.push_back(Current);
	Current = *(It);
	} else
	Current.second = std::max(Current.second, It->second);
	++It;
	}
	Merged.emplace_back(Current);
	Ranges.swap(Merged);
	}

	// Find the "ImageBase" for Caller/PC who is throwing an exception
	uintptr_t SEHFrameHandler::FindEHFrame(uintptr_t Caller) {
	for (auto &&Itr : m_Map) {
	const uintptr_t ImgBase = Itr.first;
	for (auto &&Rng : Itr.second) {
	if (Caller >= (ImgBase + Rng.first) && Caller <= (ImgBase + Rng.second))
	return ImgBase;
	}
	}
	return 0;
	}

	// Register a range of adresses for a single section that
	void SEHFrameHandler::RegisterEHFrames(uintptr_t ImageBase,
	const EHFrameInfos &Frames, bool Block) {
	if (Frames.empty())
	return;
	assert(m_Map.find(ImageBase) == m_Map.end());

	ImageBaseMap::mapped_type &Ranges = m_Map[ImageBase];
	ImageRanges::value_type *BlockRange = nullptr;
	if (Block) {
	// Merge all unwind adresses into a single contiguous block for faster
	// searching later.
	Ranges.emplace_back(std::numeric_limits<DWORD>::max(),
	std::numeric_limits<DWORD>::min());
	BlockRange = &Ranges.back();
	}

	for (auto &&Frame : Frames) {
	assert(m_Map.find(DWORD64(Frame.Addr)) == m_Map.end() &&
	"Runtime function should not be a key!");

	PRUNTIME_FUNCTION RFunc = reinterpret_cast<PRUNTIME_FUNCTION>(Frame.Addr);
	const size_t N = Frame.Size / sizeof(RUNTIME_FUNCTION);
	if (BlockRange) {
	for (PRUNTIME_FUNCTION It = RFunc, End = RFunc + N; It < End; ++It) {
	BlockRange->first = std::min(BlockRange->first, It->BeginAddress);
	BlockRange->second = std::max(BlockRange->second, It->EndAddress);
	}
	} else {
	for (PRUNTIME_FUNCTION It = RFunc, End = RFunc + N; It < End; ++It)
	Ranges.emplace_back(It->BeginAddress, It->EndAddress);
	}

	::RtlAddFunctionTable(RFunc, N, ImageBase);
	}

	if (!Block)
	MergeRanges(Ranges); // Initial sort and merge
	}

	void SEHFrameHandler::DeRegisterEHFrames(uintptr_t ImageBase,
	const EHFrameInfos &Frames) {
	if (Frames.empty())
	return;

	auto Itr = m_Map.find(ImageBase);
	if (Itr != m_Map.end()) {
	// Remove the ImageBase from lookup
	m_Map.erase(Itr);

	// Unregister all the PRUNTIME_FUNCTIONs
	for (auto &&Frame : Frames)
	::RtlDeleteFunctionTable(reinterpret_cast<PRUNTIME_FUNCTION>(Frame.Addr));
	}
	}

	// FIXME: Rather than this static and overriding _CxxThrowException via
	// DynamicLibrary::AddSymbol, a better route would be to transform the call
	// to _CxxThrowException(Arg0, Arg1) -> RaiseSEHException(Arg0, Arg1, this)
	// where 'this' is the SingleSectionMemoryManager instance. This could probably
	// be done with clang, and definitely possible by injecting an llvm-IR function
	// into the module with the name '_CxxThrowException'
	//
	static SEHFrameHandler sFrameHandler;

	void SingleSectionMemoryManager::deregisterEHFrames() {
	sFrameHandler.DeRegisterEHFrames(ImageBase, EHFrames);
	EHFrameInfos().swap(EHFrames);
	}

	bool SingleSectionMemoryManager::finalizeMemory(std::string *ErrMsg) {
	sFrameHandler.RegisterEHFrames(ImageBase, EHFrames);
	ImageBase = 0;
	return SectionMemoryManager::finalizeMemory(ErrMsg);
	}

	SingleSectionMemoryManager::SingleSectionMemoryManager() {
	// Override Windows _CxxThrowException to call into our local version that
	// can throw to and from the JIT.
	sys::DynamicLibrary::AddSymbol(
	"_CxxThrowException",
	(void *)(uintptr_t)&SEHFrameHandler::RaiseSEHException);
	}

	// Adapted from VisualStudio/VC/crt/src/vcruntime/throw.cpp
	#ifdef _WIN64
	#define _EH_RELATIVE_OFFSETS 1
	#endif
	// The NT Exception # that we use
	#define EH_EXCEPTION_NUMBER ('msc' \| 0xE0000000)
	// The magic # identifying this version
	#define EH_MAGIC_NUMBER1 0x19930520
	#define EH_PURE_MAGIC_NUMBER1 0x01994000
	// Number of parameters in exception record
	#define EH_EXCEPTION_PARAMETERS 4

	// A generic exception record
	struct EHExceptionRecord {
	DWORD ExceptionCode;
	DWORD ExceptionFlags; // Flags determined by NT
	_EXCEPTION_RECORD *ExceptionRecord; // Extra exception record (unused)
	void *ExceptionAddress; // Address at which exception occurred
	DWORD NumberParameters; // No. of parameters = EH_EXCEPTION_PARAMETERS
	struct EHParameters {
	DWORD magicNumber; // = EH_MAGIC_NUMBER1
	void *pExceptionObject; // Pointer to the actual object thrown
	struct ThrowInfo *pThrowInfo; // Description of thrown object
	#if _EH_RELATIVE_OFFSETS
	DWORD64 pThrowImageBase; // Image base of thrown object
	#endif
	} params;
	};

	__declspec(noreturn) void __stdcall
	SEHFrameHandler::RaiseSEHException(void CxxExcept, void Info) {
	uintptr_t Caller;
	static_assert(sizeof(Caller) == sizeof(PVOID), "Size mismatch");

	USHORT Frames = CaptureStackBackTrace(1, 1, (PVOID *)&Caller, NULL);
	assert(Frames && "No frames captured");
	(void)Frames;

	const DWORD64 BaseAddr = sFrameHandler.FindEHFrame(Caller);
	if (BaseAddr == 0)
	_CxxThrowException(CxxExcept, (_ThrowInfo *)Info);

	// A generic exception record
	EHExceptionRecord Exception = {
	EH_EXCEPTION_NUMBER, // Exception number
	EXCEPTION_NONCONTINUABLE, // Exception flags (we don't do resume)
	nullptr, // Additional record (none)
	nullptr, // Address of exception (OS fills in)
	EH_EXCEPTION_PARAMETERS, // Number of parameters
	{EH_MAGIC_NUMBER1, CxxExcept, (struct ThrowInfo *)Info,
	#if _EH_RELATIVE_OFFSETS
	BaseAddr
	#endif
	}};

	// const ThrowInfo* pTI = (const ThrowInfo*)Info;

	#ifdef THROW_ISWINRT
	if (pTI && (THROW_ISWINRT((*pTI)))) {
	// The pointer to the ExceptionInfo structure is stored sizeof(void*)
	// infront of each WinRT Exception Info.
	ULONG_PTR EPtr = reinterpret_cast<ULONG_PTR **>(CxxExcept);
	EPtr--;

	WINRTEXCEPTIONINFO ppWei = reinterpret_cast<WINRTEXCEPTIONINFO >(EPtr);
	pTI = (*ppWei)->throwInfo;
	(*ppWei)->PrepareThrow(ppWei);
	}
	#endif

	// If the throw info indicates this throw is from a pure region,
	// set the magic number to the Pure one, so only a pure-region
	// catch will see it.
	//
	// Also use the Pure magic number on Win64 if we were unable to
	// determine an image base, since that was the old way to determine
	// a pure throw, before the TI_IsPure bit was added to the FuncInfo
	// attributes field.
	if (Info != nullptr) {
	#ifdef THROW_ISPURE
	if (THROW_ISPURE(*pTI))
	Exception.params.magicNumber = EH_PURE_MAGIC_NUMBER1;
	#if _EH_RELATIVE_OFFSETS
	else
	#endif // _EH_RELATIVE_OFFSETS
	#endif // THROW_ISPURE

	// Not quite sure what this is about, but pThrowImageBase can never be 0
	// here, as that is used to mark when an "ImageBase" was not found.
	#if 0 && _EH_RELATIVE_OFFSETS
	if (Exception.params.pThrowImageBase == 0)
	Exception.params.magicNumber = EH_PURE_MAGIC_NUMBER1;
	#endif // _EH_RELATIVE_OFFSETS
	}

	// Hand it off to the OS:
	#if defined(_M_X64) && defined(_NTSUBSET_)
	RtlRaiseException((PEXCEPTION_RECORD)&Exception);
	#else
	RaiseException(Exception.ExceptionCode, Exception.ExceptionFlags,
	Exception.NumberParameters, (PULONG_PTR)&Exception.params);
	#endif
	}

	#endif // CLANG_INTERPRETER_WIN_EXCEPTIONS

	} // namespace interpreter

examples/clang-interpreter/main.cpp

//===-- examples/clang-interpreter/main.cpp - Clang C Interpreter Example -===//		//===-- examples/clang-interpreter/main.cpp - Clang C Interpreter Example -===//
//		//
// The LLVM Compiler Infrastructure		// The LLVM Compiler Infrastructure
//		//
// This file is distributed under the University of Illinois Open Source		// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.		// License. See LICENSE.TXT for details.
//		//
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

#include "Invoke.h"
#include "Manager.h"

#include "clang/CodeGen/CodeGenAction.h"
#include "clang/Basic/DiagnosticOptions.h"		#include "clang/Basic/DiagnosticOptions.h"
		#include "clang/CodeGen/CodeGenAction.h"
#include "clang/Driver/Compilation.h"		#include "clang/Driver/Compilation.h"
#include "clang/Driver/Driver.h"		#include "clang/Driver/Driver.h"
#include "clang/Driver/Tool.h"		#include "clang/Driver/Tool.h"
#include "clang/Frontend/CompilerInstance.h"		#include "clang/Frontend/CompilerInstance.h"
#include "clang/Frontend/CompilerInvocation.h"		#include "clang/Frontend/CompilerInvocation.h"
#include "clang/Frontend/FrontendDiagnostic.h"		#include "clang/Frontend/FrontendDiagnostic.h"
#include "clang/Frontend/TextDiagnosticPrinter.h"		#include "clang/Frontend/TextDiagnosticPrinter.h"
#include "llvm/ADT/SmallString.h"		#include "llvm/ADT/SmallString.h"
#include "llvm/ExecutionEngine/ExecutionEngine.h"		#include "llvm/ExecutionEngine/ExecutionEngine.h"
#include "llvm/ExecutionEngine/MCJIT.h"		#include "llvm/ExecutionEngine/Orc/CompileUtils.h"
		#include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
		#include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
		#include "llvm/ExecutionEngine/SectionMemoryManager.h"
		#include "llvm/IR/DataLayout.h"
		#include "llvm/IR/Mangler.h"
#include "llvm/IR/Module.h"		#include "llvm/IR/Module.h"
#include "llvm/Support/FileSystem.h"		#include "llvm/Support/FileSystem.h"
#include "llvm/Support/Host.h"		#include "llvm/Support/Host.h"
#include "llvm/Support/ManagedStatic.h"		#include "llvm/Support/ManagedStatic.h"
#include "llvm/Support/Path.h"		#include "llvm/Support/Path.h"
#include "llvm/Support/TargetSelect.h"		#include "llvm/Support/TargetSelect.h"
#include "llvm/Support/raw_ostream.h"		#include "llvm/Support/raw_ostream.h"
		#include "llvm/Target/TargetMachine.h"

using namespace clang;		using namespace clang;
using namespace clang::driver;		using namespace clang::driver;

namespace interpreter {

static llvm::ExecutionEngine *
createExecutionEngine(std::unique_ptr<llvm::Module> M, std::string *ErrorStr) {
llvm::EngineBuilder EB(std::move(M));
EB.setErrorStr(ErrorStr);
EB.setMemoryManager(llvm::make_unique<SingleSectionMemoryManager>());
llvm::ExecutionEngine *EE = EB.create();
EE->finalizeObject();
return EE;
}

// Invoked from a try/catch block in invoke.cpp.
//
static int Invoke(llvm::ExecutionEngine EE, llvm::Function EntryFn,
const std::vector<std::string> &Args, char const EnvP) {
return EE->runFunctionAsMain(EntryFn, Args, EnvP);
}

// This function isn't referenced outside its translation unit, but it		// This function isn't referenced outside its translation unit, but it
// can't use the "static" keyword because its address is used for		// can't use the "static" keyword because its address is used for
// GetMainExecutable (since some platforms don't support taking the		// GetMainExecutable (since some platforms don't support taking the
// address of main, and some platforms can't implement GetMainExecutable		// address of main, and some platforms can't implement GetMainExecutable
// without being given the address of a function in the main executable).		// without being given the address of a function in the main executable).
std::string GetExecutablePath(const char Argv0, void MainAddr) {		std::string GetExecutablePath(const char Argv0, void MainAddr) {
return llvm::sys::fs::getMainExecutable(Argv0, MainAddr);		return llvm::sys::fs::getMainExecutable(Argv0, MainAddr);
}		}

} // namespace interpreter		namespace llvm {
		namespace orc {

int main(int argc, const char *argv, char const *envp) {		class SimpleJIT {
		private:
		alexander-shaposhnikovUnsubmitted Not Done Reply Inline Actions not needed alexander-shaposhnikov: not needed
		sasAuthorUnsubmitted Not Done Reply Inline Actions Seems cleaner to me to have these explicit, and avoids potentiel code churn if there are changes above. Is there something in the llvm coding style that recommends skipping these? sas: Seems cleaner to me to have these explicit, and avoids potentiel code churn if there are…
		ExecutionSession ES;
		std::shared_ptr<SymbolResolver> Resolver;
		std::unique_ptr<TargetMachine> TM;
		const DataLayout DL;
		RTDyldObjectLinkingLayer ObjectLayer;
		IRCompileLayer<decltype(ObjectLayer), SimpleCompiler> CompileLayer;

		public:
		SimpleJIT()
		: Resolver(createLegacyLookupResolver(
		[this](const std::string &Name) -> JITSymbol {
		if (auto Sym = CompileLayer.findSymbol(Name, false))
		return Sym;
		else if (auto Err = Sym.takeError())
		return std::move(Err);
		if (auto SymAddr =
		RTDyldMemoryManager::getSymbolAddressInProcess(Name))
		return JITSymbol(SymAddr, JITSymbolFlags::Exported);
		return nullptr;
		},
		[](Error Err) { cantFail(std::move(Err), "lookupFlags failed"); })),
		TM(EngineBuilder().selectTarget()), DL(TM->createDataLayout()),
		ObjectLayer(ES,
		[this](VModuleKey) {
		return RTDyldObjectLinkingLayer::Resources{
		std::make_shared<SectionMemoryManager>(), Resolver};
		}),
		CompileLayer(ObjectLayer, SimpleCompiler(*TM)) {
		llvm::sys::DynamicLibrary::LoadLibraryPermanently(nullptr);
		}

		const TargetMachine &getTargetMachine() const { return *TM; }
		alexander-shaposhnikovUnsubmitted Not Done Reply Inline Actions const TargetMachine & ? alexander-shaposhnikov: const TargetMachine & ?

		VModuleKey addModule(std::unique_ptr<Module> M) {
		// Add the module to the JIT with a new VModuleKey.
		auto K = ES.allocateVModule();
		cantFail(CompileLayer.addModule(K, std::move(M)));
		return K;
		}

		JITSymbol findSymbol(const StringRef &Name) {
		alexander-shaposhnikovUnsubmitted Not Done Reply Inline Actions const string & or maybe even StringRef and the same below alexander-shaposhnikov: const string & or maybe even StringRef and the same below
		std::string MangledName;
		raw_string_ostream MangledNameStream(MangledName);
		Mangler::getNameWithPrefix(MangledNameStream, Name, DL);
		return CompileLayer.findSymbol(MangledNameStream.str(), true);
		}

		JITTargetAddress getSymbolAddress(const StringRef &Name) {
		return cantFail(findSymbol(Name).getAddress());
		}

		void removeModule(VModuleKey K) {
		cantFail(CompileLayer.removeModule(K));
		}
		};

		} // end namespace orc
		} // end namespace llvm

		int main(int argc, const char **argv) {
// This just needs to be some symbol in the binary; C++ doesn't		// This just needs to be some symbol in the binary; C++ doesn't
// allow taking the address of ::main however.		// allow taking the address of ::main however.
void MainAddr = (void) (intptr_t) interpreter::GetExecutablePath;		void MainAddr = (void) (intptr_t) GetExecutablePath;
std::string Path = interpreter::GetExecutablePath(argv[0], MainAddr);		std::string Path = GetExecutablePath(argv[0], MainAddr);
IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();		IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
TextDiagnosticPrinter *DiagClient =		TextDiagnosticPrinter *DiagClient =
new TextDiagnosticPrinter(llvm::errs(), &*DiagOpts);		new TextDiagnosticPrinter(llvm::errs(), &*DiagOpts);

IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());		IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagClient);		DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagClient);

const std::string TripleStr = llvm::sys::getProcessTriple();		const std::string TripleStr = llvm::sys::getProcessTriple();
llvm::Triple T(TripleStr);		llvm::Triple T(TripleStr);

// Use ELF on Windows-32 and MingW for now.		// Use ELF on Windows-32 and MingW for now.
#ifndef CLANG_INTERPRETER_COFF_FORMAT		#ifndef CLANG_INTERPRETER_COFF_FORMAT
if (T.isOSBinFormatCOFF())		if (T.isOSBinFormatCOFF())
T.setObjectFormat(llvm::Triple::ELF);		T.setObjectFormat(llvm::Triple::ELF);
#endif		#endif

Driver TheDriver(Path, T.str(), Diags);		Driver TheDriver(Path, T.str(), Diags);
TheDriver.setTitle("clang interpreter");		TheDriver.setTitle("clang interpreter");
TheDriver.setCheckInputsExist(false);		TheDriver.setCheckInputsExist(false);

// FIXME: This is a hack to try to force the driver to do something we can		// FIXME: This is a hack to try to force the driver to do something we can
// recognize. We need to extend the driver library to support this use model		// recognize. We need to extend the driver library to support this use model
// (basically, exactly one input, and the operation mode is hard wired).		// (basically, exactly one input, and the operation mode is hard wired).
SmallVector<const char *, 16> Args(argv, argv + argc);		SmallVector<const char *, 16> Args(argv, argv + argc);
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines	#endif
std::unique_ptr<CodeGenAction> Act(new EmitLLVMOnlyAction());		std::unique_ptr<CodeGenAction> Act(new EmitLLVMOnlyAction());
if (!Clang.ExecuteAction(*Act))		if (!Clang.ExecuteAction(*Act))
return 1;		return 1;

llvm::InitializeNativeTarget();		llvm::InitializeNativeTarget();
llvm::InitializeNativeTargetAsmPrinter();		llvm::InitializeNativeTargetAsmPrinter();

int Res = 255;		int Res = 255;
if (std::unique_ptr<llvm::Module> Module = Act->takeModule()) {		std::unique_ptr<llvm::Module> Module = Act->takeModule();
llvm::Function *EntryFn = Module->getFunction("main");
if (!EntryFn) {
llvm::errs() << "'main' function not found in module.\n";
return Res;
}

std::string Error;
std::unique_ptr<llvm::ExecutionEngine> EE(
interpreter::createExecutionEngine(std::move(Module), &Error));
if (!EE) {
llvm::errs() << "unable to make execution engine: " << Error << "\n";
return Res;
}

interpreter::InvokeArgs Args;		if (Module) {
for (int I = 1; I < argc; ++I)		llvm::orc::SimpleJIT J;
Args.push_back(argv[I]);		auto H = J.addModule(std::move(Module));
		auto Main = (int(*)(...))J.getSymbolAddress("main");
if (Clang.getLangOpts().CPlusPlus)		Res = Main();
Res = interpreter::TryIt(EE.get(), EntryFn, Args, envp, interpreter::Invoke);		J.removeModule(H);
else
Res = interpreter::Invoke(EE.get(), EntryFn, Args, envp);
}		}

// Shutdown.		// Shutdown.
llvm::llvm_shutdown();		llvm::llvm_shutdown();

return Res;		return Res;
}		}

This is an archive of the discontinued LLVM Phabricator instance.

Convert clang-interpreter to ORC JIT APIClosedPublic

Details

Diff Detail

Event Timeline