[lld-macho] Add --start-lib --end-lib

[MaskRay]

Summary

In ld.lld, when an ObjFile/BitcodeFile is read in --start-lib state, the file is
given archive semantics. --end-lib closes the previous --start-lib. A build
system can use this feature as an alternative to archives. This patch ports
the feature to lld-macho.

--start-lib and --end-lib are positional, unlike usual ld64 options.
I think the slight drawback does not matter as (a) reusing option names
make build systems convenient (b) --start-lib a.o b.o --end-lib conveys more
information than an alternative design: -objlib a.o -objlib b.o because
--start-lib makes it clear which objects are in the same conceptual archive.
This provides flexibility (c) -objlib/-filelist interaction may be weird.

Close https://github.com/llvm/llvm-project/issues/52931

[MaskRay]

rebase. improve tests

[MaskRay]

lld/MachO/UnwindInfoSection.cpp

229

@oontvoo This change does not make the new test in lld/test/MachO/objc-uses-custom-personality.s work. Do you know why?

[oontvoo]

lld/MachO/Driver.cpp

250

can this be a parameter to the addFile() function instead?

Having it as a global makes it harder to introduce any kind parallelization in processing the input (which i'm working on a POC for, since lld-macho is currently proven to be too slow to link Youtube)

Also I've said this on the bug but I'm kind concerned about introducing stateful flags like this given there's no precedence for it in LD64.

lld/MachO/UnwindInfoSection.cpp

229

I think this is because this new lazyobject, as currently implemented, is slightly different from an archive in that objc symbols in archives are pulled in "eagerly" if the -ObjC flag is present. (This is a necessary condition for this test because it needs _OBJC_CLASS_$_MyTest, which would then pull in the personality symbol).

There's no golden standard to look to here given LD64 doesn't have this, but I guess we should try to make it behave similarly to archives when it comes to objc handling.

[smeenai]

Also I've said this on the bug but I'm kind concerned about introducing stateful flags like this given there's no precedence for it in LD64.

I'd also be more supportive of doing something like -objlib instead of --start-lib. We have an analog for this already, where ELF linkers use --whole-archive --no-whole-archive to enclose archives to be linked whole, whereas ld64 has -force_load to whole-link a particular archive. I don't feel super strongly about that though.

[MaskRay]

• Support -ObjC
• remove inLib

I keep my viewpoint that --start-lib is more suitable because of (b) (as stated in the description).
The library boundary is useful and -objlib would lose the information.

--whole-archive (-force_load), while similar, keeps the library boundary information,
so it's not the best analogy.

[MaskRay]

lld/MachO/Driver.cpp

250

Removed. The state would not make parallelization more difficult. We do not parallelize the addFile function calls but the underlying initialization.

[MaskRay]

Add some /*isLazy=*/ comments

[int3]

So I realize that the choice of class hierarchy here was chosen to follow the LLD-ELF backend's design... but I'm not the biggest fan of it for two reasons:

1. ObjFiles and BitcodeFiles with lazy = true aren't proper instances of their classes; e.g. calling ->getDataInCode() on a lazy ObjFile isn't a valid operation. IMO it would make more sense to have a separate LazyFile instance that gets converted to ObjFile / BitcodeFile as necessary. Kind of like an ArchiveFile but with only one member.
2. I have the opposite objection to LazyObject: it doesn't really merit the creation of a new class. Implementation-wise, it's indeed different from LazyArchive, but interface-wise, they both expose a single common operation: the fetching of their associated file. IMO it would be cleaner to have a single LazySymbol class with a fetchFile() method. It can use a PointerUnion to store a pointer to the llvm::object::Archive::Symbol or InputFile instance as necessary.

All that said, I do see the sense in not deviating from LLD-ELF's architecture. If you prefer the hierarchy as-is, I'm good with that too.

lld/MachO/Driver.cpp

350

nit: how about isa<ObjFile> and isa<BitcodeFile> since the line above is also using isa<>?

350–359

IIUC, we are evaluating lazy object files for ObjC members after doing regular symbol resolution. Archive loading (intentionally) does this in the opposite order: D108781: [lld-macho] Have -ObjC load archive members before symbol resolution. Would probably be good to follow suit

lld/MachO/InputFiles.cpp

929

nit: no need for llvm::

1619

no need for llvm::

lld/MachO/InputFiles.h

242

make this private?

[oontvoo]

In D116913#3246384, @MaskRay wrote:

• Support -ObjC
• remove inLib

I keep my viewpoint that --start-lib is more suitable because of (b) (as stated in the description).
The library boundary is useful and -objlib would lose the information.

--whole-archive (-force_load), while similar, keeps the library boundary information,
so it's not the best analogy.

Ok, I think i'm convinced --start-lib/--end-lib is better in this case :)

lld/MachO/Driver.cpp

350

is anything wrong with switching the previous predicate to checking the magic? (checking for the underlying type always seemed kind of iffy to me ... )

lld/MachO/InputFiles.cpp

1619

Sorry, I'm missing something here but why not simply for (const lto::InputFile::Symbol &objSym : obj->symbols()) ?
IOWs, why is llvm::enumerate needed?

lld/test/MachO/objc.s

34

OBJC-DAG instead?

[MaskRay]

lld/MachO/Driver.cpp

350–359

Thanks for the pointer. Unfortunately it is difficult to follow D108781 because without parse and parseLazy, we don't have symbols (to check ObjC symbols/sections).... For now I just add a test with TODO.

I think some heavy symbol table refactoring is needed to make symbols available before symbol resolution. https://github.com/llvm/llvm-project/issues/53104

lld/MachO/InputFiles.cpp

1619

llvm::foo for STL-like helpers (lower_bound, find_if, etc) has an advantage: prevent the confusing argument-dependent lookup. In other components of llvm-project llvm::foo for STL-like helpers is generally recommended.

So I am going to defend for the usage a bit...

1619

symbols[it.index()] is needed by -ObjC for ObjC symbol checking. It has another advantage: when a symbol table refactoring is done in the future, we can transfer the symbol table to the non-lazy state. See D116390 for ELF.

[MaskRay]

address comments

[MaskRay]

In D116913#3250279, @int3 wrote:

So I realize that the choice of class hierarchy here was chosen to follow the LLD-ELF backend's design... but I'm not the biggest fan of it for two reasons:

1. ObjFiles and BitcodeFiles with lazy = true aren't proper instances of their classes; e.g. calling ->getDataInCode() on a lazy ObjFile isn't a valid operation. IMO it would make more sense to have a separate LazyFile instance that gets converted to ObjFile / BitcodeFile as necessary. Kind of like an ArchiveFile but with only one member.
2. I have the opposite objection to LazyObject: it doesn't really merit the creation of a new class. Implementation-wise, it's indeed different from LazyArchive, but interface-wise, they both expose a single common operation: the fetching of their associated file. IMO it would be cleaner to have a single LazySymbol class with a fetchFile() method. It can use a PointerUnion to store a pointer to the llvm::object::Archive::Symbol or InputFile instance as necessary.

All that said, I do see the sense in not deviating from LLD-ELF's architecture. If you prefer the hierarchy as-is, I'm good with that too.

A separate LazyFile class makes sharing information (symbols/sections) between the lazy and non-lazy states difficult.
(https://maskray.me/blog/2021-12-19-why-isnt-ld.lld-faster "initialization of sections" and "initialization of non-local symbols")
I think we are currently a bit far away from the goal, but I am carefully writing code not to make it harder.

[int3]

lgtm, thanks!

lld/MachO/InputFiles.cpp

1619

mm yeah, I have also been including llvm:: in front of LLVM functions which have STL counterparts of the same name. My reasoning was that since std::enumerate doesn't exist, llvm:: wasn't needed here... but I can also see the argument for using llvm:: for all STL-like things.

[oontvoo]

LG thanks!

[jyknight]

Sorry I didn't see to comment on this before, but I'm also skeptical about introducing a new concept of stateful options to this command-line syntax.

(b) --start-lib a.o b.o --end-lib conveys more
information than an alternative design: -objlib a.o -objlib b.o because
--start-lib makes it clear which objects are in the same conceptual archive.

I don't think this is relevant to this linker -- what flexibility are you imagining it provides? "Conceptual archive" doesn't mean anything to a Mach-O linker, since we don't have the legacy ELF symbol lookup behavior where you need to loop around and search an archive repeatedly to find the proper files to pull into the link.

(c) -objlib/-filelist interaction may be weird.

Filelist can _only_ contain files, no options, so I don't see how this is an advantage of --start-lib? Also, the use of -filelist should be considered deprecated -- passing the args directly to Clang, via a clang @ response-file if needed, is preferable in every way.

[MaskRay]

In D116913#3255820, @jyknight wrote:

Sorry I didn't see to comment on this before, but I'm also skeptical about introducing a new concept of stateful options to this command-line syntax.

(b) --start-lib a.o b.o --end-lib conveys more
information than an alternative design: -objlib a.o -objlib b.o because
--start-lib makes it clear which objects are in the same conceptual archive.

I don't think this is relevant to this linker -- what flexibility are you imagining it provides? "Conceptual archive" doesn't mean anything to a Mach-O linker, since we don't have the legacy ELF symbol lookup behavior where you need to loop around and search an archive repeatedly to find the proper files to pull into the link.

If we later discover that linking x.a(a.o b.o) y.a(c.o) has different behavior than x.a(a.o) y.a(b.o c.o), with --start-lib, since we have the library boundary information, we can fix it.
With -objlib a.o -objlib b.o -objlib c.o, we can't.
I wouldn't put my bet on that Mach-O archives will never introduce such a rule (or has already such a rule but we just don't know yet), given weird options like -ObjC.

If an archive is augmented with special __.* members doing weird stuff, with --start-lib we can port it.
With -objlib, we can't.

(c) -objlib/-filelist interaction may be weird.

Filelist can _only_ contain files, no options, so I don't see how this is an advantage of --start-lib? Also, the use of -filelist should be considered deprecated -- passing the args directly to Clang, via a clang @ response-file if needed, is preferable in every way.

I used this as a very weak argument. I think it is fine to argue this in both ways. --start-lib makes it easy to use --start-lib @response.rsp --end-lib.

lld/MachO/Driver.cpp

case OPT_max_relative_cache_size_lto:
       add(Twine("cache_size=") + arg->getValue() + "%");
       break;
     }
   }
   return CHECK(parseCachePruningPolicy(ltoPolicy), "invalid LTO cache policy");
 }
 
 static DenseMap<StringRef, ArchiveFile *> loadedArchives;
 
 static InputFile *addFile(StringRef path, ForceLoad forceLoadArchive,
-                          bool isExplicit = true, bool isBundleLoader = false) {
+                          bool isLazy = false, bool isExplicit = true,
+                          bool isBundleLoader = false) {
   Optional<MemoryBufferRef> buffer = readFile(path);
   if (!buffer)
     return nullptr;
   MemoryBufferRef mbref = *buffer;
   InputFile *newFile = nullptr;
 
   file_magic magic = identify_magic(mbref.getBuffer());
   switch (magic) {
if ((forceLoadArchive == ForceLoad::Default && config->allLoad) ||
       }
     }
 
     file->addLazySymbols();
     newFile = loadedArchives[path] = file;
     break;
   }
   case file_magic::macho_object:
