Fix memory leaks in clang-offload-bundler

[vitalybuka]

Summary

1. Pair removed from StringMap was not destroyed
2. ObjectFile had no owner

[sfantao]

Oh, I see, thanks for the fix, it looks good.

tools/clang-offload-bundler/ClangOffloadBundler.cpp

 /// (the one we are bundling into) refers to.
 ///
 /// To unbundle, we use just copy the contents of the designated section. If the
 /// requested bundle refer to the main object file, we just copy it with no
 /// changes.
 class ObjectFileHandler final : public FileHandler {
 
   /// The object file we are currently dealing with.
-  ObjectFile &Obj;
+  std::unique_ptr<ObjectFile> Obj;
 
   /// Return the input file contents.
-  StringRef getInputFileContents() const { return Obj.getData(); }
+  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;
     CurSection.getName(SectionName);
 
class ObjectFileHandler final : public FileHandler {
   /// Iterator of the current and next section.
   section_iterator CurrentSection;
   section_iterator NextSection;
 
 public:
   void ReadHeader(MemoryBuffer &Input) {}
   StringRef ReadBundleStart(MemoryBuffer &Input) {
 
-    while (NextSection != Obj.section_end()) {
+    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;
void WriteBundle(raw_fd_ostream &OS, MemoryBuffer &Input) {
 
     // 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(ObjectFile &Obj)
-      : FileHandler(), Obj(Obj), CurrentSection(Obj.section_begin()),
-        NextSection(Obj.section_begin()) {}
+  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"
if (!BinaryOrErr) {
     // not get a valid device binary object we use the default binary handler.
     consumeError(BinaryOrErr.takeError());
     return new BinaryFileHandler();
   }
 
   // We only support regular object files. If this is not an object file,
   // default to the binary handler. The handler will be owned by the client of
   // this function.
-  ObjectFile *Obj = dyn_cast<ObjectFile>(BinaryOrErr.get().release());
+  std::unique_ptr<ObjectFile> Obj(
+      dyn_cast<ObjectFile>(BinaryOrErr.get().release()));
 
   if (!Obj)
     return new BinaryFileHandler();
 
-  return new ObjectFileHandler(*Obj);
+  return new ObjectFileHandler(std::move(Obj));
 }
 
 /// Return an appropriate handler given the input files and options.
 static FileHandler *CreateFileHandler(MemoryBuffer &FirstInput) {
   if (FilesType == "i")
     return new TextFileHandler(/*Comment=*/"//");
   if (FilesType == "ii")
     return new TextFileHandler(/*Comment=*/"//");
while (!Worklist.empty()) {
     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";
       return true;
     }
     FH.get()->ReadBundle(OutputFile, Input);
     FH.get()->ReadBundleEnd(Input);
-    Worklist.remove(&*Output);
+    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.