jyapayne/llvmpy
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Removed cyclic dependency _util <-> core. Added testcases. Passes in _core.c. Code cleanup.

Browse source 
git-svn-id: http://llvm-py.googlecode.com/svn/trunk@32 8d1e9007-1d4e-0410-b67e-1979fd6579aa
This commit is contained in:
mdevan.foobar 2008-08-11 17:11:57 +00:00
commit 4ee007190c
7 changed files with 293 additions and 92 deletions
Download patch file Download diff file Expand all files Collapse all files

143
llvm/_core.c
View file

@ -657,14 +657,72 @@ _wrap_obj2none(LLVMDisposePassManager, LLVMPassManagerRef)
/* Passes */ /* Passes */
/*===----------------------------------------------------------------------===*/ /*===----------------------------------------------------------------------===*/
_wrap_obj2none(LLVMAddConstantPropagationPass, LLVMPassManagerRef) #define _wrap_pass(P) \
_wrap_obj2none(LLVMAddInstructionCombiningPass, LLVMPassManagerRef) _wrap_obj2none( LLVMAdd ## P ## Pass, LLVMPassManagerRef)
_wrap_obj2none(LLVMAddPromoteMemoryToRegisterPass, LLVMPassManagerRef)
_wrap_obj2none(LLVMAddDemoteMemoryToRegisterPass, LLVMPassManagerRef)
_wrap_obj2none(LLVMAddReassociatePass, LLVMPassManagerRef)
_wrap_obj2none(LLVMAddGVNPass, LLVMPassManagerRef)
_wrap_obj2none(LLVMAddCFGSimplificationPass, LLVMPassManagerRef)
_wrap_pass( AggressiveDCE )
_wrap_pass( ArgumentPromotion )
_wrap_pass( BlockPlacement )
_wrap_pass( BreakCriticalEdges )
_wrap_pass( CodeGenPrepare )
_wrap_pass( CondPropagation )
_wrap_pass( ConstantMerge )
_wrap_pass( ConstantPropagation )
_wrap_pass( DeadCodeElimination )
_wrap_pass( DeadArgElimination )
_wrap_pass( DeadTypeElimination )
_wrap_pass( DeadInstElimination )
_wrap_pass( DeadStoreElimination )
_wrap_pass( GCSE )
_wrap_pass( GlobalDCE )
_wrap_pass( GlobalOptimizer )
_wrap_pass( GVN )
_wrap_pass( GVNPRE )
_wrap_pass( IndMemRem )
_wrap_pass( IndVarSimplify )
_wrap_pass( FunctionInlining )
_wrap_pass( BlockProfiler )
_wrap_pass( EdgeProfiler )
_wrap_pass( FunctionProfiler )
_wrap_pass( NullProfilerRS )
_wrap_pass( RSProfiling )
_wrap_pass( InstructionCombining )
_wrap_pass( Internalize )
_wrap_pass( IPConstantPropagation )
_wrap_pass( IPSCCP )
_wrap_pass( JumpThreading )
_wrap_pass( LCSSA )
_wrap_pass( LICM )
_wrap_pass( LoopDeletion )
_wrap_pass( LoopExtractor )
_wrap_pass( SingleLoopExtractor )
_wrap_pass( LoopIndexSplit )
_wrap_pass( LoopStrengthReduce )
_wrap_pass( LoopRotate )
_wrap_pass( LoopUnroll )
_wrap_pass( LoopUnswitch )
_wrap_pass( LoopSimplify )
_wrap_pass( LowerAllocations )
_wrap_pass( LowerInvoke )
_wrap_pass( LowerSetJmp )
_wrap_pass( LowerSwitch )
_wrap_pass( PromoteMemoryToRegister )
_wrap_pass( MemCpyOpt )
_wrap_pass( UnifyFunctionExitNodes )
_wrap_pass( PredicateSimplifier )
_wrap_pass( PruneEH )
_wrap_pass( RaiseAllocations )
_wrap_pass( Reassociate )
_wrap_pass( DemoteRegisterToMemory )
_wrap_pass( ScalarReplAggregates )
_wrap_pass( SCCP )
_wrap_pass( SimplifyLibCalls )
_wrap_pass( CFGSimplification )
_wrap_pass( StripSymbols )
_wrap_pass( StripDeadPrototypes )
_wrap_pass( StructRetPromotion )
_wrap_pass( TailCallElimination )
_wrap_pass( TailDuplication )
/*===----------------------------------------------------------------------===*/ /*===----------------------------------------------------------------------===*/
/* Target Data */ /* Target Data */
@ -836,6 +894,7 @@ _wrap_objintlist2obj(LLVMGetIntrinsic, LLVMModuleRef, LLVMTypeRef,
/*===----------------------------------------------------------------------===*/ /*===----------------------------------------------------------------------===*/
#define _method( func ) { # func , _w ## func , METH_VARARGS }, #define _method( func ) { # func , _w ## func , METH_VARARGS },
#define _pass( P ) _method( LLVMAdd ## P ## Pass )
static PyMethodDef core_methods[] = { static PyMethodDef core_methods[] = {
@ -1165,13 +1224,69 @@ static PyMethodDef core_methods[] = {
_method( LLVMDisposePassManager ) _method( LLVMDisposePassManager )
/* Passes */ /* Passes */
_method( LLVMAddConstantPropagationPass ) _pass( AggressiveDCE )
_method( LLVMAddInstructionCombiningPass ) _pass( ArgumentPromotion )
_method( LLVMAddPromoteMemoryToRegisterPass ) _pass( BlockPlacement )
_method( LLVMAddDemoteMemoryToRegisterPass ) _pass( BreakCriticalEdges )
_method( LLVMAddReassociatePass ) _pass( CodeGenPrepare )
_method( LLVMAddGVNPass ) _pass( CondPropagation )
_method( LLVMAddCFGSimplificationPass ) _pass( ConstantMerge )
_pass( ConstantPropagation )
_pass( DeadCodeElimination )
_pass( DeadArgElimination )
_pass( DeadTypeElimination )
_pass( DeadInstElimination )
_pass( DeadStoreElimination )
_pass( GCSE )
_pass( GlobalDCE )
_pass( GlobalOptimizer )
_pass( GVN )
_pass( GVNPRE )
_pass( IndMemRem )
_pass( IndVarSimplify )
_pass( FunctionInlining )
_pass( BlockProfiler )
_pass( EdgeProfiler )
_pass( FunctionProfiler )
_pass( NullProfilerRS )
_pass( RSProfiling )
_pass( InstructionCombining )
_pass( Internalize )
_pass( IPConstantPropagation )
_pass( IPSCCP )
_pass( JumpThreading )
_pass( LCSSA )
_pass( LICM )
_pass( LoopDeletion )
_pass( LoopExtractor )
_pass( SingleLoopExtractor )
_pass( LoopIndexSplit )
_pass( LoopStrengthReduce )
_pass( LoopRotate )
_pass( LoopUnroll )
_pass( LoopUnswitch )
_pass( LoopSimplify )
_pass( LowerAllocations )
_pass( LowerInvoke )
_pass( LowerSetJmp )
_pass( LowerSwitch )
_pass( PromoteMemoryToRegister )
_pass( MemCpyOpt )
_pass( UnifyFunctionExitNodes )
_pass( PredicateSimplifier )
_pass( PruneEH )
_pass( RaiseAllocations )
_pass( Reassociate )
_pass( DemoteRegisterToMemory )
_pass( ScalarReplAggregates )
_pass( SCCP )
_pass( SimplifyLibCalls )
_pass( CFGSimplification )
_pass( StripSymbols )
_pass( StripDeadPrototypes )
_pass( StructRetPromotion )
_pass( TailCallElimination )
_pass( TailDuplication )
/* Target Data */ /* Target Data */
_method( LLVMCreateTargetData ) _method( LLVMCreateTargetData )

14
llvm/_util.py
View file

@ -2,7 +2,6 @@
Used only in other modules, not for public use.""" Used only in other modules, not for public use."""
import llvm.core as core
import llvm import llvm
@ -17,15 +16,6 @@ def check_gen(obj, type):
msg = "argument not an instance of llvm.core.%s" % type_str msg = "argument not an instance of llvm.core.%s" % type_str
raise TypeError, msg raise TypeError, msg
def check_is_type(obj): check_gen(obj, core.Type)
def check_is_value(obj): check_gen(obj, core.Value)
def check_is_pointer(obj): check_gen(obj, core.Pointer)
def check_is_constant(obj): check_gen(obj, core.Constant)
def check_is_function(obj): check_gen(obj, core.Function)
def check_is_basic_block(obj): check_gen(obj, core.BasicBlock)
def check_is_module(obj): check_gen(obj, core.Module)
def check_is_module_provider(obj): check_gen(obj, core.ModuleProvider)
def check_is_unowned(ownable): def check_is_unowned(ownable):
if ownable.owner: if ownable.owner:
raise llvm.LLVMException, "object is already owned" raise llvm.LLVMException, "object is already owned"
@ -41,10 +31,6 @@ def unpack_gen(objlist, check_fn):
for obj in objlist: check_fn(obj) for obj in objlist: check_fn(obj)
return [ obj.ptr for obj in objlist ] return [ obj.ptr for obj in objlist ]
def unpack_types(objlist): return unpack_gen(objlist, check_is_type)
def unpack_values(objlist): return unpack_gen(objlist, check_is_value)
def unpack_constants(objlist): return unpack_gen(objlist, check_is_constant)
#===----------------------------------------------------------------------=== #===----------------------------------------------------------------------===
# Helper to wrap over iterables (LLVMFirstXXX, LLVMNextXXX). This used # Helper to wrap over iterables (LLVMFirstXXX, LLVMNextXXX). This used

94
llvm/core.py
View file

@ -13,7 +13,6 @@ from llvm._util import * # utility functions
# Enumerations # Enumerations
#===----------------------------------------------------------------------=== #===----------------------------------------------------------------------===
# type kinds # type kinds
TYPE_VOID = 0 TYPE_VOID = 0
TYPE_FLOAT = 1 TYPE_FLOAT = 1
@ -694,9 +693,26 @@ INTR_X86_SSSE3_PSIGN_W_128 = 594
#===----------------------------------------------------------------------=== #===----------------------------------------------------------------------===
# Module # Helpers (for internal use)
#===----------------------------------------------------------------------=== #===----------------------------------------------------------------------===
def check_is_type(obj): check_gen(obj, Type)
def check_is_value(obj): check_gen(obj, Value)
def check_is_pointer(obj): check_gen(obj, Pointer)
def check_is_constant(obj): check_gen(obj, Constant)
def check_is_function(obj): check_gen(obj, Function)
def check_is_basic_block(obj): check_gen(obj, BasicBlock)
def check_is_module(obj): check_gen(obj, Module)
def check_is_module_provider(obj): check_gen(obj, ModuleProvider)
def unpack_types(objlist): return unpack_gen(objlist, check_is_type)
def unpack_values(objlist): return unpack_gen(objlist, check_is_value)
def unpack_constants(objlist): return unpack_gen(objlist, check_is_constant)
#===----------------------------------------------------------------------===
# Module
#===----------------------------------------------------------------------===
class Module(llvm.Ownable): class Module(llvm.Ownable):
"""A Module instance stores all the information related to an LLVM module. """A Module instance stores all the information related to an LLVM module.
@ -865,7 +881,6 @@ class Module(llvm.Ownable):
# Types # Types
#===----------------------------------------------------------------------=== #===----------------------------------------------------------------------===
class Type(object): class Type(object):
"""Represents a type, like a 32-bit integer or an 80-bit x86 float. """Represents a type, like a 32-bit integer or an 80-bit x86 float.
@ -1181,7 +1196,6 @@ def _make_type(ptr, kind):
# Type Handle # Type Handle
#===----------------------------------------------------------------------=== #===----------------------------------------------------------------------===
class TypeHandle(object): class TypeHandle(object):
@staticmethod @staticmethod
@ -1205,7 +1219,6 @@ class TypeHandle(object):
# Values # Values
#===----------------------------------------------------------------------=== #===----------------------------------------------------------------------===
class Value(object): class Value(object):
def __init__(self, ptr): def __init__(self, ptr):
@ -1220,13 +1233,13 @@ class Value(object):
else: else:
return False return False
def get_name(self): def _get_name(self):
return _core.LLVMGetValueName(self.ptr) return _core.LLVMGetValueName(self.ptr)
def set_name(self, value): def _set_name(self, value):
return _core.LLVMSetValueName(self.ptr, value) return _core.LLVMSetValueName(self.ptr, value)
name = property(get_name, set_name) name = property(_get_name, _set_name)
@property @property
def type(self): def type(self):
@ -1472,21 +1485,21 @@ class GlobalValue(Constant):
self._module = None # set it free self._module = None # set it free
self.ptr = None self.ptr = None
def get_linkage(self): return _core.LLVMGetLinkage(self.ptr) def _get_linkage(self): return _core.LLVMGetLinkage(self.ptr)
def set_linkage(self, value): _core.LLVMSetLinkage(self.ptr, value) def _set_linkage(self, value): _core.LLVMSetLinkage(self.ptr, value)
linkage = property(get_linkage, set_linkage) linkage = property(_get_linkage, _set_linkage)
def get_section(self): return _core.LLVMGetSection(self.ptr) def _get_section(self): return _core.LLVMGetSection(self.ptr)
def set_section(self, value): return _core.LLVMSetSection(self.ptr, value) def _set_section(self, value): return _core.LLVMSetSection(self.ptr, value)
section = property(get_section, set_section) section = property(_get_section, _set_section)
def get_visibility(self): return _core.LLVMGetVisibility(self.ptr) def _get_visibility(self): return _core.LLVMGetVisibility(self.ptr)
def set_visibility(self, value): return _core.LLVMSetVisibility(self.ptr, value) def _set_visibility(self, value): return _core.LLVMSetVisibility(self.ptr, value)
visibility = property(get_visibility, set_visibility) visibility = property(_get_visibility, _set_visibility)
def get_alignment(self): return _core.LLVMGetAlignment(self.ptr) def _get_alignment(self): return _core.LLVMGetAlignment(self.ptr)
def set_alignment(self, value): return _core.LLVMSetAlignment(self.ptr, value) def _set_alignment(self, value): return _core.LLVMSetAlignment(self.ptr, value)
alignment = property(get_alignment, set_alignment) alignment = property(_get_alignment, _set_alignment)
@property @property
def is_declaration(self): def is_declaration(self):
@ -1518,26 +1531,26 @@ class GlobalVariable(GlobalValue):
_core.LLVMDeleteGlobal(self.ptr) _core.LLVMDeleteGlobal(self.ptr)
self._delete() self._delete()
def get_initializer(self): def _get_initializer(self):
if _core.LLVMHasInitializer(self.ptr): if _core.LLVMHasInitializer(self.ptr):
return Constant(_core.LLVMGetInitializer(self.ptr)) return Constant(_core.LLVMGetInitializer(self.ptr))
else: else:
return None return None
def set_initializer(self, const): def _set_initializer(self, const):
check_is_constant(const) check_is_constant(const)
_core.LLVMSetInitializer(self.ptr, const.ptr) _core.LLVMSetInitializer(self.ptr, const.ptr)
initializer = property(get_initializer, set_initializer) initializer = property(_get_initializer, _set_initializer)
def get_is_global_constant(self): def _get_is_global_constant(self):
return _core.LLVMIsGlobalConstant(self.ptr) return _core.LLVMIsGlobalConstant(self.ptr)
def set_is_global_constant(self, value): def _set_is_global_constant(self, value):
value = 1 if value else 0 value = 1 if value else 0
_core.LLVMSetGlobalConstant(self.ptr, value) _core.LLVMSetGlobalConstant(self.ptr, value)
global_constant = property(get_is_global_constant, set_is_global_constant) global_constant = property(_get_is_global_constant, _set_is_global_constant)
class Argument(Value): class Argument(Value):
@ -1587,13 +1600,13 @@ class Function(GlobalValue):
def intrinsic_id(self): def intrinsic_id(self):
return _core.LLVMGetIntrinsicID(self.ptr) return _core.LLVMGetIntrinsicID(self.ptr)
def get_calling_convention(self): return _core.LLVMGetFunctionCallConv(self.ptr) def _get_cc(self): return _core.LLVMGetFunctionCallConv(self.ptr)
def set_calling_convention(self, value): _core.LLVMSetFunctionCallConv(self.ptr, value) def _set_cc(self, value): _core.LLVMSetFunctionCallConv(self.ptr, value)
calling_convention = property(get_calling_convention, set_calling_convention) calling_convention = property(_get_cc, _set_cc)
def get_collector(self): return _core.LLVMGetCollector(self.ptr) def _get_coll(self): return _core.LLVMGetCollector(self.ptr)
def set_collector(self, value): _core.LLVMSetCollector(self.ptr, value) def _set_coll(self, value): _core.LLVMSetCollector(self.ptr, value)
collector = property(get_collector, set_collector) collector = property(_get_coll, _set_coll)
@property @property
def args(self): def args(self):
@ -1642,9 +1655,9 @@ class CallOrInvokeInstruction(Instruction):
def __init__(self, ptr): def __init__(self, ptr):
Instruction.__init__(self, ptr) Instruction.__init__(self, ptr)
def get_calling_convention(self): return _core.LLVMGetInstructionCallConv(self.ptr) def _get_cc(self): return _core.LLVMGetInstructionCallConv(self.ptr)
def set_calling_convention(self, value): _core.LLVMSetInstructionCallConv(self.ptr, value) def _set_cc(self, value): _core.LLVMSetInstructionCallConv(self.ptr, value)
calling_convention = property(get_calling_convention, set_calling_convention) calling_convention = property(_get_cc, _set_cc)
def add_parameter_attribute(self, idx, attr): def add_parameter_attribute(self, idx, attr):
_core.LLVMAddInstrParamAttr(self.ptr, idx, attr) _core.LLVMAddInstrParamAttr(self.ptr, idx, attr)
@ -1692,7 +1705,6 @@ class SwitchInstruction(Instruction):
# Basic block # Basic block
#===----------------------------------------------------------------------=== #===----------------------------------------------------------------------===
class BasicBlock(Value): class BasicBlock(Value):
def __init__(self, ptr): def __init__(self, ptr):
@ -1705,9 +1717,10 @@ class BasicBlock(Value):
_core.LLVMDeleteBasicBlock(self.ptr) _core.LLVMDeleteBasicBlock(self.ptr)
self.ptr = None self.ptr = None
@property #-- disabled till we find a proper way to do it --
def function(self): #@property
return Function(_core.LLVMGetBasicBlockParent(self.ptr)) #def function(self):
# return Function(_core.LLVMGetBasicBlockParent(self.ptr))
@property @property
def instructions(self): def instructions(self):
@ -1719,7 +1732,6 @@ class BasicBlock(Value):
# Builder # Builder
#===----------------------------------------------------------------------=== #===----------------------------------------------------------------------===
class Builder(object): class Builder(object):
@staticmethod @staticmethod
@ -2058,7 +2070,6 @@ class Builder(object):
# Module provider # Module provider
#===----------------------------------------------------------------------=== #===----------------------------------------------------------------------===
class ModuleProvider(llvm.Ownable): class ModuleProvider(llvm.Ownable):
@staticmethod @staticmethod
@ -2080,7 +2091,6 @@ class ModuleProvider(llvm.Ownable):
# Memory buffer # Memory buffer
#===----------------------------------------------------------------------=== #===----------------------------------------------------------------------===
class MemoryBuffer(object): class MemoryBuffer(object):
@staticmethod @staticmethod

23
llvm/ee.py
View file

@ -33,19 +33,19 @@ class GenericValue(object):
@staticmethod @staticmethod
def int(ty, intval): def int(ty, intval):
check_is_type(ty) core.check_is_type(ty)
ptr = _core.LLVMCreateGenericValueOfInt(ty.ptr, intval, 0) ptr = _core.LLVMCreateGenericValueOfInt(ty.ptr, intval, 0)
return GenericValue(ptr) return GenericValue(ptr)
@staticmethod @staticmethod
def int_signed(ty, intval): def int_signed(ty, intval):
check_is_type(ty) core.check_is_type(ty)
ptr = _core.LLVMCreateGenericValueOfInt(ty.ptr, intval, 1) ptr = _core.LLVMCreateGenericValueOfInt(ty.ptr, intval, 1)
return GenericValue(ptr) return GenericValue(ptr)
@staticmethod @staticmethod
def real(ty, floatval): def real(ty, floatval):
check_is_type(ty) # only float or double core.check_is_type(ty) # only float or double
ptr = _core.LLVMCreateGenericValueOfFloat(ty.ptr, floatval) ptr = _core.LLVMCreateGenericValueOfFloat(ty.ptr, floatval)
return GenericValue(ptr) return GenericValue(ptr)
@ -62,14 +62,14 @@ class GenericValue(object):
return _core.LLVMGenericValueToInt(self.ptr, 1) return _core.LLVMGenericValueToInt(self.ptr, 1)
def as_real(self, ty): def as_real(self, ty):
check_is_type(ty) # only float or double core.check_is_type(ty) # only float or double
return _core.LLVMGenericValueToFloat(ty.ptr, self.ptr) return _core.LLVMGenericValueToFloat(ty.ptr, self.ptr)
# helper functions for generic value objects # helper functions for generic value objects
def _check_is_generic_value(obj): check_gen(obj, GenericValue) def check_is_generic_value(obj): check_gen(obj, GenericValue)
def _unpack_generic_values(objlist): def _unpack_generic_values(objlist):
return unpack_gen(objlist, _check_is_generic_value) return unpack_gen(objlist, check_is_generic_value)
#===----------------------------------------------------------------------=== #===----------------------------------------------------------------------===
@ -80,8 +80,8 @@ class ExecutionEngine(object):
@staticmethod @staticmethod
def new(mp, force_interpreter=False): def new(mp, force_interpreter=False):
check_is_module_provider(mp) core.check_is_module_provider(mp)
check_is_unowned(mp) core.check_is_unowned(mp)
ret = _core.LLVMCreateExecutionEngine(mp.ptr, int(force_interpreter)) ret = _core.LLVMCreateExecutionEngine(mp.ptr, int(force_interpreter))
if isinstance(ret, str): if isinstance(ret, str):
raise llvm.LLVMException, ret raise llvm.LLVMException, ret
@ -95,7 +95,7 @@ class ExecutionEngine(object):
_core.LLVMDisposeExecutionEngine(self.ptr) _core.LLVMDisposeExecutionEngine(self.ptr)
def run_function(self, fn, args): def run_function(self, fn, args):
check_is_function(fn) core.check_is_function(fn)
ptrs = _unpack_generic_values(args) ptrs = _unpack_generic_values(args)
gvptr = _core.LLVMRunFunction2(self.ptr, fn.ptr, ptrs) gvptr = _core.LLVMRunFunction2(self.ptr, fn.ptr, ptrs)
return GenericValue(gvptr) return GenericValue(gvptr)
@ -107,11 +107,12 @@ class ExecutionEngine(object):
_core.LLVMRunStaticDestructors(self.ptr) _core.LLVMRunStaticDestructors(self.ptr)
def free_machine_code_for(self, fn): def free_machine_code_for(self, fn):
check_is_function(fn) core.check_is_function(fn)
_core.LLVMFreeMachineCodeForFunction(self.ptr, fn.ptr) _core.LLVMFreeMachineCodeForFunction(self.ptr, fn.ptr)
# CRASH! BOOM!! BANG!!! TODO FIXME
def add_module_provider(self, mp): def add_module_provider(self, mp):
check_is_module_provider(mp) core.check_is_module_provider(mp)
_core.LLVMAddModuleProvider(self.ptr, mp.ptr) _core.LLVMAddModuleProvider(self.ptr, mp.ptr)
@property @property

3
setup.py
View file

@ -50,7 +50,8 @@ def call_setup(llvm_config):
ldflags = _run(llvm_config + ' --ldflags') ldflags = _run(llvm_config + ' --ldflags')
libs_core, objs_core = get_libs_and_objs(llvm_config, libs_core, objs_core = get_libs_and_objs(llvm_config,
['core', 'analysis', 'scalaropts', 'executionengine', ['core', 'analysis', 'scalaropts', 'executionengine',
'jit', 'native', 'interpreter', 'bitreader', 'bitwriter']) 'jit', 'native', 'interpreter', 'bitreader', 'bitwriter',
'instrumentation', 'ipa', 'ipo', 'transformutils'])
std_libs = [ 'pthread', 'm' ] std_libs = [ 'pthread', 'm' ]
if not sys.platform.startswith("openbsd"): if not sys.platform.startswith("openbsd"):

96
test/testall.py
View file

@ -8,9 +8,30 @@
from llvm import * from llvm import *
from llvm.core import * from llvm.core import *
from llvm.ee import *
ti = Type.int() ti = Type.int()
def do_llvmexception():
print " Testing class LLVMException"
e = LLVMException()
def do_ownable():
print " Testing class Ownable"
o = Ownable(None, lambda x: None)
try:
o._own(None)
o._disown()
except LLVMException:
pass
def do_llvm():
print " Testing module llvm"
do_llvmexception()
do_ownable()
def do_module(): def do_module():
print " Testing class Module" print " Testing class Module"
m = Module.new('test') m = Module.new('test')
@ -134,7 +155,7 @@ def do_constant():
k = Constant.int(ti, 10) k = Constant.int(ti, 10)
f = Constant.real(Type.float(), 3.1415) f = Constant.real(Type.float(), 3.1415)
k.neg().not_().add(k).sub(k).mul(k).udiv(k).sdiv(k).urem(k) k.neg().not_().add(k).sub(k).mul(k).udiv(k).sdiv(k).urem(k)
k.srem(k).and_(k).or_(k).icmp(IPRED_ULT, k) k.srem(k).and_(k).or_(k).xor(k).icmp(IPRED_ULT, k)
f.fdiv(f).frem(f).fcmp(RPRED_ULT, f) f.fdiv(f).frem(f).fcmp(RPRED_ULT, f)
vi = Constant.vector([Constant.int(ti,42)]*10) vi = Constant.vector([Constant.int(ti,42)]*10)
vf = Constant.vector([Constant.real(Type.float(), 3.14)]*10) vf = Constant.vector([Constant.real(Type.float(), 3.14)]*10)
@ -168,7 +189,6 @@ def do_global_value():
gv = GlobalVariable.new(m, Type.int(), 'b') gv = GlobalVariable.new(m, Type.int(), 'b')
s = gv.is_declaration s = gv.is_declaration
m = gv.module m = gv.module
s = gv.is_declaration
gv.linkage = LINKAGE_EXTERNAL gv.linkage = LINKAGE_EXTERNAL
s = gv.linkage s = gv.linkage
gv.section = '.text' gv.section = '.text'
@ -214,6 +234,7 @@ def do_function():
f.delete() f.delete()
ft = Type.function(ti, [ti]*20) ft = Type.function(ti, [ti]*20)
f = Function.new(m, ft, 'func2') f = Function.new(m, ft, 'func2')
f2 = Function.intrinsic(m, INTR_COS, [ti])
g = f.intrinsic_id g = f.intrinsic_id
f.calling_convenion = CC_FASTCALL f.calling_convenion = CC_FASTCALL
g = f.calling_convenion g = f.calling_convenion
@ -286,6 +307,22 @@ def do_switchinstruction():
s.add_case(Constant.int(ti, 10), b) s.add_case(Constant.int(ti, 10), b)
def do_basicblock():
print " Testing class BasicBlock"
m = Module.new('a')
ft = Type.function(ti, [ti])
f = Function.new(m, ft, 'func')
b = f.append_basic_block('b')
bb = Builder.new(b)
s = bb.switch(f.args[0], b)
s.add_case(Constant.int(ti, 10), b)
s = list(b.instructions)
b2 = b.insert_before('before')
b2.delete()
# ff = b.function
# ^ not working yet!
def do_builder(): def do_builder():
print " Testing class Builder" print " Testing class Builder"
m = Module.new('a') m = Module.new('a')
@ -387,14 +424,65 @@ def do_llvm_core():
do_callorinvokeinstruction() do_callorinvokeinstruction()
do_phinode() do_phinode()
do_switchinstruction() do_switchinstruction()
do_basicblock()
do_builder() do_builder()
do_moduleprovider() do_moduleprovider()
def do_llvm(): def do_targetdata():
print " Testing class TargetData"
t = TargetData.new('')
t = str(t)
def do_genericvalue():
print " Testing class GenericValue"
v = GenericValue.int(ti, 1)
v = GenericValue.int_signed(ti, 1)
v = GenericValue.real(Type.float(), 3.14)
a = v.as_int()
a = v.as_int_signed()
a = v.as_real(Type.float())
def do_executionengine():
print " Testing class ExecutionEngine"
m = Module.new('a')
mp = ModuleProvider.new(m)
ee = ExecutionEngine.new(mp, True)
ft = Type.function(ti, [])
f = m.add_function(ft, 'func')
bb = f.append_basic_block('entry')
b = Builder.new(bb)
b.ret(Constant.int(ti, 42))
gv = ee.run_function(f, [])
is42 = gv.as_int() == 42
ee.run_static_ctors()
ee.run_static_dtors()
ee.free_machine_code_for(f)
t = ee.target_data
m2 = Module.new('b')
mp2 = ModuleProvider.new(m2)
# CRASHES!! TODO FIXME
# ee.add_module_provider(mp2)
m3 = Module.new('c')
mp3 = ModuleProvider.new(m3)
ee2 = ExecutionEngine.new(mp3, False)
def do_llvm_ee():
print " Testing module llvm.ee"
do_targetdata()
do_genericvalue()
do_executionengine()
def main():
print "Testing package llvm" print "Testing package llvm"
do_llvm()
do_llvm_core() do_llvm_core()
do_llvm_ee()
do_llvm() main()