[ORC] Minor renaming and typo fixes (NFC)

[sgraenitz]

Summary

One typo, one unsused include and some leftovers from the TargetProcessControl -> ExecutorProcessControl renaming

[xgupta]

Although this patch is correct, running ./LLJITWithTargetProcessControl result in segmentation fault.

PLEASE submit a bug report to https://bugs.llvm.org/ and include the crash backtrace.
Stack dump:
0. Program arguments: ./LLJITWithTargetProcessControl
#0 0x00007fdee365ab73 llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) (/home/xgupta/llvm/llvm-upstream/build/bin/../lib/libLLVMSupport.so.14git+0x1f6b73)
#1 0x00007fdee365892e llvm::sys::RunSignalHandlers() (/home/xgupta/llvm/llvm-upstream/build/bin/../lib/libLLVMSupport.so.14git+0x1f492e)
#2 0x00007fdee365b03a SignalHandler(int) Signals.cpp:0:0
#3 0x00007fdee3c16870 restore_rt sigaction.c:0:0
#4 0x00007fdee461a9e4 llvm::orc::EPCIndirectionUtils::Create(llvm::orc::ExecutorProcessControl&) (/home/xgupta/llvm/llvm-upstream/build/bin/../lib/libLLVMOrcJIT.so.14git+0xfb9e4)
#5 0x0000000000208781 main (./LLJITWithTargetProcessControl+0x208781)
#6 0x00007fdee2f48b25 libc_start_main (/usr/lib/libc.so.6+0x27b25)
#7 0x0000000000207fde _start (./LLJITWithTargetProcessControl+0x207fde)
[1] 52081 segmentation fault (core dumped) ./LLJITWithTargetProcessControl

[sgraenitz]

Thanks @xgupta for your note! The parameter passed to EPCIndirectionUtils::Create() in the example was referencing a moved-from value. This caused the segfault. Unfortunately, the examples don't have good test coverage so far.

[xgupta]

In D110260#3018110, @sgraenitz wrote:

Thanks @xgupta for your note! The parameter passed to EPCIndirectionUtils::Create() in the example was referencing a moved-from value. This caused the segfault. Unfortunately, the examples don't have good test coverage so far.

Yeah we need testcases, now it says

JIT session error: Symbols not found: [ return1 ]
JIT session error: Failed to materialize symbols: { (main, { foo_body }) }
Unable to lazily compile function. Exiting.

Anyways the current patch LGTM.

[sgraenitz]

In D110260#3018412, @xgupta wrote:

Yeah we need testcases, now it says

JIT session error: Symbols not found: [ return1 ]
JIT session error: Failed to materialize symbols: { (main, { foo_body }) }
Unable to lazily compile function. Exiting.

Interesting, it does work for me now on macOS with both, shared libs on and off. Can you please check if you get something like this as well:

➜ nm bin/LLJITWithExecutorProcessControl | grep return1
0000000100004c10 T _return1

[xgupta]

In D110260#3018555, @sgraenitz wrote:

Interesting, it does work for me now on macOS with both, shared libs on and off. Can you please check if you get something like this as well:

➜ nm bin/LLJITWithExecutorProcessControl | grep return1
0000000100004c10 T _return1

nothing returns, I am on arch linux (an rolling release distribution which has all the latest packages) and building LLVM with shared libs config.
cmake ../llvm -DLLVM_TARGETS_TO_BUILD="X86" -DCMAKE_BUILD_TYPE=Release -DLLVM_BUILD_TOOLS=ON -DLLVM_USE_LINKER=lld -DBUILD_SHARED_LIBS=ON -DCMAKE_C_COMPILER=/usr/local/bin/clang \
-DCMAKE_CXX_COMPILER=/usr/local/bin/clang++ -DCMAKE_EXPORT_COMPILE_COMMANDS=ON -DLLVM_BUILD_EXAMPLES=ON

[xgupta]

Problem is fixed with D110345, Thank you very much for quick fixes.

[sgraenitz]

FYI Included one more typo fix in ExecutorAddress.h

