[Clang][Bundler] Error reporting improvements

[sdmitriev]

Summary

• Changed FileHandler read/write methods to return llvm::Error
• Using unified way of reporting errors
• Removed trailing '.' from the error messages

[Hahnfeld]

This changes error messages, so I'd say it's not NFC.

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

42–45

The code still uses (in the order of marked includes)

• std::unique_ptr
• std::string
• std::error_code
• std::vector,

so I don't think these lines should be removed. Same goes for assert and probably also cstddef / cstdint (uint64_t?)

[sdmitriev]

Addressed review comments.

[sdmitriev]

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

42–45

Right. Restored required system includes.

[MaskRay]

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

898

I think trailing full stop is uncommon in error messages.

[sdmitriev]

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

898

Maybe., but all error messages in this tool seem to be consistent in that sense)) Do you suggest removing trailing '.' from all error messages?

[sdmitriev]

Removed trailing '.' from error messages and added few additional changes for better error handling.

[sdmitriev]

Any comments?

[Hahnfeld]

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

42–45

vector is still removed which is definitely used. Are you 100% sure that algorithm and cstddef are not needed?

[sdmitriev]

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

42–45

I have replaced all uses of vector with SmallVector.

Are you 100% sure that algorithm and cstddef are not needed?

Ok, I will add algorithm and cstddef back:)

[Hahnfeld]

Also, there should be a summary of the changes in here.

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

42–45

If you want to replace vector by SmallVector, this must be its own revision.

[sdmitriev]

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

42–45

Must? Can you show any document/link explaining this?
I have no problem with doing that in a separate commit, not a big deal, just want to see why it has to be done that way.

[Hahnfeld]

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

42–45

This is common practice for reviews: Only one change per patch and split into smaller patches if possible and logically appropriate.

I can't quote a written requirement, but the Developer Policy section about code reviews mentions splitting patches and there's a whole section about Incremental Development.

[sdmitriev]

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

42–45

I have reverted vector -> SmallVector change.

[sdmitriev]

I think I have addressed all comments posted so far. Do you have more notes/comments/suggestions?

[sdmitriev]

Ping

[sdmitriev]

Rebase

[sdmitriev]

Ping.

[sdmitriev]

Ping.

[sdmitriev]

Ping.

[ABataev]

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

132–136

Do we really need an inner Optional here?

[sdmitriev]

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

132–136

The idea was to return StringRef with bundle name when we have still have bundles and None when there are no more bundles in the file (BTW comment has to be updated to describe this). But I can restore the old convention where empty bundle name means 'no more bundles' in the file. In terms of functionality that would be the same, though use of Optional<...> makes intentions more explicit))

[sdmitriev]

Rebased patch.

[sdmitriev]

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

132–136

I have updated comment to describe the intended behavior.
@ABataev do you insist on removing inner Optional<> and restoring the current convention where empty string means the end of bundles in the file?

[ABataev]

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

132–136

The problem here is that Expected already handles the state and we have inner Optional for the same reason. Can we reuse Expected to indicate that there are no more bundles?

[sdmitriev]

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

132–136

Well, Expected encodes two possible states (either Error or Value), but we need to encode three states - Error, Value or None. I do not have ideas how to do it without adding inner Optional. If you have, please share.

[ABataev]

LG

clang/test/Driver/clang-offload-bundler.c

 // CK-HELP: {{.*}}gch {{.*}}- precompiled-header
 // CK-HELP: {{.*}}ast {{.*}}- clang AST file
 // CK-HELP: {{.*}}-unbundle {{.*}}- Unbundle bundled file into several output files.
 
 //
 // Check errors.
 //
 // RUN: not clang-offload-bundler -type=i -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -inputs=%t.i,%t.tgt1,%t.tgt2 -outputs=%t.bundle.i -unbundle 2>&1 | FileCheck %s --check-prefix CK-ERR1
-// CK-ERR1: error: only one input file supported in unbundling mode.
-// CK-ERR1: error: number of output files and targets should match in unbundling mode.
+// CK-ERR1: error: only one input file supported in unbundling mode
+// CK-ERR1: error: number of output files and targets should match in unbundling mode
 
 // RUN: not clang-offload-bundler -type=i -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu -inputs=%t.i,%t.tgt1,%t.tgt2 -outputs=%t.bundle.i 2>&1 | FileCheck %s --check-prefix CK-ERR2
 // RUN: not clang-offload-bundler -type=i -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -inputs=%t.i,%t.tgt1 -outputs=%t.bundle.i 2>&1 | FileCheck %s --check-prefix CK-ERR2
-// CK-ERR2: error: number of input files and targets should match in bundling mode.
+// CK-ERR2: error: number of input files and targets should match in bundling mode
 
 // RUN: not clang-offload-bundler -type=i -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -outputs=%t.i,%t.tgt1,%t.tgt2 -inputs=%t.bundle.i 2>&1 | FileCheck %s --check-prefix CK-ERR3