-    newFile = make<ObjFile>(mbref, getModTime(path), "");
+    newFile = make<ObjFile>(mbref, getModTime(path), "", isLazy);
     break;
   case file_magic::macho_dynamically_linked_shared_lib:
   case file_magic::macho_dynamically_linked_shared_lib_stub:
   case file_magic::tapi_file:
     if (DylibFile *dylibFile = loadDylib(mbref)) {
       if (isExplicit)
         dylibFile->explicitlyLinked = true;
       newFile = dylibFile;
     }
     break;
   case file_magic::bitcode:
-    newFile = make<BitcodeFile>(mbref, "", 0);
+    newFile = make<BitcodeFile>(mbref, "", 0, isLazy);
     break;
   case file_magic::macho_executable:
   case file_magic::macho_bundle:
     // We only allow executable and bundle type here if it is used
     // as a bundle loader.
     if (!isBundleLoader)
       error(path + ": unhandled file type");
     if (DylibFile *dylibFile = loadDylib(mbref, nullptr, isBundleLoader))
       newFile = dylibFile;
     break;
   default:
     error(path + ": unhandled file type");
   }
   if (newFile && !isa<DylibFile>(newFile)) {
+    if ((magic == file_magic::macho_object || magic == file_magic::bitcode) &&
+        newFile->lazy && config->forceLoadObjC) {
+      for (Symbol *sym : newFile->symbols)
+        if (sym && sym->getName().startswith(objc::klass)) {
+          extract(*newFile, "-ObjC");
+          break;
+        }
+      if (newFile->lazy && hasObjCSection(mbref))
+        extract(*newFile, "-ObjC");
+    }
+
     // printArchiveMemberLoad() prints both .a and .o names, so no need to
-    // print the .a name here.
-    if (config->printEachFile && magic != file_magic::archive)
+    // print the .a name here. Similarly skip lazy files.
+    if (config->printEachFile && magic != file_magic::archive && !isLazy)
       message(toString(newFile));
     inputFiles.insert(newFile);
   }
   return newFile;
 }
 
 static void addLibrary(StringRef name, bool isNeeded, bool isWeak,
                        bool isReexport, bool isExplicit,
                        ForceLoad forceLoadArchive) {
   if (Optional<StringRef> path = findLibrary(name)) {
     if (auto *dylibFile = dyn_cast_or_null<DylibFile>(
-            addFile(*path, forceLoadArchive, isExplicit))) {
+            addFile(*path, forceLoadArchive, /*isLazy=*/false, isExplicit))) {
       if (isNeeded)
         dylibFile->forceNeeded = true;
       if (isWeak)
         dylibFile->forceWeakImport = true;
       if (isReexport) {
         config->hasReexports = true;
         dylibFile->reexport = true;
       }
     }
     return;
   }
   error("library not found for -l" + name);
 }
 
 static void addFramework(StringRef name, bool isNeeded, bool isWeak,
                          bool isReexport, bool isExplicit,
                          ForceLoad forceLoadArchive) {
   if (Optional<StringRef> path = findFramework(name)) {
     if (auto *dylibFile = dyn_cast_or_null<DylibFile>(
-            addFile(*path, forceLoadArchive, isExplicit))) {
+            addFile(*path, forceLoadArchive, /*isLazy=*/false, isExplicit))) {
       if (isNeeded)
         dylibFile->forceNeeded = true;
       if (isWeak)
         dylibFile->forceWeakImport = true;
       if (isReexport) {
         config->hasReexports = true;
         dylibFile->reexport = true;
       }
if (arg.consume_front("-l")) {
     StringRef name = argv[++i];
     addFramework(name, /*isNeeded=*/false, /*isWeak=*/false,
                  /*isReexport=*/false, /*isExplicit=*/false, ForceLoad::No);
   } else {
     error(arg + " is not allowed in LC_LINKER_OPTION");
   }
 }
 
-static void addFileList(StringRef path) {
+static void addFileList(StringRef path, bool isLazy) {
   Optional<MemoryBufferRef> buffer = readFile(path);
   if (!buffer)
     return;
   MemoryBufferRef mbref = *buffer;
   for (StringRef path : args::getLines(mbref))
-    addFile(rerootPath(path), ForceLoad::Default);
+    addFile(rerootPath(path), ForceLoad::Default, isLazy);
 }
 
 // An order file has one entry per line, in the following format:
 //
 //   <cpu>:<object file>:<symbol name>
 //
 // <cpu> and <object file> are optional. If not specified, then that entry
 // matches any symbol of that name. Parsing this format is not quite
for (InputFile *file : inputFiles)
         warn("the effect of -export_dynamic on LTO is not yet implemented");
         break;
       }
 
   TimeTraceScope timeScope("LTO");
   auto *lto = make<BitcodeCompiler>();
   for (InputFile *file : inputFiles)
     if (auto *bitcodeFile = dyn_cast<BitcodeFile>(file))
+      if (!file->lazy)
         lto->add(*bitcodeFile);
 
   for (ObjFile *file : lto->compile())
     inputFiles.insert(file);
 }
 
 // Replaces common symbols with defined symbols residing in __common sections.
 // This function must be called after all symbol names are resolved (i.e. after
 // all InputFiles have been loaded.) As a result, later operations won't see
