[LLD][COFF] Generate import modules in PDB

[aganea]

Summary

This patch makes LLD generate a PDB with import modules & coff groups.
This is suitable for hot patching tools like Recode and Live++, which need to extract this information from the PDB. We're using this patch on several productions for a few months now.

---

We generate one debug symbol stream for each imported dll:

                          Streams
============================================================
[...]
  Stream 10 ( 256 bytes): [Module "Import:pdb-publics-import.test.tmp1.dll"]
             Blocks: [9]

We generate two modules for each imported dll:
(currently the first module is empty because llvm-lib does not generate the additional symbol stream, and some descriptors are not imported (remains TODO)

                        Module Stats
============================================================
[...]
Mod 0001 | `pdb-publics-import.test.tmp1.dll`:
  Mod 1 (debug info not present): [pdb-publics-import.test.tmp1.dll]
Mod 0002 | `Import:pdb-publics-import.test.tmp1.dll`:
  Stream 10, 256 bytes

    Symbols
                                       Total:       8 entries (     248 bytes)
    --------------------------------------------------------------------------
                                   S_THUNK32:       2 entries (      72 bytes)
                                       S_END:       2 entries (       8 bytes)
                                   S_OBJNAME:       2 entries (      88 bytes)
                                  S_COMPILE3:       2 entries (      80 bytes)

    Chunks
                                       Total:       0 entries (       0 bytes)
    --------------------------------------------------------------------------

We ensure the modules' first contrib section is properly set (65535 values):

                          Modules
============================================================
[...]
Mod 0001 | `pdb-publics-import.test.tmp1.dll`:
SC[???]  | mod = 65535, 65535:0000, size = -1, data crc = 0, reloc crc = 0
        none
Obj: `F:\svn\build2\tools\lld\test\COFF\Output\pdb-publics-import.test.tmp1.lib`:
debug stream: 65535, # files: 0, has ec info: false
pdb file ni: 0 ``, src file ni: 0 ``
Mod 0002 | `Import:pdb-publics-import.test.tmp1.dll`:
SC[.text]  | mod = 2, 0001:0032, size = 6, data crc = 0, reloc crc = 0
        IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ
Obj: `F:\svn\build2\tools\lld\test\COFF\Output\pdb-publics-import.test.tmp1.lib`:
debug stream: 10, # files: 0, has ec info: false
pdb file ni: 0 ``, src file ni: 0 ``

We generate proper symbol streams for each import module, in the same way as link.exe:

                          Symbols
============================================================
[...]
Mod 0002 | `Import:pdb-publics-import.test.tmp1.dll`:
     4 | S_OBJNAME [size = 44] sig=0, `pdb-publics-import.test.tmp1.dll`
    48 | S_COMPILE3 [size = 40]
         machine = intel x86-x64, Ver = LLVM Linker, language = link
         frontend = 0.0.0.0, backend = 14.10.25019.0
         flags = none
    88 | S_THUNK32 [size = 36] `exportfn1`
         parent = 0, end = 124, next = 0
         kind = thunk, size = 6, addr = 0001:0016
   124 | S_END [size = 4]
   128 | S_OBJNAME [size = 44] sig=0, `pdb-publics-import.test.tmp1.dll`
   172 | S_COMPILE3 [size = 40]
         machine = intel x86-x64, Ver = LLVM Linker, language = link
         frontend = 0.0.0.0, backend = 14.10.25019.0
         flags = none
   212 | S_THUNK32 [size = 36] `exportfn2`
         parent = 0, end = 248, next = 0
         kind = thunk, size = 6, addr = 0001:0032
   248 | S_END [size = 4]

And we also generate COFF groups in the * Linker * section, out from PartialSections (that is, unmerged sections).
(there's a subtly here: the .idata$XXX COFF groups have the "write" flag set, whereas the corresponding .idata section does not have it - this is what link.exe does)

Mod 0003 | `* Linker *`:
[...]
   588 | S_SECTION [size = 28] `.text`
         length = 38, alignment = 12, rva = 4096, section # = 1
         characteristics =
           code
           execute permissions
           read permissions
   616 | S_COFFGROUP [size = 24] `.text`
         length = 8, addr = 0001:0000
         characteristics =
           code
           execute permissions
           read permissions
   640 | S_SECTION [size = 28] `.rdata`
         length = 61, alignment = 12, rva = 8192, section # = 2
         characteristics =
           initialized data
           read permissions
   668 | S_SECTION [size = 28] `.idata`
         length = 145, alignment = 12, rva = 12288, section # = 3
         characteristics =
           initialized data
           read permissions
   696 | S_COFFGROUP [size = 28] `.idata$2`
         length = 40, addr = 0003:0000
         characteristics =
           initialized data
           read permissions
           write permissions
   724 | S_COFFGROUP [size = 28] `.idata$4`
         length = 24, addr = 0003:0040
         characteristics =
           initialized data
           read permissions
           write permissions
   752 | S_COFFGROUP [size = 28] `.idata$5`
         length = 24, addr = 0003:0064
         characteristics =
           initialized data
           read permissions
           write permissions
   780 | S_COFFGROUP [size = 28] `.idata$6`
         length = 24, addr = 0003:0088
         characteristics =
           initialized data
           read permissions
           write permissions
   808 | S_COFFGROUP [size = 28] `.idata$7`
         length = 33, addr = 0003:0112
         characteristics =
           initialized data
           read permissions
           write permissions

[aganea]

Please note this work was started from Stefan Reinalter's D49230 and D49231. We agreed offline with Stefan that I will finish those patches.

[aganea]

The file below shows the remaining differences betwen link and lld-link (with this patch). I've modified lld\test\COFF\Output\pdb-publics-import.test to use link.exe instead of lld-link.exe

pdb-publics-import-compare.zip16 KBDownload

[zturner]

Do you happen to know what these are used for? I'm ok with supporting them just for the sake of compatibility, but it's always nice to know "if these aren't present, X won't work"

[aganea]

In D54802#1305448, @zturner wrote:

Do you happen to know what these are used for? I'm ok with supporting them just for the sake of compatibility, but it's always nice to know "if these aren't present, X won't work"

Some edit-and-continue tools rely on this: Recode and Live++. These tools need to extract and repro the linking with the EXE/PDB alone. They need this information for recompiling TUs that change, and hot patch the process in memory.

[aganea]

This all boils down to iterativity. Using the tools I've mentionned above allows for really quick iterations, when you need to change small bits of code. When you're iterating over some gameplay or UI code, for example.
Without these tools, for testing any small change, you need to: compile the TU, link the whole EXE, start it, load the game map, and do a walkthrough until you're at the right position in the game world. This can take more than 10 minutes.
With these edit-and-continue tools, you don't shut down the game. The player remains at the same position in the game. You simply change the code, the tool applies the changes, and that's it. You can go for hundreds of iterations like this. Live++ even allows the game to save/reload data structures, which means that you can change pretty much anything in the code, including class definitions.

[rnk]

Cool. :)

lld/trunk/COFF/Driver.cpp

1226

Do you want to submit this separately? It seems to cause wide ranging mechanical changes to the tests. Feel free to submit it without review.

lld/trunk/COFF/Writer.cpp

758–760

This seems like it's really just replicating Map into some longer lived data structure, and then creating a backreference from the output section to the concatenated input section. There are three other helper functions that take a reference to Map, and that type is ridiculously long. I think we could clean this code up significantly if we planned some NFC changes first to make Map a member of Writer and then give it a real key and value type. WDYT? I'm imagining that the type would become: std::map<NameAndChars, InputSection>

That would have the side effect of cleaning up a lot of unreadable Pair.second and Pair.first.first accesses in this code.

Honestly I started looking at this at first just because we copy the Chunks vector again, and I was wondering if that could be avoided, especially for a no-PDB build...

[pcc]

lld/trunk/COFF/Driver.cpp

1226

Are you sure that this is what link.exe does? I'm pretty sure I added this here after noticing that this was what link.exe did, see D45737

[aganea]

After further testing, in some scenarios this patch doesn't seem to be enough for Recode to work. I'll pause this patch and follow up with Will (@lantictac) to ensure everything is covered.

lld/trunk/COFF/Driver.cpp

1226

import-tests.zip46 KBDownload

@pcc: Please see the zip file above for comparing the output from different linkers.

I figured out a few more things with link.exe along the way:

• S_TRAMPOLINE records are used for jump thunks when incremental linking is active. Of course this makes the produced EXE to execute slower because there are missed function inlining oportunities.
• The * Linker * module has a section contribution in .idata only when incremental linking is specified. Otherwise, there's no contrib section, only a debug stream.
• There's a lot more .text padding (CCCCCC) around functions when incremental linking is active.
• More importantly, link.exe folds .idata sections into .rdata only when /INCREMENTAL:NO is specified. Given that /INCREMENTAL is the default, I thought we should do the same in LLD. I would need to disable that behavior when providing /INCREMENTAL:NO (not in this patch yet).

Doc and defaults for /INCREMENTAL are here.

lld/trunk/COFF/Writer.cpp

758–760

Agreed. Will do that.

[aganea]

Actually, the question about folding .idata into .rdata remains open. Should we follow the same behavior as link.exe or not, to reduce variability in the output?

[rnk]

In D54802#1309701, @aganea wrote:

Actually, the question about folding .idata into .rdata remains open. Should we follow the same behavior as link.exe or not, to reduce variability in the output?

I don't think we intend to support incremental linking, so I'd just fold idata into rdata by default as we do now.

[aganea]

In D54802#1309791, @rnk wrote:

I don't think we intend to support incremental linking, so I'd just fold idata into rdata by default as we do now.

I'd say incremental linking is the only major hurdle for widespread LLD adoption on industrial sites. Like we discussed at the LLVM conf., I agree that EXEs/DLLs shouldn't be incrementally linked. But what about incremental PDB generation?

For our typical gameplay developement loop, for a DLL target, this is what we currently see:

  Input File Reading:          1847 ms (  3.7%)
  Code Layout:                  579 ms (  1.2%)
  PDB Emission (Cumulative):  43468 ms ( 87.8%)
    Add Objects:              33074 ms ( 66.8%)
      Type Merging:           28276 ms ( 57.1%)
      Symbol Merging:          4748 ms (  9.6%)
    TPI Stream Layout:         1487 ms (  3.0%)
    Globals Stream Layout:     1789 ms (  3.6%)
    Commit to Disk:            5981 ms ( 12.1%)
  Commit Output File:          2837 ms (  5.7%)
-------------------------------------------------
Total Link Time:              49494 ms (100.0%)

That is for the biggest DLL in the game, and inherently the one that programmers iterate the most on:

-- DLL: 182 MB
-- PDB: 930 MB
-- Merged OBJs: 179 (no GHASH, OBJs are from cl.exe; these are unity/blob .cpp files)
-- Inserted type records: 91,573,186
-- Final unique type records: 3,578,658 (hash table size: 8,388,608)
-- TypeTable.RecordStorage: 1,639,715,884 bytes allocated

For the same thing, link.exe /INCREMENTAL takes about 3 sec to relink any change. If we could at least do the Type/Symbol passes incrementally, that would be a major win.

[aganea]

Sorry that was the wrong timings - that was for MSVC-built LLD. With Clang 7.0 things are a bit better in reality:

  Input File Reading:          1658 ms (  4.7%)
  Code Layout:                  621 ms (  1.8%)
  PDB Emission (Cumulative):  30380 ms ( 86.7%)
    Add Objects:              22615 ms ( 64.6%)
      Type Merging:           19205 ms ( 54.8%)
      Symbol Merging:          3385 ms (  9.7%)
    TPI Stream Layout:          897 ms (  2.6%)
    Globals Stream Layout:     1418 ms (  4.1%)
    Commit to Disk:            4559 ms ( 13.0%)
  Commit Output File:          1717 ms (  4.9%)
-------------------------------------------------
Total Link Time:              35021 ms (100.0%)

I noticed by the way that the default cmake config for Clang/LLVM/LLD comes with /INCREMENTAL and /MD (dll CRT) active. This causes a lot of thunking. I changed that to /INCREMENTAL:NO and /MT and things are a lot better - I'll send another review for that.

[rnk]

In D54802#1311401, @aganea wrote:

  Input File Reading:          1658 ms (  4.7%)
  Code Layout:                  621 ms (  1.8%)
  PDB Emission (Cumulative):  30380 ms ( 86.7%)
    Add Objects:              22615 ms ( 64.6%)
      Type Merging:           19205 ms ( 54.8%)
      Symbol Merging:          3385 ms (  9.7%)
    TPI Stream Layout:          897 ms (  2.6%)
    Globals Stream Layout:     1418 ms (  4.1%)
    Commit to Disk:            4559 ms ( 13.0%)
  Commit Output File:          1717 ms (  4.9%)
-------------------------------------------------
Total Link Time:              35021 ms (100.0%)

I think we can optimize copying symbols using the same techniques we've used for optimizing LLD. Symbol records are pretty straightforward: You figure out which .debug$S sections are live, relocate them, process them a bit, and copy the bytes to the PDB in some order. In D54554 I did some work, and that cuts down the "Commit Output File" (13%) and "Symbol Merging" times, but there may be more things to do.

For types, I think this is one of the classic problems where you make a hash table and say "it's O(1) insertion" but really it's order "length of key", and probably with a high constant factor. I think if we looked at the distribution of type record sizes, we'd see a few categories like this:

1. Small records, < 20bytes, i.e. less than a SHA-1, like pointer types, qualified (const/volatile) types, array types, function types, etc. Merging theses in the linker should be cheap, ghash or no ghash.
2. Records with names, like LF_STRUCTURE and LF_PROC_ID. C++ mangled names can get long, but they probably aren't 64K, the max CV record length, bytes long. Think ~4KB.
3. Long field lists. LF_FIELDLIST is a bear. I expect on average most field lists are 32KB plus, since they include the name of every field, method, and typedef. Templates tend to have lots of members, many of which are unused in most instantiations.

The other thing to keep in mind is that type hash table "hits" are common. Most types are duplicates. Given some 64KB field list record, you can expect it will be deduplicated O(#objects) times. Without the content hash, this means you have to memcmp the entire 64KB for every duplicate. With the hash, you do O(length of hash) work, so a 8 or 20 byte memcmp. I think that's where the real ghash gains are coming from. I'm not sure what to do with that information, but it seems like a useful insight.

One thing we talked about a while ago was trying to parallelize type merging. I think the challenge there is it requires a good concurrent hash map implementation, which we'd have to find or implement ourselves.

[thakis]

lld/trunk/COFF/PDB.cpp

1533

This regresses PDBs being independent of the build directory, cf r344061

[aganea]

In D54802#1311943, @rnk wrote:

I think the challenge there is it requires a good concurrent hash map implementation, which we'd have to find or implement ourselves.

I can provide that, we have a good lockless, insert-only, DenseHash implemention that we have been using for many years.

Although the issue at stake here is the high memory bandwith, due to the large volume of data to process in a tight loop. Like you are pointing out, GHash uses a smaller key size (8 bytes) which packs more entries per cache line (instead of the {hash, ArrayRef<U8>} key (24 bytes) when GHash isn’t used). I’m not entierely sure multithreading will help a lot, but we can give it a try. Packing more tightly the data in the DenseHash, and avoiding indirections at all cost would probably benefit more in the short term.

lld/trunk/COFF/PDB.cpp

1533

Thanks for pointing out!

[mstorsjo]

lld/trunk/test/COFF/hello32.test

60

I didn't read the whole patch in detail, but can you give a TL;DR about what's added to the output files in the case when no PDB output is enabled, that shuffles some sections forward now?

[aganea]

I still need to work on this patch. I'll mark it as pending in the meanwhile.

lld/trunk/test/COFF/hello32.test

60

Please see lld/trunk/COFF/Driver.cpp, L1226, I initially removed parseMerge(".idata=.rdata");

And the comment above:
"More importantly, link.exe folds .idata sections into .rdata only when /INCREMENTAL:NO is specified. Given that /INCREMENTAL is the default, I thought we should do the same in LLD. I would need to disable that behavior when providing /INCREMENTAL:NO (not in this patch yet)."

However, it was decided that we'll keep the current .idata merging behavior for now.

[mstorsjo]

lld/trunk/test/COFF/hello32.test

60

Ok, I see. Thanks!

[aganea]

Simplify & addressed comments.

I took the liberty to remove COFF groups from the MinGW target. This was adding a significant footprint to the PDB, given that each function is in its own .text section.
As an additionnal side-effect, MinGW PDBs are now much smaller, because we don't emit empty debug streams anymore.

As an example, using Martin's test package, I generated libqt_plugin.pdb:

trunk			21 MB
	coff groups	import modules	27.1 MB
(this patch)	no coff groups	import modules	13.5 MB
	no coff groups	no import modules	13.3 MB

The impact is less significat in non-MinGW, on a 1 GB PDB this patch adds 2 MB and scales with the size (actually depends on the number of imported libraries).

[rnk]

lld/trunk/COFF/PDB.cpp

1126

Is this relevant to this change?

1524

DllModSet, maybe? DllToModuleDbi?

1542–1544

Usually we use Twine to avoid the cost of concatenating strings used for debugging purposes, like names for instructions that aren't used in release mode, or log statements. In this case, I think you can use plain old std::string, something like addModuleInfo(std::string("Import:") + File->DLLName. With that simplification, I think the lambda is unnecessary.

llvm/trunk/lib/DebugInfo/PDB/Native/ModuleDebugStream.cpp

6–16

I don't see the change to add this method to the class in this patch. Was this change intended to be part of this review? It seems unnecessary for import files.

[aganea]

lld/trunk/COFF/PDB.cpp

1126

Yes, I think we can remove that comment now, unless @zturner says otherwise.

llvm/trunk/lib/DebugInfo/PDB/Native/ModuleDebugStream.cpp

6–16

I indeed forgot an include file from the diff. But you're right, this is for supporting empty streams, I should maybe do that in another patch.

[aganea]

Rebased, reduced & adressed comments.

[santagada]

Anything missing for this to be accepted? It seems like this patch is ready.

[rnk]

lgtm, thanks!

In D54802#1440864, @santagada wrote:

Anything missing for this to be accepted? It seems like this patch is ready.

I just missed the update, sorry.

COFF/Writer.cpp

307 ↗

(On Diff #191490)

Needs wrapping

lld/trunk/COFF/Driver.cpp

else
       Driver->addBuffer(std::move(MBOrErr.first), WholeArchive);
   });
 }
 
 void LinkerDriver::addArchiveBuffer(MemoryBufferRef MB, StringRef SymName,
                                     StringRef ParentName) {
   file_magic Magic = identify_magic(MB.getBuffer());
   if (Magic == file_magic::coff_import_library) {
-    Symtab->addFile(make<ImportFile>(MB));
+    InputFile *Imp = make<ImportFile>(MB);
+    Imp->ParentName = ParentName;
+    Symtab->addFile(Imp);
     return;
   }
 
   InputFile *Obj;
   if (Magic == file_magic::coff_object) {
     Obj = make<ObjFile>(MB);
   } else if (Magic == file_magic::bitcode) {
     Obj = make<BitcodeFile>(MB);
for (auto *Arg : Args.filtered(OPT_failifmismatch))
     checkFailIfMismatch(Arg->getValue());
 
   // Handle /merge
   for (auto *Arg : Args.filtered(OPT_merge))
     parseMerge(Arg->getValue());
 
   // Add default section merging rules after user rules. User rules take
   // precedence, but we will emit a warning if there is a conflict.
-  parseMerge(".idata=.rdata");
   parseMerge(".didat=.rdata");
   parseMerge(".edata=.rdata");
   parseMerge(".xdata=.rdata");
   parseMerge(".bss=.data");
 
   if (Config->MinGW) {
     parseMerge(".ctors=.rdata");
     parseMerge(".dtors=.rdata");

lld/trunk/COFF/InputFiles.cpp

 
 // Returns a string in the format of "foo.obj" or "foo.obj(bar.lib)".
 std::string lld::toString(const coff::InputFile *File) {
   if (!File)
     return "<internal>";
   if (File->ParentName.empty())
     return File->getName();
 
+  if (File->kind() == coff::InputFile::ImportKind)
+    return File->getName();
+
   return (getBasename(File->ParentName) + "(" + getBasename(File->getName()) +
           ")")
       .str();
 }

lld/trunk/COFF/PDB.cpp

public:
   void initialize(llvm::codeview::DebugInfo *BuildId);
 
   /// Add natvis files specified on the command line.
   void addNatvisFiles();
 
   /// Link CodeView from each object file in the symbol table into the PDB.
   void addObjectsToPDB();
 
+  /// Link info for each import file in the symbol table into the PDB.
+  void addImportFilesToPDB(ArrayRef<OutputSection *> OutputSections);
+
   /// Link CodeView from a single object file into the target (output) PDB.
   /// When a precompiled headers object is linked, its TPI map might be provided
   /// externally.
   void addObjFile(ObjFile *File, CVIndexMap *ExternIndexMap = nullptr);
 
   /// Produce a mapping from the type and item indices used in the object
   /// file to those in the destination PDB.
   ///
if (Config->DebugGHashes) {
     // as inputs.
     auto TpiHashes = GloballyHashedType::hashTypes(ExpectedTpi->typeArray());
     auto IpiHashes =
         GloballyHashedType::hashIds(ExpectedIpi->typeArray(), TpiHashes);
 
     Optional<EndPrecompRecord> EndPrecomp;
     // Merge TPI first, because the IPI stream will reference type indices.
     if (auto Err = mergeTypeRecords(GlobalTypeTable, IndexMap.TPIMap,
-                                    ExpectedTpi->typeArray(), TpiHashes, EndPrecomp))
       fatal("codeview::mergeTypeRecords failed: " + toString(std::move(Err)));
 
     // Merge IPI.
     if (auto Err =
             mergeIdRecords(GlobalIDTable, IndexMap.TPIMap, IndexMap.IPIMap,
                            ExpectedIpi->typeArray(), IpiHashes))
       fatal("codeview::mergeIdRecords failed: " + toString(std::move(Err)));
   } else {
static void scopeStackOpen(SmallVectorImpl<SymbolScope> &Stack,
   S.ScopeOffset = CurOffset;
   S.OpeningRecord = const_cast<ScopeRecord *>(
       reinterpret_cast<const ScopeRecord *>(Sym.content().data()));
   S.OpeningRecord->PtrParent = Stack.empty() ? 0 : Stack.back().ScopeOffset;
   Stack.push_back(S);
 }
 
 static void scopeStackClose(SmallVectorImpl<SymbolScope> &Stack,
-                            uint32_t CurOffset, ObjFile *File) {
+                            uint32_t CurOffset, InputFile *File) {
   if (Stack.empty()) {
     warn("symbol scopes are not balanced in " + File->getName());
     return;
   }
   SymbolScope S = Stack.pop_back_val();
   S.OpeningRecord->PtrEnd = CurOffset;
 }
 
static ArrayRef<uint8_t> relocateDebugChunk(BumpPtrAllocator &Alloc,
   assert(DebugChunk.OutputSectionOff == 0 &&
          "debug sections should not be in output sections");
   DebugChunk.readRelocTargets();
   DebugChunk.writeTo(Buffer);
   return makeArrayRef(Buffer, DebugChunk.getSize());
 }
 
 static pdb::SectionContrib createSectionContrib(const Chunk *C, uint32_t Modi) {
-  OutputSection *OS = C->getOutputSection();
+  OutputSection *OS = C ? C->getOutputSection() : nullptr;
   pdb::SectionContrib SC;
   memset(&SC, 0, sizeof(SC));
-  SC.ISect = OS->SectionIndex;
-  SC.Off = C->getRVA() - OS->getRVA();
-  SC.Size = C->getSize();
-  if (auto *SecChunk = dyn_cast<SectionChunk>(C)) {
+  SC.ISect = OS ? OS->SectionIndex : llvm::pdb::kInvalidStreamIndex;
+  SC.Off = C && OS ? C->getRVA() - OS->getRVA() : 0;
+  SC.Size = C ? C->getSize() : -1;
+  if (auto *SecChunk = dyn_cast_or_null<SectionChunk>(C)) {
     SC.Characteristics = SecChunk->Header->Characteristics;
     SC.Imod = SecChunk->File->ModuleDBI->getModuleIndex();
     ArrayRef<uint8_t> Contents = SecChunk->getContents();
     JamCRC CRC(0);
     ArrayRef<char> CharContents = makeArrayRef(
         reinterpret_cast<const char *>(Contents.data()), Contents.size());
     CRC.update(CharContents);
     SC.DataCrc = CRC.getCRC();
   } else {
-    SC.Characteristics = OS->Header.Characteristics;
+    SC.Characteristics = OS ? OS->Header.Characteristics : 0;
     // FIXME: When we start creating DBI for import libraries, use those here.
     SC.Imod = Modi;
   }
   SC.RelocCrc = 0; // FIXME
 
   return SC;
 }
 
 static uint32_t
case COFF::IMAGE_FILE_MACHINE_ARMNT:
     return codeview::CPUType::ARMNT;
   case COFF::IMAGE_FILE_MACHINE_I386:
     return codeview::CPUType::Intel80386;
   default:
     llvm_unreachable("Unsupported CPU Type");
   }
 }
 
-static void addCommonLinkerModuleSymbols(StringRef Path,
-                                         pdb::DbiModuleDescriptorBuilder &Mod,
-                                         BumpPtrAllocator &Allocator) {
-  ObjNameSym ONS(SymbolRecordKind::ObjNameSym);
-  Compile3Sym CS(SymbolRecordKind::Compile3Sym);
-  EnvBlockSym EBS(SymbolRecordKind::EnvBlockSym);
-
-  ONS.Name = "* Linker *";
-  ONS.Signature = 0;
-
+static void fillLinkerVerRecord(Compile3Sym &CS) {
   CS.Machine = toCodeViewMachine(Config->Machine);
   // Interestingly, if we set the string to 0.0.0.0, then when trying to view
   // local variables WinDbg emits an error that private symbols are not present.
   // By setting this to a valid MSVC linker version string, local variables are
   // displayed properly.   As such, even though it is not representative of
   // LLVM's version information, we need this for compatibility.
   CS.Flags = CompileSym3Flags::None;
   CS.VersionBackendBuild = 25019;
   CS.VersionBackendMajor = 14;
   CS.VersionBackendMinor = 10;
   CS.VersionBackendQFE = 0;
 
   // MSVC also sets the frontend to 0.0.0.0 since this is specifically for the
   // linker module (which is by definition a backend), so we don't need to do
   // anything here.  Also, it seems we can use "LLVM Linker" for the linker name
   // without any problems.  Only the backend version has to be hardcoded to a
   // magic number.
   CS.VersionFrontendBuild = 0;
   CS.VersionFrontendMajor = 0;
   CS.VersionFrontendMinor = 0;
   CS.VersionFrontendQFE = 0;
   CS.Version = "LLVM Linker";
   CS.setLanguage(SourceLanguage::Link);
+}
+
+static void addCommonLinkerModuleSymbols(StringRef Path,
+                                         pdb::DbiModuleDescriptorBuilder &Mod,
+                                         BumpPtrAllocator &Allocator) {
+  ObjNameSym ONS(SymbolRecordKind::ObjNameSym);
+  EnvBlockSym EBS(SymbolRecordKind::EnvBlockSym);
+  Compile3Sym CS(SymbolRecordKind::Compile3Sym);
+  fillLinkerVerRecord(CS);
+
+  ONS.Name = "* Linker *";
+  ONS.Signature = 0;
 
   ArrayRef<StringRef> Args = makeArrayRef(Config->Argv).drop_front();
   std::string ArgStr = llvm::join(Args, " ");
   EBS.Fields.push_back("cwd");
   SmallString<64> cwd;
-  if (Config->PDBSourcePath.empty()) 
+  if (Config->PDBSourcePath.empty())
     sys::fs::current_path(cwd);
   else
     cwd = Config->PDBSourcePath;
   EBS.Fields.push_back(cwd);
   EBS.Fields.push_back("exe");
   SmallString<64> exe = Config->Argv[0];
   pdbMakeAbsolute(exe);
   EBS.Fields.push_back(exe);
   EBS.Fields.push_back("pdb");
   EBS.Fields.push_back(Path);
   EBS.Fields.push_back("cmd");
   EBS.Fields.push_back(ArgStr);
   Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
       ONS, Allocator, CodeViewContainer::Pdb));
   Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
       CS, Allocator, CodeViewContainer::Pdb));
   Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
       EBS, Allocator, CodeViewContainer::Pdb));
 }
 