-// CK-ERR3: error: only one output file supported in bundling mode.
-// CK-ERR3: error: number of input files and targets should match in bundling mode.
+// CK-ERR3: error: only one output file supported in bundling mode
+// CK-ERR3: error: number of input files and targets should match in bundling mode
 
 // RUN: not clang-offload-bundler -type=i -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu -outputs=%t.i,%t.tgt1,%t.tgt2 -inputs=%t.bundle.i -unbundle 2>&1 | FileCheck %s --check-prefix CK-ERR4
 // RUN: not clang-offload-bundler -type=i -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -outputs=%t.i,%t.tgt1 -inputs=%t.bundle.i -unbundle 2>&1 | FileCheck %s --check-prefix CK-ERR4
-// CK-ERR4: error: number of output files and targets should match in unbundling mode.
+// CK-ERR4: error: number of output files and targets should match in unbundling mode
 
-// RUN: not clang-offload-bundler -type=i -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -inputs=%t.i,%t.tgt1,%t.tgt2.notexist -outputs=%t.bundle.i 2>&1 | FileCheck %s --check-prefix CK-ERR5
-// RUN: not clang-offload-bundler -type=i -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -outputs=%t.i,%t.tgt1,%t.tgt2 -inputs=%t.bundle.i.notexist -unbundle 2>&1 | FileCheck %s --check-prefix CK-ERR5
-// CK-ERR5: error: Can't open file {{.+}}.notexist: {{N|n}}o such file or directory
+// RUN: not clang-offload-bundler -type=i -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -inputs=%t.i,%t.tgt1,%t.tgt2.notexist -outputs=%t.bundle.i 2>&1 | FileCheck %s -DFILE=%t.tgt2.notexist --check-prefix CK-ERR5
+// RUN: not clang-offload-bundler -type=i -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -outputs=%t.i,%t.tgt1,%t.tgt2 -inputs=%t.bundle.i.notexist -unbundle 2>&1 | FileCheck %s -DFILE=%t.bundle.i.notexist --check-prefix CK-ERR5
+// CK-ERR5: error: '[[FILE]]': {{N|n}}o such file or directory
 
-// RUN: not clang-offload-bundler -type=invalid -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -inputs=%t.i,%t.tgt1,%t.tgt2 -outputs=%t.bundle.i 2>&1 | FileCheck %s --check-prefix CK-ERR6
-// CK-ERR6: error: invalid file type specified.
+// RUN: not clang-offload-bundler -type=invalid -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -inputs=%t.i,%t.tgt1,%t.tgt2 -outputs=%t.bundle.i 2>&1 | FileCheck %s -DTYPE=invalid --check-prefix CK-ERR6
+// CK-ERR6: error: '[[TYPE]]': invalid file type specified
 
 // RUN: not clang-offload-bundler 2>&1 | FileCheck %s --check-prefix CK-ERR7
 // CK-ERR7-DAG: clang-offload-bundler: for the --type option: must be specified at least once!
 // CK-ERR7-DAG: clang-offload-bundler: for the --inputs option: must be specified at least once!
 // CK-ERR7-DAG: clang-offload-bundler: for the --outputs option: must be specified at least once!
 // CK-ERR7-DAG: clang-offload-bundler: for the --targets option: must be specified at least once!
 
 // RUN: not clang-offload-bundler -type=i -targets=hxst-powerpcxxle-ibm-linux-gnu,openxp-pxxerpc64le-ibm-linux-gnu,xpenmp-x86_xx-pc-linux-gnu -inputs=%t.i,%t.tgt1,%t.tgt2 -outputs=%t.bundle.i 2>&1 | FileCheck %s --check-prefix CK-ERR8
-// CK-ERR8: error: invalid target 'hxst-powerpcxxle-ibm-linux-gnu', unknown offloading kind 'hxst', unknown target triple 'powerpcxxle-ibm-linux-gnu'.
-// CK-ERR8: error: invalid target 'openxp-pxxerpc64le-ibm-linux-gnu', unknown offloading kind 'openxp', unknown target triple 'pxxerpc64le-ibm-linux-gnu'.
-// CK-ERR8: error: invalid target 'xpenmp-x86_xx-pc-linux-gnu', unknown offloading kind 'xpenmp', unknown target triple 'x86_xx-pc-linux-gnu'.
+// CK-ERR8: error: invalid target 'hxst-powerpcxxle-ibm-linux-gnu', unknown offloading kind 'hxst', unknown target triple 'powerpcxxle-ibm-linux-gnu'
+// CK-ERR8: error: invalid target 'openxp-pxxerpc64le-ibm-linux-gnu', unknown offloading kind 'openxp', unknown target triple 'pxxerpc64le-ibm-linux-gnu'
+// CK-ERR8: error: invalid target 'xpenmp-x86_xx-pc-linux-gnu', unknown offloading kind 'xpenmp', unknown target triple 'x86_xx-pc-linux-gnu'
 
 // RUN: not clang-offload-bundler -type=i -targets=openmp-powerpc64le-linux,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -inputs=%t.i,%t.tgt1,%t.tgt2 -outputs=%t.bundle.i 2>&1 | FileCheck %s --check-prefix CK-ERR9A
 // RUN: not clang-offload-bundler -type=i -targets=host-%itanium_abi_triple,host-%itanium_abi_triple,openmp-x86_64-pc-linux-gnu -inputs=%t.i,%t.tgt1,%t.tgt2 -outputs=%t.bundle.i 2>&1 | FileCheck %s --check-prefix CK-ERR9B
