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 = Module.new('example') f = Function.new(mod, Type.function( Type.double(), [Type.double(), Type.double()], False), 'foo') block = f.append_basic_block('entry') builder = Builder.new(block) x2 = builder.fmul(f.args[0], f.args[0]) y2 = builder.fmul(f.args[1], f.args[1]) r = builder.fadd(x2, y2) builder.ret(r) |
Output :
<llvm.core.Instruction object at 0x10078e990>
Code #5 :
from llvm.ee import ExecutionEngine engine = ExecutionEngine.new(mod) ptr = engine.get_pointer_to_function(f) ptr |
Output :
4325863440
Code #6 : Call the resulting function
foo = ctypes.CFUNCTYPE(ctypes.c_double, ctypes.c_double, ctypes.c_double)(ptr) print (foo(2, 3)) print ("\n", foo(4, 5)) print ("\n", foo(1, 2)) |
Output :
13.0 41.0 5.0
