Reland "[lld] Preliminary fat-lto-object support"

[paulkirth]

Summary

This patch adds support to lld for --fat-lto-objects. We add a new
--fat-lto-objects option to LLD, and slightly change how it chooses input
files in the driver when the option is set.

Fat LTO objects contain both LTO compatible IR, as well as generated object
code. This allows users to defer the choice of whether to use LTO or not to
link-time. This is a feature available in GCC for some time, and makes the
existing -ffat-lto-objects option functional in the same way as GCC's.

If the --fat-lto-objects option is passed to LLD and the input files are fat
object files, then the linker will chose the LTO compatible bitcode sections
embedded within the fat object and link them together using LTO. Otherwise,
standard object file linking is done using the assembly section in the object
files.

The previous version of this patch had a missing REQUIRES: x86 line in
fatlto.invalid.s. Additionally, it was reported that this patch caused
a test failure in export-dynamic-symbols.s, however,
29112a994694baee070a2021e00f772f1913d214 disabled the
export-dynamic-symbols.s test on Windows due to a quotation difference
between platforms, unrelated to this patch.

Original RFC: https://discourse.llvm.org/t/rfc-ffat-lto-objects-support/63977

[paulkirth]

remove unused yaml input files for testing

[paulkirth]

Fix typo in test code.

[paulkirth]

Fix typo in title

[paulkirth]

Rebase.

[paulkirth]

Rebase.

[paulkirth]

Rebase.

[paulkirth]

Add release note

[paulkirth]

Rebase

[paulkirth]

Rebase

[paulkirth]

rebase

[aeubanks]

lld/docs/ReleaseNotes.rst

29

typo

[paulkirth]

Fix typo

[paulkirth]

Rebase.

[paulkirth]

rebase

[paulkirth]

Rebase

[paulkirth]

Rebase

[paulkirth]

Rebase.

[MaskRay]

Thanks. This looks mostly good but archives need to be implemented.

If the -fat-lto-objects flag is passed to LLD and the input files are fat

If the --fat-lto-objects option is ...

lld/ELF/Options.td

647

BB

Don't allow single-dash long options for new options.

defm fat_lto_objects

lld/docs/ReleaseNotes.rst

34

Double backsticks. Prefer option over flag especially for linkers.

lld/test/ELF/fatlto/Inputs/a-LTO.ll

1 ↗

