[LTO] Switch to the new resolution-based API.

[davide]

Summary

This should be all the logic. Before reviewing the style/code appeareance, I'd like to ensure that this is the right direction, thanks.

Left to be done:

• There are two tests failing, the one which include inline asm (currently investigating).
• The old LTO code wasn't removed yet. I found that it makes the patch less readable, and that can be removed separately.

[ruiu]

I want to see the old code being removed in this patch to see deltas.

[davide]

In D24492#540718, @ruiu wrote:

I want to see the old code being removed in this patch to see deltas.

Fair enough, I'll do that tomorrow.

[davide]

Back to more interesting business, the two asm inline tests that are failing are also failing with the gold plugin, so that might inidcate a bug in lib/LTO. Here's a synthetic testcase.

$ /usr/bin/ld.gold -shared -m elf_x86_64 -o /home/davide/work/llvm/build/test/tools/gold/X86/Output/module_asm.ll.tmp2 -plugin /home/davide/work/llvm/build/./lib/LLVMgold.so /home/davide/work/llvm/build/test/tools/gold/X86/Output/module_asm.ll.tmp.o
ld.gold: ../lib/Linker/IRMover.cpp:1240: llvm::Error (anonymous namespace)::IRLinker::run(): Assertion `!GV->isDeclaration()' failed.

; RUN: llvm-as %s -o %t.o
; RUN: %gold -shared -m elf_x86_64 -o %t2 -plugin %llvmshlibdir/LLVMgold.so %t.o

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

module asm ".weak patatino"
module asm ".equ patatino, foo"

declare void @patatino()

define void @foo() {
  ret void
}

define void @_start() {
  call void @patatino()
  ret void
}

[davide]

I opened a report for the gold-plugin bug (https://llvm.org/bugs/show_bug.cgi?id=30363). I'll take a closer look tomorrow.

[ruiu]

Davide,

Sure. Go ahead with your patch first.

[davide]

Removed dead code as per Rui's request.
Also, for whoever cares, here's the output of diffstat:

33 files changed, 209 insertions(+), 432 deletions(-)

[ruiu]

This patch contains complex code with almost no comment. Please explain in the code about what you are doing.

ELF/SymbolTable.cpp

116–120

Why don't you keep the old interface and replace only the content of LTO.cpp? I think that was a good separation.

[pcc]

ELF/SymbolTable.cpp

213

You should replace all uses of IRObjectFile elsewhere with lto::InputFile. Then you won't need to create a new InputFile here, you can just reuse the one in the BitcodeFile.

225

You shouldn't need to do this, see r281437.

234

This isn't right, this should test whether the SymbolBody is a DefinedBitcode and is defined by this BitcodeFile.

252

There's no need to save objects to files, you can just use raw_string_ostream and operate on the object file directly in memory.

[davide]

Addressed comments. I'm working to remove the call to getComdatSymbolTable(). Other than that it should be ready for another look.

[• rafael]

lld/ELF/InputFiles.cpp

629 ↗

(On Diff #72753)

You can use GlobalValue::VisibilityTypes to make the argument type clear.

642 ↗

(On Diff #72753)

static

644 ↗

(On Diff #72753)

You don't need the llvm:: prefixes.
Do you really want a StringSaver by value?

655 ↗

(On Diff #72753)

Simplify to just

uint8_t Type = ObjSym.isTLS() ? STT_TLS : STT_NOTYPE;

656 ↗

(On Diff #72753)

Simplify to

uint8_t Visibility = mapVisibility(ObjSym.getVisibility());

661 ↗

(On Diff #72753)

You have lost HasUnnamedAddr. Where do you compensate for that?

[davide]

Rafael's comments.

lld/ELF/InputFiles.cpp

661 ↗

(On Diff #72753)

I think it's not needed anymore becuase lib/LTO will compute it based on GlobalResolution.
I'm garbage collecting it for now.

[ruiu]

lld/ELF/Error.h

36 ↗

(On Diff #72851)

You are not using Msg.

lld/ELF/LTO.cpp

150 ↗

(On Diff #72851)

Filenames is not a large vector, so please use std::string for simplicity.

155–156 ↗

(On Diff #72851)

I'd make getOutputFilename a pure function that returns std::string so that we can do

Filenames[Task] = getOutputFilename(Filename, MaxTasks > 1 ? Task : -1);

[davide]

Rui's comments.

[pcc]

lld/ELF/LTO.cpp

150 ↗

(On Diff #72851)

Once you make the change below, Filenames will be unused and you can remove it.

166 ↗

(On Diff #72851)

This could be if (!Buff[I].empty()), then you can make this a for-range loop.

[pcc]

lld/ELF/LTO.cpp

151 ↗

(On Diff #72860)

Rename to AddStream.

[• rafael]

lld/ELF/InputFiles.cpp

672 ↗

(On Diff #72851)

You don't need the llvm prefix.

lld/ELF/LTO.cpp

67 ↗

(On Diff #72851)

Just inline the variable into the single use.

88 ↗

(On Diff #72851)

You don't need the ()

122 ↗

(On Diff #72851)

Add a comment on why you need the undefined check.

[ruiu]

lld/ELF/Error.h

38 ↗

(On Diff #72860)

Do you need c_str()?

[pcc]

lld/ELF/LTO.cpp

79 ↗

(On Diff #72860)

You could just assign without the if statement here and below.

[davide]

lld/ELF/LTO.cpp

154 ↗

(On Diff #72867)

hmm, I still need I to be passed to saveBuffer, no? Do you want me to use a separate variable incremented at each iteration?

[pcc]

lld/ELF/LTO.cpp

154 ↗

(On Diff #72867)

No, sorry, what you have is fine.

155 ↗

(On Diff #72867)

I would remove this comment as it doesn't help readers understand the code.

[davide]

Rebased on top of

commit de07c6a10ee2cbf5877e74fdbbe1d8d3f1d343a4
Author: Etienne Bergeron <[e-mail]>
Date:   Wed Sep 28 18:04:07 2016 +0000

+ removed comment as suggested by Peter.

[ruiu]

lld/ELF/InputFiles.cpp

653 ↗

(On Diff #72870)

Remove ().

lld/ELF/LTO.cpp

85–88 ↗

(On Diff #72870)

Remove llvm::.

I don't think your code is prepared to see LtoObj being null. Maybe you want to return a new instance regardless of HasError value?

101–102 ↗

(On Diff #72870)

Why do you want to return here immediately if there was an error before this function?

[davide]

lld/ELF/LTO.cpp

101–102 ↗

(On Diff #72870)

Ooops, fixed, thanks.

[ruiu]

lld/ELF/LTO.cpp

107 ↗

(On Diff #72883)

auto -> BasicSymbolRef &

126 ↗

(On Diff #72883)

Stray }?

148 ↗

(On Diff #72883)

if (Buff[I].empty())
  continue;

[davide]

lld/ELF/LTO.cpp

131–132 ↗

(On Diff #72886)

hmm, no, just clang-formatted incorrectly. Weird as I have a pre-hook for that that didn't kick in.

[ruiu]

lld/ELF/LTO.cpp

131–132 ↗

(On Diff #72886)

It seems that it is still formatted weirdly.

[davide]

run clang-format manually and it seems fine on my side.

[pcc]

LGTM with nit. Thanks for working on this!

lld/ELF/InputFiles.cpp

646 ↗

(On Diff #72890)

Unused argument

[ruiu]

LGTM

ELF/Error.h

 //===- Error.h --------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COFF_ERROR_H
 #define LLD_COFF_ERROR_H
 
 #include "lld/Core/LLVM.h"
 
+#include "llvm/Support/Error.h"
+
 namespace lld {
 namespace elf {
 
 extern bool HasError;
 extern llvm::raw_ostream *ErrorOS;
 
 void log(const Twine &Msg);
 void warning(const Twine &Msg);
 
 void error(const Twine &Msg);
 void error(std::error_code EC, const Twine &Prefix);
 
 template <typename T> void error(const ErrorOr<T> &V, const Twine &Prefix) {
   error(V.getError(), Prefix);
 }
 
 LLVM_ATTRIBUTE_NORETURN void fatal(const Twine &Msg);
 LLVM_ATTRIBUTE_NORETURN void fatal(const Twine &Msg, const Twine &Prefix);
 
+inline void check(Error E, std::string Msg = "") {
+  handleAllErrors(std::move(E), [&](llvm::ErrorInfoBase &EIB) {
+    error(EIB.message().c_str());
+    return Error::success();
+  });
+}
+
 template <class T> T check(ErrorOr<T> E) {
   if (auto EC = E.getError())
     fatal(EC.message());
   return std::move(*E);
 }
 
 template <class T> T check(Expected<T> E) {
   if (!E)

ELF/InputFiles.h

 public:
   explicit BitcodeFile(MemoryBufferRef M);
   static bool classof(const InputFile *F) { return F->kind() == BitcodeKind; }
   template <class ELFT>
   void parse(llvm::DenseSet<StringRef> &ComdatGroups);
   ArrayRef<Symbol *> getSymbols() { return Symbols; }
   static bool shouldSkip(uint32_t Flags);
   std::unique_ptr<llvm::object::IRObjectFile> Obj;
+  MemoryBufferRef getBuffer() { return MB; }
 
 private:
   std::vector<Symbol *> Symbols;
   llvm::BumpPtrAllocator Alloc;
   llvm::StringSaver Saver{Alloc};
   template <class ELFT>
   Symbol *createSymbol(const llvm::DenseSet<const llvm::Comdat *> &KeptComdats,
                        const llvm::object::IRObjectFile &Obj,

ELF/SymbolTable.h

private:
   std::vector<std::unique_ptr<LazyObjectFile>> LazyObjectFiles;
   std::vector<std::unique_ptr<SharedFile<ELFT>>> SharedFiles;
   std::vector<std::unique_ptr<BitcodeFile>> BitcodeFiles;
 
   // Set of .so files to not link the same shared object file more than once.
   llvm::DenseSet<StringRef> SoNames;
 
   std::unique_ptr<BitcodeCompiler> Lto;
+
+  std::vector<std::unique_ptr<llvm::MemoryBuffer>> CompiledBitcodeFiles;
 };
 
 template <class ELFT> struct Symtab { static SymbolTable<ELFT> *X; };
 template <class ELFT> SymbolTable<ELFT> *Symtab<ELFT>::X;
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/SymbolTable.cpp

 // all input files to the symbol table. The symbol table is basically
 // a hash table with the logic to resolve symbol name conflicts using
 // the symbol types.
 //
 //===----------------------------------------------------------------------===//
 
 #include "SymbolTable.h"
 #include "Config.h"
+#include "Driver.h"
 #include "Error.h"
 #include "LinkerScript.h"
 #include "SymbolListFile.h"
 #include "Symbols.h"
 #include "llvm/Bitcode/ReaderWriter.h"
+#include "llvm/CodeGen/CommandFlags.h"
+#include "llvm/IR/DiagnosticPrinter.h"
+#include "llvm/LTO/LTO.h"
+#include "llvm/LTO/LTOBackend.h"
 #include "llvm/Support/StringSaver.h"
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::ELF;
 
 using namespace lld;
 using namespace lld::elf;
void SymbolTable<ELFT>::addFile(std::unique_ptr<InputFile> File) {
   }
 
   // Regular object file
   auto *F = cast<ObjectFile<ELFT>>(FileP);
   ObjectFiles.emplace_back(cast<ObjectFile<ELFT>>(File.release()));
   F->parse(ComdatGroups);
 }
 
+static void diagnosticHandler(const DiagnosticInfo &DI) {
+  if (const auto *BDI = dyn_cast<BitcodeDiagnosticInfo>(&DI)) {
+    std::error_code EC = BDI->getError();
+    if (EC == BitcodeError::InvalidBitcodeSignature)
+      return;
+  }
+
+  std::string ErrStorage;
+  {
+    raw_string_ostream OS(ErrStorage);
+    DiagnosticPrinterRawOStream DP(OS);
+    DI.print(DP);
+  }
+  warning(ErrStorage.c_str());
+}
+
+static std::unique_ptr<lto::LTO> createLTO() {
+  lto::Config Conf;
+  lto::ThinBackend Backend;
+  unsigned ParallelCodeGenParallelismLevel = Config->LtoJobs;
+
+  // LLD supports the new relocations.
+  Conf.Options = InitTargetOptionsFromCodeGenFlags();
+  Conf.Options.RelaxELFRelocations = true;
+
+  Conf.RelocModel = Config->Pic ? Reloc::PIC_ : Reloc::Static;
+  Conf.DisableVerify = Config->DisableVerify;
+  Conf.DiagHandler = diagnosticHandler;
+  Conf.OptLevel = Config->LtoO;
+
+  // Set up a custom pipeline if we've been asked to.
+  if (!Config->LtoNewPmPasses.empty())
+    Conf.OptPipeline = Config->LtoNewPmPasses;
+
+  if (Config->SaveTemps)
+    check(Conf.addSaveTemps(std::string(Config->OutputFile) + ".",
+                            /*UseInputModulePath*/ true));
+
+  return (HasError)
+             ? nullptr
+             : llvm::make_unique<lto::LTO>(std::move(Conf), Backend,
+                                           ParallelCodeGenParallelismLevel);
+}
+
+namespace {
+// Define the LTOOutput handling
+class LTOOutput : public lto::NativeObjectOutput {
+  StringRef Path;
+
+public:
+  LTOOutput(StringRef Path) : Path(Path) {}
+  // Open the filename \p Path and allocate a stream.
+  std::unique_ptr<raw_pwrite_stream> getStream() override {
+    int FD;
+    std::error_code EC = sys::fs::openFileForWrite(Path, FD, sys::fs::F_None);
+    if (EC)
+      llvm_unreachable("can't open the file");
+    return llvm::make_unique<llvm::raw_fd_ostream>(FD, true);
+  }
+};
+}
+
+/// Return the desired output filename given a base input name, a flag
+/// indicating whether a temp file should be generated, and an optional task id.
+/// The new filename generated is returned in \p NewFilename.
+static void getOutputFileName(SmallString<128> InFilename,
+                              SmallString<128> &NewFilename, int TaskID = -1) {
+  NewFilename = InFilename;
+  if (TaskID >= 0)
+    NewFilename += utostr(TaskID);
+}
+
+static void undefine(Symbol *S) {
+  replaceBody<Undefined>(S, S->body()->getName(), STV_DEFAULT, S->body()->Type,
+                         nullptr);
+}
+
+// This is for use when debugging LTO.
+static void saveBuffer(StringRef Buffer, const Twine &Path) {
+  std::error_code EC;
+  raw_fd_ostream OS(Path.str(), EC, sys::fs::OpenFlags::F_None);
+  if (EC)
+    error(EC, "cannot create " + Path);
+  OS << Buffer;
+}
+
 // This function is where all the optimizations of link-time
 // optimization happens. When LTO is in use, some input files are
 // not in native object file format but in the LLVM bitcode format.
 // This function compiles bitcode files into a few big native files
 // using LLVM functions and replaces bitcode symbols with the results.
 // Because all bitcode files that consist of a program are passed
 // to the compiler at once, it can do whole-program optimization.
 template <class ELFT> void SymbolTable<ELFT>::addCombinedLtoObject() {
   if (BitcodeFiles.empty())
     return;
 
-  // Compile bitcode files.
-  Lto.reset(new BitcodeCompiler);
-  for (const std::unique_ptr<BitcodeFile> &F : BitcodeFiles)
-    Lto->add(*F);
-  std::vector<std::unique_ptr<InputFile>> IFs = Lto->compile();
-
-  // Replace bitcode symbols.
-  for (auto &IF : IFs) {
-    ObjectFile<ELFT> *Obj = cast<ObjectFile<ELFT>>(IF.release());
+  std::unique_ptr<lto::LTO> LtoObj = createLTO();
+  if (HasError)
+    return;
+
+  for (const std::unique_ptr<BitcodeFile> &F : BitcodeFiles) {
+    Expected<std::unique_ptr<lto::InputFile>> ObjOrErr =
+        lto::InputFile::create(F->getBuffer());
+    if (!ObjOrErr)
+      error(toString(ObjOrErr.takeError()).c_str());
+    if (HasError)
+      return;
+    lto::InputFile &Obj = **ObjOrErr;
+    Module &M = Obj.getModule();
+    if (M.getDataLayoutStr().empty())
+      fatal("invalid bitcode file: " + F->getName() + " has no datalayout");
+
+    unsigned SymNum = 0;
+    std::vector<Symbol *> Syms = F->getSymbols();
+    std::vector<lto::SymbolResolution> Resols(Syms.size());
+    for (LLVM_ATTRIBUTE_UNUSED auto &ObjSym : Obj.symbols()) {
+      Symbol *Sym = Syms[SymNum];
+      lto::SymbolResolution &R = Resols[SymNum];
+      ++SymNum;
+      SymbolBody *B = Sym->body();
+      if (B->File != F.get())
+        continue;
+      if (Sym->body()->isUndefined())
+        continue;
+      R.Prevailing = Sym->body()->isDefined();
+      R.VisibleToRegularObj = Sym->IsUsedInRegularObj || Sym->includeInDynsym();
+      if (Sym->body()->isDefined())
+        undefine(Sym);
+    }
+    check(LtoObj->add(std::move(*ObjOrErr), Resols));
+    if (HasError)
+      return;
+  }
+
+  SmallString<128> Filename;
+  Filename = Config->OutputFile;
+  unsigned MaxTasks = LtoObj->getMaxTasks();
+  std::vector<SmallString<128>> Filenames(MaxTasks);
+
+  auto AddOutput =
+      [&](size_t Task) -> std::unique_ptr<lto::NativeObjectOutput> {
+    auto &OutputName = Filenames[Task];
+    getOutputFileName(Filename, OutputName, MaxTasks > 1 ? Task : -1);
+    return llvm::make_unique<LTOOutput>(OutputName);
+  };
 
+  check(LtoObj->run(AddOutput));
+  if (HasError)
+    return;
+
+  for (unsigned I = 0; I != MaxTasks; ++I) {
+    if (!Filenames[I].empty()) {
+      auto MBOrErr = MemoryBuffer::getFile(Filenames[I]);
+      if (auto EC = MBOrErr.getError()) {
+        error(EC, "cannot open " + Filenames[I]);
+        return;
+      }
+      MemoryBufferRef MB = (*MBOrErr)->getMemBufferRef();
+
+      // Do we want to move this to the LTO API?
+      if (Config->SaveTemps) {
+        if (MaxTasks == 1)
+          saveBuffer(MB.getBuffer(), Config->OutputFile + ".lto.o");
+        else
+          saveBuffer(MB.getBuffer(), Config->OutputFile + Twine(I) + ".lto.o");
+      }
+
+      CompiledBitcodeFiles.push_back(std::move(*MBOrErr));
+      ObjectFile<ELFT> *Obj =
+          cast<ObjectFile<ELFT>>(createObjectFile(MB).release());
       DenseSet<StringRef> DummyGroups;
       Obj->parse(DummyGroups);
       ObjectFiles.emplace_back(Obj);
     }
   }
+}
 
 template <class ELFT>
 DefinedRegular<ELFT> *SymbolTable<ELFT>::addAbsolute(StringRef Name,
                                                      uint8_t Visibility) {
   return cast<DefinedRegular<ELFT>>(
       addRegular(Name, STB_GLOBAL, Visibility)->body());
 }
 

test/ELF/lto/archive-3.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %S/Inputs/archive-3.ll -o %t1.o
 ; RUN: llvm-as %s -o %t2.o
 
 ; RUN: ld.lld -m elf_x86_64 %t1.o %t2.o  -o %t3 -save-temps
-; RUN: llvm-dis %t3.lto.bc -o - | FileCheck %s
+; RUN: llvm-dis %t3.0.2.internalize.bc -o - | FileCheck %s
 
 ; RUN: rm -f %t.a
 ; RUN: llvm-ar rcs %t.a %t1.o
 ; RUN: ld.lld -m elf_x86_64 %t.a %t1.o %t2.o  -o %t3 -save-temps
-; RUN: llvm-dis %t3.lto.bc -o - | FileCheck %s
+; RUN: llvm-dis %t3.0.2.internalize.bc -o - | FileCheck %s
 
 ; CHECK: define internal void @foo() {
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 define void @_start() {
   ret void
 }

test/ELF/lto/available-externally.ll

 ; RUN: llvm-as %s -o %t1.o
 ; RUN: llvm-as %p/Inputs/available-externally.ll -o %t2.o
 ; RUN: ld.lld %t1.o %t2.o -m elf_x86_64 -o %t.so -shared -save-temps
-; RUN: llvm-dis < %t.so.lto.bc | FileCheck %s
+; RUN: llvm-dis < %t.so.0.2.internalize.bc | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @foo() {
   call void @bar()
   call void @zed()
   ret void

test/ELF/lto/common2.ll

 ; RUN: llvm-as %s -o %t1.o
 ; RUN: ld.lld -m elf_x86_64 %t1.o -o %t -shared -save-temps
-; RUN: llvm-dis < %t.lto.bc | FileCheck %s
+; RUN: llvm-dis < %t.0.2.internalize.bc | FileCheck %s
 ; RUN: llvm-readobj -t %t | FileCheck %s --check-prefix=SHARED
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @a = common global i8 0, align 8
 ; CHECK-DAG: @a = common global i8 0, align 8
 

test/ELF/lto/common3.ll

 ; RUN: llvm-as %s -o %t1.o
 ; RUN: llvm-as %S/Inputs/common3.ll -o %t2.o
 ; RUN: ld.lld -m elf_x86_64 %t1.o %t2.o -o %t -shared -save-temps
-; RUN: llvm-dis < %t.lto.bc | FileCheck %s
+; RUN: llvm-dis < %t.0.2.internalize.bc | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 @a = common hidden global i32 0, align 8
 define i32 @f() {
   %t = load i32, i32* @a, align 4
   ret i32 %t
 }
 
 ; CHECK: @a = internal global i64 0, align 8

test/ELF/lto/discard-value-names.ll

 ; RUN: llvm-as %s -o %t.o
 
 ; RUN: ld.lld -m elf_x86_64 -shared -save-temps %t.o -o %t2.o
-; RUN: llvm-dis < %t2.o.lto.bc | FileCheck %s
+; RUN: llvm-dis < %t2.o.0.0.preopt.bc | FileCheck %s
 
 ; CHECK: @GlobalValueName
 ; CHECK: @foo(i32 %in)
 ; CHECK: somelabel:
 ; CHECK:  %GV = load i32, i32* @GlobalValueName
 ; CHECK:  %add = add i32 %in, %GV
 ; CHECK:  ret i32 %add
 

test/ELF/lto/drop-debug-info.ll

 ; REQUIRES: x86
 ;
 ; drop-debug-info.bc was created from "void f(void) {}" with clang 3.5 and
 ; -gline-tables-only, so it contains old debug info.
 ;
 ; RUN: ld.lld -m elf_x86_64 -shared %p/Inputs/drop-debug-info.bc \
 ; RUN: -disable-verify 2>&1 | FileCheck %s
-; CHECK: warning: ignoring debug info with an invalid version (1) in {{.*}}drop-debug-info.bc
+; CHECK: ignoring debug info with an invalid version (1) in {{.*}}drop-debug-info.bc
 

test/ELF/lto/drop-linkage.ll

 target triple = "x86_64-unknown-linux-gnu"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 ; REQUIRES: x86
 ; RUN: llc %s -o %t.o -filetype=obj
 ; RUN: llvm-as %p/Inputs/drop-linkage.ll -o %t2.o
 ; RUN: ld.lld %t.o %t2.o -o %t.so -save-temps -shared
-; RUN: llvm-dis %t.so.lto.opt.bc -o - | FileCheck %s
+; RUN: llvm-dis %t.so.0.4.opt.bc -o - | FileCheck %s
 
 define void @foo() {
   ret void
 }
 
 ; CHECK: declare void @foo()

test/ELF/lto/internalize-basic.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 ; RUN: ld.lld -m elf_x86_64 %t.o -o %t2 -save-temps
-; RUN: llvm-dis < %t2.lto.bc | FileCheck %s
+; RUN: llvm-dis < %t2.0.2.internalize.bc | FileCheck %s
 
 target triple = "x86_64-unknown-linux-gnu"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 define void @_start() {
   ret void
 }
 

test/ELF/lto/internalize-exportdyn.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 ; RUN: llvm-as %p/Inputs/internalize-exportdyn.ll -o %t2.o
 ; RUN: ld.lld -m elf_x86_64 %t.o %t2.o -o %t2 --export-dynamic -save-temps
-; RUN: llvm-dis < %t2.lto.bc | FileCheck %s
+; RUN: llvm-dis < %t2.0.2.internalize.bc | FileCheck %s
 
 target triple = "x86_64-unknown-linux-gnu"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 define void @_start() {
   ret void
 }
 

test/ELF/lto/internalize-llvmused.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 ; RUN: ld.lld -m elf_x86_64 %t.o -o %t2 -save-temps
-; RUN: llvm-dis < %t2.lto.bc | FileCheck %s
+; RUN: llvm-dis < %t2.0.2.internalize.bc | FileCheck %s
 
 target triple = "x86_64-unknown-linux-gnu"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 define void @_start() {
   ret void
 }
 
 define hidden void @f() {
   ret void
 }
 
 @llvm.used = appending global [1 x i8*] [ i8* bitcast (void ()* @f to i8*)]
 
 ; Check that f is not internalized.
 ; CHECK: define hidden void @f()

test/ELF/lto/internalize-undef.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 ; RUN: llvm-as %p/Inputs/internalize-undef.ll -o %t2.o
 ; RUN: ld.lld -m elf_x86_64 %t.o %t2.o -o %t -save-temps
-; RUN: llvm-dis < %t.lto.bc | FileCheck %s
+; RUN: llvm-dis < %t.0.2.internalize.bc | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare void @f()
 define void @_start() {
   call void @f()
   ret void
 }
 
 ; CHECK: define internal void @f()

test/ELF/lto/internalize-version-script.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 ; RUN: echo "{ global: foo; local: *; };" > %t.script
 ; RUN: ld.lld -m elf_x86_64 %t.o -o %t2 -shared --version-script %t.script -save-temps
-; RUN: llvm-dis < %t2.lto.bc | FileCheck %s
+; RUN: llvm-dis < %t2.0.2.internalize.bc | FileCheck %s
 
 target triple = "x86_64-unknown-linux-gnu"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 define void @foo() {
   ret void
 }
 

test/ELF/lto/irmover-error.ll

 ; RUN: llvm-as -o %t1.bc %s
 ; RUN: llvm-as -o %t2.bc %S/Inputs/irmover-error.ll
 ; RUN: not ld.lld -m elf_x86_64 %t1.bc %t2.bc -o %t 2>&1 | FileCheck %s
 
-; CHECK: failed to link module {{.*}}2.bc: linking module flags 'foo': IDs have conflicting values
+; CHECK: linking module flags 'foo': IDs have conflicting values
 
 target triple = "x86_64-unknown-linux-gnu"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 !0 = !{ i32 1, !"foo", i32 1 }
 
 !llvm.module.flags = !{ !0 }

test/ELF/lto/linkonce-odr.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %p/Inputs/linkonce-odr.ll -o %t1.o
 ; RUN: llc -relocation-model=pic %s -o %t2.o -filetype=obj
 ; RUN: ld.lld %t1.o %t2.o -o %t.so -shared -save-temps
-; RUN: llvm-dis %t.so.lto.opt.bc -o - | FileCheck %s
+; RUN: llvm-dis %t.so.0.4.opt.bc -o - | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 declare void @f()
 
 define void @g() {
   call void @f()
   ret void
 }
 
 ; Be sure that 'f' is kept and has weak_odr linkage.
 ; CHECK: define weak_odr void @f()

test/ELF/lto/linkonce.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %p/Inputs/linkonce.ll -o %t1.o
 ; RUN: llc -relocation-model=pic %s -o %t2.o -filetype=obj
 ; RUN: ld.lld %t1.o %t2.o -o %t.so -shared -save-temps
-; RUN: llvm-dis %t.so.lto.opt.bc -o - | FileCheck %s
+; RUN: llvm-dis %t.so.0.4.opt.bc -o - | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 declare void @f()
 
 define void @g() {
   call void @f()
   ret void
 }
 
 ; Be sure that 'f' is kept and has weak linkage.
 ; CHECK: define weak void @f()

test/ELF/lto/ltopasses-basic.ll

 ; REQUIRES: x86
-; RUN: rm -f %t.so.lto.bc %t.so.lto.opt.bc %t.so.lto.o
 ; RUN: llvm-as %s -o %t.o
 ; RUN: ld.lld -m elf_x86_64 %t.o -o %t.so -save-temps -mllvm -debug-pass=Arguments -shared 2>&1 | FileCheck %s --check-prefix=MLLVM
-; RUN: llvm-dis %t.so.lto.opt.bc -o - | FileCheck %s
+; RUN: llvm-dis %t.so.0.4.opt.bc -o - | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @ctor, i8* null }]
 define void @ctor() {
   ret void
 }
 
 ; `@ctor` doesn't do anything and so the optimizer should kill it, leaving no ctors
 ; CHECK: @llvm.global_ctors = appending global [0 x { i32, void ()*, i8* }] zeroinitializer
 
 ; MLLVM: Pass Arguments:

test/ELF/lto/ltopasses-custom.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 ; RUN: ld.lld -m elf_x86_64 %t.o -o %t.so -save-temps --lto-aa-pipeline=basic-aa \
 ; RUN: --lto-newpm-passes=ipsccp -shared
 ; RUN: ld.lld -m elf_x86_64 %t.o -o %t2.so -save-temps --lto-newpm-passes=loweratomic -shared
-; RUN: llvm-dis %t.so.lto.opt.bc -o - | FileCheck %s
-; RUN: llvm-dis %t2.so.lto.opt.bc -o - | FileCheck %s --check-prefix=ATOMIC
+; RUN: llvm-dis %t.so.0.4.opt.bc -o - | FileCheck %s
+; RUN: llvm-dis %t2.so.0.4.opt.bc -o - | FileCheck %s --check-prefix=ATOMIC
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @barrier() {
   fence seq_cst
   ret void
 }

test/ELF/lto/save-temps.ll

 ; REQUIRES: x86
 ; RUN: cd %T
 ; RUN: rm -f a.out a.out.lto.bc a.out.lto.o
 ; RUN: llvm-as %s -o %t.o
 ; RUN: llvm-as %p/Inputs/save-temps.ll -o %t2.o
 ; RUN: ld.lld -shared -m elf_x86_64 %t.o %t2.o -save-temps
 ; RUN: llvm-nm a.out | FileCheck %s
-; RUN: llvm-nm a.out.lto.bc | FileCheck %s
+; RUN: llvm-nm a.out.0.0.preopt.bc | FileCheck %s
 ; RUN: llvm-nm a.out.lto.o | FileCheck %s
-; RUN: llvm-dis a.out.lto.bc
+; RUN: llvm-dis a.out.0.0.preopt.bc
 
 target triple = "x86_64-unknown-linux-gnu"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 define void @foo() {
   ret void
 }
 
 ; CHECK: T bar
 ; CHECK: T foo

test/ELF/lto/type-merge.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 ; RUN: llvm-as %p/Inputs/type-merge.ll -o %t2.o
 ; RUN: ld.lld -m elf_x86_64 %t.o %t2.o -o %t -shared -save-temps
-; RUN: llvm-dis < %t.lto.bc | FileCheck %s
+; RUN: llvm-dis < %t.0.0.preopt.bc | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @foo()  {
   call void @bar(i8* null)
   ret void
 }

test/ELF/lto/type-merge2.ll

 ; RUN: llvm-as %s -o %t.o
 ; RUN: llvm-as %p/Inputs/type-merge2.ll -o %t2.o
 ; RUN: ld.lld -m elf_x86_64 %t.o %t2.o -o %t.so -shared -save-temps
-; RUN: llvm-dis %t.so.lto.bc -o - | FileCheck %s
+; RUN: llvm-dis %t.so.0.0.preopt.bc -o - | FileCheck %s
 
 target triple = "x86_64-unknown-linux-gnu"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 %zed = type { i8 }
 define void @foo()  {
   call void @bar(%zed* null)
   ret void

test/ELF/lto/unnamed-addr-comdat.ll

 ; RUN: llvm-as %s -o %t.o
 ; RUN: ld.lld -m elf_x86_64 %t.o %t.o -o %t.so -save-temps -shared
-; RUN: llvm-dis %t.so.lto.bc -o - | FileCheck %s
+; RUN: llvm-dis %t.so.0.2.internalize.bc -o - | FileCheck %s
 
 target triple = "x86_64-unknown-linux-gnu"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 $foo = comdat any
 @foo = linkonce_odr unnamed_addr constant i32 42, comdat
 
 ; CHECK: @foo = internal unnamed_addr constant i32 42, comdat

test/ELF/lto/unnamed-addr-drop.ll

 ; RUN: llvm-as %s -o %t1.o
 ; RUN: llvm-as %S/Inputs/unnamed-addr-drop.ll -o %t2.o
 ; RUN: ld.lld -m elf_x86_64 %t1.o %t2.o -o %t.so -save-temps -shared
-; RUN: llvm-dis %t.so.lto.bc -o - | FileCheck %s
+; RUN: llvm-dis %t.so.0.2.internalize.bc -o - | FileCheck %s
 
 target triple = "x86_64-unknown-linux-gnu"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 @foo = weak constant i32 41
 
 ; Check that unnamed_addr is dropped during the merge.
 ; CHECK: @foo = constant i32 42

test/ELF/lto/unnamed-addr-lib.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 ; RUN: llvm-mc %p/Inputs/unnamed-addr-lib.s -o %t2.o -filetype=obj -triple=x86_64-pc-linux
 ; RUN: ld.lld %t2.o -shared -o %t2.so
 ; RUN: ld.lld -m elf_x86_64 %t.o %t2.so -o %t.so -save-temps -shared
-; RUN: llvm-dis %t.so.lto.bc -o - | FileCheck %s
+; RUN: llvm-dis %t.so.0.2.internalize.bc -o - | FileCheck %s
 
 ; This documents a small limitation of lld's internalization logic. We decide
 ; that bar should be in the symbol table because if it is it will preempt the
 ; one in the shared library.
 ; We could add one extra bit for ODR so that we know that preemption is not
 ; necessary, but that is probably not worth it.
 
-; CHECK: @foo = internal constant i8 42
-; CHECK: @bar = weak_odr constant i8 42
+; CHECK: @foo = internal unnamed_addr constant i8 42
+; CHECK: @bar = weak_odr unnamed_addr constant i8 42
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @foo = linkonce_odr unnamed_addr constant i8 42
 @bar = linkonce_odr unnamed_addr constant i8 42

test/ELF/lto/unnamed-addr.ll

 ; RUN: llvm-as %s -o %t.o
 ; RUN: ld.lld -m elf_x86_64 %t.o -o %t.so -save-temps -shared
-; RUN: llvm-dis %t.so.lto.opt.bc -o - | FileCheck %s
+; RUN: llvm-dis %t.so.0.4.opt.bc -o - | FileCheck %s
 
 target triple = "x86_64-unknown-linux-gnu"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 @a = internal unnamed_addr constant i8 42
 
 define i8* @f() {
   ret i8* @a
 }
 
 ; CHECK: @a = internal unnamed_addr constant i8 42

test/ELF/lto/version-script.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 ; RUN: echo "VERSION_1.0{ global: foo; local: *; }; VERSION_2.0{ global: bar; local: *; };" > %t.script
 ; RUN: ld.lld -m elf_x86_64 %t.o -o %t2 -shared --version-script %t.script -save-temps
-; RUN: llvm-dis < %t2.lto.bc | FileCheck %s
+; RUN: llvm-dis < %t2.0.0.preopt.bc | FileCheck %s
 ; RUN: llvm-readobj -V -dyn-symbols %t2 | FileCheck --check-prefix=DSO %s
 
 target triple = "x86_64-unknown-linux-gnu"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 define void @foo() {
   ret void
 }