clang/docs/ClangFormattedStatus.rst

* - llvm/examples/OrcV2Examples/LLJITWithOptimizingIRTransform
      - `1`
      - `0`
      - :good:`100%`
    * - llvm/examples/OrcV2Examples/LLJITWithRemoteDebugging
      - `3`
      - `3`
      - `0`
      - :good:`100%`
-   * - llvm/examples/OrcV2Examples/LLJITWithTargetProcessControl
+   * - llvm/examples/OrcV2Examples/LLJITWithExecutorProcessControl
      - `1`
      - `1`
      - `0`
      - :good:`100%`
    * - llvm/examples/OrcV2Examples/LLJITWithThinLTOSummaries
      - `1`
      - `0`
      - `1`

llvm/examples/OrcV2Examples/CMakeLists.txt

 add_subdirectory(LLJITDumpObjects)
 add_subdirectory(LLJITWithCustomObjectLinkingLayer)
+add_subdirectory(LLJITWithExecutorProcessControl)
 add_subdirectory(LLJITWithGDBRegistrationListener)
 add_subdirectory(LLJITWithInitializers)
 add_subdirectory(LLJITWithLazyReexports)
 add_subdirectory(LLJITWithObjectCache)
 add_subdirectory(LLJITWithObjectLinkingLayerPlugin)
 add_subdirectory(LLJITWithOptimizingIRTransform)
-add_subdirectory(LLJITWithTargetProcessControl)
 add_subdirectory(LLJITWithThinLTOSummaries)
 add_subdirectory(OrcV2CBindingsAddObjectFile)
 add_subdirectory(OrcV2CBindingsBasicUsage)
 add_subdirectory(OrcV2CBindingsDumpObjects)
 add_subdirectory(OrcV2CBindingsIRTransforms)
 add_subdirectory(OrcV2CBindingsReflectProcessSymbols)
 add_subdirectory(OrcV2CBindingsRemovableCode)
 add_subdirectory(OrcV2CBindingsLazy)
 add_subdirectory(OrcV2CBindingsVeryLazy)
 
 if(CMAKE_HOST_UNIX)
   add_subdirectory(LLJITWithRemoteDebugging)
 endif()

llvm/examples/OrcV2Examples/LLJITWithExecutorProcessControl/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Core
   ExecutionEngine
   IRReader
   OrcJIT
   Support
   nativecodegen
   )
 
