def create_target_machine(self, cpu='', features='',
opt=2, reloc='default', codemodel='jitdefault',
jitdebug=False, printmc=False):
"""
Create a new TargetMachine for this target and the given options.
Specifying codemodel='default' will result in the use of the "small"
code model. Specifying codemodel='jitdefault' will result in the code
model being picked based on platform bitness (32="small", 64="large").
"""
assert 0 <= opt <= 3
assert reloc in RELOC
assert codemodel in CODEMODEL
triple = self._triple
# MCJIT under Windows only supports ELF objects, see
# http://lists.llvm.org/pipermail/llvm-dev/2013-December/068341.html
# Note we still want to produce regular COFF files in AOT mode.
if os.name == 'nt' and codemodel == 'jitdefault':
triple += '-elf'
tm = ffi.lib.LLVMPY_CreateTargetMachine(self,
_encode_string(triple),
_encode_string(cpu),
_encode_string(features),
opt,
_encode_string(reloc),
_encode_string(codemodel),
int(jitdebug),
int(printmc),
)
if tm:
return TargetMachine(tm)
else:
raise RuntimeError("Cannot create target machine")
def set_option(name, option):
"""
Set the given LLVM "command-line" option.
For example set_option("test", "-debug-pass=Structure") would display
all optimization passes when generating code.
"""
ffi.lib.LLVMPY_SetCommandLine(_encode_string(name), _encode_string(option))
def load_library_permanently(filename):
"""
Load an external library
"""
with ffi.OutputString() as outerr:
if ffi.lib.LLVMPY_LoadLibraryPermanently(
_encode_string(filename), outerr):
raise RuntimeError(str(outerr))
def get_struct_type(self, name):
"""
Get a TypeRef pointing to a structure type named *name*.
NameError is raised if the struct type isn't found.
"""
p = ffi.lib.LLVMPY_GetNamedStructType(self, _encode_string(name))
if not p:
raise NameError(name)
return TypeRef(p)
def get_global_variable(self, name):
"""
Get a ValueRef pointing to the global variable named *name*.
NameError is raised if the symbol isn't found.
"""
p = ffi.lib.LLVMPY_GetNamedGlobalVariable(self, _encode_string(name))
if not p:
raise NameError(name)
return ValueRef(p, 'global', dict(module=self))
def get_function(self, name):
"""
Get a ValueRef pointing to the function named *name*.
NameError is raised if the symbol isn't found.
"""
p = ffi.lib.LLVMPY_GetNamedFunction(self, _encode_string(name))
if not p:
raise NameError(name)
return ValueRef(p, 'function', dict(module=self))
def get_object_format(triple=None):
"""
Get the object format for the given *triple* string (or the default
triple if omitted).
A string is returned
"""
if triple is None:
triple = get_default_triple()
res = ffi.lib.LLVMPY_GetTripleObjectFormat(_encode_string(triple))
return _object_formats[res]
def parse_assembly(llvmir, context=None):
"""
Create Module from a LLVM IR string
"""
if context is None:
context = get_global_context()
llvmir = _encode_string(llvmir)
strbuf = c_char_p(llvmir)
with ffi.OutputString() as errmsg:
mod = ModuleRef(ffi.lib.LLVMPY_ParseAssembly(context, strbuf, errmsg),
context)
if errmsg:
mod.close()
raise RuntimeError("LLVM IR parsing error\n{0}".format(errmsg))
return mod
def add_function_attribute(self, attr):
"""Only works on function value
Parameters
-----------
attr : str
attribute name
"""
if not self.is_function:
raise ValueError("expected function value, got %s" % (self._kind,))
attrname = str(attr)
attrval = ffi.lib.LLVMPY_GetEnumAttributeKindForName(
_encode_string(attrname), len(attrname)
)
if attrval == 0:
raise ValueError("no such attribute {!r}".format(attrname))
ffi.lib.LLVMPY_AddFunctionAttr(self, attrval)
def create_target_machine(self,
cpu='',
features='',
opt=2,
reloc='default',
codemodel='jitdefault',
printmc=False,
jit=False,
abiname=''):
"""
Create a new TargetMachine for this target and the given options.
Specifying codemodel='default' will result in the use of the "small"
code model. Specifying codemodel='jitdefault' will result in the code
model being picked based on platform bitness (32="small", 64="large").
The `printmc` option corresponds to llvm's `-print-machineinstrs`.
The `jit` option should be set when the target-machine is to be used
in a JIT engine.
The `abiname` option specifies the ABI. RISC-V targets with hard-float
needs to pass the ABI name to LLVM.
"""
assert 0 <= opt <= 3
assert reloc in RELOC
assert codemodel in CODEMODEL
triple = self._triple
# MCJIT under Windows only supports ELF objects, see
# http://lists.llvm.org/pipermail/llvm-dev/2013-December/068341.html
# Note we still want to produce regular COFF files in AOT mode.
if os.name == 'nt' and codemodel == 'jitdefault':
triple += '-elf'
tm = ffi.lib.LLVMPY_CreateTargetMachine(
self,
_encode_string(triple),
_encode_string(cpu),
_encode_string(features),
opt,
_encode_string(reloc),
_encode_string(codemodel),
int(printmc),
int(jit),
_encode_string(abiname),
)
if tm:
return TargetMachine(tm)
else:
raise RuntimeError("Cannot create target machine")
def load_library_permanently(filename):
"""
Load an external library
"""
print("load_library_permanently({})".format(filename))
from logging import getLogger
import os
log = getLogger(__name__)
log.warning("load_library_permanently({})".format(filename))
log.warning("load_library_permanently .. so.environ[PATH] is: {}".format(
os.environ['PATH']))
try:
with ffi.OutputString() as outerr:
if ffi.lib.LLVMPY_LoadLibraryPermanently(_encode_string(filename),
outerr):
raise RuntimeError(
str(outerr) +
'\nLIZZY PATH is: {}'.format(os.environ['PATH']))
except Exception as e:
raise RuntimeError(
str(outerr) + '\nLIZZY2 PATH is: {}'.format(os.environ['PATH']))
def name(self, val):
ffi.lib.LLVMPY_SetValueName(self, _encode_string(val))
def name(self, value):
ffi.lib.LLVMPY_SetModuleName(self, _encode_string(value))
def address_of_symbol(name):
"""
Get the in-process address of symbol named *name*.
An integer is returned, or None if the symbol isn't found.
"""
return ffi.lib.LLVMPY_SearchAddressOfSymbol(_encode_string(name))
def add_symbol(name, address):
"""
Register the *address* of global symbol *name*. This will make
it usable (e.g. callable) from LLVM-compiled functions.
"""
ffi.lib.LLVMPY_AddSymbol(_encode_string(name), c_void_p(address))
def create_target_data(layout):
"""
Create a TargetData instance for the given *layout* string.
"""
return TargetData(ffi.lib.LLVMPY_CreateTargetData(_encode_string(layout)))
