Open In App
Related Articles

Turning a Function Pointer to Callable

Improve Article
Save Article
Like Article

Well, the memory address of a compiled function is obtained but how to turn it to Python callable that can be used as an extension. The answer to this the use of ctypes module that can create a Python callable and can wrap arbitrary memory address.

The code below shows how to obtain the raw, low-level address of a C function and how to turn it back into a callable object.

Code #1:

import ctypes
lib = ctypes.cdll.LoadLibrary(None)
# Get the address of sin() from the C math library
addr = ctypes.cast(lib.sin, ctypes.c_void_p).value
print ("addr : ", addr)

Output :

addr : 140735505915760

Code #2 : Turn the address into a callable function

functype = ctypes.CFUNCTYPE(ctypes.c_double, ctypes.c_double)
func = functype(addr)
print ("Function : ", func)

Output :

Function : <CFunctionType object at 0x1006816d0>

Code #3 : Call the resulting function

print ("func(2) : ", func(2))
print ("func(0) : ", func(0))

Output :

func(2) : 0.9092974268256817

func(0) : 0.0

A CFUNCTYPE instance has to be created first to make a callable. The first argument to CFUNCTYPE() is the return type. Next arguments are the types of arguments. After defining the function type, it is wrapped around an integer memory address to create a callable object. The resulting object is used like any normal function accessed through ctypes.
It is becoming increasingly common for programs and libraries to utilize advanced code generation techniques like just-in-time compilation, as found in libraries such as LLVM (LLVM itself is not an acronym; it is the full name of the project.)

The code below uses the llvmpy extension to make an assembly function, obtain a function pointer to it, and turn it into a Python callable.

Code #4 :

from llvm.core import Module, Function, Type, Builder
mod ='example')
f =, Type.function(
                  Type.double(), [Type.double(), Type.double()], False), 'foo')
block = f.append_basic_block('entry')
builder =
x2 = builder.fmul(f.args[0], f.args[0])
y2 = builder.fmul(f.args[1], f.args[1])
r = builder.fadd(x2, y2)

Output :

<llvm.core.Instruction object at 0x10078e990>

Code #5 :

from import ExecutionEngine
engine =
ptr = engine.get_pointer_to_function(f)

Output :


Code #6 : Call the resulting function

foo = ctypes.CFUNCTYPE(ctypes.c_double, 
print (foo(2, 3))
print ("\n", foo(4, 5))
print ("\n", foo(1, 2))

Output :




Last Updated : 02 Apr, 2019
Like Article
Save Article
Similar Reads
Related Tutorials