Preliminary support for dynamically loadable coff objects

[AndyAyers]

Summary

Provide basic support for dynamically loadable coff objects. Only handles a subset of x64 currently.

[chandlerc]

include/llvm/Support/COFF.h

5 ↗

(On Diff #20416)

Please don't modify the banner at the top.

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldCOFF.cpp

6

Same comment.

[chandlerc]

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldCOFF.h

6

Doh, and this one. Sorry. Meant to flag them all for you so they were easy to find.

[AndyAyers]

Should be just those 3 places.

Is there language anywhere under llvm.org that I can point to as a reference about this policy? I and some others looked and didn't see any.

[majnemer]

lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp

296–304

Your change is correct, it's a shame we can't just ask SectionRef::isBSS...

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldCOFF.cpp

188

Any reason you chose to include the RelocationTypeAMD64 scope qualifier?

232–234

Curly braces here aren't needed.

237–238

Could you remove the extra scope qualifiers? I think the enumeration value is pretty specific on its own.

262–263

This might be a little simpler as a range-based for loop.

266

Is it not possible for this to fail in practice?

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldCOFF.h

30

Any reason why you chose to make this different from ELF? They use Check.

47–62

Something tells me you aren't trying to support SystemZ ;)

I'd remove support for everything but the ARM and x86 variants.

lib/Object/COFFObjectFile.cpp

193–196

Good catch :)

372–374

What's the rationale for this change?

[chandlerc]

In D7793#127827, @AndyAyers wrote:

Should be just those 3 places.

Is there language anywhere under llvm.org that I can point to as a reference about this policy? I and some others looked and didn't see any.

http://llvm.org/docs/CodingStandards.html#file-headers

The more general policy for all contributions of course lives in http://llvm.org/docs/DeveloperPolicy.html

[AndyAyers]

Yeah, we'd seen those bits.

I'll relay that not marking up headers is the custom and get an update out soon.

Thanks.

[lhames]

Hi Andy,

Thanks very much for working on this. It looks great.

If you plan to support more architectures in the future you should consider moving the target specific code into a subclass (along the same lines as RuntimeDyldMachO). In my experience mixing the relocation handling code for multiple architectures was a debugging and maintenance headache - I ended up expending a lot of effort to untangle that code last year.

Could you also add some tests under llvm/test/ExecutionEngine/RuntimeDyld/ ?

Cheers,
Lang.

[AndyAyers]

Lang --

I'd be happy to add a test -- would checking in an object file be ok, or would you rather have the test input be an assembly file?

If the latter, I'll have to figure out how to express what I want in your assembly syntax.

I'll probably hold off refactoring for architecture unless you feel strongly we should do it now.

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldCOFF.cpp

188

Just force of habit... have trimmed this back.

237–238

Yep.

262–263

Made it so.

266

I don't think coff allows nameless sections, but added a Check here anyways.

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldCOFF.h

30

Thanks for reminding me about this. I had a name collision and just renamed it as a workaround.

I'll moved Check into RuntimeDyldImpl.h so that both ELF and COFF can share.

47–62

Yep. Thanks.

lib/Object/COFFObjectFile.cpp

372–374

I thought it better matched the intent of the comment in ObjectFile.h:

// A section is 'virtual' if its contents aren't present in the object image.

For coff this means the section has no raw data, regardless of section characteristics. In practice it probably doesn't matter so I'd be happy to revert this if you prefer.

[majnemer]

lib/Object/COFFObjectFile.cpp

372–374

Compiling char x[300]; as C++ with MSVC 2015 results in a .bss section with SizeOfRawData set to 0x12c.

The relevant text from the COFF spec is:

The size of the section (for object files) or the size of the initialized data on disk (for image files).

Heh, I guess my formulation of isSectionVirtual was more appropriate for object files while yours is better for executables.

[AndyAyers]

lib/Object/COFFObjectFile.cpp

372–374

Perhaps a better check is if PointerToRawData is zero, this should work in both obj and pe cases?

[majnemer]

lib/Object/COFFObjectFile.cpp

372–374

Yes, I think that would work perfectly.

[zturner]

lib/Object/COFFObjectFile.cpp

372–374

I'm following this from the sidelines as I don't know much in this area, but I think it would be good to have a comment summarizing the takeaway from this discussion at the point you add the check for PointerToRawData == 0

[lhames]

Hi Andy,

I'd be happy to add a test -- would checking in an object file be ok, or would you rather have the test input be an assembly file?

If the latter, I'll have to figure out how to express what I want in your assembly syntax.

I usually just take some IR that requires the relocations that I want to test, then run it through llc to get the assembly. Then you can add a few rtdyld-check lines to verify that the relocations are correctly applied.

The various *.s files under llvm/test/ExecutionEngine/RuntimeDyld/ should give you an idea of the rtdyld-check syntax, but if anything's unclear I'd be happy to help out.