for (const Arg *arg : args.filtered(listFileOptionCode)) {
     }
   }
 }
 
 static void createFiles(const InputArgList &args) {
   TimeTraceScope timeScope("Load input files");
   // This loop should be reserved for options whose exact ordering matters.
   // Other options should be handled via filtered() and/or getLastArg().
+  bool isLazy = false;
   for (const Arg *arg : args) {
     const Option &opt = arg->getOption();
     warnIfDeprecatedOption(opt);
     warnIfUnimplementedOption(opt);
 
     switch (opt.getID()) {
     case OPT_INPUT:
-      addFile(rerootPath(arg->getValue()), ForceLoad::Default);
+      addFile(rerootPath(arg->getValue()), ForceLoad::Default, isLazy);
       break;
     case OPT_needed_library:
       if (auto *dylibFile = dyn_cast_or_null<DylibFile>(
               addFile(rerootPath(arg->getValue()), ForceLoad::Default)))
         dylibFile->forceNeeded = true;
       break;
     case OPT_reexport_library:
       if (auto *dylibFile = dyn_cast_or_null<DylibFile>(
               addFile(rerootPath(arg->getValue()), ForceLoad::Default))) {
         config->hasReexports = true;
         dylibFile->reexport = true;
       }
       break;
     case OPT_weak_library:
       if (auto *dylibFile = dyn_cast_or_null<DylibFile>(
               addFile(rerootPath(arg->getValue()), ForceLoad::Default)))
         dylibFile->forceWeakImport = true;
       break;
     case OPT_filelist:
-      addFileList(arg->getValue());
+      addFileList(arg->getValue(), isLazy);
       break;
     case OPT_force_load:
       addFile(rerootPath(arg->getValue()), ForceLoad::Yes);
       break;
     case OPT_l:
     case OPT_needed_l:
     case OPT_reexport_l:
     case OPT_weak_l:
       addLibrary(arg->getValue(), opt.getID() == OPT_needed_l,
                  opt.getID() == OPT_weak_l, opt.getID() == OPT_reexport_l,
                  /*isExplicit=*/true, ForceLoad::Default);
       break;
     case OPT_framework:
     case OPT_needed_framework:
     case OPT_reexport_framework:
     case OPT_weak_framework:
       addFramework(arg->getValue(), opt.getID() == OPT_needed_framework,
                    opt.getID() == OPT_weak_framework,
                    opt.getID() == OPT_reexport_framework, /*isExplicit=*/true,
                    ForceLoad::Default);
       break;
+    case OPT_start_lib:
+      if (isLazy)
+        error("nested --start-lib");
+      isLazy = true;
+      break;
+    case OPT_end_lib:
+      if (!isLazy)
+        error("stray --end-lib");
+      isLazy = false;
+      break;
     default:
       break;
     }
   }
 }
 
 static void gatherInputSections() {
   TimeTraceScope timeScope("Gathering input sections");
bool macho::link(ArrayRef<const char *> argsArr, bool canExitEarly,
   config->printEachFile = args.hasArg(OPT_t);
   config->printWhyLoad = args.hasArg(OPT_why_load);
   config->omitDebugInfo = args.hasArg(OPT_S);
   config->outputType = getOutputType(args);
   config->errorForArchMismatch = args.hasArg(OPT_arch_errors_fatal);
   if (const Arg *arg = args.getLastArg(OPT_bundle_loader)) {
     if (config->outputType != MH_BUNDLE)
       error("-bundle_loader can only be used with MachO bundle output");
-    addFile(arg->getValue(), ForceLoad::Default, /*isExplicit=*/false,
+    addFile(arg->getValue(), ForceLoad::Default, /*isLazy=*/false,
+            /*isExplicit=*/false,
             /*isBundleLoader=*/true);
   }
   if (const Arg *arg = args.getLastArg(OPT_umbrella)) {
     if (config->outputType != MH_DYLIB)
       warn("-umbrella used, but not creating dylib");
     config->umbrella = arg->getValue();
   }
   config->ltoObjPath = args.getLastArgValue(OPT_object_path_lto);

lld/MachO/InputFiles.h

public:
   Kind kind() const { return fileKind; }
   StringRef getName() const { return name; }
   static void resetIdCount() { idCount = 0; }
 
   MemoryBufferRef mb;
 
   std::vector<Symbol *> symbols;
   std::vector<Section> sections;
-  // Provides an easy way to sort InputFiles deterministically.
-  const int id;
 
   // If not empty, this stores the name of the archive containing this file.
   // We use this string for creating error messages.
   std::string archiveName;
 
+  // Provides an easy way to sort InputFiles deterministically.
+  const int id;
+
+  // True if this is a lazy ObjFile or BitcodeFile.
+  bool lazy = false;
+
 protected:
-  InputFile(Kind kind, MemoryBufferRef mb)
-      : mb(mb), id(idCount++), fileKind(kind), name(mb.getBufferIdentifier()) {}
+  InputFile(Kind kind, MemoryBufferRef mb, bool lazy = false)
+      : mb(mb), id(idCount++), lazy(lazy), fileKind(kind),
+        name(mb.getBufferIdentifier()) {}
 
   InputFile(Kind, const llvm::MachO::InterfaceFile &);
 
 private:
   const Kind fileKind;
   const StringRef name;
 
   static int idCount;
 };
 
 // .o file
 class ObjFile final : public InputFile {
 public:
-  ObjFile(MemoryBufferRef mb, uint32_t modTime, StringRef archiveName);
+  ObjFile(MemoryBufferRef mb, uint32_t modTime, StringRef archiveName,
+          bool lazy = false);
   ArrayRef<llvm::MachO::data_in_code_entry> getDataInCode() const;
+  template <class LP> void parse();
 
   static bool classof(const InputFile *f) { return f->kind() == ObjKind; }
 
   llvm::DWARFUnit *compileUnit = nullptr;
   const uint32_t modTime;
   std::vector<ConcatInputSection *> debugSections;
   std::vector<CallGraphEntry> callGraph;
 
 private:
   Section *compactUnwindSection = nullptr;
 
-  template <class LP> void parse();
+  template <class LP> void parseLazy();
   template <class SectionHeader> void parseSections(ArrayRef<SectionHeader>);
   template <class LP>
   void parseSymbols(ArrayRef<typename LP::section> sectionHeaders,
                     ArrayRef<typename LP::nlist> nList, const char *strtab,
                     bool subsectionsViaSymbols);
   template <class NList>
   Symbol *parseNonSectionSymbol(const NList &sym, StringRef name);
   template <class SectionHeader>
private:
   // Keep track of children fetched from the archive by tracking
   // which address offsets have been fetched already.
   llvm::DenseSet<uint64_t> seen;
 };
 
 class BitcodeFile final : public InputFile {
 public:
   explicit BitcodeFile(MemoryBufferRef mb, StringRef archiveName,
-                       uint64_t offsetInArchive);
+                       uint64_t offsetInArchive, bool lazy = false);
   static bool classof(const InputFile *f) { return f->kind() == BitcodeKind; }
+  void parse();
+  void parseLazy();
 
   std::unique_ptr<llvm::lto::InputFile> obj;
 };
 
 extern llvm::SetVector<InputFile *> inputFiles;
 extern llvm::DenseMap<llvm::CachedHashStringRef, MemoryBufferRef> cachedReads;
 
 llvm::Optional<MemoryBufferRef> readFile(StringRef path);
 
+void extract(InputFile &file, StringRef reason);
+
 namespace detail {
 
 template <class CommandType, class... Types>
 std::vector<const CommandType *>
 findCommands(const void *anyHdr, size_t maxCommands, Types... types) {
   std::vector<const CommandType *> cmds;
   std::initializer_list<uint32_t> typesList{types...};
   const auto *hdr = reinterpret_cast<const llvm::MachO::mach_header *>(anyHdr);

lld/MachO/InputFiles.cpp

OpaqueFile::OpaqueFile(MemoryBufferRef mb, StringRef segName,
   ConcatInputSection *isec =
       make<ConcatInputSection>(segName.take_front(16), sectName.take_front(16),
                                /*file=*/this, data);
   isec->live = true;
   sections.push_back(0);
   sections.back().subsections.push_back({0, isec});
 }
 
-ObjFile::ObjFile(MemoryBufferRef mb, uint32_t modTime, StringRef archiveName)
-    : InputFile(ObjKind, mb), modTime(modTime) {
+ObjFile::ObjFile(MemoryBufferRef mb, uint32_t modTime, StringRef archiveName,
+                 bool lazy)
+    : InputFile(ObjKind, mb, lazy), modTime(modTime) {
   this->archiveName = std::string(archiveName);
+  if (lazy) {
+    if (target->wordSize == 8)
+      parseLazy<LP64>();
+    else
+      parseLazy<ILP32>();
+  } else {
     if (target->wordSize == 8)
       parse<LP64>();
     else
       parse<ILP32>();
   }
+}
 
 template <class LP> void ObjFile::parse() {
   using Header = typename LP::mach_header;
   using SegmentCommand = typename LP::segment_command;
   using SectionHeader = typename LP::section;
   using NList = typename LP::nlist;
 
   auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
if (!sections[i].subsections.empty())
       parseRelocations(sectionHeaders, sectionHeaders[i],
                        sections[i].subsections);
 
   parseDebugInfo();
   if (compactUnwindSection)
     registerCompactUnwind();
 }
 
+template <class LP> void ObjFile::parseLazy() {
+  using Header = typename LP::mach_header;
+  using NList = typename LP::nlist;
+
+  auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
+  auto *hdr = reinterpret_cast<const Header *>(mb.getBufferStart());
+  const load_command *cmd = findCommand(hdr, LC_SYMTAB);
+  if (!cmd)
+    return;
+  auto *c = reinterpret_cast<const symtab_command *>(cmd);
+  ArrayRef<NList> nList(reinterpret_cast<const NList *>(buf + c->symoff),
+                        c->nsyms);
+  const char *strtab = reinterpret_cast<const char *>(buf) + c->stroff;
+  symbols.resize(nList.size());
+  for (auto it : llvm::enumerate(nList)) {
+    const NList &sym = it.value();
+    if ((sym.n_type & N_EXT) && !isUndef(sym)) {
+      // TODO: Bound checking
+      StringRef name = strtab + sym.n_strx;
+      symbols[it.index()] = symtab->addLazyObject(name, *this);
+      if (!lazy)
+        break;
+    }
+  }
+}
+
 void ObjFile::parseDebugInfo() {
   std::unique_ptr<DwarfObject> dObj = DwarfObject::create(this);
   if (!dObj)
     return;
 
   auto *ctx = make<DWARFContext>(
       std::move(dObj), "",
       [&](Error err) {
return symtab->addDefined(name, &file, /*isec=*/nullptr, /*value=*/0,
                             /*size=*/0, objSym.isWeak(), isPrivateExtern,
                             /*isThumb=*/false,
                             /*isReferencedDynamically=*/false,
                             /*noDeadStrip=*/false,
                             /*isWeakDefCanBeHidden=*/false);
 }
 
 BitcodeFile::BitcodeFile(MemoryBufferRef mb, StringRef archiveName,
-                         uint64_t offsetInArchive)
-    : InputFile(BitcodeKind, mb) {
+                         uint64_t offsetInArchive, bool lazy)
+    : InputFile(BitcodeKind, mb, lazy) {
   this->archiveName = std::string(archiveName);
   std::string path = mb.getBufferIdentifier().str();
   // ThinLTO assumes that all MemoryBufferRefs given to it have a unique
   // name. If two members with the same name are provided, this causes a
   // collision and ThinLTO can't proceed.
   // So, we append the archive name to disambiguate two members with the same
   // name from multiple different archives, and offset within the archive to
   // disambiguate two members of the same name from a single archive.
   MemoryBufferRef mbref(
       mb.getBuffer(),
       saver.save(archiveName.empty() ? path
                                      : archiveName + sys::path::filename(path) +
                                            utostr(offsetInArchive)));
 
   obj = check(lto::InputFile::create(mbref));
+  if (lazy)
+    parseLazy();
+  else
+    parse();
+}
 
+void BitcodeFile::parse() {
   // Convert LTO Symbols to LLD Symbols in order to perform resolution. The
   // "winning" symbol will then be marked as Prevailing at LTO compilation
   // time.
+  symbols.clear();
   for (const lto::InputFile::Symbol &objSym : obj->symbols())
     symbols.push_back(createBitcodeSymbol(objSym, *this));
 }
 
+void BitcodeFile::parseLazy() {
+  symbols.resize(obj->symbols().size());
+  for (auto it : llvm::enumerate(obj->symbols())) {
+    const lto::InputFile::Symbol &objSym = it.value();
+    if (!objSym.isUndefined()) {
+      symbols[it.index()] =
+          symtab->addLazyObject(saver.save(objSym.getName()), *this);
+      if (!lazy)
+        break;
+    }
+  }
+}
+
+void macho::extract(InputFile &file, StringRef reason) {
+  assert(file.lazy);
+  file.lazy = false;
+  printArchiveMemberLoad(reason, &file);
+  if (auto *bitcode = dyn_cast<BitcodeFile>(&file)) {
+    bitcode->parse();
+  } else {
+    auto &f = cast<ObjFile>(file);
+    if (target->wordSize == 8)
+      f.parse<LP64>();
+    else
+      f.parse<ILP32>();
+  }
+}
+
 template void ObjFile::parse<LP64>();

lld/MachO/Options.td

def lto_O: Joined<["--"], "lto-O">,
     HelpText<"Set optimization level for LTO (default: 2)">,
     MetaVarName<"<opt-level>">,
     Group<grp_lld>;
 def thinlto_cache_policy: Joined<["--"], "thinlto-cache-policy=">,
     HelpText<"Pruning policy for the ThinLTO cache">,
     Group<grp_lld>;
 def O : JoinedOrSeparate<["-"], "O">,
     HelpText<"Optimize output file size">;
+def start_lib: Flag<["--"], "start-lib">,
+    HelpText<"Start a grouping of objects that should be treated as if they were together in an archive">;
+def end_lib: Flag<["--"], "end-lib">,
+    HelpText<"End a grouping of objects that should be treated as if they were together in an archive">;
 def no_warn_dylib_install_name: Joined<["--"], "no-warn-dylib-install-name">,
     HelpText<"Do not warn on -install-name if -dylib is not passed (default)">,
     Group<grp_lld>;
 def warn_dylib_install_name: Joined<["--"], "warn-dylib-install-name">,
     HelpText<"Warn on -install-name if -dylib is not passed">,
     Group<grp_lld>;
 def call_graph_profile_sort: Flag<["--"], "call-graph-profile-sort">,
     HelpText<"Reorder sections with call graph profile (default)">,

lld/MachO/SymbolTable.h

public:
   Symbol *addCommon(StringRef name, InputFile *, uint64_t size, uint32_t align,
                     bool isPrivateExtern);
 
   Symbol *addDylib(StringRef name, DylibFile *file, bool isWeakDef, bool isTlv);
   Symbol *addDynamicLookup(StringRef name);
 
   Symbol *addLazyArchive(StringRef name, ArchiveFile *file,
                          const llvm::object::Archive::Symbol &sym);
+  Symbol *addLazyObject(StringRef name, InputFile &file);
 
   Defined *addSynthetic(StringRef name, InputSection *, uint64_t value,
                         bool isPrivateExtern, bool includeInSymtab,
                         bool referencedDynamically);
 
   ArrayRef<Symbol *> getSymbols() const { return symVector; }
   Symbol *find(llvm::CachedHashStringRef name);
   Symbol *find(StringRef name) { return find(llvm::CachedHashStringRef(name)); }

lld/MachO/SymbolTable.cpp

Symbol *SymbolTable::addUndefined(StringRef name, InputFile *file,
   std::tie(s, wasInserted) = insert(name, file);
 
   RefState refState = isWeakRef ? RefState::Weak : RefState::Strong;
 
   if (wasInserted)
     replaceSymbol<Undefined>(s, name, file, refState);
   else if (auto *lazy = dyn_cast<LazyArchive>(s))
     lazy->fetchArchiveMember();
+  else if (isa<LazyObject>(s))
+    extract(*s->getFile(), s->getName());
   else if (auto *dynsym = dyn_cast<DylibSymbol>(s))
     dynsym->reference(refState);
   else if (auto *undefined = dyn_cast<Undefined>(s))
     undefined->refState = std::max(undefined->refState, refState);
   return s;
 }
 
 Symbol *SymbolTable::addCommon(StringRef name, InputFile *file, uint64_t size,
if (dysym->isWeakDef()) {
         file->fetch(sym);
       else
         replaceSymbol<LazyArchive>(s, file, sym);
     }
   }
   return s;
 }
 
+Symbol *SymbolTable::addLazyObject(StringRef name, InputFile &file) {
+  Symbol *s;
+  bool wasInserted;
+  std::tie(s, wasInserted) = insert(name, &file);
+
+  if (wasInserted) {
+    replaceSymbol<LazyObject>(s, file, name);
+  } else if (isa<Undefined>(s)) {
+    extract(file, name);
+  } else if (auto *dysym = dyn_cast<DylibSymbol>(s)) {
+    if (dysym->isWeakDef()) {
+      if (dysym->getRefState() != RefState::Unreferenced)
+        extract(file, name);
+      else
+        replaceSymbol<LazyObject>(s, file, name);
+    }
+  }
+  return s;
+}
+
 Defined *SymbolTable::addSynthetic(StringRef name, InputSection *isec,
                                    uint64_t value, bool isPrivateExtern,
                                    bool includeInSymtab,
                                    bool referencedDynamically) {
   Defined *s =
       addDefined(name, nullptr, isec, value, /*size=*/0,
                  /*isWeakDef=*/false, isPrivateExtern,
                  /*isThumb=*/false, referencedDynamically,

lld/MachO/Symbols.h

 class Symbol {
 public:
   enum Kind {
     DefinedKind,
     UndefinedKind,
     CommonKind,
     DylibKind,
     LazyArchiveKind,
+    LazyObjectKind,
   };
 
   virtual ~Symbol() {}
 
   Kind kind() const { return symbolKind; }
 
   StringRef getName() const {
     if (nameSize == (uint32_t)-1)
       nameSize = strlen(nameData);
     return {nameData, nameSize};
   }
 
   bool isLive() const { return used; }
+  bool isLazy() const {
+    return symbolKind == LazyArchiveKind || symbolKind == LazyObjectKind;
+  }
 
   virtual uint64_t getVA() const { return 0; }
 
   virtual bool isWeakDef() const { llvm_unreachable("cannot be weak def"); }
 
   // Only undefined or dylib symbols can be weak references. A weak reference
   // need not be satisfied at runtime, e.g. due to the symbol not being
   // available on a given target platform.
public:
   void fetchArchiveMember();
 
   static bool classof(const Symbol *s) { return s->kind() == LazyArchiveKind; }
 
 private:
   const llvm::object::Archive::Symbol sym;
 };
 
+// A defined symbol in an ObjFile/BitcodeFile surrounded by --start-lib and
+// --end-lib.
+class LazyObject : public Symbol {
+public:
+  LazyObject(InputFile &file, StringRef name)
+      : Symbol(LazyObjectKind, name, &file) {
+    isUsedInRegularObj = false;
+  }
+
+  static bool classof(const Symbol *s) { return s->kind() == LazyObjectKind; }
+};
+
 union SymbolUnion {
   alignas(Defined) char a[sizeof(Defined)];
   alignas(Undefined) char b[sizeof(Undefined)];
   alignas(CommonSymbol) char c[sizeof(CommonSymbol)];
   alignas(DylibSymbol) char d[sizeof(DylibSymbol)];
   alignas(LazyArchive) char e[sizeof(LazyArchive)];
+  alignas(LazyObject) char f[sizeof(LazyObject)];
 };
 
 template <typename T, typename... ArgT>
 T *replaceSymbol(Symbol *s, ArgT &&...arg) {
   static_assert(sizeof(T) <= sizeof(SymbolUnion), "SymbolUnion too small");
   static_assert(alignof(T) <= alignof(SymbolUnion),
                 "SymbolUnion not aligned enough");
   assert(static_cast<Symbol *>(static_cast<T *>(nullptr)) == nullptr &&

lld/MachO/UnwindInfoSection.cpp

if (auto *s = r.referent.dyn_cast<Symbol *>()) {
         // inconsistent with how symbol resolution usually work
         //
         // So we've decided not to follow it. Instead, simply pick the symbol
         // with the same name from the symbol table to replace the local one.
         //
         // (See discussions/alternatives already considered on D107533)
         if (!defined->isExternal())
           if (Symbol *sym = symtab->find(defined->getName()))
-            if (sym->kind() != Symbol::LazyArchiveKind)
+            if (!sym->isLazy())
               r.referent = s = sym;
       }
       if (auto *undefined = dyn_cast<Undefined>(s)) {
         treatUndefinedSymbol(*undefined);
         // treatUndefinedSymbol() can replace s with a DylibSymbol; re-check.
         if (isa<Undefined>(s))
           continue;
       }

lld/test/MachO/objc-uses-custom-personality.s

 ## Tests that lld correctly resolves the custom personality referenced by objc code in an archive.
 
 # REQUIRES: x86
 # RUN: rm -rf %t; split-file %s %t
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-iossimulator %t/defined.s -o %t/defined.o
 # RUN: yaml2obj %t/combined.yaml > %t/combined.o
 # RUN: llvm-ar r %t/pack.a %t/defined.o %t/combined.o
 # RUN: %lld -dylib -arch x86_64 -platform_version ios-simulator 12.0.0 15.0 -ObjC %t/pack.a -o %t/a.dylib
 # RUN: llvm-objdump --macho --syms %t/a.dylib | FileCheck %s
+# RUN: %lld -dylib -arch x86_64 -platform_version ios-simulator 12.0.0 15.0 -ObjC --start-lib %t/defined.o %t/combined.o --end-lib -o %t/a.dylib
+# RUN: llvm-objdump --macho --syms %t/a.dylib | FileCheck %s
 
 # CHECK: SYMBOL TABLE:
 # CHECK: {{.*}}  l     F __TEXT,__text _my_personality
 
 
 #--- defined.s
 .private_extern _my_personality
 

lld/test/MachO/objc.s

 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/test.s -o %t/test.o
 
 # RUN: %lld -lSystem %t/test.o -o %t/test -L%t -lHasSomeObjC -ObjC
 # RUN: llvm-objdump --section-headers --syms %t/test | FileCheck %s --check-prefix=OBJC
 
 # RUN: %lld -lSystem %t/test.o -o %t/test -L%t -lHasSomeObjC2 -ObjC
 # RUN: llvm-objdump --section-headers --syms %t/test | FileCheck %s --check-prefix=OBJC
 
+# RUN: %lld -lSystem %t/test.o -o %t/test --start-lib %t/no-objc.o %t/has-objc-symbol.o %t/has-objc-category.o %t/has-swift.o %t/wrong-arch.o --end-lib -ObjC
+# RUN: llvm-objdump --section-headers --syms %t/test | FileCheck %s --check-prefix=OBJC
+
 # OBJC:       Sections:
 # OBJC-NEXT:  Idx Name            Size   VMA  Type
 # OBJC-NEXT:    0 __text          {{.*}}      TEXT
 # OBJC-NEXT:    1 __swift         {{.*}}      DATA
 # OBJC-NEXT:    2 __objc_catlist  {{.*}}      DATA
 # OBJC-NEXT:    3 has_objc_symbol {{.*}}      DATA
 # OBJC-EMPTY:
 # OBJC-NEXT:  SYMBOL TABLE:
 # OBJC-NEXT:  g     F __TEXT,__text _main
-# OBJC-NEXT:  g     F __TEXT,__text _OBJC_CLASS_$_MyObject
+# OBJC:       g     F __TEXT,__text _OBJC_CLASS_$_MyObject
 
 # RUN: %lld -lSystem %t/test.o -o %t/test -L%t -lHasSomeObjC
 # RUN: llvm-objdump --section-headers --syms %t/test | FileCheck %s --check-prefix=NO-OBJC
 
 # NO-OBJC:       Sections:
 # NO-OBJC-NEXT:  Idx Name           Size   VMA  Type
 # NO-OBJC-NEXT:    0 __text         {{.*}}      TEXT
 # NO-OBJC-EMPTY:

lld/test/MachO/start-lib.s

+# REQUIRES: x86
+
+# RUN: rm -rf %t; split-file %s %t && cd %t
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin main.s -o main.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin calls-foo.s -o calls-foo.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin 1.s -o 1.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin 2.s -o 2.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin common.s -o common.o
+
+# RUN: llvm-as 1.ll -o 1.bc
+# RUN: llvm-as 2.ll -o 2.bc
+
+## Neither 1.o nor 2.o is loaded.
+# RUN: %lld main.o --start-lib 1.o 2.o --end-lib -why_load | count 0
+# RUN: %lld main.o --start-lib -filelist filelist --end-lib -why_load | count 0
+# RUN: llvm-readobj -s a.out | FileCheck %s
+# CHECK-NOT: Name: _foo
+# CHECK-NOT: Name: _bar
+
+## _bar loads 2.o. The last --end-lib can be omitted.
+# RUN: %lld main.o -u _bar --start-lib 1.o 2.o -t -why_load | FileCheck %s --check-prefix=CHECK2WHY
+# RUN: %lld main.o -u _bar --start-lib -filelist filelist -t -why_load | FileCheck %s --check-prefix=CHECK2WHY
+# RUN: llvm-readobj -s a.out | FileCheck --check-prefix=CHECK2 %s
+# CHECK2WHY:      main.o
+# CHECK2WHY-NEXT: 2.o
+# CHECK2WHY-NEXT: _bar forced load of 2.o
+# CHECK2WHY-EMPTY:
+# CHECK2-NOT: Name: _foo
+# CHECK2: Name: _bar
+# CHECK2-NOT: Name: _foo
+
+## _foo loads 1.o. 1.o loads 2.o.
+# RUN: %lld main.o -u _foo --start-lib 1.o 2.o -why_load | FileCheck %s --check-prefix=CHECK3WHY
+# RUN: llvm-readobj -s a.out | FileCheck --check-prefix=CHECK3 %s
+# RUN: %lld main.o -u _foo --start-lib 2.o --end-lib --start-lib 1.o -why_load | FileCheck %s --check-prefix=CHECK3WHY
+# RUN: llvm-readobj -s a.out | FileCheck --check-prefix=CHECK3 %s
+# CHECK3WHY:      _foo forced load of 1.o
+# CHECK3WHY-NEXT: _bar forced load of 2.o
+# CHECK3WHY-EMPTY:
+# CHECK3-DAG: Name: _foo
+# CHECK3-DAG: Name: _bar
+
+## Don't treat undefined _bar in 1.o as a lazy definition.
+# RUN: not %lld main.o -u _bar --start-lib 1.o 2>&1 | FileCheck %s --check-prefix=CHECK4
+# CHECK4: error: undefined symbol: _bar
+
+# RUN: %lld main.o -u _common --start-lib common.o
+# RUN: llvm-readobj -s a.out | FileCheck %s --check-prefix=COMMON1
+# COMMON1: Name: _common
+
+# RUN: %lld main.o --start-lib common.o
+# RUN: llvm-readobj -s a.out | FileCheck %s --check-prefix=COMMON2
+# COMMON2-NOT: Name: _common
+
+## Neither 1.bc nor 2.bc is loaded.
+# RUN: %lld main.o --start-lib 1.bc 2.bc -why_load | count 0
+# RUN: llvm-readobj -s a.out | FileCheck %s --check-prefix=BITCODE
+# BITCODE-NOT: Name: _foo
+# BITCODE-NOT: Name: _bar
+
+## _bar loads 2.bc.
+# RUN: %lld main.o -u _bar --start-lib 1.bc 2.bc -why_load | FileCheck %s --check-prefix=BITCODE2WHY
+# RUN: llvm-readobj -s a.out | FileCheck %s --check-prefix=BITCODE2
+# BITCODE2WHY:      _bar forced load of 2.bc
+# BITCODE2WHY-EMPTY:
+# BITCODE2-NOT: Name: _foo
+# BITCODE2: Name: _bar
+# BITCODE2-NOT: Name: _foo
+
+## calls-foo.o loads 1.bc. 1.bc loads 2.bc.
+# RUN: %lld calls-foo.o --start-lib 1.bc 2.bc -why_load | FileCheck %s --check-prefix=BITCODE3WHY
+# RUN: llvm-readobj -s a.out | FileCheck --check-prefix=BITCODE3 %s
+# RUN: %lld calls-foo.o --start-lib 2.bc --end-lib --start-lib 1.bc -why_load | FileCheck %s --check-prefix=BITCODE3WHY
+# RUN: llvm-readobj -s a.out | FileCheck --check-prefix=BITCODE3 %s
+# BITCODE3WHY:      _foo forced load of 1.bc
+# BITCODE3WHY-NEXT: _bar forced load of 2.bc
+# BITCODE3WHY-EMPTY:
+# BITCODE3-DAG: Name: _foo
+
+# RUN: not %lld main.o --start-lib --start-lib 2>&1 | FileCheck -check-prefix=NESTED-LIB %s
+# NESTED-LIB: error: nested --start-lib
+
+# RUN: not %lld --end-lib 2>&1 | FileCheck %s --check-prefix=STRAY
+# STRAY: error: stray --end-lib
+
+#--- main.s
+.globl _main
+_main:
+
+#--- calls-foo.s
+.globl _main
+_main:
+  call _foo
+
+#--- 1.s
+.globl _foo
+_foo:
+  call _bar
+
+#--- 2.s
+.globl _bar
+_bar:
+  ret
+
+#--- common.s
+.comm _common, 1
+
+#--- 1.ll
+target triple = "x86_64-apple-macosx10.15.0"
+target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+
+define void @foo() {
+  tail call void () @bar()
+  ret void
+}
+
+declare void @bar()
+
+#--- 2.ll
+target triple = "x86_64-apple-macosx10.15.0"
+target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+
+define void @bar() {
+  ret void
+}
+
+#--- filelist
+1.o
+2.o

lld/test/MachO/weak-definition-direct-fetch.s

 ## The next 5 chunks refs-foo.symbol pairs of different types.
 
 ## (Weak) archive symbols take precedence over weak dylib symbols.
 # RUN: %lld -lSystem -o %t/weak-dylib-weak-ar -L%t -lweakfoo %t/weakfoo.a %t/refs-foo.o
 # RUN: llvm-objdump --macho --lazy-bind --syms %t/weak-dylib-weak-ar | FileCheck %s --check-prefix=PREFER-WEAK-OBJECT
 # RUN: %lld -lSystem -o %t/weak-ar-weak-dylib -L%t %t/weakfoo.a -lweakfoo %t/refs-foo.o
 # RUN: llvm-objdump --macho --lazy-bind --syms %t/weak-ar-weak-dylib | FileCheck %s --check-prefix=PREFER-WEAK-OBJECT
 
+# RUN: %lld -lSystem -o %t/weak-dylib-weak-ar -L%t -lweakfoo --start-lib %t/weakfoo.o --end-lib %t/refs-foo.o
+# RUN: llvm-objdump --macho --lazy-bind --syms %t/weak-dylib-weak-ar | FileCheck %s --check-prefix=PREFER-WEAK-OBJECT
+# RUN: %lld -lSystem -o %t/weak-ar-weak-dylib -L%t --start-lib %t/weakfoo.o --end-lib -lweakfoo %t/refs-foo.o
+# RUN: llvm-objdump --macho --lazy-bind --syms %t/weak-ar-weak-dylib | FileCheck %s --check-prefix=PREFER-WEAK-OBJECT
+
 ## (Weak) archive symbols have the same precedence as dylib symbols.
 # RUN: %lld -lSystem -o %t/weak-ar-nonweak-dylib -L%t %t/weakfoo.a -lfoo %t/refs-foo.o
 # RUN: llvm-objdump --macho --lazy-bind --syms %t/weak-ar-nonweak-dylib | FileCheck %s --check-prefix=PREFER-WEAK-OBJECT
 # RUN: %lld -lSystem -o %t/nonweak-dylib-weak-ar -L%t -lfoo %t/weakfoo.a %t/refs-foo.o
 # RUN: llvm-objdump --macho --lazy-bind --syms %t/nonweak-dylib-weak-ar | FileCheck %s --check-prefix=PREFER-NONWEAK-DYLIB
 
 ## Weak defined symbols take precedence over weak dylib symbols.
 # RUN: %lld -lSystem -o %t/weak-dylib-weak-obj -L%t -lweakfoo %t/weakfoo.o %t/refs-foo.o

 
 ## Regression test: A weak dylib symbol that isn't referenced by an undefined
 ## symbol should not cause an archive symbol to get loaded.
 # RUN: %lld -dylib -lSystem -o %t/weak-ar-weak-unref-dylib -L%t %t/weakfoo.a -lweakfoo
 # RUN: llvm-objdump --macho --lazy-bind --syms %t/weak-ar-weak-unref-dylib | FileCheck %s --check-prefix=NO-SYM
 # RUN: %lld -dylib -lSystem -o %t/weak-unref-dylib-weak-ar -L%t -lweakfoo %t/weakfoo.a
 # RUN: llvm-objdump --macho --lazy-bind --syms %t/weak-unref-dylib-weak-ar | FileCheck %s --check-prefix=NO-SYM
 
+# RUN: %lld -dylib -lSystem -o %t/weak-ar-weak-unref-dylib -L%t --start-lib %t/weakfoo.o --end-lib -lweakfoo
+# RUN: llvm-objdump --macho --lazy-bind --syms %t/weak-ar-weak-unref-dylib | FileCheck %s --check-prefix=NO-SYM
+# RUN: %lld -dylib -lSystem -o %t/weak-unref-dylib-weak-ar -L%t -lweakfoo --start-lib %t/weakfoo.o --end-lib
+# RUN: llvm-objdump --macho --lazy-bind --syms %t/weak-unref-dylib-weak-ar | FileCheck %s --check-prefix=NO-SYM
+
 ## However, weak references are sufficient to cause the archive to be loaded.
 # RUN: %lld -dylib -lSystem -o %t/weak-ar-weak-ref-weak-dylib -L%t %t/weakfoo.a -lweakfoo %t/weak-refs-foo.o
 # RUN: llvm-objdump --macho --lazy-bind --syms %t/weak-ar-weak-ref-weak-dylib | FileCheck %s --check-prefix=PREFER-WEAK-OBJECT
 # RUN: %lld -dylib -lSystem -o %t/weak-ref-weak-dylib-weak-ar -L%t -lweakfoo %t/weakfoo.a %t/weak-refs-foo.o
 # RUN: llvm-objdump --macho --lazy-bind --syms %t/weak-ref-weak-dylib-weak-ar | FileCheck %s --check-prefix=PREFER-WEAK-OBJECT
 # RUN: %lld -dylib -lSystem -o %t/weak-ref-weak-dylib-weak-ar -L%t -lweakfoo %t/weak-refs-foo.o %t/weakfoo.a
 # RUN: llvm-objdump --macho --lazy-bind --syms %t/weak-ref-weak-dylib-weak-ar | FileCheck %s --check-prefix=PREFER-WEAK-OBJECT
 
+# RUN: %lld -dylib -lSystem -o %t/weak-ar-weak-ref-weak-dylib -L%t --start-lib %t/weakfoo.o --end-lib -lweakfoo %t/weak-refs-foo.o
+# RUN: llvm-objdump --macho --lazy-bind --syms %t/weak-ar-weak-ref-weak-dylib | FileCheck %s --check-prefix=PREFER-WEAK-OBJECT
+# RUN: %lld -dylib -lSystem -o %t/weak-ref-weak-dylib-weak-ar -L%t -lweakfoo --start-lib %t/weakfoo.o --end-lib %t/weak-refs-foo.o
+# RUN: llvm-objdump --macho --lazy-bind --syms %t/weak-ref-weak-dylib-weak-ar | FileCheck %s --check-prefix=PREFER-WEAK-OBJECT
+# RUN: %lld -dylib -lSystem -o %t/weak-ref-weak-dylib-weak-ar -L%t -lweakfoo %t/weak-refs-foo.o --start-lib %t/weakfoo.o --end-lib
+# RUN: llvm-objdump --macho --lazy-bind --syms %t/weak-ref-weak-dylib-weak-ar | FileCheck %s --check-prefix=PREFER-WEAK-OBJECT
+
 #--- foo.s
 .globl _foo
 .section __TEXT,nonweak
 _foo:
 
 #--- weakfoo.s
 .globl _foo
 .weak_definition _foo