-// CK-ERR9A: error: expecting exactly one host target but got 0.
-// CK-ERR9B: error: expecting exactly one host target but got 2.
+// CK-ERR9A: error: expecting exactly one host target but got 0
+// CK-ERR9B: error: expecting exactly one host target but got 2
 
 //
 // Check text bundle. This is a readable format, so we check for the format we expect to find.
 //
 // RUN: clang-offload-bundler -type=i -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -inputs=%t.i,%t.tgt1,%t.tgt2 -outputs=%t.bundle3.i
 // RUN: clang-offload-bundler -type=ii -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -inputs=%t.ii,%t.tgt1,%t.tgt2 -outputs=%t.bundle3.ii
 // RUN: clang-offload-bundler -type=ll -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -inputs=%t.ll,%t.tgt1,%t.tgt2 -outputs=%t.bundle3.ll
 // RUN: clang-offload-bundler -type=s -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -inputs=%t.s,%t.tgt1,%t.tgt2 -outputs=%t.bundle3.s

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

 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Errc.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 "llvm/Support/StringSaver.h"
+#include "llvm/Support/WithColor.h"
+#include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <memory>
 #include <string>
 #include <system_error>
+#include <utility>
 
 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 cl::OptionCategory

 /// 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;
+  /// file.
+  virtual Error 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 of the next bundled to be read in the file. The bundle
+  /// name is returned if there is one in the file, or `None` if there are no
+  /// more bundles to be read.
+  virtual Expected<Optional<StringRef>>
+  ReadBundleStart(MemoryBuffer &Input) = 0;
 
   /// Read the marker that closes the current bundle.
-  virtual void ReadBundleEnd(MemoryBuffer &Input) = 0;
+  virtual Error 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;
+  virtual Error 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,
+  virtual Error 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;
+  virtual Error 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;
+  /// OS.
+  virtual Error 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;
+  virtual Error WriteBundle(raw_fd_ostream &OS, MemoryBuffer &Input) = 0;
 };
 
 /// 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)
class BinaryFileHandler final : public FileHandler {
   StringMap<BundleInfo>::iterator CurBundleInfo;
   StringMap<BundleInfo>::iterator NextBundleInfo;
 
 public:
   BinaryFileHandler() : FileHandler() {}
 
   ~BinaryFileHandler() final {}
 
-  void ReadHeader(MemoryBuffer &Input) final {
+  Error 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())
-      return;
+      return Error::success();
 
     // Check if no magic was found.
     StringRef Magic(FC.data(), sizeof(OFFLOAD_BUNDLER_MAGIC_STR) - 1);
     if (!Magic.equals(OFFLOAD_BUNDLER_MAGIC_STR))
-      return;
+      return Error::success();
 
     // Read number of bundles.
     if (ReadChars + 8 > FC.size())
-      return;
+      return Error::success();
 
     uint64_t NumberOfBundles = Read8byteIntegerFromBuffer(FC, ReadChars);
     ReadChars += 8;
 
