[LLVMdev] Please help with LLVM C++ integration

[kirill havok]

Hi Gordon,
I wrote a small example, but while running I get an error("Tied to
execute an unknown external function"), where I am wrong?

Thanks in advance.
Kirill.

int some_test_func( int ){
	std::cout << "!!!!" << std::endl;
	return 8848;
}

int _tmain(int argc, _TCHAR* argv[]){

	Module *M = new Module("test");
	ExistingModuleProvider* MP = new ExistingModuleProvider(M);
	ExecutionEngine* EE = ExecutionEngine::create(MP, false);

	std::vector<const Type *> func_args;
	func_args.push_back(Type::Int32Ty);
	FunctionType * func_type = FunctionType::get(Type::Int32Ty, func_args, false);
	Function * my_function = Function::Create( func_type,
Function::ExternalLinkage, "some_test_func", M );
	EE->addGlobalMapping( my_function, (void*)&some_test_func );

	Function *FooF = cast<Function>(M->getOrInsertFunction("foo",
Type::Int32Ty, (Type *)0));
	BasicBlock * BB = BasicBlock::Create("EntryBlock", FooF);
	Value *Ten = ConstantInt::get(Type::Int32Ty, 10);
	CallInst *Add1CallRes = CallInst::Create(my_function, Ten,
"some_test_func", BB);
	Add1CallRes->setTailCall(true);

	ReturnInst::Create(Add1CallRes, BB);

	std::cout << "We just constructed this LLVM module:\n\n" << *M;
	std::cout << "\n\nRunning foo: " << std::flush;

	std::vector<GenericValue> noargs;
	GenericValue gv = EE->runFunction(FooF, noargs);

	std::cout << "Result: " << gv.IntVal.toStringUnsigned(10) << "\n";
	return 0;
}



2008/8/19, Gordon Henriksen <gordonhenriksen at me.com>:
>
> On Aug 19, 2008, at 13:36, kirill havok wrote:
>
> I got very interested in LLVM project, and I decided to start writing my own
> scripting language based on it. By studying the documentation, I could not
> find how to call external function, written in C. That is, I have a set of
> functions written in C/C++, I generate code, using LLVM C++ interface, how
> can I call(or register in machine in run-time) my external functions? Maybe
> I just missed something. Please, give in which direction to search.
>
> Hi Kirill,
>
> Since LLVM goes to the bare metal, there is no need for an "FFI" or bindings
> to call native code. Simply create a declaration for the function—a Function
> with no body—and call it as any other function in your program. (Also, of
> course, link with a library to define the symbols.) It might be instructive
> to examine the llvm-gcc -S -emit-llvm output of a program like this:
>
> int MyExternalFn(int, int, int);
>
> int main(int, const char**, const char**) {
>   return MyExternalFn(1, 2, 3);
> }
>
>
> Where you tweak MyExternalFn to have the desired prototype.
>
> To create a function declaration:
>
>
> From C++, simply call Function::Create and then do not add any basic blocks.
> From LLVM assembly, use the keyword "declare" instead of "define":
> http://llvm.org/docs/LangRef.html#functionstructure
>
>
> If you're using the JIT, you'll need to do the above, but also may need to
> register your functions using
> ExecutionEngine::addGlobalMapping.
>
> http://llvm.org/doxygen/classllvm_1_1ExecutionEngine.html#a8
>
>
> Note that the C calling convention do not map directly to LLVM IR for many
> cases, so it's best to stick to simple parameter types (pointers and ints,
> for example) and also to verify that the LLVM FunctionTypes you use are
> correct on each platform you support.
>
> Good luck!
>
> — Gordon
>
>
> _______________________________________________
>  LLVM Developers mailing list
>  LLVMdev at cs.uiuc.edu         http://llvm.cs.uiuc.edu
>  http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
>
>