def test_opaque(self):
# Create an opaque type
ts = Type.opaque("mystruct")
self.assertTrue("type opaque" in str(ts))
self.assertTrue(ts.is_opaque)
self.assertTrue(ts.is_identified)
self.assertFalse(ts.is_literal)
# print(ts)
# Create a recursive type
ts.set_body([Type.int(), Type.pointer(ts)])
self.assertEqual(ts.elements[0], Type.int())
self.assertEqual(ts.elements[1], Type.pointer(ts))
self.assertEqual(ts.elements[1].pointee, ts)
self.assertFalse(ts.is_opaque) # is not longer a opaque type
# print(ts)
with self.assertRaises(llvm.LLVMException):
# Cannot redefine
ts.set_body([])
def test_opaque(self):
# Create an opaque type
ts = Type.opaque('mystruct')
self.assertTrue('type opaque' in str(ts))
self.assertTrue(ts.is_opaque)
self.assertTrue(ts.is_identified)
self.assertFalse(ts.is_literal)
#print(ts)
# Create a recursive type
ts.set_body([Type.int(), Type.pointer(ts)])
self.assertEqual(ts.elements[0], Type.int())
self.assertEqual(ts.elements[1], Type.pointer(ts))
self.assertEqual(ts.elements[1].pointee, ts)
self.assertFalse(ts.is_opaque) # is not longer a opaque type
#print(ts)
with self.assertRaises(llvm.LLVMException):
# Cannot redefine
ts.set_body([])
def handle_struct(type, memo):
# Check the cache with a hashable struct type
key = type
if key in memo:
return memo[key]
if key in opaque_memo:
return opaque_memo[key]
# Allocate and pre-order cache dummy struct
struct_type = Type.opaque('dummy_struct_type')
memo[key] = struct_type
opaque_memo[key] = struct_type
# Process fields and re-cache
fields = [llvm_type(ftype, memo) for ftype in type.types]
result = Type.struct(fields)
struct_type.set_body([result])
memo[key] = result
opaque_memo[key] = result
return result
char_type = Type.int(8)
pointer = Type.pointer
any_type = pointer(Type.int(ptrsize))
string_type = pointer(char_type)
# { i32*, i32, i32* }
array_type = lambda elt_type: Type.struct([
pointer(elt_type), # data | (<type>)*
int_type, # dimensions | int
pointer(int_type), # strides | int*
], name='ndarray_' + str(elt_type))
# opaque for now
blaze_type = lambda datashape: Type.opaque(name="blaze")
#------------------------------------------------------------------------
# Constants
#------------------------------------------------------------------------
false = Constant.int(bool_type, 0)
true = Constant.int(bool_type, 1)
zero = Constant.int(int_type, 0)
#------------------------------------------------------------------------
# Type Relations
#------------------------------------------------------------------------
typemap = {
'int' : int_type,
import llvm.core as llc
from llvm.core import Type as lltype
ty_void = lltype.void()
ty_int8 = lltype.int(8)
ty_int16 = lltype.int(16)
ty_int32 = lltype.int(32)
ty_int64 = lltype.int(64)
ty_float32 = lltype.float()
ty_float64 = lltype.double()
ty_pyobj = lltype.opaque("PyObj")
ty_ptr_pyobj = lltype.pointer(ty_pyobj)
ty_ptr_int8 = lltype.pointer(ty_int8)
ty_ptr_int16 = lltype.pointer(ty_int16)
ty_ptr_int32 = lltype.pointer(ty_int32)
ty_ptr_int64 = lltype.pointer(ty_int64)
ty_ptr_float32 = lltype.pointer(ty_float32)
ty_ptr_float64 = lltype.pointer(ty_float64)
python_to_lltype_mappings = {
np.int8 : ty_int8,
np.int16 : ty_int16,
np.int32 : ty_int32,
np.int64 : ty_int64,
def test_opaque_with_no_name(self):
with self.assertRaises(llvm.LLVMException):
Type.opaque('')
pointer = Type.pointer
any_type = pointer(Type.int(ptrsize))
string_type = pointer(char_type)
# { i32*, i32, i32* }
array_type = lambda elt_type: Type.struct(
[
pointer(elt_type), # data | (<type>)*
int_type, # dimensions | int
pointer(int_type), # strides | int*
],
name='ndarray_' + str(elt_type))
# opaque for now
blaze_type = lambda datashape: Type.opaque(name="blaze")
#------------------------------------------------------------------------
# Constants
#------------------------------------------------------------------------
false = Constant.int(bool_type, 0)
true = Constant.int(bool_type, 1)
zero = Constant.int(int_type, 0)
#------------------------------------------------------------------------
# Type Relations
#------------------------------------------------------------------------
typemap = {
'int': int_type,
def test_opaque_with_no_name(self):
with self.assertRaises(llvm.LLVMException):
Type.opaque("")
'''
Implementations of built-in functions in Pascal-86.
'''
from . import symtab as s
from . import log
from llvm import core
from llvm.core import Type
from llvm.core import Constant
from llvm_cbuilder import CDefinition
from llvm_cbuilder import CTemp
from llvm_cbuilder import CVar
mutant_t = Type.opaque('P86.mutant_t')
mutant_t.set_body([Type.int(32), Type.pointer(Type.int(8)),
Type.pointer(mutant_t)])
class New(CDefinition):
'''
Allocate heap memory
'''
_name_ = 'P86.new'
_retty_ = Type.void()
_argtys_ = [('ptr', Type.pointer(Type.pointer(Type.int(8)))),
('length', Type.int(32))]
def body(self, ptr, length):
mem = self.builder.malloc_array(Type.int(8), length.value)