     // Read bundle offsets, sizes and triples.
     for (uint64_t i = 0; i < NumberOfBundles; ++i) {
 
       // Read offset.
       if (ReadChars + 8 > FC.size())
-        return;
+        return Error::success();
 
       uint64_t Offset = Read8byteIntegerFromBuffer(FC, ReadChars);
       ReadChars += 8;
 
       // Read size.
       if (ReadChars + 8 > FC.size())
-        return;
+        return Error::success();
 
       uint64_t Size = Read8byteIntegerFromBuffer(FC, ReadChars);
       ReadChars += 8;
 
       // Read triple size.
       if (ReadChars + 8 > FC.size())
-        return;
+        return Error::success();
 
       uint64_t TripleSize = Read8byteIntegerFromBuffer(FC, ReadChars);
       ReadChars += 8;
 
       // Read triple.
       if (ReadChars + TripleSize > FC.size())
-        return;
+        return Error::success();
 
       StringRef Triple(&FC.data()[ReadChars], TripleSize);
       ReadChars += TripleSize;
 
       // Check if the offset and size make sense.
       if (!Offset || Offset + Size > FC.size())
-        return;
+        return Error::success();
 
       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.end();
     NextBundleInfo = BundlesInfo.begin();
+    return Error::success();
   }
 
-  StringRef ReadBundleStart(MemoryBuffer &Input) final {
+  Expected<Optional<StringRef>> ReadBundleStart(MemoryBuffer &Input) final {
     if (NextBundleInfo == BundlesInfo.end())
-      return StringRef();
+      return None;
     CurBundleInfo = NextBundleInfo++;
     return CurBundleInfo->first();
   }
 
-  void ReadBundleEnd(MemoryBuffer &Input) final {
+  Error ReadBundleEnd(MemoryBuffer &Input) final {
     assert(CurBundleInfo != BundlesInfo.end() && "Invalid reader info!");
+    return Error::success();
   }
 
-  void ReadBundle(raw_fd_ostream &OS, MemoryBuffer &Input) final {
+  Error 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);
+    return Error::success();
   }
 
-  void WriteHeader(raw_fd_ostream &OS,
+  Error WriteHeader(raw_fd_ostream &OS,
                     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.
       HeaderSize += T.size(); // The triple.
     }
 
     // Write to the buffer the header.
     OS << OFFLOAD_BUNDLER_MAGIC_STR;
 
     Write8byteIntegerToBuffer(OS, TargetNames.size());
 
     unsigned Idx = 0;
     for (auto &T : TargetNames) {
-      MemoryBuffer &MB = *Inputs[Idx++].get();
+      MemoryBuffer &MB = *Inputs[Idx++];
       // Bundle offset.
       Write8byteIntegerToBuffer(OS, HeaderSize);
       // Size of the bundle (adds to the next bundle's offset)
       Write8byteIntegerToBuffer(OS, MB.getBufferSize());
       HeaderSize += MB.getBufferSize();
       // Size of the triple
       Write8byteIntegerToBuffer(OS, T.size());
       // Triple
       OS << T;
     }
+    return Error::success();
   }
 
-  void WriteBundleStart(raw_fd_ostream &OS, StringRef TargetTriple) final {}
+  Error WriteBundleStart(raw_fd_ostream &OS, StringRef TargetTriple) final {
+    return Error::success();
+  }
 
-  bool WriteBundleEnd(raw_fd_ostream &OS, StringRef TargetTriple) final {
-    return false;
+  Error WriteBundleEnd(raw_fd_ostream &OS, StringRef TargetTriple) final {
+    return Error::success();
   }
 
-  void WriteBundle(raw_fd_ostream &OS, MemoryBuffer &Input) final {
+  Error WriteBundle(raw_fd_ostream &OS, MemoryBuffer &Input) final {
     OS.write(Input.getBufferStart(), Input.getBufferSize());
+    return Error::success();
   }
 };
 
 /// 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.
-///
 /// To unbundle, we just copy the contents of the designated section.
 class ObjectFileHandler final : public FileHandler {
 
   /// The object file we are currently dealing with.
   std::unique_ptr<ObjectFile> Obj;
 
   /// Return the input file contents.
   StringRef getInputFileContents() const { return Obj->getData(); }
 
-  /// Return true if the provided section is an offload section and return the
-  /// triple by reference.
-  static bool IsOffloadSection(SectionRef CurSection,
-                               StringRef &OffloadTriple) {
-    StringRef SectionName;
-    if (Expected<StringRef> NameOrErr = CurSection.getName())
-      SectionName = *NameOrErr;
-    else
-      consumeError(NameOrErr.takeError());
-
-    if (SectionName.empty())
-      return false;
+  /// Return bundle name (<kind>-<triple>) if the provided section is an offload
+  /// section.
+  static Expected<Optional<StringRef>> IsOffloadSection(SectionRef CurSection) {
+    Expected<StringRef> NameOrErr = CurSection.getName();
+    if (!NameOrErr)
+      return NameOrErr.takeError();
 
     // If it does not start with the reserved suffix, just skip this section.
-    if (!SectionName.startswith(OFFLOAD_BUNDLER_MAGIC_STR))
-      return false;
+    if (!NameOrErr->startswith(OFFLOAD_BUNDLER_MAGIC_STR))
+      return None;
 
     // Return the triple that is right after the reserved prefix.
-    OffloadTriple = SectionName.substr(sizeof(OFFLOAD_BUNDLER_MAGIC_STR) - 1);
-    return true;
+    return NameOrErr->substr(sizeof(OFFLOAD_BUNDLER_MAGIC_STR) - 1);
   }
 
   /// Total number of inputs.
   unsigned NumberOfInputs = 0;
 
   /// Total number of processed inputs, i.e, inputs that were already
   /// read from the buffers.
   unsigned NumberOfProcessedInputs = 0;
 
   /// Iterator of the current and next section.
   section_iterator CurrentSection;
   section_iterator NextSection;
 
 public:
   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 {}
+  Error ReadHeader(MemoryBuffer &Input) final { return Error::success(); }
 
-  StringRef ReadBundleStart(MemoryBuffer &Input) final {
+  Expected<Optional<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;
+      Expected<Optional<StringRef>> TripleOrErr =
+          IsOffloadSection(*CurrentSection);
+      if (!TripleOrErr)
+        return TripleOrErr.takeError();
+      if (*TripleOrErr)
+        return **TripleOrErr;
     }
-    return StringRef();
+    return None;
   }
 
-  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.
+  Error ReadBundleEnd(MemoryBuffer &Input) final { return Error::success(); }
 
+  Error ReadBundle(raw_fd_ostream &OS, MemoryBuffer &Input) final {
     Expected<StringRef> Content = CurrentSection->getContents();
-    if (!Content) {
-      consumeError(Content.takeError());
-      return;
-    }
+    if (!Content)
+      return Content.takeError();
 
     OS.write(Content->data(), Content->size());
+    return Error::success();
   }
 
-  void WriteHeader(raw_fd_ostream &OS,
+  Error WriteHeader(raw_fd_ostream &OS,
                     ArrayRef<std::unique_ptr<MemoryBuffer>> Inputs) final {
     assert(HostInputIndex != ~0u && "Host input index not defined.");
 
     // Record number of inputs.
     NumberOfInputs = Inputs.size();
+    return Error::success();
   }
 
-  void WriteBundleStart(raw_fd_ostream &OS, StringRef TargetTriple) final {
+  Error WriteBundleStart(raw_fd_ostream &OS, StringRef TargetTriple) final {
     ++NumberOfProcessedInputs;
+    return Error::success();
   }
 
-  bool WriteBundleEnd(raw_fd_ostream &OS, StringRef TargetTriple) final {
+  Error 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;
+      return Error::success();
 
     // Find llvm-objcopy in order to create the bundle binary.
     ErrorOr<std::string> Objcopy = sys::findProgramByName(
         "llvm-objcopy", sys::path::parent_path(BundlerExecutable));
     if (!Objcopy)
       Objcopy = sys::findProgramByName("llvm-objcopy");
-    if (!Objcopy) {
-      errs() << "error: unable to find 'llvm-objcopy' in path.\n";
-      return true;
-    }
+    if (!Objcopy)
+      return createStringError(Objcopy.getError(),
+                               "unable to find 'llvm-objcopy' in path");
 
     // We write to the output file directly. So, we close it and use the name
     // to pass down to llvm-objcopy.
     OS.close();
 
     // Compose command line for the objcopy tool.
     BumpPtrAllocator Alloc;
     StringSaver SS{Alloc};
     SmallVector<StringRef, 8u> ObjcopyArgs{"llvm-objcopy"};
     for (unsigned I = 0; I < NumberOfInputs; ++I)
       ObjcopyArgs.push_back(SS.save(Twine("--add-section=") +
                                     OFFLOAD_BUNDLER_MAGIC_STR + TargetNames[I] +
                                     "=" + InputFileNames[I]));
     ObjcopyArgs.push_back(InputFileNames[HostInputIndex]);
     ObjcopyArgs.push_back(OutputFileNames.front());
 
     // If the user asked for the commands to be printed out, we do that instead
     // of executing it.
     if (PrintExternalCommands) {
-      errs() << "\"" << Objcopy.get() << "\"";
+      errs() << "\"" << *Objcopy << "\"";
       for (StringRef Arg : drop_begin(ObjcopyArgs, 1))
         errs() << " \"" << Arg << "\"";
       errs() << "\n";
     } else {
-      if (sys::ExecuteAndWait(Objcopy.get(), ObjcopyArgs)) {
-        errs() << "error: llvm-objcopy tool failed.\n";
-        return true;
-      }
+      if (sys::ExecuteAndWait(*Objcopy, ObjcopyArgs))
+        return createStringError(inconvertibleErrorCode(),
+                                 "'llvm-objcopy' tool failed");
     }
 
-    return false;
+    return Error::success();
   }
 
-  void WriteBundle(raw_fd_ostream &OS, MemoryBuffer &Input) final {}
+  Error WriteBundle(raw_fd_ostream &OS, MemoryBuffer &Input) final {
+    return Error::success();
+  }
 };
 
 /// 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) final {}
+  Error ReadHeader(MemoryBuffer &Input) final { return Error::success(); }
 
-  StringRef ReadBundleStart(MemoryBuffer &Input) final {
+  Expected<Optional<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();
+      return None;
 
     // 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();
+      return None;
 
     // Next time we read after the new line.
     ++ReadChars;
 
     return StringRef(&FC.data()[TripleStart], TripleEnd - TripleStart);
   }
 
-  void ReadBundleEnd(MemoryBuffer &Input) final {
+  Error 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;
-
+    if (TripleEnd != FC.npos)
       // Next time we read after the new line.
       ++ReadChars;
+
+    return Error::success();
   }
 
-  void ReadBundle(raw_fd_ostream &OS, MemoryBuffer &Input) final {
+  Error 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;
+
+    return Error::success();
   }
 
-  void WriteHeader(raw_fd_ostream &OS,
-                   ArrayRef<std::unique_ptr<MemoryBuffer>> Inputs) final {}
+  Error WriteHeader(raw_fd_ostream &OS,
+                    ArrayRef<std::unique_ptr<MemoryBuffer>> Inputs) final {
+    return Error::success();
+  }
 
-  void WriteBundleStart(raw_fd_ostream &OS, StringRef TargetTriple) final {
+  Error WriteBundleStart(raw_fd_ostream &OS, StringRef TargetTriple) final {
     OS << BundleStartString << TargetTriple << "\n";
+    return Error::success();
   }
 
-  bool WriteBundleEnd(raw_fd_ostream &OS, StringRef TargetTriple) final {
+  Error WriteBundleEnd(raw_fd_ostream &OS, StringRef TargetTriple) final {
     OS << BundleEndString << TargetTriple << "\n";
-    return false;
+    return Error::success();
   }
 
-  void WriteBundle(raw_fd_ostream &OS, MemoryBuffer &Input) final {
+  Error WriteBundle(raw_fd_ostream &OS, MemoryBuffer &Input) final {
     OS << Input.getBuffer();
+    return Error::success();
   }
 
 public:
   TextFileHandler(StringRef Comment)
       : FileHandler(), Comment(Comment), ReadChars(0) {
     BundleStartString =
         "\n" + Comment.str() + " " OFFLOAD_BUNDLER_MAGIC_STR "__START__ ";
     BundleEndString =
         "\n" + Comment.str() + " " OFFLOAD_BUNDLER_MAGIC_STR "__END__ ";
   }
 };
 
 /// Return an appropriate object file handler. We use the specific object
 /// handler if we know how to deal with that format, otherwise we use a default
 /// binary file handler.
-static FileHandler *CreateObjectFileHandler(MemoryBuffer &FirstInput) {
+static std::unique_ptr<FileHandler>
+CreateObjectFileHandler(MemoryBuffer &FirstInput) {
   // Check if the input file format is one that we know how to deal with.
   Expected<std::unique_ptr<Binary>> BinaryOrErr = createBinary(FirstInput);
 
   // We only support regular object files. If failed to open the input as a
   // known binary or this is not an object file use the default binary handler.
   if (errorToBool(BinaryOrErr.takeError()) || !isa<ObjectFile>(*BinaryOrErr))
-    return new BinaryFileHandler();
+    return std::make_unique<BinaryFileHandler>();
 
   // Otherwise create an object file handler. The handler will be owned by the
   // client of this function.
-  return new ObjectFileHandler(
+  return std::make_unique<ObjectFileHandler>(
       std::unique_ptr<ObjectFile>(cast<ObjectFile>(BinaryOrErr->release())));
 }
 
 /// Return an appropriate handler given the input files and options.
-static FileHandler *CreateFileHandler(MemoryBuffer &FirstInput) {
+static Expected<std::unique_ptr<FileHandler>>
+CreateFileHandler(MemoryBuffer &FirstInput) {
   if (FilesType == "i")
-    return new TextFileHandler(/*Comment=*/"//");
+    return std::make_unique<TextFileHandler>(/*Comment=*/"//");
   if (FilesType == "ii")
-    return new TextFileHandler(/*Comment=*/"//");
+    return std::make_unique<TextFileHandler>(/*Comment=*/"//");
   if (FilesType == "cui")
-    return new TextFileHandler(/*Comment=*/"//");
+    return std::make_unique<TextFileHandler>(/*Comment=*/"//");
   // TODO: `.d` should be eventually removed once `-M` and its variants are
   // handled properly in offload compilation.
   if (FilesType == "d")
-    return new TextFileHandler(/*Comment=*/"#");
+    return std::make_unique<TextFileHandler>(/*Comment=*/"#");
   if (FilesType == "ll")
-    return new TextFileHandler(/*Comment=*/";");
+    return std::make_unique<TextFileHandler>(/*Comment=*/";");
   if (FilesType == "bc")
-    return new BinaryFileHandler();
+    return std::make_unique<BinaryFileHandler>();
   if (FilesType == "s")
-    return new TextFileHandler(/*Comment=*/"#");
+    return std::make_unique<TextFileHandler>(/*Comment=*/"#");
   if (FilesType == "o")
     return CreateObjectFileHandler(FirstInput);
   if (FilesType == "gch")
-    return new BinaryFileHandler();
+    return std::make_unique<BinaryFileHandler>();
   if (FilesType == "ast")
-    return new BinaryFileHandler();
+    return std::make_unique<BinaryFileHandler>();
 
-  errs() << "error: invalid file type specified.\n";
-  return nullptr;
+  return createStringError(errc::invalid_argument,
+                           "'" + FilesType + "': invalid file type specified");
 }
 
 /// Bundle the files. Return true if an error was found.
-static bool BundleFiles() {
+static Error BundleFiles() {
   std::error_code EC;
 
   // Create output file.
   raw_fd_ostream OutputFile(OutputFileNames.front(), EC, sys::fs::OF_None);
-
-  if (EC) {
-    errs() << "error: Can't open file " << OutputFileNames.front() << ".\n";
-    return true;
-  }
+  if (EC)
+    return createFileError(OutputFileNames.front(), EC);
 
   // Open input files.
   SmallVector<std::unique_ptr<MemoryBuffer>, 8u> InputBuffers;
   InputBuffers.reserve(InputFileNames.size());
   for (auto &I : InputFileNames) {
     ErrorOr<std::unique_ptr<MemoryBuffer>> CodeOrErr =
         MemoryBuffer::getFileOrSTDIN(I);
-    if (std::error_code EC = CodeOrErr.getError()) {
-      errs() << "error: Can't open file " << I << ": " << EC.message() << "\n";
-      return true;
-    }
-    InputBuffers.emplace_back(std::move(CodeOrErr.get()));
+    if (std::error_code EC = CodeOrErr.getError())
+      return createFileError(I, EC);
+    InputBuffers.emplace_back(std::move(*CodeOrErr));
   }
 
   // Get the file handler. We use the host buffer as reference.
   assert(HostInputIndex != ~0u && "Host input index undefined??");
-  std::unique_ptr<FileHandler> FH;
-  FH.reset(CreateFileHandler(*InputBuffers[HostInputIndex].get()));
+  Expected<std::unique_ptr<FileHandler>> FileHandlerOrErr =
+      CreateFileHandler(*InputBuffers[HostInputIndex]);
+  if (!FileHandlerOrErr)
+    return FileHandlerOrErr.takeError();
 
-  // Quit if we don't have a handler.
-  if (!FH.get())
-    return true;
+  std::unique_ptr<FileHandler> &FH = *FileHandlerOrErr;
+  assert(FH);
 
   // Write header.
-  FH.get()->WriteHeader(OutputFile, InputBuffers);
+  if (Error Err = FH->WriteHeader(OutputFile, InputBuffers))
+    return std::move(Err);
 
   // Write all bundles along with the start/end markers. If an error was found
   // writing the end of the bundle component, abort the bundle writing.
   auto Input = InputBuffers.begin();
   for (auto &Triple : TargetNames) {
-    FH.get()->WriteBundleStart(OutputFile, Triple);
-    FH.get()->WriteBundle(OutputFile, *Input->get());
-    if (FH.get()->WriteBundleEnd(OutputFile, Triple))
-      return true;
+    if (Error Err = FH->WriteBundleStart(OutputFile, Triple))
+      return std::move(Err);
+    if (Error Err = FH->WriteBundle(OutputFile, **Input))
+      return std::move(Err);
+    if (Error Err = FH->WriteBundleEnd(OutputFile, Triple))
+      return std::move(Err);
     ++Input;
   }
-  return false;
+  return Error::success();
 }
 
 // Unbundle the files. Return true if an error was found.
-static bool UnbundleFiles() {
+static Error UnbundleFiles() {
   // Open Input file.
   ErrorOr<std::unique_ptr<MemoryBuffer>> CodeOrErr =
       MemoryBuffer::getFileOrSTDIN(InputFileNames.front());
-  if (std::error_code EC = CodeOrErr.getError()) {
-    errs() << "error: Can't open file " << InputFileNames.front() << ": "
-           << EC.message() << "\n";
-    return true;
-  }
+  if (std::error_code EC = CodeOrErr.getError())
+    return createFileError(InputFileNames.front(), EC);
 
-  MemoryBuffer &Input = *CodeOrErr.get();
+  MemoryBuffer &Input = **CodeOrErr;
 
   // Select the right files handler.
-  std::unique_ptr<FileHandler> FH;
-  FH.reset(CreateFileHandler(Input));
+  Expected<std::unique_ptr<FileHandler>> FileHandlerOrErr =
+      CreateFileHandler(Input);
+  if (!FileHandlerOrErr)
+    return FileHandlerOrErr.takeError();
 
-  // Quit if we don't have a handler.
-  if (!FH.get())
-    return true;
+  std::unique_ptr<FileHandler> &FH = *FileHandlerOrErr;
+  assert(FH);
 
   // Read the header of the bundled file.
-  FH.get()->ReadHeader(Input);
+  if (Error Err = FH->ReadHeader(Input))
+    return std::move(Err);
 
   // Create a work list that consist of the map triple/output file.
   StringMap<StringRef> Worklist;
   auto Output = OutputFileNames.begin();
   for (auto &Triple : TargetNames) {
     Worklist[Triple] = *Output;
     ++Output;
   }
 
   // Read all the bundles that are in the work list. If we find no bundles we
   // assume the file is meant for the host target.
   bool FoundHostBundle = false;
   while (!Worklist.empty()) {
-    StringRef CurTriple = FH.get()->ReadBundleStart(Input);
+    Expected<Optional<StringRef>> CurTripleOrErr = FH->ReadBundleStart(Input);
+    if (!CurTripleOrErr)
+      return CurTripleOrErr.takeError();
 
     // We don't have more bundles.
-    if (CurTriple.empty())
+    if (!*CurTripleOrErr)
       break;
 
+    StringRef CurTriple = **CurTripleOrErr;
+    assert(!CurTriple.empty());
+
     auto Output = Worklist.find(CurTriple);
     // The file may have more bundles for other targets, that we don't care
     // about. Therefore, move on to the next triple
-    if (Output == Worklist.end()) {
+    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::OF_None);
-    if (EC) {
-      errs() << "error: Can't open file " << Output->second << ": "
-             << EC.message() << "\n";
-      return true;
-    }
-    FH.get()->ReadBundle(OutputFile, Input);
-    FH.get()->ReadBundleEnd(Input);
+    if (EC)
+      return createFileError(Output->second, EC);
+    if (Error Err = FH->ReadBundle(OutputFile, Input))
+      return std::move(Err);
+    if (Error Err = FH->ReadBundleEnd(Input))
+      return std::move(Err);
     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::OF_None);
-      if (EC) {
-        errs() << "error: Can't open file " << E.second << ": " << EC.message()
-               << "\n";
-        return true;
-      }
+      if (EC)
+        return createFileError(E.second, EC);
 
       // 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;
+    return Error::success();
   }
 
   // If we found elements, we emit an error if none of those were for the host
   // in case host bundle name was provided in command line.
-  if (!FoundHostBundle && HostInputIndex != ~0u) {
-    errs() << "error: Can't find bundle for the host target\n";
-    return true;
-  }
+  if (!FoundHostBundle && HostInputIndex != ~0u)
+    return createStringError(inconvertibleErrorCode(),
+                             "Can't find bundle for the host target");
 
   // 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::OF_None);
-    if (EC) {
-      errs() << "error: Can't open file " << E.second << ": "  << EC.message()
-             << "\n";
-      return true;
-    }
+    if (EC)
+      return createFileError(E.second, EC);
   }
 
-  return false;
+  return Error::success();
 }
 
 static void PrintVersion(raw_ostream &OS) {
   OS << clang::getClangToolFullVersion("clang-offload-bundler") << '\n';
 }
 
 int main(int argc, const char **argv) {
   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();
     return 0;
   }
 
+  auto reportError = [argv](Error E) {
+    logAllUnhandledErrors(std::move(E), WithColor::error(errs(), argv[0]));
+  };
+
   bool Error = false;
   if (Unbundle) {
     if (InputFileNames.size() != 1) {
       Error = true;
-      errs() << "error: only one input file supported in unbundling mode.\n";
+      reportError(createStringError(
+          errc::invalid_argument,
+          "only one input file supported in unbundling mode"));
     }
     if (OutputFileNames.size() != TargetNames.size()) {
       Error = true;
-      errs() << "error: number of output files and targets should match in "
-                "unbundling mode.\n";
+      reportError(createStringError(errc::invalid_argument,
+                                    "number of output files and targets should "
+                                    "match in unbundling mode"));
     }
   } else {
     if (OutputFileNames.size() != 1) {
       Error = true;
-      errs() << "error: only one output file supported in bundling mode.\n";
+      reportError(createStringError(
+          errc::invalid_argument,
+          "only one output file supported in bundling mode"));
     }
     if (InputFileNames.size() != TargetNames.size()) {
       Error = true;
-      errs() << "error: number of input files and targets should match in "
-                "bundling mode.\n";
+      reportError(createStringError(
+          errc::invalid_argument,
+          "number of input files and targets should match in bundling mode"));
     }
   }
 
   // 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 && StringSwitch<bool>(Kind)
                                      .Default(false);
 
     bool TripleIsValid = !Triple.empty();
     llvm::Triple T(Triple);
     TripleIsValid &= T.getArch() != Triple::UnknownArch;
 
     if (!KindIsValid || !TripleIsValid) {
       Error = true;
-      errs() << "error: invalid target '" << Target << "'";
 
+      SmallVector<char, 128u> Buf;
+      raw_svector_ostream Msg(Buf);
+      Msg << "invalid target '" << Target << "'";
       if (!KindIsValid)
-        errs() << ", unknown offloading kind '" << Kind << "'";
+        Msg << ", unknown offloading kind '" << Kind << "'";
       if (!TripleIsValid)
-        errs() << ", unknown target triple '" << Triple << "'";
-      errs() << ".\n";
+        Msg << ", unknown target triple '" << Triple << "'";
+      reportError(createStringError(errc::invalid_argument, Msg.str()));
     }
 
     if (KindIsValid && Kind == "host") {
       ++HostTargetNum;
       // Save the index of the input that refers to the host.
       HostInputIndex = Index;
     }
 
     ++Index;
   }
 
   // Host triple is not really needed for unbundling operation, so do not
   // treat missing host triple as error if we do unbundling.
   if ((Unbundle && HostTargetNum > 1) || (!Unbundle && HostTargetNum != 1)) {
     Error = true;
-    errs() << "error: expecting exactly one host target but got "
-           << HostTargetNum << ".\n";
+    reportError(createStringError(errc::invalid_argument,
+                                  "expecting exactly one host target but got " +
+                                      Twine(HostTargetNum)));
   }
 
   if (Error)
     return 1;
 
   // Save the current executable directory as it will be useful to find other
   // tools.
   BundlerExecutable = sys::fs::getMainExecutable(argv[0], &BundlerExecutable);
 
-  return Unbundle ? UnbundleFiles() : BundleFiles();
+  if (llvm::Error Err = Unbundle ? UnbundleFiles() : BundleFiles()) {
+    reportError(std::move(Err));
+    return 1;
+  }
+  return 0;
 }