MCJIT: Support setting relocation model from C wrappers

[evgeny777]

Summary

Also added unit tests which uses MCJIT to create position independent code.

[davide]

I think the code is fine, but why do you need to introduce a new API for this (i.e. which problem you're trying to solve?)

[davide]

Also, I and @rafael have ideas on how to change the reloc model to include PIE (see https://reviews.llvm.org/D21100#455440). Not sure when it's gonna happen, but you may want to consider that it could change in the future (and you don't want to rely on it). LLVM doesn't provide stability guarantees about APIs anyway IIRC (cc: @echristo)

[evgeny777]

The real problem is with memory reservation for position independent code, which occurs because RuntimeDyld doesn't calculate size of .got section.
Memory reservation occurs when virtual method needsToReserveAllocationSpace() of memory manager returns true. Currently jitting position
independent code and using memory reservation at the same time causes undefined behavior.

I have patch addressing this issue, but it is blocked by this review:
https://reviews.llvm.org/D28571

The source file MCJITCAPITest.cpp already has test for JIT memory reservation (see TestReserveSectionMemoryManager), so to test the fix for a "PIC/reservation" problem I would need to
add just few lines of code. But I need to be able to set relocation model from C API to do this.

So what I actually plan to do is to land this patch + D28571, and after that submit a review for problem described above.
This patch makes it very easy to write a test case for that problem.

[evgeny777]

Also, I and @rafael have ideas on how to change the reloc model to include PIE

I don't know much about differences between PIC and PIE reloc models, but how adding extra enum member affects this patch (besides extra line in CodeGenCWrappers.h)?

[deadalnix]

include/llvm-c/ExecutionEngine.h

46

Sadly, many people are using the C API in foreign languages (as in not C, not German or French).

I know there is no promise to keep the OrcJIT API stable at this stage, so maybe that's ok, but it's a bit unfortunate that this ends up being in the ExecutionEngine rather than some Orc specific header. Maybe deproting Orc specific declaration from there to some Orc specific header would be better.

include/llvm/Support/CodeGenCWrappers.h

63

Why not use Reloc::Default ?

I've been thinking that Reloc::Default should probably not default to static every time, because more and more linux distro use PIE by default on amd64. Maybe default should become whatever the target uses as default.

[evgeny777]

include/llvm-c/ExecutionEngine.h

46

What exactly declaration are you talking about?

As far as I know relocation model is not something specific to ORC. At least I used legacy MCJIT API with PIC long time go, but I used C++ API (llvm/ExecutionEngine.h). The fact one can't use PIC from C API looks like as a limitation of C API to me.

include/llvm/Support/CodeGenCWrappers.h

63

Just because there is no such enumeration value. See llvm/Support/CodeGen.h

[deadalnix]

include/llvm-c/ExecutionEngine.h

46

The C API has stricter backward compatibility constraints than the regular C++ API, because it is used from other language. These users won't get any error, just weird crash because the structure layout do not match anymore.

Is MCJIT going away at some point ? If so I'd just duplicate the struct and use it for Orc.

include/llvm/Support/CodeGenCWrappers.h

63

I see @rafael blasted it away. What's the reason ?

[evgeny777]

The C API has stricter backward compatibility constraints than the regular C++ API

So does this mean that C API guarantees binary compatibility between old and new versions? If so then this patch does have a problem.

[deadalnix]

In D29222#659900, @evgeny777 wrote:

So does this mean that C API guarantees binary compatibility between old and new versions? If so then this patch does have a problem.

Yes, except for some parts such as the Orc binding, it does. It is still allowed to deprecate functions and remove them (you'd get a link error from a foreign language, so that's fine).

include/llvm-c/ExecutionEngine.h

 void LLVMLinkInInterpreter(void);
 
 typedef struct LLVMOpaqueGenericValue *LLVMGenericValueRef;
 typedef struct LLVMOpaqueExecutionEngine *LLVMExecutionEngineRef;
 typedef struct LLVMOpaqueMCJITMemoryManager *LLVMMCJITMemoryManagerRef;
 
 struct LLVMMCJITCompilerOptions {
   unsigned OptLevel;
+  LLVMRelocMode RelMode;
   LLVMCodeModel CodeModel;
   LLVMBool NoFramePointerElim;
   LLVMBool EnableFastISel;
   LLVMMCJITMemoryManagerRef MCJMM;
 };
 
 /*===-- Operations on generic values --------------------------------------===*/
 

include/llvm/Support/CodeGenCWrappers.h

inline LLVMCodeModel wrap(CodeModel::Model Model) {
   case CodeModel::Medium:
     return LLVMCodeModelMedium;
   case CodeModel::Large:
     return LLVMCodeModelLarge;
   }
   llvm_unreachable("Bad CodeModel!");
 }
 
+inline Reloc::Model unwrap(LLVMRelocMode Model) {
+  switch (Model) {
+  case LLVMRelocDefault:
+  case LLVMRelocStatic:
+    return Reloc::Static;
+  case LLVMRelocPIC:
+    return Reloc::PIC_;
+  case LLVMRelocDynamicNoPic:
+    return Reloc::DynamicNoPIC;
+  }
+  llvm_unreachable("Invalid LLVMRelocMode!");
+}
+
+inline LLVMRelocMode wrap(Reloc::Model Model) {
+  switch (Model) {
+  case Reloc::Static:
+    return LLVMRelocStatic;
+  case Reloc::PIC_:
+    return LLVMRelocPIC;
+  case Reloc::DynamicNoPIC:
+    return LLVMRelocDynamicNoPic;
+  case Reloc::ROPI:
+  case Reloc::RWPI:
+  case Reloc::ROPI_RWPI:
+    break;
+  }
+  llvm_unreachable("Unsupported Reloc::Model!");
+}
+
 } // end llvm namespace
 
 #endif
 