+static void addLinkerModuleCoffGroup(InputSection *ISec,
+                                     pdb::DbiModuleDescriptorBuilder &Mod,
+                                     OutputSection &OS,
+                                     BumpPtrAllocator &Allocator) {
+  // If there's a section, there's at least one chunk
+  assert(!ISec->Chunks.empty());
+  const Chunk *firstChunk = *ISec->Chunks.begin();
+  const Chunk *lastChunk = *ISec->Chunks.rbegin();
+  
+  // Emit COFF group
+  CoffGroupSym CGS(SymbolRecordKind::CoffGroupSym);
+  CGS.Name = ISec->Name;
+  CGS.Segment = OS.SectionIndex;
+  CGS.Offset = firstChunk->getRVA() - OS.getRVA();
+  CGS.Size = lastChunk->getRVA() + lastChunk->getSize() - firstChunk->getRVA();
+  CGS.Characteristics = ISec->Characteristics;
+
+  // Somehow .idata sections & sections groups in the debug symbol stream have
+  // the "write" flag set. However the section header for the corresponding
+  // .idata section doesn't have it.
+  if (CGS.Name.startswith(".idata"))
+    CGS.Characteristics |= llvm::COFF::IMAGE_SCN_MEM_WRITE;
+
+  Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
+      CGS, Allocator, CodeViewContainer::Pdb));
+}
+
 static void addLinkerModuleSectionSymbol(pdb::DbiModuleDescriptorBuilder &Mod,
                                          OutputSection &OS,
                                          BumpPtrAllocator &Allocator) {
   SectionSym Sym(SymbolRecordKind::SectionSym);
   Sym.Alignment = 12; // 2^12 = 4KB
   Sym.Characteristics = OS.Header.Characteristics;
   Sym.Length = OS.getVirtualSize();
   Sym.Name = OS.Name;
   Sym.Rva = OS.getRVA();
   Sym.SectionNumber = OS.SectionIndex;
   Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
       Sym, Allocator, CodeViewContainer::Pdb));