I'll probably hold off refactoring for architecture unless you feel strongly we should do it now.

I have a strong preference for the refactor being done before this is committed. You don't have to go as far with the refactor as RuntimeDyldMachO does (i.e using the curiously recursive template idiom). You can just subclass RuntimeDyldCOFF and implement processRelocationRef, resolveRelocation and finalizeObject in the the RuntimeDyldCOFF_X86_64 subclass if you like.

[AndyAyers]

Ok, thanks. Will refactor to split out the architecture-specific bits.

On the testing front -- I started trying to load up one of our generated .objs via rtdyld and ran into some assumptions in the base loader code. In particular the object we generate has a zero-sized .data, and the loader code is a bit too eager to get at the contents of .bss. But our objs are kind of degenerate; I don't know if the intent is to have this code work with arbitrary objects or just the plausible ones you'd see from a compiler or assembler where zero-sized sections probably get squashed.

[AndyAyers]

This update should address all of the review feedback on the code. Still working on tests.

[majnemer]

lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldCOFFX86_64.cpp

133

Would report_fatal_error be more reasonable here?

142

Likewise, would it be nicer to report an error in release builds as well?

146–147

Please stick this curly brace after the colon.

167

Please stick the ampersand next to the variable name.

[zturner]

lib/ExecutionEngine/RuntimeDyld/CMakeLists.txt

8

Minor CMake style nit. The relationship between this folder and Targets is a little awkward (not because of your doing, seems historical). In any case, adding a file from a subfolder into this library can be strange to someone using an IDE because they will see RuntimeDyldCOFFX86_64.cpp in the same file list as the rest, even though it's in a different location on disk.

It might be a little better if "Targets" showed up as a folder in the IDE, with RuntimeDyldCOFFx86_64.cpp showing up under that folder. An example of the CMake needed to do this is in \lib\DebugInfo\PDB\CMakeLists.txt. It's only a couple of boiler plate lines.

[AndyAyers]

I've added this to CMakeLists.txt, but VS doesn't show things any differently. So not sure if I'm doing it wrong or other IDEs honor these groups....

macro(add_dyld_targets_folder group)
  list(APPEND DYLD_TARGETS_SOURCES ${ARGN})
  source_group(${group} FILES ${ARGN})
endmacro()

add_dyld_targets_folder(Targets
  Targets/RuntimeDyldCOFFX86_64.cpp
  )

add_llvm_library(LLVMRuntimeDyld
  RTDyldMemoryManager.cpp
  RuntimeDyld.cpp
  RuntimeDyldChecker.cpp
  RuntimeDyldCOFF.cpp
  RuntimeDyldELF.cpp
  RuntimeDyldMachO.cpp
  ${DYLD_TARGETS_SOURCES}
  )

[zturner]

I applied your patch. It shows up for me, but actually in this case your situation is different so I still end up with 3 folders Header Files, Source Files, and Targets. I'm not sure how (or even if) you can make it appear as a subfolder under Source Files. So feel free to ignore my suggestion now and revert that part of the commit, and leave it as it was before :)

Sorry for the noise.

[andrew.w.kaylor]

lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldCOFFX86_64.cpp

95

Shouldn't you be using Section.ObjAddress here?

133

I know we're doing this all over the existing code, but RuntimeDyld should really avoid fatal errors, including llvm_unreachable, as much as possible. With a static compiler it is kind of reasonable to bring down the program if a catastrophic error occurs, but RuntimeDyld really shouldn't do that.

I'm not suggesting that this problem needs to be addressed in this change set. I'm just bringing it up as a general concern that needs to be dealt with sooner or later.

[AndyAyers]

lib/ExecutionEngine/RuntimeDyld/CMakeLists.txt

8

Sounds like we're leaving this as is, per your investigation.

lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldCOFFX86_64.cpp

95

You should get the same result either way, but I agree the intent might be clearer if we read from the original object instead of its loaded copy.

However once we implement the rel forms (which I am ending up doing as part of adding test cases) we need to know the actual address of the location to fix up; then it seems simpler to use that address to fetch any possible target displacement too.

[andrew.w.kaylor]

lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldCOFFX86_64.cpp

95

One of issues that ObjAddress is meant to address, and I agree you don't have this problem the way you implemented things here, is that after the relocation has been applied once you no longer have access to to original placeholder value by way of the loaded object. If relocations are applied a second time the second pass can't rely on the loaded object having the correct placeholder value.

If I've got everything straight, your implementation here is grabbing the placeholder value and rolling it into the relocation entry, which is a decent solution. So using Section.Address instead of Section.ObjAddress is really only very technically incorrect. I would still advocate for the use of Section.ObjAddress for the sake of any future refactoring that is meant to address this class of behavior in some currently unanticipated way.

