refactor COFF linker to use new LTO API

[inglorion]

Summary

The COFF linker previously implemented link-time optimization using an API which has now been marked as legacy. This change refactors the COFF linker to use the new LTO API, which is also used by the ELF linker.

[ruiu]

COFF/Config.h

90 ↗

(On Diff #85482)

You don't seem to set a value to that variable in this patch. Does it work?

COFF/Driver.cpp

818 ↗

(On Diff #85482)

Do you actually need to run the entire loop after LTO? I was thinking that, once LTO is done, all symbols are essentially resolved, so no need to run that loop.

COFF/LTO.cpp

1 ↗

(On Diff #85482)

This file seems very similar to ELF/LTO.cpp. Do you think there is a way to merge the two?

[inglorion]

I've added some inline notes to explain the changes. Essentially, I copied over LTO.cpp and LTO.h from the ELF linker and adapted the code to use those instead of the legacy LTO API. I've aimed to keep the changes (both compared to the ELF code and compared to the original code in the COFF linker) to a minimum to make reviewing easier. There are a couple of features that are present in the ELF linker which we're currently not using in the COFF linker, which is why createLTO() has a couple of hardcoded values. I can change that in a follow-up, or in this change if that's preferred. With these changes, all tests pass, and I can build Chrome with LTO.

COFF/Driver.cpp

818 ↗

(On Diff #85482)

I noticed that the linker left some work to be done and then crashed further on, which I fixed by running untin run() returns false. Since we also do that just above here, I factored that out into a separate function.

COFF/LTO.cpp

1 ↗

(On Diff #85482)

Based on ELF/LTO.cpp

COFF/LTO.h

1 ↗

(On Diff #85482)

Slightly modified version of ELF/LTO.h

test/COFF/lto-comdat.ll

1 ↗

(On Diff #85482)

The new implementation generates code here that isn't bit-for-bit identical to what the old implementation generated, but it looks semantically equivalent. Basically, functions are emitted at different addresses, which causes some int3s are replaced by nopws. I've changed the test a bit so that it checks that we don't generate any unexpected calls, instead of specifically checking for int3 or nop instructions.

test/COFF/lto-parallel.ll

8 ↗

(On Diff #85482)

"lto.tmp" is what I carried over from the ELF code, so that the COFF linker and the ELF linker now use the same string. I can probably change it to be "<lto object>" if anyone strongly prefers that.

[inglorion]

COFF/LTO.cpp

1 ↗

(On Diff #85482)

Yes. I noticed that there is a bit of very similar code in the ELF linker and the COFF linker. I would like to take a look at what can be merged. I'm actually not sure at this point if we should merge the LTO code, but I think for example Error.{h,cpp} can probably be unified.

[pcc]

COFF/InputFiles.cpp

345 ↗

(On Diff #85482)

If we're switching to the new LTO API, it isn't quite right to keep the Replaceable flag, which mixes together the three different ways that symbols can be merged in COFF (common, comdat, weak external). The reason is that the legacy LTO API relied on the IR linker to resolve conflicts between these three types of symbol correctly (so if we had two replaceable BitcodeSymbols, it wouldn't matter which one wins), but the new API needs to know exactly which symbol prevails. Without correct symbol resolution, the wrong symbol may appear in the final object file depending on the order in which we read object files (for example, with this code, when we see a weak external followed by a comdat member, the weak external would win, whereas the comdat member needs to win).

That is why I suggested offline that we could remove the BitcodeSymbol class, and extend DefinedRegular to handle bitcode symbols, as we do in the ELF linker.

356 ↗

(On Diff #85482)

We don't really want to parse the module twice just to get the linker directives (this also won't work with multi-module bitcode files). As I mentioned on your other change, there should be an accessor function on InputFile that retrieves the directives.

COFF/LTO.cpp

73 ↗

(On Diff #85482)

This line doesn't make sense in a COFF linker.

75 ↗

(On Diff #85482)

Non-relocatable COFF objects are rare enough that I think we can always use PIC here (which is the default), so you can remove this line.

80–82 ↗

(On Diff #85482)

These don't need to be initialized.

125 ↗

(On Diff #85482)

Symbols can also be exported with /export. I think you just need to check IsUsedInRegularObj because we handle /export by (among other things) setting that flag on the symbol.

COFF/SymbolTable.cpp

366 ↗

(On Diff #85482)

I think this part is unnecessary because we are already doing it in LTO.cpp (see line 128).

[pcc]

COFF/LTO.cpp

149 ↗

(On Diff #85482)

May want to make the same change as r293138 here.

[pcc]

Another thing I'd like to see is a test showing that ThinLTO works, something similar to lld/test/ELF/lto/thinlto.ll.

[inglorion]

Another thing I'd like to see is a test showing that ThinLTO

I'll add that in a follow-up. The end goal of this refactor is making thinlto work with COFF, but the goal for this diff is just to get the existing functionality to work with the new API.

[ruiu]

So I'm not very familiar with LTO. I want to avoid this much code duplication in LLD, but I'm not sure if it is doable. What do you think, Peter?

[pcc]

In D29059#657847, @ruiu wrote:

So I'm not very familiar with LTO. I want to avoid this much code duplication in LLD, but I'm not sure if it is doable. What do you think, Peter?

It seems that BitcodeCompiler::add is the only actual linker-specific part (the constructor and compile are basically the same except for a few details). If we changed the two linkers to share error handling functions, and moved BitcodeCompiler::add to a linker-specific location, I think we'd be able to share BitcodeCompiler between the linkers.

COFF/LTO.h

46 ↗

(On Diff #85482)

Remove the word "template". I'm actually a little surprised that this compiles.

[pcc]

COFF/InputFiles.cpp

392 ↗

(On Diff #85482)

This will only ever be a native object file, I think.

[inglorion]

Changes requested by @pcc and @ruiu.

The major change here is that I removed DefinedBitcode. Instead, we now use DefinedRegular and DefinedCommon, regardless of whether the symbols come from a COFF file or a bitcode file. This also gets rid of IsReplaceable, and we now handle common, comdat, and weak individually. I also renamed DefinedCOFF to DefinedByFile to reflect that this is a common base class for symbols that are defined by a file, not necessarily a COFF file.

I moved the parsing of linker options in object files from COFF/InputFiles.cpp to LLVM's LTO.

Other, smaller changes:

• removed redundant loop to undefine bitcode symbols
• removed some things that we aren't actually using, e.g. SaveTemps and some ELF specifics

[inglorion]

COFF/LTO.cpp

125 ↗

(On Diff #85482)

/export will be correctly handled without this, but symbols annotated in the source code with dllexport will not. Specifically, COFF/dll.test fails with

$ "C:/src/clang/./bin\FileCheck.EXE" "-check-prefix=EXPORT-LTO" "C:\src\llvm\tools\lld\test\COFF\dll.test"
# command stderr:
C:\src\llvm\tools\lld\test\COFF\dll.test:40:18: error: expected string not found in input
EXPORT-LTO-NEXT: 3 0x1030 exportfn3
               ^
<stdin>:11:1: note: scanning from here

^

when I remove the check for R.Prevailing && ObjSym.hasDLLExportStorageClass().

That test has two symbols for which it passes /export, and one for which it doesn't pass /export but has dllexport in the source. That last symbol is the one that fails.

149 ↗

(On Diff #85482)

Thanks! I actually removed this code, because SaveTemps isn't currently set by the COFF linker anyway.

[pcc]

COFF/InputFiles.cpp

345 ↗

(On Diff #85482)

I think your IsWeak flag would just be used for weak externals (COFF has no direct concept of weak defined symbols). Would it be possible to represent these with Undefined in a similar way to weak externals in regular objects?

381 ↗

(On Diff #85993)

You never supply a non-default argument to ArchiveName or OffsetInArchive. I would just create the ObjectFile directly in LTO.cpp.

COFF/InputFiles.h

71–77 ↗

(On Diff #85993)

It doesn't look like you ever set these fields.

Regarding ArchiveName we also already have ParentName above.

We might want to fix the issue that required us to add OffsetInArchive in the ELF linker (see D25495) but I think that can be done separately.

COFF/LTO.cpp

125 ↗

(On Diff #85482)

What if you change getLinkerOpts to emit /export flags? (see suggestion on D29207)

I would also try undoing the runLoop change after making that change.

COFF/SymbolTable.cpp

64 ↗

(On Diff #85993)

Do we need to do this just yet?

252 ↗

(On Diff #85993)

In general I would try to have just one add* function per symbol type. The input file readers should extract any field values, not the symbol table.

275 ↗

(On Diff #85993)

This will never be true, we create Undefined symbols for COFF weak externals.

290 ↗

(On Diff #85993)

This isn't correct, we need to compare sizes as below.

COFF/Symbols.cpp

32–46 ↗

(On Diff #85993)

Why change this? I think we still have the invariant that if the name is empty, the file is a COFF object, no?

COFF/Symbols.h

139 ↗

(On Diff #85993)

You could move this into SymbolBody to save space (that is if you don't take my suggestion to use Undefined for weak undef).

193 ↗

(On Diff #85993)

Move into SymbolBody.

COFF/Writer.cpp

449–450 ↗

(On Diff #85993)

It looks like you are only using fields Defined::Type and Defined::StorageClass here. Instead of storing them in Defined, you could change createSymbolAndStringTable to walk the original object's symbol table, extract the type and storage class from the symbol and pass them to this function.

You could also do something similar for isSectionDefinition in MapFile.cpp if you were so inclined.

[inglorion]

Thanks for the review, @pcc! I'm making the changes you suggested. Meanwhile, I had a couple of questions, which I've asked inline.

COFF/SymbolTable.cpp

64 ↗

(On Diff #85993)

The lto-comdat test will fail without this. Specifically, the test that uses a COFF main with LTO objects ends up picking the definition of comdat in main, resulting in calls to that being emitted for f1 and f2. The test checks that these calls are not present, which is the result we get when picking the comdat definition in the bitcode and then optimizing it out in LTO.

I thought about this for some time, and my conclusion is that preferring a symbol defined in bitcode when we have no overriding concerns makes sense. We can optimize out calls in LTO when the definition is available, which picking the bitcode symbol accomplishes. We can't optimize away calls in objects that don't participate in LTO no matter which definition we pick. So it would seem that picking the definition in bitcode is sometimes a better choice and never a worse choice (again, assuming they're otherwise equivalent).

That said, if there is a better way to do this, I'm all ears.

290 ↗

(On Diff #85993)

The code here says "if there wasn't a defined symbol with this name, use the newly discovered symbol". I think that's correct.

What I think you're referring to is the case where there is a DefinedCommon already, we still might want to replace that with the new symbol. Do we have a way to determine the size of a common defined in bitcode? Currently, that size defaults to 0, meaning the bitcode definition would always lose against a COFF definition, and different bitcode definitions are equivalent. This is consistent with the existing behavior (if there is a DefinedCommon, use that instead of the newly discovered bitcode symbol).

COFF/Symbols.cpp

32–46 ↗

(On Diff #85993)

In the process of unifying bitcode symbols with COFF symbols, I wanted to get rid of DefinedCOFF storing a coff_symbol_generic. There are a couple of simple values we extracted from that, which I now just store directly. The only tricky one is Name, which, as the comments here mention, is supposed to be extracted only when needed. I didn't feel good about having to carry around a coff_symbol_generic, the special case for DefinedCOFF here, and add a special case for when it's actually a bitcode symbol and doesn't have a coff_symbol_generic, just for the one case where we did not already extract the name prior to constructing a DefinedRegular (see the calls to getSymbolName in InputFiles.cpp).

Looking at it again, it seems that the lazy name extraction may help us with internal symbols, whose names we may not be interested in. If lazy name extraction is a feature we need to keep, I'll bring it back.

[pcc]

COFF/SymbolTable.cpp

64 ↗

(On Diff #85993)

I think we should try to avoid biasing the symbol resolution logic like that.

To optimize the case where no prevailing bitcode symbol is chosen, we can teach the LTO API implementation to link non-prevailing symbol definitions with *_odr linkage if there is not already an implementation available, and set the linkage type to available_externally. That will make the function body available for inlining without it being emitted in the object file. Implementing the optimization that way will benefit all linkers no matter how they implement their symbol resolution logic.

290 ↗

(On Diff #85993)

We get the correct behaviour with the existing code because the IR linker chooses the largest IR common definition, lld chooses the largest native common definition and lld chooses the larger of the two when it adds the combined LTO object to the link. With this code, if you have multiple common symbols in bitcode with different sizes, I think you would end up choosing the first one instead of the largest one.

You can determine the size by calling getCommonSize() on the LTO symbol.

COFF/Symbols.cpp

32–46 ↗

(On Diff #85993)

Ah, I didn't notice that this relies on the Sym field that you removed.

I think for now the simplest thing to do would be to keep Sym and call getType/getStorageClass/isSectionDefinition directly via that pointer in the rest of the code. We can think about removing it in a separate change.

[inglorion]

Changes requested by @pcc (thanks!):

• Removed the special case for bitcode symbols in compareDefined.
• Use Undefined symbols instead of DefinedRegular symbols for weak symbols, so we don't need an IsWeak flag.
• Reverted the change from DefinedCOFF to DefinedByFile - DefinedCOFF now carries a coff_symbol_generic again, which we use to lazily resolve the symbol name.
• Use getCommonSize to determine the size of commons defined by bitcode.
• Simplified COFF/LTO.cpp by moving the check for dllexport to COFF/InputFiles.cpp.
• addCommon and addRegular now each have only one definition, which handles both regular and bitcode symbols.

[inglorion]

I also checked if we can now remove runLoop in Driver.cpp, but we still need it.

[inglorion]

I tried making the change @pcc has been suggesting to make getLinkerOpts() return /EXPORT directives for symbols with dllexport storage so that we wouldn't need hasDLLExportStorage anymore. However, this ran into an issue: implementing that requires iterating over all symbols. We actually do that in addRegularLTO in LTO/LTO.cpp, but that's after we need to determine symbol resolutions. So I would either have to implement an extra loop, or move the check for dllexport into a loop that runs earlier. The solution I came up with is to move it to BitcodeFile::parse in InputFiles.cpp, which already iterates over the symbols. This makes the fact that the symbol is used by regular objects available immediately after we create the symbol, which seems like a good place for it to live.

[pcc]

I tried making the change @pcc has been suggesting to make getLinkerOpts() return /EXPORT directives for symbols with dllexport storage so that we wouldn't need hasDLLExportStorage anymore. However, this ran into an issue: implementing that requires iterating over all symbols. We actually do that in addRegularLTO in LTO/LTO.cpp, but that's after we need to determine symbol resolutions. So I would either have to implement an extra loop, or move the check for dllexport into a loop that runs earlier.

I'd just add the extra loop to be honest. I would be surprised if we could measure any performance impact at all (and the performance impact will be zero once the directives are moved into the bitcode symbol table).

COFF/InputFiles.cpp

202 ↗

(On Diff #86544)

http://llvm-cs.pcc.me.uk/include/llvm/Object/COFF.h#344

Common symbols are external by definition, you can also remove IsExternal here.

254 ↗

(On Diff #86544)

You can remove the IsExternal argument, it will always be true.

353 ↗

(On Diff #86544)

I think it would be more accurate to test that both SF_Weak and SF_Indirect are set here.

356 ↗

(On Diff #86544)

Can you please also upload the change that adds this function?

359 ↗

(On Diff #86544)

In the regular object reader we diagnose undefined symbols with different weak aliases. Could you factor that out into a function and call it from here?

COFF/InputFiles.h

195 ↗

(On Diff #86544)

I think you are no longer using this LLVMContext object, so you can remove it.

COFF/SymbolTable.cpp

36 ↗

(On Diff #86544)

Now that this function has only one caller, it no longer needs to be a separate function.

Also, the logic in this function doesn't seem to match what was there before (e.g. you are no longer reporting conflicts between comdat and non-comdat). I think you just need the logic on lines 215-226 in the old code with the bitcode part removed.

[pcc]

COFF/InputFiles.cpp

204 ↗

(On Diff #86544)

Instead of setting IsUsedInRegularObj here, can you change addRegular and addCommon to set it based on the type of the input file? See what we're doing in addUndefined for example.

[pcc]

COFF/MapFile.cpp

82 ↗

(On Diff #86544)

This can be as it was before, we should never see bitcode symbols here.

COFF/Symbols.cpp

60 ↗

(On Diff #86544)

This is more of a programmer error than a user error, so I would just use cast here.

[inglorion]

COFF/InputFiles.cpp

204 ↗

(On Diff #86544)

Yeah, I thought about that but it felt like a more magical way to do things. I decided to make add* work exactly the same for bitcode and object files, and set IsUsedInRegularObj explicitly. If you prefer, I can change add* to set the flag automatically.

[pcc]

COFF/InputFiles.cpp

204 ↗

(On Diff #86544)

I think I would slightly prefer it because setting IsUsedInRegularObj is really the symbol table's job, and passing in a flag would be redundant. (It's also consistent with the ELF linker.)

[inglorion]

• removed unnecessary LLVMContext objects
• removed unnecessary IsExternal parameters
• test for SF_Indirect in addition to SF_Weak when looking for weak externals
• removed isSectionDefinition from DefinedCOFF
• fixed symbol resolution logic
• use cast instead of dyn_cast and report_fatal in getCOFFSymbol
• factored out check for conflicting definitions of weak aliases

[inglorion]

COFF/InputFiles.cpp

204 ↗

(On Diff #86544)

I will make that change, and also synthesize "/EXPORT" flags instead of hasDLLExportStorageClass.

COFF/SymbolTable.cpp

36 ↗

(On Diff #86544)

I actually like this as a separate function. I feel it makes the logic of how symbol preference and conflicts are determined easier to read.

Good call on changing the logic for comdat vs. non-comdat here. I had misread the original code. That should now be fixed.

[pcc]

Generally looking pretty good at this point.

COFF/InputFiles.cpp

353 ↗

(On Diff #86544)

You no longer need the !IsCOMDAT part; I don't think weak externals can be comdat members.

264 ↗

(On Diff #86713)

Same here, Sym.isExternal() will always be false (also Name will always be empty).

COFF/SymbolTable.cpp

36 ↗

(On Diff #86544)

I actually like this as a separate function. I feel it makes the logic of how symbol preference and conflicts are determined easier to read.

I don't share that opinion (maybe I'm biased by being familiar with the code), but I have no strong objections to doing it this way. I guess if I felt it necessary to make this change, I would do it in a separate commit, but up to you.

COFF/Symbols.cpp

42 ↗

(On Diff #86713)

We should never see bitcode symbols with empty names, so you can cast here.

COFF/Symbols.h

92 ↗

(On Diff #86713)

*symbol

103 ↗

(On Diff #86713)

Can you remove the explicit and the default argument?

128 ↗

(On Diff #86713)

Mention that only internal symbol names are lazily loaded.

[inglorion]

Implemented the improvements suggested by @pcc. The big ones are:

• set IsUsedInRegularObject in SymbolTable instead of InputFiles
• no longer call hasDLLExportStorageClass
• removed IsCOMDAT check for weak external bitcode symbols

[pcc]

COFF/InputFiles.cpp

264 ↗

(On Diff #86713)

What about this?

353 ↗

(On Diff #86752)

Use } else if (...) {.

COFF/SymbolTable.cpp

363 ↗

(On Diff #86752)

I noticed that there is a functional change here in how we're reading the combined LTO objects. The old code was adding the new objects to ObjectFiles and then calling parse, while the new code is calling addFile which calls parse and then reads the linker directives. Now that we're reading all linker directives up front, if you change this code to just add to ObjectFiles and parse, can you undo the runLoop change?

COFF/Symbols.cpp

42 ↗

(On Diff #86713)

You can also cast this.

[inglorion]

COFF/InputFiles.cpp

264 ↗

(On Diff #86713)

Ah, I forgot to respond. This is calling the constructor, which expects us to pass values for these parameters. We have a couple of options:

1. Change these to constants, given that we already know their values. Compared to the existing code, that has the downside that it is less clear what the values mean. We could get around that by adding comments. I actually prefer the code as it is written now, but I can make this change if you want me to.

2. Add another constructor to DefinedRegular that doesn't take the parameters that happen to be constants here. I didn't consider it worth adding another constructor that's only used in one place, but, again, I'll make that change if you prefer it that way.

Other options? What did you have in mind?

COFF/SymbolTable.cpp

363 ↗

(On Diff #86752)

Let me check that. I'm calling addFile here specifically so that we do process the linker directives, but perhaps that's actually the wrong thing to do.

[pcc]

COFF/InputFiles.cpp

264 ↗

(On Diff #86713)

I meant option 1. We normally add comments alongside the arguments where it is unclear from context what they mean, i.e: /*Name=*/"" and /*IsExternal=*/false.

[inglorion]

• don't process linker directives from object files produced by LTO; undo Driver loop change
• changed else { if (...) to else if (...) {
• replaced named parameters with constants and comments

[inglorion]

• removed now unneeded runLoop declaration from Driver.h

[pcc]

Mostly looks good, except for one last thing.

COFF/Symbols.cpp

42 ↗

(On Diff #86713)

What about this?

test/COFF/lto-parallel.ll

8 ↗

(On Diff #86860)

Sorry, I didn't notice this before. This test expects there to be 2 parallel LTO codegen paritions. Your change changes the semantics of /opt:lldltojobs to mean the number of ThinLTO jobs rather than the number of parallel LTO codegen partitions. I think the change in semantics is fine, it's what we've adopted in the other linkers. But it means that we aren't testing the parallel LTO codegen feature correctly here.

Can you introduce a new flag /opt:lldltopartitions which controls Config->LTOPartitions, and then change this test to use it? Once you've done that, the CHECK lines should look roughly like they did before (except for the name change).

[pcc]

COFF/LTO.h

10–16 ↗

(On Diff #86861)

Nit: s/ELF/COFF/g here.

[pcc]

COFF/InputFiles.cpp

359 ↗

(On Diff #86861)

Instead of collecting the weak aliases into a vector and looping over them, you can call checkAndSetWeakAlias directly from here I think.

[inglorion]

• added lldltopartitions option
• use cast instead of dyn_cast for file in getName
• changed to work with updated D29365

[pcc]

LGTM with my last two comments addressed, thanks!

[inglorion]

I've tested that I can build and link Chromium with this.

[inglorion]

moved calls to checkAndSetWeakAlias out of the loop in BitcodeFile::parse and changed "COFF" to "ELF" in LTO.h

lld/trunk/COFF/CMakeLists.txt

add_lld_library(lldCOFF
   Chunks.cpp
   DLL.cpp
   Driver.cpp
   DriverUtils.cpp
   Error.cpp
   ICF.cpp
   InputFiles.cpp
   Librarian.cpp
+  LTO.cpp
   MapFile.cpp
   MarkLive.cpp
   ModuleDef.cpp
   PDB.cpp
   Strings.cpp
   SymbolTable.cpp
   Symbols.cpp
   Writer.cpp

lld/trunk/COFF/Config.h

struct Configuration {
   Symbol *SEHTable = nullptr;
   Symbol *SEHCount = nullptr;
 
   // Used for /opt:lldlto=N
   unsigned LTOOptLevel = 2;
 
   // Used for /opt:lldltojobs=N
   unsigned LTOJobs = 1;
+  // Used for /opt:lldltopartitions=N
+  unsigned LTOPartitions = 1;
 
   // Used for /merge:from=to (e.g. /merge:.rdata=.text)
   std::map<StringRef, StringRef> Merge;
 
   // Used for /section=.name,{DEKPRSW} to set section attributes.
   std::map<StringRef, uint32_t> Section;
 
   // Options for manifest files.

lld/trunk/COFF/Driver.cpp

for (StringRef S : Vec) {
         continue;
       }
       if (StringRef(S).startswith("lldltojobs=")) {
         StringRef Jobs = StringRef(S).substr(11);
         if (Jobs.getAsInteger(10, Config->LTOJobs) || Config->LTOJobs == 0)
           fatal("/opt:lldltojobs: invalid job count: " + Jobs);
         continue;
       }
+      if (StringRef(S).startswith("lldltopartitions=")) {
+        StringRef N = StringRef(S).substr(17);
+        if (N.getAsInteger(10, Config->LTOPartitions) ||
+            Config->LTOPartitions == 0)
+          fatal("/opt:lldltopartitions: invalid partition count: " + N);
+        continue;
+      }
       if (S != "ref" && S != "lbr" && S != "nolbr")
         fatal("/opt: unknown option: " + S);
     }
   }
 
   // Handle /failifmismatch
   for (auto *Arg : Args.filtered(OPT_failifmismatch))
     checkFailIfMismatch(Arg->getValue());

lld/trunk/COFF/InputFiles.h

 //===- InputFiles.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_INPUT_FILES_H
 #define LLD_COFF_INPUT_FILES_H
 
 #include "lld/Core/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseSet.h"
-#include "llvm/IR/LLVMContext.h"
-#include "llvm/LTO/legacy/LTOModule.h"
+#include "llvm/LTO/LTO.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/StringSaver.h"
 #include <memory>
 #include <set>
 #include <vector>
 
 namespace lld {
 namespace coff {
 
-using llvm::LTOModule;
 using llvm::COFF::IMAGE_FILE_MACHINE_UNKNOWN;
 using llvm::COFF::MachineTypes;
 using llvm::object::Archive;
 using llvm::object::COFFObjectFile;
 using llvm::object::COFFSymbolRef;
 using llvm::object::coff_import_header;
 using llvm::object::coff_section;
 

 
 // Used for LTO.
 class BitcodeFile : public InputFile {
 public:
   explicit BitcodeFile(MemoryBufferRef M) : InputFile(BitcodeKind, M) {}
   static bool classof(const InputFile *F) { return F->kind() == BitcodeKind; }
   std::vector<SymbolBody *> &getSymbols() { return SymbolBodies; }
   MachineTypes getMachineType() override;
-  std::unique_ptr<LTOModule> takeModule() { return std::move(M); }
-
-  static llvm::LLVMContext Context;
+  std::unique_ptr<llvm::lto::InputFile> Obj;
 
 private:
   void parse() override;
 
   std::vector<SymbolBody *> SymbolBodies;
   llvm::BumpPtrAllocator Alloc;
-  std::unique_ptr<LTOModule> M;
 };
 } // namespace coff
 
 std::string toString(coff::InputFile *File);
 } // namespace lld
 
 #endif

lld/trunk/COFF/InputFiles.cpp

 #include "Error.h"
 #include "Memory.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "llvm-c/lto.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ADT/Twine.h"
-#include "llvm/IR/LLVMContext.h"
-#include "llvm/LTO/legacy/LTOModule.h"
+#include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/COFF.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Target/TargetOptions.h"
 #include <cstring>
 #include <system_error>
 #include <utility>
 
 using namespace llvm;
 using namespace llvm::COFF;
 using namespace llvm::object;
 using namespace llvm::support::endian;
 
 using llvm::Triple;
 using llvm::support::ulittle32_t;
 
 namespace lld {
 namespace coff {
 
-LLVMContext BitcodeFile::Context;
+/// Checks that Source is compatible with being a weak alias to Target.
+/// If Source is Undefined and has no weak alias set, makes it a weak
+/// alias to Target.
+static void checkAndSetWeakAlias(SymbolTable *Symtab, InputFile *F,
+                                 SymbolBody *Source, SymbolBody *Target) {
+  auto *U = dyn_cast<Undefined>(Source);
+  if (!U)
+    return;
+  else if (!U->WeakAlias)
+    U->WeakAlias = Target;
+  else if (U->WeakAlias != Target)
+    Symtab->reportDuplicate(Source->symbol(), F);
+}
 
 ArchiveFile::ArchiveFile(MemoryBufferRef M) : InputFile(ArchiveKind, M) {}
 
 void ArchiveFile::parse() {
   // Parse a MemoryBufferRef as an archive file.
   File = check(Archive::create(MB), toString(this));
 
   // Read the symbol table to construct Lazy objects.
for (uint32_t I = 0; I < NumSymbols; ++I) {
     }
     if (Body) {
       SymbolBodies.push_back(Body);
       SparseSymbolBodies[I] = Body;
     }
     I += Sym.getNumberOfAuxSymbols();
     LastSectionNumber = Sym.getSectionNumber();
   }
-  for (auto WeakAlias : WeakAliases) {
-    auto *U = dyn_cast<Undefined>(WeakAlias.first);
-    if (!U)
-      continue;
-    // Report an error if two undefined symbols have different weak aliases.
-    if (U->WeakAlias && U->WeakAlias != SparseSymbolBodies[WeakAlias.second])
-      Symtab->reportDuplicate(U->symbol(), this);
-    U->WeakAlias = SparseSymbolBodies[WeakAlias.second];
-  }
+  for (auto WeakAlias : WeakAliases)
+    checkAndSetWeakAlias(Symtab, this, WeakAlias.first,
+                         SparseSymbolBodies[WeakAlias.second]);
 }
 
 SymbolBody *ObjectFile::createUndefined(COFFSymbolRef Sym) {
   StringRef Name;
   COFFObj->getSymbolName(Sym, Name);
   return Symtab->addUndefined(Name, this, Sym.isWeakExternal())->body();
 }
 
 SymbolBody *ObjectFile::createDefined(COFFSymbolRef Sym, const void *AuxP,
                                       bool IsFirst) {
   StringRef Name;
   if (Sym.isCommon()) {
     auto *C = new (Alloc) CommonChunk(Sym);
     Chunks.push_back(C);
-    return Symtab->addCommon(this, Sym, C)->body();
+    COFFObj->getSymbolName(Sym, Name);
+    Symbol *S =
+        Symtab->addCommon(this, Name, Sym.getValue(), Sym.getGeneric(), C);
+    return S->body();
   }
   if (Sym.isAbsolute()) {
     COFFObj->getSymbolName(Sym, Name);
     // Skip special symbols.
     if (Name == "@comp.id")
       return nullptr;
     // COFF spec 5.10.1. The .sxdata section.
     if (Name == "@feat.00") {
if (IsFirst && AuxP) {
     if (Aux->Selection == IMAGE_COMDAT_SELECT_ASSOCIATIVE)
       if (auto *ParentSC = cast_or_null<SectionChunk>(
               SparseChunks[Aux->getNumber(Sym.isBigObj())]))
         ParentSC->addAssociative(SC);
     SC->Checksum = Aux->CheckSum;
   }
 
   DefinedRegular *B;
-  if (Sym.isExternal())
-    B = cast<DefinedRegular>(Symtab->addRegular(this, Sym, SC)->body());
-  else
-    B = new (Alloc) DefinedRegular(this, Sym, SC);
+  if (Sym.isExternal()) {
+    COFFObj->getSymbolName(Sym, Name);
+    Symbol *S =
+        Symtab->addRegular(this, Name, SC->isCOMDAT(), Sym.getGeneric(), SC);
+    B = cast<DefinedRegular>(S->body());
+  } else
+    B = new (Alloc) DefinedRegular(this, /*Name*/ "", SC->isCOMDAT(),
+                                   /*IsExternal*/ false, Sym.getGeneric(), SC);
   if (SC->isCOMDAT() && Sym.getValue() == 0 && !AuxP)
     SC->setSymbol(B);
 
   return B;
 }
 
 void ObjectFile::initializeSEH() {
   if (!SEHCompat || !SXData)
void ImportFile::parse() {
   // DLL functions just like regular non-DLL functions.)
   if (Hdr->getType() != llvm::COFF::IMPORT_CODE)
     return;
   ThunkSym = cast<DefinedImportThunk>(
       Symtab->addImportThunk(Name, ImpSym, Hdr->Machine)->body());
 }
 
 void BitcodeFile::parse() {
-  Context.enableDebugTypeODRUniquing();
-  ErrorOr<std::unique_ptr<LTOModule>> ModOrErr = LTOModule::createFromBuffer(
-      Context, MB.getBufferStart(), MB.getBufferSize(), llvm::TargetOptions());
-  M = check(std::move(ModOrErr), "could not create LTO module");
-
-  StringSaver Saver(Alloc);
-  for (unsigned I = 0, E = M->getSymbolCount(); I != E; ++I) {
-    lto_symbol_attributes Attrs = M->getSymbolAttributes(I);
-    if ((Attrs & LTO_SYMBOL_SCOPE_MASK) == LTO_SYMBOL_SCOPE_INTERNAL)
-      continue;
-
-    StringRef SymName = Saver.save(M->getSymbolName(I));
-    int SymbolDef = Attrs & LTO_SYMBOL_DEFINITION_MASK;
-    if (SymbolDef == LTO_SYMBOL_DEFINITION_UNDEFINED) {
-      SymbolBodies.push_back(Symtab->addUndefined(SymName, this, false)->body());
+  Obj = check(lto::InputFile::create(
+      MemoryBufferRef(MB.getBuffer(), Saver.save(MB.getBufferIdentifier()))));
+  for (const lto::InputFile::Symbol &ObjSym : Obj->symbols()) {
+    StringRef SymName = Saver.save(ObjSym.getName());
+    auto Flags = ObjSym.getFlags();
+    Symbol *Sym;
+    if (Flags & object::BasicSymbolRef::SF_Undefined) {
+      Sym = Symtab->addUndefined(SymName, this, false);
+    } else if (Flags & object::BasicSymbolRef::SF_Common) {
+      Sym = Symtab->addCommon(this, SymName, ObjSym.getCommonSize());
+    } else if ((Flags & object::BasicSymbolRef::SF_Weak) &&
+               (Flags & object::BasicSymbolRef::SF_Indirect)) {
+      // Weak external.
+      Sym = Symtab->addUndefined(SymName, this, true);
+      std::string Fallback = ObjSym.getCOFFWeakExternalFallback();
+      SymbolBody *Alias = Symtab->addUndefined(Saver.save(Fallback));
+      checkAndSetWeakAlias(Symtab, this, Sym->body(), Alias);
     } else {
-      bool Replaceable =
-          (SymbolDef == LTO_SYMBOL_DEFINITION_TENTATIVE || // common
-           (Attrs & LTO_SYMBOL_COMDAT) ||                  // comdat
-           (SymbolDef == LTO_SYMBOL_DEFINITION_WEAK &&     // weak external
-            (Attrs & LTO_SYMBOL_ALIAS)));
-      SymbolBodies.push_back(
-          Symtab->addBitcode(this, SymName, Replaceable)->body());
+      Expected<int> ComdatIndex = ObjSym.getComdatIndex();
+      bool IsCOMDAT = ComdatIndex && *ComdatIndex != -1;
+      Sym = Symtab->addRegular(this, SymName, IsCOMDAT);
     }
+    SymbolBodies.push_back(Sym->body());
   }
-
-  Directives = M->getLinkerOpts();
+  Directives = check(Obj->getLinkerOpts());
 }
 
 MachineTypes BitcodeFile::getMachineType() {
-  if (!M)
+  Expected<std::string> ET = getBitcodeTargetTriple(MB);
+  if (!ET)
     return IMAGE_FILE_MACHINE_UNKNOWN;
-  switch (Triple(M->getTargetTriple()).getArch()) {
+  switch (Triple(*ET).getArch()) {
   case Triple::x86_64:
     return AMD64;
   case Triple::x86:
     return I386;
   case Triple::arm:
     return ARMNT;
   default:
     return IMAGE_FILE_MACHINE_UNKNOWN;

lld/trunk/COFF/LTO.h

+//===- LTO.h ----------------------------------------------------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides a way to combine bitcode files into one COFF
+// file by compiling them using LLVM.
+//
+// If LTO is in use, your input files are not in regular COFF files
+// but instead LLVM bitcode files. In that case, the linker has to
+// convert bitcode files into the native format so that we can create
+// a COFF file that contains native code. This file provides that
+// functionality.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_COFF_LTO_H
+#define LLD_COFF_LTO_H
+
+#include "lld/Core/LLVM.h"
+#include "llvm/ADT/SmallString.h"
+#include <memory>
+#include <vector>
+
+namespace llvm {
+namespace lto {
+class LTO;
+}
+}
+
+namespace lld {
+namespace coff {
+
+class BitcodeFile;
+class InputFile;
+
+class BitcodeCompiler {
+public:
+  BitcodeCompiler();
+  ~BitcodeCompiler();
+
+  void add(BitcodeFile &F);
+  std::vector<InputFile *> compile();
+
+private:
+  std::unique_ptr<llvm::lto::LTO> LTOObj;
+  std::vector<SmallString<0>> Buff;
+};
+}
+}
+
+#endif

lld/trunk/COFF/LTO.cpp

+//===- LTO.cpp ------------------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "LTO.h"
+#include "Config.h"
+#include "Error.h"
+#include "InputFiles.h"
+#include "Symbols.h"
+#include "lld/Core/TargetOptionsCommandFlags.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Twine.h"
+#include "llvm/IR/DiagnosticPrinter.h"
+#include "llvm/LTO/Config.h"
+#include "llvm/LTO/LTO.h"
+#include "llvm/Object/SymbolicFile.h"
+#include "llvm/Support/CodeGen.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/raw_ostream.h"
+#include <algorithm>
+#include <cstddef>
+#include <memory>
+#include <string>
+#include <system_error>
+#include <vector>
+
+using namespace llvm;
+using namespace llvm::object;
+
+using namespace lld;
+using namespace lld::coff;
+
+static void diagnosticHandler(const DiagnosticInfo &DI) {
+  SmallString<128> ErrStorage;
+  raw_svector_ostream OS(ErrStorage);
+  DiagnosticPrinterRawOStream DP(OS);
+  DI.print(DP);
+  warn(ErrStorage);
+}
+
+static void checkError(Error E) {
+  handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) -> Error {
+    error(EIB.message());
+    return Error::success();
+  });
+}
+
+static std::unique_ptr<lto::LTO> createLTO() {
+  lto::Config Conf;
+  Conf.Options = InitTargetOptionsFromCodeGenFlags();
+  Conf.RelocModel = Reloc::PIC_;
+  Conf.DisableVerify = true;
+  Conf.DiagHandler = diagnosticHandler;
+  Conf.OptLevel = Config->LTOOptLevel;
+  lto::ThinBackend Backend;
+  if (Config->LTOJobs != -1u)
+    Backend = lto::createInProcessThinBackend(Config->LTOJobs);
+  return llvm::make_unique<lto::LTO>(std::move(Conf), Backend,
+                                     Config->LTOPartitions);
+}
+
+BitcodeCompiler::BitcodeCompiler() : LTOObj(createLTO()) {}
+
+BitcodeCompiler::~BitcodeCompiler() = default;
+
+static void undefine(Symbol *S) {
+  replaceBody<Undefined>(S, S->body()->getName());
+}
+
+void BitcodeCompiler::add(BitcodeFile &F) {
+  lto::InputFile &Obj = *F.Obj;
+  unsigned SymNum = 0;
+  std::vector<SymbolBody *> SymBodies = F.getSymbols();
+  std::vector<lto::SymbolResolution> Resols(SymBodies.size());
+
+  // Provide a resolution to the LTO API for each symbol.
+  for (const lto::InputFile::Symbol &ObjSym : Obj.symbols()) {
+    SymbolBody *B = SymBodies[SymNum];
+    Symbol *Sym = B->symbol();
+    lto::SymbolResolution &R = Resols[SymNum];
+    ++SymNum;
+
+    // Ideally we shouldn't check for SF_Undefined but currently IRObjectFile
+    // reports two symbols for module ASM defined. Without this check, lld
+    // flags an undefined in IR with a definition in ASM as prevailing.
+    // Once IRObjectFile is fixed to report only one symbol this hack can
+    // be removed.
+    R.Prevailing =
+        !(ObjSym.getFlags() & object::BasicSymbolRef::SF_Undefined) &&
+        B->getFile() == &F;
+    R.VisibleToRegularObj = Sym->IsUsedInRegularObj;
+    if (R.Prevailing)
+      undefine(Sym);
+  }
+  checkError(LTOObj->add(std::move(F.Obj), Resols));
+}
+
+// Merge all the bitcode files we have seen, codegen the result
+// and return the resulting ObjectFile(s).
+std::vector<InputFile *> BitcodeCompiler::compile() {
+  std::vector<InputFile *> Ret;
+  unsigned MaxTasks = LTOObj->getMaxTasks();
+  Buff.resize(MaxTasks);
+
+  checkError(LTOObj->run([&](size_t Task) {
+    return llvm::make_unique<lto::NativeObjectStream>(
+        llvm::make_unique<raw_svector_ostream>(Buff[Task]));
+  }));
+
+  for (unsigned I = 0; I != MaxTasks; ++I) {
+    if (Buff[I].empty())
+      continue;
+    Ret.push_back(make<ObjectFile>(MemoryBufferRef(Buff[I], "lto.tmp")));
+  }
+  return Ret;
+}

lld/trunk/COFF/SymbolTable.h

 //===- SymbolTable.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_SYMBOL_TABLE_H
 #define LLD_COFF_SYMBOL_TABLE_H
 
 #include "InputFiles.h"
+#include "LTO.h"
 #include "llvm/ADT/CachedHashString.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 struct LTOCodeGenerator;
public:
   SymbolBody *addUndefined(StringRef Name);
 
   Symbol *addRelative(StringRef N, uint64_t VA);
   Symbol *addAbsolute(StringRef N, uint64_t VA);
 
   Symbol *addUndefined(StringRef Name, InputFile *F, bool IsWeakAlias);
   void addLazy(ArchiveFile *F, const Archive::Symbol Sym);
   Symbol *addAbsolute(StringRef N, COFFSymbolRef S);
-  Symbol *addRegular(ObjectFile *F, COFFSymbolRef S, SectionChunk *C);
-  Symbol *addBitcode(BitcodeFile *F, StringRef N, bool IsReplaceable);
-  Symbol *addCommon(ObjectFile *F, COFFSymbolRef S, CommonChunk *C);
+  Symbol *addRegular(InputFile *F, StringRef N, bool IsCOMDAT,
+                     const llvm::object::coff_symbol_generic *S = nullptr,
+                     SectionChunk *C = nullptr);
+  Symbol *addCommon(InputFile *F, StringRef N, uint64_t Size,
+                    const llvm::object::coff_symbol_generic *S = nullptr,
+                    CommonChunk *C = nullptr);
   Symbol *addImportData(StringRef N, ImportFile *F);
   Symbol *addImportThunk(StringRef Name, DefinedImportData *S,
                          uint16_t Machine);
 
   void reportDuplicate(Symbol *Existing, InputFile *NewFile);
 
   // A list of chunks which to be added to .rdata.
   std::vector<Chunk *> LocalImportChunks;
 
 private:
   void readArchive();
   void readObjects();
 
   std::pair<Symbol *, bool> insert(StringRef Name);
   StringRef findByPrefix(StringRef Prefix);
 
   void addCombinedLTOObject(ObjectFile *Obj);
-  std::vector<ObjectFile *> createLTOObjects(llvm::LTOCodeGenerator *CG);
 
   llvm::DenseMap<llvm::CachedHashStringRef, Symbol *> Symtab;
 
   std::vector<BitcodeFile *> BitcodeFiles;
-  std::vector<SmallString<0>> Objs;
+  std::unique_ptr<BitcodeCompiler> LTO;
 };
 
 extern SymbolTable *Symtab;
 
 } // namespace coff
 } // namespace lld
 
 #endif

lld/trunk/COFF/SymbolTable.cpp

 //===- SymbolTable.cpp ----------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "SymbolTable.h"
 #include "Config.h"
 #include "Driver.h"
 #include "Error.h"
+#include "LTO.h"
 #include "Memory.h"
 #include "Symbols.h"
 #include "llvm/IR/LLVMContext.h"
-#include "llvm/LTO/legacy/LTOCodeGenerator.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include <utility>
 
 using namespace llvm;
 
 namespace lld {
 namespace coff {
 
+enum SymbolPreference {
+  SP_EXISTING = -1,
+  SP_CONFLICT = 0,
+  SP_NEW = 1,
+};
+
+/// Checks if an existing symbol S should be kept or replaced by a new symbol.
+/// Returns SP_EXISTING when S should be kept, SP_NEW when the new symbol
+/// should be kept, and SP_CONFLICT if no valid resolution exists.
+static SymbolPreference compareDefined(Symbol *S, bool WasInserted,
+                                       bool NewIsCOMDAT) {
+  // If the symbol wasn't previously known, the new symbol wins by default.
+  if (WasInserted || !isa<Defined>(S->body()))
+    return SP_NEW;
+
+  // If the existing symbol is a DefinedRegular, both it and the new symbol
+  // must be comdats. In that case, we have no reason to prefer one symbol
+  // over the other, and we keep the existing one. If one of the symbols
+  // is not a comdat, we report a conflict.
+  if (auto *R = dyn_cast<DefinedRegular>(S->body())) {
+    if (NewIsCOMDAT && R->isCOMDAT())
+      return SP_EXISTING;
+    else
+      return SP_CONFLICT;
+  }
+
+  // Existing symbol is not a DefinedRegular; new symbol wins.
+  return SP_NEW;
+}
+
 SymbolTable *Symtab;
 
 void SymbolTable::addFile(InputFile *File) {
   if (Config->Verbose)
     outs() << "Reading " << toString(File) << "\n";
   File->parse();
 
   MachineTypes MT = File->getMachineType();
Symbol *SymbolTable::addRelative(StringRef N, uint64_t VA) {
   S->IsUsedInRegularObj = true;
   if (WasInserted || isa<Undefined>(S->body()) || isa<Lazy>(S->body()))
     replaceBody<DefinedRelative>(S, N, VA);
   else if (!isa<DefinedCOFF>(S->body()))
     reportDuplicate(S, nullptr);
   return S;
 }
 
-Symbol *SymbolTable::addRegular(ObjectFile *F, COFFSymbolRef Sym,
+Symbol *SymbolTable::addRegular(InputFile *F, StringRef N, bool IsCOMDAT,
+                                const coff_symbol_generic *Sym,
                                 SectionChunk *C) {
-  StringRef Name;
-  F->getCOFFObj()->getSymbolName(Sym, Name);
   Symbol *S;
   bool WasInserted;
-  std::tie(S, WasInserted) = insert(Name);
+  std::tie(S, WasInserted) = insert(N);
+  if (!isa<BitcodeFile>(F))
     S->IsUsedInRegularObj = true;
-  if (WasInserted || isa<Undefined>(S->body()) || isa<Lazy>(S->body()))
-    replaceBody<DefinedRegular>(S, F, Sym, C);
-  else if (auto *R = dyn_cast<DefinedRegular>(S->body())) {
-    if (!C->isCOMDAT() || !R->isCOMDAT())
-      reportDuplicate(S, F);
-  } else if (auto *B = dyn_cast<DefinedBitcode>(S->body())) {
-    if (B->IsReplaceable)
-      replaceBody<DefinedRegular>(S, F, Sym, C);
-    else if (!C->isCOMDAT())
-      reportDuplicate(S, F);
-  } else
-    replaceBody<DefinedRegular>(S, F, Sym, C);
-  return S;
-}
-
-Symbol *SymbolTable::addBitcode(BitcodeFile *F, StringRef N, bool IsReplaceable) {
-  Symbol *S;
-  bool WasInserted;
-  std::tie(S, WasInserted) = insert(N);
-  if (WasInserted || isa<Undefined>(S->body()) || isa<Lazy>(S->body())) {
-    replaceBody<DefinedBitcode>(S, F, N, IsReplaceable);
-    return S;
+  SymbolPreference SP = compareDefined(S, WasInserted, IsCOMDAT);
+  if (SP == SP_CONFLICT) {
+  } else if (SP == SP_NEW) {
+    replaceBody<DefinedRegular>(S, F, N, IsCOMDAT, /*IsExternal*/ true, Sym, C);
   }
-  if (isa<DefinedCommon>(S->body()))
-    return S;
-  if (IsReplaceable)
-    if (isa<DefinedRegular>(S->body()) || isa<DefinedBitcode>(S->body()))
-      return S;
-  reportDuplicate(S, F);
   return S;
 }
 
-Symbol *SymbolTable::addCommon(ObjectFile *F, COFFSymbolRef Sym,
-                               CommonChunk *C) {
-  StringRef Name;
-  F->getCOFFObj()->getSymbolName(Sym, Name);
+Symbol *SymbolTable::addCommon(InputFile *F, StringRef N, uint64_t Size,
+                               const coff_symbol_generic *Sym, CommonChunk *C) {
   Symbol *S;
   bool WasInserted;
-  std::tie(S, WasInserted) = insert(Name);
+  std::tie(S, WasInserted) = insert(N);
+  if (!isa<BitcodeFile>(F))
     S->IsUsedInRegularObj = true;
   if (WasInserted || !isa<DefinedCOFF>(S->body()))
-    replaceBody<DefinedCommon>(S, F, Sym, C);
+    replaceBody<DefinedCommon>(S, F, N, Size, Sym, C);
   else if (auto *DC = dyn_cast<DefinedCommon>(S->body()))
-    if (Sym.getValue() > DC->getSize())
-      replaceBody<DefinedCommon>(S, F, Sym, C);
+    if (Size > DC->getSize())
+      replaceBody<DefinedCommon>(S, F, N, Size, Sym, C);
   return S;
 }
 
 Symbol *SymbolTable::addImportData(StringRef N, ImportFile *F) {
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(N);
   S->IsUsedInRegularObj = true;

 SymbolBody *SymbolTable::addUndefined(StringRef Name) {
   return addUndefined(Name, nullptr, false)->body();
 }
 
 void SymbolTable::addCombinedLTOObjects() {
   if (BitcodeFiles.empty())
     return;
 
-  // Create an object file and add it to the symbol table by replacing any
-  // DefinedBitcode symbols with the definitions in the object file.
-  LTOCodeGenerator CG(BitcodeFile::Context);
-  CG.setOptLevel(Config->LTOOptLevel);
-  for (ObjectFile *Obj : createLTOObjects(&CG))
+  LTO.reset(new BitcodeCompiler);
+  for (BitcodeFile *F : BitcodeFiles)
+    LTO->add(*F);
+
+  for (auto *File : LTO->compile()) {
+    auto *Obj = cast<ObjectFile>(File);
+    ObjectFiles.push_back(Obj);
     Obj->parse();
   }
-
-// Combine and compile bitcode files and then return the result
-// as a vector of regular COFF object files.
-std::vector<ObjectFile *> SymbolTable::createLTOObjects(LTOCodeGenerator *CG) {
-  // All symbols referenced by non-bitcode objects, including GC roots, must be
-  // preserved. We must also replace bitcode symbols with undefined symbols so
-  // that they may be replaced with real definitions without conflicting.
-  for (BitcodeFile *File : BitcodeFiles)
-    for (SymbolBody *Body : File->getSymbols()) {
-      if (!isa<DefinedBitcode>(Body))
-        continue;
-      if (Body->symbol()->IsUsedInRegularObj)
-        CG->addMustPreserveSymbol(Body->getName());
-      replaceBody<Undefined>(Body->symbol(), Body->getName());
-    }
-
-  CG->setModule(BitcodeFiles[0]->takeModule());
-  for (unsigned I = 1, E = BitcodeFiles.size(); I != E; ++I)
-    CG->addModule(BitcodeFiles[I]->takeModule().get());
-
-  bool DisableVerify = true;
-#ifdef NDEBUG
-  DisableVerify = false;
-#endif
-  if (!CG->optimize(DisableVerify, false, false, false))
-    fatal(""); // optimize() should have emitted any error message.
-
-  Objs.resize(Config->LTOJobs);
-  // Use std::list to avoid invalidation of pointers in OSPtrs.
-  std::list<raw_svector_ostream> OSs;
-  std::vector<raw_pwrite_stream *> OSPtrs;
-  for (SmallString<0> &Obj : Objs) {
-    OSs.emplace_back(Obj);
-    OSPtrs.push_back(&OSs.back());
-  }
-
-  if (!CG->compileOptimized(OSPtrs))
-    fatal(""); // compileOptimized() should have emitted any error message.
-
-  std::vector<ObjectFile *> ObjFiles;
-  for (SmallString<0> &Obj : Objs) {
-    auto *ObjFile = make<ObjectFile>(MemoryBufferRef(Obj, "<LTO object>"));
-    ObjectFiles.push_back(ObjFile);
-    ObjFiles.push_back(ObjFile);
-  }
-
-  return ObjFiles;
 }
-
 } // namespace coff
 } // namespace lld

lld/trunk/COFF/Symbols.h

 namespace coff {
 
 using llvm::object::Archive;
 using llvm::object::COFFSymbolRef;
 using llvm::object::coff_import_header;
 using llvm::object::coff_symbol_generic;
 
 class ArchiveFile;
-class BitcodeFile;
 class InputFile;
 class ObjectFile;
 struct Symbol;
 class SymbolTable;
 
 // The base class for real symbol classes.
 class SymbolBody {
 public:
   enum Kind {
     // The order of these is significant. We start with the regular defined
     // symbols as those are the most prevelant and the zero tag is the cheapest
     // to set. Among the defined kinds, the lower the kind is preferred over
     // the higher kind when testing wether one symbol should take precedence
     // over another.
     DefinedRegularKind = 0,
     DefinedCommonKind,
     DefinedLocalImportKind,
     DefinedImportThunkKind,
     DefinedImportDataKind,
     DefinedAbsoluteKind,
     DefinedRelativeKind,
-    DefinedBitcodeKind,
 
     UndefinedKind,
     LazyKind,
 
     LastDefinedCOFFKind = DefinedCommonKind,
-    LastDefinedKind = DefinedBitcodeKind,
+    LastDefinedKind = DefinedRelativeKind,
   };
 
   Kind kind() const { return static_cast<Kind>(SymbolKind); }
 
   // Returns true if this is an external symbol.
   bool isExternal() { return IsExternal; }
 
   // Returns the symbol name.
   StringRef getName();
 
   // Returns the file from which this symbol was created.
   InputFile *getFile();
 
   Symbol *symbol();
   const Symbol *symbol() const {
     return const_cast<SymbolBody *>(this)->symbol();
   }
 
 protected:
   friend SymbolTable;
   explicit SymbolBody(Kind K, StringRef N = "")
       : SymbolKind(K), IsExternal(true), IsCOMDAT(false),
-        IsReplaceable(false), WrittenToSymtab(false), Name(N) {}
+        WrittenToSymtab(false), Name(N) {}
 
   const unsigned SymbolKind : 8;
   unsigned IsExternal : 1;
 
   // This bit is used by the \c DefinedRegular subclass.
   unsigned IsCOMDAT : 1;
 
-  // This bit is used by the \c DefinedBitcode subclass.
-  unsigned IsReplaceable : 1;
-
 public:
-  // This bit is used by Writer::createSymbolAndStringTable().
+  // This bit is used by Writer::createSymbolAndStringTable() to prevent
+  // symbols from being written to the symbol table more than once.
   unsigned WrittenToSymtab : 1;
 
 protected:
   StringRef Name;
 };
 
 // The base class for any defined symbols, including absolute symbols,
 // etc.
 class Defined : public SymbolBody {
 public:
-  Defined(Kind K, StringRef N = "") : SymbolBody(K, N) {}
+  Defined(Kind K, StringRef N) : SymbolBody(K, N) {}
 
   static bool classof(const SymbolBody *S) {
     return S->kind() <= LastDefinedKind;
   }
 
   // Returns the RVA (relative virtual address) of this symbol. The
   // writer sets and uses RVAs.
   uint64_t getRVA();
 
   // Returns the RVA relative to the beginning of the output section.
   // Used to implement SECREL relocation type.
   uint64_t getSecrel();
 
   // Returns the output section index.
   // Used to implement SECTION relocation type.
   uint64_t getSectionIndex();
 
   // Returns true if this symbol points to an executable (e.g. .text) section.
   // Used to implement ARM relocations.
   bool isExecutable();
 };
 
-// Symbols defined via a COFF object file.
+// Symbols defined via a COFF object file or bitcode file.  For COFF files, this
+// stores a coff_symbol_generic*, and names of internal symbols are lazily
+// loaded through that. For bitcode files, Sym is nullptr and the name is stored
+// as a StringRef.
 class DefinedCOFF : public Defined {
   friend SymbolBody;
 public:
-  DefinedCOFF(Kind K, ObjectFile *F, COFFSymbolRef S)
-      : Defined(K), File(F), Sym(S.getGeneric()) {}
+  DefinedCOFF(Kind K, InputFile *F, StringRef N, const coff_symbol_generic *S)
+      : Defined(K, N), File(F), Sym(S) {}
 
   static bool classof(const SymbolBody *S) {
     return S->kind() <= LastDefinedCOFFKind;
   }
 
-  ObjectFile *getFile() { return File; }
+  InputFile *getFile() { return File; }
 
   COFFSymbolRef getCOFFSymbol();
 
-  ObjectFile *File;
+  InputFile *File;
 
 protected:
   const coff_symbol_generic *Sym;
 };
 
 // Regular defined symbols read from object file symbol tables.
 class DefinedRegular : public DefinedCOFF {
 public:
-  DefinedRegular(ObjectFile *F, COFFSymbolRef S, SectionChunk *C)
-      : DefinedCOFF(DefinedRegularKind, F, S), Data(&C->Repl) {
-    IsExternal = S.isExternal();
-    IsCOMDAT = C->isCOMDAT();
+  DefinedRegular(InputFile *F, StringRef N, bool IsCOMDAT,
+                 bool IsExternal = false,
+                 const coff_symbol_generic *S = nullptr,
+                 SectionChunk *C = nullptr)
+      : DefinedCOFF(DefinedRegularKind, F, N, S), Data(&C->Repl) {
+    this->IsExternal = IsExternal;
+    this->IsCOMDAT = IsCOMDAT;
   }
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == DefinedRegularKind;
   }
 
   uint64_t getRVA() { return (*Data)->getRVA() + Sym->Value; }
   bool isCOMDAT() { return IsCOMDAT; }
   SectionChunk *getChunk() { return *Data; }
   uint32_t getValue() { return Sym->Value; }
 
 private:
   SectionChunk **Data;
 };
 
 class DefinedCommon : public DefinedCOFF {
 public:
-  DefinedCommon(ObjectFile *F, COFFSymbolRef S, CommonChunk *C)
-      : DefinedCOFF(DefinedCommonKind, F, S), Data(C) {
-    IsExternal = S.isExternal();
+  DefinedCommon(InputFile *F, StringRef N, uint64_t Size,
+                const coff_symbol_generic *S = nullptr,
+                CommonChunk *C = nullptr)
+      : DefinedCOFF(DefinedCommonKind, F, N, S), Data(C), Size(Size) {
+    this->IsExternal = true;
   }
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == DefinedCommonKind;
   }
 
   uint64_t getRVA() { return Data->getRVA(); }
 
 private:
   friend SymbolTable;
-  uint64_t getSize() { return Sym->Value; }
+  uint64_t getSize() const { return Size; }
   CommonChunk *Data;
+  uint64_t Size;
 };
 
 // Absolute symbols.
 class DefinedAbsolute : public Defined {
 public:
   DefinedAbsolute(StringRef N, COFFSymbolRef S)
       : Defined(DefinedAbsoluteKind, N), VA(S.getValue()) {
     IsExternal = S.isExternal();
public:
 
   uint64_t getRVA() { return Data->getRVA(); }
   Chunk *getChunk() { return Data; }
 
 private:
   LocalImportChunk *Data;
 };
 
-class DefinedBitcode : public Defined {
-  friend SymbolBody;
-public:
-  DefinedBitcode(BitcodeFile *F, StringRef N, bool IsReplaceable)
-      : Defined(DefinedBitcodeKind, N), File(F) {
-    // IsReplaceable tracks whether the bitcode symbol may be replaced with some
-    // other (defined, common or bitcode) symbol. This is the case for common,
-    // comdat and weak external symbols. We try to replace bitcode symbols with
-    // "real" symbols (see SymbolTable::add{Regular,Bitcode}), and resolve the
-    // result against the real symbol from the combined LTO object.
-    this->IsReplaceable = IsReplaceable;
-  }
-
-  static bool classof(const SymbolBody *S) {
-    return S->kind() == DefinedBitcodeKind;
-  }
-
-  BitcodeFile *File;
-};
-
 inline uint64_t Defined::getRVA() {
   switch (kind()) {
   case DefinedAbsoluteKind:
     return cast<DefinedAbsolute>(this)->getRVA();
   case DefinedRelativeKind:
     return cast<DefinedRelative>(this)->getRVA();
   case DefinedImportDataKind:
     return cast<DefinedImportData>(this)->getRVA();
   case DefinedImportThunkKind:
     return cast<DefinedImportThunk>(this)->getRVA();
   case DefinedLocalImportKind:
     return cast<DefinedLocalImport>(this)->getRVA();
   case DefinedCommonKind:
     return cast<DefinedCommon>(this)->getRVA();
   case DefinedRegularKind:
     return cast<DefinedRegular>(this)->getRVA();
-  case DefinedBitcodeKind:
-    llvm_unreachable("There is no address for a bitcode symbol.");
   case LazyKind:
   case UndefinedKind:
     llvm_unreachable("Cannot get the address for an undefined symbol.");
   }
   llvm_unreachable("unknown symbol kind");
 }
 
 // A real symbol object, SymbolBody, is usually stored within a Symbol. There's
 // always one Symbol for each symbol name. The resolver updates the SymbolBody
 // stored in the Body field of this object as it resolves symbols. Symbol also
 // holds computed properties of symbol names.
 struct Symbol {
   // True if this symbol was referenced by a regular (non-bitcode) object.
   unsigned IsUsedInRegularObj : 1;
 
   // True if we've seen both a lazy and an undefined symbol with this symbol
   // name, which means that we have enqueued an archive member load and should
   // not load any more archive members to resolve the same symbol.
   unsigned PendingArchiveLoad : 1;
 
   // This field is used to store the Symbol's SymbolBody. This instantiation of
   // AlignedCharArrayUnion gives us a struct with a char array field that is
   // large and aligned enough to store any derived class of SymbolBody.
-  llvm::AlignedCharArrayUnion<DefinedRegular, DefinedCommon, DefinedAbsolute,
-                              DefinedRelative, Lazy, Undefined,
-                              DefinedImportData, DefinedImportThunk,
-                              DefinedLocalImport, DefinedBitcode>
+  llvm::AlignedCharArrayUnion<
+      DefinedRegular, DefinedCommon, DefinedAbsolute, DefinedRelative, Lazy,
+      Undefined, DefinedImportData, DefinedImportThunk, DefinedLocalImport>
       Body;
 
   SymbolBody *body() {
     return reinterpret_cast<SymbolBody *>(Body.buffer);
   }
   const SymbolBody *body() const { return const_cast<Symbol *>(this)->body(); }
 };
 

lld/trunk/COFF/Symbols.cpp

if (Optional<std::string> S = coff::demangle(B.getName()))
     return ("\"" + *S + "\" (" + B.getName() + ")").str();
   return B.getName();
 }
 
 namespace lld {
 namespace coff {
 
 StringRef SymbolBody::getName() {
-  // DefinedCOFF names are read lazily for a performance reason.
+  // COFF symbol names are read lazily for a performance reason.
   // Non-external symbol names are never used by the linker except for logging
   // or debugging. Their internal references are resolved not by name but by
   // symbol index. And because they are not external, no one can refer them by
   // name. Object files contain lots of non-external symbols, and creating
   // StringRefs for them (which involves lots of strlen() on the string table)
   // is a waste of time.
   if (Name.empty()) {
     auto *D = cast<DefinedCOFF>(this);
-    D->File->getCOFFObj()->getSymbolName(D->Sym, Name);
+    cast<ObjectFile>(D->File)->getCOFFObj()->getSymbolName(D->Sym, Name);
   }
   return Name;
 }
 
 InputFile *SymbolBody::getFile() {
   if (auto *Sym = dyn_cast<DefinedCOFF>(this))
     return Sym->File;
-  if (auto *Sym = dyn_cast<DefinedBitcode>(this))
-    return Sym->File;
   if (auto *Sym = dyn_cast<Lazy>(this))
     return Sym->File;
   return nullptr;
 }
 
 COFFSymbolRef DefinedCOFF::getCOFFSymbol() {
-  size_t SymSize = File->getCOFFObj()->getSymbolTableEntrySize();
+  size_t SymSize =
+      cast<ObjectFile>(File)->getCOFFObj()->getSymbolTableEntrySize();
   if (SymSize == sizeof(coff_symbol16))
     return COFFSymbolRef(reinterpret_cast<const coff_symbol16 *>(Sym));
   assert(SymSize == sizeof(coff_symbol32));
   return COFFSymbolRef(reinterpret_cast<const coff_symbol32 *>(Sym));
 }
 
 DefinedImportThunk::DefinedImportThunk(StringRef Name, DefinedImportData *S,
                                        uint16_t Machine)

lld/trunk/test/COFF/lto-comdat.ll

 ; RUN: llvm-as -o %T/comdat-main.lto.obj %s
 ; RUN: llvm-as -o %T/comdat1.lto.obj %S/Inputs/lto-comdat1.ll
 ; RUN: llvm-as -o %T/comdat2.lto.obj %S/Inputs/lto-comdat2.ll
 ; RUN: rm -f %T/comdat.lto.lib
 ; RUN: llvm-ar cru %T/comdat.lto.lib %T/comdat1.lto.obj %T/comdat2.lto.obj
 
 ; RUN: llc -filetype=obj -o %T/comdat-main.obj %s
 ; RUN: llc -filetype=obj -o %T/comdat1.obj %S/Inputs/lto-comdat1.ll
 ; RUN: llc -filetype=obj -o %T/comdat2.obj %S/Inputs/lto-comdat2.ll
 ; RUN: rm -f %T/comdat.lib
 ; RUN: llvm-ar cru %T/comdat.lib %T/comdat1.obj %T/comdat2.obj
 
+; Check that, when we use an LTO main with LTO objects, we optimize away all
+; of f1, f2, and comdat.
 ; RUN: lld-link /out:%T/comdat-main.exe /entry:main /subsystem:console %T/comdat-main.lto.obj %T/comdat1.lto.obj %T/comdat2.lto.obj
 ; RUN: llvm-readobj -file-headers %T/comdat-main.exe | FileCheck -check-prefix=HEADERS-11 %s
 ; RUN: llvm-objdump -d %T/comdat-main.exe | FileCheck -check-prefix=TEXT-11 %s
 ; RUN: lld-link /out:%T/comdat-main.exe /entry:main /subsystem:console %T/comdat-main.lto.obj %T/comdat.lto.lib
 ; RUN: llvm-readobj -file-headers %T/comdat-main.exe | FileCheck -check-prefix=HEADERS-11 %s
 ; RUN: llvm-objdump -d %T/comdat-main.exe | FileCheck -check-prefix=TEXT-11 %s
 
+; Check that, when we use a non-LTO main with LTO objects, we pick the comdat
+; implementation in LTO, elide calls to it from inside LTO, and retain the
+; call to comdat from main.
 ; RUN: lld-link /out:%T/comdat-main.exe /entry:main /subsystem:console %T/comdat-main.obj %T/comdat1.lto.obj %T/comdat2.lto.obj
 ; RUN: llvm-readobj -file-headers %T/comdat-main.exe | FileCheck -check-prefix=HEADERS-01 %s
 ; RUN: llvm-objdump -d %T/comdat-main.exe | FileCheck -check-prefix=TEXT-01 %s
 ; RUN: lld-link /out:%T/comdat-main.exe /entry:main /subsystem:console %T/comdat-main.obj %T/comdat.lto.lib
 ; RUN: llvm-readobj -file-headers %T/comdat-main.exe | FileCheck -check-prefix=HEADERS-01 %s
 ; RUN: llvm-objdump -d %T/comdat-main.exe | FileCheck -check-prefix=TEXT-01 %s
 
+; Check that, when we use an LTO main with non-LTO objects, we pick the comdat
+; implementation in LTO, elide the call to it from inside LTO, and keep the
+; calls to comdat from the non-LTO objects.
 ; RUN: lld-link /out:%T/comdat-main.exe /entry:main /subsystem:console %T/comdat-main.lto.obj %T/comdat1.obj %T/comdat2.obj
 ; RUN: llvm-readobj -file-headers %T/comdat-main.exe | FileCheck -check-prefix=HEADERS-10 %s
 ; RUN: llvm-objdump -d %T/comdat-main.exe | FileCheck -check-prefix=TEXT-10 %s
 ; RUN: lld-link /out:%T/comdat-main.exe /entry:main /subsystem:console %T/comdat-main.lto.obj %T/comdat.lib
 ; RUN: llvm-readobj -file-headers %T/comdat-main.exe | FileCheck -check-prefix=HEADERS-10 %s
 ; RUN: llvm-objdump -d %T/comdat-main.exe | FileCheck -check-prefix=TEXT-10 %s
 
 ; HEADERS-11: AddressOfEntryPoint: 0x1000
 ; TEXT-11: Disassembly of section .text:
 ; TEXT-11-NEXT: .text:
 ; TEXT-11-NEXT: xorl  %eax, %eax
 ; TEXT-11-NEXT: retq
 
 ; HEADERS-01: AddressOfEntryPoint: 0x2000
 ; TEXT-01: Disassembly of section .text:
 ; TEXT-01-NEXT: .text:
 ; TEXT-01-NEXT: subq  $40, %rsp
 ; TEXT-01-NEXT: callq 39
 ; TEXT-01-NEXT: callq 50
 ; TEXT-01-NEXT: callq 13
 ; TEXT-01-NEXT: xorl  %eax, %eax
 ; TEXT-01-NEXT: addq  $40, %rsp
-; TEXT-01-NEXT: retq
-; TEXT-01-NEXT: int3
-; TEXT-01-NEXT: int3
-; TEXT-01-NEXT: int3
-; TEXT-01-NEXT: int3
-; TEXT-01-NEXT: int3
-; TEXT-01-NEXT: int3
-; TEXT-01-NEXT: retq
-; TEXT-01-NEXT: int3
-; TEXT-01-NEXT: int3
-; TEXT-01-NEXT: int3
-; TEXT-01-NEXT: int3
-; TEXT-01-NEXT: int3
-; TEXT-01-NEXT: int3
-; TEXT-01-NEXT: int3
-; TEXT-01-NEXT: int3
-; TEXT-01-NEXT: int3
-; TEXT-01-NEXT: int3
-; TEXT-01-NEXT: int3
-; TEXT-01-NEXT: int3
-; TEXT-01-NEXT: int3
-; TEXT-01-NEXT: int3
-; TEXT-01-NEXT: int3
-; TEXT-01-NEXT: retq
-; TEXT-01-NEXT: nopw  %cs:(%rax,%rax)
-; TEXT-01-NEXT: retq
+; TEXT-01: retq
+; TEXT-01-NOT: callq
+; TEXT-01: retq
+; TEXT-01-NOT: callq
+; TEXT-01: retq
+; TEXT-01-NOT: callq
+; TEXT-01: retq
+; TEXT-01-NOT: {{.}}
 
-; HEADERS-10: AddressOfEntryPoint: 0x2030
+; HEADERS-10: AddressOfEntryPoint: 0x2020
 ; TEXT-10: Disassembly of section .text:
 ; TEXT-10-NEXT: .text:
 ; TEXT-10-NEXT: subq  $40, %rsp
-; TEXT-10-NEXT: callq 7
+; TEXT-10-NEXT: callq 55
 ; TEXT-10-NEXT: nop
 ; TEXT-10-NEXT: addq  $40, %rsp
 ; TEXT-10-NEXT: retq
 ; TEXT-10-NEXT: int3
-; TEXT-10-NEXT: retq
-; TEXT-10-NEXT: int3
-; TEXT-10-NEXT: int3
-; TEXT-10-NEXT: int3
-; TEXT-10-NEXT: int3
-; TEXT-10-NEXT: int3
-; TEXT-10-NEXT: int3
-; TEXT-10-NEXT: int3
-; TEXT-10-NEXT: int3
-; TEXT-10-NEXT: int3
-; TEXT-10-NEXT: int3
-; TEXT-10-NEXT: int3
-; TEXT-10-NEXT: int3
-; TEXT-10-NEXT: int3
-; TEXT-10-NEXT: int3
-; TEXT-10-NEXT: int3
 ; TEXT-10-NEXT: subq  $40, %rsp
-; TEXT-10-NEXT: callq -25
+; TEXT-10-NEXT: callq 39
 ; TEXT-10-NEXT: nop
 ; TEXT-10-NEXT: addq  $40, %rsp
 ; TEXT-10-NEXT: retq
 ; TEXT-10-NEXT: int3
 ; TEXT-10-NEXT: subq  $40, %rsp
-; TEXT-10-NEXT: callq -57
+; TEXT-10-NEXT: callq -41
 ; TEXT-10-NEXT: callq -30
 ; TEXT-10-NEXT: xorl  %eax, %eax
 ; TEXT-10-NEXT: addq  $40, %rsp
 ; TEXT-10-NEXT: retq
+; TEXT-10-NOT: callq
+; TEXT-10: retq
+; TEXT-10-NOT: {{.}}
 
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc"
 
 $comdat = comdat any
 
 define i32 @main() {
   call void @f1()

lld/trunk/test/COFF/lto-parallel.ll

 ; RUN: llvm-as -o %t.obj %s
-; RUN: lld-link /out:%t.exe /entry:foo /include:bar /opt:lldltojobs=2 /subsystem:console /lldmap:%t.map %t.obj
+; RUN: lld-link /out:%t.exe /entry:foo /include:bar /opt:lldltopartitions=2 /subsystem:console /lldmap:%t.map %t.obj
 ; RUN: FileCheck %s < %t.map
 
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc"
 
-; CHECK: <lto object>
+; CHECK: lto.tmp
 ; CHECK-NEXT: foo
 define void @foo() {
   call void @bar()
   ret void
 }
 
-; CHECK: <lto object>
-; CHECK-NEXT: bar
+; CHECK: lto.tmp
+; CHECK: bar
 define void @bar() {
   call void @foo()
   ret void
 }

lld/trunk/test/COFF/weak-external.test

 # RUN: yaml2obj %s > %t.obj
 # RUN: llvm-as -o %t.lto.obj %S/Inputs/weak-external.ll
 # RUN: lld-link /out:%t1.exe /entry:g /subsystem:console %t.obj
 # RUN: lld-link /out:%t2.exe /entry:g /subsystem:console /lldmap:%t2.map %t.obj %t.lto.obj
 # RUN: FileCheck %s < %t2.map
 
-# CHECK: <lto object>
+# CHECK: lto.tmp
 # CHECK-NEXT: 0 g
 
 --- !COFF
 header:
   Machine:         IMAGE_FILE_MACHINE_AMD64
   Characteristics: [  ]
 sections:
   - Name:            '.text'

lld/trunk/test/COFF/weak-external3.test

 # RUN: yaml2obj %s > %t.obj
 # RUN: llvm-as -o %t.lto.obj %S/Inputs/weak-external3.ll
 # RUN: lld-link /out:%t1.exe /entry:f /subsystem:console /lldmap:%t1.map %t.lto.obj
 # RUN: FileCheck --check-prefix=CHECK1 %s < %t1.map
 # RUN: lld-link /out:%t2.exe /entry:f /subsystem:console /lldmap:%t2.map %t.obj %t.lto.obj
 # RUN: FileCheck --check-prefix=CHECK2 %s < %t2.map
 
-# CHECK1: <lto object>
+# CHECK1: lto.tmp
 # CHECK1-NEXT: 0 g
 
 # CHECK2: weak-external3.test.tmp.obj
 # CHECK2-NEXT: 0 f
 
 --- !COFF
 header:
   Machine:         IMAGE_FILE_MACHINE_AMD64