+
+  // Output COFF groups for individual chunks of this section.
+  for (InputSection *ISec : OS.ContribSections) {
+    addLinkerModuleCoffGroup(ISec, Mod, OS, Allocator);
+  }
+}
+
+// Add all import files as modules to the PDB.
+void PDBLinker::addImportFilesToPDB(ArrayRef<OutputSection *> OutputSections) {
+  if (ImportFile::Instances.empty())
+    return;
+
+  std::map<std::string, llvm::pdb::DbiModuleDescriptorBuilder *> ModSet;
+
+  for (ImportFile *File : ImportFile::Instances) {
+    if (!File->Live)
+      continue;
+
+    if (!File->ThunkSym)
+      continue;
+
+    std::string DLL = StringRef(File->DLLName).lower();
+    auto &Mod = ModSet[DLL];
+    if (!Mod) {
+      pdb::DbiStreamBuilder &DbiBuilder = Builder.getDbiBuilder();
+      SmallString<128> LibPath = File->ParentName;
+      sys::fs::make_absolute(LibPath);
+      sys::path::native(LibPath);
+
+      auto CreateMod = [&](Twine S) -> llvm::pdb::DbiModuleDescriptorBuilder * {
+        SmallString<128> Name;
+        S.toVector(Name);
+        auto *M = &ExitOnErr(DbiBuilder.addModuleInfo(Name));
+        M->setObjFileName(LibPath);
+        return M;
+      };
+
+      // Name modules similar to MSVC's link.exe.
+      // The first module is the simple dll filename
+      // The second is the actual import module, where the import stream goes.
+      auto FirstMod = CreateMod(File->DLLName);
+      pdb::SectionContrib SC =
+          createSectionContrib(nullptr, llvm::pdb::kInvalidStreamIndex);
+      FirstMod->setFirstSectionContrib(SC);
+
+      Mod = CreateMod("Import:" + File->DLLName);
+    }
+
+    DefinedImportThunk *Thunk = cast<DefinedImportThunk>(File->ThunkSym);
+
+    ObjNameSym ONS(SymbolRecordKind::ObjNameSym);
+    Compile3Sym CS(SymbolRecordKind::Compile3Sym);
+    Thunk32Sym TS(SymbolRecordKind::Thunk32Sym);
+    ScopeEndSym ES(SymbolRecordKind::ScopeEndSym);
+
+    ONS.Name = File->DLLName;
+    ONS.Signature = 0;
+
+    fillLinkerVerRecord(CS);
+
+    TS.Name = Thunk->getName();
+    TS.Parent = 0;
+    TS.End = 0;
+    TS.Next = 0;
+    TS.Thunk = ThunkOrdinal::Standard;
+    TS.Length = Thunk->getChunk()->getSize();
+    TS.Segment = Thunk->getChunk()->getOutputSection()->SectionIndex;
+    TS.Offset = Thunk->getChunk()->OutputSectionOff;
+
+    Mod->addSymbol(codeview::SymbolSerializer::writeOneSymbol(
+        ONS, Alloc, CodeViewContainer::Pdb));
+    Mod->addSymbol(codeview::SymbolSerializer::writeOneSymbol(
+        CS, Alloc, CodeViewContainer::Pdb));
+
+    SmallVector<SymbolScope, 4> Scopes;
+    CVSymbol NewSym = codeview::SymbolSerializer::writeOneSymbol(
+        TS, Alloc, CodeViewContainer::Pdb);
+    scopeStackOpen(Scopes, Mod->getNextSymbolOffset(), NewSym);
+
+    Mod->addSymbol(NewSym);
+
+    NewSym = codeview::SymbolSerializer::writeOneSymbol(ES, Alloc,
+                                                        CodeViewContainer::Pdb);
+    scopeStackClose(Scopes, Mod->getNextSymbolOffset(), File);
+
+    Mod->addSymbol(NewSym);
+
+    pdb::SectionContrib SC =
+        createSectionContrib(Thunk->getChunk(), Mod->getModuleIndex());
+    Mod->setFirstSectionContrib(SC);
+  }
 }
 
 // Creates a PDB file.
 void coff::createPDB(SymbolTable *Symtab,
                      ArrayRef<OutputSection *> OutputSections,
                      ArrayRef<uint8_t> SectionTable,
                      llvm::codeview::DebugInfo *BuildId) {
   ScopedTimer T1(TotalPdbLinkTimer);
   PDBLinker PDB(Symtab);
 
   PDB.initialize(BuildId);
   PDB.addObjectsToPDB();
+  PDB.addImportFilesToPDB(OutputSections);
   PDB.addSections(OutputSections, SectionTable);
   PDB.addNatvisFiles();
 
   ScopedTimer T2(DiskCommitTimer);
   codeview::GUID Guid;
   PDB.commit(&Guid);
   memcpy(&BuildId->PDB70.Signature, &Guid, 16);
 }

