[clang-offload-bundler] Fix some Clang-tidy modernize-use-override and Include What You Use warnings; other minor fixes

[Eugene.Zelenko]

Summary

I checked this patch on my own build on RHEL 6. Regressions were OK.

[sfantao]

Hi Eugene,

The patch looks good to me. You may wait for someone that could okay the patch to take a look too.

Thanks,
Samuel

[sfantao]

Hi Eugene,

The patch looks good to me. You may wait for someone that could okay the patch to take a look too.

Thanks,
Samuel

cfe/trunk/tools/clang-offload-bundler/ClangOffloadBundler.cpp

-//===-- clang-offload-bundler/ClangOffloadBundler.cpp - Clang format tool -===//
+//===-- clang-offload-bundler/ClangOffloadBundler.cpp ---------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief This file implements a clang-offload-bundler that bundles different
 /// files that relate with the same source code but different targets into a
 /// single one. Also the implements the opposite functionality, i.e. unbundle
 /// files previous created by this tool.
 ///
 //===----------------------------------------------------------------------===//
 
-#include "clang/Basic/FileManager.h"
 #include "clang/Basic/Version.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
+#include "llvm/ADT/Triple.h"
 #include "llvm/Bitcode/ReaderWriter.h"
+#include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
+#include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Object/Binary.h"
-#include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem.h"
+#include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
+#include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/Signals.h"
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <system_error>
+#include <vector>
 
 using namespace llvm;
 using namespace llvm::object;
 
 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 bool hasHostKind(StringRef Target) {
   StringRef Triple;
   getOffloadKindAndTriple(Target, OffloadKind, Triple);
   return OffloadKind == "host";
 }
 
 /// Generic file handler interface.
 class FileHandler {
 public:
+  FileHandler() {}
+
+  virtual ~FileHandler() {}
+
   /// Update the file handler with information from the header of the bundled
   /// file
   virtual void ReadHeader(MemoryBuffer &Input) = 0;
+
   /// Read the marker of the next bundled to be read in the file. The triple of
   /// the target associated with that bundle is returned. An empty string is
   /// returned if there are no more bundles to be read.
   virtual StringRef ReadBundleStart(MemoryBuffer &Input) = 0;
+
   /// Read the marker that closes the current bundle.
   virtual void ReadBundleEnd(MemoryBuffer &Input) = 0;
+
   /// Read the current bundle and write the result into the stream \a OS.
   virtual void ReadBundle(raw_fd_ostream &OS, MemoryBuffer &Input) = 0;
 
   /// Write the header of the bundled file to \a OS based on the information
   /// gathered from \a Inputs.
   virtual void WriteHeader(raw_fd_ostream &OS,
                            ArrayRef<std::unique_ptr<MemoryBuffer>> Inputs) = 0;
+
   /// Write the marker that initiates a bundle for the triple \a TargetTriple to
   /// \a OS.
   virtual void WriteBundleStart(raw_fd_ostream &OS, StringRef TargetTriple) = 0;
+
   /// Write the marker that closes a bundle for the triple \a TargetTriple to \a
   /// OS. Return true if any error was found.
+
   virtual bool WriteBundleEnd(raw_fd_ostream &OS, StringRef TargetTriple) = 0;
+
   /// Write the bundle from \a Input into \a OS.
   virtual void WriteBundle(raw_fd_ostream &OS, MemoryBuffer &Input) = 0;
-
-  FileHandler() {}
-  virtual ~FileHandler() {}
 };
 
 /// Handler for binary files. The bundled file will have the following format
 /// (all integers are stored in little-endian format):
 ///
 /// "OFFLOAD_BUNDLER_MAGIC_STR" (ASCII encoding of the string)
 ///
 /// NumberOfOffloadBundles (8-byte integer)
