3 files changed, 0 insertions, 412 deletions

diff --git a/clang/lib/Tooling/Transformer/CMakeLists.txt b/clang/lib/Tooling/Transformer/CMakeLists.txt
deleted file mode 100644
index 68f0cfeee8f6..000000000000
--- a/clang/lib/Tooling/Transformer/CMakeLists.txt
+++ /dev/null
@@ -1,18 +0,0 @@
-set(LLVM_LINK_COMPONENTS Support)
-
-add_clang_library(clangTransformer
-  RangeSelector.cpp
-  RewriteRule.cpp
-  SourceCode.cpp
-  SourceCodeBuilders.cpp
-  Stencil.cpp
-  Transformer.cpp
-
-  LINK_LIBS
-  clangAST
-  clangASTMatchers
-  clangBasic
-  clangLex
-  clangToolingCore
-  clangToolingRefactoring
-  )
diff --git a/clang/tools/clang-offload-wrapper/CMakeLists.txt b/clang/tools/clang-offload-wrapper/CMakeLists.txt
deleted file mode 100644
index 6f8940f88eab..000000000000
--- a/clang/tools/clang-offload-wrapper/CMakeLists.txt
+++ /dev/null
@@ -1,23 +0,0 @@
-set(LLVM_LINK_COMPONENTS BitWriter Core Support TransformUtils)
-
-if(NOT CLANG_BUILT_STANDALONE)
-  set(tablegen_deps intrinsics_gen)
-endif()
-
-add_clang_tool(clang-offload-wrapper
-  ClangOffloadWrapper.cpp
-
-  DEPENDS
-  ${tablegen_deps}
-  )
-
-set(CLANG_OFFLOAD_WRAPPER_LIB_DEPS
-  clangBasic
-  )
-
-add_dependencies(clang clang-offload-wrapper)
-
-clang_target_link_libraries(clang-offload-wrapper
-  PRIVATE
-  ${CLANG_OFFLOAD_WRAPPER_LIB_DEPS}
-  )
diff --git a/clang/tools/clang-offload-wrapper/ClangOffloadWrapper.cpp b/clang/tools/clang-offload-wrapper/ClangOffloadWrapper.cpp
deleted file mode 100644
index c3863422adf6..000000000000
--- a/clang/tools/clang-offload-wrapper/ClangOffloadWrapper.cpp
+++ /dev/null
@@ -1,371 +0,0 @@
-//===-- clang-offload-wrapper/ClangOffloadWrapper.cpp -----------*- C++ -*-===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// Implementation of the offload wrapper tool. It takes offload target binaries
-/// as input and creates wrapper bitcode file containing target binaries
-/// packaged as data. Wrapper bitcode also includes initialization code which
-/// registers target binaries in offloading runtime at program startup.
-///
-//===----------------------------------------------------------------------===//
-
-#include "clang/Basic/Version.h"
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/Triple.h"
-#include "llvm/Bitcode/BitcodeWriter.h"
-#include "llvm/IR/Constants.h"
-#include "llvm/IR/GlobalVariable.h"
-#include "llvm/IR/IRBuilder.h"
-#include "llvm/IR/LLVMContext.h"
-#include "llvm/IR/Module.h"
-#include "llvm/Support/CommandLine.h"
-#include "llvm/Support/Errc.h"
-#include "llvm/Support/Error.h"
-#include "llvm/Support/ErrorOr.h"
-#include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Support/Signals.h"
-#include "llvm/Support/ToolOutputFile.h"
-#include "llvm/Support/WithColor.h"
-#include "llvm/Support/raw_ostream.h"
-#include "llvm/Transforms/Utils/ModuleUtils.h"
-#include <cassert>
-#include <cstdint>
-
-using namespace llvm;
-
-static cl::opt<bool> Help("h", cl::desc("Alias for -help"), cl::Hidden);
-
-// Mark all our options with this category, everything else (except for -version
-// and -help) will be hidden.
-static cl::OptionCategory
-    ClangOffloadWrapperCategory("clang-offload-wrapper options");
-
-static cl::opt<std::string> Output("o", cl::Required,
-                                   cl::desc("Output filename"),
-                                   cl::value_desc("filename"),
-                                   cl::cat(ClangOffloadWrapperCategory));
-
-static cl::list<std::string> Inputs(cl::Positional, cl::OneOrMore,
-                                    cl::desc("<input files>"),
-                                    cl::cat(ClangOffloadWrapperCategory));
-
-static cl::opt<std::string>
-    Target("target", cl::Required,
-           cl::desc("Target triple for the output module"),
-           cl::value_desc("triple"), cl::cat(ClangOffloadWrapperCategory));
-
-namespace {
-
-class BinaryWrapper {
-  LLVMContext C;
-  Module M;
-
-  StructType *EntryTy = nullptr;
-  StructType *ImageTy = nullptr;
-  StructType *DescTy = nullptr;
-
-private:
-  IntegerType *getSizeTTy() {
-    switch (M.getDataLayout().getPointerTypeSize(Type::getInt8PtrTy(C))) {
-    case 4u:
-      return Type::getInt32Ty(C);
-    case 8u:
-      return Type::getInt64Ty(C);
-    }
-    llvm_unreachable("unsupported pointer type size");
-  }
-
-  // struct __tgt_offload_entry {
-  //   void *addr;
-  //   char *name;
-  //   size_t size;
-  //   int32_t flags;
-  //   int32_t reserved;
-  // };
-  StructType *getEntryTy() {
-    if (!EntryTy)
-      EntryTy = StructType::create("__tgt_offload_entry", Type::getInt8PtrTy(C),
-                                   Type::getInt8PtrTy(C), getSizeTTy(),
-                                   Type::getInt32Ty(C), Type::getInt32Ty(C));
-    return EntryTy;
-  }
-
-  PointerType *getEntryPtrTy() { return PointerType::getUnqual(getEntryTy()); }
-
-  // struct __tgt_device_image {
-  //   void *ImageStart;
-  //   void *ImageEnd;
-  //   __tgt_offload_entry *EntriesBegin;
-  //   __tgt_offload_entry *EntriesEnd;
-  // };
-  StructType *getDeviceImageTy() {
-    if (!ImageTy)
-      ImageTy = StructType::create("__tgt_device_image", Type::getInt8PtrTy(C),
-                                   Type::getInt8PtrTy(C), getEntryPtrTy(),
-                                   getEntryPtrTy());
-    return ImageTy;
-  }
-
-  PointerType *getDeviceImagePtrTy() {
-    return PointerType::getUnqual(getDeviceImageTy());
-  }
-
-  // struct __tgt_bin_desc {
-  //   int32_t NumDeviceImages;
-  //   __tgt_device_image *DeviceImages;
-  //   __tgt_offload_entry *HostEntriesBegin;
-  //   __tgt_offload_entry *HostEntriesEnd;
-  // };
-  StructType *getBinDescTy() {
-    if (!DescTy)
-      DescTy = StructType::create("__tgt_bin_desc", Type::getInt32Ty(C),
-                                  getDeviceImagePtrTy(), getEntryPtrTy(),
-                                  getEntryPtrTy());
-    return DescTy;
-  }
-
-  PointerType *getBinDescPtrTy() {
-    return PointerType::getUnqual(getBinDescTy());
-  }
-
-  /// Creates binary descriptor for the given device images. Binary descriptor
-  /// is an object that is passed to the offloading runtime at program startup
-  /// and it describes all device images available in the executable or shared
-  /// library. It is defined as follows
-  ///
-  /// __attribute__((visibility("hidden")))
-  /// extern __tgt_offload_entry *__start_omp_offloading_entries;
-  /// __attribute__((visibility("hidden")))
-  /// extern __tgt_offload_entry *__stop_omp_offloading_entries;
-  ///
-  /// static const char Image0[] = { <Bufs.front() contents> };
-  ///  ...
-  /// static const char ImageN[] = { <Bufs.back() contents> };
-  ///
-  /// static const __tgt_device_image Images[] = {
-  ///   {
-  ///     Image0,                            /*ImageStart*/
-  ///     Image0 + sizeof(Image0),           /*ImageEnd*/
-  ///     __start_omp_offloading_entries,    /*EntriesBegin*/
-  ///     __stop_omp_offloading_entries      /*EntriesEnd*/
-  ///   },
-  ///   ...
-  ///   {
-  ///     ImageN,                            /*ImageStart*/
-  ///     ImageN + sizeof(ImageN),           /*ImageEnd*/
-  ///     __start_omp_offloading_entries,    /*EntriesBegin*/
-  ///     __stop_omp_offloading_entries      /*EntriesEnd*/
-  ///   }
-  /// };
-  ///
-  /// static const __tgt_bin_desc BinDesc = {
-  ///   sizeof(Images) / sizeof(Images[0]),  /*NumDeviceImages*/
-  ///   Images,                              /*DeviceImages*/
-  ///   __start_omp_offloading_entries,      /*HostEntriesBegin*/
-  ///   __stop_omp_offloading_entries        /*HostEntriesEnd*/
-  /// };
-  ///
-  /// Global variable that represents BinDesc is returned.
-  GlobalVariable *createBinDesc(ArrayRef<ArrayRef<char>> Bufs) {
-    // Create external begin/end symbols for the offload entries table.
-    auto *EntriesB = new GlobalVariable(
-        M, getEntryTy(), /*isConstant*/ true, GlobalValue::ExternalLinkage,
-        /*Initializer*/ nullptr, "__start_omp_offloading_entries");
-    EntriesB->setVisibility(GlobalValue::HiddenVisibility);
-    auto *EntriesE = new GlobalVariable(
-        M, getEntryTy(), /*isConstant*/ true, GlobalValue::ExternalLinkage,
-        /*Initializer*/ nullptr, "__stop_omp_offloading_entries");
-    EntriesE->setVisibility(GlobalValue::HiddenVisibility);
-
-    // We assume that external begin/end symbols that we have created above will
-    // be defined by the linker. But linker will do that only if linker inputs
-    // have section with "omp_offloading_entries" name which is not guaranteed.
-    // So, we just create dummy zero sized object in the offload entries section
-    // to force linker to define those symbols.
-    auto *DummyInit =
-        ConstantAggregateZero::get(ArrayType::get(getEntryTy(), 0u));
-    auto *DummyEntry = new GlobalVariable(
-        M, DummyInit->getType(), true, GlobalVariable::ExternalLinkage,
-        DummyInit, "__dummy.omp_offloading.entry");
-    DummyEntry->setSection("omp_offloading_entries");
-    DummyEntry->setVisibility(GlobalValue::HiddenVisibility);
-
-    auto *Zero = ConstantInt::get(getSizeTTy(), 0u);
-    Constant *ZeroZero[] = {Zero, Zero};
-
-    // Create initializer for the images array.
-    SmallVector<Constant *, 4u> ImagesInits;
-    ImagesInits.reserve(Bufs.size());
-    for (ArrayRef<char> Buf : Bufs) {
-      auto *Data = ConstantDataArray::get(C, Buf);
-      auto *Image = new GlobalVariable(M, Data->getType(), /*isConstant*/ true,
-                                       GlobalVariable::InternalLinkage, Data,
-                                       ".omp_offloading.device_image");
-      Image->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
-
-      auto *Size = ConstantInt::get(getSizeTTy(), Buf.size());
-      Constant *ZeroSize[] = {Zero, Size};
-
-      auto *ImageB = ConstantExpr::getGetElementPtr(Image->getValueType(),
-                                                    Image, ZeroZero);
-      auto *ImageE = ConstantExpr::getGetElementPtr(Image->getValueType(),
-                                                    Image, ZeroSize);
-
-      ImagesInits.push_back(ConstantStruct::get(getDeviceImageTy(), ImageB,
-                                                ImageE, EntriesB, EntriesE));
-    }
-
-    // Then create images array.
-    auto *ImagesData = ConstantArray::get(
-        ArrayType::get(getDeviceImageTy(), ImagesInits.size()), ImagesInits);
-
-    auto *Images =
-        new GlobalVariable(M, ImagesData->getType(), /*isConstant*/ true,
-                           GlobalValue::InternalLinkage, ImagesData,
-                           ".omp_offloading.device_images");
-    Images->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
-
-    auto *ImagesB = ConstantExpr::getGetElementPtr(Images->getValueType(),
-                                                   Images, ZeroZero);
-
-    // And finally create the binary descriptor object.
-    auto *DescInit = ConstantStruct::get(
-        getBinDescTy(),
-        ConstantInt::get(Type::getInt32Ty(C), ImagesInits.size()), ImagesB,
-        EntriesB, EntriesE);
-
-    return new GlobalVariable(M, DescInit->getType(), /*isConstant*/ true,
-                              GlobalValue::InternalLinkage, DescInit,
-                              ".omp_offloading.descriptor");
-  }
-
-  void createRegisterFunction(GlobalVariable *BinDesc) {
-    auto *FuncTy = FunctionType::get(Type::getVoidTy(C), /*isVarArg*/ false);
-    auto *Func = Function::Create(FuncTy, GlobalValue::InternalLinkage,
-                                  ".omp_offloading.descriptor_reg", &M);
-    Func->setSection(".text.startup");
-
-    // Get __tgt_register_lib function declaration.
-    auto *RegFuncTy = FunctionType::get(Type::getVoidTy(C), getBinDescPtrTy(),
-                                        /*isVarArg*/ false);
-    FunctionCallee RegFuncC =
-        M.getOrInsertFunction("__tgt_register_lib", RegFuncTy);
-
-    // Construct function body
-    IRBuilder<> Builder(BasicBlock::Create(C, "entry", Func));
-    Builder.CreateCall(RegFuncC, BinDesc);
-    Builder.CreateRetVoid();
-
-    // Add this function to constructors.
-    appendToGlobalCtors(M, Func, 0);
-  }
-
-  void createUnregisterFunction(GlobalVariable *BinDesc) {
-    auto *FuncTy = FunctionType::get(Type::getVoidTy(C), /*isVarArg*/ false);
-    auto *Func = Function::Create(FuncTy, GlobalValue::InternalLinkage,
-                                  ".omp_offloading.descriptor_unreg", &M);
-    Func->setSection(".text.startup");
-
-    // Get __tgt_unregister_lib function declaration.
-    auto *UnRegFuncTy = FunctionType::get(Type::getVoidTy(C), getBinDescPtrTy(),
-                                          /*isVarArg*/ false);
-    FunctionCallee UnRegFuncC =
-        M.getOrInsertFunction("__tgt_unregister_lib", UnRegFuncTy);
-
-    // Construct function body
-    IRBuilder<> Builder(BasicBlock::Create(C, "entry", Func));
-    Builder.CreateCall(UnRegFuncC, BinDesc);
-    Builder.CreateRetVoid();
-
-    // Add this function to global destructors.
-    appendToGlobalDtors(M, Func, 0);
-  }
-
-public:
-  BinaryWrapper(StringRef Target) : M("offload.wrapper.object", C) {
-    M.setTargetTriple(Target);
-  }
-
-  const Module &wrapBinaries(ArrayRef<ArrayRef<char>> Binaries) {
-    GlobalVariable *Desc = createBinDesc(Binaries);
-    assert(Desc && "no binary descriptor");
-    createRegisterFunction(Desc);
-    createUnregisterFunction(Desc);
-    return M;
-  }
-};
-
-} // anonymous namespace
-
-int main(int argc, const char **argv) {
-  sys::PrintStackTraceOnErrorSignal(argv[0]);
-
-  cl::HideUnrelatedOptions(ClangOffloadWrapperCategory);
-  cl::SetVersionPrinter([](raw_ostream &OS) {
-    OS << clang::getClangToolFullVersion("clang-offload-wrapper") << '\n';
-  });
-  cl::ParseCommandLineOptions(
-      argc, argv,
-      "A tool to create a wrapper bitcode for offload target binaries. Takes "
-      "offload\ntarget binaries as input and produces bitcode file containing "
-      "target binaries packaged\nas data and initialization code which "
-      "registers target binaries in offload runtime.\n");
-
-  if (Help) {
-    cl::PrintHelpMessage();
-    return 0;
-  }
-
-  auto reportError = [argv](Error E) {
-    logAllUnhandledErrors(std::move(E), WithColor::error(errs(), argv[0]));
-  };
-
-  if (Triple(Target).getArch() == Triple::UnknownArch) {
-    reportError(createStringError(
-        errc::invalid_argument, "'" + Target + "': unsupported target triple"));
-    return 1;
-  }
-
-  // Read device binaries.
-  SmallVector<std::unique_ptr<MemoryBuffer>, 4u> Buffers;
-  SmallVector<ArrayRef<char>, 4u> Images;
-  Buffers.reserve(Inputs.size());
-  Images.reserve(Inputs.size());
-  for (const std::string &File : Inputs) {
-    ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
-        MemoryBuffer::getFileOrSTDIN(File);
-    if (!BufOrErr) {
-      reportError(createFileError(File, BufOrErr.getError()));
-      return 1;
-    }
-    const std::unique_ptr<MemoryBuffer> &Buf =
-        Buffers.emplace_back(std::move(*BufOrErr));
-    Images.emplace_back(Buf->getBufferStart(), Buf->getBufferSize());
-  }
-
-  // Create the output file to write the resulting bitcode to.
-  std::error_code EC;
-  ToolOutputFile Out(Output, EC, sys::fs::OF_None);
-  if (EC) {
-    reportError(createFileError(Output, EC));
-    return 1;
-  }
-
-  // Create a wrapper for device binaries and write its bitcode to the file.
-  WriteBitcodeToFile(BinaryWrapper(Target).wrapBinaries(
-                         makeArrayRef(Images.data(), Images.size())),
-                     Out.os());
-  if (Out.os().has_error()) {
-    reportError(createFileError(Output, Out.os().error()));
-    return 1;
-  }
-
-  // Success.
-  Out.keep();
-  return 0;
-}