lld/trunk/COFF/Writer.h

 #include <vector>
 
 namespace lld {
 namespace coff {
 static const int PageSize = 4096;
 
 void writeResult();
 
+class OutputSection;
+
+// InputSection represents all unmerged sections contributing to the output
+// file, including synthetic ones.
+class InputSection {
+public:
+  InputSection(llvm::StringRef N, uint32_t Chars, std::vector<Chunk *> &C,
+               OutputSection *O)
+      : Name(N), Characteristics(Chars), Chunks(C), TargetSection(O) {}
+
+  llvm::StringRef Name;
+  unsigned Characteristics;
+  std::vector<Chunk *> Chunks;
+
+  OutputSection *TargetSection;
+};
+
 // OutputSection represents a section in an output file. It's a
 // container of chunks. OutputSection and Chunk are 1:N relationship.
 // Chunks cannot belong to more than one OutputSections. The writer
 // creates multiple OutputSections and assign them unique,
 // non-overlapping file offsets and RVAs.
 class OutputSection {
 public:
   OutputSection(llvm::StringRef N, uint32_t Chars) : Name(N) {
     Header.Characteristics = Chars;
   }
   void addChunk(Chunk *C);
   void insertChunkAtStart(Chunk *C);
   void merge(OutputSection *Other);
-  void addPermissions(uint32_t C);
   void setPermissions(uint32_t C);
   uint64_t getRVA() { return Header.VirtualAddress; }
   uint64_t getFileOff() { return Header.PointerToRawData; }
   void writeHeaderTo(uint8_t *Buf);
+  void addContributingInputSec(InputSection *ISec);
 
   // Returns the size of this section in an executable memory image.
   // This may be smaller than the raw size (the raw size is multiple
   // of disk sector size, so there may be padding at end), or may be
   // larger (if that's the case, the loader reserves spaces after end
   // of raw data).
   uint64_t getVirtualSize() { return Header.VirtualSize; }
 
   // Returns the size of the section in the output file.
   uint64_t getRawSize() { return Header.SizeOfRawData; }
 
   // Set offset into the string table storing this section name.
   // Used only when the name is longer than 8 bytes.
   void setStringTableOff(uint32_t V) { StringTableOff = V; }
 
   // N.B. The section index is one based.
   uint32_t SectionIndex = 0;
 
   llvm::StringRef Name;
   llvm::object::coff_section Header = {};
 
   std::vector<Chunk *> Chunks;
   std::vector<Chunk *> OrigChunks;
 
+  std::vector<InputSection *> ContribSections;
+
 private:
   uint32_t StringTableOff = 0;
 };
 
-}
-}
+} // namespace coff
+} // namespace lld
 
 #endif

lld/trunk/COFF/Writer.cpp

private:
   OutputSection *findSection(StringRef Name);
   void addBaserels();
   void addBaserelBlocks(std::vector<Baserel> &V);
 
   uint32_t getSizeOfInitializedData();
   std::map<StringRef, std::vector<DefinedImportData *>> binImports();
 
   std::unique_ptr<FileOutputBuffer> &Buffer;
+  std::vector<InputSection *> InputSections;
   std::vector<OutputSection *> OutputSections;
   std::vector<char> Strtab;
   std::vector<llvm::object::coff_symbol16> OutputSymtab;
   IdataContents Idata;
   Chunk *ImportTableStart = nullptr;
   uint64_t ImportTableSize = 0;
   Chunk *IATStart = nullptr;
   uint64_t IATSize = 0;
void OutputSection::writeHeaderTo(uint8_t *Buf) {
   } else {
     assert(!Config->Debug || Name.size() <= COFF::NameSize ||
            (Hdr->Characteristics & IMAGE_SCN_MEM_DISCARDABLE) == 0);
     strncpy(Hdr->Name, Name.data(),
             std::min(Name.size(), (size_t)COFF::NameSize));
   }
 }
 
