[lld-macho] Avoid unnecessary shared_ptr in DylibFile ctor

[int3]

Summary

DylibFile doesn't store a pointer to its InterfaceFile
parameter, so there's no need to use a shared_ptr.

lld/MachO/Driver.cpp

case file_magic::macho_dynamically_linked_shared_lib:
     inputFiles.push_back(make<DylibFile>(mbref));
     break;
   case file_magic::tapi_file: {
     llvm::Expected<std::unique_ptr<llvm::MachO::InterfaceFile>> result =
         TextAPIReader::get(mbref);
     if (!result)
       return;
 
-    inputFiles.push_back(make<DylibFile>(std::move(*result)));
+    inputFiles.push_back(make<DylibFile>(**result));
     break;
   }
   default:
     error(path + ": unhandled file type");
   }
 }
 
 static void addFileList(StringRef path) {

lld/MachO/InputFiles.h

public:
   explicit OpaqueFile(MemoryBufferRef mb, StringRef segName,
                       StringRef sectName);
   static bool classof(const InputFile *f) { return f->kind() == OpaqueKind; }
 };
 
 // .dylib file
 class DylibFile : public InputFile {
 public:
-  explicit DylibFile(std::shared_ptr<llvm::MachO::InterfaceFile> interface,
+  explicit DylibFile(const llvm::MachO::InterfaceFile &interface,
                      DylibFile *umbrella = nullptr);
 
   // Mach-O dylibs can re-export other dylibs as sub-libraries, meaning that the
   // symbols in those sub-libraries will be available under the umbrella
   // library's namespace. Those sub-libraries can also have their own
   // re-exports. When loading a re-exported dylib, `umbrella` should be set to
   // the root dylib to ensure symbols in the child library are correctly bound
   // to the root. On the other hand, if a dylib is being directly loaded

lld/MachO/InputFiles.cpp

for (uint32_t i = 0, n = hdr->ncmds; i < n; ++i) {
     if (!buffer) {
       error("unable to read re-exported dylib at " + reexportPath);
       return;
     }
     reexported.push_back(make<DylibFile>(*buffer, umbrella));
   }
 }
 
-DylibFile::DylibFile(std::shared_ptr<llvm::MachO::InterfaceFile> interface,
-                     DylibFile *umbrella)
+DylibFile::DylibFile(const InterfaceFile &interface, DylibFile *umbrella)
     : InputFile(DylibKind, MemoryBufferRef()) {
   if (umbrella == nullptr)
     umbrella = this;
 
-  dylibName = saver.save(interface->getInstallName());
+  dylibName = saver.save(interface.getInstallName());
   auto addSymbol = [&](const Twine &name) -> void {
     symbols.push_back(symtab->addDylib(saver.save(name), umbrella,
                                        /*isWeakDef=*/false,
                                        /*isTlv=*/false));
   };
   // TODO(compnerd) filter out symbols based on the target platform
   // TODO: handle weak defs, thread locals
-  for (const auto symbol : interface->symbols()) {
+  for (const auto symbol : interface.symbols()) {
     if (!symbol->getArchitectures().has(config->arch))
       continue;
 
     switch (symbol->getKind()) {
     case SymbolKind::GlobalSymbol:
       addSymbol(symbol->getName());
       break;
     case SymbolKind::ObjectiveCClass:
       // XXX ld64 only creates these symbols when -ObjC is passed in. We may
       // want to emulate that.
       addSymbol("_OBJC_CLASS_$_" + symbol->getName());
       addSymbol("_OBJC_METACLASS_$_" + symbol->getName());
       break;
     case SymbolKind::ObjectiveCClassEHType:
       addSymbol("_OBJC_EHTYPE_$_" + symbol->getName());
       break;
     case SymbolKind::ObjectiveCInstanceVariable:
       addSymbol("_OBJC_IVAR_$_" + symbol->getName());
       break;
     }
   }
   // TODO(compnerd) properly represent the hierarchy of the documents as it is
   // in theory possible to have re-exported dylibs from re-exported dylibs which
   // should be parent'ed to the child.
-  for (auto document : interface->documents())
-    reexported.push_back(make<DylibFile>(document, umbrella));
+  for (const std::shared_ptr<InterfaceFile> &intf : interface.documents())
+    reexported.push_back(make<DylibFile>(*intf, umbrella));
 }
 
 ArchiveFile::ArchiveFile(std::unique_ptr<llvm::object::Archive> &&f)
     : InputFile(ArchiveKind, f->getMemoryBufferRef()), file(std::move(f)) {
   for (const object::Archive::Symbol &sym : file->symbols())
     symtab->addLazy(sym.getName(), this, sym);
 }