llvm dev - Mar 2016 - JIT compiler and calls to existing functions

In the context of a JIT compiler, what's the recommended way to generate a
call to an existing function, that is, not one that you are generating
on-the-fly with LLVM, but one that's already linked into your program? For
example the cosine function (from the standard math library); the
Kaleidoscope tutorial recommends looking it up by name with
dlsym("cos"),
but it seems to me that it should be possible to use a more efficient and
portable solution that takes advantage of the fact that you already have an
actual pointer to cos, even if you haven't linked with debugging symbols.
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20160328/89c42dcd/attachment.html>

> From: llvm-dev [mailto:llvm-dev-bounces at lists.llvm.org] 
> On Behalf Of Russell Wallace via llvm-dev
> Subject: [llvm-dev] JIT compiler and calls to existing functions
> In the context of a JIT compiler, what's the recommended way to
generate a call to an
> existing function, that is, not one that you are generating on-the-fly with
LLVM, but
> one that's already linked into your program? For example the cosine
function (from the
> standard math library); the Kaleidoscope tutorial recommends looking it up
by name with
> dlsym("cos"), but it seems to me that it should be possible to
use a more efficient and
> portable solution that takes advantage of the fact that you already have an
actual pointer
> to cos, even if you haven't linked with debugging symbols.
Perhaps not the most elegant, but we simply use the IRBuilder.CreateIntToPtr()
method to construct the Callee argument for IRBuilder.CreateCall().  The first
argument for CreateIntToPtr() comes from ConstantInt::get(I64, uintptr_t(ptr)),
while the second is a function type pointer defined by using PointerType::get()
on the result of FunctionType::get() with the appropriate function signature.

 - Chuck

That seems to work, thanks! The specific code I ended up with to call
int64_t print(int64_t) looks like:

        auto f = builder.CreateIntToPtr(
            ConstantInt::get(builder.getInt64Ty(), uintptr_t(print)),
            PointerType::getUnqual(FunctionType::get(
                builder.getInt64Ty(), {builder.getInt64Ty()}, false)));
        return builder.CreateCall(f, args);


On Mon, Mar 28, 2016 at 1:40 PM, Caldarale, Charles R <
Chuck.Caldarale at unisys.com> wrote:
> > From: llvm-dev [mailto:llvm-dev-bounces at lists.llvm.org]
> > On Behalf Of Russell Wallace via llvm-dev
> > Subject: [llvm-dev] JIT compiler and calls to existing functions
>
> > In the context of a JIT compiler, what's the recommended way to
generate
> a call to an
> > existing function, that is, not one that you are generating on-the-fly
> with LLVM, but
> > one that's already linked into your program? For example the
cosine
> function (from the
> > standard math library); the Kaleidoscope tutorial recommends looking
it
> up by name with
> > dlsym("cos"), but it seems to me that it should be possible
to use a
> more efficient and
> > portable solution that takes advantage of the fact that you already
have
> an actual pointer
> > to cos, even if you haven't linked with debugging symbols.
>
> Perhaps not the most elegant, but we simply use the
> IRBuilder.CreateIntToPtr() method to construct the Callee argument for
> IRBuilder.CreateCall().  The first argument for CreateIntToPtr() comes from
> ConstantInt::get(I64, uintptr_t(ptr)), while the second is a function type
> pointer defined by using PointerType::get() on the result of
> FunctionType::get() with the appropriate function signature.
>
>  - Chuck
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20160329/80353574/attachment.html>