lib/ExecutionEngine/ExecutionEngineBindings.cpp

for (auto &F : *Mod) {
       Attrs = Attrs.addAttribute(F.getContext(), AttributeSet::FunctionIndex,
                                  "no-frame-pointer-elim", Value);
       F.setAttributes(Attrs);
     }
 
   std::string Error;
   EngineBuilder builder(std::move(Mod));
   builder.setEngineKind(EngineKind::JIT)
-         .setErrorStr(&Error)
-         .setOptLevel((CodeGenOpt::Level)options.OptLevel)
-         .setCodeModel(unwrap(options.CodeModel))
-         .setTargetOptions(targetOptions);
+      .setRelocationModel(unwrap(options.RelMode))
   if (options.MCJMM)
     builder.setMCJITMemoryManager(
       std::unique_ptr<RTDyldMemoryManager>(unwrap(options.MCJMM)));
   if (ExecutionEngine *JIT = builder.create()) {
     *OutJIT = wrap(JIT);
     return 0;
   }
   *OutError = strdup(Error.c_str());

unittests/ExecutionEngine/MCJIT/MCJITCAPITest.cpp

 #include "llvm/Support/Host.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 static bool didCallAllocateCodeSection;
 static bool didAllocateCompactUnwindSection;
 static bool didCallYield;
+static bool didAllocateGot;
 
 static uint8_t *roundTripAllocateCodeSection(void *object, uintptr_t size,
                                              unsigned alignment,
                                              unsigned sectionID,
                                              const char *sectionName) {
   didCallAllocateCodeSection = true;
   return static_cast<SectionMemoryManager*>(object)->allocateCodeSection(
     size, alignment, sectionID, sectionName);
 }
 
 static uint8_t *roundTripAllocateDataSection(void *object, uintptr_t size,
                                              unsigned alignment,
                                              unsigned sectionID,
                                              const char *sectionName,
                                              LLVMBool isReadOnly) {
   if (!strcmp(sectionName, "__compact_unwind"))
     didAllocateCompactUnwindSection = true;
+  else if (!strcmp(sectionName, ".got"))
+    didAllocateGot = true;
   return static_cast<SectionMemoryManager*>(object)->allocateDataSection(
     size, alignment, sectionID, sectionName, isReadOnly);
 }
 
 static LLVMBool roundTripFinalizeMemory(void *object, char **errMsg) {
   std::string errMsgString;
   bool result =
     static_cast<SectionMemoryManager*>(object)->finalizeMemory(&errMsgString);
TEST_F(MCJITCAPITest, reserve_allocation_space) {
   EXPECT_EQ(789, GetGlobalFct());
   EXPECT_LE(MM->UsedCodeSize, MM->ReservedCodeSize);
   EXPECT_LE(MM->UsedDataSizeRO, MM->ReservedDataSizeRO);
   EXPECT_LE(MM->UsedDataSizeRW, MM->ReservedDataSizeRW);
   EXPECT_TRUE(MM->UsedCodeSize > 0); 
   EXPECT_TRUE(MM->UsedDataSizeRW > 0);
 }
 
+TEST_F(MCJITCAPITest, position_independent_code) {
+  SKIP_UNSUPPORTED_PLATFORM;
+
+  buildModuleWithCodeAndData();
+  buildMCJITOptions();
+  Options.RelMode = LLVMRelocPIC;
+  Options.CodeModel = LLVMCodeModelSmall;
+  useRoundTripSectionMemoryManager();
+  buildMCJITEngine();
+  buildAndRunPasses();
+
+  auto SetGlobalFct = reinterpret_cast<void (*)(int)>(
+      reinterpret_cast<uintptr_t>(LLVMGetPointerToGlobal(Engine, Function2)));
+
+  SetGlobalFct(789);
+  EXPECT_TRUE(didAllocateGot);
+}
+
 TEST_F(MCJITCAPITest, yield) {
   SKIP_UNSUPPORTED_PLATFORM;
 
   buildSimpleFunction();
   buildMCJITOptions();
   buildMCJITEngine();
   LLVMContextRef C = LLVMGetGlobalContext();
   LLVMContextSetYieldCallback(C, yield, nullptr);