+void OutputSection::addContributingInputSec(InputSection *ISec) {
+  ContribSections.push_back(ISec);
+}
+
 } // namespace coff
 } // namespace lld
 
 // Check whether the target address S is in range from a relocation
 // of type RelType at address P.
 static bool isInRange(uint16_t RelType, uint64_t S, uint64_t P, int Margin) {
   assert(Config->Machine == ARMNT);
   int64_t Diff = AbsoluteDifference(S, P + 4) + Margin;
if (Name == ".CRT") {
 
       sortCRTSectionChunks(Pair.second);
     }
 
     OutputSection *Sec = CreateSection(Name, OutChars);
     std::vector<Chunk *> &Chunks = Pair.second;
     for (Chunk *C : Chunks)
       Sec->addChunk(C);
+
+    InputSection *ISec =
+        make<InputSection>(Pair.first.first, OutChars, Chunks, Sec);
+    InputSections.push_back(ISec);
+    Sec->addContributingInputSec(ISec);
   }
 
   // Finally, move some output sections to the end.
   auto SectionOrder = [&](OutputSection *S) {
     // Move DISCARDABLE (or non-memory-mapped) sections to the end of file because
     // the loader cannot handle holes. Stripping can remove other discardable ones
     // than .reloc, which is first of them (created early).
     if (S->Header.Characteristics & IMAGE_SCN_MEM_DISCARDABLE)

lld/trunk/test/COFF/arm64-relocs-imports.test

 # AFTER:  14000107c:      09 00 00 00     udf #9
 # AFTER:  140001080:      00 20 0e 91     add     x0, x0, #904
 # AFTER:  140001084:      00 04 40 91     add     x0, x0, #1, lsl #12
 # AFTER:  140001088:      00 c4 41 f9     ldr     x0, [x0, #904]
 # AFTER:  14000108c:      03 00 00 00     udf #3
 # AFTER:  140001090:      e0 95 09 30     adr     x0, #78525
 # AFTER:  140001094:      41 00 00 54     b.ne    #8
 # AFTER:  140001098:      20 00 00 36     tbz     w0, #0, #4
-# AFTER:  14000109c:      10 00 00 b0     adrp    x16, #4096
-# AFTER:  1400010a0:      10 2a 40 f9     ldr     x16, [x16, #80]
+# AFTER:  14000109c:      10 00 00 d0     adrp    x16, #8192
+# AFTER:  1400010a0:      10 1e 40 f9     ldr     x16, [x16, #56]
 # AFTER:  1400010a4:      00 02 1f d6     br      x16
 
 --- !COFF
 header:
   Machine:         IMAGE_FILE_MACHINE_ARM64
   Characteristics: [  ]
 sections:
   - Name:            .text

lld/trunk/test/COFF/autoimport-arm-data.s

 # REQUIRES: arm
 
 # RUN: echo -e ".global variable\n.global DllMainCRTStartup\n.thumb\n.text\nDllMainCRTStartup:\nbx lr\n.data\nvariable:\n.long 42" > %t-lib.s
 # RUN: llvm-mc -triple=armv7-windows-gnu %t-lib.s -filetype=obj -o %t-lib.obj
 # RUN: lld-link -out:%t-lib.dll -dll -entry:DllMainCRTStartup %t-lib.obj -lldmingw -implib:%t-lib.lib
 
 # RUN: llvm-mc -triple=armv7-windows-gnu %s -filetype=obj -o %t.obj
 # RUN: lld-link -lldmingw -out:%t.exe -entry:main %t.obj %t-lib.lib -verbose
 
 # RUN: llvm-readobj -coff-imports %t.exe | FileCheck -check-prefix=IMPORTS %s
 # RUN: llvm-objdump -s %t.exe | FileCheck -check-prefix=CONTENTS %s
 
 # IMPORTS: Import {
 # IMPORTS-NEXT: Name: autoimport-arm-data.s.tmp-lib.dll
-# IMPORTS-NEXT: ImportLookupTableRVA: 0x2050
-# IMPORTS-NEXT: ImportAddressTableRVA: 0x2058
+# IMPORTS-NEXT: ImportLookupTableRVA: 0x4028
+# IMPORTS-NEXT: ImportAddressTableRVA: 0x4030
 # IMPORTS-NEXT: Symbol: variable (0)
 # IMPORTS-NEXT: }
 
 # Runtime pseudo reloc list header consisting of 0x0, 0x0, 0x1.
 # First runtime pseudo reloc, with import from 0x2058,
 # applied at 0x3000, with a size of 32 bits.
 # CONTENTS: Contents of section .rdata:
-# CONTENTS:  402000 00000000 00000000 01000000 58200000
+# CONTENTS:  402000 00000000 00000000 01000000 30400000
 # CONTENTS:  402010 00300000 20000000
 # ptr: pointing at the IAT RVA at 0x2058
 # relocs: pointing at the runtime pseudo reloc list at
 # 0x2000 - 0x2018.
 # CONTENTS: Contents of section .data:
-# CONTENTS:  403000 58204000 00204000 18204000
+# CONTENTS:  403000 30404000 00204000 18204000
 
     .global main
     .text
     .thumb
 main:
     bx lr
     .data
 ptr:
     .long variable
 relocs:
     .long __RUNTIME_PSEUDO_RELOC_LIST__
     .long __RUNTIME_PSEUDO_RELOC_LIST_END__

lld/trunk/test/COFF/autoimport-arm64-data.s

 # REQUIRES: aarch64
 
 # RUN: echo -e ".global variable\n.global DllMainCRTStartup\n.text\nDllMainCRTStartup:\nret\n.data\nvariable:\n.long 42" > %t-lib.s
 # RUN: llvm-mc -triple=aarch64-windows-gnu %t-lib.s -filetype=obj -o %t-lib.obj
 # RUN: lld-link -out:%t-lib.dll -dll -entry:DllMainCRTStartup %t-lib.obj -lldmingw -implib:%t-lib.lib
 
 # RUN: llvm-mc -triple=aarch64-windows-gnu %s -filetype=obj -o %t.obj
 # RUN: lld-link -lldmingw -out:%t.exe -entry:main %t.obj %t-lib.lib -verbose
 
 # RUN: llvm-readobj -coff-imports %t.exe | FileCheck -check-prefix=IMPORTS %s
 # RUN: llvm-objdump -s %t.exe | FileCheck -check-prefix=CONTENTS %s
 
 # IMPORTS: Import {
 # IMPORTS-NEXT: Name: autoimport-arm64-data.s.tmp-lib.dll
-# IMPORTS-NEXT: ImportLookupTableRVA: 0x2060
-# IMPORTS-NEXT: ImportAddressTableRVA: 0x2070
+# IMPORTS-NEXT: ImportLookupTableRVA: 0x4028
+# IMPORTS-NEXT: ImportAddressTableRVA: 0x4038
 # IMPORTS-NEXT: Symbol: variable (0)
 # IMPORTS-NEXT: }
 
 # Runtime pseudo reloc list header consisting of 0x0, 0x0, 0x1.
 # First runtime pseudo reloc, with import from 0x2070,
 # applied at 0x3000, with a size of 32 bits.
 # CONTENTS: Contents of section .rdata:
-# CONTENTS:  140002000 00000000 00000000 01000000 70200000
+# CONTENTS:  140002000 00000000 00000000 01000000 38400000
 # CONTENTS:  140002010 00300000 40000000
 # ptr: pointing at the IAT RVA at 0x2070
 # relocs: pointing at the runtime pseudo reloc list at
 # 0x2000 - 0x2018.
 # CONTENTS: Contents of section .data:
-# CONTENTS:  140003000 70200040 01000000 00200040 01000000
+# CONTENTS:  140003000 38400040 01000000 00200040 01000000
 # CONTENTS:  140003010 18200040 01000000
 
     .global main
     .text
 main:
     ret
     .data
 ptr:
     .quad variable
 relocs:
     .quad __RUNTIME_PSEUDO_RELOC_LIST__
     .quad __RUNTIME_PSEUDO_RELOC_LIST_END__

lld/trunk/test/COFF/autoimport-refptr.s

 # REQUIRES: x86
 
 # RUN: echo -e ".global variable\n.global DllMainCRTStartup\n.text\nDllMainCRTStartup:\nret\n.data\nvariable:\n.long 42" > %t-lib.s
 # RUN: llvm-mc -triple=x86_64-windows-gnu %t-lib.s -filetype=obj -o %t-lib.obj
 # RUN: lld-link -out:%t-lib.dll -dll -entry:DllMainCRTStartup %t-lib.obj -lldmingw -implib:%t-lib.lib
 
 # RUN: llvm-mc -triple=x86_64-windows-gnu %s -filetype=obj -o %t.obj
 # RUN: lld-link -lldmingw -out:%t.exe -entry:main %t.obj %t-lib.lib -verbose
 
 # RUN: llvm-readobj -coff-imports %t.exe | FileCheck -check-prefix=IMPORTS %s
 # RUN: llvm-objdump -d %t.exe | FileCheck -check-prefix=DISASM %s
 # RUN: llvm-objdump -s %t.exe | FileCheck -check-prefix=CONTENTS %s
 
 # IMPORTS: Import {
 # IMPORTS-NEXT: Name: autoimport-refptr.s.tmp-lib.dll
-# IMPORTS-NEXT: ImportLookupTableRVA: 0x2050
-# IMPORTS-NEXT: ImportAddressTableRVA: 0x2060
+# IMPORTS-NEXT: ImportLookupTableRVA: 0x4028
+# IMPORTS-NEXT: ImportAddressTableRVA: 0x4038
 # IMPORTS-NEXT: Symbol: variable (0)
 # IMPORTS-NEXT: }
 
 # DISASM: Disassembly of section .text:
 # DISASM: .text:
 # Relative offset at 0x1002 pointing at the IAT at 0x2060
-# DISASM: 140001000:      48 8b 05 59 10 00 00    movq    4185(%rip), %rax
+# DISASM: 140001000:      48 8b 05 31 30 00 00    movq    12337(%rip), %rax
 # DISASM: 140001007:      8b 00   movl    (%rax), %eax
 # Relative offset at 0x100b pointing at the .refptr.localvar stub at
 # 0x2000
 # DISASM: 140001009:      48 8b 0d f0 0f 00 00    movq    4080(%rip), %rcx
 # DISASM: 140001010:      03 01   addl    (%rcx), %eax
 # DISASM: 140001012:      c3      retq
 
 # relocs: pointing at an empty list of runtime pseudo relocs.

lld/trunk/test/COFF/autoimport-x86.s

 # REQUIRES: x86
 
 # RUN: echo -e ".global variable\n.global DllMainCRTStartup\n.text\nDllMainCRTStartup:\nret\n.data\nvariable:\n.long 42" > %t-lib.s
 # RUN: llvm-mc -triple=x86_64-windows-gnu %t-lib.s -filetype=obj -o %t-lib.obj
 # RUN: lld-link -out:%t-lib.dll -dll -entry:DllMainCRTStartup %t-lib.obj -lldmingw -implib:%t-lib.lib
 
 # RUN: llvm-mc -triple=x86_64-windows-gnu %s -filetype=obj -o %t.obj
 # RUN: lld-link -lldmingw -out:%t.exe -entry:main %t.obj %t-lib.lib -verbose
 
 # RUN: llvm-readobj -coff-imports %t.exe | FileCheck -check-prefix=IMPORTS %s
 # RUN: llvm-objdump -d %t.exe | FileCheck -check-prefix=DISASM %s
 # RUN: llvm-objdump -s %t.exe | FileCheck -check-prefix=CONTENTS %s
 
 # IMPORTS: Import {
 # IMPORTS-NEXT: Name: autoimport-x86.s.tmp-lib.dll
-# IMPORTS-NEXT: ImportLookupTableRVA: 0x2070
-# IMPORTS-NEXT: ImportAddressTableRVA: 0x2080
+# IMPORTS-NEXT: ImportLookupTableRVA: 0x4028
+# IMPORTS-NEXT: ImportAddressTableRVA: 0x4038
 # IMPORTS-NEXT: Symbol: variable (0)
 # IMPORTS-NEXT: }
 
 # DISASM: Disassembly of section .text:
 # DISASM: .text:
 # Relative offset at 0x1002 pointing at the IAT at 0x2080.
-# DISASM: 140001000:      8b 05 7a 10 00 00       movl    4218(%rip), %eax
+# DISASM: 140001000:      8b 05 32 30 00 00       movl    12338(%rip), %eax
 # DISASM: 140001006:      c3      retq
 
 # Runtime pseudo reloc list header consisting of 0x0, 0x0, 0x1.
 # First runtime pseudo reloc, with import from 0x2080,
 # applied at 0x1002, with a size of 32 bits.
 # Second runtime pseudo reloc, with import from 0x2080,
 # applied at 0x3000, with a size of 64 bits.
 # CONTENTS: Contents of section .rdata:
-# CONTENTS:  140002000 00000000 00000000 01000000 80200000
-# CONTENTS:  140002010 02100000 20000000 80200000 00300000
+# CONTENTS:  140002000 00000000 00000000 01000000 38400000
+# CONTENTS:  140002010 02100000 20000000 38400000 00300000
 # CONTENTS:  140002020 40000000
 # ptr: pointing at the IAT RVA at 0x2080
 # relocs: pointing at the runtime pseudo reloc list at
 # 0x2000 - 0x2024.
 # CONTENTS: Contents of section .data:
-# CONTENTS:  140003000 80200040 01000000 00200040 01000000
+# CONTENTS:  140003000 38400040 01000000 00200040 01000000
 # CONTENTS:  140003010 24200040 01000000
 
     .global main
     .text
 main:
     movl variable(%rip), %eax
     ret
     .data
 ptr:
     .quad variable
 relocs:
     .quad __RUNTIME_PSEUDO_RELOC_LIST__
     .quad __RUNTIME_PSEUDO_RELOC_LIST_END__

lld/trunk/test/COFF/hello32.test

 HEADER-NEXT:   SizeOfStackReserve: 1048576
 HEADER-NEXT:   SizeOfStackCommit: 4096
 HEADER-NEXT:   SizeOfHeapReserve: 1048576
 HEADER-NEXT:   SizeOfHeapCommit: 4096
 HEADER-NEXT:   NumberOfRvaAndSize: 16
 HEADER-NEXT:   DataDirectory {
 HEADER-NEXT:     ExportTableRVA: 0x0
 HEADER-NEXT:     ExportTableSize: 0x0
-HEADER-NEXT:     ImportTableRVA: 0x2000
+HEADER-NEXT:     ImportTableRVA: 0x3000
 HEADER-NEXT:     ImportTableSize: 0x28
 HEADER-NEXT:     ResourceTableRVA: 0x0
 HEADER-NEXT:     ResourceTableSize: 0x0
 HEADER-NEXT:     ExceptionTableRVA: 0x0
 HEADER-NEXT:     ExceptionTableSize: 0x0
 HEADER-NEXT:     CertificateTableRVA: 0x0
 HEADER-NEXT:     CertificateTableSize: 0x0
 HEADER-NEXT:     BaseRelocationTableRVA: 0x4000
 HEADER-NEXT:     BaseRelocationTableSize: 0x10
 HEADER-NEXT:     DebugRVA: 0x0
 HEADER-NEXT:     DebugSize: 0x0
 HEADER-NEXT:     ArchitectureRVA: 0x0
 HEADER-NEXT:     ArchitectureSize: 0x0
 HEADER-NEXT:     GlobalPtrRVA: 0x0
 HEADER-NEXT:     GlobalPtrSize: 0x0
 HEADER-NEXT:     TLSTableRVA: 0x0
 HEADER-NEXT:     TLSTableSize: 0x0
 HEADER-NEXT:     LoadConfigTableRVA: 0x0
 HEADER-NEXT:     LoadConfigTableSize: 0x0
 HEADER-NEXT:     BoundImportRVA: 0x0
 HEADER-NEXT:     BoundImportSize: 0x0
-HEADER-NEXT:     IATRVA: 0x2034
+HEADER-NEXT:     IATRVA: 0x3034
 HEADER-NEXT:     IATSize: 0xC
 HEADER-NEXT:     DelayImportDescriptorRVA: 0x0
 HEADER-NEXT:     DelayImportDescriptorSize: 0x0
 HEADER-NEXT:     CLRRuntimeHeaderRVA: 0x0
 HEADER-NEXT:     CLRRuntimeHeaderSize: 0x0
 HEADER-NEXT:     ReservedRVA: 0x0
 HEADER-NEXT:     ReservedSize: 0x0
 HEADER-NEXT:   }

 HEADER-NEXT:   AddressOfNewExeHeader: 120
 HEADER-NEXT: }
 
 IMPORTS: Format: COFF-i386
 IMPORTS: Arch: i386
 IMPORTS: AddressSize: 32bit
 IMPORTS: Import {
 IMPORTS:   Name: std32.dll
-IMPORTS:   ImportLookupTableRVA: 0x2028
-IMPORTS:   ImportAddressTableRVA: 0x2034
+IMPORTS:   ImportLookupTableRVA: 0x3028
+IMPORTS:   ImportAddressTableRVA: 0x3034
 IMPORTS:   Symbol: ExitProcess (0)
 IMPORTS:   Symbol: MessageBoxA (1)
 IMPORTS: }
 
 BASEREL: BaseReloc [
 BASEREL:   Entry {
 BASEREL:     Type: HIGHLOW
 BASEREL:     Address: 0x1005
 BASEREL:   }
 BASEREL:   Entry {
 BASEREL:     Type: HIGHLOW
 BASEREL:     Address: 0x100C
 BASEREL:   }
 BASEREL: ]

lld/trunk/test/COFF/imports-gnu-only.s

# RUN: llvm-objdump -s %t.exe | FileCheck -check-prefix=DATA %s
         .global main
 main:
         call func
         ret
 
 # Check that the linker inserted the null terminating import descriptor,
 # even if there were no normal import libraries, only gnu ones.
 
-# DATA: Contents of section .rdata:
+# DATA: Contents of section .idata:
 # First import descriptor
 # DATA:  140002000 28200000 00000000 00000000 53200000
 # Last word from first import descriptor, null terminator descriptor
 # DATA:  140002010 38200000 00000000 00000000 00000000
 # Null terminator descriptor and import lookup table.
 # DATA:  140002020 00000000 00000000 48200000 00000000

lld/trunk/test/COFF/imports.test

 # RUN:   %p/Inputs/hello64.obj %p/Inputs/std64.lib /include:ExitProcess
 # RUN: llvm-objdump -d %t.exe | FileCheck -check-prefix=TEXT %s
 # RUN: llvm-readobj -coff-imports %t.exe | FileCheck -check-prefix=IMPORT %s
 
 TEXT: Disassembly of section .text:
 TEXT-NEXT: .text:
 TEXT-NEXT: subq    $40, %rsp
 TEXT-NEXT: movq    $0, %rcx
-TEXT-NEXT: leaq    8180(%rip), %rdx
-TEXT-NEXT: leaq    8167(%rip), %r8
+TEXT-NEXT: leaq    4084(%rip), %rdx
+TEXT-NEXT: leaq    4071(%rip), %r8
 TEXT-NEXT: movl    $0, %r9d
 TEXT-NEXT: callq   60
 TEXT-NEXT: movl    $0, %ecx
 TEXT-NEXT: callq   18
 TEXT-NEXT: callq   29
