diff options
Diffstat (limited to 'gnu/llvm/clang/examples/clang-interpreter')
| -rw-r--r-- | gnu/llvm/clang/examples/clang-interpreter/CMakeLists.txt | 93 | ||||
| -rw-r--r-- | gnu/llvm/clang/examples/clang-interpreter/README.txt | 20 | ||||
| -rw-r--r-- | gnu/llvm/clang/examples/clang-interpreter/Test.cxx | 33 | ||||
| -rw-r--r-- | gnu/llvm/clang/examples/clang-interpreter/main.cpp | 229 |
4 files changed, 375 insertions, 0 deletions
diff --git a/gnu/llvm/clang/examples/clang-interpreter/CMakeLists.txt b/gnu/llvm/clang/examples/clang-interpreter/CMakeLists.txt new file mode 100644 index 00000000000..11056aa379a --- /dev/null +++ b/gnu/llvm/clang/examples/clang-interpreter/CMakeLists.txt @@ -0,0 +1,93 @@ +set(LLVM_LINK_COMPONENTS + Core + ExecutionEngine + MC + MCJIT + Object + OrcJit + Option + RuntimeDyld + Support + native + ) + +add_clang_executable(clang-interpreter + main.cpp + ) + +add_dependencies(clang-interpreter + clang-resource-headers + ) + +clang_target_link_libraries(clang-interpreter + PRIVATE + clangBasic + clangCodeGen + clangDriver + clangFrontend + clangSerialization + ) + +export_executable_symbols(clang-interpreter) + +if (MSVC) + # Is this a CMake bug that even with export_executable_symbols, Windows + # needs to explictly export the type_info vtable + set_property(TARGET clang-interpreter + APPEND_STRING PROPERTY LINK_FLAGS " /EXPORT:??_7type_info@@6B@") +endif() + +function(clang_enable_exceptions TARGET) + # Really have to jump through hoops to enable exception handling independent + # of how LLVM is being built. + if (NOT LLVM_REQUIRES_EH AND NOT LLVM_REQUIRES_RTTI) + if (MSVC) + # /EHs to allow throwing from extern "C" + set(excptnExceptions_ON "/D _HAS_EXCEPTIONS=1 /EHs /wd4714") + set(excptnExceptions_OFF "/D _HAS_EXCEPTIONS=0 /EHs-c-") + set(excptnRTTI_ON "/GR") + set(excptnRTTI_OFF "/GR-") + set(excptnEHRTTIRegEx "(/EHs(-c-?)|_HAS_EXCEPTIONS=(0|1))") + else() + set(excptnExceptions_ON "-fexceptions") + set(excptnExceptions_OFF "-fno-exceptions") + set(excptnRTTI_ON "-frtti") + set(excptnRTTI_OFF "-fno-rtti") + set(excptnEHRTTIRegEx "-f(exceptions|no-exceptions)") + endif() + if (LLVM_REQUIRES_EH) + set(excptnExceptions_DFLT ${excptnExceptions_ON}) + else() + set(excptnExceptions_DFLT ${excptnExceptions_OFF}) + endif() + if (LLVM_REQUIRES_RTTI) + set(excptnRTTI_DFLT ${excptnRTTI_ON}) + else() + set(excptnRTTI_DFLT ${excptnRTTI_OFF}) + endif() + + # Strip the exception & rtti flags from the target + get_property(addedFlags TARGET ${TARGET} PROPERTY COMPILE_FLAGS) + string(REGEX REPLACE ${excptnEHRTTIRegEx} "" editedFlags "${addedFlags}") + string(REPLACE ${excptnRTTI_OFF} "" editedFlags "${editedFlags}") + set_property(TARGET ${TARGET} PROPERTY COMPILE_FLAGS "${editedFlags}") + + get_property(addedFlags TARGET ${TARGET} PROPERTY COMPILE_DEFINITIONS) + string(REGEX REPLACE ${excptnEHRTTIRegEx} "" editedFlags "${addedFlags}") + string(REPLACE ${excptnRTTI_OFF} "" editedFlags "${editedFlags}") + set_property(TARGET ${TARGET} PROPERTY COMPILE_DEFINITIONS "${editedFlags}") + + # Re-add the exception & rtti flags from LLVM + set_property(SOURCE main.cpp APPEND_STRING PROPERTY COMPILE_FLAGS + " ${excptnExceptions_DFLT} ${excptnRTTI_DFLT} ") + set_property(SOURCE Manager.cpp APPEND_STRING PROPERTY COMPILE_FLAGS + " ${excptnExceptions_DFLT} ${excptnRTTI_DFLT} ") + + # Invoke with exceptions & rtti + set_property(SOURCE Invoke.cpp APPEND_STRING PROPERTY COMPILE_FLAGS + " ${excptnExceptions_ON} ${excptnRTTI_ON} ") + + endif() +endfunction(clang_enable_exceptions) + +clang_enable_exceptions(clang-interpreter) diff --git a/gnu/llvm/clang/examples/clang-interpreter/README.txt b/gnu/llvm/clang/examples/clang-interpreter/README.txt new file mode 100644 index 00000000000..b4f8a935cef --- /dev/null +++ b/gnu/llvm/clang/examples/clang-interpreter/README.txt @@ -0,0 +1,20 @@ +This is an example of Clang based interpreter, for executing standalone C/C++ +programs. + +It demonstrates the following features: + 1. Parsing standard compiler command line arguments using the Driver library. + + 2. Constructing a Clang compiler instance, using the appropriate arguments + derived in step #1. + + 3. Invoking the Clang compiler to lex, parse, syntax check, and then generate + LLVM code. + + 4. Use the LLVM JIT functionality to execute the final module. + + 5. Intercepting a Win64 library call to allow throwing and catching exceptions + in and from the JIT. + +The implementation has many limitations and is not designed to be a full fledged +interpreter. It is designed to demonstrate a simple but functional use of the +Clang compiler libraries. diff --git a/gnu/llvm/clang/examples/clang-interpreter/Test.cxx b/gnu/llvm/clang/examples/clang-interpreter/Test.cxx new file mode 100644 index 00000000000..ed7fc86f9e5 --- /dev/null +++ b/gnu/llvm/clang/examples/clang-interpreter/Test.cxx @@ -0,0 +1,33 @@ +//===-- examples/clang-interpreter/Test.cxx - Clang C Interpreter Example -===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// Example throwing in and from the JIT (particularly on Win64). +// +// ./bin/clang-interpreter <src>/tools/clang/examples/clang-interpreter/Test.cxx + +#include <stdexcept> +#include <stdio.h> + +static void ThrowerAnError(const char* Name) { + throw std::runtime_error(Name); +} + +int main(int argc, const char** argv) { + for (int I = 0; I < argc; ++I) + printf("arg[%d]='%s'\n", I, argv[I]); + + try { + ThrowerAnError("In JIT"); + } catch (const std::exception& E) { + printf("Caught: '%s'\n", E.what()); + } catch (...) { + printf("Unknown exception\n"); + } + ThrowerAnError("From JIT"); + return 0; +} diff --git a/gnu/llvm/clang/examples/clang-interpreter/main.cpp b/gnu/llvm/clang/examples/clang-interpreter/main.cpp new file mode 100644 index 00000000000..c0aae472230 --- /dev/null +++ b/gnu/llvm/clang/examples/clang-interpreter/main.cpp @@ -0,0 +1,229 @@ +//===-- examples/clang-interpreter/main.cpp - Clang C Interpreter Example -===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "clang/Basic/DiagnosticOptions.h" +#include "clang/CodeGen/CodeGenAction.h" +#include "clang/Driver/Compilation.h" +#include "clang/Driver/Driver.h" +#include "clang/Driver/Tool.h" +#include "clang/Frontend/CompilerInstance.h" +#include "clang/Frontend/CompilerInvocation.h" +#include "clang/Frontend/FrontendDiagnostic.h" +#include "clang/Frontend/TextDiagnosticPrinter.h" +#include "llvm/ADT/SmallString.h" +#include "llvm/ExecutionEngine/ExecutionEngine.h" +#include "llvm/ExecutionEngine/Orc/CompileUtils.h" +#include "llvm/ExecutionEngine/Orc/ExecutionUtils.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/Support/FileSystem.h" +#include "llvm/Support/Host.h" +#include "llvm/Support/ManagedStatic.h" +#include "llvm/Support/Path.h" +#include "llvm/Support/TargetSelect.h" +#include "llvm/Support/raw_ostream.h" +#include "llvm/Target/TargetMachine.h" + +using namespace clang; +using namespace clang::driver; + +// This function isn't referenced outside its translation unit, but it +// can't use the "static" keyword because its address is used for +// GetMainExecutable (since some platforms don't support taking the +// address of main, and some platforms can't implement GetMainExecutable +// without being given the address of a function in the main executable). +std::string GetExecutablePath(const char *Argv0, void *MainAddr) { + return llvm::sys::fs::getMainExecutable(Argv0, MainAddr); +} + +namespace llvm { +namespace orc { + +class SimpleJIT { +private: + ExecutionSession ES; + std::unique_ptr<TargetMachine> TM; + const DataLayout DL; + MangleAndInterner Mangle{ES, DL}; + JITDylib &MainJD{ES.createJITDylib("<main>")}; + RTDyldObjectLinkingLayer ObjectLayer{ES, createMemMgr}; + IRCompileLayer CompileLayer{ES, ObjectLayer, + std::make_unique<SimpleCompiler>(*TM)}; + + static std::unique_ptr<SectionMemoryManager> createMemMgr() { + return std::make_unique<SectionMemoryManager>(); + } + + SimpleJIT( + std::unique_ptr<TargetMachine> TM, DataLayout DL, + std::unique_ptr<DynamicLibrarySearchGenerator> ProcessSymbolsGenerator) + : TM(std::move(TM)), DL(std::move(DL)) { + llvm::sys::DynamicLibrary::LoadLibraryPermanently(nullptr); + MainJD.addGenerator(std::move(ProcessSymbolsGenerator)); + } + +public: + static Expected<std::unique_ptr<SimpleJIT>> Create() { + auto JTMB = JITTargetMachineBuilder::detectHost(); + if (!JTMB) + return JTMB.takeError(); + + auto TM = JTMB->createTargetMachine(); + if (!TM) + return TM.takeError(); + + auto DL = (*TM)->createDataLayout(); + + auto ProcessSymbolsGenerator = + DynamicLibrarySearchGenerator::GetForCurrentProcess( + DL.getGlobalPrefix()); + + if (!ProcessSymbolsGenerator) + return ProcessSymbolsGenerator.takeError(); + + return std::unique_ptr<SimpleJIT>(new SimpleJIT( + std::move(*TM), std::move(DL), std::move(*ProcessSymbolsGenerator))); + } + + const TargetMachine &getTargetMachine() const { return *TM; } + + Error addModule(ThreadSafeModule M) { + return CompileLayer.add(MainJD, std::move(M)); + } + + Expected<JITEvaluatedSymbol> findSymbol(const StringRef &Name) { + return ES.lookup({&MainJD}, Mangle(Name)); + } + + Expected<JITTargetAddress> getSymbolAddress(const StringRef &Name) { + auto Sym = findSymbol(Name); + if (!Sym) + return Sym.takeError(); + return Sym->getAddress(); + } +}; + +} // end namespace orc +} // end namespace llvm + +llvm::ExitOnError ExitOnErr; + +int main(int argc, const char **argv) { + // This just needs to be some symbol in the binary; C++ doesn't + // allow taking the address of ::main however. + void *MainAddr = (void*) (intptr_t) GetExecutablePath; + std::string Path = GetExecutablePath(argv[0], MainAddr); + IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions(); + TextDiagnosticPrinter *DiagClient = + new TextDiagnosticPrinter(llvm::errs(), &*DiagOpts); + + IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs()); + DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagClient); + + const std::string TripleStr = llvm::sys::getProcessTriple(); + llvm::Triple T(TripleStr); + + // Use ELF on Windows-32 and MingW for now. +#ifndef CLANG_INTERPRETER_COFF_FORMAT + if (T.isOSBinFormatCOFF()) + T.setObjectFormat(llvm::Triple::ELF); +#endif + + ExitOnErr.setBanner("clang interpreter"); + + Driver TheDriver(Path, T.str(), Diags); + TheDriver.setTitle("clang interpreter"); + TheDriver.setCheckInputsExist(false); + + // 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 + // (basically, exactly one input, and the operation mode is hard wired). + SmallVector<const char *, 16> Args(argv, argv + argc); + Args.push_back("-fsyntax-only"); + std::unique_ptr<Compilation> C(TheDriver.BuildCompilation(Args)); + if (!C) + return 0; + + // FIXME: This is copied from ASTUnit.cpp; simplify and eliminate. + + // We expect to get back exactly one command job, if we didn't something + // failed. Extract that job from the compilation. + const driver::JobList &Jobs = C->getJobs(); + if (Jobs.size() != 1 || !isa<driver::Command>(*Jobs.begin())) { + SmallString<256> Msg; + llvm::raw_svector_ostream OS(Msg); + Jobs.Print(OS, "; ", true); + Diags.Report(diag::err_fe_expected_compiler_job) << OS.str(); + return 1; + } + + const driver::Command &Cmd = cast<driver::Command>(*Jobs.begin()); + if (llvm::StringRef(Cmd.getCreator().getName()) != "clang") { + Diags.Report(diag::err_fe_expected_clang_command); + return 1; + } + + // Initialize a compiler invocation object from the clang (-cc1) arguments. + const llvm::opt::ArgStringList &CCArgs = Cmd.getArguments(); + std::unique_ptr<CompilerInvocation> CI(new CompilerInvocation); + CompilerInvocation::CreateFromArgs(*CI, CCArgs, Diags); + + // Show the invocation, with -v. + if (CI->getHeaderSearchOpts().Verbose) { + llvm::errs() << "clang invocation:\n"; + Jobs.Print(llvm::errs(), "\n", true); + llvm::errs() << "\n"; + } + + // FIXME: This is copied from cc1_main.cpp; simplify and eliminate. + + // Create a compiler instance to handle the actual work. + CompilerInstance Clang; + Clang.setInvocation(std::move(CI)); + + // Create the compilers actual diagnostics engine. + Clang.createDiagnostics(); + if (!Clang.hasDiagnostics()) + return 1; + + // Infer the builtin include path if unspecified. + if (Clang.getHeaderSearchOpts().UseBuiltinIncludes && + Clang.getHeaderSearchOpts().ResourceDir.empty()) + Clang.getHeaderSearchOpts().ResourceDir = + CompilerInvocation::GetResourcesPath(argv[0], MainAddr); + + // Create and execute the frontend to generate an LLVM bitcode module. + std::unique_ptr<CodeGenAction> Act(new EmitLLVMOnlyAction()); + if (!Clang.ExecuteAction(*Act)) + return 1; + + llvm::InitializeNativeTarget(); + llvm::InitializeNativeTargetAsmPrinter(); + + int Res = 255; + std::unique_ptr<llvm::LLVMContext> Ctx(Act->takeLLVMContext()); + std::unique_ptr<llvm::Module> Module = Act->takeModule(); + + if (Module) { + auto J = ExitOnErr(llvm::orc::SimpleJIT::Create()); + + ExitOnErr(J->addModule( + llvm::orc::ThreadSafeModule(std::move(Module), std::move(Ctx)))); + auto Main = (int (*)(...))ExitOnErr(J->getSymbolAddress("main")); + Res = Main(); + } + + // Shutdown. + llvm::llvm_shutdown(); + + return Res; +} |