-add_llvm_example(LLJITWithTargetProcessControl
-  LLJITWithTargetProcessControl.cpp
+add_llvm_example(LLJITWithExecutorProcessControl
+  LLJITWithExecutorProcessControl.cpp
   )

llvm/examples/OrcV2Examples/LLJITWithExecutorProcessControl/LLJITWithExecutorProcessControl.cpp

 //===- LLJITWithExecutorProcessControl.cpp - LLJIT example with EPC utils -===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // In this example we will use the lazy re-exports utility to lazily compile
 // IR modules. We will do this in seven steps:
 //
 // 1. Create an LLJIT instance.
 // 2. Install a transform so that we can see what is being compiled.
 // 3. Create an indirect stubs manager and lazy call-through manager.
 // 4. Add two modules that will be conditionally compiled, plus a main module.
 // 5. Add lazy-rexports of the symbols in the conditionally compiled modules.
 // 6. Dump the ExecutionSession state to see the symbol table prior to
 //    executing any code.
 // 7. Verify that only modules containing executed code are compiled.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h"
 #include "llvm/ExecutionEngine/Orc/EPCDynamicLibrarySearchGenerator.h"
 #include "llvm/ExecutionEngine/Orc/EPCIndirectionUtils.h"
 #include "llvm/ExecutionEngine/Orc/ExecutorProcessControl.h"
 #include "llvm/ExecutionEngine/Orc/LLJIT.h"
 #include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
 #include "llvm/ExecutionEngine/Orc/OrcABISupport.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include "../ExampleModules.h"
 
 #include <future>
 
 using namespace llvm;
 using namespace llvm::orc;
 
 ExitOnError ExitOnErr;
 
 // Example IR modules.
 //
 // Note that in the conditionally compiled modules, FooMod and BarMod, functions
 // have been given an _body suffix. This is to ensure that their names do not
 // clash with their lazy-reexports.
 // For clients who do not wish to rename function bodies (e.g. because they want
 // to re-use cached objects between static and JIT compiles) techniques exist to
 // avoid renaming. See the lazy-reexports section of the ORCv2 design doc.
 
 const llvm::StringRef FooMod =
     R"(
   declare i32 @return1()
 
   define i32 @foo_body() {
   entry:
     %0 = call i32 @return1()
     ret i32 %0
   }
 )";
 
 const llvm::StringRef BarMod =
     R"(
   declare i32 @return2()
 
   define i32 @bar_body() {
   entry:
     %0 = call i32 @return2()
     ret i32 %0
   }
 )";
 
 const llvm::StringRef MainMod =
     R"(
 
   define i32 @entry(i32 %argc) {
   entry:
     %and = and i32 %argc, 1
     %tobool = icmp eq i32 %and, 0
     br i1 %tobool, label %if.end, label %if.then
 
   if.then:                                          ; preds = %entry
     %call = tail call i32 @foo() #2
     br label %return
 
   if.end:                                           ; preds = %entry
     %call1 = tail call i32 @bar() #2
     br label %return
 
   return:                                           ; preds = %if.end, %if.then
     %retval.0 = phi i32 [ %call, %if.then ], [ %call1, %if.end ]
     ret i32 %retval.0
   }
 
   declare i32 @foo()
   declare i32 @bar()
 )";
 
 extern "C" int32_t return1() { return 1; }
 extern "C" int32_t return2() { return 2; }
 
 static void *reenter(void *Ctx, void *TrampolineAddr) {
   std::promise<void *> LandingAddressP;
   auto LandingAddressF = LandingAddressP.get_future();
 
   auto *EPCIU = static_cast<EPCIndirectionUtils *>(Ctx);
   EPCIU->getLazyCallThroughManager().resolveTrampolineLandingAddress(
       pointerToJITTargetAddress(TrampolineAddr),
       [&](JITTargetAddress LandingAddress) {
         LandingAddressP.set_value(
             jitTargetAddressToPointer<void *>(LandingAddress));
       });
   return LandingAddressF.get();
 }
 
 static void reportErrorAndExit() {
   errs() << "Unable to lazily compile function. Exiting.\n";
   exit(1);
 }
 
 cl::list<std::string> InputArgv(cl::Positional,
                                 cl::desc("<program arguments>..."));
 
 int main(int argc, char *argv[]) {
   // Initialize LLVM.
   InitLLVM X(argc, argv);
 
   InitializeNativeTarget();
   InitializeNativeTargetAsmPrinter();
 
   cl::ParseCommandLineOptions(argc, argv, "LLJITWithLazyReexports");
   ExitOnErr.setBanner(std::string(argv[0]) + ": ");
 
   // (1) Create LLJIT instance.
   auto EPC = ExitOnErr(SelfExecutorProcessControl::Create());
   auto J = ExitOnErr(
       LLJITBuilder().setExecutorProcessControl(std::move(EPC)).create());
 
   // (2) Install transform to print modules as they are compiled:
   J->getIRTransformLayer().setTransform(
       [](ThreadSafeModule TSM,
          const MaterializationResponsibility &R) -> Expected<ThreadSafeModule> {
         TSM.withModuleDo([](Module &M) { dbgs() << "---Compiling---\n" << M; });
         return std::move(TSM); // Not a redundant move: fix build on gcc-7.5
       });
 
   // (3) Create stubs and call-through managers:
   auto EPCIU = ExitOnErr(EPCIndirectionUtils::Create(*EPC));
   ExitOnErr(EPCIU->writeResolverBlock(pointerToJITTargetAddress(&reenter),
                                       pointerToJITTargetAddress(EPCIU.get())));
   EPCIU->createLazyCallThroughManager(
       J->getExecutionSession(), pointerToJITTargetAddress(&reportErrorAndExit));
   auto ISM = EPCIU->createIndirectStubsManager();
   J->getMainJITDylib().addGenerator(
       ExitOnErr(EPCDynamicLibrarySearchGenerator::GetForTargetProcess(
           J->getExecutionSession())));
 
   // (4) Add modules.
   ExitOnErr(J->addIRModule(ExitOnErr(parseExampleModule(FooMod, "foo-mod"))));
   ExitOnErr(J->addIRModule(ExitOnErr(parseExampleModule(BarMod, "bar-mod"))));
   ExitOnErr(J->addIRModule(ExitOnErr(parseExampleModule(MainMod, "main-mod"))));
 
   // (5) Add lazy reexports.
   MangleAndInterner Mangle(J->getExecutionSession(), J->getDataLayout());
   SymbolAliasMap ReExports(
       {{Mangle("foo"),
         {Mangle("foo_body"),
          JITSymbolFlags::Exported | JITSymbolFlags::Callable}},
        {Mangle("bar"),
         {Mangle("bar_body"),
          JITSymbolFlags::Exported | JITSymbolFlags::Callable}}});
   ExitOnErr(J->getMainJITDylib().define(
       lazyReexports(EPCIU->getLazyCallThroughManager(), *ISM,
                     J->getMainJITDylib(), std::move(ReExports))));
 
   // (6) Dump the ExecutionSession state.
   dbgs() << "---Session state---\n";
   J->getExecutionSession().dump(dbgs());
   dbgs() << "\n";
 
   // (7) Execute the JIT'd main function and pass the example's command line
   // arguments unmodified. This should cause either ExampleMod1 or ExampleMod2
   // to be compiled, and either "1" or "2" returned depending on the number of
   // arguments passed.
 
   // Look up the JIT'd function, cast it to a function pointer, then call it.
   auto EntrySym = ExitOnErr(J->lookup("entry"));
   auto *Entry = (int (*)(int))EntrySym.getAddress();
 
   int Result = Entry(argc);
   outs() << "---Result---\n"
          << "entry(" << argc << ") = " << Result << "\n";
 
   return 0;
 }