-TEXT:      jmpq    *4098(%rip)
-TEXT:      jmpq    *4090(%rip)
-TEXT:      jmpq    *4082(%rip)
+TEXT:      jmpq    *8194(%rip)
+TEXT:      jmpq    *8186(%rip)
+TEXT:      jmpq    *8178(%rip)
 
 IMPORT:      Import {
 IMPORT-NEXT:   Name: std64.dll
-IMPORT-NEXT:   ImportLookupTableRVA: 0x2028
-IMPORT-NEXT:   ImportAddressTableRVA: 0x2048
+IMPORT-NEXT:   ImportLookupTableRVA: 0x3028
+IMPORT-NEXT:   ImportAddressTableRVA: 0x3048
 IMPORT-NEXT:   Symbol: ExitProcess (0)
 IMPORT-NEXT:   Symbol:  (50)
 IMPORT-NEXT:   Symbol: MessageBoxA (1)
 IMPORT-NEXT: }

lld/trunk/test/COFF/pdb-lib.s

 # REQUIRES: x86
 # RUN: rm -rf %t && mkdir -p %t && cd %t
 # RUN: llvm-mc -filetype=obj -triple=i686-windows-msvc %s -o foo.obj
 # RUN: llc %S/Inputs/bar.ll -filetype=obj -mtriple=i686-windows-msvc -o bar.obj
 # RUN: llvm-lib bar.obj -out:bar.lib
 # RUN: lld-link -debug -pdb:foo.pdb foo.obj bar.lib -out:foo.exe -entry:main
 # RUN: llvm-pdbutil dump -modules %t/foo.pdb | FileCheck %s
 
 # Make sure that the PDB has module descriptors. foo.obj and bar.lib should be
 # absolute paths, and bar.obj should be the relative path passed to llvm-lib.
 
 # CHECK:                               Modules
 # CHECK-NEXT: ============================================================
 # CHECK-NEXT:   Mod 0000 | `{{.*pdb-lib.s.tmp[/\\]foo.obj}}`:
 # CHECK-NEXT:              Obj: `{{.*pdb-lib.s.tmp[/\\]foo.obj}}`:
-# CHECK-NEXT:              debug stream: 10, # files: 0, has ec info: false
+# CHECK-NEXT:              debug stream: 65535, # files: 0, has ec info: false
 # CHECK-NEXT:              pdb file ni: 0 ``, src file ni: 0 ``
 # CHECK-NEXT:   Mod 0001 | `bar.obj`:
 # CHECK-NEXT:              Obj: `{{.*pdb-lib.s.tmp[/\\]bar.lib}}`:
-# CHECK-NEXT:              debug stream: 11, # files: 0, has ec info: false
+# CHECK-NEXT:              debug stream: 65535, # files: 0, has ec info: false
 # CHECK-NEXT:              pdb file ni: 0 ``, src file ni: 0 ``
 # CHECK-NEXT:   Mod 0002 | `* Linker *`:
 # CHECK-NEXT:              Obj: ``:
-# CHECK-NEXT:              debug stream: 12, # files: 0, has ec info: false
+# CHECK-NEXT:              debug stream: 10, # files: 0, has ec info: false
 # CHECK-NEXT:              pdb file ni: 1 `{{.*foo.pdb}}`, src file ni: 0 ``
 
         .def     _main;
         .scl    2;
         .type   32;
         .endef
         .globl  _main
 _main:
         calll _bar
         xor %eax, %eax
         retl
 

lld/trunk/test/COFF/pdb-publics-import.test

 Make a DLL that exports a few functions, then make a DLL with PDBs that imports
 them. Check that the __imp_ pointer and the generated thunks appear in the
 publics stream.
 
 RUN: yaml2obj < %p/Inputs/export.yaml > %t1.obj
 RUN: lld-link /out:%t1.dll /dll %t1.obj /implib:%t1.lib \
 RUN:   /export:exportfn1 /export:exportfn2
 RUN: yaml2obj < %p/Inputs/import.yaml > %t2.obj
 RUN: lld-link /out:%t2.exe /pdb:%t2.pdb /pdbaltpath:test.pdb \
 RUN:   /debug /entry:main %t2.obj %t1.lib
-RUN: llvm-pdbutil dump %t2.pdb -publics -section-contribs | FileCheck %s
+RUN: llvm-pdbutil dump %t2.pdb -all | FileCheck %s
+
+CHECK:                               Streams
+CHECK-NEXT: ============================================================
+CHECK-LABEL: Stream 10 ( 256 bytes): [Module "Import:pdb-publics-import.test.tmp1.dll"]
+
+CHECK:                        Module Stats
+CHECK-NEXT: ============================================================
+CHECK-LABEL: Mod 0000 | `{{.*}}pdb-publics-import.test.tmp2.obj`:
+CHECK-NEXT:   Mod 0 (debug info not present): [{{.*}}pdb-publics-import.test.tmp2.obj]
+CHECK-LABEL: Mod 0001 | `pdb-publics-import.test.tmp1.dll`:
+CHECK-NEXT:   Mod 1 (debug info not present): [pdb-publics-import.test.tmp1.dll]
+CHECK-LABEL: Mod 0002 | `Import:pdb-publics-import.test.tmp1.dll`:
+
+
+CHECK:                               Modules
+CHECK-NEXT: ============================================================
+CHECK-LABEL: Mod 0000 | `{{.*}}pdb-publics-import.test.tmp2.obj`:
+CHECK-NEXT:   SC[.text]  | mod = 0, 0001:0000, size = 8, data crc = 0, reloc crc = 0
+CHECK-NEXT:           IMAGE_SCN_CNT_CODE | IMAGE_SCN_ALIGN_4BYTES | IMAGE_SCN_MEM_EXECUTE |
+CHECK-NEXT:           IMAGE_SCN_MEM_READ
+CHECK-NEXT:   Obj: `{{.*}}pdb-publics-import.test.tmp2.obj`:
+CHECK-NEXT:   debug stream: 65535, # files: 0, has ec info: false
+CHECK-NEXT:   pdb file ni: 0 ``, src file ni: 0 ``
+
+CHECK-LABEL: Mod 0001 | `pdb-publics-import.test.tmp1.dll`:
+CHECK-NEXT: SC[???]  | mod = 65535, 65535:0000, size = -1, data crc = 0, reloc crc = 0
+CHECK-NEXT:         none
+CHECK-NEXT: Obj: `{{.*}}pdb-publics-import.test.tmp1.lib`:
+CHECK-NEXT: debug stream: 65535, # files: 0, has ec info: false
+CHECK-NEXT: pdb file ni: 0 ``, src file ni: 0 ``
+
+CHECK-LABEL: Mod 0002 | `Import:pdb-publics-import.test.tmp1.dll`:
+CHECK-NEXT: SC[.text]  | mod = 2, 0001:0032, size = 6, data crc = 0, reloc crc = 0
+CHECK-NEXT:         IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ
+CHECK-NEXT: Obj: `{{.*}}pdb-publics-import.test.tmp1.lib`:
+CHECK-NEXT: debug stream: 10, # files: 0, has ec info: false
+CHECK-NEXT: pdb file ni: 0 ``, src file ni: 0 ``
+
+CHECK-LABEL: Mod 0003 | `* Linker *`:
 
 CHECK:                             Public Symbols
 CHECK-NEXT: ============================================================
 CHECK-NEXT:    Records
 CHECK-NEXT:      112 | S_PUB32 [size = 20] `main`
 CHECK-NEXT:            flags = function, addr = 0001:0000
 CHECK-NEXT:       64 | S_PUB32 [size = 24] `exportfn1`
 CHECK-NEXT:            flags = function, addr = 0001:0016
 CHECK-NEXT:       88 | S_PUB32 [size = 24] `exportfn2`
 CHECK-NEXT:            flags = function, addr = 0001:0032
 CHECK-NEXT:       32 | S_PUB32 [size = 32] `__imp_exportfn2`
-CHECK-NEXT:            flags = none, addr = 0002:0136
+CHECK-NEXT:            flags = none, addr = 0003:0072
 CHECK-NEXT:        0 | S_PUB32 [size = 32] `__imp_exportfn1`
