[LLD][COFF] Add support for /FUNCTIONPADMIN command-line option

[aganea]

Summary

This patch adds support for the /FUNCTIONPADMIN command-line option (allowing an image to be hotpatched) described here: https://msdn.microsoft.com/en-us/library/ms173524.aspx

Even though LLD understands /FUNCTIONPADMIN, all it does is ignore it.
I added parsing of this command-line option (note that it accepts an additional integer argument specifying the number of padding bytes, e.g. /FUNCTIONPADMIN:10) and added support for it in the section chunks and when writing PDB contributions.

[zturner]

You'll definitely need to add a test here, hopefully @ruiu or @rnk can suggest the best way to write one. But I think there should be at least 3. One that tests /FUNCTIONPADMIN with x86 produces 5, one that tests /FUNCTIONPADMIN with x64 produces 6, and one that tests that /FUNCTIONPADMIN:N produces N bytes of padding.

COFF/DriverUtils.cpp

271–273 ↗

(On Diff #155632)

What about ARM64? The documentation doesn't say what the default value is here, but it should be easy to figure out.

COFF/PDB.cpp

118–122 ↗

(On Diff #155632)

It looks like you may have run clang-format against the entire source files, rather than against only the lines that you changed. Would it be possible to revert these changes and only clang-format changed lines? There's a script called git-clang-format in the clang source tree. Usually what we do is add this location to PATH, and then run git clang-format That will only format touched lines.

790 ↗

(On Diff #155632)

That is quite odd. Wouldn't this mean that the PDB has incorrect info? I wonder how this could possibly be correct. So either it's a bug in link.exe or there's something I don't understand about what PDB conumers use this information for.

[stefan_reinalter]

COFF/DriverUtils.cpp

271–273 ↗

(On Diff #155632)

Understood, I will try figuring this out.

COFF/PDB.cpp

118–122 ↗

(On Diff #155632)

Yes, I ran clang-format against all touched files. I thought this was the intention to make everything use the same format, but can revert the changes of course.

790 ↗

(On Diff #155632)

I don't think this means that the PDB has incorrect info, but rather that the padding bytes are not accounted for anywhere.
E.g. take a function SimpleFunction at RVA 0x3190:

The public symbol stored will hold its address:
PublicSymbol: [00003190][0001:00002190] ?SimpleFunction@@YAXXZ(void __cdecl SimpleFunction(void))

The function stored inside the compiland will hold the following info:
Function : static, [00003190][0001:00002190], len = 00000020, void __cdecl SimpleFunction(void)
FuncDebugStart : static, [00003194][0001:00002194]
FuncDebugEnd : static, [000031A7][0001:000021A7]

This stores the address, the length, and end of the prologue as well as start of the epilogue. None of these are concerned about padding bytes. The contribution also shows 0x20 bytes being contributed, which does *not* include padding bytes:
00003190 0001:00002190 00000020 C:\SomePath\SimpleFunction.obj

The padding bytes between functions are 'unaccounted' for, so to speak.
I think this is by design, otherwise you'd get different info from the compiland/function stream and the contribution stream.

Note that padding bytes are inserted in front of functions (=between section chunks), but function entry points/RVAs still point at the first code byte, not any padding.

[zturner]

COFF/PDB.cpp

118–122 ↗

(On Diff #155632)

Usually we try to keep CLs limited to only changes that contribute to the functionality you're implementing in this patch. clang-formatting an entire file might be worthwile, but we should do it in a separate patch (before or after this patch doesn't matter) that way the only thing we see on the review is changes specifically related to implementing /FUNCTIONPADMIN

[pcc]

Unless I'm missing something, doesn't this patch end up adding padding to the end of every code section rather than the beginning?

It seems like this ought to be implemented by changing the section layout code. I'm thinking that you would add code to http://llvm-cs.pcc.me.uk/tools/lld/COFF/Writer.cpp#742 that does this:

if (C requires padding) {
  RawSize += Padding;
  VirtualSize += Padding;
}

With that I don't think you need to add fields for storing the amount of padding required, you can just figure it out on the fly there.

COFF/DriverUtils.cpp

271–273 ↗

(On Diff #155632)

And ARM32.

COFF/PDB.cpp

790 ↗

(On Diff #155632)

If you move the implementation of /functionpadmin to section layout I don't think you would need to worry about that here.

[stefan_reinalter]

In D49366#1163821, @pcc wrote:

Unless I'm missing something, doesn't this patch end up adding padding to the end of every code section rather than the beginning?

It seems like this ought to be implemented by changing the section layout code. I'm thinking that you would add code to http://llvm-cs.pcc.me.uk/tools/lld/COFF/Writer.cpp#742 that does this:

if (C requires padding) {
  RawSize += Padding;
  VirtualSize += Padding;
}

With that I don't think you need to add fields for storing the amount of padding required, you can just figure it out on the fly there.

Fully agree. I like your suggestion because it's also less invasive.

[stefan_reinalter]

COFF/DriverUtils.cpp

271–273 ↗

(On Diff #155632)

When building for ARM using MSVC/link.exe, using /FUNCTIONPADMIN yields:
LINK : fatal error LNK1146: no argument specified with option '/FUNCTIONPADMIN'

Seems like there is no default for these platforms.

[stefan_reinalter]

I updated the implementation according to the recommendation by Peter. I also added a comment regarding /FUNCTIONPADMIN default padding on ARM platforms.
Also ran git-clang-format against the source files so that the diff shows only my changes.

Tests are still missing though, I'm waiting for your advice on this.

[pcc]

Probably the best way to write the test would be to have it create an input file with a .text section containing the entry point and a non-code section and relocations pointing from the .text section to itself as well as to the non-code section, and use llvm-objdump to test that (1) the .text section has an appropriate amount of padding behind it in the output file, (2) the non-code section does not receive padding and (3) the relocation points to the address of the section (i.e. not the address of the padding). You can see an example of this sort of test in lld/test/COFF/string-tail-merge.s. By using llvm-mc to assemble the test with different target triples it should be possible to write it in such a way that you don't need a separate test for each target.

COFF/Config.h

177 ↗

(On Diff #155875)

Nit: we tend to name configuration fields after the flag that they're derived from. So this one should be called FunctionPadMin I think. With that you don't need the comment either because it becomes redundant with the name of the field, and you can group it with the other uint32_t fields below.

COFF/DriverUtils.cpp

271–273 ↗

(On Diff #155632)

I wouldn't add a padding amount for IA64 here since the rest of the linker doesn't support it so it is basically dead code.

COFF/Writer.cpp

760 ↗

(On Diff #155875)

It looks like you don't need to protect this code with an if statement because there's no harm in padding compiler-generated sections, and link.exe does it too (try running link.exe /functionpadmin:4096 /entry:ExitProcess /subsystem:console /out:exit.exe kernel32.lib and disassembling exit.exe).

761 ↗

(On Diff #155875)

Taking a closer look at the code, it looks like RawSize is updated automatically at the end of the loop, so you don't need to update it here.

[stefan_reinalter]

COFF/Writer.cpp

761 ↗

(On Diff #155875)

Can we assume that C->hasData() is always true in this case?

[pcc]

COFF/Writer.cpp

761 ↗

(On Diff #155875)

As it happens it should always be true for chunks in the text section (what it means is that the section is not uninitialized data, i.e. bss) but even in the case where it weren't true we wouldn't want to change RawSize because that variable contains the amount of initialized data in the section and it shouldn't be affected by any uninitialized data sections.

[aganea]

After discussing offline with Stefan, I will take ownership and will finish this patch.

[aganea]

Just for the record, this is not as simple as I initially thought. We should only be padding functions that originate from hotpatch-enabled OBJs. Currently, LLVM currently does not generate /hotpatch OBJs (at least the flag isn't set). In theory, x64 and ARM OBJs should be fine to have this flag enabled. I'll do more research and get back.

[aganea]

Adressed all comments. Added tests as suggested by @pcc

I've also added proper handling for the [[ https://docs.microsoft.com/en-us/cpp/build/reference/hotpatch-create-hotpatchable-image?view=vs-2017 | /HOTPATCH ]] compile-time flag. If this flag is not present in the input, then /FUNCTIONPADMIN will not do anything for functions originating from that input. Linker-generated DLL thunks are always padded when providing /FUNCTIONPADMIN.

Incidentally, Clang currently doesn't generate the CompileSym3Flags::HotPatch flag in S_COMPILE3 records. So as it stands, /FUNCTIONPADMIN will currently not work with Clang OBJs. This shall be fixed in a subsequent patch.

[ruiu]

COFF/DriverUtils.cpp

260–261 ↗

(On Diff #187590)

Return early.

COFF/InputFiles.h

163 ↗

(On Diff #187590)

Why Optional?

[aganea]

COFF/InputFiles.cpp

621 ↗

(On Diff #187590)

There's a typo here - it shall read be continue; instead of return;.

COFF/InputFiles.h

163 ↗

(On Diff #187590)

It's a reliquate. Fixed.
I'll also change it for PCHSignature above in a subsequent NFC patch.

[aganea]

COFF/InputFiles.cpp

621 ↗

(On Diff #187590)

Sorry never mind, this was meant for the previous revision. Fixed now.

[rnk]

Neat!

COFF/Driver.h

160 ↗

(On Diff #187618)

Maybe parseFunctionPadMin to help readability? Initially I parsed it as "/function p admin", but I don't think that's right.

test/COFF/functionpadmin.test

7 ↗

(On Diff #187618)

Why objdump -s instead of objdump -d to look at the disassembly? Maybe the idea is that part of the test is to show that .rdata sections and .pdata sections are not padded with 0xCC? I guess that's good.

[aganea]

test/COFF/functionpadmin.test

7 ↗

(On Diff #187618)

Yes that was part of Peter's suggestion for testing: ensure only code sections were padded.

[aganea]

Sorry for all the updates. Fixed typo in COFF/InputFiles.h.

[rnk]

lgtm

[ruiu]

COFF/Chunks.h

218 ↗

(On Diff #187645)

LLVM coding standard recommends you omit virtual if override is given.

COFF/InputFiles.cpp

608 ↗

(On Diff #187645)

It needs a function comment.

COFF/InputFiles.h

148 ↗

(On Diff #187645)

Looks like you can directly use HotPatchable instead of this function, and you can remove this function.

[aganea]

COFF/InputFiles.cpp

608 ↗

(On Diff #187645)

Let me know if you wish to rephrase this in a different manner.

[aganea]

@ruiu Is this good to go? Any other changes you see?

[ruiu]

COFF/Chunks.cpp

609 ↗

(On Diff #187683)

too short. -> too short:.

609–621 ↗

(On Diff #187683)

Error messages should start with lowercase letter.

612 ↗

(On Diff #187683)

. -> :

617–618 ↗

(On Diff #187683)

Ditto

619–620 ↗

(On Diff #187683)

else } if -> else if

COFF/Driver.cpp

1387–1390 ↗

(On Diff #187683)

This place does not seem like a right place to add this code. We parse command line arguments much earlier.

COFF/InputFiles.cpp

602 ↗

(On Diff #187683)

nit: omit {}

608 ↗

(On Diff #187683)

Can you mention that this function initializes PCHSignature and HotPatchable by reading .debug$S seciton?

COFF/Options.td

35 ↗

(On Diff #187683)

Newline before HelpText just like other definitions.

test/COFF/functionpadmin.test

1 ↗

(On Diff #187683)

Blank line?

[aganea]

COFF/Driver.cpp

1387–1390 ↗

(On Diff #187683)

We need Config->Machine to be set before parsing /FUNCTIONPADMIN. In some cases this is extracted from inputs, run() a few lines above.

[ruiu]

LGTM

COFF/Driver.cpp

1387–1390 ↗

(On Diff #187683)

Ah, you are right. Thank you for clarifying.

COFF/Options.td

35 ↗

(On Diff #187683)

You can use P just like above, can't you?

[aganea]

COFF/Options.td

35 ↗

(On Diff #187683)

Yes, and that displays properly the help page, such as /functionpadmin:<value> instead of previous /functionpadmin<value>. Thank you for taking the time to review this!

lld/trunk/COFF/Chunks.h

public:
 
   // Returns a human-readable name of this chunk. Chunks are unnamed chunks of
   // bytes, so this is used only for logging or debugging.
   virtual StringRef getDebugName() { return ""; }
 
   // The alignment of this chunk. The writer uses the value.
   uint32_t Alignment = 1;
 
+  virtual bool isHotPatchable() const { return false; }
+
 protected:
   Chunk(Kind K = OtherKind) : ChunkKind(K) {}
   const Kind ChunkKind;
 
   // The RVA of this chunk in the output. The writer sets a value.
   uint64_t RVA = 0;
 
   // The output section for this chunk.
public:
   }
 
   // Allow iteration over the associated child chunks for this section.
   ArrayRef<SectionChunk *> children() const { return AssocChildren; }
 
   // The section ID this chunk belongs to in its Obj.
   uint32_t getSectionNumber() const;
 
+  ArrayRef<uint8_t> consumeDebugMagic();
+
+  static ArrayRef<uint8_t> consumeDebugMagic(ArrayRef<uint8_t> Data,
+                                             StringRef SectionName);
+
+  static SectionChunk *findByName(ArrayRef<SectionChunk *> Sections,
+                                  StringRef Name);
+
+  bool isHotPatchable() const override { return File->HotPatchable; }
+
   // A pointer pointing to a replacement for this chunk.
   // Initially it points to "this" object. If this chunk is merged
   // with other chunk by ICF, it points to another chunk,
   // and this chunk is considered as dead.
   SectionChunk *Repl;
 
   // The CRC of the contents as described in the COFF spec 4.5.5.
   // Auxiliary Format 5: Section Definitions. Used for ICF.

 // A chunk for DLL import jump table entry. In a final output, its
 // contents will be a JMP instruction to some __imp_ symbol.
 class ImportThunkChunkX64 : public Chunk {
 public:
   explicit ImportThunkChunkX64(Defined *S);
   size_t getSize() const override { return sizeof(ImportThunkX86); }
   void writeTo(uint8_t *Buf) const override;
 
+  bool isHotPatchable() const override { return true; }
+
 private:
   Defined *ImpSymbol;
 };
 
 class ImportThunkChunkX86 : public Chunk {
 public:
   explicit ImportThunkChunkX86(Defined *S) : ImpSymbol(S) {}
   size_t getSize() const override { return sizeof(ImportThunkX86); }
   void getBaserels(std::vector<Baserel> *Res) override;
   void writeTo(uint8_t *Buf) const override;
 
+  bool isHotPatchable() const override { return true; }
+
 private:
   Defined *ImpSymbol;
 };
 
 class ImportThunkChunkARM : public Chunk {
 public:
   explicit ImportThunkChunkARM(Defined *S) : ImpSymbol(S) {}
   size_t getSize() const override { return sizeof(ImportThunkARM); }
   void getBaserels(std::vector<Baserel> *Res) override;
   void writeTo(uint8_t *Buf) const override;
 
+  bool isHotPatchable() const override { return true; }
+
 private:
   Defined *ImpSymbol;
 };
 
 class ImportThunkChunkARM64 : public Chunk {
 public:
   explicit ImportThunkChunkARM64(Defined *S) : ImpSymbol(S) {}
   size_t getSize() const override { return sizeof(ImportThunkARM64); }
   void writeTo(uint8_t *Buf) const override;
 
+  bool isHotPatchable() const override { return true; }
+
 private:
   Defined *ImpSymbol;
 };
 
 class RangeExtensionThunkARM : public Chunk {
 public:
   explicit RangeExtensionThunkARM(Defined *T) : Target(T) {}
   size_t getSize() const override;

lld/trunk/COFF/Chunks.cpp

 }
 
 ArrayRef<uint8_t> SectionChunk::getContents() const {
   ArrayRef<uint8_t> A;
   File->getCOFFObj()->getSectionContents(Header, A);
   return A;
 }
 
+ArrayRef<uint8_t> SectionChunk::consumeDebugMagic() {
+  assert(isCodeView());
+  return consumeDebugMagic(getContents(), SectionName);
+}
+
+ArrayRef<uint8_t> SectionChunk::consumeDebugMagic(ArrayRef<uint8_t> Data,
+                                                  StringRef SectionName) {
+  if (Data.empty())
+    return {};
+
+  // First 4 bytes are section magic.
+  if (Data.size() < 4)
+    fatal("the section is too short: " + SectionName);
+
+  if (!SectionName.startswith(".debug$"))
+    fatal("invalid section: " + SectionName);
+
+  unsigned Magic = support::endian::read32le(Data.data());
+  unsigned ExpectedMagic = SectionName == ".debug$H"
+                               ? DEBUG_HASHES_SECTION_MAGIC
+                               : DEBUG_SECTION_MAGIC;
+  if (Magic != ExpectedMagic)
+    fatal("section: " + SectionName + " has an invalid magic: " + Twine(Magic));
+  return Data.slice(4);
+}
+
+SectionChunk *SectionChunk::findByName(ArrayRef<SectionChunk *> Sections,
+                                       StringRef Name) {
+  for (SectionChunk *C : Sections)
+    if (C->getSectionName() == Name)
+      return C;
+  return nullptr;
+}
+
 void SectionChunk::replace(SectionChunk *Other) {
   Alignment = std::max(Alignment, Other->Alignment);
   Other->Repl = Repl;
   Other->Live = false;
 }
 
 uint32_t SectionChunk::getSectionNumber() const {
   DataRefImpl R;

lld/trunk/COFF/Config.h

struct Configuration {
   uint64_t StackCommit = 4096;
   uint64_t HeapReserve = 1024 * 1024;
   uint64_t HeapCommit = 4096;
   uint32_t MajorImageVersion = 0;
   uint32_t MinorImageVersion = 0;
   uint32_t MajorOSVersion = 6;
   uint32_t MinorOSVersion = 0;
   uint32_t Timestamp = 0;
+  uint32_t FunctionPadMin = 0;
   bool DynamicBase = true;
   bool AllowBind = true;
   bool NxCompat = true;
   bool AllowIsolation = true;
   bool TerminalServerAware = true;
   bool LargeAddressAware = false;
   bool HighEntropyVA = false;
   bool AppContainer = false;

lld/trunk/COFF/Driver.h

 void parseSubsystem(StringRef Arg, WindowsSubsystem *Sys, uint32_t *Major,
                     uint32_t *Minor);
 
 void parseAlternateName(StringRef);
 void parseMerge(StringRef);
 void parseSection(StringRef);
 void parseAligncomm(StringRef);
 
+// Parses a string in the form of "[:<integer>]"
+void parseFunctionPadMin(llvm::opt::Arg *A, llvm::COFF::MachineTypes Machine);
+
 // Parses a string in the form of "EMBED[,=<integer>]|NO".
 void parseManifest(StringRef Arg);
 
 // Parses a string in the form of "level=<string>|uiAccess=<string>"
 void parseManifestUAC(StringRef Arg);
 
 // Create a resource file containing a manifest XML.
 std::unique_ptr<MemoryBuffer> createManifestRes();

lld/trunk/COFF/Driver.cpp

void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
   // We should have inferred a machine type by now from the input files, but if
   // not we assume x64.
   if (Config->Machine == IMAGE_FILE_MACHINE_UNKNOWN) {
     warn("/machine is not specified. x64 is assumed");
     Config->Machine = AMD64;
   }
   Config->Wordsize = Config->is64() ? 8 : 4;
 
+  // Handle /functionpadmin
+  for (auto *Arg : Args.filtered(OPT_functionpadmin, OPT_functionpadmin_opt))
+    parseFunctionPadMin(Arg, Config->Machine);
+
   // Input files can be Windows resource files (.res files). We use
   // WindowsResource to convert resource files to a regular COFF file,
   // then link the resulting file normally.
   if (!Resources.empty())
     Symtab->addFile(make<ObjFile>(convertResToCOFF(Resources)));
 
   if (Tar)
     Tar->append("response.txt",

lld/trunk/COFF/DriverUtils.cpp

void parseAligncomm(StringRef S) {
   int V;
   if (Align.getAsInteger(0, V)) {
     error("/aligncomm: invalid argument: " + S);
     return;
   }
   Config->AlignComm[Name] = std::max(Config->AlignComm[Name], 1 << V);
 }
 
+// Parses /functionpadmin option argument.
+void parseFunctionPadMin(llvm::opt::Arg *A, llvm::COFF::MachineTypes Machine) {
+  StringRef Arg = A->getNumValues() ? A->getValue() : "";
+  if (!Arg.empty()) {
+    // Optional padding in bytes is given.
+    if (Arg.getAsInteger(0, Config->FunctionPadMin))
+      error("/functionpadmin: invalid argument: " + Arg);
+    return;
+  }
+  // No optional argument given.
+  // Set default padding based on machine, similar to link.exe.
+  // There is no default padding for ARM platforms.
+  if (Machine == I386) {
+    Config->FunctionPadMin = 5;
+  } else if (Machine == AMD64) {
+    Config->FunctionPadMin = 6;
+  } else {
+    error("/functionpadmin: invalid argument for this machine: " + Arg);
+  }
+}
+
 // Parses a string in the form of "EMBED[,=<integer>]|NO".
 // Results are directly written to Config.
 void parseManifest(StringRef Arg) {
   if (Arg.equals_lower("no")) {
     Config->Manifest = Configuration::No;
     return;
   }
   if (!Arg.startswith_lower("embed"))

lld/trunk/COFF/InputFiles.h

public:
   MachineTypes getMachineType() override;
   ArrayRef<Chunk *> getChunks() { return Chunks; }
   ArrayRef<SectionChunk *> getDebugChunks() { return DebugChunks; }
   ArrayRef<SectionChunk *> getSXDataChunks() { return SXDataChunks; }
   ArrayRef<SectionChunk *> getGuardFidChunks() { return GuardFidChunks; }
   ArrayRef<SectionChunk *> getGuardLJmpChunks() { return GuardLJmpChunks; }
   ArrayRef<Symbol *> getSymbols() { return Symbols; }
 
+  ArrayRef<uint8_t> getDebugSection(StringRef SecName);
+
   // Returns a Symbol object for the SymbolIndex'th symbol in the
   // underlying object file.
   Symbol *getSymbol(uint32_t SymbolIndex) {
     return Symbols[SymbolIndex];
   }
 
   // Returns the underlying COFF file.
   COFFObjectFile *getCOFFObj() { return COFFObj.get(); }
public:
 
   const coff_section *AddrsigSec = nullptr;
 
   // When using Microsoft precompiled headers, this is the PCH's key.
   // The same key is used by both the precompiled object, and objects using the
   // precompiled object. Any difference indicates out-of-date objects.
   llvm::Optional<uint32_t> PCHSignature;
 
+  // Tells whether this file was compiled with /hotpatch
+  bool HotPatchable = false;
+
 private:
   const coff_section* getSection(uint32_t I);
   const coff_section *getSection(COFFSymbolRef Sym) {
     return getSection(Sym.getSectionNumber());
   }
 
   void initializeChunks();
   void initializeSymbols();
+  void initializeFlags();
 
   SectionChunk *
   readSection(uint32_t SectionNumber,
               const llvm::object::coff_aux_section_definition *Def,
               StringRef LeaderName);
 
   void readAssociativeDefinition(
       COFFSymbolRef COFFSym,

lld/trunk/COFF/InputFiles.cpp

 #include "Symbols.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "llvm-c/lto.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/BinaryFormat/COFF.h"
+#include "llvm/DebugInfo/CodeView/DebugSubsectionRecord.h"
+#include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
+#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/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/Support/Path.h"
 #include "llvm/Target/TargetOptions.h"
 #include <cstring>
 #include <system_error>
 #include <utility>
 
 using namespace llvm;
 using namespace llvm::COFF;
+using namespace llvm::codeview;
 using namespace llvm::object;
 using namespace llvm::support::endian;
 
 using llvm::Triple;
 using llvm::support::ulittle32_t;
 
 namespace lld {
 namespace coff {
if (auto *Obj = dyn_cast<COFFObjectFile>(Bin.get())) {
     COFFObj.reset(Obj);
   } else {
     fatal(toString(this) + " is not a COFF file");
   }
 
   // Read section and symbol tables.
   initializeChunks();
   initializeSymbols();
+  initializeFlags();
 }
 
 const coff_section* ObjFile::getSection(uint32_t I) {
   const coff_section *Sec;
   if (auto EC = COFFObj->getSection(I, Sec))
     fatal("getSection failed: #" + Twine(I) + ": " + EC.message());
   return Sec;
 }

 }
 
 MachineTypes ObjFile::getMachineType() {
   if (COFFObj)
     return static_cast<MachineTypes>(COFFObj->getMachine());
   return IMAGE_FILE_MACHINE_UNKNOWN;
 }
 
+ArrayRef<uint8_t> ObjFile::getDebugSection(StringRef SecName) {
+  if (SectionChunk *Sec = SectionChunk::findByName(DebugChunks, SecName))
+    return Sec->consumeDebugMagic();
+  return {};
+}
+
+// OBJ files systematically store critical informations in a .debug$S stream,
+// even if the TU was compiled with no debug info. At least two records are
+// always there. S_OBJNAME stores a 32-bit signature, which is loaded into the
+// PCHSignature member. S_COMPILE3 stores compile-time cmd-line flags. This is
+// currently used to initialize the HotPatchable member.
+void ObjFile::initializeFlags() {
+  ArrayRef<uint8_t> Data = getDebugSection(".debug$S");
+  if (Data.empty())
+    return;
+
+  DebugSubsectionArray Subsections;
+
+  BinaryStreamReader Reader(Data, support::little);
+  ExitOnError ExitOnErr;
+  ExitOnErr(Reader.readArray(Subsections, Data.size()));
+
+  for (const DebugSubsectionRecord &SS : Subsections) {
+    if (SS.kind() != DebugSubsectionKind::Symbols)
+      continue;
+
+    unsigned Offset = 0;
+
+    // Only parse the first two records. We are only looking for S_OBJNAME
+    // and S_COMPILE3, and they usually appear at the beginning of the
+    // stream.
+    for (unsigned I = 0; I < 2; ++I) {
+      Expected<CVSymbol> Sym = readSymbolFromStream(SS.getRecordData(), Offset);
+      if (!Sym) {
+        consumeError(Sym.takeError());
+        return;
+      }
+      if (Sym->kind() == SymbolKind::S_COMPILE3) {
+        auto CS =
+            cantFail(SymbolDeserializer::deserializeAs<Compile3Sym>(Sym.get()));
+        HotPatchable =
+            (CS.Flags & CompileSym3Flags::HotPatch) != CompileSym3Flags::None;
+      }
+      if (Sym->kind() == SymbolKind::S_OBJNAME) {
+        auto ObjName = cantFail(SymbolDeserializer::deserializeAs<ObjNameSym>(
+            Sym.get()));
+        PCHSignature = ObjName.Signature;
+      }
+      Offset += Sym->length();
+    }
+  }
+}
+
 StringRef ltrim1(StringRef S, const char *Chars) {
   if (!S.empty() && strchr(Chars, S[0]))
     return S.substr(1);
   return S;
 }
 
 void ImportFile::parse() {
   const char *Buf = MB.getBufferStart();

lld/trunk/COFF/Options.td

 def defaultlib : P<"defaultlib", "Add the library to the list of input files">;
 def delayload : P<"delayload", "Delay loaded DLL name">;
 def entry   : P<"entry", "Name of entry point symbol">;
 def errorlimit : P<"errorlimit",
     "Maximum number of errors to emit before stopping (0 = no limit)">;
 def export  : P<"export", "Export a function">;
 // No help text because /failifmismatch is not intended to be used by the user.
 def failifmismatch : P<"failifmismatch", "">;
+def functionpadmin : F<"functionpadmin">;
+def functionpadmin_opt : P<"functionpadmin", "Prepares an image for hotpatching">;
 def guard   : P<"guard", "Control flow guard">;
 def heap    : P<"heap", "Size of the heap">;
 def ignore : P<"ignore", "Specify warning codes to ignore">;
 def implib  : P<"implib", "Import library name">;
 def lib : F<"lib">,
     HelpText<"Act like lib.exe; must be first argument if present">;
 def libpath : P<"libpath", "Additional library search path">;
 def linkrepro : P<"linkrepro", "Dump linker invocation and input files for debugging">;

 
 class QF<string name> : Joined<["/", "-", "-?"], name#":">;
 
 multiclass QB<string name> {
   def "" : F<name>;
   def _no : F<name#":no">;
 }
 
-def functionpadmin : F<"functionpadmin">;
 def ignoreidl : F<"ignoreidl">;
 def nologo : F<"nologo">;
 def throwingnew : F<"throwingnew">;
 def editandcontinue : F<"editandcontinue">;
 def fastfail : F<"fastfail">;
 
 def delay : QF<"delay">;
 def errorreport : QF<"errorreport">;
 def idlout : QF<"idlout">;
 def maxilksize : QF<"maxilksize">;
 def tlbid : QF<"tlbid">;
 def tlbout : QF<"tlbout">;
 def verbose_all : QF<"verbose">;
 def guardsym : QF<"guardsym">;

lld/trunk/COFF/PDB.cpp

sys::path::Style GuessedStyle = AbsoluteFileName.startswith("/")
                                       : sys::path::Style::windows;
   sys::path::append(AbsoluteFileName, GuessedStyle, FileName);
   sys::path::native(AbsoluteFileName, GuessedStyle);
   sys::path::remove_dots(AbsoluteFileName, true, GuessedStyle);
 
   FileName = std::move(AbsoluteFileName);
 }
 
-static SectionChunk *findByName(ArrayRef<SectionChunk *> Sections,
-                                StringRef Name) {
-  for (SectionChunk *C : Sections)
-    if (C->getSectionName() == Name)
-      return C;
-  return nullptr;
-}
-
-static ArrayRef<uint8_t> consumeDebugMagic(ArrayRef<uint8_t> Data,
-                                           StringRef SecName) {
-  // First 4 bytes are section magic.
-  if (Data.size() < 4)
-    fatal(SecName + " too short");
-  if (support::endian::read32le(Data.data()) != COFF::DEBUG_SECTION_MAGIC)
-    fatal(SecName + " has an invalid magic");
-  return Data.slice(4);
-}
-
-static ArrayRef<uint8_t> getDebugSection(ObjFile *File, StringRef SecName) {
-  if (SectionChunk *Sec = findByName(File->getDebugChunks(), SecName))
-    return consumeDebugMagic(Sec->getContents(), SecName);
-  return {};
-}
-
 // A COFF .debug$H section is currently a clang extension.  This function checks
 // if a .debug$H section is in a format that we expect / understand, so that we
 // can ignore any sections which are coincidentally also named .debug$H but do
 // not contain a format we recognize.
 static bool canUseDebugH(ArrayRef<uint8_t> DebugH) {
   if (DebugH.size() < sizeof(object::debug_h_header))
     return false;
   auto *Header =
       reinterpret_cast<const object::debug_h_header *>(DebugH.data());
   DebugH = DebugH.drop_front(sizeof(object::debug_h_header));
   return Header->Magic == COFF::DEBUG_HASHES_SECTION_MAGIC &&
          Header->Version == 0 &&
          Header->HashAlgorithm == uint16_t(GlobalTypeHashAlg::SHA1_8) &&
          (DebugH.size() % 8 == 0);
 }
 
 static Optional<ArrayRef<uint8_t>> getDebugH(ObjFile *File) {
-  SectionChunk *Sec = findByName(File->getDebugChunks(), ".debug$H");
+  SectionChunk *Sec =
+      SectionChunk::findByName(File->getDebugChunks(), ".debug$H");
   if (!Sec)
     return llvm::None;
   ArrayRef<uint8_t> Contents = Sec->getContents();
   if (!canUseDebugH(Contents))
     return None;
   return Contents;
 }
 
static void addTypeInfo(pdb::TpiStreamBuilder &TpiBuilder,
   TypeTable.ForEachRecord([&](TypeIndex TI, const CVType &Type) {
     auto Hash = pdb::hashTypeRecord(Type);
     if (auto E = Hash.takeError())
       fatal("type hashing error");
     TpiBuilder.addTypeRecord(Type.RecordData, *Hash);
   });
 }
 
-// OBJs usually start their symbol stream with a S_OBJNAME record. This record
-// also contains the signature/key of the current PCH session. The signature
-// must be same for all objects which depend on the precompiled object.
-// Recompiling the precompiled headers will generate a new PCH key and thus
-// invalidate all the dependent objects.
-static uint32_t extractPCHSignature(ObjFile *File) {
-  auto DbgIt = find_if(File->getDebugChunks(), [](SectionChunk *C) {
-    return C->getSectionName() == ".debug$S";
-  });
-  if (!DbgIt)
-    return 0;
-
-  ArrayRef<uint8_t> Contents =
-      consumeDebugMagic((*DbgIt)->getContents(), ".debug$S");
-  DebugSubsectionArray Subsections;
-  BinaryStreamReader Reader(Contents, support::little);
-  ExitOnErr(Reader.readArray(Subsections, Contents.size()));
-
-  for (const DebugSubsectionRecord &SS : Subsections) {
-    if (SS.kind() != DebugSubsectionKind::Symbols)
-      continue;
-
-    // If it's there, the S_OBJNAME record shall come first in the stream.
-    Expected<CVSymbol> Sym = readSymbolFromStream(SS.getRecordData(), 0);
-    if (!Sym) {
-      consumeError(Sym.takeError());
-      continue;
-    }
-    if (auto ObjName = SymbolDeserializer::deserializeAs<ObjNameSym>(Sym.get()))
-      return ObjName->Signature;
-  }
-  return 0;
-}
-
 Expected<const CVIndexMap &>
 PDBLinker::mergeDebugT(ObjFile *File, CVIndexMap *ObjectIndexMap) {
   ScopedTimer T(TypeMergingTimer);
 
   bool IsPrecompiledHeader = false;
 
-  ArrayRef<uint8_t> Data = getDebugSection(File, ".debug$T");
+  ArrayRef<uint8_t> Data = File->getDebugSection(".debug$T");
   if (Data.empty()) {
     // Try again, Microsoft precompiled headers use .debug$P instead of
     // .debug$T
-    Data = getDebugSection(File, ".debug$P");
+    Data = File->getDebugSection(".debug$P");
     IsPrecompiledHeader = true;
   }
   if (Data.empty())
     return *ObjectIndexMap; // no debug info
 
   // Precompiled headers objects need to save the index map for further
   // reference by other objects which use the precompiled headers.
   if (IsPrecompiledHeader) {
-    uint32_t PCHSignature = extractPCHSignature(File);
+    uint32_t PCHSignature = File->PCHSignature.getValueOr(0);
     if (PCHSignature == 0)
       fatal("No signature found for the precompiled headers OBJ (" +
             File->getName() + ")");
 
     // When a precompiled headers object comes first on the command-line, we
     // update the mapping here. Otherwise, if an object referencing the
     // precompiled headers object comes first, the mapping is created in
     // aquirePrecompObj(), thus we would skip this block.
translateStringTableIndex(uint32_t ObjIndex,
   }
 
   return PdbStrTable.insert(*ExpectedString);
 }
 
 void DebugSHandler::handleDebugS(lld::coff::SectionChunk &DebugS) {
   DebugSubsectionArray Subsections;
 
-  ArrayRef<uint8_t> RelocatedDebugContents = consumeDebugMagic(
+  ArrayRef<uint8_t> RelocatedDebugContents = SectionChunk::consumeDebugMagic(
       relocateDebugChunk(Linker.Alloc, DebugS), DebugS.getSectionName());
 
   BinaryStreamReader Reader(RelocatedDebugContents, support::little);
   ExitOnErr(Reader.readArray(Subsections, RelocatedDebugContents.size()));
 
   for (const DebugSubsectionRecord &SS : Subsections) {
     switch (SS.kind()) {
     case DebugSubsectionKind::StringTable: {
for (const coff_relocation &R : DbgC->Relocs) {
 
       if (auto *S = dyn_cast_or_null<DefinedRegular>(
               C->File->getSymbols()[R.SymbolTableIndex]))
         if (S->getChunk() == C)
           Secrels[R.VirtualAddress] = S->getValue();
     }
 
     ArrayRef<uint8_t> Contents =
-        consumeDebugMagic(DbgC->getContents(), ".debug$S");
+        SectionChunk::consumeDebugMagic(DbgC->getContents(), ".debug$S");
     DebugSubsectionArray Subsections;
     BinaryStreamReader Reader(Contents, support::little);
     ExitOnErr(Reader.readArray(Subsections, Contents.size()));
 
     for (const DebugSubsectionRecord &SS : Subsections) {
       switch (SS.kind()) {
       case DebugSubsectionKind::StringTable: {
         assert(!CVStrTab.valid() &&

lld/trunk/COFF/Writer.cpp

void Writer::assignAddresses() {
   uint64_t RVA = PageSize; // The first page is kept unmapped.
   FileSize = SizeOfHeaders;
 
   for (OutputSection *Sec : OutputSections) {
     if (Sec == RelocSec)
       addBaserels();
     uint64_t RawSize = 0, VirtualSize = 0;
     Sec->Header.VirtualAddress = RVA;
+
+    // If /FUNCTIONPADMIN is used, functions are padded in order to create a
+    // hotpatchable image.
+    const bool IsCodeSection =
+        (Sec->Header.Characteristics & IMAGE_SCN_CNT_CODE) &&
+        (Sec->Header.Characteristics & IMAGE_SCN_MEM_READ) &&
+        (Sec->Header.Characteristics & IMAGE_SCN_MEM_EXECUTE);
+    uint32_t Padding = IsCodeSection ? Config->FunctionPadMin : 0;
+
     for (Chunk *C : Sec->Chunks) {
+      if (Padding && C->isHotPatchable())
+        VirtualSize += Padding;
       VirtualSize = alignTo(VirtualSize, C->Alignment);
       C->setRVA(RVA + VirtualSize);
       C->OutputSectionOff = VirtualSize;
       C->finalizeContents();
       VirtualSize += C->getSize();
       if (C->hasData())
         RawSize = alignTo(VirtualSize, SectorSize);
     }

lld/trunk/test/COFF/functionpadmin.test

+// ---- precomp-a.obj - x86_64, hotpatch
+RUN: lld-link %S/Inputs/precomp-a.obj /out:%t.exe /nodefaultlib /force
+RUN: llvm-objdump -s %t.exe | FileCheck %s --check-prefix BASE
+
+RUN: lld-link %S/Inputs/precomp-a.obj /out:%t.exe /nodefaultlib /force /functionpadmin
+RUN: llvm-objdump -s %t.exe | FileCheck %s --check-prefix PADDED
+
+RUN: lld-link %S/Inputs/precomp-a.obj /out:%t.exe /nodefaultlib /force /functionpadmin:17
+RUN: llvm-objdump -s %t.exe | FileCheck %s --check-prefix PADDED-MORE
+
+// ---- Many arguments
+RUN: lld-link %S/Inputs/precomp-a.obj /out:%t.exe /nodefaultlib /force /functionpadmin:17 /functionpadmin
+RUN: llvm-objdump -s %t.exe | FileCheck %s --check-prefix PADDED
+
+RUN: lld-link %S/Inputs/precomp-a.obj /out:%t.exe /nodefaultlib /force /functionpadmin /functionpadmin:17
+RUN: llvm-objdump -s %t.exe | FileCheck %s --check-prefix PADDED-MORE
+
+RUN: not lld-link %S/Inputs/precomp-a.obj /out:%t.exe /nodefaultlib /force /functionpadmin:zz 2>&1 | FileCheck %s --check-prefix FAIL
+
+// ---- precomp-a.obj, precomp-b.obj - x86_64, hotpatch - Ensure several functions are properly padded
+RUN: lld-link %S/Inputs/precomp-a.obj %S/Inputs/precomp-b.obj %S/Inputs/precomp.obj /out:%t.exe /nodefaultlib /force
+RUN: llvm-objdump -s %t.exe | FileCheck %s --check-prefix MULTI-BASE
+
+RUN: lld-link %S/Inputs/precomp-a.obj %S/Inputs/precomp-b.obj %S/Inputs/precomp.obj /out:%t.exe /nodefaultlib /force /functionpadmin
+RUN: llvm-objdump -s %t.exe | FileCheck %s --check-prefix MULTI-BASE-PADDED
+
+RUN: lld-link %S/Inputs/precomp-a.obj %S/Inputs/precomp-b.obj %S/Inputs/precomp.obj /out:%t.exe /nodefaultlib /force /functionpadmin:17
+RUN: llvm-objdump -s %t.exe | FileCheck %s --check-prefix MULTI-BASE-PADDED-MORE
+
+// ---- pdb-diff.obj - x86, no hotpatch - No padding is applied
+RUN: lld-link %S/Inputs/pdb-diff.obj /out:%t.exe /nodefaultlib /force /functionpadmin
+RUN: llvm-objdump -s %t.exe | FileCheck %s --check-prefix NO-HOTPATCH
+
+// ---- hello64.obj - MASM, x86_64, no hotpatch - No padding is applied
+RUN: lld-link %S/Inputs/hello64.obj /out:%t.exe /nodefaultlib /force /functionpadmin
+RUN: llvm-objdump -s %t.exe | FileCheck %s --check-prefix HELLO
+
+// ---- std64.lib - Import library, x86_64 - Ensure thunks are padded
+RUN: lld-link %S/Inputs/std64.lib /entry:ExitProcess /out:%t.exe /nodefaultlib /force /subsystem:console
+RUN: llvm-objdump -s %t.exe | FileCheck %s --check-prefix THUNKS-NO-PAD
+RUN: llvm-readobj --file-headers %t.exe | FileCheck %s --check-prefix THUNKS-NO-PAD-ENTRY
+
+RUN: lld-link %S/Inputs/std64.lib /entry:ExitProcess /out:%t.exe /nodefaultlib /force /functionpadmin /subsystem:console
+RUN: llvm-objdump -s %t.exe | FileCheck %s --check-prefix THUNKS-PAD
+RUN: llvm-readobj --file-headers %t.exe | FileCheck %s --check-prefix THUNKS-PAD-ENTRY
+
+BASE: Contents of section .text:
+BASE-NEXT:  140001000 4883ec28 b161e8f5 efffbf33 c04883c4  H..(.a.....3.H..
+BASE-NEXT:  140001010 28c3                                 (.
+BASE-NEXT: Contents of section .rdata:
+BASE-NEXT:  140002000 01040100 04420000                    .....B..
+BASE-NEXT: Contents of section .pdata:
+BASE-NEXT:  140003000 00100000 12100000 00200000           ......... ..
+
+PADDED: Contents of section .text:
+PADDED-NEXT:  140001000 cccccccc cccccccc cccccccc cccccccc  ................
+PADDED-NEXT:  140001010 4883ec28 b161e8e5 efffbf33 c04883c4  H..(.a.....3.H..
+PADDED-NEXT:  140001020 28c3                                 (.
+PADDED-NEXT: Contents of section .rdata:
+PADDED-NEXT:  140002000 01040100 04420000                    .....B..
+PADDED-NEXT: Contents of section .pdata:
+PADDED-NEXT:  140003000 10100000 22100000 00200000           ....".... ..
+
+PADDED-MORE: Contents of section .text:
+PADDED-MORE-NEXT:  140001000 cccccccc cccccccc cccccccc cccccccc  ................
+PADDED-MORE-NEXT:  140001010 cccccccc cccccccc cccccccc cccccccc  ................
+PADDED-MORE-NEXT:  140001020 4883ec28 b161e8d5 efffbf33 c04883c4  H..(.a.....3.H..
+PADDED-MORE-NEXT:  140001030 28c3                                 (.
+PADDED-MORE-NEXT: Contents of section .rdata:
+PADDED-MORE-NEXT:  140002000 01040100 04420000                    .....B..
+PADDED-MORE-NEXT: Contents of section .pdata:
+PADDED-MORE-NEXT:  140003000 20100000 32100000 00200000            ...2.... ..
+
+FAIL: lld-link: error: /functionpadmin: invalid argument: zz
+
+MULTI-BASE: Contents of section .text:
+MULTI-BASE-NEXT:  140001000 4883ec28 b161e815 00000033 c04883c4  H..(.a.....3.H..
+MULTI-BASE-NEXT:  140001010 28c3cccc cccccccc cccccccc cccccccc  (...............
+MULTI-BASE-NEXT:  140001020 884c2408 0fbe4424 08c3               .L$...D$..
+MULTI-BASE-NEXT: Contents of section .rdata:
+MULTI-BASE-NEXT:  140002000 01040100 04420000                    .....B..
+MULTI-BASE-NEXT: Contents of section .pdata:
+MULTI-BASE-NEXT:  140004000 00100000 12100000 00200000           ......... ..
+
+MULTI-BASE-PADDED: Contents of section .text:
+MULTI-BASE-PADDED-NEXT:  140001000 cccccccc cccccccc cccccccc cccccccc  ................
+MULTI-BASE-PADDED-NEXT:  140001010 4883ec28 b161e815 00000033 c04883c4  H..(.a.....3.H..
+MULTI-BASE-PADDED-NEXT:  140001020 28c3cccc cccccccc cccccccc cccccccc  (...............
+MULTI-BASE-PADDED-NEXT:  140001030 884c2408 0fbe4424 08c3               .L$...D$..
+MULTI-BASE-PADDED-NEXT: Contents of section .rdata:
+MULTI-BASE-PADDED-NEXT:  140002000 01040100 04420000                    .....B..
+MULTI-BASE-PADDED-NEXT: Contents of section .pdata:
+MULTI-BASE-PADDED-NEXT:  140004000 10100000 22100000 00200000           ....".... ..
+
+MULTI-BASE-PADDED-MORE: Contents of section .text:
+MULTI-BASE-PADDED-MORE-NEXT:  140001000 cccccccc cccccccc cccccccc cccccccc  ................
+MULTI-BASE-PADDED-MORE-NEXT:  140001010 cccccccc cccccccc cccccccc cccccccc  ................
+MULTI-BASE-PADDED-MORE-NEXT:  140001020 4883ec28 b161e825 00000033 c04883c4  H..(.a.%...3.H..
+MULTI-BASE-PADDED-MORE-NEXT:  140001030 28c3cccc cccccccc cccccccc cccccccc  (...............
+MULTI-BASE-PADDED-MORE-NEXT:  140001040 cccccccc cccccccc cccccccc cccccccc  ................
+MULTI-BASE-PADDED-MORE-NEXT:  140001050 884c2408 0fbe4424 08c3               .L$...D$..
+MULTI-BASE-PADDED-MORE-NEXT: Contents of section .rdata:
+MULTI-BASE-PADDED-MORE-NEXT:  140002000 01040100 04420000                    .....B..
+MULTI-BASE-PADDED-MORE-NEXT: Contents of section .pdata:
+MULTI-BASE-PADDED-MORE-NEXT:  140004000 20100000 32100000 00200000            ...2.... ..
+
+
+NO-HOTPATCH: Contents of section .text:
+NO-HOTPATCH-NEXT: 401000 558becb8 2a000000 5dc3               U...*...].
+
+HELLO: Contents of section .text:
+HELLO-NEXT:  140001000 4883ec28 48c7c100 00000048 8d15f40f  H..(H......H....
+HELLO-NEXT:  140001010 00004c8d 05e70f00 0041b900 000000e8  ..L......A......
+HELLO-NEXT:  140001020 dcefffbf b9000000 00e8d2ef ffbfe8cd  ................
+HELLO-NEXT:  140001030 efffbf                               ...
+HELLO-NEXT: Contents of section .data:
+HELLO-NEXT:  140002000 48656c6c 6f004865 6c6c6f20 576f726c  Hello.Hello Worl
+HELLO-NEXT:  140002010 642100                               d!.
+
+THUNKS-NO-PAD: Contents of section .text:
+THUNKS-NO-PAD-NEXT:  140001000 ff253210 0000                        .%2...
+THUNKS-NO-PAD-NEXT: Contents of section .rdata:
+THUNKS-NO-PAD-NEXT:  140002000 28200000 00000000 00000000 56200000  ( ..........V ..
+THUNKS-NO-PAD-NEXT:  140002010 38200000 00000000 00000000 00000000  8 ..............
+THUNKS-NO-PAD-NEXT:  140002020 00000000 00000000 48200000 00000000  ........H ......
+THUNKS-NO-PAD-NEXT:  140002030 00000000 00000000 48200000 00000000  ........H ......
+THUNKS-NO-PAD-NEXT:  140002040 00000000 00000000 00004578 69745072  ..........ExitPr
+THUNKS-NO-PAD-NEXT:  140002050 6f636573 73007374 6436342e 646c6c00  ocess.std64.dll.
+
+THUNKS-NO-PAD-ENTRY-LABEL: ImageOptionalHeader {
+THUNKS-NO-PAD-ENTRY:   AddressOfEntryPoint: 0x1000
+THUNKS-NO-PAD-ENTRY-NEXT:   BaseOfCode: 0x1000
+
+THUNKS-PAD: Contents of section .text:
+THUNKS-PAD-NEXT:  140001000 cccccccc cccccccc cccccccc cccccccc  ................
+THUNKS-PAD-NEXT:  140001010 ff252210 0000                        .%"...
+THUNKS-PAD-NEXT: Contents of section .rdata:
+THUNKS-PAD-NEXT:  140002000 28200000 00000000 00000000 56200000  ( ..........V ..
+THUNKS-PAD-NEXT:  140002010 38200000 00000000 00000000 00000000  8 ..............
+THUNKS-PAD-NEXT:  140002020 00000000 00000000 48200000 00000000  ........H ......
+THUNKS-PAD-NEXT:  140002030 00000000 00000000 48200000 00000000  ........H ......
+THUNKS-PAD-NEXT:  140002040 00000000 00000000 00004578 69745072  ..........ExitPr
+THUNKS-PAD-NEXT:  140002050 6f636573 73007374 6436342e 646c6c00  ocess.std64.dll.
+
+THUNKS-PAD-ENTRY-LABEL: ImageOptionalHeader {
+THUNKS-PAD-ENTRY:   AddressOfEntryPoint: 0x1010
+THUNKS-PAD-ENTRY-NEXT:   BaseOfCode: 0x1000