def f(n):
o = llop.extract_ushort(llgroup.HALFWORD, goffsets[n])
p = llop.get_group_member(Ptr(S1), grpptr, o)
p.x = 5
for i in range(len(goffsets)):
if i != n:
o = llop.extract_ushort(llgroup.HALFWORD, goffsets[i])
q = llop.get_group_member(Ptr(S1), grpptr, o)
q.x = 666
return p.x
def f():
p = llop.get_group_member(lltype.Ptr(test.S1), grpptr, test.g1a)
assert p == test.p1a
p = llop.get_group_member(lltype.Ptr(test.S1), grpptr, test.g1b)
assert p == test.p1b
p = llop.get_group_member(lltype.Ptr(test.S2), grpptr, test.g2a)
assert p == test.p2a
p = llop.get_group_member(lltype.Ptr(test.S2), grpptr, test.g2b)
assert p == test.p2b
#
p = llop.get_next_group_member(lltype.Ptr(test.S2), grpptr, test.g1a,
llmemory.sizeof(test.S1))
assert p == test.p2a
p = llop.get_next_group_member(lltype.Ptr(test.S2), grpptr, test.g2a,
llmemory.sizeof(test.S2))
assert p == test.p2b
p = llop.get_next_group_member(lltype.Ptr(test.S1), grpptr, test.g2b,
llmemory.sizeof(test.S2))
assert p == test.p1b
#
expected = [123, 456]
for i in range(2):
p = llop.get_group_member(lltype.Ptr(test.S1), grpptr, g1x[i])
assert p.x == expected[i]
#
for i in range(2):
s = llop.extract_ushort(rffi.USHORT, cslist[i])
p = llop.get_group_member(lltype.Ptr(test.S1), grpptr, s)
assert p == test.p1b
assert cslist[0] & ~0xFFFF == 0x450000
assert cslist[1] & ~0xFFFF == 0x410000
#
return 42
def malloc_array_nonstandard(basesize, itemsize, lengthofs, tid, num_elem):
"""For the rare case of non-standard arrays, i.e. arrays where
self.standard_array_{basesize,length_ofs} is wrong. It can
occur e.g. with arrays of floats on Win32."""
type_id = llop.extract_ushort(llgroup.HALFWORD, tid)
check_typeid(type_id)
return llop1.do_malloc_varsize_clear(llmemory.GCREF, type_id, num_elem, basesize, itemsize, lengthofs)
def _bh_malloc(self, sizedescr):
from pypy.rpython.memory.gctypelayout import check_typeid
llop1 = self.llop1
type_id = llop.extract_ushort(llgroup.HALFWORD, sizedescr.tid)
check_typeid(type_id)
return llop1.do_malloc_fixedsize_clear(llmemory.GCREF, type_id, sizedescr.size, False, False, False)
def malloc_array(itemsize, tid, num_elem):
type_id = llop.extract_ushort(rffi.USHORT, tid)
_check_typeid(type_id)
return llop1.do_malloc_varsize_clear(
llmemory.GCREF,
type_id, num_elem, self.array_basesize, itemsize,
self.array_length_ofs, True)
def malloc_big_fixedsize(size, tid):
if self.DEBUG:
self._random_usage_of_xmm_registers()
type_id = llop.extract_ushort(llgroup.HALFWORD, tid)
check_typeid(type_id)
return llop1.do_malloc_fixedsize_clear(llmemory.GCREF, type_id,
size, False, False, False)
def f():
p = llop.get_group_member(lltype.Ptr(test.S1), grpptr, test.g1a)
assert p == test.p1a
p = llop.get_group_member(lltype.Ptr(test.S1), grpptr, test.g1b)
assert p == test.p1b
p = llop.get_group_member(lltype.Ptr(test.S2), grpptr, test.g2a)
assert p == test.p2a
p = llop.get_group_member(lltype.Ptr(test.S2), grpptr, test.g2b)
assert p == test.p2b
#
p = llop.get_next_group_member(lltype.Ptr(test.S2), grpptr, test.g1a, llmemory.sizeof(test.S1))
assert p == test.p2a
p = llop.get_next_group_member(lltype.Ptr(test.S2), grpptr, test.g2a, llmemory.sizeof(test.S2))
assert p == test.p2b
p = llop.get_next_group_member(lltype.Ptr(test.S1), grpptr, test.g2b, llmemory.sizeof(test.S2))
assert p == test.p1b
#
expected = [123, 456]
for i in range(2):
p = llop.get_group_member(lltype.Ptr(test.S1), grpptr, g1x[i])
assert p.x == expected[i]
#
for i in range(2):
s = llop.extract_ushort(rffi.USHORT, cslist[i])
p = llop.get_group_member(lltype.Ptr(test.S1), grpptr, s)
assert p == test.p1b
assert cslist[0] & ~0xFFFF == 0x450000
assert cslist[1] & ~0xFFFF == 0x410000
#
return 42
def malloc_array(itemsize, tid, num_elem):
type_id = llop.extract_ushort(llgroup.HALFWORD, tid)
check_typeid(type_id)
return llop1.do_malloc_varsize_clear(
llmemory.GCREF,
type_id, num_elem, self.array_basesize, itemsize,
self.array_length_ofs)
def f():
p = llop.get_group_member(lltype.Ptr(test.S1), grpptr, test.g1a)
assert p == test.p1a
p = llop.get_group_member(lltype.Ptr(test.S1), grpptr, test.g1b)
assert p == test.p1b
p = llop.get_group_member(lltype.Ptr(test.S2), grpptr, test.g2a)
assert p == test.p2a
p = llop.get_group_member(lltype.Ptr(test.S2), grpptr, test.g2b)
assert p == test.p2b
#
p = llop.get_next_group_member(lltype.Ptr(test.S2), grpptr,
test.g1a, llmemory.sizeof(test.S1))
assert p == test.p2a
p = llop.get_next_group_member(lltype.Ptr(test.S2), grpptr,
test.g2a, llmemory.sizeof(test.S2))
assert p == test.p2b
p = llop.get_next_group_member(lltype.Ptr(test.S1), grpptr,
test.g2b, llmemory.sizeof(test.S2))
assert p == test.p1b
#
expected = [123, 456]
for i in range(2):
p = llop.get_group_member(lltype.Ptr(test.S1), grpptr, g1x[i])
assert p.x == expected[i]
#
for i in range(2):
s = llop.extract_ushort(HALFWORD, cslist[i])
p = llop.get_group_member(lltype.Ptr(test.S1), grpptr, s)
assert p == test.p1b
assert cslist[0] & ~MASK == 0x45 << HALFSHIFT
assert cslist[1] & ~MASK == 0x41 << HALFSHIFT
assert cslist[0] >> HALFSHIFT == 0x45
assert cslist[1] >> (HALFSHIFT+1) == 0x41 >> 1
#
return 42
def malloc_array(itemsize, tid, num_elem):
type_id = llop.extract_ushort(rffi.USHORT, tid)
_check_typeid(type_id)
return llop1.do_malloc_varsize_clear(llmemory.GCREF, type_id,
num_elem, self.array_basesize,
itemsize,
self.array_length_ofs, True)
def get_type_id(self, addr):
tid = self.header(addr).tid
ll_assert(tid & (GCFLAG_FORWARDED | GCFLAG_EXTERNAL) != GCFLAG_FORWARDED, "get_type_id on forwarded obj")
# Non-prebuilt forwarded objects are overwritten with a FORWARDSTUB.
# Although calling get_type_id() on a forwarded object works by itself,
# we catch it as an error because it's likely that what is then
# done with the typeid is bogus.
return llop.extract_ushort(llgroup.HALFWORD, tid)
def malloc_big_fixedsize(size, tid):
if self.DEBUG:
self._random_usage_of_xmm_registers()
type_id = llop.extract_ushort(llgroup.HALFWORD, tid)
check_typeid(type_id)
return llop1.do_malloc_fixedsize_clear(llmemory.GCREF,
type_id, size,
False, False, False)
def _bh_malloc(self, sizedescr):
from pypy.rpython.memory.gctypelayout import check_typeid
llop1 = self.llop1
type_id = llop.extract_ushort(llgroup.HALFWORD, sizedescr.tid)
check_typeid(type_id)
return llop1.do_malloc_fixedsize_clear(llmemory.GCREF,
type_id, sizedescr.size,
False, False, False)
def malloc_array(itemsize, tid, num_elem):
"""Allocate an array with a variable-size num_elem.
Only works for standard arrays."""
type_id = llop.extract_ushort(llgroup.HALFWORD, tid)
check_typeid(type_id)
return llop1.do_malloc_varsize_clear(
llmemory.GCREF,
type_id, num_elem, self.standard_array_basesize, itemsize,
self.standard_array_length_ofs)
def get_type_id(self, addr):
tid = self.header(addr).tid
ll_assert(tid & (GCFLAG_FORWARDED|GCFLAG_EXTERNAL) != GCFLAG_FORWARDED,
"get_type_id on forwarded obj")
# Non-prebuilt forwarded objects are overwritten with a FORWARDSTUB.
# Although calling get_type_id() on a forwarded object works by itself,
# we catch it as an error because it's likely that what is then
# done with the typeid is bogus.
return llop.extract_ushort(llgroup.HALFWORD, tid)
def _bh_malloc_array(self, arraydescr, num_elem):
from pypy.rpython.memory.gctypelayout import check_typeid
llop1 = self.llop1
type_id = llop.extract_ushort(llgroup.HALFWORD, arraydescr.tid)
check_typeid(type_id)
return llop1.do_malloc_varsize_clear(
llmemory.GCREF, type_id, num_elem, arraydescr.basesize, arraydescr.itemsize, arraydescr.lendescr.offset
)
def _bh_malloc_array(self, arraydescr, num_elem):
from pypy.rpython.memory.gctypelayout import check_typeid
llop1 = self.llop1
type_id = llop.extract_ushort(llgroup.HALFWORD, arraydescr.tid)
check_typeid(type_id)
return llop1.do_malloc_varsize_clear(llmemory.GCREF, type_id, num_elem,
arraydescr.basesize,
arraydescr.itemsize,
arraydescr.lendescr.offset)
def malloc_array(itemsize, tid, num_elem):
"""Allocate an array with a variable-size num_elem.
Only works for standard arrays."""
type_id = llop.extract_ushort(llgroup.HALFWORD, tid)
check_typeid(type_id)
return llop1.do_malloc_varsize_clear(
llmemory.GCREF,
type_id, num_elem, self.standard_array_basesize, itemsize,
self.standard_array_length_ofs)
def malloc_basic(size, tid):
type_id = llop.extract_ushort(rffi.USHORT, tid)
has_finalizer = bool(tid & (1 << 16))
_check_typeid(type_id)
res = llop1.do_malloc_fixedsize_clear(llmemory.GCREF, type_id,
size, True, has_finalizer,
False)
#llop.debug_print(lltype.Void, "\tmalloc_basic", size, type_id,
# "-->", res)
return res
def malloc_basic(size, tid):
type_id = llop.extract_ushort(rffi.USHORT, tid)
has_finalizer = bool(tid & (1<<16))
_check_typeid(type_id)
res = llop1.do_malloc_fixedsize_clear(llmemory.GCREF,
type_id, size, True,
has_finalizer, False)
#llop.debug_print(lltype.Void, "\tmalloc_basic", size, type_id,
# "-->", res)
return res
def malloc_array_nonstandard(basesize, itemsize, lengthofs, tid,
num_elem):
"""For the rare case of non-standard arrays, i.e. arrays where
self.standard_array_{basesize,length_ofs} is wrong. It can
occur e.g. with arrays of floats on Win32."""
type_id = llop.extract_ushort(llgroup.HALFWORD, tid)
check_typeid(type_id)
return llop1.do_malloc_varsize_clear(
llmemory.GCREF,
type_id, num_elem, basesize, itemsize, lengthofs)
def malloc_array(itemsize, tid, num_elem):
type_id = llop.extract_ushort(rffi.USHORT, tid)
_check_typeid(type_id)
try:
return llop1.do_malloc_varsize_clear(
llmemory.GCREF, type_id, num_elem, self.array_basesize,
itemsize, self.array_length_ofs, True)
except MemoryError:
fatalerror("out of memory (from JITted code)")
return lltype.nullptr(llmemory.GCREF.TO)
def malloc_array(itemsize, tid, num_elem):
type_id = llop.extract_ushort(llgroup.HALFWORD, tid)
check_typeid(type_id)
try:
return llop1.do_malloc_varsize_clear(
llmemory.GCREF,
type_id, num_elem, self.array_basesize, itemsize,
self.array_length_ofs, True)
except MemoryError:
fatalerror("out of memory (from JITted code)")
return lltype.nullptr(llmemory.GCREF.TO)
def malloc_basic(size, tid):
type_id = llop.extract_ushort(llgroup.HALFWORD, tid)
has_finalizer = bool(tid & (1<<llgroup.HALFSHIFT))
check_typeid(type_id)
try:
res = llop1.do_malloc_fixedsize_clear(llmemory.GCREF,
type_id, size, True,
has_finalizer, False)
except MemoryError:
fatalerror("out of memory (from JITted code)")
res = lltype.nullptr(llmemory.GCREF.TO)
#llop.debug_print(lltype.Void, "\tmalloc_basic", size, type_id,
# "-->", res)
return res
def malloc_basic(size, tid):
type_id = llop.extract_ushort(llgroup.HALFWORD, tid)
check_typeid(type_id)
res = llop1.do_malloc_fixedsize_clear(llmemory.GCREF,
type_id, size,
False, False, False)
# In case the operation above failed, we are returning NULL
# from this function to assembler. There is also an RPython
# exception set, typically MemoryError; but it's easier and
# faster to check for the NULL return value, as done by
# translator/exceptiontransform.py.
#llop.debug_print(lltype.Void, "\tmalloc_basic", size, type_id,
# "-->", res)
return res
def malloc_basic(size, tid):
type_id = llop.extract_ushort(rffi.USHORT, tid)
has_finalizer = bool(tid & (1 << 16))
_check_typeid(type_id)
try:
res = llop1.do_malloc_fixedsize_clear(llmemory.GCREF, type_id,
size, True,
has_finalizer, False)
except MemoryError:
fatalerror("out of memory (from JITted code)")
res = lltype.nullptr(llmemory.GCREF.TO)
#llop.debug_print(lltype.Void, "\tmalloc_basic", size, type_id,
# "-->", res)
return res
def build_test():
test = TestLLGroup()
test.build()
grpptr = test.grpptr
g1x = [test.g1a, test.g1b]
MASK = CombinedSymbolic.MASK
cs1 = CombinedSymbolic(test.g1b, 0x45 << HALFSHIFT)
cs2 = CombinedSymbolic(test.g1b, 0x41 << HALFSHIFT)
assert llop.extract_ushort(HALFWORD, cs1) is test.g1b
assert cs1 & ~MASK == 0x45 << HALFSHIFT
cslist = [cs1, cs2]
#
def f():
p = llop.get_group_member(lltype.Ptr(test.S1), grpptr, test.g1a)
assert p == test.p1a
p = llop.get_group_member(lltype.Ptr(test.S1), grpptr, test.g1b)
assert p == test.p1b
p = llop.get_group_member(lltype.Ptr(test.S2), grpptr, test.g2a)
assert p == test.p2a
p = llop.get_group_member(lltype.Ptr(test.S2), grpptr, test.g2b)
assert p == test.p2b
#
p = llop.get_next_group_member(lltype.Ptr(test.S2), grpptr,
test.g1a, llmemory.sizeof(test.S1))
assert p == test.p2a
p = llop.get_next_group_member(lltype.Ptr(test.S2), grpptr,
test.g2a, llmemory.sizeof(test.S2))
assert p == test.p2b
p = llop.get_next_group_member(lltype.Ptr(test.S1), grpptr,
test.g2b, llmemory.sizeof(test.S2))
assert p == test.p1b
#
expected = [123, 456]
for i in range(2):
p = llop.get_group_member(lltype.Ptr(test.S1), grpptr, g1x[i])
assert p.x == expected[i]
#
for i in range(2):
s = llop.extract_ushort(HALFWORD, cslist[i])
p = llop.get_group_member(lltype.Ptr(test.S1), grpptr, s)
assert p == test.p1b
assert cslist[0] & ~MASK == 0x45 << HALFSHIFT
assert cslist[1] & ~MASK == 0x41 << HALFSHIFT
assert cslist[0] >> HALFSHIFT == 0x45
assert cslist[1] >> (HALFSHIFT+1) == 0x41 >> 1
#
return 42
return f
def build_test():
test = TestLLGroup()
test.build()
grpptr = test.grpptr
g1x = [test.g1a, test.g1b]
cs1 = CombinedSymbolic(test.g1b, 0x450000)
cs2 = CombinedSymbolic(test.g1b, 0x410000)
assert llop.extract_ushort(rffi.USHORT, cs1) is test.g1b
assert cs1 & ~0xFFFF == 0x450000
cslist = [cs1, cs2]
#
def f():
p = llop.get_group_member(lltype.Ptr(test.S1), grpptr, test.g1a)
assert p == test.p1a
p = llop.get_group_member(lltype.Ptr(test.S1), grpptr, test.g1b)
assert p == test.p1b
p = llop.get_group_member(lltype.Ptr(test.S2), grpptr, test.g2a)
assert p == test.p2a
p = llop.get_group_member(lltype.Ptr(test.S2), grpptr, test.g2b)
assert p == test.p2b
#
p = llop.get_next_group_member(lltype.Ptr(test.S2), grpptr, test.g1a,
llmemory.sizeof(test.S1))
assert p == test.p2a
p = llop.get_next_group_member(lltype.Ptr(test.S2), grpptr, test.g2a,
llmemory.sizeof(test.S2))
assert p == test.p2b
p = llop.get_next_group_member(lltype.Ptr(test.S1), grpptr, test.g2b,
llmemory.sizeof(test.S2))
assert p == test.p1b
#
expected = [123, 456]
for i in range(2):
p = llop.get_group_member(lltype.Ptr(test.S1), grpptr, g1x[i])
assert p.x == expected[i]
#
for i in range(2):
s = llop.extract_ushort(rffi.USHORT, cslist[i])
p = llop.get_group_member(lltype.Ptr(test.S1), grpptr, s)
assert p == test.p1b
assert cslist[0] & ~0xFFFF == 0x450000
assert cslist[1] & ~0xFFFF == 0x410000
#
return 42
return f
def build_test():
test = TestLLGroup()
test.build()
grpptr = test.grpptr
g1x = [test.g1a, test.g1b]
cs1 = CombinedSymbolic(test.g1b, 0x450000)
cs2 = CombinedSymbolic(test.g1b, 0x410000)
assert llop.extract_ushort(rffi.USHORT, cs1) is test.g1b
assert cs1 & ~0xFFFF == 0x450000
cslist = [cs1, cs2]
#
def f():
p = llop.get_group_member(lltype.Ptr(test.S1), grpptr, test.g1a)
assert p == test.p1a
p = llop.get_group_member(lltype.Ptr(test.S1), grpptr, test.g1b)
assert p == test.p1b
p = llop.get_group_member(lltype.Ptr(test.S2), grpptr, test.g2a)
assert p == test.p2a
p = llop.get_group_member(lltype.Ptr(test.S2), grpptr, test.g2b)
assert p == test.p2b
#
p = llop.get_next_group_member(lltype.Ptr(test.S2), grpptr, test.g1a, llmemory.sizeof(test.S1))
assert p == test.p2a
p = llop.get_next_group_member(lltype.Ptr(test.S2), grpptr, test.g2a, llmemory.sizeof(test.S2))
assert p == test.p2b
p = llop.get_next_group_member(lltype.Ptr(test.S1), grpptr, test.g2b, llmemory.sizeof(test.S2))
assert p == test.p1b
#
expected = [123, 456]
for i in range(2):
p = llop.get_group_member(lltype.Ptr(test.S1), grpptr, g1x[i])
assert p.x == expected[i]
#
for i in range(2):
s = llop.extract_ushort(rffi.USHORT, cslist[i])
p = llop.get_group_member(lltype.Ptr(test.S1), grpptr, s)
assert p == test.p1b
assert cslist[0] & ~0xFFFF == 0x450000
assert cslist[1] & ~0xFFFF == 0x410000
#
return 42
return f
def get_type_id(self, addr):
tid = self.header(addr).tid
return llop.extract_ushort(rffi.USHORT, tid)
def get_type_id(self, addr):
tid = self.header(addr).tid
return llop.extract_ushort(rffi.USHORT, tid)
def get_type_id(self, addr):
tid = self.header(addr).tid
return llop.extract_ushort(llgroup.HALFWORD, tid)
def get_type_id(self, addr):
tid = self.header(addr).tid
return llop.extract_ushort(llgroup.HALFWORD, tid)