-CHECK-NEXT:            flags = none, addr = 0002:0128
+CHECK-NEXT:            flags = none, addr = 0003:0064
+
+CHECK:                          Symbols
+CHECK-NEXT: ============================================================
+CHECK-NEXT:   Mod 0000 | `{{.*}}pdb-publics-import.test.tmp2.obj`:
+CHECK-NEXT:   Error loading module stream 0.  The specified stream could not be loaded. Module stream not present
+CHECK-NEXT: Mod 0001 | `pdb-publics-import.test.tmp1.dll`:
+CHECK-NEXT: Error loading module stream 1.  The specified stream could not be loaded. Module stream not present
+CHECK-NEXT: Mod 0002 | `Import:pdb-publics-import.test.tmp1.dll`:
+CHECK-NEXT:      4 | S_OBJNAME [size = 44] sig=0, `pdb-publics-import.test.tmp1.dll`
+CHECK-NEXT:     48 | S_COMPILE3 [size = 40]
+CHECK-NEXT:          machine = intel x86-x64, Ver = LLVM Linker, language = link
+CHECK-NEXT:          frontend = 0.0.0.0, backend = 14.10.25019.0
+CHECK-NEXT:          flags = none
+CHECK-NEXT:     88 | S_THUNK32 [size = 36] `exportfn1`
+CHECK-NEXT:          parent = 0, end = 124, next = 0
+CHECK-NEXT:          kind = thunk, size = 6, addr = 0001:0016
+CHECK-NEXT:    124 | S_END [size = 4]
+CHECK-NEXT:    128 | S_OBJNAME [size = 44] sig=0, `pdb-publics-import.test.tmp1.dll`
+CHECK-NEXT:    172 | S_COMPILE3 [size = 40]
+CHECK-NEXT:          machine = intel x86-x64, Ver = LLVM Linker, language = link
+CHECK-NEXT:          frontend = 0.0.0.0, backend = 14.10.25019.0
+CHECK-NEXT:          flags = none
+CHECK-NEXT:    212 | S_THUNK32 [size = 36] `exportfn2`
+CHECK-NEXT:          parent = 0, end = 248, next = 0
+CHECK-NEXT:          kind = thunk, size = 6, addr = 0001:0032
+CHECK-NEXT:    248 | S_END [size = 4]
+CHECK-NEXT: Mod 0003 | `* Linker *`:
+CHECK-NEXT:      4 | S_OBJNAME [size = 20] sig=0, `* Linker *`
+CHECK-NEXT:     24 | S_COMPILE3 [size = 40]
+CHECK-NEXT:          machine = intel x86-x64, Ver = LLVM Linker, language = link
+CHECK-NEXT:          frontend = 0.0.0.0, backend = 14.10.25019.0
+CHECK-NEXT:          flags = none
+CHECK-NEXT:     64 | S_ENVBLOCK [size = {{[0-9]+}}]
+CHECK:  {{[0-9]+}} | S_SECTION [size = 28] `.text`
+CHECK-NEXT:          length = 38, alignment = 12, rva = 4096, section # = 1
+CHECK-NEXT:          characteristics =
+CHECK-NEXT:            code
+CHECK-NEXT:            execute permissions
+CHECK-NEXT:            read permissions
+CHECK-NEXT: {{[0-9]+}} | S_COFFGROUP [size = 24] `.text`
+CHECK-NEXT:          length = 8, addr = 0001:0000
+CHECK-NEXT:          characteristics =
+CHECK-NEXT:            code
+CHECK-NEXT:            execute permissions
+CHECK-NEXT:            read permissions
+CHECK-NEXT: {{[0-9]+}} | S_SECTION [size = 28] `.rdata`
+CHECK-NEXT:          length = 61, alignment = 12, rva = 8192, section # = 2
+CHECK-NEXT:          characteristics =
+CHECK-NEXT:            initialized data
+CHECK-NEXT:            read permissions
+CHECK-NEXT: {{[0-9]+}} | S_SECTION [size = 28] `.idata`
+CHECK-NEXT:          length = 145, alignment = 12, rva = 12288, section # = 3
+CHECK-NEXT:          characteristics =
+CHECK-NEXT:            initialized data
+CHECK-NEXT:            read permissions
+CHECK-NEXT: {{[0-9]+}} | S_COFFGROUP [size = 28] `.idata$2`
+CHECK-NEXT:          length = 40, addr = 0003:0000
+CHECK-NEXT:          characteristics =
+CHECK-NEXT:            initialized data
+CHECK-NEXT:            read permissions
+CHECK-NEXT:            write permissions
+CHECK-NEXT: {{[0-9]+}} | S_COFFGROUP [size = 28] `.idata$4`
+CHECK-NEXT:          length = 24, addr = 0003:0040
+CHECK-NEXT:          characteristics =
+CHECK-NEXT:            initialized data
+CHECK-NEXT:            read permissions
+CHECK-NEXT:            write permissions
+CHECK-NEXT: {{[0-9]+}} | S_COFFGROUP [size = 28] `.idata$5`
+CHECK-NEXT:          length = 24, addr = 0003:0064
+CHECK-NEXT:          characteristics =
+CHECK-NEXT:            initialized data
+CHECK-NEXT:            read permissions
+CHECK-NEXT:            write permissions
+CHECK-NEXT: {{[0-9]+}} | S_COFFGROUP [size = 28] `.idata$6`
+CHECK-NEXT:          length = 24, addr = 0003:0088
+CHECK-NEXT:          characteristics =
+CHECK-NEXT:            initialized data
+CHECK-NEXT:            read permissions
+CHECK-NEXT:            write permissions
+CHECK-NEXT: {{[0-9]+}} | S_COFFGROUP [size = 28] `.idata$7`
+CHECK-NEXT:          length = 33, addr = 0003:0112
+CHECK-NEXT:          characteristics =
+CHECK-NEXT:            initialized data
+CHECK-NEXT:            read permissions
+CHECK-NEXT:            write permissions
+
+CHECK:                       Section Headers
+CHECK-NEXT: ============================================================
+CHECK-LABEL:   SECTION HEADER #1
+CHECK-NEXT:      .text name
+CHECK-NEXT:         26 virtual size
+CHECK-NEXT:       1000 virtual address
+CHECK-NEXT:        200 size of raw data
+CHECK-NEXT:        400 file pointer to raw data
+CHECK-NEXT:          0 file pointer to relocation table
+CHECK-NEXT:          0 file pointer to line numbers
+CHECK-NEXT:          0 number of relocations
+CHECK-NEXT:          0 number of line numbers
+CHECK-NEXT:   60000020 flags
+CHECK-NEXT:            IMAGE_SCN_CNT_CODE
+CHECK-NEXT:            IMAGE_SCN_MEM_EXECUTE
+CHECK-NEXT:            IMAGE_SCN_MEM_READ
+CHECK-LABEL:   SECTION HEADER #2
+CHECK-NEXT:     .rdata name
+CHECK-NEXT:         3D virtual size
+CHECK-NEXT:       2000 virtual address
+CHECK-NEXT:        200 size of raw data
+CHECK-NEXT:        600 file pointer to raw data
+CHECK-NEXT:          0 file pointer to relocation table
+CHECK-NEXT:          0 file pointer to line numbers
+CHECK-NEXT:          0 number of relocations
+CHECK-NEXT:          0 number of line numbers
+CHECK-NEXT:   40000040 flags
+CHECK-NEXT:            IMAGE_SCN_CNT_INITIALIZED_DATA
+CHECK-NEXT:            IMAGE_SCN_MEM_READ
+CHECK-LABEL:   SECTION HEADER #3
+CHECK-NEXT:     .idata name
+CHECK-NEXT:         91 virtual size
+CHECK-NEXT:       3000 virtual address
+CHECK-NEXT:        200 size of raw data
+CHECK-NEXT:        800 file pointer to raw data
+CHECK-NEXT:          0 file pointer to relocation table
+CHECK-NEXT:          0 file pointer to line numbers
+CHECK-NEXT:          0 number of relocations
+CHECK-NEXT:          0 number of line numbers
+CHECK-NEXT:   40000040 flags
+CHECK-NEXT:            IMAGE_SCN_CNT_INITIALIZED_DATA
+CHECK-NEXT:            IMAGE_SCN_MEM_READ
 
 CHECK:                         Section Contributions
 CHECK-NEXT: ============================================================
     main
-CHECK-NEXT:   SC[.text]   | mod = 0, 0001:0000, size = 8, data crc = 0, reloc crc = 0
-CHECK-NEXT:                 IMAGE_SCN_CNT_CODE | IMAGE_SCN_ALIGN_4BYTES | IMAGE_SCN_MEM_EXECUTE |
-CHECK-NEXT:                 IMAGE_SCN_MEM_READ
-    exportfn1 thunk
-CHECK-NEXT:   SC[.text]   | mod = 1, 0001:0016, size = 6, data crc = 0, reloc crc = 0
-CHECK-NEXT:                 IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ
-    exportfn2 thunk
-CHECK-NEXT:   SC[.text]   | mod = 1, 0001:0032, size = 6, data crc = 0, reloc crc = 0
-CHECK-NEXT:                 IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ
-    .rdata debug directory data chunks
-CHECK-NEXT:   SC[.rdata]  | mod = 1, 0002:0000, size = 28, data crc = 0, reloc crc = 0
-CHECK-NEXT:                 IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ
-CHECK-NEXT:   SC[.rdata]  | mod = 1, 0002:0028, size = 33, data crc = 0, reloc crc = 0
-CHECK-NEXT:                 IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ
+CHECK-NEXT:   SC[.text]   | mod = 0, 0001:0000, size = 8, data crc = 0, reloc crc = 0
+CHECK-NEXT:                 IMAGE_SCN_CNT_CODE | IMAGE_SCN_ALIGN_4BYTES | IMAGE_SCN_MEM_EXECUTE |
+CHECK-NEXT:                 IMAGE_SCN_MEM_READ
+  exportfn1 thunk
+CHECK-NEXT:   SC[.text]   | mod = 3, 0001:0016, size = 6, data crc = 0, reloc crc = 0
+CHECK-NEXT:                 IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ
+  exportfn2 thunk
+CHECK-NEXT:   SC[.text]   | mod = 3, 0001:0032, size = 6, data crc = 0, reloc crc = 0
+CHECK-NEXT:                 IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ
+  .rdata debug directory data chunks
+CHECK-NEXT:   SC[.rdata]  | mod = 3, 0002:0000, size = 28, data crc = 0, reloc crc = 0
+CHECK-NEXT:                 IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ
+CHECK-NEXT:   SC[.rdata]  | mod = 3, 0002:0028, size = 33, data crc = 0, reloc crc = 0
+CHECK-NEXT:                 IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ
+
+CHECK-NEXT:   SC[.idata]  | mod = 3, 0003:0000, size = 20, data crc = 0, reloc crc = 0
+CHECK-NEXT:                 IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ
+CHECK-NEXT:   SC[.idata]  | mod = 3, 0003:0020, size = 20, data crc = 0, reloc crc = 0
+CHECK-NEXT:                 IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ
+CHECK-NEXT:   SC[.idata]  | mod = 3, 0003:0040, size = 8, data crc = 0, reloc crc = 0
+CHECK-NEXT:                 IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ
+CHECK-NEXT:   SC[.idata]  | mod = 3, 0003:0048, size = 8, data crc = 0, reloc crc = 0
+CHECK-NEXT:                 IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ
+CHECK-NEXT:   SC[.idata]  | mod = 3, 0003:0056, size = 8, data crc = 0, reloc crc = 0
+CHECK-NEXT:                 IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ
+CHECK-NEXT:   SC[.idata]  | mod = 3, 0003:0064, size = 8, data crc = 0, reloc crc = 0
+CHECK-NEXT:                 IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ
+CHECK-NEXT:   SC[.idata]  | mod = 3, 0003:0072, size = 8, data crc = 0, reloc crc = 0
+CHECK-NEXT:                 IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ
+CHECK-NEXT:   SC[.idata]  | mod = 3, 0003:0080, size = 8, data crc = 0, reloc crc = 0
+CHECK-NEXT:                 IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ
+CHECK-NEXT:   SC[.idata]  | mod = 3, 0003:0088, size = 12, data crc = 0, reloc crc = 0
+CHECK-NEXT:                 IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ
+CHECK-NEXT:   SC[.idata]  | mod = 3, 0003:0100, size = 12, data crc = 0, reloc crc = 0
+CHECK-NEXT:                 IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ
+CHECK-NEXT:   SC[.idata]  | mod = 3, 0003:0112, size = 33, data crc = 0, reloc crc = 0
+CHECK-NEXT:                 IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ

lld/trunk/test/COFF/pdb.test

 RAW-NEXT:   Mod 0001 | `{{.*}}pdb.test.tmp2.obj`:
 RAW-NEXT:              SC[.text]  | mod = 1, 0001:0016, size = 6, data crc = 2139436471, reloc crc = 0
 RAW-NEXT:                           IMAGE_SCN_CNT_CODE | IMAGE_SCN_ALIGN_16BYTES | IMAGE_SCN_MEM_EXECUTE |
 RAW-NEXT:                           IMAGE_SCN_MEM_READ
 RAW-NEXT:              Obj: `{{.*}}pdb.test.tmp2.obj`:
 RAW-NEXT:              debug stream: 12, # files: 1, has ec info: false
 RAW-NEXT:              pdb file ni: 0 ``, src file ni: 0 ``
 RAW-NEXT:   Mod 0002 | `* Linker *`:
-RAW-NEXT:              SC[???]  | mod = 2, 0000:0000, size = 0, data crc = 0, reloc crc = 0
+RAW-NEXT:              SC[???]  | mod = 0, 0000:0000, size = 0, data crc = 0, reloc crc = 0
 RAW-NEXT:                         none
 RAW-NEXT:              Obj: ``:
 RAW-NEXT:              debug stream: 13, # files: 0, has ec info: false
 RAW-NEXT:              pdb file ni: 1 `{{.*pdb.test.tmp.pdb}}`, src file ni: 0 ``
 RAW:                          Types (TPI Stream)
 RAW-NEXT: ============================================================
 RAW-NEXT:   Showing 5 records
 RAW-NEXT:   0x1000 | LF_ARGLIST [size = 8, hash = 0xEC0]

lld/trunk/test/COFF/symtab.test

 # RUN: yaml2obj < %s > %t.obj
 # RUN: lld-link /debug:dwarf /out:%t.exe /entry:main %t.obj %p/Inputs/std64.lib
-# RUN: llvm-readobj -symbols %t.exe | FileCheck %s
+# RUN: llvm-readobj -symbols %t.exe | FileCheck %s -check-prefixes=CHECK,DWARF-HASDEBUG
 # RUN: lld-link /debug:dwarf /opt:noref /out:%t.exe /entry:main %t.obj %p/Inputs/std64.lib
-# RUN: llvm-readobj -symbols %t.exe | FileCheck %s
+# RUN: llvm-readobj -symbols %t.exe | FileCheck %s -check-prefixes=CHECK,DWARF-HASDEBUG
 # RUN: lld-link /debug:symtab /opt:noref /out:%t.exe /entry:main %t.obj %p/Inputs/std64.lib
