Remove LLVM 8.0.1 files.

4 files changed, 0 insertions, 369 deletions

diff --git a/gnu/llvm/tools/clang/examples/clang-interpreter/CMakeLists.txt b/gnu/llvm/tools/clang/examples/clang-interpreter/CMakeLists.txt
deleted file mode 100644
index b69a82e0541..00000000000
--- a/gnu/llvm/tools/clang/examples/clang-interpreter/CMakeLists.txt
+++ /dev/null
@@ -1,93 +0,0 @@
-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-headers
-  )
-
-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/tools/clang/examples/clang-interpreter/README.txt b/gnu/llvm/tools/clang/examples/clang-interpreter/README.txt
deleted file mode 100644
index b4f8a935cef..00000000000
--- a/gnu/llvm/tools/clang/examples/clang-interpreter/README.txt
+++ /dev/null
@@ -1,20 +0,0 @@
-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/tools/clang/examples/clang-interpreter/Test.cxx b/gnu/llvm/tools/clang/examples/clang-interpreter/Test.cxx
deleted file mode 100644
index d39249214dc..00000000000
--- a/gnu/llvm/tools/clang/examples/clang-interpreter/Test.cxx
+++ /dev/null
@@ -1,34 +0,0 @@
-//===-- examples/clang-interpreter/Test.cxx - 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.
-//
-//===----------------------------------------------------------------------===//
-
-// 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/tools/clang/examples/clang-interpreter/main.cpp b/gnu/llvm/tools/clang/examples/clang-interpreter/main.cpp
deleted file mode 100644
index 1c83b1d3e75..00000000000
--- a/gnu/llvm/tools/clang/examples/clang-interpreter/main.cpp
+++ /dev/null
@@ -1,222 +0,0 @@
-//===-- examples/clang-interpreter/main.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 "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/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::shared_ptr<SymbolResolver> Resolver;
-  std::unique_ptr<TargetMachine> TM;
-  const DataLayout DL;
-  LegacyRTDyldObjectLinkingLayer ObjectLayer;
-  LegacyIRCompileLayer<decltype(ObjectLayer), SimpleCompiler> CompileLayer;
-
-public:
-  SimpleJIT()
-      : Resolver(createLegacyLookupResolver(
-            ES,
-            [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 LegacyRTDyldObjectLinkingLayer::Resources{
-                          std::make_shared<SectionMemoryManager>(), Resolver};
-                    }),
-        CompileLayer(ObjectLayer, SimpleCompiler(*TM)) {
-    llvm::sys::DynamicLibrary::LoadLibraryPermanently(nullptr);
-  }
-
-  const TargetMachine &getTargetMachine() const { return *TM; }
-
-  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) {
-    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
-  // 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
-
-  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,
-                                     const_cast<const char **>(CCArgs.data()),
-                                     const_cast<const char **>(CCArgs.data()) +
-                                       CCArgs.size(),
-                                     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::Module> Module = Act->takeModule();
-
-  if (Module) {
-    llvm::orc::SimpleJIT J;
-    auto H = J.addModule(std::move(Module));
-    auto Main = (int(*)(...))J.getSymbolAddress("main");
-    Res = Main();
-    J.removeModule(H);
-  }
-
-  // Shutdown.
-  llvm::llvm_shutdown();
-
-  return Res;
-}