Sharing a C ++ pointer with JL'LLM code

Question

I want most of my program to be a usually compiled C ++ program. The specified program uses a piece of contiguous memory for the stack. The top of the stack is supported by a regular pointer.

I want to share this pointer with code generated through LLVM JIT. For example, given:

llvm::InitializeNativeTarget(); llvm::LLVMContext ctx; std::unique_ptr<llvm::Module> uptr_module = llvm::make_unique<llvm::Module>( "lt", ctx ); llvm::Module *const module = uptr_module.get(); int *const stack = new int[100]; int *top = stack; // I want this pointer to be shared with JIT'd code llvm::Function *const func = llvm::cast<llvm::Function>( module->getOrInsertFunction( "func", llvm::Type::getVoidTy( ctx ), (llvm::Type*)0 ) ); llvm::BasicBlock *const block = llvm::BasicBlock::Create( ctx, "entry", func ); pointerInc( &top, block ); // Increment the pointer in JIT'd code llvm::ReturnInst::Create( ctx, block ); llvm::verifyFunction( *func, &llvm::outs() ); llvm::verifyModule( *module, &llvm::outs() ); module->dump(); llvm::EngineBuilder eb( std::move( uptr_module ) ); llvm::ExecutionEngine *const exec = eb.create(); assert( exec ); void *const func_ptr = exec->getPointerToFunction( func ); assert( func_ptr ); typedef void (*PFv_v)(); (*(PFv_v)func_ptr)(); // Call JIT'd function 

where pointerInc() will insert the JIT'd code into the current BasicBlock to increase top . Code pointerInc() :

 // Convert a raw C++ pointer into an LLVM Constant*. template<typename T> inline llvm::Value* ptrToValue( T **pptr, llvm::LLVMContext &ctx ) { return return llvm::ConstantInt::get( llvm::Type::getInt64Ty( ctx ), (uint64_t)pptr ); } void pointerInc( llvm::Constant *pptrAsInt64, llvm::ConstantInt *sizeof_T, llvm::BasicBlock *block ) { llvm::LLVMContext &ctx = block->getContext(); llvm::Constant *const intToPtr8 = llvm::ConstantExpr::getIntToPtr( pptrAsInt64, llvm::PointerType::getUnqual( llvm::Type::getInt8Ty( ctx ) ) ); llvm::GetElementPtrInst *const inc = llvm::GetElementPtrInst::Create( intToPtr8, sizeof_T, "inc", block ); llvm::CastInst *const cast = llvm::CastInst::CreatePointerCast( inc, llvm::Type::getInt64Ty( ctx ), "cast", block ); llvm::Constant *const intToPtr64 = llvm::ConstantExpr::getIntToPtr( pptrAsInt64, llvm::PointerType::getUnqual( llvm::Type::getInt64Ty( ctx ) ) ); llvm::StoreInst *const store = new llvm::StoreInst( cast, intToPtr64, false, block ); store->setAlignment( 8 ); } template<typename T> inline void pointerInc( T **pptr, llvm::BasicBlock *block ) { llvm::LLVMContext &ctx = block->getContext(); llvm::ConstantInt *const sizeof_T = llvm::ConstantInt::get( llvm::Type::getInt64Ty( ctx ), sizeof( T ) ); pointerInc( ptrToValue( pptr, ctx ), sizeof_T, block ); } 

Unfortunately this does not work. This is the wrong body of (larger) pointerInc() . The code is actually derived from the LLVM C ++ API code generated by llc on a regular C ++ program that increments a pointer.

At startup, the program prints:

 &p = 140734551679784 -------------------- ; ModuleID = 'lt' define void @func() { entry: %inc = getelementptr i8* inttoptr (i64 140734551679784 to i8*), i64 4 %cast = ptrtoint i8* %inc to i64 store i64 %cast, i64* inttoptr (i64 140734551679784 to i64*), align 8 ret void } Segmentation fault: 11 (core dumped) 

There are two questions:

• It is right? Can I do what I want, that is, share a raw C ++ pointer with JIT'd code?
• Why does this reset the core?

Even if I made the JIT'd function empty, the code still remains in the line that calls the function. The LLVM JIT setup code looks like all the examples I saw, so I don’t see what is wrong with this.

Help a little?

---

Update

If I change the deprecated line:

 void *const func_ptr = exec->getPointerToFunction( func ); 

to a new line:

 uint64_t const func_ptr = exec->getFunctionAddress( "func" ); 

then func_ptr is null.

Answer 1

After playing multiple times with lcc (and using the best C ++ code to feed it) I have work:

 llvm::Value* pointerToPointer( void *ptr, llvm::BasicBlock *block ) { using namespace llvm; LLVMContext &ctx = block->getContext(); ConstantInt *const ptrAsInt = ConstantInt::get( IntegerType::get( ctx, 64 ), (uint64_t)ptr ); PointerType *const Int8Ptr_type = Type::getInt8PtrTy( ctx ); PointerType *const Int8PtrPtr_type = PointerType::getUnqual( Int8Ptr_type ); return new IntToPtrInst( ptrAsInt, Int8PtrPtr_type, "pptr", block ); } void pointerInc( llvm::Value *pptr, llvm::ConstantInt *sizeof_T, llvm::BasicBlock *block ) { using namespace llvm; LLVMContext &ctx = block->getContext(); LoadInst *const ptr = new LoadInst( pptr, "ptr", block ); ptr->setAlignment( sizeof(void*) ); GetElementPtrInst *const inc = GetElementPtrInst::Create( ptr, sizeof_T, "inc", block ); StoreInst *const store = new StoreInst( inc, pptr, block ); store->setAlignment(sizeof(void*)); } template<typename T> inline void pointerInc( T **pptr, llvm::BasicBlock *block ) { using namespace llvm; LLVMContext &ctx = block->getContext(); ConstantInt *const sizeof_T = ConstantInt::get( IntegerType::get( ctx, 64 ), (uint64_t)sizeof( T ) ); pointerInc( pointerToPointer( pptr, block ), sizeof_T, block ); } 

However, the program only works successfully when the JIT'd function is called through:

 vector<GenericValue> noargs; exec->runFunction( func, noargs ); 

Using either getFunctionAddress() or getPointerToFunction() resets the kernel. I still do not answer this.