LLVM ORC V2 Symbol to Global Variable - c++

Question

I am trying to access a variable in the host program from LLVM IR, with a global variable, but I am having problems getting it to work. I am declaring a symbol with the required variable address in the main JitDylib. After that I create the Global variable with the same name, with external linkage so the linker can find it. But it does not work. Executing the Jit'ed functions crashes the host program.
Below is my test program based on the LLJIT example in the LLVM repository. I have tried many things such as using CreateGEP to get a valid pointer, or using a different JitDylib to declare the symbol. But none have worked for me. I suspect it is something linking related. Has anyone gotten it work using the new ORC V2 JIT API?
//===-- examples/HowToUseJIT/HowToUseJIT.cpp - An example use of the JIT --===//
//
// 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
//
//===----------------------------------------------------------------------===//
//===-- examples/HowToUseJIT/HowToUseJIT.cpp - An example use of the JIT --===//
//
// 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
//
//===----------------------------------------------------------------------===//
#include "llvm/ExecutionEngine/Orc/LLJIT.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/Module.h"
#include "llvm/Support/InitLLVM.h"
#include "llvm/Support/TargetSelect.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
using namespace llvm::orc;
ExitOnError ExitOnErr;
ThreadSafeModule createDemoModule()
{
auto Context = std::make_unique<LLVMContext>();
auto M = std::make_unique<Module>("test", *Context);
Function* Add1F =
Function::Create(FunctionType::get(Type::getInt64Ty(*Context),
{ }, false),
Function::ExternalLinkage, "add1", M.get());
BasicBlock* BB = BasicBlock::Create(*Context, "EntryBlock", Add1F);
IRBuilder<> builder(BB);
Value* One = builder.getInt32(1);
llvm::Type* arr_ty = builder.getInt32Ty()->getPointerTo();
llvm::GlobalVariable* g = new llvm::GlobalVariable(*M, arr_ty, true, llvm::GlobalValue::LinkageTypes::ExternalLinkage, nullptr, "_mptr");
g->setInitializer(ConstantPointerNull::get(cast<PointerType>(g->getType()->getPointerElementType())));
g->setExternallyInitialized(true);
auto g_loaded = builder.CreateLoad(g);
auto Val = builder.CreateLoad(g_loaded);
Value* Add = builder.CreateAdd(One, Val);
builder.CreateRet(Add);
return ThreadSafeModule(std::move(M), std::move(Context));
}
int main(int argc, char* argv[])
{
InitLLVM X(argc, argv);
InitializeNativeTarget();
InitializeNativeTargetAsmPrinter();
cl::ParseCommandLineOptions(argc, argv, "HowToUseLLJIT");
ExitOnErr.setBanner(std::string(argv[0]) + ": ");
auto J = ExitOnErr(LLJITBuilder().create());
uint32_t test = 5;
auto& ES = J->getExecutionSession();
auto& DL = J->getDataLayout();
MangleAndInterner Mangle(ES, DL);
auto& JD = J->getMainJITDylib();
JD.define(
llvm::orc::absoluteSymbols({
{ Mangle("_mptr"), { llvm::pointerToJITTargetAddress(&test), llvm::JITSymbolFlags::Exported } }
}));
auto M = createDemoModule();
ExitOnErr(J->addIRModule(std::move(M)));
auto Add1Sym = ExitOnErr(J->lookup("add1"));
int (*Add1)() = (int (*)())Add1Sym.getAddress();
int Result = Add1();
outs() << "add1(42) = " << Result << "\n";
return 0;
}

Answer 1

A JITDylib needs to be told to search for symbols in the host program like so:
JD.addGenerator(cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(DL.getGlobalPrefix())))
Your method of defining absolute symbols should also work. However, I don't think you need to mangle the variable name in this case. You also might want to add the llvm::JITSymbolFlags::Absolute symbol flag. You could try this instead:
JD.define(
llvm::orc::absoluteSymbols({
{ ES->intern("_mptr"), { llvm::pointerToJITTargetAddress(&test), llvm::JITSymbolFlags::Exported | llvm::JITSymbolFlags::Absolute} }
}));
Finally, you could simply hard-code the address as a constant and not rely on any linking like so:
llvm::ConstantInt* addressConstant = llvm::ConstantInt::get(Context, llvm::APInt(sizeof(std::uintptr_t) * 8, reinterpret_cast<uint64_t>(&test), false));
llvm::Value* testPtr = builder->CreateIntToPtr(addressConstant, llvm::Type::getInt8PtrTy(Context));