for (unsigned i = 0; i < 8; ++i) {
     uint64_t Char = (uint64_t)Data[pos + 7 - i];
     Res |= 0xffu & Char;
   }
   return Res;
 }
 
 /// Write 8-byte integers to a buffer in little-endian format.
 static void Write8byteIntegerToBuffer(raw_fd_ostream &OS, uint64_t Val) {
-
   for (unsigned i = 0; i < 8; ++i) {
     char Char = (char)(Val & 0xffu);
     OS.write(&Char, 1);
     Val >>= 8;
   }
 }
 
 class BinaryFileHandler final : public FileHandler {
   /// Information about the bundles extracted from the header.
   struct BundleInfo final {
     /// Size of the bundle.
     uint64_t Size = 0u;
     /// Offset at which the bundle starts in the bundled file.
     uint64_t Offset = 0u;
+
     BundleInfo() {}
     BundleInfo(uint64_t Size, uint64_t Offset) : Size(Size), Offset(Offset) {}
   };
+
   /// Map between a triple and the corresponding bundle information.
   StringMap<BundleInfo> BundlesInfo;
 
   /// Iterator for the bundle information that is being read.
   StringMap<BundleInfo>::iterator CurBundleInfo;
 
 public:
-  void ReadHeader(MemoryBuffer &Input) {
+  BinaryFileHandler() : FileHandler() {}
+
+  ~BinaryFileHandler() final {}
+
+  void ReadHeader(MemoryBuffer &Input) final {
     StringRef FC = Input.getBuffer();
 
     // Initialize the current bundle with the end of the container.
     CurBundleInfo = BundlesInfo.end();
 
     // Check if buffer is smaller than magic string.
     size_t ReadChars = sizeof(OFFLOAD_BUNDLER_MAGIC_STR) - 1;
     if (ReadChars > FC.size())
for (uint64_t i = 0; i < NumberOfBundles; ++i) {
 
       assert(BundlesInfo.find(Triple) == BundlesInfo.end() &&
              "Triple is duplicated??");
       BundlesInfo[Triple] = BundleInfo(Size, Offset);
     }
     // Set the iterator to where we will start to read.
     CurBundleInfo = BundlesInfo.begin();
   }
-  StringRef ReadBundleStart(MemoryBuffer &Input) {
+
+  StringRef ReadBundleStart(MemoryBuffer &Input) final {
     if (CurBundleInfo == BundlesInfo.end())
       return StringRef();
 
     return CurBundleInfo->first();
   }
-  void ReadBundleEnd(MemoryBuffer &Input) {
+
+  void ReadBundleEnd(MemoryBuffer &Input) final {
     assert(CurBundleInfo != BundlesInfo.end() && "Invalid reader info!");
     ++CurBundleInfo;
   }
-  void ReadBundle(raw_fd_ostream &OS, MemoryBuffer &Input) {
+
+  void ReadBundle(raw_fd_ostream &OS, MemoryBuffer &Input) final {
     assert(CurBundleInfo != BundlesInfo.end() && "Invalid reader info!");
     StringRef FC = Input.getBuffer();
     OS.write(FC.data() + CurBundleInfo->second.Offset,
              CurBundleInfo->second.Size);
   }
 
   void WriteHeader(raw_fd_ostream &OS,
-                   ArrayRef<std::unique_ptr<MemoryBuffer>> Inputs) {
+                   ArrayRef<std::unique_ptr<MemoryBuffer>> Inputs) final {
     // Compute size of the header.
     uint64_t HeaderSize = 0;
 
     HeaderSize += sizeof(OFFLOAD_BUNDLER_MAGIC_STR) - 1;
     HeaderSize += 8; // Number of Bundles
 
     for (auto &T : TargetNames) {
       HeaderSize += 3 * 8; // Bundle offset, Size of bundle and size of triple.
for (auto &T : TargetNames) {
       Write8byteIntegerToBuffer(OS, MB.getBufferSize());
       HeaderSize += MB.getBufferSize();
       // Size of the triple
       Write8byteIntegerToBuffer(OS, T.size());
       // Triple
       OS << T;
     }
   }
-  void WriteBundleStart(raw_fd_ostream &OS, StringRef TargetTriple) {}
-  bool WriteBundleEnd(raw_fd_ostream &OS, StringRef TargetTriple) {
+
+  void WriteBundleStart(raw_fd_ostream &OS, StringRef TargetTriple) final {}
+
+  bool WriteBundleEnd(raw_fd_ostream &OS, StringRef TargetTriple) final {
     return false;
   }
-  void WriteBundle(raw_fd_ostream &OS, MemoryBuffer &Input) {
+
+  void WriteBundle(raw_fd_ostream &OS, MemoryBuffer &Input) final {
     OS.write(Input.getBufferStart(), Input.getBufferSize());
   }
-
-  BinaryFileHandler() : FileHandler() {}
-  ~BinaryFileHandler() {}
 };
 
 /// Handler for object files. The bundles are organized by sections with a
 /// designated name.
 ///
 /// In order to bundle we create an IR file with the content of each section and
 /// use incremental linking to produce the resulting object. We also add section
 /// with a single byte to state the name of the component the main object file
class ObjectFileHandler final : public FileHandler {
   /// The name of the main input file.
   StringRef MainInputFileName;
 
   /// Iterator of the current and next section.
   section_iterator CurrentSection;
   section_iterator NextSection;
 
 public:
-  void ReadHeader(MemoryBuffer &Input) {}
-  StringRef ReadBundleStart(MemoryBuffer &Input) {
+  ObjectFileHandler(std::unique_ptr<ObjectFile> ObjIn)
+      : FileHandler(), Obj(std::move(ObjIn)),
+        CurrentSection(Obj->section_begin()),
+        NextSection(Obj->section_begin()) {}
 
+  ~ObjectFileHandler() final {}
+
+  void ReadHeader(MemoryBuffer &Input) final {}
+
+  StringRef ReadBundleStart(MemoryBuffer &Input) final {
     while (NextSection != Obj->section_end()) {
       CurrentSection = NextSection;
       ++NextSection;
 
       StringRef OffloadTriple;
       // Check if the current section name starts with the reserved prefix. If
       // so, return the triple.
       if (IsOffloadSection(*CurrentSection, OffloadTriple))
         return OffloadTriple;
     }
     return StringRef();
   }
-  void ReadBundleEnd(MemoryBuffer &Input) {}
-  void ReadBundle(raw_fd_ostream &OS, MemoryBuffer &Input) {
+
+  void ReadBundleEnd(MemoryBuffer &Input) final {}
+
+  void ReadBundle(raw_fd_ostream &OS, MemoryBuffer &Input) final {
     // If the current section has size one, that means that the content we are
     // interested in is the file itself. Otherwise it is the content of the
     // section.
     //
     // TODO: Instead of copying the input file as is, deactivate the section
     // that is no longer needed.
 
     StringRef Content;
     CurrentSection->getContents(Content);
 
     if (Content.size() < 2)
       OS.write(Input.getBufferStart(), Input.getBufferSize());
     else
       OS.write(Content.data(), Content.size());
   }
 
   void WriteHeader(raw_fd_ostream &OS,
-                   ArrayRef<std::unique_ptr<MemoryBuffer>> Inputs) {
+                   ArrayRef<std::unique_ptr<MemoryBuffer>> Inputs) final {
     assert(HostInputIndex != ~0u && "Host input index not defined.");
 
     // Record number of inputs.
     NumberOfInputs = Inputs.size();
 
     // Create an LLVM module to have the content we need to bundle.
     auto *M = new Module("clang-offload-bundle", VMContext);
     M->setTargetTriple(getTriple(TargetNames[HostInputIndex]));
     AuxModule.reset(M);
   }
-  void WriteBundleStart(raw_fd_ostream &OS, StringRef TargetTriple) {
+
+  void WriteBundleStart(raw_fd_ostream &OS, StringRef TargetTriple) final {
     ++NumberOfProcessedInputs;
 
     // Record the triple we are using, that will be used to name the section we
     // will create.
     CurrentTriple = TargetTriple;
   }
-  bool WriteBundleEnd(raw_fd_ostream &OS, StringRef TargetTriple) {
+
+  bool WriteBundleEnd(raw_fd_ostream &OS, StringRef TargetTriple) final {
     assert(NumberOfProcessedInputs <= NumberOfInputs &&
            "Processing more inputs that actually exist!");
     assert(HostInputIndex != ~0u && "Host input index not defined.");
 
     // If this is not the last output, we don't have to do anything.
     if (NumberOfProcessedInputs != NumberOfInputs)
       return false;
 
     // Create the bitcode file name to write the resulting code to. Keep it if
     // save-temps is active.
     SmallString<128> BitcodeFileName;
     if (sys::fs::createTemporaryFile("clang-offload-bundler", "bc",
                                      BitcodeFileName)) {
-      llvm::errs() << "error: unable to create temporary file.\n";
+      errs() << "error: unable to create temporary file.\n";
       return true;
     }
 
     // Dump the contents of the temporary file if that was requested.
     if (DumpTemporaryFiles) {
-      llvm::errs() << ";\n; Object file bundler IR file.\n;\n";
+      errs() << ";\n; Object file bundler IR file.\n;\n";
       AuxModule.get()->dump();
     }
 
     // Find clang in order to create the bundle binary.
-    StringRef Dir = llvm::sys::path::parent_path(BundlerExecutable);
+    StringRef Dir = sys::path::parent_path(BundlerExecutable);
 
     auto ClangBinary = sys::findProgramByName("clang", Dir);
     if (ClangBinary.getError()) {
       // Remove bitcode file.
       sys::fs::remove(BitcodeFileName);
 
-      llvm::errs() << "error: unable to find 'clang' in path.\n";
+      errs() << "error: unable to find 'clang' in path.\n";
       return true;
     }
 
     // Do the incremental linking. We write to the output file directly. So, we
     // close it and use the name to pass down to clang.
     OS.close();
     SmallString<128> TargetName = getTriple(TargetNames[HostInputIndex]);
     const char *ClangArgs[] = {"clang",
                                "-r",
                                "-target",
                                TargetName.c_str(),
                                "-o",
                                OutputFileNames.front().c_str(),
                                InputFileNames[HostInputIndex].c_str(),
                                BitcodeFileName.c_str(),
                                "-nostdlib",
                                nullptr};
 
     // If the user asked for the commands to be printed out, we do that instead
     // of executing it.
     if (PrintExternalCommands) {
-      llvm::errs() << "\"" << ClangBinary.get() << "\"";
+      errs() << "\"" << ClangBinary.get() << "\"";
       for (unsigned I = 1; ClangArgs[I]; ++I)
-        llvm::errs() << " \"" << ClangArgs[I] << "\"";
-      llvm::errs() << "\n";
+        errs() << " \"" << ClangArgs[I] << "\"";
+      errs() << "\n";
     } else {
       // Write the bitcode contents to the temporary file.
       {
         std::error_code EC;
         raw_fd_ostream BitcodeFile(BitcodeFileName, EC, sys::fs::F_None);
         if (EC) {
-          llvm::errs() << "error: unable to open temporary file.\n";
+          errs() << "error: unable to open temporary file.\n";
           return true;
         }
         WriteBitcodeToFile(AuxModule.get(), BitcodeFile);
       }
 
       bool Failed = sys::ExecuteAndWait(ClangBinary.get(), ClangArgs);
 
       // Remove bitcode file.
       sys::fs::remove(BitcodeFileName);
 
       if (Failed) {
-        llvm::errs() << "error: incremental linking by external tool failed.\n";
+        errs() << "error: incremental linking by external tool failed.\n";
         return true;
       }
     }
 
     return false;
   }
-  void WriteBundle(raw_fd_ostream &OS, MemoryBuffer &Input) {
+
+  void WriteBundle(raw_fd_ostream &OS, MemoryBuffer &Input) final {
     Module *M = AuxModule.get();
 
     // Create the new section name, it will consist of the reserved prefix
     // concatenated with the triple.
     std::string SectionName = OFFLOAD_BUNDLER_MAGIC_STR;
     SectionName += CurrentTriple;
 
     // Create the constant with the content of the section. For the input we are
if (NumberOfProcessedInputs == HostInputIndex + 1) {
                                        Input.getBufferSize()));
 
     // Create the global in the desired section. We don't want these globals in
     // the symbol table, so we mark them private.
     auto *GV = new GlobalVariable(*M, Content->getType(), /*IsConstant=*/true,
                                   GlobalVariable::PrivateLinkage, Content);
     GV->setSection(SectionName);
   }
-
-  ObjectFileHandler(std::unique_ptr<ObjectFile> ObjIn)
-      : FileHandler(), Obj(std::move(ObjIn)),
-        CurrentSection(Obj->section_begin()),
-        NextSection(Obj->section_begin()) {}
-  ~ObjectFileHandler() {}
 };
 
 /// Handler for text files. The bundled file will have the following format.
 ///
 /// "Comment OFFLOAD_BUNDLER_MAGIC_STR__START__ triple"
 /// Bundle 1
 /// "Comment OFFLOAD_BUNDLER_MAGIC_STR__END__ triple"
 /// ...
class TextFileHandler final : public FileHandler {
 
   /// String that closes a bundle.
   std::string BundleEndString;
 
   /// Number of chars read from input.
   size_t ReadChars = 0u;
 
 protected:
-  void ReadHeader(MemoryBuffer &Input) {}
-  StringRef ReadBundleStart(MemoryBuffer &Input) {
+  void ReadHeader(MemoryBuffer &Input) final {}
+
+  StringRef ReadBundleStart(MemoryBuffer &Input) final {
     StringRef FC = Input.getBuffer();
 
     // Find start of the bundle.
     ReadChars = FC.find(BundleStartString, ReadChars);
     if (ReadChars == FC.npos)
       return StringRef();
 
     // Get position of the triple.
     size_t TripleStart = ReadChars = ReadChars + BundleStartString.size();
 
     // Get position that closes the triple.
     size_t TripleEnd = ReadChars = FC.find("\n", ReadChars);
     if (TripleEnd == FC.npos)
       return StringRef();
 
     // Next time we read after the new line.
     ++ReadChars;
 
     return StringRef(&FC.data()[TripleStart], TripleEnd - TripleStart);
   }
-  void ReadBundleEnd(MemoryBuffer &Input) {
+
+  void ReadBundleEnd(MemoryBuffer &Input) final {
     StringRef FC = Input.getBuffer();
 
     // Read up to the next new line.
     assert(FC[ReadChars] == '\n' && "The bundle should end with a new line.");
 
     size_t TripleEnd = ReadChars = FC.find("\n", ReadChars + 1);
     if (TripleEnd == FC.npos)
       return;
 
     // Next time we read after the new line.
     ++ReadChars;
   }
-  void ReadBundle(raw_fd_ostream &OS, MemoryBuffer &Input) {
+
+  void ReadBundle(raw_fd_ostream &OS, MemoryBuffer &Input) final {
     StringRef FC = Input.getBuffer();
     size_t BundleStart = ReadChars;
 
     // Find end of the bundle.
     size_t BundleEnd = ReadChars = FC.find(BundleEndString, ReadChars);
 
     StringRef Bundle(&FC.data()[BundleStart], BundleEnd - BundleStart);
     OS << Bundle;
   }
 
   void WriteHeader(raw_fd_ostream &OS,
-                   ArrayRef<std::unique_ptr<MemoryBuffer>> Inputs) {}
-  void WriteBundleStart(raw_fd_ostream &OS, StringRef TargetTriple) {
+                   ArrayRef<std::unique_ptr<MemoryBuffer>> Inputs) final {}
+
+  void WriteBundleStart(raw_fd_ostream &OS, StringRef TargetTriple) final {
     OS << BundleStartString << TargetTriple << "\n";
   }
-  bool WriteBundleEnd(raw_fd_ostream &OS, StringRef TargetTriple) {
+
+  bool WriteBundleEnd(raw_fd_ostream &OS, StringRef TargetTriple) final {
     OS << BundleEndString << TargetTriple << "\n";
     return false;
   }
-  void WriteBundle(raw_fd_ostream &OS, MemoryBuffer &Input) {
+
+  void WriteBundle(raw_fd_ostream &OS, MemoryBuffer &Input) final {
     OS << Input.getBuffer();
   }
 
 public:
   TextFileHandler(StringRef Comment)
       : FileHandler(), Comment(Comment), ReadChars(0) {
     BundleStartString =
         "\n" + Comment.str() + " " OFFLOAD_BUNDLER_MAGIC_STR "__START__ ";
if (FilesType == "s")
     return new TextFileHandler(/*Comment=*/"#");
   if (FilesType == "o")
     return CreateObjectFileHandler(FirstInput);
   if (FilesType == "gch")
     return new BinaryFileHandler();
   if (FilesType == "ast")
     return new BinaryFileHandler();
 
-  llvm::errs() << "error: invalid file type specified.\n";
+  errs() << "error: invalid file type specified.\n";
   return nullptr;
 }
 
 /// Bundle the files. Return true if an error was found.
 static bool BundleFiles() {
   std::error_code EC;
 
   // Create output file.
   raw_fd_ostream OutputFile(OutputFileNames.front(), EC, sys::fs::F_None);
 
   if (EC) {
-    llvm::errs() << "error: Can't open file " << OutputFileNames.front()
-                 << ".\n";
+    errs() << "error: Can't open file " << OutputFileNames.front() << ".\n";
     return true;
   }
 
   // Open input files.
   std::vector<std::unique_ptr<MemoryBuffer>> InputBuffers(
       InputFileNames.size());
 
   unsigned Idx = 0;
   for (auto &I : InputFileNames) {
     ErrorOr<std::unique_ptr<MemoryBuffer>> CodeOrErr =
         MemoryBuffer::getFileOrSTDIN(I);
     if (std::error_code EC = CodeOrErr.getError()) {
-      llvm::errs() << "error: Can't open file " << I << ": " << EC.message()
-                   << "\n";
+      errs() << "error: Can't open file " << I << ": " << EC.message() << "\n";
       return true;
     }
     InputBuffers[Idx++] = std::move(CodeOrErr.get());
   }
 
   // Get the file handler. We use the host buffer as reference.
   assert(HostInputIndex != ~0u && "Host input index undefined??");
   std::unique_ptr<FileHandler> FH;

 }
 
 // Unbundle the files. Return true if an error was found.
 static bool UnbundleFiles() {
   // Open Input file.
   ErrorOr<std::unique_ptr<MemoryBuffer>> CodeOrErr =
       MemoryBuffer::getFileOrSTDIN(InputFileNames.front());
   if (std::error_code EC = CodeOrErr.getError()) {
-    llvm::errs() << "error: Can't open file " << InputFileNames.front() << ": "
-                 << EC.message() << "\n";
+    errs() << "error: Can't open file " << InputFileNames.front() << ": "
     return true;
   }
 
   MemoryBuffer &Input = *CodeOrErr.get();
 
   // Select the right files handler.
   std::unique_ptr<FileHandler> FH;
   FH.reset(CreateFileHandler(Input));
while (!Worklist.empty()) {
     if (Output == Worklist.end()) {
       continue;
     }
 
     // Check if the output file can be opened and copy the bundle to it.
     std::error_code EC;
     raw_fd_ostream OutputFile(Output->second, EC, sys::fs::F_None);
     if (EC) {
-      llvm::errs() << "error: Can't open file " << Output->second << ": "
-                   << EC.message() << "\n";
+      errs() << "error: Can't open file " << Output->second << ": "
       return true;
     }
     FH.get()->ReadBundle(OutputFile, Input);
     FH.get()->ReadBundleEnd(Input);
     Worklist.erase(Output);
 
     // Record if we found the host bundle.
     if (hasHostKind(CurTriple))
       FoundHostBundle = true;
   }
 
   // If no bundles were found, assume the input file is the host bundle and
   // create empty files for the remaining targets.
   if (Worklist.size() == TargetNames.size()) {
     for (auto &E : Worklist) {
       std::error_code EC;
       raw_fd_ostream OutputFile(E.second, EC, sys::fs::F_None);
       if (EC) {
-        llvm::errs() << "error: Can't open file " << E.second << ": "
-                     << EC.message() << "\n";
+        errs() << "error: Can't open file " << E.second << ": " << EC.message()
+               << "\n";
         return true;
       }
 
       // If this entry has a host kind, copy the input file to the output file.
       if (hasHostKind(E.first()))
         OutputFile.write(Input.getBufferStart(), Input.getBufferSize());
     }
     return false;
   }
 
   // If we found elements, we emit an error if none of those were for the host.
   if (!FoundHostBundle) {
-    llvm::errs() << "error: Can't find bundle for the host target\n";
+    errs() << "error: Can't find bundle for the host target\n";
     return true;
   }
 
   // If we still have any elements in the worklist, create empty files for them.
   for (auto &E : Worklist) {
     std::error_code EC;
     raw_fd_ostream OutputFile(E.second, EC, sys::fs::F_None);
     if (EC) {
-      llvm::errs() << "error: Can't open file " << E.second << ": "
-                   << EC.message() << "\n";
+      errs() << "error: Can't open file " << E.second << ": "  << EC.message()
+             << "\n";
       return true;
     }
   }
 
   return false;
 }
 
 static void PrintVersion() {
   raw_ostream &OS = outs();
   OS << clang::getClangToolFullVersion("clang-offload-bundler") << '\n';
 }
 
 int main(int argc, const char **argv) {
-  llvm::sys::PrintStackTraceOnErrorSignal(argv[0]);
+  sys::PrintStackTraceOnErrorSignal(argv[0]);
 
   cl::HideUnrelatedOptions(ClangOffloadBundlerCategory);
   cl::SetVersionPrinter(PrintVersion);
   cl::ParseCommandLineOptions(
       argc, argv,
       "A tool to bundle several input files of the specified type <type> \n"
       "referring to the same source file but different targets into a single \n"
       "one. The resulting file can also be unbundled into different files by \n"
       "this tool if -unbundle is provided.\n");
 
   if (Help)
     cl::PrintHelpMessage();
 
   bool Error = false;
   if (Unbundle) {
     if (InputFileNames.size() != 1) {
       Error = true;
-      llvm::errs()
-          << "error: only one input file supported in unbundling mode.\n";
+      errs() << "error: only one input file supported in unbundling mode.\n";
     }
     if (OutputFileNames.size() != TargetNames.size()) {
       Error = true;
-      llvm::errs() << "error: number of output files and targets should match "
-                      "in unbundling mode.\n";
+      errs() << "error: number of output files and targets should match in "
+                "unbundling mode.\n";
     }
   } else {
     if (OutputFileNames.size() != 1) {
       Error = true;
-      llvm::errs()
-          << "error: only one output file supported in bundling mode.\n";
+      errs() << "error: only one output file supported in bundling mode.\n";
     }
     if (InputFileNames.size() != TargetNames.size()) {
       Error = true;
-      llvm::errs() << "error: number of input files and targets should match "
-                      "in bundling mode.\n";
+      errs() << "error: number of input files and targets should match in "
+                "bundling mode.\n";
     }
   }
 
   // Verify that the offload kinds and triples are known. We also check that we
   // have exactly one host target.
   unsigned Index = 0u;
   unsigned HostTargetNum = 0u;
   for (StringRef Target : TargetNames) {
KindIsValid = KindIsValid &&
                       .Default(false);
 
     bool TripleIsValid = !Triple.empty();
     llvm::Triple T(Triple);
     TripleIsValid &= T.getArch() != Triple::UnknownArch;
 
     if (!KindIsValid || !TripleIsValid) {
       Error = true;
-      llvm::errs() << "error: invalid target '" << Target << "'";
+      errs() << "error: invalid target '" << Target << "'";
 
       if (!KindIsValid)
-        llvm::errs() << ", unknown offloading kind '" << Kind << "'";
+        errs() << ", unknown offloading kind '" << Kind << "'";
       if (!TripleIsValid)
-        llvm::errs() << ", unknown target triple '" << Triple << "'";
-      llvm::errs() << ".\n";
+        errs() << ", unknown target triple '" << Triple << "'";
+      errs() << ".\n";
     }
 
     if (KindIsValid && Kind == "host") {
       ++HostTargetNum;
       // Save the index of the input that refers to the host.
       HostInputIndex = Index;
     }
 
     ++Index;
   }
 
   if (HostTargetNum != 1) {
     Error = true;
-    llvm::errs() << "error: expecting exactly one host target but got "
-                 << HostTargetNum << ".\n";
+    errs() << "error: expecting exactly one host target but got "
   }
 
   if (Error)
     return 1;
 
   // Save the current executable directory as it will be useful to find other
   // tools.
-  BundlerExecutable =
-      llvm::sys::fs::getMainExecutable(argv[0], &BundlerExecutable);
+  BundlerExecutable = sys::fs::getMainExecutable(argv[0], &BundlerExecutable);
 
   return Unbundle ? UnbundleFiles() : BundleFiles();
 }