-# RUN: llvm-readobj -symbols %t.exe | FileCheck %s
+# RUN: llvm-readobj -symbols %t.exe | FileCheck %s -check-prefixes=CHECK,SYMTAB-NODEBUG
 
 # RUN: lld-link /debug /out:%t.exe /entry:main %t.obj %p/Inputs/std64.lib
 # RUN: llvm-readobj -symbols %t.exe | FileCheck -check-prefix=NO %s
 
 # CHECK:      Symbols [
 # CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: .text
 # CHECK-NEXT:     Value: 0

 # CHECK-NEXT:     BaseType: Null (0x0)
 # CHECK-NEXT:     ComplexType: Null (0x0)
 # CHECK-NEXT:     StorageClass: Static (0x3)
 # CHECK-NEXT:     AuxSymbolCount: 0
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: .data
 # CHECK-NEXT:     Value: 0
-# CHECK-NEXT:     Section: .data (3)
+
+# Using /debug:dwarf sets Config->Debug thus it adds extra (debug) chunks in the .rdata section
+# Whereas /debug:symtab does not set Config->Debug thus the .rdata section is not emitted, so the .data section appears in a different section id.
+
+# DWARF-HASDEBUG-NEXT:     Section: .data (3)
+# SYMTAB-NODEBUG-NEXT:     Section: .data (2)
+
 # CHECK-NEXT:     BaseType: Null (0x0)
 # CHECK-NEXT:     ComplexType: Null (0x0)
 # CHECK-NEXT:     StorageClass: Static (0x3)
 # CHECK-NEXT:     AuxSymbolCount: 0
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: MessageBoxA
 # CHECK-NEXT:     Value: 80

 # CHECK-NEXT:     BaseType: Null (0x0)
 # CHECK-NEXT:     ComplexType: Null (0x0)
 # CHECK-NEXT:     StorageClass: External (0x2)
 # CHECK-NEXT:     AuxSymbolCount: 0
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: message
 # CHECK-NEXT:     Value: 6
-# CHECK-NEXT:     Section: .text2
+
+# DWARF-HASDEBUG-NEXT:     Section: .text2 (5)
+# SYMTAB-NODEBUG-NEXT:     Section: .text2 (4)
+
 # CHECK-NEXT:     BaseType: Null (0x0)
 # CHECK-NEXT:     ComplexType: Null (0x0)
 # CHECK-NEXT:     StorageClass: Static (0x3)
 # CHECK-NEXT:     AuxSymbolCount: 0
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: main
 # CHECK-NEXT:     Value: 0
 # CHECK-NEXT:     Section: .text (1)
 # CHECK-NEXT:     BaseType: Null (0x0)
 # CHECK-NEXT:     ComplexType: Null (0x0)
 # CHECK-NEXT:     StorageClass: External (0x2)
 # CHECK-NEXT:     AuxSymbolCount: 0
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: caption
 # CHECK-NEXT:     Value: 0
-# CHECK-NEXT:     Section: .text2
+
+# DWARF-HASDEBUG-NEXT:     Section: .text2 (5)
+# SYMTAB-NODEBUG-NEXT:     Section: .text2 (4)
+
 # CHECK-NEXT:     BaseType: Null (0x0)
 # CHECK-NEXT:     ComplexType: Null (0x0)
 # CHECK-NEXT:     StorageClass: Static (0x3)
 # CHECK-NEXT:     AuxSymbolCount: 0
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: abs_symbol
 # CHECK-NEXT:     Value: 2662186735

llvm/trunk/include/llvm/DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.h

public:
 
   ArrayRef<std::string> source_files() const {
     return makeArrayRef(SourceFiles);
   }
 
   uint32_t calculateSerializedLength() const;
 
   /// Return the offset within the module symbol stream of the next symbol
-  /// record passed to addSymbol. Add four to account for the signature.
-  uint32_t getNextSymbolOffset() const { return SymbolByteSize + 4; }
+  /// record passed to addSymbol.
+  uint32_t getNextSymbolOffset() const {
+    return /*signature*/ sizeof(uint32_t) + SymbolByteSize;
+  }
 
   void finalize();
   Error finalizeMsfLayout();
 
   Error commit(BinaryStreamWriter &ModiWriter, const msf::MSFLayout &MsfLayout,
                WritableBinaryStreamRef MsfBuffer);
 
 private:

llvm/trunk/lib/DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.cpp

 uint32_t DbiModuleDescriptorBuilder::calculateSerializedLength() const {
   uint32_t L = sizeof(Layout);
   uint32_t M = ModuleName.size() + 1;
   uint32_t O = ObjFileName.size() + 1;
   return alignTo(L + M + O, sizeof(uint32_t));
 }
 
 void DbiModuleDescriptorBuilder::finalize() {
-  Layout.SC.Imod = Layout.Mod;
+  if (Layout.SC.ISect == kInvalidStreamIndex)
+    Layout.Mod = 0;
   Layout.FileNameOffs = 0; // TODO: Fix this
   Layout.Flags = 0;        // TODO: Fix this
   Layout.C11Bytes = 0;
   Layout.C13Bytes = calculateC13DebugInfoSize();
   (void)Layout.Mod;         // Set in constructor
   (void)Layout.ModDiStream; // Set in finalizeMsfLayout
   Layout.NumFiles = SourceFiles.size();
   Layout.PdbFilePathNI = PdbFilePathNI;
   Layout.SrcFileNameNI = 0;
 
   // This value includes both the signature field as well as the record bytes
   // from the symbol stream.
-  Layout.SymBytes = SymbolByteSize + sizeof(uint32_t);
+  Layout.SymBytes =
+      Layout.ModDiStream == kInvalidStreamIndex ? 0 : getNextSymbolOffset();
 }
 
 Error DbiModuleDescriptorBuilder::finalizeMsfLayout() {
   this->Layout.ModDiStream = kInvalidStreamIndex;
   uint32_t C13Size = calculateC13DebugInfoSize();
+  if (C13Size || SymbolByteSize) {
     auto ExpectedSN =
         MSF.addStream(calculateDiSymbolStreamSize(SymbolByteSize, C13Size));
     if (!ExpectedSN)
       return ExpectedSN.takeError();
     Layout.ModDiStream = *ExpectedSN;
+  }
   return Error::success();
 }
 
 Error DbiModuleDescriptorBuilder::commit(BinaryStreamWriter &ModiWriter,
                                          const msf::MSFLayout &MsfLayout,
                                          WritableBinaryStreamRef MsfBuffer) {
   // We write the Modi record to the `ModiWriter`, but we additionally write its
   // symbol stream to a brand new stream.
   if (auto EC = ModiWriter.writeObject(Layout))
     return EC;
   if (auto EC = ModiWriter.writeCString(ModuleName))
     return EC;
   if (auto EC = ModiWriter.writeCString(ObjFileName))
     return EC;
   if (auto EC = ModiWriter.padToAlignment(sizeof(uint32_t)))
     return EC;
 
   if (Layout.ModDiStream != kInvalidStreamIndex) {
     auto NS = WritableMappedBlockStream::createIndexedStream(
         MsfLayout, MsfBuffer, Layout.ModDiStream, MSF.getAllocator());
     WritableBinaryStreamRef Ref(*NS);
     BinaryStreamWriter SymbolWriter(Ref);
-    // Write the symbols.
+
     if (auto EC =
             SymbolWriter.writeInteger<uint32_t>(COFF::DEBUG_SECTION_MAGIC))
       return EC;
+
+    // Write the symbols.
+    if (SymbolByteSize > 0) {
       BinaryItemStream<CVSymbol> Records(llvm::support::endianness::little);
       Records.setItems(Symbols);
       BinaryStreamRef RecordsRef(Records);
       if (auto EC = SymbolWriter.writeStreamRef(RecordsRef))
         return EC;
-    if (auto EC = SymbolWriter.padToAlignment(4))
+      if (auto EC = SymbolWriter.padToAlignment(sizeof(uint32_t)))
         return EC;
+    }
+
     // TODO: Write C11 Line data
     assert(SymbolWriter.getOffset() % alignOf(CodeViewContainer::Pdb) == 0 &&
            "Invalid debug section alignment!");
     for (const auto &Builder : C13Builders) {
       assert(Builder && "Empty C13 Fragment Builder!");
       if (auto EC = Builder->commit(SymbolWriter))
         return EC;
     }

llvm/trunk/lib/DebugInfo/PDB/Native/ModuleDebugStream.cpp

 //===- ModuleDebugStream.cpp - PDB Module Info Stream Access --------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/PDB/Native/ModuleDebugStream.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/DebugChecksumsSubsection.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/DebugInfo/PDB/Native/DbiModuleDescriptor.h"
+#include "llvm/DebugInfo/PDB/Native/RawConstants.h"
 #include "llvm/DebugInfo/PDB/Native/RawError.h"
 #include "llvm/Support/BinaryStreamReader.h"
 #include "llvm/Support/BinaryStreamRef.h"
 #include "llvm/Support/Error.h"
 #include <algorithm>
 #include <cstdint>
 
 using namespace llvm;
 using namespace llvm::codeview;
 using namespace llvm::msf;
 using namespace llvm::pdb;
 
 ModuleDebugStreamRef::ModuleDebugStreamRef(
     const DbiModuleDescriptor &Module,
     std::unique_ptr<MappedBlockStream> Stream)
     : Mod(Module), Stream(std::move(Stream)) {}
 
 ModuleDebugStreamRef::~ModuleDebugStreamRef() = default;
 
 Error ModuleDebugStreamRef::reload() {
   BinaryStreamReader Reader(*Stream);
 
-  uint32_t SymbolSize = Mod.getSymbolDebugInfoByteSize();
+  if (Mod.getModuleStreamIndex() != llvm::pdb::kInvalidStreamIndex) {
+    uint32_t SymbolSize =
+        Mod.getSymbolDebugInfoByteSize() - /*signature*/ sizeof(uint32_t);
     uint32_t C11Size = Mod.getC11LineInfoByteSize();
     uint32_t C13Size = Mod.getC13LineInfoByteSize();
 
     if (C11Size > 0 && C13Size > 0)
       return make_error<RawError>(raw_error_code::corrupt_file,
                                   "Module has both C11 and C13 line info");
 
     BinaryStreamRef S;
 
     if (auto EC = Reader.readInteger(Signature))
       return EC;
-  if (auto EC = Reader.readSubstream(SymbolsSubstream, SymbolSize - 4))
+    if (SymbolSize > 0) {
+      if (auto EC = Reader.readSubstream(SymbolsSubstream, SymbolSize))
         return EC;
+    }
     if (auto EC = Reader.readSubstream(C11LinesSubstream, C11Size))
       return EC;
     if (auto EC = Reader.readSubstream(C13LinesSubstream, C13Size))
       return EC;
 
     BinaryStreamReader SymbolReader(SymbolsSubstream.StreamData);
     if (auto EC =
             SymbolReader.readArray(SymbolArray, SymbolReader.bytesRemaining()))
       return EC;
-
     BinaryStreamReader SubsectionsReader(C13LinesSubstream.StreamData);
-  if (auto EC = SubsectionsReader.readArray(Subsections,
-                                            SubsectionsReader.bytesRemaining()))
+    if (auto EC = SubsectionsReader.readArray(
+            Subsections, SubsectionsReader.bytesRemaining()))
       return EC;
 
     uint32_t GlobalRefsSize;
     if (auto EC = Reader.readInteger(GlobalRefsSize))
       return EC;
     if (auto EC = Reader.readSubstream(GlobalRefsSubstream, GlobalRefsSize))
       return EC;
+  }
   if (Reader.bytesRemaining() > 0)
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "Unexpected bytes in module stream.");
 
   return Error::success();
 }
 
 BinarySubstreamRef ModuleDebugStreamRef::getSymbolsSubstream() const {