I know Lang wanted to do something to eliminate the need to keep the original object image around. Are the "rel forms" related to that? I don't think I'm familiar with that term. Whether yes or no, how will the rel forms address this issue?

[lhames]

Thanks very much for doing the refactor. This is looking great.

Are you still having trouble running rtdyld on your objects? Assuming you've got that working, please feel free to go ahead and commit.

If you're still having trouble let me know - I'm busy for the next few days, but later next week I will have time to test this out.

lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldCOFFX86_64.cpp

95

I definitely want to remove the need to keep the original object around, but I don't have a timeline for it yet. I think using ObjAddress is the appropriate solution for now.

133

Yep - I don't mind this going in as is. I'm going to do a thorough audit for these in all the RuntimeDyld subclasses fairly soon. I can change it to something more reasonable then.

[AndyAyers]

Still working on tests. The verify option to rtdyld turned up some things needing fixing, which is great (we didn't see these since we are strictly in-proc).

Working on a test also brought up some other issues, in part since we're really loading up a coff object file (not a PE):

• The way we use this code now we never see the REL32 relocations, but every test case I can create from text input creates these (and we really should too, we're just not doing it yet). So I'll add support for this class of relocs -- though maybe not testing for the full set of REL32_* variants yet. These relative relocations can only be used if the dynamic loader promises to keep sections within 32 bit reaches of each other. I currently don't see any way to ensure this will be true.

• ADDR32NB is a bit of a hack, since (from what I can tell) there is no real notion of an image base, at least in the non-PE case. I don't need this to work since I only see these relocs in .pdata which I am ignoring, but it would be nice if it there would be some way to have a base and they are used more broadly. For instance some times jump tables are encoded this way to save size.

• Zero sized sections cause trouble. I routinely see zero sized .data and .bss. I have marked any zero sized section as not required for execution and am deferring looking at section data in some places until we know the section is required. An alternative here would be to get the coff producer to stop emitting zero sized sections.

Hope to have an update out in a day or two, but I have some vacation here and there. So we'll see.

[AndyAyers]

Add a rtdyld test case for coff object files.

Rework the x86_64 relocation processing so that it can pass the rtdyld's verification and check tests. In particular be more careful about Address vs ObjAddress vs LoadedAddress.

Implement REL32 forms of relocations. Add a test case showing that the dynamic linker does the proper update for the basic REL32 relocation. Streamline the relocation processing to remove the second of a matching set of switches.

Stub out ADDR32NB until we understand how the dynamic linker is going to provide an image base and constrain sections to be within a 4GB region.

Fix some issues where the dynamic linker was confused by zero sized sections (we now claim they don't need to be loaded for COFF) or was too eager to look at .bss.

[majnemer]

lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp

271–272

This makes sense but is a little subtle. Both checks are needed because:

• VirtualSize may be zero in object files while SizeOfRawData is non-zero.
• SizeOfRawData may be zero in executables while VirtualSize is non-zero.

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldCOFF.h

30

This space is superfluous.

lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldCOFFX86_64.cpp

58–59

I thought Value was a variable with automatic storage duration, please consider indenting this.

64

This space is superfluous.

73

This seems wrong for RelType != COFF::IMAGE_REL_AMD64_REL32. I think we would want + 4 for IMAGE_REL_AMD64_REL32, + 3 for IMAGE_REL_AMD64_REL32_1, etc.

139

This space is superfluous.

147

Please insert a space between the pointee type and the star token.

lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldCOFFX86_64.h

27

This space is superfluous.

38

Variable names are capitalized in LLVM.

46–49

This looks a little funny, would you mind reformatting this? You might want to look into using clang-format, many contributors use it to automate reformatting source code to the LLVM conventions.

51

You could just go with unsigned.

54–55

Likewise, the way RuntimeDyldELF.h formats this method declaration is more in line with LLVM's style.

lib/Object/COFFObjectFile.cpp

364–368

It might be nicer to store the flags in a variable, perhaps:

const uint32_t BSSFlags = COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA |
                          COFF::IMAGE_SCN_MEM_READ | COFF::IMAGE_SCN_MEM_WRITE;
return (Sec->Characteristics & BSSFlags) == BSSFlags;

[lhames]

LGTM pending addressing of majnemer's comments. Running clang-format over the source is a particularly good idea.

Thanks again for your work on this Andy, and your patience with the review process. It's really great to see the JIT getting COFF support.

[AndyAyers]

Will have an updated patch out shortly....

lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp

271–272

I'll add a comment here.

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldCOFF.h

30

Am going to run clang-format as suggested to clear these up.

lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldCOFFX86_64.cpp

73

There was a "Delta" in processRelocationRef that was supposed to take care of this, but I had the sign wrong there... will move it up here since it probably fits better here than there.

Note the _N variants subtract additional N, not add it. Eg REL32_1 means there's a reloc that begins 5 bytes from the end of the instruction.

lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldCOFFX86_64.h

38

Will fix.

46–49

Yep, clang-format it is.

lib/Object/COFFObjectFile.cpp

364–368

Will do.

[AndyAyers]

Reformat using clang-format. Note in edited files, I only took formatting changes for the parts I had edited.

Incorporate all the review feedback from the last iteration.

Rework how the REL_N relocations handle the _N part -- move the adjustment into resolveRelocation, and fix the sign of the adjustment.

[majnemer]

LGTM!

Thanks, this looks excellent :)

[AndyAyers]

Is there anything else I need to do here?

[AndyAyers]

I don't have commit access, so if you wouldn't mind...

[lhames]

Excellent. Thanks Andy and David!

lib/ExecutionEngine/RuntimeDyld/CMakeLists.txt

   RTDyldMemoryManager.cpp
   RuntimeDyld.cpp
   RuntimeDyldChecker.cpp
+  RuntimeDyldCOFF.cpp
   RuntimeDyldELF.cpp
   RuntimeDyldMachO.cpp
+  Targets/RuntimeDyldCOFFX86_64.cpp
   )

lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp

 
 #include "llvm/ExecutionEngine/RuntimeDyld.h"
 #include "RuntimeDyldCheckerImpl.h"
+#include "RuntimeDyldCOFF.h"
 #include "RuntimeDyldELF.h"
 #include "RuntimeDyldImpl.h"
 #include "RuntimeDyldMachO.h"
 #include "llvm/Object/ELFObjectFile.h"
+#include "llvm/Object/COFF.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MutexGuard.h"
 

   const ObjectFile *Obj = Section.getObject();
   if (auto *ELFObj = dyn_cast<object::ELFObjectFileBase>(Obj))
     return ELFObj->getSectionFlags(Section) & ELF::SHF_ALLOC;
+  if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj)) {
+    const coff_section *CoffSection = COFFObj->getCOFFSection(Section);
+    // Avoid loading zero-sized COFF sections.
+    // In PE files, VirtualSize gives the section size, and SizeOfRawData
+    // may be zero for sections with content. In Obj files, SizeOfRawData 
+    // gives the section size, and VirtualSize is always zero. Hence
+    // the need to check for both cases below.
+    bool HasContent = (CoffSection->VirtualSize > 0) 
+      || (CoffSection->SizeOfRawData > 0);
+    bool IsDiscardable = CoffSection->Characteristics &
+      (COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_LNK_INFO);
+    return HasContent && !IsDiscardable;
+  }
+  
   assert(isa<MachOObjectFile>(Obj));
   return true;
  }

   if (auto *ELFObj = dyn_cast<object::ELFObjectFileBase>(Obj))
     return !(ELFObj->getSectionFlags(Section) &
              (ELF::SHF_WRITE | ELF::SHF_EXECINSTR));