llvm/include/llvm/ExecutionEngine/Orc/SimpleRemoteEPC.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_EXECUTIONENGINE_ORC_SIMPLEREMOTEEPC_H
 #define LLVM_EXECUTIONENGINE_ORC_SIMPLEREMOTEEPC_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/FunctionExtras.h"
-#include "llvm/ExecutionEngine/Orc/EPCGenericJITLinkMemoryManager.h"
 #include "llvm/ExecutionEngine/Orc/EPCGenericMemoryAccess.h"
 #include "llvm/ExecutionEngine/Orc/ExecutorProcessControl.h"
 #include "llvm/ExecutionEngine/Orc/Shared/SimpleRemoteEPCUtils.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/MSVCErrorWorkarounds.h"
 
 #include <future>
 

llvm/lib/ExecutionEngine/Orc/Shared/SimpleRemoteEPCUtils.cpp

OpC = static_cast<SimpleRemoteEPCOpcode>(static_cast<uint64_t>(
         *((support::ulittle64_t *)(HeaderBuffer + FDMsgHeader::OpCOffset))));
     SeqNo =
         *((support::ulittle64_t *)(HeaderBuffer + FDMsgHeader::SeqNoOffset));
     TagAddr.setValue(
         *((support::ulittle64_t *)(HeaderBuffer + FDMsgHeader::TagAddrOffset)));
 
     if (MsgSize < FDMsgHeader::Size) {
       Err = joinErrors(std::move(Err),
-                       make_error<StringError>("Mesasge size too small",
+                       make_error<StringError>("Message size too small",
                                                inconvertibleErrorCode()));
       break;
     }
 
     // Read the argument bytes.
     SimpleRemoteEPCArgBytesVector ArgBytes;
     ArgBytes.resize(MsgSize - FDMsgHeader::Size);
     if (auto Err2 = readBytes(ArgBytes.data(), ArgBytes.size())) {