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

Merge branch 'master' of github.com:llvmpy/llvmpy into llpython-dev

Browse source
This commit is contained in:
Jon Riehl 2013-06-03 16:01:03 -05:00
commit 420d0ed88d
10 changed files with 1293 additions and 88 deletions
Download patch file Download diff file Expand all files Collapse all files

3
llvm-config-win32.py
View file

@ -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()

20
llvm/core.py
View file

@ -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):
@ -498,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)
@ -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
#===----------------------------------------------------------------------===

5
llvm/ee.py
View file

@ -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

51
llvm/test_llvmpy.py
View file

@ -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):

4
llvm_array/__init__.py
View file

@ -1,2 +1,2 @@
from __future__ import absolute_imports
from .array.py import *
from __future__ import absolute_import
from .array import *

261
llvm_array/array.py
View file

@ -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__':

18
llvmpy/capsule.py
View file

@ -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):
@ -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)

357
llvmpy/src/DIBuilder.py Normal file
View file

@ -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)

99
llvmpy/src/DebugInfo.py Normal file
View file

@ -0,0 +1,99 @@
from binding import *
from .namespace import llvm
from .ADT.StringRef import StringRef
from .Value import MDNode
DIDescriptor = llvm.Class()
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:
new = Constructor(ptr(MDNode))
delete = Destructor()
@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)

563
llvmpy/src/Support/Dwarf.py Normal file
View file

@ -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