+  if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj))
+    return ((COFFObj->getCOFFSection(Section)->Characteristics &
+             (COFF::IMAGE_SCN_CNT_INITIALIZED_DATA
+             | COFF::IMAGE_SCN_MEM_READ
+             | COFF::IMAGE_SCN_MEM_WRITE))
+             ==
+             (COFF::IMAGE_SCN_CNT_INITIALIZED_DATA
+             | COFF::IMAGE_SCN_MEM_READ));
+
   assert(isa<MachOObjectFile>(Obj));
   return false;
 }

   const ObjectFile *Obj = Section.getObject();
   if (auto *ELFObj = dyn_cast<object::ELFObjectFileBase>(Obj))
     return ELFObj->getSectionType(Section) == ELF::SHT_NOBITS;
+  if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj))
+    return COFFObj->getCOFFSection(Section)->Characteristics &
+            COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA;
 
   auto *MachO = cast<MachOObjectFile>(Obj);
   unsigned SectionType = MachO->getSectionType(Section);

                                       const SectionRef &Section, bool IsCode) {
 
   StringRef data;
-  Check(Section.getContents(data));
   uint64_t Alignment64 = Section.getAlignment();
 
   unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL;

   // Some sections, such as debug info, don't need to be loaded for execution.
   // Leave those where they are.
   if (IsRequired) {
+    Check(Section.getContents(data));
     Allocate = DataSize + PaddingSize + StubBufSize;
     Addr = IsCode ? MemMgr->allocateCodeSection(Allocate, Alignment, SectionID,
                                                 Name)

 
 RuntimeDyld::~RuntimeDyld() {}
 
+static std::unique_ptr<RuntimeDyldCOFF>
+createRuntimeDyldCOFF(Triple::ArchType Arch, RTDyldMemoryManager *MM,
+                      bool ProcessAllSections, RuntimeDyldCheckerImpl *Checker) {
+  std::unique_ptr<RuntimeDyldCOFF> Dyld(RuntimeDyldCOFF::create(Arch, MM));
+  Dyld->setProcessAllSections(ProcessAllSections);
+  Dyld->setRuntimeDyldChecker(Checker);
+  return Dyld;
+}
+
 static std::unique_ptr<RuntimeDyldELF>
 createRuntimeDyldELF(RTDyldMemoryManager *MM, bool ProcessAllSections,
                      RuntimeDyldCheckerImpl *Checker) {

       Dyld = createRuntimeDyldMachO(
                static_cast<Triple::ArchType>(Obj.getArch()), MM,
                ProcessAllSections, Checker);
+    else if (Obj.isCOFF())
+      Dyld = createRuntimeDyldCOFF(
+               static_cast<Triple::ArchType>(Obj.getArch()), MM,
+               ProcessAllSections, Checker);
     else
       report_fatal_error("Incompatible object format!");
   }

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldCOFF.h

+//===-- RuntimeDyldCOFF.h - Run-time dynamic linker for MC-JIT ---*- C++ -*-==//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// COFF support for MC-JIT runtime dynamic linker.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_RUNTIME_DYLD_COFF_H
+#define LLVM_RUNTIME_DYLD_COFF_H
+
+#include "RuntimeDyldImpl.h"
+#include "llvm/ADT/DenseMap.h"
+
+#define DEBUG_TYPE "dyld"
+
+using namespace llvm;
+
+namespace llvm {
+
+// Common base class for COFF dynamic linker support.
+// Concrete subclasses for each target can be found in ./Targets.
+class RuntimeDyldCOFF : public RuntimeDyldImpl {
+
+public:
+  std::unique_ptr<RuntimeDyld::LoadedObjectInfo>
+  loadObject(const object::ObjectFile &Obj) override;
+  bool isCompatibleFile(const object::ObjectFile &Obj) const override;
+  static std::unique_ptr<RuntimeDyldCOFF> create(Triple::ArchType Arch,
+                                                 RTDyldMemoryManager *MM);
+
+protected:
+  RuntimeDyldCOFF(RTDyldMemoryManager *MM) : RuntimeDyldImpl(MM) {}
+  uint64_t getSymbolOffset(const SymbolRef &Sym);
+};
+
+} // end namespace llvm
+
+#undef DEBUG_TYPE
+
+#endif

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldCOFF.cpp

+//===-- RuntimeDyldCOFF.cpp - Run-time dynamic linker for MC-JIT -*- C++ -*-==//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Implementation of COFF support for the MC-JIT runtime dynamic linker.
+//
+//===----------------------------------------------------------------------===//
+
+#include "RuntimeDyldCOFF.h"
+#include "Targets/RuntimeDyldCOFFX86_64.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/Object/ObjectFile.h"
+
+using namespace llvm;
+using namespace llvm::object;
+
+#define DEBUG_TYPE "dyld"
+
+namespace {
+
+class LoadedCOFFObjectInfo : public RuntimeDyld::LoadedObjectInfo {
+public:
+  LoadedCOFFObjectInfo(RuntimeDyldImpl &RTDyld, unsigned BeginIdx,
+                       unsigned EndIdx)
+      : RuntimeDyld::LoadedObjectInfo(RTDyld, BeginIdx, EndIdx) {}
+
+  OwningBinary<ObjectFile>
+  getObjectForDebug(const ObjectFile &Obj) const override {
+    return OwningBinary<ObjectFile>();
+  }
+};
+}
+
+namespace llvm {
+
+std::unique_ptr<RuntimeDyldCOFF>
+llvm::RuntimeDyldCOFF::create(Triple::ArchType Arch, RTDyldMemoryManager *MM) {
+  switch (Arch) {
+  default:
+    llvm_unreachable("Unsupported target for RuntimeDyldCOFF.");
+    break;
+  case Triple::x86_64:
+    return make_unique<RuntimeDyldCOFFX86_64>(MM);
+  }
+}
+
+std::unique_ptr<RuntimeDyld::LoadedObjectInfo>
+RuntimeDyldCOFF::loadObject(const object::ObjectFile &O) {
+  unsigned SectionStartIdx, SectionEndIdx;
+  std::tie(SectionStartIdx, SectionEndIdx) = loadObjectImpl(O);
+  return llvm::make_unique<LoadedCOFFObjectInfo>(*this, SectionStartIdx,
+                                                 SectionEndIdx);
+}
+
+uint64_t RuntimeDyldCOFF::getSymbolOffset(const SymbolRef &Sym) {
+  uint64_t Address;
+  if (std::error_code EC = Sym.getAddress(Address))
+    return UnknownAddressOrSize;
+
+  if (Address == UnknownAddressOrSize)
+    return UnknownAddressOrSize;
+
+  const ObjectFile *Obj = Sym.getObject();
+  section_iterator SecI(Obj->section_end());
+  if (std::error_code EC = Sym.getSection(SecI))
+    return UnknownAddressOrSize;
+
+  if (SecI == Obj->section_end())
+    return UnknownAddressOrSize;
+
+  uint64_t SectionAddress = SecI->getAddress();
+  return Address - SectionAddress;
+}
+
+bool RuntimeDyldCOFF::isCompatibleFile(const object::ObjectFile &Obj) const {
+  return Obj.isCOFF();
+}
+
+} // namespace llvm

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h

 using namespace llvm;
 
 namespace llvm {
-namespace {
-// Helper for extensive error checking in debug builds.
-std::error_code Check(std::error_code Err) {
-  if (Err) {
-    report_fatal_error(Err.message());
-  }
-  return Err;
-}
-
-} // end anonymous namespace
 
 class RuntimeDyldELF : public RuntimeDyldImpl {
 

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h

 
 namespace llvm {
 
+namespace {
+  // Helper for extensive error checking in debug builds.
+  std::error_code Check(std::error_code Err) {
+    if (Err) {
+      report_fatal_error(Err.message());
+    }
+    return Err;
+  }
+} // end anonymous namespace
+
 class Twine;
 
 /// SectionEntry - represents a section emitted into memory by the dynamic

lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldCOFFX86_64.h

+//===-- RuntimeDyldCOFFX86_64.h --- COFF/X86_64 specific code ---*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// COFF x86_x64 support for MC-JIT runtime dynamic linker.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_EXECUTIONENGINE_RUNTIMEDYLD_TARGETS_RUNTIMEDYLDCOFF86_64_H
+#define LLVM_LIB_EXECUTIONENGINE_RUNTIMEDYLD_TARGETS_RUNTIMEDYLDCOFF86_64_H
+
+#include "llvm/Object/COFF.h"
+#include "llvm/Support/COFF.h"
+#include "../RuntimeDyldCOFF.h"
+
+using namespace llvm;
+
+namespace llvm {
+
+class RuntimeDyldCOFFX86_64 : public RuntimeDyldCOFF {
+
+private:
+  // When a module is loaded we save the SectionID of the unwind
+  // sections in a table until we receive a request to register all
+  // unregisteredEH frame sections with the memory manager.
+  SmallVector<SID, 2> UnregisteredEHFrameSections;
+  SmallVector<SID, 2> RegisteredEHFrameSections;
+
+public:
+  RuntimeDyldCOFFX86_64(RTDyldMemoryManager *MM) : RuntimeDyldCOFF(MM) {}
+
+  unsigned getMaxStubSize() override {
+    return 6; // 2-byte jmp instruction + 32-bit relative address
+  }
+
+  void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override;
+
+  relocation_iterator processRelocationRef(unsigned SectionID,
+                                           relocation_iterator RelI,
+                                           const ObjectFile &Obj,
+                                           ObjSectionToIDMap &ObjSectionToID,
+                                           StubMap &Stubs) override;
+
+  unsigned getStubAlignment() override { return 1; }
+  void registerEHFrames() override;
+  void deregisterEHFrames() override;
+  void finalizeLoad(const ObjectFile &Obj,
+                    ObjSectionToIDMap &SectionMap) override;
+};
+
+} // end namespace llvm
+
+#undef DEBUG_TYPE
+
+#endif

lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldCOFFX86_64.cpp

+//===-- RuntimeDyldCOFFX86_64.cpp - COFF/X86_64 specific code ---*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// COFF x86_x64 support for MC-JIT runtime dynamic linker.
+//
+//===----------------------------------------------------------------------===//
+
+#include "RuntimeDyldCOFFX86_64.h"
+
+#define DEBUG_TYPE "dyld"
+
+namespace llvm {
+
+void RuntimeDyldCOFFX86_64::registerEHFrames() {
+  if (!MemMgr)
+    return;
+  for (auto const &EHFrameSID : UnregisteredEHFrameSections) {
+    uint8_t *EHFrameAddr = Sections[EHFrameSID].Address;
+    uint64_t EHFrameLoadAddr = Sections[EHFrameSID].LoadAddress;
+    size_t EHFrameSize = Sections[EHFrameSID].Size;
+    MemMgr->registerEHFrames(EHFrameAddr, EHFrameLoadAddr, EHFrameSize);
+    RegisteredEHFrameSections.push_back(EHFrameSID);
+  }
+  UnregisteredEHFrameSections.clear();
+}
+
+void RuntimeDyldCOFFX86_64::deregisterEHFrames() {
+  // Stub
+}
+
+// The target location for the relocation is described by RE.SectionID and
+// RE.Offset.  RE.SectionID can be used to find the SectionEntry.  Each
+// SectionEntry has three members describing its location.
+// SectionEntry::Address is the address at which the section has been loaded
+// into memory in the current (host) process.  SectionEntry::LoadAddress is the
+// address that the section will have in the target process.
+// SectionEntry::ObjAddress is the address of the bits for this section in the
+// original emitted object image (also in the current address space).
+//
+// Relocations will be applied as if the section were loaded at
+// SectionEntry::LoadAddress, but they will be applied at an address based
+// on SectionEntry::Address.  SectionEntry::ObjAddress will be used to refer to
+// Target memory contents if they are required for value calculations.
+//
+// The Value parameter here is the load address of the symbol for the
+// relocation to be applied.  For relocations which refer to symbols in the
+// current object Value will be the LoadAddress of the section in which
+// the symbol resides (RE.Addend provides additional information about the
+// symbol location).  For external symbols, Value will be the address of the
+// symbol in the target address space.
+void RuntimeDyldCOFFX86_64::resolveRelocation(const RelocationEntry &RE,
+                                              uint64_t Value) {
+  const SectionEntry &Section = Sections[RE.SectionID];
+  uint8_t *Target = Section.Address + RE.Offset;
+
+  switch (RE.RelType) {
+
+  case COFF::IMAGE_REL_AMD64_REL32:
+  case COFF::IMAGE_REL_AMD64_REL32_1:
+  case COFF::IMAGE_REL_AMD64_REL32_2:
+  case COFF::IMAGE_REL_AMD64_REL32_3:
+  case COFF::IMAGE_REL_AMD64_REL32_4:
+  case COFF::IMAGE_REL_AMD64_REL32_5: {
+    uint32_t *TargetAddress = (uint32_t *)Target;
+    uint64_t FinalAddress = Section.LoadAddress + RE.Offset;
+    // Delta is the distance from the start of the reloc to the end of the
+    // instruction with the reloc.
+    uint64_t Delta = 4 + (RE.RelType - COFF::IMAGE_REL_AMD64_REL32);
+    Value -= FinalAddress + Delta;
+    uint64_t Result = Value + RE.Addend;
+    assert(((int64_t)Result <= INT32_MAX) && "Relocation overflow");
+    assert(((int64_t)Result >= INT32_MIN) && "Relocation underflow");
+    *TargetAddress = Result;
+    break;
+  }
+
+  case COFF::IMAGE_REL_AMD64_ADDR32NB: {
+    // Note ADDR32NB requires a well-established notion of
+    // image base. This address must be less than or equal
+    // to every section's load address, and all sections must be
+    // within a 32 bit offset from the base.
+    //
+    // For now we just set these to zero.
+    uint32_t *TargetAddress = (uint32_t *)Target;
+    *TargetAddress = 0;
+    break;
+  }
+
+  case COFF::IMAGE_REL_AMD64_ADDR64: {
+    uint64_t *TargetAddress = (uint64_t *)Target;
+    *TargetAddress = Value + RE.Addend;
+    break;
+  }
+
+  default:
+    llvm_unreachable("Relocation type not implemented yet!");
+    break;
+  }
+}
+
+relocation_iterator RuntimeDyldCOFFX86_64::processRelocationRef(
+    unsigned SectionID, relocation_iterator RelI, const ObjectFile &Obj,
+    ObjSectionToIDMap &ObjSectionToID, StubMap &Stubs) {
+
+  // Find the symbol referred to in the relocation, and
+  // get its section and offset.
+  //
+  // Insist for now that all symbols be resolvable within
+  // the scope of this object file.
+  symbol_iterator Symbol = RelI->getSymbol();
+  if (Symbol == Obj.symbol_end())
+    report_fatal_error("Unknown symbol in relocation");
+  unsigned TargetSectionID = 0;
+  uint64_t TargetOffset = UnknownAddressOrSize;
+  const COFFObjectFile *COFFObj = cast<COFFObjectFile>(&Obj);
+  const COFFSymbolRef COFFSymbol = COFFObj->getCOFFSymbol(*Symbol);
+  section_iterator SecI(Obj.section_end());
+  Symbol->getSection(SecI);
+  if (SecI == Obj.section_end())
+    report_fatal_error("Unknown section in relocation");
+  bool IsCode = SecI->isText();
+  TargetSectionID = findOrEmitSection(Obj, *SecI, IsCode, ObjSectionToID);
+  TargetOffset = getSymbolOffset(*Symbol);
+
+  // Determine the Addend used to adjust the relocation value.
+  uint64_t RelType;
+  Check(RelI->getType(RelType));
+  uint64_t Offset;
+  Check(RelI->getOffset(Offset));
+  uint64_t Addend = 0;
+  SectionEntry &Section = Sections[SectionID];
+  uintptr_t ObjTarget = Section.ObjAddress + Offset;
+
+  switch (RelType) {
+
+  case COFF::IMAGE_REL_AMD64_REL32:
+  case COFF::IMAGE_REL_AMD64_REL32_1:
+  case COFF::IMAGE_REL_AMD64_REL32_2:
+  case COFF::IMAGE_REL_AMD64_REL32_3:
+  case COFF::IMAGE_REL_AMD64_REL32_4:
+  case COFF::IMAGE_REL_AMD64_REL32_5:
+  case COFF::IMAGE_REL_AMD64_ADDR32NB: {
+    uint32_t *Displacement = (uint32_t *)ObjTarget;
+    Addend = *Displacement;
+    break;
+  }
+
+  case COFF::IMAGE_REL_AMD64_ADDR64: {
+    uint64_t *Displacement = (uint64_t *)ObjTarget;
+    Addend = *Displacement;
+    break;
+  }
+
+  default:
+    break;
+  }
+
+  StringRef TargetName;
+  Symbol->getName(TargetName);
+  DEBUG(dbgs() << "\t\tIn Section " << SectionID << " Offset " << Offset
+               << " RelType: " << RelType << " TargetName: " << TargetName
+               << " Addend " << Addend << "\n");
+
+  RelocationEntry RE(SectionID, Offset, RelType, TargetOffset + Addend);
+  addRelocationForSection(RE, TargetSectionID);
+
+  return ++RelI;
+}
+
+void RuntimeDyldCOFFX86_64::finalizeLoad(const ObjectFile &Obj,
+                                         ObjSectionToIDMap &SectionMap) {
+  // Look for and record the EH frame section IDs.
+  for (const auto &SectionPair : SectionMap) {
+    const SectionRef &Section = SectionPair.first;
+    StringRef Name;
+    Check(Section.getName(Name));
+    // Note unwind info is split across .pdata and .xdata, so this
+    // may not be sufficiently general for all users.
+    if (Name == ".xdata") {
+      UnregisteredEHFrameSections.push_back(SectionPair.second);
+    }
+  }
+}
+}
 No newline at end of file

lib/Object/COFFObjectFile.cpp

     Result = SymbolRef::ST_Data;
   } else if (Symb.isFileRecord()) {
     Result = SymbolRef::ST_File;
-  } else if (SectionNumber == COFF::IMAGE_SYM_DEBUG) {
+  } else if (SectionNumber == COFF::IMAGE_SYM_DEBUG ||
+             Symb.isSectionDefinition()) {
+    // TODO: perhaps we need a new symbol type ST_Section.
     Result = SymbolRef::ST_Debug;
   } else if (!COFF::isReservedSectionNumber(SectionNumber)) {
     const coff_section *Section = nullptr;

 
 bool COFFObjectFile::isSectionBSS(DataRefImpl Ref) const {
   const coff_section *Sec = toSec(Ref);
-  return Sec->Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA;
+  const uint32_t BssFlags = COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA |
+                            COFF::IMAGE_SCN_MEM_READ |
+                            COFF::IMAGE_SCN_MEM_WRITE;
+  return (Sec->Characteristics & BssFlags) == BssFlags;
 }
 
 bool COFFObjectFile::isSectionVirtual(DataRefImpl Ref) const {
   const coff_section *Sec = toSec(Ref);
-  return Sec->Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA;
+  // In COFF, a virtual section won't have any in-file 
+  // content, so the file pointer to the content will be zero.
+  return Sec->PointerToRawData == 0;
 }
 
 bool COFFObjectFile::sectionContainsSymbol(DataRefImpl SecRef,

test/ExecutionEngine/RuntimeDyld/X86/COFF_x86_64

+# RUN: llvm-mc -triple=x86_64-pc-win32 -filetype=obj -o %T/COFF_x86_64.o %s
+# RUN: llvm-rtdyld -triple=x86_64-pc-win32 -verify -check=%s %/T/COFF_x86_64.o
+          .text
+  .def   F;
+  .scl  2;
+  .type 32;
+  .endef
+  .globl  __real400921f9f01b866e
+  .section  .rdata,"dr",discard,__real400921f9f01b866e
+  .align  8
+__real400921f9f01b866e:
+  .quad 4614256650576692846     # double 3.1415899999999999
+  .text
+  .globl  F
+        .global inst1
+  .align  16, 0x90
+F:                                      # @F
+.Ltmp0:
+.seh_proc F
+# BB#0:                                 # %entry
+.Ltmp1:
+  .seh_endprologue
+# rtdyld-check: decode_operand(inst1, 4) = __real400921f9f01b866e - next_pc(inst1)
+inst1:
+  movsd __real400921f9f01b866e(%rip), %xmm0 # xmm0 = mem[0],zero
+  retq
+.Leh_func_end0:
+.Ltmp2:
+  .seh_endproc
+
+