[ORC] Emit i386 indirections for 32-bit processes on x86_64 hosts

[sgraenitz]

Summary

The ORC ABI determines the machine instructions emitted for compiler-generated indirections. We use the target triple to select the right ABI, but the triple detection does not respect the process bitness. Thus, ORC emitted x86_64 instructions instead of i386 ones for 32-bit processes on x86_64 hosts. This caused segfaults in two tests as reported with https://llvm.org/PR51292.

[mgorny]

llvm/lib/ExecutionEngine/Orc/IndirectionUtils.cpp

151

As I said on the bug, we normally don't use LLVM_BUILD_32_BITS. I think this is somewhat ugly but how about just using __i386__?

[sgraenitz]

I did debug the misbehavior in LazyCallThroughManager specifically and verified that this change fixes the issue. I assume that the approach can/should be used in IndirectStubsManager and JITCompileCallbackManager as well, but these cases don't seem to have test coverage right now.

Note that this may not be sufficient to fix https://llvm.org/PR51292. There seems to be another issue with i386 call-through stubs that causes a subsequent segfault.

llvm/lib/ExecutionEngine/Orc/IndirectionUtils.cpp

226

TODO: clang-format proposed this new indentation, but it doesn't look correct

[sgraenitz]

llvm/lib/ExecutionEngine/Orc/IndirectionUtils.cpp

151

Didn't tests it yet, but if it works that's fine for me. It would avoid the CMake change. What do you think @lhames?

[lhames]

Why are we getting Triple::x86_64 rather than Triple::x86? I think we really want to add a Triple::x86 case and then figure out how to make sure the right triple is fed in.

[sgraenitz]

In D107569#2930141, @lhames wrote:

Why are we getting Triple::x86_64 rather than Triple::x86? I think we really want to add a Triple::x86 case and then figure out how to make sure the right triple is fed in.

sys::getProcessTriple() returns LLVM_HOST_TRIPLE which contains Triple::x86_64 on 64-bit hosts (even in 32-bit processes). We could patch the getProcessTriple() function, but I am afraid it's going to be a bigger chunk of work. Please find some more detail from my investigation in the ticket: https://bugs.llvm.org/show_bug.cgi?id=51292#c3

[sgraenitz]

I am still seeing segfaults in 32-bit builds even with the appropriate triple. Not sure what else is missing and right now I don't have the time to investigate the details. For the moment D107640 limits the debug object tests to 64-bit processes on x86_64 hosts. This is what the debug plugin and tests were made for.

llvm/cmake/modules/HandleLLVMOptions.cmake

if( LLVM_BUILD_32_BITS )
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -m32")
     set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -m32")
     set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -m32")
     set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -m32")
 
     # FIXME: CMAKE_SIZEOF_VOID_P is still 8
     add_definitions(-D_LARGEFILE_SOURCE)
     add_definitions(-D_FILE_OFFSET_BITS=64)
+    add_definitions(-DLLVM_BUILD_32_BITS)
   endif( LLVM_BUILD_32_BITS )
 endif( CMAKE_SIZEOF_VOID_P EQUAL 8 AND NOT WIN32 )
 
 # If building on a GNU specific 32-bit system, make sure off_t is 64 bits
 # so that off_t can stored offset > 2GB.
 # Android until version N (API 24) doesn't support it.
 if (ANDROID AND (ANDROID_NATIVE_API_LEVEL LESS 24))
   set(LLVM_FORCE_SMALLFILE_FOR_ANDROID TRUE)

llvm/lib/ExecutionEngine/Orc/IndirectionUtils.cpp

case Triple::aarch64_32: {
 
     case Triple::mips64:
     case Triple::mips64el: {
       typedef orc::LocalJITCompileCallbackManager<orc::OrcMips64> CCMgrT;
       return CCMgrT::Create(ES, ErrorHandlerAddress);
     }
 
     case Triple::x86_64: {
+#if defined(LLVM_BUILD_32_BITS)
+      typedef orc::LocalJITCompileCallbackManager<orc::OrcI386> CCMgrT;
+      return CCMgrT::Create(ES, ErrorHandlerAddress);
+#else
       if (T.getOS() == Triple::OSType::Win32) {
         typedef orc::LocalJITCompileCallbackManager<orc::OrcX86_64_Win32> CCMgrT;
         return CCMgrT::Create(ES, ErrorHandlerAddress);
       } else {
         typedef orc::LocalJITCompileCallbackManager<orc::OrcX86_64_SysV> CCMgrT;
         return CCMgrT::Create(ES, ErrorHandlerAddress);
       }
+#endif
     }
-
   }
 }
 
 std::function<std::unique_ptr<IndirectStubsManager>()>
 createLocalIndirectStubsManagerBuilder(const Triple &T) {
   switch (T.getArch()) {
     default:
       return [](){
switch (T.getArch()) {
     case Triple::mips64:
     case Triple::mips64el:
       return [](){
           return std::make_unique<
                       orc::LocalIndirectStubsManager<orc::OrcMips64>>();
       };
 
     case Triple::x86_64:
+#if defined(LLVM_BUILD_32_BITS)
+      return []() {
+        return std::make_unique<orc::LocalIndirectStubsManager<orc::OrcI386>>();
+      };
+#else
       if (T.getOS() == Triple::OSType::Win32) {
         return [](){
           return std::make_unique<
                      orc::LocalIndirectStubsManager<orc::OrcX86_64_Win32>>();
         };
       } else {
         return [](){
           return std::make_unique<
                      orc::LocalIndirectStubsManager<orc::OrcX86_64_SysV>>();
         };
       }
-
+#endif
     }
 }
 
 Constant* createIRTypedAddress(FunctionType &FT, JITTargetAddress Addr) {
   Constant *AddrIntVal =
     ConstantInt::get(Type::getInt64Ty(FT.getContext()), Addr);
   Constant *AddrPtrVal =
     ConstantExpr::getCast(Instruction::IntToPtr, AddrIntVal,
                           PointerType::get(&FT, 0));

llvm/lib/ExecutionEngine/Orc/LazyReexports.cpp

case Triple::mipsel:
     return LocalLazyCallThroughManager::Create<OrcMips32Le>(ES,
                                                             ErrorHandlerAddr);
 
   case Triple::mips64:
   case Triple::mips64el:
     return LocalLazyCallThroughManager::Create<OrcMips64>(ES, ErrorHandlerAddr);
 
   case Triple::x86_64:
+#if defined(LLVM_BUILD_32_BITS)
+    return LocalLazyCallThroughManager::Create<OrcI386>(ES, ErrorHandlerAddr);
+#else
     if (T.getOS() == Triple::OSType::Win32)
       return LocalLazyCallThroughManager::Create<OrcX86_64_Win32>(
           ES, ErrorHandlerAddr);
     else
       return LocalLazyCallThroughManager::Create<OrcX86_64_SysV>(
           ES, ErrorHandlerAddr);
+#endif
   }
 }
 
 LazyReexportsMaterializationUnit::LazyReexportsMaterializationUnit(
     LazyCallThroughManager &LCTManager, IndirectStubsManager &ISManager,
     JITDylib &SourceJD, SymbolAliasMap CallableAliases, ImplSymbolMap *SrcJDLoc)
     : MaterializationUnit(extractFlags(CallableAliases), nullptr),
       LCTManager(LCTManager), ISManager(ISManager), SourceJD(SourceJD),