(On Diff #532273)

Extra files can be avoided with split-file

lld/test/ELF/fatlto/fatlto.test

5

Add period for complete sentences throughout.

Delete ;; Clean up and initialize test dir which is not too useful.

6

; RUN: rm -rf %t && mkdir %t && cd %t

Do this in one line and you can avoid %t/ below...

[MaskRay]

lld/ELF/Driver.cpp

340

Add a test that the .llvm.lto has invalid LLVM IR.

You can use .section .llvm.lto,"e" in assembly to construct such a test case.

2860

This code can be avoided if .llvm.lto has the SHF_EXCLUDE flag.

lld/test/ELF/fatlto/Inputs/a-LTO.ll

5 ↗

(On Diff #532273)

Add a _start function to prevent a linker warning. Maybe just change a to _start

lld/test/ELF/fatlto/fatlto.test

25

--fat-lto-objects

30

We should test --start-lib (inLib) and fat lto objects in an archive.

54

This obj2yaml comparison is not common. Just use cmp foo-fatNoLTO foo-noLTO

[paulkirth]

Rebase

[paulkirth]

Fix some comments

• update option to use --
• remove check against .llvm.lto string
• update some test checks w/ new flag & mark .llvm.lto section exclude w/ objcopy

There are still several comments to address regarding tests.

[MaskRay]

I wonder whether --fat-lto-objects should be the default. Since clang -ffat-lto-objects is an opt-in feature, we don't need to worry about default --fat-lto-objects breaking existing users.
AFAIK LLVMgold defaults to --fat-lto-objects (currently there is no -?-plugin-opt= option to toggle this feature, but it'd be nice to have one.

[MaskRay]

lld/test/ELF/fatlto/Inputs/main-LTO.ll

30 ↗

(On Diff #535529)

This can be omitted. If not, having the 15.0.0 identifier for a 17.0.0 or 18.0.0 feature lures readers to think that this may be available for 15.0.0

[MaskRay]

lld/test/ELF/fatlto/Inputs/main-LTO.ll

30 ↗

(On Diff #535529)

I think we can use very simple IR to improve signal-to-noise ratio. ls -lS should list some very simple IR, e.g. inline-asm.ll

[paulkirth]

Rebase and address comments.

• Add archive support
• Update tests to use split-file
• Add test for invalid IR
• Use normal comparison

This still needs to get a test for inLib and for archives.

Also, in Driver.cpp, the FatLTO support seems a bit repetitive, so I plan to
simplify w/ a helper function, but wanted to be sure I've handled the new cases
for archives correctly first before refactoring.

[paulkirth]

Introduce helper function to reduce repeated code and add tests for archive and --start-lib

[paulkirth]

lld/test/ELF/fatlto/fatlto.test

6

I opted to leave %t/, but have refactored to combine the rm -rf and split-file

[MaskRay]

man lld/docs/ld.lld.1. Can you also add the option to the manpage?

lld/test/ELF/fatlto/fatlto.test

7

Ditto everywhere

10

--add-section=.llvm.lto=%t/a-fatLTO.bc --set-section-flags=.llvm.lto=exclude

12

This llvm-readobj -S %t/a-fatLTO.o check is unneeded. The operation is tested in test/tools/llvm-objcopy/ELF.

20

This llvm-readobj -S %t/main-fatLTO.o check is unneeded.

28

[paulkirth]

Rebase and address comments

[paulkirth]

Add --fat-lto-objects to man page documentation

[paulkirth]

Revise manapge text for clarity

[paulkirth]

lld/docs/ld.lld.1

624–627

I think this reads pretty naturally, but I'll defer to @MaskRay on the final text.

[MaskRay]

lld/ELF/Options.td

648

relocatable object file

lld/docs/ReleaseNotes.rst

34

`--fat-lto-objects` option is added to support LLVM FatLTO.

lld/docs/ld.lld.1

624–627

Perhaps

.It Fl -fat-lto-objects
Use the .llvm.lto section, which contains LLVM bitcode, in fat LTO object files to perform LTO.
.It Fl -no-fat-lto-objects
Ignore the .llvm.lto section in relocatable object files (default).

You can use man docs/ld.lld.1 to check the content. Fl appends a dash itself...

[paulkirth]

Address comments

• update man page text
• use relocatable object file more consistently
• slightly revise text in release notes.

[MaskRay]

lld/ELF/Options.td

648

This can reuse the manpage description.

For example, the ".text" part in "Use the .text section in the relocatable object file (default)" is not accurate.

lld/test/ELF/fatlto/fatlto.invalid.s

5

Add error: is present in the diagnostic.

11

delete trailing blank line

lld/test/ELF/fatlto/fatlto.test

107

We should not test module summary index. They are unstable and may change, and cause hassle for future LTO changes. This part should be generated by opt --module-summary.

[paulkirth]

Fix some test issues.

• remove summaries from IR, and generate them w/ opt
• improve error checking in fatlto.invalid.s
• reuse wording from man page in help text

[paulkirth]

@MaskRay the CI failures here and in D152973 seem unrelated to the FatLTO patches (e.g. MLIR + windows).

Are we good w/ landing the linker support for LLD + gold now, or would you prefer that I rebase these and get the premerge checks passing first?

[MaskRay]

In D146778#4516124, @paulkirth wrote:

@MaskRay the CI failures here and in D152973 seem unrelated to the FatLTO patches (e.g. MLIR + windows).

Are we good w/ landing the linker support for LLD + gold now, or would you prefer that I rebase these and get the premerge checks passing first?

You may land this patch after fixing a "Support" nit for the release note. I have applied this patch and check-lld-elf passes.

You can also land the gold patch. Pre-commit build bots don't seem to check binutils. You'll need a local checkout of binutils-gdb, e.g. -DLLVM_BINUTILS_INCDIR=$HOME/Dev/binutils-gdb/include.

lld/docs/ReleaseNotes.rst

34

Support should not be capitalized.

[chapuni]

lld/test/ELF/fatlto/fatlto.test

55

Should this test be suppressed if x86 is uncofigred?

[paulkirth]

lld/test/ELF/fatlto/fatlto.test

55

Doesn’t this test have a requires x86 line?

[chapuni]

lld/test/ELF/fatlto/fatlto.invalid.s

2

This should be suppressed, too.

lld/test/ELF/fatlto/fatlto.test

55

Sorry, this has required x86. fatlto.invalid.s doesn't.

[paulkirth]

lld/test/ELF/fatlto/fatlto.test

55

Oh shoot. Sorry about that. I’m mid commute atm. If you could revert or forward fix I’d appreciate it. Otherwise I can get to this in about 40 minutes.

[ormris]

Hey, an LLD test is failing on our buildbot after this was committed. Could you take a look?

https://lab.llvm.org/buildbot/#/builders/216/builds/24150

[paulkirth]

@ormris, sorry for the delay on responding, I saw the forward fix go out and didn't check for a couple hours. I've reverted this for now until I can properly investigate, since I still see that bot having an issue after the forward fix.

[paulkirth]

Rebase, add REQUIRES line in test, and update summary

Looks like the windows failure was unrelated to the previous patch, and
that test is now unsupported on windows.

[paulkirth]

@MaskRay, I see that 29112a994694baee070a2021e00f772f1913d214 seems to have disabled the export-dynamic-symbols.s test on Windows, which was what was failing previously in CI. Would you be OK w/ a reland now that the REQUIRES line is in both tests, and the windows failure was unrelated?

[paulkirth]

Actually update summary on phabricator.

[paulkirth]

Fix typo in summary.

[paulkirth]

@MaskRay are we OK w/ landing this now? We've reached consensus on the gold patch, so I think these should go in relatively close to one another.

[MaskRay]

In D146778#4595744, @paulkirth wrote:

@MaskRay are we OK w/ landing this now? We've reached consensus on the gold patch, so I think these should go in relatively close to one another.

LGTM. Please double check this works. We don't want more reverts.

lld/ELF/Config.h

public:
   void addFile(StringRef path, bool withLOption);
   void addLibrary(StringRef name);
 
 private:
   void createFiles(llvm::opt::InputArgList &args);
   void inferMachineType();
   void link(llvm::opt::InputArgList &args);
   template <class ELFT> void compileBitcodeFiles(bool skipLinkedOutput);
-
+  bool tryAddFatLTOFile(MemoryBufferRef mb, StringRef archiveName,
+                        uint64_t offsetInArchive, bool lazy);
   // True if we are in --whole-archive and --no-whole-archive.
   bool inWholeArchive = false;
 
   // True if we are in --start-lib and --end-lib.
   bool inLib = false;
 
   std::unique_ptr<BitcodeCompiler> lto;
   std::vector<InputFile *> files;
struct Config {
   llvm::SmallVector<SymbolVersion, 0> dynamicList;
   llvm::SmallVector<uint8_t, 0> buildIdVector;
   llvm::SmallVector<llvm::StringRef, 0> mllvmOpts;
   llvm::MapVector<std::pair<const InputSectionBase *, const InputSectionBase *>,
                   uint64_t>
       callGraphProfile;
   bool cmseImplib = false;
   bool allowMultipleDefinition;
+  bool fatLTOObjects;
   bool androidPackDynRelocs = false;
   bool armHasBlx = false;
   bool armHasMovtMovw = false;
   bool armJ1J2BranchEncoding = false;
   bool armCMSESupport = false;
   bool asNeeded = false;
   bool armBe8 = false;
   BsymbolicKind bsymbolic = BsymbolicKind::None;

lld/ELF/Driver.cpp

 #include "lld/Common/TargetOptionsCommandFlags.h"
 #include "lld/Common/Version.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/LTO/LTO.h"
 #include "llvm/Object/Archive.h"
+#include "llvm/Object/IRObjectFile.h"
 #include "llvm/Remarks/HotnessThresholdParser.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/GlobPattern.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/Parallel.h"
 #include "llvm/Support/Path.h"
std::vector<std::pair<MemoryBufferRef, uint64_t>> static getArchiveMembers(
 
   return v;
 }
 
 static bool isBitcode(MemoryBufferRef mb) {
   return identify_magic(mb.getBuffer()) == llvm::file_magic::bitcode;
 }
 
+bool LinkerDriver::tryAddFatLTOFile(MemoryBufferRef mb, StringRef archiveName,
+                                    uint64_t offsetInArchive, bool lazy) {
+  if (!config->fatLTOObjects)
+    return false;
+  Expected<MemoryBufferRef> fatLTOData =
+      IRObjectFile::findBitcodeInMemBuffer(mb);
+  if (errorToBool(fatLTOData.takeError()))
+    return false;
+  files.push_back(
+      make<BitcodeFile>(*fatLTOData, archiveName, offsetInArchive, lazy));
+  return true;
+}
+
 // Opens a file and create a file object. Path has to be resolved already.
 void LinkerDriver::addFile(StringRef path, bool withLOption) {
   using namespace sys::fs;
 
   std::optional<MemoryBufferRef> buffer = readFile(path);
   if (!buffer)
     return;
   MemoryBufferRef mbref = *buffer;
 
   if (config->formatBinary) {
     files.push_back(make<BinaryFile>(mbref));
     return;
   }
 
   switch (identify_magic(mbref.getBuffer())) {
   case file_magic::unknown:
     readLinkerScript(mbref);
     return;
   case file_magic::archive: {
     auto members = getArchiveMembers(mbref);
     if (inWholeArchive) {
       for (const std::pair<MemoryBufferRef, uint64_t> &p : members) {
         if (isBitcode(p.first))
           files.push_back(make<BitcodeFile>(p.first, path, p.second, false));
-        else
+        else if (!tryAddFatLTOFile(p.first, path, p.second, false))
           files.push_back(createObjFile(p.first, path));
       }
       return;
     }
 
     archiveFiles.emplace_back(path, members.size());
 
     // Handle archives and --start-lib/--end-lib using the same code path. This
     // scans all the ELF relocatable object files and bitcode files in the
     // archive rather than just the index file, with the benefit that the
     // symbols are only loaded once. For many projects archives see high
     // utilization rates and it is a net performance win. --start-lib scans
     // symbols in the same order that llvm-ar adds them to the index, so in the
     // common case the semantics are identical. If the archive symbol table was
     // created in a different order, or is incomplete, this strategy has
     // different semantics. Such output differences are considered user error.
     //
     // All files within the archive get the same group ID to allow mutual
     // references for --warn-backrefs.
     bool saved = InputFile::isInGroup;
     InputFile::isInGroup = true;
     for (const std::pair<MemoryBufferRef, uint64_t> &p : members) {
       auto magic = identify_magic(p.first.getBuffer());
-      if (magic == file_magic::elf_relocatable)
+      if (magic == file_magic::elf_relocatable) {
+        if (!tryAddFatLTOFile(p.first, path, p.second, true))
           files.push_back(createObjFile(p.first, path, true));
-      else if (magic == file_magic::bitcode)
+      } else if (magic == file_magic::bitcode)
         files.push_back(make<BitcodeFile>(p.first, path, p.second, true));
       else
         warn(path + ": archive member '" + p.first.getBufferIdentifier() +
              "' is neither ET_REL nor LLVM bitcode");
     }
     InputFile::isInGroup = saved;
     if (!saved)
       ++InputFile::nextGroupId;
case file_magic::elf_shared_object: {
     f->init();
     files.push_back(f);
     return;
   }
   case file_magic::bitcode:
     files.push_back(make<BitcodeFile>(mbref, "", 0, inLib));
     break;
   case file_magic::elf_relocatable:
+    if (!tryAddFatLTOFile(mbref, "", 0, inLib))
       files.push_back(createObjFile(mbref, "", inLib));
     break;
   default:
     error(path + ": unknown file type");
   }
 }
 
 // Add a given library by searching it from input search paths.
 void LinkerDriver::addLibrary(StringRef name) {
   if (std::optional<std::string> path = searchLibrary(name))
     addFile(saver().save(*path), /*withLOption=*/true);
static void readConfigs(opt::InputArgList &args) {
   config->allowMultipleDefinition =
       args.hasFlag(OPT_allow_multiple_definition,
                    OPT_no_allow_multiple_definition, false) ||
       hasZOption(args, "muldefs");
   config->androidMemtagHeap =
       args.hasFlag(OPT_android_memtag_heap, OPT_no_android_memtag_heap, false);
   config->androidMemtagStack = args.hasFlag(OPT_android_memtag_stack,
                                             OPT_no_android_memtag_stack, false);
+  config->fatLTOObjects =
+      args.hasFlag(OPT_fat_lto_objects, OPT_no_fat_lto_objects, false);
   config->androidMemtagMode = getMemtagMode(args);
   config->auxiliaryList = args::getStrings(args, OPT_auxiliary);
   config->armBe8 = args.hasArg(OPT_be8);
   if (opt::Arg *arg =
           args.getLastArg(OPT_Bno_symbolic, OPT_Bsymbolic_non_weak_functions,
                           OPT_Bsymbolic_functions, OPT_Bsymbolic)) {
     if (arg->getOption().matches(OPT_Bsymbolic_non_weak_functions))
       config->bsymbolic = BsymbolicKind::NonWeakFunctions;
replaceCommonSymbols();
     // Now that we have a complete list of input files.
     // Beyond this point, no new files are added.
     // Aggregate all input sections into one place.
     for (InputFile *f : ctx.objectFiles) {
       for (InputSectionBase *s : f->getSections()) {
         if (!s || s == &InputSection::discarded)
           continue;
         if (LLVM_UNLIKELY(isa<EhInputSection>(s)))
           ctx.ehInputSections.push_back(cast<EhInputSection>(s));
         else
           ctx.inputSections.push_back(s);
       }
     }
     for (BinaryFile *f : ctx.binaryFiles)
       for (InputSectionBase *s : f->getSections())
         ctx.inputSections.push_back(cast<InputSection>(s));
   }

lld/ELF/Options.td

 def thinlto_index_only_eq: JJ<"thinlto-index-only=">;
 def thinlto_jobs_eq: JJ<"thinlto-jobs=">,
   HelpText<"Number of ThinLTO jobs. Default to --threads=">;
 def thinlto_object_suffix_replace_eq: JJ<"thinlto-object-suffix-replace=">;
 def thinlto_prefix_replace_eq: JJ<"thinlto-prefix-replace=">;
 def thinlto_single_module_eq: JJ<"thinlto-single-module=">,
   HelpText<"Specify a single module to compile in ThinLTO mode, for debugging only">;
 
+defm fat_lto_objects: BB<"fat-lto-objects",
+    "Use the embedded bitcode in the .llvm.lto section of the object file",
+    "Use the assembly in the object file (default)">;
+
 def: J<"plugin-opt=O">, Alias<lto_O>, HelpText<"Alias for --lto-O">;
 def: F<"plugin-opt=debug-pass-manager">,
   Alias<lto_debug_pass_manager>, HelpText<"Alias for --lto-debug-pass-manager">;
 def: F<"plugin-opt=disable-verify">, Alias<disable_verify>, HelpText<"Alias for --disable-verify">;
 def plugin_opt_dwo_dir_eq: J<"plugin-opt=dwo_dir=">,
   HelpText<"Directory to store .dwo files when LTO and debug fission are used">;
 def plugin_opt_emit_asm: F<"plugin-opt=emit-asm">,
   Alias<lto_emit_asm>, HelpText<"Alias for --lto-emit-asm">;

lld/docs/ReleaseNotes.rst

 from the `LLVM releases web site <https://llvm.org/releases/>`_.
 
 Non-comprehensive list of changes in this release
 =================================================
 
 ELF Improvements
 ----------------
 
 * ``--remap-inputs=`` and ``--remap-inputs-file=`` are added to remap input files.
   (`D148859 <https://reviews.llvm.org/D148859>`_)
 * ``PT_RISCV_ATTRIBUTES`` is added to include the SHT_RISCV_ATTRIBUTES section.
   (`D152065 <https://reviews.llvm.org/D152065>`_)
 
+- Support LTO with LLVM FatLTO objects by adding the ``--fat-lto-objects`` option.
+  Without ``--fat-lto-objects``, LLD will link FatLTO objects without LTO.
+  (`D146778 <https://reviews.llvm.org/D146778>`_)
+
 Breaking changes
 ----------------
 
 COFF Improvements
 -----------------
 
 * lld-link can now find libraries with relative paths that are relative to
   `/libpath`. Before it would only be able to find libraries relative to the

lld/docs/ld.lld.1

 .It Fl -thinlto-jobs Ns = Ns Ar value
 Number of ThinLTO jobs.
 .It Fl -threads Ns = Ns Ar N
 Number of threads.
 .Cm all
 (default) means all of concurrent threads supported.
 .Cm 1
 disables multi-threading.
+.It Fl --no-fat-lto-objects
+Select the .text object code section of fat lto object files(use traditional linking).
+.It Fl --fat-lto-objects
+Select the .llvm.lto bitcode section of fat lto object files(use LTO).
 .It Fl -time-trace
 Record time trace.
 .It Fl -time-trace-file Ns = Ns Ar file
 Write time trace output to
 .Ar file .
 .It Fl -time-trace-granularity Ns = Ns Ar value
 Minimum time granularity (in microseconds) traced by time profiler.
 .It Fl -trace

lld/test/ELF/fatlto/fatlto.invalid.s

+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+# RUN: not ld.lld %t -o /dev/null --fat-lto-objects 2>&1 | FileCheck %s
+
+# CHECK: Invalid bitcode signature
+
+.section        .llvm.lto,"e",@progbits
+.Lllvm.embedded.object:
+        .asciz  "BC\300\3365\000"
+        .size   .Lllvm.embedded.object, 12
+

lld/test/ELF/fatlto/fatlto.test

+;; Basic FatLTO tests.
+; REQUIRES: x86
+
+; RUN: rm -rf %t && split-file %s %t
+
+;; Ensure that input files contain .llvm.lto section.
+; RUN: llc %t/a-LTO.ll --filetype=obj -o %t/a-fatLTO.o
+; RUN: llvm-as %t/a-LTO.ll -o %t/a-fatLTO.bc
+; RUN: llvm-objcopy --add-section=.llvm.lto=%t/a-fatLTO.bc --set-section-flags=.llvm.lto=exclude %t/a-fatLTO.o
+
+; RUN: llc %t/main-LTO.ll --filetype=obj -o %t/main-fatLTO.o
+; RUN: llvm-as %t/main-LTO.ll -o %t/main-fatLTO.bc
+; RUN: llvm-objcopy --add-section=.llvm.lto=%t/main-fatLTO.bc --set-section-flags=.llvm.lto=exclude %t/main-fatLTO.o
+
+;; Final executable should not have .llvm.lto section no matter what the target is.
+; RUN: ld.lld -o %t/foo-fatLTO %t/a-fatLTO.o %t/main-fatLTO.o --fat-lto-objects
+; RUN: llvm-readobj -S %t/foo-fatLTO | FileCheck --check-prefix=CHECK-LTO-TARGET %s
+
+;; Check that fat objects work w/ --start-lib.
+; RUN: ld.lld -o %t/foo-fatLTO.start_lib --start-lib %t/a-fatLTO.o %t/main-fatLTO.o --fat-lto-objects
+; RUN: llvm-readobj -S %t/foo-fatLTO.start_lib | FileCheck --check-prefix=CHECK-LTO-TARGET %s
+
+;; Check if .llvm.lto section gets aggregated in LTO target.
+; CHECK-LTO-TARGET-NOT: Name: .llvm.lto
+
+;; Final executable should not have .llvm.lto section no matter what the target is.
+; RUN: ld.lld -o %t/foo-fatNoLTO %t/a-fatLTO.o %/t/main-fatLTO.o
+; RUN: llvm-readobj -S %t/foo-fatNoLTO | FileCheck --check-prefix=CHECK-NON-LTO-TARGET %s
+
+;; Check if .llvm.lto section gets aggregated in non-LTO target.
+; CHECK-NON-LTO-TARGET-NOT: Name: .llvm.lto
+
+;; Check if the LTO target executable produced from FatLTO object file is
+;; identical to the one produced from LTO modules.
+; RUN: llvm-as %t/a-LTO.ll -o %t/a-LTO.bc
+; RUN: llvm-as %t/main-LTO.ll -o %t/main-LTO.bc
+; RUN: ld.lld -o %t/foo-LTO %t/a-LTO.bc %t/main-LTO.bc
+; RUN: cmp %t/foo-fatLTO %t/foo-LTO
+
+;; Check if the no-LTO target executable produced from FatLTO object file is
+;; identical to the one produced from regular object files.
+; RUN: llc %t/a-LTO.ll --filetype=obj -o %t/a.o
+; RUN: llc %t/main-LTO.ll --filetype=obj -o %t/main.o
+; RUN: ld.lld -o %t/foo-noLTO %t/a.o %t/main.o
+; RUN: cmp %t/foo-fatNoLTO %t/foo-noLTO
+
+;; Check archive support.
+; RUN: llvm-ar rcs %t/a.a %t/a-fatLTO.o 
+; RUN: ld.lld -o %t/foo-fatLTO.archive %t/a.a %t/main-LTO.bc --fat-lto-objects
+; RUN: cmp %t/foo-fatLTO.archive %t/foo-LTO
+
+;--- a-LTO.ll
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; Function Attrs: noinline nounwind uwtable
+define dso_local i32 @_start() #0 {
+entry:
+  ret i32 0
+}
+
+attributes #0 = { noinline nounwind uwtable }
+
+!llvm.module.flags = !{!0, !1, !2, !3, !4, !5, !6}
+
+!0 = !{i32 1, !"wchar_size", i32 4}
+!1 = !{i32 7, !"PIC Level", i32 2}
+!2 = !{i32 7, !"PIE Level", i32 2}
+!3 = !{i32 7, !"uwtable", i32 2}
+!4 = !{i32 7, !"frame-pointer", i32 2}
+!5 = !{i32 1, !"ThinLTO", i32 0}
+!6 = !{i32 1, !"EnableSplitLTOUnit", i32 1}
+
+^0 = module: (path: "a-LTO.bc", hash: (0, 0, 0, 0, 0))
+^1 = gv: (name: "_start", summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 1, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 1, funcFlags: (readNone: 0, readOnly: 0, noRecurse: 0, returnDoesNotAlias: 0, noInline: 1, alwaysInline: 0, noUnwind: 1, mayThrow: 0, hasUnknownCall: 0, mustBeUnreachable: 0)))) ; guid = 12157170054180749580
+^2 = flags: 8
+^3 = blockcount: 1
+
+;--- main-LTO.ll
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; Function Attrs: noinline nounwind uwtable
+define dso_local i32 @main() #0 {
+entry:
+  %retval = alloca i32, align 4
+  store i32 0, ptr %retval, align 4
+  %call = call i32 (...) @_start()
+  ret i32 %call
+}
+
+declare i32 @_start(...)
+
+attributes #0 = { noinline nounwind uwtable }
+
+!llvm.module.flags = !{!0, !1, !2, !3, !4, !5, !6}
+
+!0 = !{i32 1, !"wchar_size", i32 4}
+!1 = !{i32 7, !"PIC Level", i32 2}
+!2 = !{i32 7, !"PIE Level", i32 2}
+!3 = !{i32 7, !"uwtable", i32 2}
+!4 = !{i32 7, !"frame-pointer", i32 2}
+!5 = !{i32 1, !"ThinLTO", i32 0}
+!6 = !{i32 1, !"EnableSplitLTOUnit", i32 1}
+
+^0 = module: (path: "main-LTO.bc", hash: (0, 0, 0, 0, 0))
+^1 = gv: (name: "_start") ; guid = 12157170054180749580
+^2 = gv: (name: "main", summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 1, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 4, funcFlags: (readNone: 0, readOnly: 0, noRecurse: 0, returnDoesNotAlias: 0, noInline: 1, alwaysInline: 0, noUnwind: 1, mayThrow: 0, hasUnknownCall: 0, mustBeUnreachable: 0), calls: ((callee: ^1))))) ; guid = 15822663052811949562
+^3 = flags: 8
+^4 = blockcount: 1