From 5b2b878f24cc5e56d8aaf5bf01757ff0594139db Mon Sep 17 00:00:00 2001 From: Siu Kwan Lam Date: Wed, 22 May 2013 15:17:59 -0500 Subject: [PATCH 01/11] Enable MCJIT --- llvm/ee.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/llvm/ee.py b/llvm/ee.py index e4ee4bc..7ea90d0 100644 --- a/llvm/ee.py +++ b/llvm/ee.py @@ -167,6 +167,11 @@ class EngineBuilder(llvm.Wrapper): ptr = self._ptr.selectTarget() return TargetMachine(ptr) + def mcjit(self, enable): + '''Enable/disable MCJIT + ''' + self._ptr.setUseMCJIT(enable) + return self #===----------------------------------------------------------------------=== # Execution engine From a0eb03b23950b9095f30e0bf15cd48d03166ab6e Mon Sep 17 00:00:00 2001 From: Siu Kwan Lam Date: Thu, 23 May 2013 11:45:15 -0500 Subject: [PATCH 02/11] Fix CompareInstruction.predicate --- llvm/core.py | 18 ++++++++++++++-- llvm/test_llvmpy.py | 51 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 67 insertions(+), 2 deletions(-) diff --git a/llvm/core.py b/llvm/core.py index 9cb1946..fd72902 100644 --- a/llvm/core.py +++ b/llvm/core.py @@ -55,12 +55,18 @@ class Enum(int): @classmethod def declare(cls): + declared = cls._declared_ = {} scope = globals() for name in filter(lambda s: s.startswith(cls.prefix), dir(cls)): n = getattr(cls, name) typ = type(name, (cls,), {}) - scope[name] = typ(n) + obj = typ(n) + declared[n] = obj + scope[name] = obj + @classmethod + def get(cls, num): + return cls._declared_[num] # type id (llvm::Type::TypeID) class TypeEnum(Enum): @@ -1872,16 +1878,24 @@ class PHINode(Instruction): class SwitchInstruction(Instruction): + _type_ = api.llvm.SwitchInst def add_case(self, const, bblk): self._ptr.addCase(const._ptr, bblk._ptr) class CompareInstruction(Instruction): + _type_ = api.llvm.CmpInst @property def predicate(self): - return self._ptr.getPredicate() + n = self._ptr.getPredicate() + try: + return ICMPEnum.get(n) + except KeyError: + return FCMPEnum.get(n) + + #===----------------------------------------------------------------------=== # Basic block #===----------------------------------------------------------------------=== diff --git a/llvm/test_llvmpy.py b/llvm/test_llvmpy.py index 3ecffff..e21a825 100644 --- a/llvm/test_llvmpy.py +++ b/llvm/test_llvmpy.py @@ -1302,6 +1302,57 @@ class TestArgAttr(TestCase): tests.append(TestArgAttr) +# --------------------------------------------------------------------------- + +class TestSwitch(TestCase): + def test_arg_attr(self): + m = Module.new('oifjda') + fnty = Type.function(Type.void(), [Type.int()]) + func = m.add_function(fnty, 'foo') + bb = func.append_basic_block('') + bbdef = func.append_basic_block('') + bbsw1 = func.append_basic_block('') + bbsw2 = func.append_basic_block('') + bldr = Builder.new(bb) + + swt = bldr.switch(func.args[0], bbdef, n=2) + swt.add_case(Constant.int(Type.int(), 0), bbsw1) + swt.add_case(Constant.int(Type.int(), 1), bbsw2) + + bldr.position_at_end(bbsw1) + bldr.ret_void() + + bldr.position_at_end(bbsw2) + bldr.ret_void() + + bldr.position_at_end(bbdef) + bldr.ret_void() + + func.verify() + +tests.append(TestSwitch) + +# --------------------------------------------------------------------------- + +class TestCmp(TestCase): + def test_arg_attr(self): + m = Module.new('oifjda') + fnty = Type.function(Type.void(), [Type.int()]) + func = m.add_function(fnty, 'foo') + bb = func.append_basic_block('') + bldr = Builder.new(bb) + + cmpinst = bldr.icmp(lc.ICMP_ULE, func.args[0], + Constant.int(Type.int(), 123)) + self.assertTrue(repr(cmpinst.predicate).startswith('ICMP_ULE')) + self.assertEqual(cmpinst.predicate, lc.ICMP_ULE) + bldr.ret_void() + + func.verify() + +tests.append(TestCmp) + + # --------------------------------------------------------------------------- def run(verbosity=1): From 1812cff2d0e23eaaccbe609d1bd9ae69b0af568f Mon Sep 17 00:00:00 2001 From: "Travis E. Oliphant" Date: Sat, 25 May 2013 13:34:14 -0500 Subject: [PATCH 03/11] Fix import problem. --- llvm_array/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/llvm_array/__init__.py b/llvm_array/__init__.py index f6a0f3f..5e807c2 100644 --- a/llvm_array/__init__.py +++ b/llvm_array/__init__.py @@ -1,2 +1,2 @@ from __future__ import absolute_imports -from .array.py import * +from .array import * From 009239713eb97ead506584652325f9ddf260557a Mon Sep 17 00:00:00 2001 From: "Travis E. Oliphant" Date: Sat, 25 May 2013 13:35:37 -0500 Subject: [PATCH 04/11] Update llvm_array concepts. --- llvm_array/array.py | 261 +++++++++++++++++++++++++++++++------------- 1 file changed, 187 insertions(+), 74 deletions(-) diff --git a/llvm_array/array.py b/llvm_array/array.py index 12df60e..3cac244 100644 --- a/llvm_array/array.py +++ b/llvm_array/array.py @@ -24,19 +24,98 @@ # intp stride; #} diminfo # +# These are for low-level array-routines that need to know the number +# of dimensions at run-time (not just code-generation time): +# +# The first two are recommended +# +# struct { +# eltype *data; +# int32 nd; +# intp shape[nd]; +# } contiguous_array_nd(eltype) +# +# struct { +# eltype *data; +# int32 nd; +# diminfo shape[nd]; +# } strided_array_nd(eltype) +# +# +# Backward compatible but deprecated: +# struct { +# eltype *data; +# int32 nd; +# intp shape[nd]; +# intp stride[nd]; +# } strided_soa_array_nd(eltype) +# +# +# The most general (where the kind of array is stored as well as number +# of dimensions) +# Rarely needed. +# +# struct { +# eltype *data; +# int16 nd; +# int16 dimkind; +# ??? +# } array_nd(eltype) +# +# where ??? is run-time interpreted based on the dimkind to either: +# intp shape[nd]; for dimkind = C_CONTIGUOUS or F_CONTIGUOUS +# +# diminfo shape[nd]; for dimkind = STRIDED +# +# intp shape[ind]; +# intp strides[ind]; dimkind = STRIDED_SOA +# import llvm.core as lc from llvm.core import Type import llvm_cbuilder.shortnames as C -CONTIGUOUS = 1 << 8 -STRIDED = CONTIGUOUS + 1 -STRIDED_SOA = CONTIGUOUS + 2 +# Different Array Types +ARRAYBIT = 1<<4 +C_CONTIGUOUS = ARRAYBIT + 0 +F_CONTIGUOUS = ARRAYBIT + 1 +STRIDED = ARRAYBIT + 2 +STRIDED_SOA = ARRAYBIT + 3 -array_kinds = (CONTIGUOUS, STRIDED, STRIDED_SOA) +HAS_ND = 1<<5 +C_CONTIGUOUS_ND = C_CONTIGUOUS + HAS_ND +F_CONTIGUOUS_ND = F_CONTIGUOUS + HAS_ND +STRIDED_ND = STRIDED + HAS_ND +STRIDED_SOA_ND = STRIDED_SOA + HAS_ND + +HAS_DIMKIND = 1<<6 +C_CONTIGUOUS_DK = C_CONTIGUOUS + HAS_DIMKIND +F_CONTIGUOUS_DK = F_CONTIGUOUS + HAS_DIMKIND +STRIDED_DK = STRIDED + HAS_DIMKIND +STRIDED_SOA_DK = STRIDED_SOA + HAS_DIMKIND + +array_kinds = (C_CONTIGUOUS, F_CONTIGUOUS, STRIDED, STRIDED_SOA, + C_CONTIGUOUS_ND, F_CONTIGUOUS_ND, STRIDED_ND, STRIDED_SOA_DK, + C_CONTIGUOUS_DK, F_CONTIGUOUS_DK, STRIDED_DK, STRIDED_SOA_DK) + +_invmap = {} + +def kind_to_str(kind): + global _invmap + if not _invmap: + for key, value in globals().items(): + if isinstance(value, int) and value in array_kinds: + _invmap[value] = key + return _invmap[kind] + +def str_to_kind(str): + trial = eval(str) + if trial not in array_kinds: + raise ValueError("Invalid Array Kind") + return trial void_type = C.void -int_type = C.int +int32_type = C.int32 char_type = C.char int16_type = C.int16 intp_type = C.intp @@ -45,99 +124,133 @@ diminfo_type = Type.struct([intp_type, # shape intp_type # stride ], name='diminfo') -# This is the way we define LLVM arrays. -def cont_array_type(nd, el_type=char_type, name=''): - terms = [Type.pointer(el_type), # data - Type.array(intp_type, nd) # shape - ] - return Type.struct(terms, name=name) +_cache = {} +# This is the way we define LLVM arrays. +# CONTIGUOUS and STRIDED are strongly encouraged... +def array_type(nd, kind, el_type=char_type): + key = (kind, nd, el_type) + if _cache.has_key(key): + return _cache[key] -def strided_array_type(nd, el_type=char_type, name=''): - terms = [Type.pointer(el_type), # data - Type.array(diminfo_type, nd) # diminfo - ] - return Type.struct(terms, name=name) + base = kind & (~(HAS_ND | HAS_DIMKIND)) + if base == C_CONTIGUOUS: + dimstr = 'Array_C' + elif base == F_CONTIGUOUS: + dimstr = 'Array_F' + elif base == STRIDED: + dimstr = 'Array_S' + elif base == STRIDED_SOA: + dimstr = 'Array_A' + else: + raise TypeError("Do not understand Array kind of %d" % kind) + + terms = [Type.pointer(el_type)] # data + + if (kind & HAS_ND): + terms.append(int32_type) # nd + dimstr += '_ND' + elif (kind & HAS_DIMKIND): + terms.extend([int16_type, int16_type]) # nd, dimkind + dimstr += '_DK' + + if base in [C_CONTIGUOUS, F_CONTIGUOUS]: + terms.append(Type.array(intp_type, nd)) # shape + elif base == STRIDED: + terms.append(Type.array(diminfo_type, nd)) # diminfo + elif base == STRIDED_SOA: + terms.extend([Type.array(intp_type, nd), # shape + Type.array(intp_type, nd)]) # strides + + ret = Type.struct(terms, name=dimstr) + _cache[key] = ret + return ret -def strided_soa_type(nd, el_type=char_type, name=''): - terms = [Type.pointer(el_type), # data - Type.array(intp_type, nd), # shape[nd] - Type.array(intp_type, nd) # strides[nd] - ] - return Type.struct(terms, name=name) def check_array(arrtyp): if not isinstance(arrtyp, lc.StructType): return None - if arrtyp.element_count not in [2, 3]: - return None - if not isinstance(arrtyp.elements[0], lc.PointerType) or \ - not isinstance(arrtyp.elements[1], lc.ArrayType): + if arrtyp.element_count not in [2, 3, 4, 5]: return None - data_type = arrtyp.elements[0].pointee - s1 = arrtyp.elements[1] + # Look through _cache and see if it's there + for key, value in _cache.items(): + if arrtyp is value: + return key + + return _raw_check_array(arrtyp) + +# Manual check +def _raw_check_array(arrtyp): + a0 = arrtyp.elements[0] + a1 = arrtyp.elements[1] + if not isinstance(a0, lc.PointerType) or \ + not (isinstance(a1, lc.ArrayType) or + (a1 == int32_type) or (a1 == int16_type)): + return None + + data_type = a0.pointee + + if arrtyp.is_literal: + c_contig = True + else: + if arrtyp.name.startswith('Array_F'): + c_contig = False + else: + c_contig = True + + + if a1 == int32_type: + num = 2 + strided = STRIDED_ND + strided_soa = STRIDED_SOA_ND + c_contiguous = C_CONTIGUOUS_ND + f_contiguous = F_CONTIGUOUS_ND + elif a1 == int16_type: + if arrtyp.element_count < 3 or arrtyp.elements[2] != int16_type: + return None + num = 3 + strided = STRIDED_DK + strided_soa = STRIDED_SOA_DK + c_contiguous = C_CONTIGUOUS_DK + f_contiguous = F_CONTIGUOUS_DK + else: + num = 1 + strided = STRIDED + strided_soa = STRIDED_SOA + c_contiguous = C_CONTIGUOUS + f_contiguous = F_CONTIGUOUS + + elcount = num + 2 + # otherwise we have lc.ArrType as element [1] + if arrtyp.element_count not in [num+1,num+2]: + return None + s1 = arrtyp.elements[num] nd = s1.count - if arrtyp.element_count == 3: - if not isinstance(arrtyp.elements[2], lc.ArrayType): + if arrtyp.element_count == elcount: + if not isinstance(arrtyp.elements[num+1], lc.ArrayType): return None - s2 = arrtyp.elements[2] + s2 = arrtyp.elements[num+1] if s1.element != intp_type or s2.element != intp_type: return None if s1.count != s2.count: return None - return STRIDED_SOA, nd, data_type + return strided_soa, nd, data_type if s1.element == diminfo_type: - return STRIDED, nd, data_type + return strided, nd, data_type elif s1.element == intp_type: - return CONTIGUOUS, nd, data_type + return c_contiguous if c_contig else f_contiguous, nd, data_type else: return None -def is_cont_array(arrtyp): - if not isinstance(arrtyp, lc.StructType): - return False - if arrtyp.element_count != 2 or \ - not isinstance(arrtyp.elements[0], lc.PointerType) or \ - not isinstance(arrtyp.elements[1], lc.ArrayType): - return False - if arrtyp.elements[1].element != intp_type: - return False - return True - -def is_strided_array(arrtyp, kind=diminfo_type): - if not isinstance(arrtyp, lc.StructType): - return False - if arrtyp.element_count != 2 or \ - not isinstance(arrtyp.elements[0], lc.PointerType) or \ - not isinstance(arrtyp.elements[1], lc.ArrayType): - return False - if arrtyp.elements[1].element != kind: - return False - return True - -def is_strided_soa_array(arrtyp): - if not isinstance(arrtyp, lc.StructType): - return False - if arrtyp.element_count != 3 or \ - not isinstance(arrtyp.elements[0], lc.PointerType) or \ - not isinstance(arrtyp.elements[1], lc.ArrayType) or \ - not isinstance(arrtyp.elements[2], lc.ArrayType): - return False - s1, s2 = arrtyp.elements[1:] - if s1.element != intp_type or s2.element != intp_type: - return False - if s1.count != s2.count: - return False - return True def test(): - arr = cont_array_type(5) - assert check_array(arr) == (CONTIGUOUS, 5, char_type) - arr = strided_array_type(4) + arr = array_type(5, C_CONTIGUOUS) + assert check_array(arr) == (C_CONTIGUOUS, 5, char_type) + arr = array_type(4, STRIDED) assert check_array(arr) == (STRIDED, 4, char_type) - arr = strided_soa_type(3) + arr = array_type(3, STRIDED_SOA) assert check_array(arr) == (STRIDED_SOA, 3, char_type) if __name__ == '__main__': From 6b333e84aa249869401ab5c02dd0cf95b43d6984 Mon Sep 17 00:00:00 2001 From: Mark Florisson Date: Mon, 27 May 2013 12:22:13 +0100 Subject: [PATCH 05/11] Use error message string from BytesIO --- llvm/core.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/llvm/core.py b/llvm/core.py index fd72902..9c8501e 100644 --- a/llvm/core.py +++ b/llvm/core.py @@ -504,7 +504,7 @@ class Module(llvm.Wrapper): mode, errmsg) if failed: - raise llvm.LLVMException(errmsg) + raise llvm.LLVMException(errmsg.getvalue()) def get_type_named(self, name): typ = self._ptr.getTypeByName(name) From 17ec89e457c05b3fdb004fb3636d47ea853484d0 Mon Sep 17 00:00:00 2001 From: Siu Kwan Lam Date: Tue, 28 May 2013 19:23:40 -0500 Subject: [PATCH 06/11] Fix win32 build --- llvm-config-win32.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/llvm-config-win32.py b/llvm-config-win32.py index 05fc94f..5f6c401 100644 --- a/llvm-config-win32.py +++ b/llvm-config-win32.py @@ -98,6 +98,9 @@ def main(): if option == '--version': print(get_llvm_version()) + elif option == '--targets-built': + print('X86') # just do X86 + elif option == '--libs': libs_options() From 2e8944916c8a95855ec26fcdc07d4094c1681aba Mon Sep 17 00:00:00 2001 From: Siu Kwan Lam Date: Wed, 29 May 2013 16:16:19 -0500 Subject: [PATCH 07/11] Add DIBuilder binding --- llvmpy/src/DIBuilder.py | 357 +++++++++++++++++++++++ llvmpy/src/DebugInfo.py | 98 +++++++ llvmpy/src/Support/Dwarf.py | 563 ++++++++++++++++++++++++++++++++++++ 3 files changed, 1018 insertions(+) create mode 100644 llvmpy/src/DIBuilder.py create mode 100644 llvmpy/src/DebugInfo.py create mode 100644 llvmpy/src/Support/Dwarf.py diff --git a/llvmpy/src/DIBuilder.py b/llvmpy/src/DIBuilder.py new file mode 100644 index 0000000..9671963 --- /dev/null +++ b/llvmpy/src/DIBuilder.py @@ -0,0 +1,357 @@ +from binding import * +from .namespace import llvm + +DIBuilder = llvm.Class() + +from .Module import Module +from .Value import Value, MDNode, Function, BasicBlock +from .Instruction import Instruction +from .DebugInfo import DIFile, DIEnumerator, DIType, DIBasicType, DIDerivedType +from .DebugInfo import DIDescriptor, DIArray, DISubrange, DIGlobalVariable +from .DebugInfo import DIVariable, DISubprogram, DINameSpace, DILexicalBlockFile +from .DebugInfo import DILexicalBlock +from .ADT.SmallVector import SmallVector_Value +from .ADT.StringRef import StringRef + +unsigned_arg = cast(int, Unsigned) +stringref_arg = cast(str, StringRef) +bool_arg = cast(bool, Bool) +uint64_arg = cast(int, Uint64) +int64_arg = cast(int, Int64) + +@DIBuilder +class DIBuilder: + _include_ = 'llvm/DIBuilder.h' + new = Constructor(ref(Module)) + delete = Destructor() + + getCU = Method(const(ptr(MDNode))) + finalize = Method() + + createCompileUnit = Method(Void, + unsigned_arg, # Lang + stringref_arg, # File + stringref_arg, # Dir + stringref_arg, # Producer + bool_arg, # isOptimized + stringref_arg, # Flags, + unsigned_arg, # RV + # stringref_arg, # SplitName LLVM3.3 + ) #.require_only(7) + + createFile = Method(DIFile, + stringref_arg, # Filename + stringref_arg, # Directory + ) + + createEnumerator = Method(DIEnumerator, + stringref_arg, # Name + uint64_arg, # Val + ) + + createNullPtrType = Method(DIType, + stringref_arg, # Name + ) + + createBasicType = Method(DIType, + stringref_arg, # Name + uint64_arg, # SizeIntBits, + uint64_arg, # AlignInBits, + unsigned_arg, # Encoding + ) + + createQualifiedType = Method(DIType, + unsigned_arg, # Tag + ref(DIType), # FromTy + ) + + createPointerType = Method(DIType, + ref(DIType), # PointeeTy + uint64_arg, # SizeInBits + uint64_arg, # AlignInBits + stringref_arg, # Name + ).require_only(2) + + createReferenceType = Method(DIType, + unsigned_arg, # Tag + ref(DIType), # RTy + ) + + createTypedef = Method(DIType, + ref(DIType), # Ty + stringref_arg, # Name + ref(DIFile), # File + unsigned_arg, # LineNo + ref(DIDescriptor), # Context + ) + + createFriend = Method(DIType, + ref(DIType), # Ty + ref(DIType), # FriendTy + ) + + createInheritance = Method(DIType, + ref(DIType), # Ty + ref(DIType), # BaseTy + uint64_arg, # BaseOffset + unsigned_arg, # Flags + ) + + createMemberType = Method(DIType, + ref(DIDescriptor), # Scope + stringref_arg, # Name + ref(DIFile), # File + unsigned_arg, # LineNo + uint64_arg, # SizeInBits + uint64_arg, # AlignInBits + uint64_arg, # OffsetInBits + unsigned_arg, # Flags + ref(DIType), # Ty + ) + + createClassType = Method(DIType, + ref(DIDescriptor), # Scope + stringref_arg, # Name + ref(DIFile), # File + unsigned_arg, # LineNum + uint64_arg, # SizeInBits + uint64_arg, # AlignInBits + uint64_arg, # OffsetInBits, + unsigned_arg, # Flags + ref(DIType), # DerivedFrom + ref(DIArray), # Elements + ptr(MDNode), # VTableHolder = 0 + ptr(MDNode), # TemplateParms = 0 + ).require_only(10) + + createStructType = Method(DIType, + ref(DIDescriptor), # Scope + stringref_arg, # Name + ref(DIFile), # File + unsigned_arg, # LineNumber + uint64_arg, # SizeInBits + uint64_arg, # AlignInBits + unsigned_arg, # Flags + ref(DIArray), # Elements + unsigned_arg, # RunTimeLang = 0 + ).require_only(8) + + createUnionType = Method(DIType, + ref(DIDescriptor), # Scope + stringref_arg, # Name + ref(DIFile), # File + unsigned_arg, # LineNum + uint64_arg, # SizeInBits + uint64_arg, # AlignInBits + unsigned_arg, # Flags + ref(DIArray), # Elements + unsigned_arg, # RunTimeLang = 0 + ).require_only(8) + + createArrayType = Method(DIType, + uint64_arg, # Size + uint64_arg, # AlignInBits + ref(DIType), # Ty + ref(DIArray), # Subscripts + ) + + createVectorType = Method(DIType, + uint64_arg, # Size + uint64_arg, # AlignInBits + ref(DIType), # Ty + ref(DIArray), # Subscripts + ) + + createEnumerationType = Method(DIType, + ref(DIDescriptor), # Scope + stringref_arg, # Name + ref(DIFile), # File + unsigned_arg, # LineNumber + uint64_arg, # SizeInBits + uint64_arg, # AlignInBits + ref(DIArray), # Elements + ref(DIType), # ClassType + ) + + createSubroutineType = Method(DIType, + ref(DIFile), # File + ref(DIArray), # ParameterTypes + ) + + createArtificialType = Method(DIType, + ref(DIType), # Ty + ) + + createObjectPointerType = Method(DIType, + ref(DIType), # Ty + ) + + createTemporaryType = Method(DIType, ref(DIFile)).require_only(0) + + createForwardDecl = Method(DIType, + unsigned_arg, # Tag + stringref_arg, # Name + ref(DIDescriptor), # scope + ref(DIFile), # F + unsigned_arg, # Line + unsigned_arg, # RuntimeLang=0 + uint64_arg, # SizeInBits=0 + uint64_arg, # AlignInBits=0 + ).require_only(5) + + retainType = Method(Void, ref(DIType)) + + createUnspecifiedParameter = Method(DIDescriptor) + + getOrCreateArray = Method(DIArray, + ref(SmallVector_Value), # Elements + ) + + getOrCreateSubrange = Method(DISubrange, + int64_arg, # Lo + int64_arg, # Hi + ) + + createGlobalVariable = Method(DIGlobalVariable, + stringref_arg, # Name + ref(DIFile), # File + unsigned_arg, # LineNo + ref(DIType), # Ty + bool_arg, # isLocalToUnit + ptr(Value), # Val + ) + + createStaticVariable = Method(DIGlobalVariable, + ref(DIDescriptor), # Context + stringref_arg, # Name + stringref_arg, # LinkageName + ref(DIFile), # File + unsigned_arg, # LineNo + ref(DIType), # Ty + bool_arg, # isLocalToUnit + ptr(Value), # Val + ) + + createLocalVariable = Method(DIVariable, + unsigned_arg, # Tag, + ref(DIDescriptor), # Scope, + stringref_arg, # Name, + ref(DIFile), # File, + unsigned_arg, # LineNo, + ref(DIType), # Ty, + bool_arg, # AlwaysPreserve=false, + unsigned_arg, # Flags=0, + unsigned_arg, # ArgNo=0 + ).require_only(6) + + createComplexVariable = Method(DIVariable, + unsigned_arg, # Tag, + ref(DIDescriptor), # Scope, + stringref_arg, # Name, + ref(DIFile), # F, + unsigned_arg, # LineNo, + ref(DIType), # Ty, + ref(SmallVector_Value), # Addr, + unsigned_arg, # ArgNo=0, + ).require_only(7) + + createFunction = Method(DISubprogram, + ref(DIDescriptor), # Scope + stringref_arg, # Name + stringref_arg, # LinkageName + ref(DIFile), # File + unsigned_arg, # LineNo + ref(DIType), # Ty + bool_arg, # isLocalToUnit + bool_arg, # isDefinition + unsigned_arg, # ScopeLine + unsigned_arg, # Flags=0 + bool_arg, # isOptimized=false + ptr(Function), # *Fn=0 + ptr(MDNode), # *TParam=0, + ptr(MDNode), # *Decl=0 + ).require_only(9) + + + createMethod = Method(DISubprogram, + ref(DIDescriptor), # Scope + stringref_arg, # Name + stringref_arg, # LinkageName + ref(DIFile), # File + unsigned_arg, # LineNo + ref(DIType), # Ty + bool_arg, # isLocalToUnit + bool_arg, # isDefinition + unsigned_arg, # Virtuality=0 + unsigned_arg, # VTableIndex=0 + ptr(MDNode), # *VTableHolder=0 + unsigned_arg, # Flags=0 + bool_arg, # isOptimized=false + ptr(Function), # *Fn=0 + ptr(MDNode), # *TParam=0 + ).require_only(8) + + + createNameSpace = Method(DINameSpace, + ref(DIDescriptor), # Scope, + stringref_arg, # Name, + ref(DIFile), # File, + unsigned_arg, # LineNo + ) + + createLexicalBlockFile = Method(DILexicalBlockFile, + ref(DIDescriptor), # Scope, + ref(DIFile), # File + ) + + createLexicalBlock = Method(DILexicalBlock, + ref(DIDescriptor), # Scope, + ref(DIFile), # File, + unsigned_arg, # Line, + unsigned_arg, # Col + ) + + _insertDeclare_1 = Method(ptr(Instruction), + ptr(Value), # Storage, + ref(DIVariable), # VarInfo + ptr(BasicBlock), # *InsertAtEnd + ) + _insertDeclare_1.realname = 'insertDeclare' + + _insertDeclare_2 = Method(ptr(Instruction), + ptr(Value), # Storage, + ref(DIVariable), # VarInfo + ptr(Instruction), # *InsertBefore + ) + _insertDeclare_2.realname = 'insertDeclare' + + @CustomPythonMethod + def insertDeclare(self, storage, varinfo, insertpt): + if isinstance(insertbefore, _api.llvm.Instruction): + return self._insertDeclare_2(storage, varinfo, insertpt) + else: + return self._insertDeclare_1(storage, varinfo, insertpt) + + _insertDbgValueIntrinsic_1 = Method(ptr(Instruction), + ptr(Value), # *Val + uint64_arg, # Offset + ref(DIVariable), # VarInfo + ptr(BasicBlock), # *InsertAtEnd + ) + _insertDbgValueIntrinsic_1.realname = 'insertDbgValueIntrinsic' + + _insertDbgValueIntrinsic_2 = Method(ptr(Instruction), + ptr(Value), # *Val + uint64_arg, # Offset + ref(DIVariable), # VarInfo + ptr(Instruction), # *InsertAtEnd + ) + _insertDbgValueIntrinsic_2.realname = 'insertDbgValueIntrinsic' + + + @CustomPythonMethod + def insertDbgValueIntrinsic(self, storage, varinfo, insertpt): + if isinstance(insertbefore, _api.llvm.Instruction): + return self._insertDbgValueIntrinsic_2(storage, varinfo, insertpt) + else: + return self._insertDbgValueIntrinsic_1(storage, varinfo, insertpt) diff --git a/llvmpy/src/DebugInfo.py b/llvmpy/src/DebugInfo.py new file mode 100644 index 0000000..81fe168 --- /dev/null +++ b/llvmpy/src/DebugInfo.py @@ -0,0 +1,98 @@ +from binding import * +from .namespace import llvm + +from .ADT.StringRef import StringRef +from .Value import MDNode + +DIDescriptor = llvm.Class(MDNode) +DIEnumerator = llvm.Class(DIDescriptor) +DIScope = llvm.Class(DIDescriptor) +DIType = llvm.Class(DIScope) +DIBasicType = llvm.Class(DIType) +DIDerivedType = llvm.Class(DIType) +DICompositeType = llvm.Class(DIDerivedType) +DIFile = llvm.Class(DIScope) +DIArray = llvm.Class(DIDescriptor) +DISubrange = llvm.Class(DIDescriptor) +DIGlobalVariable = llvm.Class(DIDescriptor) +DIVariable = llvm.Class(DIDescriptor) +DISubprogram = llvm.Class(DIScope) +DINameSpace = llvm.Class(DIScope) +DILexicalBlockFile = llvm.Class(DIScope) +DILexicalBlock = llvm.Class(DIScope) + +llvm.includes.add('llvm/DebugInfo.h') + +return_bool = cast(Bool, bool) +return_stringref = cast(StringRef, str) +return_unsigned = cast(Unsigned, int) + +@DIDescriptor +class DIDescriptor: + pass + +@DIScope +class DIScope: + pass + +@DIFile +class DIFile: + # getFileNode = Method(ptr(MDNode)) # not in LLVM 3.2? + Verify = Method(return_bool) + +@DIEnumerator +class DIEnumerator: + getName = Method(return_stringref) + getEnumValue = Method(cast(Uint64, int)) + Verify = Method(return_bool) + +@DIType +class DIType: + getName = Method(return_stringref) + getLineNumber = Method(return_unsigned) + Verify = Method(return_bool) + +@DIBasicType +class DIBasicType: + pass + +@DIDerivedType +class DIDerivedType: + pass + +@DICompositeType +class DICompositeType: + pass + +@DIArray +class DIArray: + Verify = Method(return_bool) + +@DISubrange +class DISubrange: + Verify = Method(return_bool) + +@DIGlobalVariable +class DIGlobalVariable: + Verify = Method(return_bool) + +@DIVariable +class DIVariable: + Verify = Method(return_bool) + +@DISubprogram +class DISubprogram: + Verify = Method(return_bool) + +@DINameSpace +class DINameSpace: + Verify = Method(return_bool) + +@DILexicalBlockFile +class DILexicalBlockFile: + Verify = Method(return_bool) + +@DILexicalBlock +class DILexicalBlock: + Verify = Method(return_bool) + diff --git a/llvmpy/src/Support/Dwarf.py b/llvmpy/src/Support/Dwarf.py new file mode 100644 index 0000000..caecc24 --- /dev/null +++ b/llvmpy/src/Support/Dwarf.py @@ -0,0 +1,563 @@ +from binding import * +from ..namespace import llvm + +dwarf = llvm.Namespace('dwarf') + +dwarf.includes.add('llvm/Support/Dwarf.h') + +dwarf_constants = dwarf.Enum('dwarf_constants', +''' +DWARF_VERSION +DW_TAG_array_type +DW_TAG_class_type +DW_TAG_entry_point +DW_TAG_enumeration_type +DW_TAG_formal_parameter +DW_TAG_imported_declaration +DW_TAG_label +DW_TAG_lexical_block +DW_TAG_member +DW_TAG_pointer_type +DW_TAG_reference_type +DW_TAG_compile_unit +DW_TAG_string_type +DW_TAG_structure_type +DW_TAG_subroutine_type +DW_TAG_typedef +DW_TAG_union_type +DW_TAG_unspecified_parameters +DW_TAG_variant +DW_TAG_common_block +DW_TAG_common_inclusion +DW_TAG_inheritance +DW_TAG_inlined_subroutine +DW_TAG_module +DW_TAG_ptr_to_member_type +DW_TAG_set_type +DW_TAG_subrange_type +DW_TAG_with_stmt +DW_TAG_access_declaration +DW_TAG_base_type +DW_TAG_catch_block +DW_TAG_const_type +DW_TAG_constant +DW_TAG_enumerator +DW_TAG_file_type +DW_TAG_friend +DW_TAG_namelist +DW_TAG_namelist_item +DW_TAG_packed_type +DW_TAG_subprogram +DW_TAG_template_type_parameter +DW_TAG_template_value_parameter +DW_TAG_thrown_type +DW_TAG_try_block +DW_TAG_variant_part +DW_TAG_variable +DW_TAG_volatile_type +DW_TAG_dwarf_procedure +DW_TAG_restrict_type +DW_TAG_interface_type +DW_TAG_namespace +DW_TAG_imported_module +DW_TAG_unspecified_type +DW_TAG_partial_unit +DW_TAG_imported_unit +DW_TAG_condition +DW_TAG_shared_type +DW_TAG_type_unit +DW_TAG_rvalue_reference_type +DW_TAG_template_alias +DW_TAG_MIPS_loop +DW_TAG_format_label +DW_TAG_function_template +DW_TAG_class_template +DW_TAG_GNU_template_template_param +DW_TAG_GNU_template_parameter_pack +DW_TAG_GNU_formal_parameter_pack +DW_TAG_lo_user +DW_TAG_APPLE_property +DW_TAG_hi_user +DW_CHILDREN_no +DW_CHILDREN_yes +DW_AT_sibling +DW_AT_location +DW_AT_name +DW_AT_ordering +DW_AT_byte_size +DW_AT_bit_offset +DW_AT_bit_size +DW_AT_stmt_list +DW_AT_low_pc +DW_AT_high_pc +DW_AT_language +DW_AT_discr +DW_AT_discr_value +DW_AT_visibility +DW_AT_import +DW_AT_string_length +DW_AT_common_reference +DW_AT_comp_dir +DW_AT_const_value +DW_AT_containing_type +DW_AT_default_value +DW_AT_inline +DW_AT_is_optional +DW_AT_lower_bound +DW_AT_producer +DW_AT_prototyped +DW_AT_return_addr +DW_AT_start_scope +DW_AT_bit_stride +DW_AT_upper_bound +DW_AT_abstract_origin +DW_AT_accessibility +DW_AT_address_class +DW_AT_artificial +DW_AT_base_types +DW_AT_calling_convention +DW_AT_count +DW_AT_data_member_location +DW_AT_decl_column +DW_AT_decl_file +DW_AT_decl_line +DW_AT_declaration +DW_AT_discr_list +DW_AT_encoding +DW_AT_external +DW_AT_frame_base +DW_AT_friend +DW_AT_identifier_case +DW_AT_macro_info +DW_AT_namelist_item +DW_AT_priority +DW_AT_segment +DW_AT_specification +DW_AT_static_link +DW_AT_type +DW_AT_use_location +DW_AT_variable_parameter +DW_AT_virtuality +DW_AT_vtable_elem_location +DW_AT_allocated +DW_AT_associated +DW_AT_data_location +DW_AT_byte_stride +DW_AT_entry_pc +DW_AT_use_UTF8 +DW_AT_extension +DW_AT_ranges +DW_AT_trampoline +DW_AT_call_column +DW_AT_call_file +DW_AT_call_line +DW_AT_description +DW_AT_binary_scale +DW_AT_decimal_scale +DW_AT_small +DW_AT_decimal_sign +DW_AT_digit_count +DW_AT_picture_string +DW_AT_mutable +DW_AT_threads_scaled +DW_AT_explicit +DW_AT_object_pointer +DW_AT_endianity +DW_AT_elemental +DW_AT_pure +DW_AT_recursive +DW_AT_signature +DW_AT_main_subprogram +DW_AT_data_bit_offset +DW_AT_const_expr +DW_AT_enum_class +DW_AT_linkage_name +DW_AT_lo_user +DW_AT_hi_user +DW_AT_MIPS_loop_begin +DW_AT_MIPS_tail_loop_begin +DW_AT_MIPS_epilog_begin +DW_AT_MIPS_loop_unroll_factor +DW_AT_MIPS_software_pipeline_depth +DW_AT_MIPS_linkage_name +DW_AT_MIPS_stride +DW_AT_MIPS_abstract_name +DW_AT_MIPS_clone_origin +DW_AT_MIPS_has_inlines +DW_AT_MIPS_stride_byte +DW_AT_MIPS_stride_elem +DW_AT_MIPS_ptr_dopetype +DW_AT_MIPS_allocatable_dopetype +DW_AT_MIPS_assumed_shape_dopetype +DW_AT_MIPS_assumed_size +DW_AT_sf_names +DW_AT_src_info +DW_AT_mac_info +DW_AT_src_coords +DW_AT_body_begin +DW_AT_body_end +DW_AT_APPLE_optimized +DW_AT_APPLE_flags +DW_AT_APPLE_isa +DW_AT_APPLE_block +DW_AT_APPLE_major_runtime_vers +DW_AT_APPLE_runtime_class +DW_AT_APPLE_omit_frame_ptr +DW_AT_APPLE_property_name +DW_AT_APPLE_property_getter +DW_AT_APPLE_property_setter +DW_AT_APPLE_property_attribute +DW_AT_APPLE_objc_complete_type +DW_AT_APPLE_property +DW_FORM_addr +DW_FORM_block2 +DW_FORM_block4 +DW_FORM_data2 +DW_FORM_data4 +DW_FORM_data8 +DW_FORM_string +DW_FORM_block +DW_FORM_block1 +DW_FORM_data1 +DW_FORM_flag +DW_FORM_sdata +DW_FORM_strp +DW_FORM_udata +DW_FORM_ref_addr +DW_FORM_ref1 +DW_FORM_ref2 +DW_FORM_ref4 +DW_FORM_ref8 +DW_FORM_ref_udata +DW_FORM_indirect +DW_FORM_sec_offset +DW_FORM_exprloc +DW_FORM_flag_present +DW_FORM_ref_sig8 +DW_OP_addr +DW_OP_deref +DW_OP_const1u +DW_OP_const1s +DW_OP_const2u +DW_OP_const2s +DW_OP_const4u +DW_OP_const4s +DW_OP_const8u +DW_OP_const8s +DW_OP_constu +DW_OP_consts +DW_OP_dup +DW_OP_drop +DW_OP_over +DW_OP_pick +DW_OP_swap +DW_OP_rot +DW_OP_xderef +DW_OP_abs +DW_OP_and +DW_OP_div +DW_OP_minus +DW_OP_mod +DW_OP_mul +DW_OP_neg +DW_OP_not +DW_OP_or +DW_OP_plus +DW_OP_plus_uconst +DW_OP_shl +DW_OP_shr +DW_OP_shra +DW_OP_xor +DW_OP_skip +DW_OP_bra +DW_OP_eq +DW_OP_ge +DW_OP_gt +DW_OP_le +DW_OP_lt +DW_OP_ne +DW_OP_lit0 +DW_OP_lit1 +DW_OP_lit2 +DW_OP_lit3 +DW_OP_lit4 +DW_OP_lit5 +DW_OP_lit6 +DW_OP_lit7 +DW_OP_lit8 +DW_OP_lit9 +DW_OP_lit10 +DW_OP_lit11 +DW_OP_lit12 +DW_OP_lit13 +DW_OP_lit14 +DW_OP_lit15 +DW_OP_lit16 +DW_OP_lit17 +DW_OP_lit18 +DW_OP_lit19 +DW_OP_lit20 +DW_OP_lit21 +DW_OP_lit22 +DW_OP_lit23 +DW_OP_lit24 +DW_OP_lit25 +DW_OP_lit26 +DW_OP_lit27 +DW_OP_lit28 +DW_OP_lit29 +DW_OP_lit30 +DW_OP_lit31 +DW_OP_reg0 +DW_OP_reg1 +DW_OP_reg2 +DW_OP_reg3 +DW_OP_reg4 +DW_OP_reg5 +DW_OP_reg6 +DW_OP_reg7 +DW_OP_reg8 +DW_OP_reg9 +DW_OP_reg10 +DW_OP_reg11 +DW_OP_reg12 +DW_OP_reg13 +DW_OP_reg14 +DW_OP_reg15 +DW_OP_reg16 +DW_OP_reg17 +DW_OP_reg18 +DW_OP_reg19 +DW_OP_reg20 +DW_OP_reg21 +DW_OP_reg22 +DW_OP_reg23 +DW_OP_reg24 +DW_OP_reg25 +DW_OP_reg26 +DW_OP_reg27 +DW_OP_reg28 +DW_OP_reg29 +DW_OP_reg30 +DW_OP_reg31 +DW_OP_breg0 +DW_OP_breg1 +DW_OP_breg2 +DW_OP_breg3 +DW_OP_breg4 +DW_OP_breg5 +DW_OP_breg6 +DW_OP_breg7 +DW_OP_breg8 +DW_OP_breg9 +DW_OP_breg10 +DW_OP_breg11 +DW_OP_breg12 +DW_OP_breg13 +DW_OP_breg14 +DW_OP_breg15 +DW_OP_breg16 +DW_OP_breg17 +DW_OP_breg18 +DW_OP_breg19 +DW_OP_breg20 +DW_OP_breg21 +DW_OP_breg22 +DW_OP_breg23 +DW_OP_breg24 +DW_OP_breg25 +DW_OP_breg26 +DW_OP_breg27 +DW_OP_breg28 +DW_OP_breg29 +DW_OP_breg30 +DW_OP_breg31 +DW_OP_regx +DW_OP_fbreg +DW_OP_bregx +DW_OP_piece +DW_OP_deref_size +DW_OP_xderef_size +DW_OP_nop +DW_OP_push_object_address +DW_OP_call2 +DW_OP_call4 +DW_OP_call_ref +DW_OP_form_tls_address +DW_OP_call_frame_cfa +DW_OP_bit_piece +DW_OP_implicit_value +DW_OP_stack_value +DW_OP_lo_user +DW_OP_hi_user +DW_ATE_address +DW_ATE_boolean +DW_ATE_complex_float +DW_ATE_float +DW_ATE_signed +DW_ATE_signed_char +DW_ATE_unsigned +DW_ATE_unsigned_char +DW_ATE_imaginary_float +DW_ATE_packed_decimal +DW_ATE_numeric_string +DW_ATE_edited +DW_ATE_signed_fixed +DW_ATE_unsigned_fixed +DW_ATE_decimal_float +DW_ATE_UTF +DW_ATE_lo_user +DW_ATE_hi_user +DW_DS_unsigned +DW_DS_leading_overpunch +DW_DS_trailing_overpunch +DW_DS_leading_separate +DW_DS_trailing_separate +DW_END_default +DW_END_big +DW_END_little +DW_END_lo_user +DW_END_hi_user +DW_ACCESS_public +DW_ACCESS_protected +DW_ACCESS_private +DW_VIS_local +DW_VIS_exported +DW_VIS_qualified +DW_VIRTUALITY_none +DW_VIRTUALITY_virtual +DW_VIRTUALITY_pure_virtual +DW_LANG_C89 +DW_LANG_C +DW_LANG_Ada83 +DW_LANG_C_plus_plus +DW_LANG_Cobol74 +DW_LANG_Cobol85 +DW_LANG_Fortran77 +DW_LANG_Fortran90 +DW_LANG_Pascal83 +DW_LANG_Modula2 +DW_LANG_Java +DW_LANG_C99 +DW_LANG_Ada95 +DW_LANG_Fortran95 +DW_LANG_PLI +DW_LANG_ObjC +DW_LANG_ObjC_plus_plus +DW_LANG_UPC +DW_LANG_D +DW_LANG_Python +DW_LANG_lo_user +DW_LANG_Mips_Assembler +DW_LANG_hi_user +DW_ID_case_sensitive +DW_ID_up_case +DW_ID_down_case +DW_ID_case_insensitive +DW_CC_normal +DW_CC_program +DW_CC_nocall +DW_CC_lo_user +DW_CC_hi_user +DW_INL_not_inlined +DW_INL_inlined +DW_INL_declared_not_inlined +DW_INL_declared_inlined +DW_ORD_row_major +DW_ORD_col_major +DW_DSC_label +DW_DSC_range +DW_LNS_extended_op +DW_LNS_copy +DW_LNS_advance_pc +DW_LNS_advance_line +DW_LNS_set_file +DW_LNS_set_column +DW_LNS_negate_stmt +DW_LNS_set_basic_block +DW_LNS_const_add_pc +DW_LNS_fixed_advance_pc +DW_LNS_set_prologue_end +DW_LNS_set_epilogue_begin +DW_LNS_set_isa +DW_LNE_end_sequence +DW_LNE_set_address +DW_LNE_define_file +DW_LNE_set_discriminator +DW_LNE_lo_user +DW_LNE_hi_user +DW_MACINFO_define +DW_MACINFO_undef +DW_MACINFO_start_file +DW_MACINFO_end_file +DW_MACINFO_vendor_ext +DW_CFA_extended +DW_CFA_nop +DW_CFA_advance_loc +DW_CFA_offset +DW_CFA_restore +DW_CFA_set_loc +DW_CFA_advance_loc1 +DW_CFA_advance_loc2 +DW_CFA_advance_loc4 +DW_CFA_offset_extended +DW_CFA_restore_extended +DW_CFA_undefined +DW_CFA_same_value +DW_CFA_register +DW_CFA_remember_state +DW_CFA_restore_state +DW_CFA_def_cfa +DW_CFA_def_cfa_register +DW_CFA_def_cfa_offset +DW_CFA_def_cfa_expression +DW_CFA_expression +DW_CFA_offset_extended_sf +DW_CFA_def_cfa_sf +DW_CFA_def_cfa_offset_sf +DW_CFA_val_offset +DW_CFA_val_offset_sf +DW_CFA_val_expression +DW_CFA_MIPS_advance_loc8 +DW_CFA_GNU_window_save +DW_CFA_GNU_args_size +DW_CFA_lo_user +DW_CFA_hi_user +DW_EH_PE_absptr +DW_EH_PE_omit +DW_EH_PE_uleb128 +DW_EH_PE_udata2 +DW_EH_PE_udata4 +DW_EH_PE_udata8 +DW_EH_PE_sleb128 +DW_EH_PE_sdata2 +DW_EH_PE_sdata4 +DW_EH_PE_sdata8 +DW_EH_PE_signed +DW_EH_PE_pcrel +DW_EH_PE_textrel +DW_EH_PE_datarel +DW_EH_PE_funcrel +DW_EH_PE_aligned +DW_EH_PE_indirect +DW_APPLE_PROPERTY_readonly +DW_APPLE_PROPERTY_readwrite +DW_APPLE_PROPERTY_assign +DW_APPLE_PROPERTY_retain +DW_APPLE_PROPERTY_copy +DW_APPLE_PROPERTY_nonatomic +''') + +### The following enums are not available in LLVM 3.2 +# DW_AT_GNU_dwo_name +# DW_AT_GNU_vector +# DW_AT_GNU_template_name +# DW_AT_GNU_dwo_id +# DW_AT_GNU_ranges_base +# DW_AT_GNU_addr_base +# DW_AT_GNU_pubnames +# DW_AT_GNU_pubtypes +# DW_FORM_GNU_addr_index +# DW_FORM_GNU_str_index +# DW_OP_GNU_addr_index +# DW_OP_GNU_const_index From 84f1b433def8c4ef9a829c21a14cc26e523117df Mon Sep 17 00:00:00 2001 From: Siu Kwan Lam Date: Thu, 30 May 2013 14:04:08 -0500 Subject: [PATCH 08/11] Use if-else instead of try-except for perf reason --- llvmpy/capsule.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/llvmpy/capsule.py b/llvmpy/capsule.py index f66836f..1b3813b 100644 --- a/llvmpy/capsule.py +++ b/llvmpy/capsule.py @@ -141,9 +141,10 @@ def wrap(cap, owned=False): cls = cap.get_class() addr = cap.pointer name = cap.name - try: # lookup cached object - return _cache[cls][addr] - except KeyError: + # lookup cached object + if cls in _cache and addr in _cache[cls]: + obj = _cache[cls][addr] + else: if not owned and cls._has_dtor(): _addr2dtor[(name, addr)] = cls._delete_ obj = cap.instantiate() @@ -207,11 +208,10 @@ def downcast(obj, cls): logger.debug("Downcast %s to %s" , fromty, toty) fname = 'downcast_%s_to_%s' % (fromty, toty) fname = fname.replace('::', '_') - try: - caster = getattr(_api.downcast, fname) - except AttributeError: + if not hasattr(_api.downcast, fname): fmt = "Downcast from %s to %s is not supported" raise TypeError(fmt % (fromty, toty)) + caster = getattr(_api.downcast, fname) old = unwrap(obj) new = caster(old) used_to_own = has_ownership(old) From 69c75355f4a919fa04ab49a5f933aaa99ec95bfb Mon Sep 17 00:00:00 2001 From: Ilan Schnell Date: Fri, 31 May 2013 11:47:51 -0500 Subject: [PATCH 09/11] fix future import --- llvm_array/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/llvm_array/__init__.py b/llvm_array/__init__.py index 5e807c2..08dd11b 100644 --- a/llvm_array/__init__.py +++ b/llvm_array/__init__.py @@ -1,2 +1,2 @@ -from __future__ import absolute_imports +from __future__ import absolute_import from .array import * From ad287faeb1f4473e112ef428e05610020c5357a1 Mon Sep 17 00:00:00 2001 From: Siu Kwan Lam Date: Fri, 31 May 2013 14:01:57 -0500 Subject: [PATCH 10/11] Fixes a werid case of refct problem --- llvmpy/capsule.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/llvmpy/capsule.py b/llvmpy/capsule.py index 1b3813b..5efed13 100644 --- a/llvmpy/capsule.py +++ b/llvmpy/capsule.py @@ -56,15 +56,15 @@ class Capsule(object): @property def classname(self): - return Capsule.getClassName(self.capsule) + return self.getClassName(self.capsule) @property def name(self): - return Capsule.getName(self.capsule) + return self.getName(self.capsule) @property def pointer(self): - return Capsule.getPointer(self.capsule) + return self.getPointer(self.capsule) @staticmethod def valid(capsule): From 2415042a2a07e99b24ab6859edb4d5d341ad5ea6 Mon Sep 17 00:00:00 2001 From: Siu Kwan Lam Date: Fri, 31 May 2013 15:01:02 -0500 Subject: [PATCH 11/11] DIDescriptor does not inherit MDNode --- llvmpy/src/DebugInfo.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/llvmpy/src/DebugInfo.py b/llvmpy/src/DebugInfo.py index 81fe168..8ddb1ee 100644 --- a/llvmpy/src/DebugInfo.py +++ b/llvmpy/src/DebugInfo.py @@ -4,7 +4,7 @@ from .namespace import llvm from .ADT.StringRef import StringRef from .Value import MDNode -DIDescriptor = llvm.Class(MDNode) +DIDescriptor = llvm.Class() DIEnumerator = llvm.Class(DIDescriptor) DIScope = llvm.Class(DIDescriptor) DIType = llvm.Class(DIScope) @@ -29,7 +29,8 @@ return_unsigned = cast(Unsigned, int) @DIDescriptor class DIDescriptor: - pass + new = Constructor(ptr(MDNode)) + delete = Destructor() @DIScope class DIScope: