def test_simple_access(self):
AddressStack = get_address_stack()
addr0 = raw_malloc(llmemory.sizeof(lltype.Signed))
addr1 = raw_malloc(llmemory.sizeof(lltype.Signed))
addr2 = raw_malloc(llmemory.sizeof(lltype.Signed))
ll = AddressStack()
ll.append(addr0)
ll.append(addr1)
ll.append(addr2)
assert ll.non_empty()
a = ll.pop()
assert a == addr2
assert ll.non_empty()
a = ll.pop()
assert a == addr1
assert ll.non_empty()
a = ll.pop()
assert a == addr0
assert not ll.non_empty()
ll.append(addr0)
ll.delete()
ll = AddressStack()
ll.append(addr0)
ll.append(addr1)
ll.append(addr2)
ll.append(NULL)
a = ll.pop()
assert a == NULL
ll.delete()
raw_free(addr2)
raw_free(addr1)
raw_free(addr0)
def test_simple_access(self):
AddressStack = get_address_stack()
addr0 = raw_malloc(llmemory.sizeof(lltype.Signed))
addr1 = raw_malloc(llmemory.sizeof(lltype.Signed))
addr2 = raw_malloc(llmemory.sizeof(lltype.Signed))
ll = AddressStack()
ll.append(addr0)
ll.append(addr1)
ll.append(addr2)
assert ll.non_empty()
a = ll.pop()
assert a == addr2
assert ll.non_empty()
a = ll.pop()
assert a == addr1
assert ll.non_empty()
a = ll.pop()
assert a == addr0
assert not ll.non_empty()
ll.append(addr0)
ll.delete()
ll = AddressStack()
ll.append(addr0)
ll.append(addr1)
ll.append(addr2)
ll.append(NULL)
a = ll.pop()
assert a == NULL
ll.delete()
raw_free(addr2)
raw_free(addr1)
raw_free(addr0)
def f():
adr = llmemory.raw_malloc(sizeofs)
s = llmemory.cast_adr_to_ptr(adr, STRUCTPTR)
s.y = 5 # does not crash
result = (adr + offsety).signed[0] * 10 + int(offsety < sizeofs)
llmemory.raw_free(adr)
return result
def f():
adr = llmemory.raw_malloc(sizeofs)
s = llmemory.cast_adr_to_ptr(adr, STRUCTPTR)
s.y = 5 # does not crash
result = (adr + offsety).signed[0] * 10 + int(offsety < sizeofs)
llmemory.raw_free(adr)
return result
def f():
addr = raw_malloc(INT_SIZE * 100)
ll = AddressStack()
ll.append(addr)
ll.append(addr + INT_SIZE * 1)
ll.append(addr + INT_SIZE * 2)
a = ll.pop()
res = (a - INT_SIZE * 2 == addr)
a = ll.pop()
res = res and (a - INT_SIZE * 1 == addr)
res = res and ll.non_empty()
a = ll.pop()
res = res and a == addr
res = res and not ll.non_empty()
ll.append(addr)
for i in range(300):
ll.append(addr + INT_SIZE * i)
for i in range(299, -1, -1):
a = ll.pop()
res = res and (a - INT_SIZE * i == addr)
for i in range(300):
ll.append(addr + INT_SIZE * i)
for i in range(299, -1, -1):
a = ll.pop()
res = res and (a - INT_SIZE * i == addr)
ll.delete()
ll = AddressStack()
ll.append(addr)
ll.append(addr + INT_SIZE * 1)
ll.append(addr + INT_SIZE * 2)
ll.delete()
raw_free(addr)
return res
def test_foreach(self):
AddressDeque = get_address_deque(10)
ll = AddressDeque()
for num_entries in range(30, -1, -1):
addrs = [
raw_malloc(llmemory.sizeof(lltype.Signed))
for i in range(num_entries)
]
for a in addrs:
ll.append(a)
seen = []
def callback(addr, fortytwo):
assert fortytwo == 42
seen.append(addr)
ll.foreach(callback, 42)
assert seen == addrs
seen = []
ll.foreach(callback, 42, step=2)
assert seen == addrs[::2]
for a in addrs:
b = ll.popleft()
assert a == b
assert not ll.non_empty()
def ll_prepare_free_slot(_unused):
"""Free up a slot in the array of MAX entries, ready for storing
a new shadowstackref. Return the memory of the now-unused full
shadowstack.
"""
index = fullstack_cache[0]
if index > 0:
return llmemory.NULL # there is already at least one free slot
#
# make a compact copy in one old entry and return the
# original full-sized memory
index = -index
ll_assert(index > 0, "prepare_free_slot: cache[0] == 0")
compacting = lltype.cast_int_to_ptr(SHADOWSTACKREFPTR,
fullstack_cache[index])
index += 1
if index >= ShadowStackPool.MAX:
index = 1
fullstack_cache[0] = -index # update to the next value in order
#
compacting.detach()
original = compacting.base
size = compacting.top - original
new = llmemory.raw_malloc(size)
if new == llmemory.NULL:
return llmemory.NULL
llmemory.raw_memcopy(original, new, size)
compacting.base = new
compacting.top = new + size
return original
def _prepare_unused_stack(self):
ll_assert(self.unused_full_stack == llmemory.NULL,
"already an unused_full_stack")
root_stack_size = sizeofaddr * self.root_stack_depth
self.unused_full_stack = llmemory.raw_malloc(root_stack_size)
if self.unused_full_stack == llmemory.NULL:
raise MemoryError
def f():
addr = raw_malloc(INT_SIZE*100)
ll = AddressStack()
ll.append(addr)
ll.append(addr + INT_SIZE*1)
ll.append(addr + INT_SIZE*2)
a = ll.pop()
res = (a - INT_SIZE*2 == addr)
a = ll.pop()
res = res and (a - INT_SIZE*1 == addr)
res = res and ll.non_empty()
a = ll.pop()
res = res and a == addr
res = res and not ll.non_empty()
ll.append(addr)
for i in range(300):
ll.append(addr + INT_SIZE*i)
for i in range(299, -1, -1):
a = ll.pop()
res = res and (a - INT_SIZE*i == addr)
for i in range(300):
ll.append(addr + INT_SIZE*i)
for i in range(299, -1, -1):
a = ll.pop()
res = res and (a - INT_SIZE*i == addr)
ll.delete()
ll = AddressStack()
ll.append(addr)
ll.append(addr + INT_SIZE*1)
ll.append(addr + INT_SIZE*2)
ll.delete()
raw_free(addr)
return res
def sscopy_detach_shadow_stack():
base = llop.gc_adr_of_root_stack_base(llmemory.Address).address[0]
top = llop.gc_adr_of_root_stack_top(llmemory.Address).address[0]
length_bytes = top - base
result = llmemory.raw_malloc(SIZEADDR + length_bytes)
if result:
result.signed[0] = length_bytes
llmemory.raw_memcopy(base, result + SIZEADDR, length_bytes)
llop.gc_adr_of_root_stack_top(llmemory.Address).address[0] = base
return result
def call_qsort_rec(r):
if r > 0:
g = GcObject()
g.num += r
call_qsort_rec(r - 1)
assert g.num == 1234 + r
else:
raw = llmemory.raw_malloc(5)
qsort(raw, 5, 1, cb_compare_callback)
llmemory.raw_free(raw)
def sscopy_detach_shadow_stack():
base = llop.gc_adr_of_root_stack_base(llmemory.Address).address[0]
top = llop.gc_adr_of_root_stack_top(llmemory.Address).address[0]
length_bytes = top - base
result = llmemory.raw_malloc(SIZEADDR + length_bytes)
if result:
result.signed[0] = length_bytes
llmemory.raw_memcopy(base, result + SIZEADDR, length_bytes)
llop.gc_adr_of_root_stack_top(llmemory.Address).address[0] = base
return result
def test_length(self):
AddressStack = get_address_stack(10)
ll = AddressStack()
a = raw_malloc(llmemory.sizeof(lltype.Signed))
for i in range(42):
assert ll.length() == i
ll.append(a)
for i in range(42-1, -1, -1):
b = ll.pop()
assert b == a
assert ll.length() == i
def test_length(self):
AddressStack = get_address_stack(10)
ll = AddressStack()
a = raw_malloc(llmemory.sizeof(lltype.Signed))
for i in range(42):
assert ll.length() == i
ll.append(a)
for i in range(42 - 1, -1, -1):
b = ll.pop()
assert b == a
assert ll.length() == i
def _resize(self, base, used, new_depth):
new_size = sizeofaddr * new_depth
ll_assert(used <= new_size, "shadowstack resize: overflow detected")
addr = llmemory.raw_malloc(new_size)
if addr == llmemory.NULL:
raise MemoryError
# note that we don't know the total memory size of 'base', but we
# know the size of the part that is used right now, and we only need
# to copy that
llmemory.raw_memmove(base, addr, used)
llmemory.raw_free(base)
return addr
def test_remove(self):
AddressStack = get_address_stack()
addrs = [raw_malloc(llmemory.sizeof(lltype.Signed))
for i in range(2200)]
ll = AddressStack()
for i in range(2200):
ll.append(addrs[i])
ll.remove(addrs[-400])
expected = range(2200)
del expected[-400]
expected.reverse()
for i in expected:
a = ll.pop()
assert a == addrs[i]
assert not ll.non_empty()
def test_foreach(self):
AddressStack = get_address_stack()
addrs = [raw_malloc(llmemory.sizeof(lltype.Signed))
for i in range(3000)]
ll = AddressStack()
for i in range(3000):
ll.append(addrs[i])
seen = []
def callback(addr, fortytwo):
assert fortytwo == 42
seen.append(addr)
ll.foreach(callback, 42)
assert seen == addrs or seen[::-1] == addrs # order not guaranteed
def test_big_access(self):
import random
AddressDeque = get_address_deque(10)
deque = AddressDeque()
expected = []
for i in range(3000):
assert deque.non_empty() == (len(expected) > 0)
r = random.random()
if r < 0.51 and expected:
x = deque.popleft()
y = expected.pop(0)
assert x == y
else:
x = raw_malloc(llmemory.sizeof(lltype.Signed))
deque.append(x)
expected.append(x)
def test_remove(self):
AddressStack = get_address_stack()
addrs = [
raw_malloc(llmemory.sizeof(lltype.Signed)) for i in range(2200)
]
ll = AddressStack()
for i in range(2200):
ll.append(addrs[i])
ll.remove(addrs[-400])
expected = range(2200)
del expected[-400]
expected.reverse()
for i in expected:
a = ll.pop()
assert a == addrs[i]
assert not ll.non_empty()
def test_big_access(self):
import random
AddressDeque = get_address_deque(10)
deque = AddressDeque()
expected = []
for i in range(3000):
assert deque.non_empty() == (len(expected) > 0)
r = random.random()
if r < 0.51 and expected:
x = deque.popleft()
y = expected.pop(0)
assert x == y
else:
x = raw_malloc(llmemory.sizeof(lltype.Signed))
deque.append(x)
expected.append(x)
def test_foreach(self):
AddressStack = get_address_stack()
addrs = [
raw_malloc(llmemory.sizeof(lltype.Signed)) for i in range(3000)
]
ll = AddressStack()
for i in range(3000):
ll.append(addrs[i])
seen = []
def callback(addr, fortytwo):
assert fortytwo == 42
seen.append(addr)
ll.foreach(callback, 42)
assert seen == addrs or seen[::-1] == addrs # order not guaranteed
def test_foreach(self):
AddressDeque = get_address_deque(10)
ll = AddressDeque()
for num_entries in range(30, -1, -1):
addrs = [raw_malloc(llmemory.sizeof(lltype.Signed))
for i in range(num_entries)]
for a in addrs:
ll.append(a)
seen = []
def callback(addr, fortytwo):
assert fortytwo == 42
seen.append(addr)
ll.foreach(callback, 42)
assert seen == addrs
for a in addrs:
b = ll.popleft()
assert a == b
assert not ll.non_empty()
def test_big_access(self):
AddressStack = get_address_stack()
addrs = [raw_malloc(llmemory.sizeof(lltype.Signed))
for i in range(3000)]
ll = AddressStack()
for i in range(3000):
print i
ll.append(addrs[i])
for i in range(3000)[::-1]:
a = ll.pop()
assert a == addrs[i]
for i in range(3000):
print i
ll.append(addrs[i])
for i in range(3000)[::-1]:
a = ll.pop()
assert a == addrs[i]
ll.delete()
for addr in addrs:
raw_free(addr)
def test_big_access(self):
AddressStack = get_address_stack()
addrs = [
raw_malloc(llmemory.sizeof(lltype.Signed)) for i in range(3000)
]
ll = AddressStack()
for i in range(3000):
print i
ll.append(addrs[i])
for i in range(3000)[::-1]:
a = ll.pop()
assert a == addrs[i]
for i in range(3000):
print i
ll.append(addrs[i])
for i in range(3000)[::-1]:
a = ll.pop()
assert a == addrs[i]
ll.delete()
for addr in addrs:
raw_free(addr)
def op_raw_malloc(self, size):
assert lltype.typeOf(size) == lltype.Signed
return llmemory.raw_malloc(size)
def _prepare_unused_stack(self):
if self.unused_full_stack == llmemory.NULL:
root_stack_size = sizeofaddr * self.root_stack_depth
self.unused_full_stack = llmemory.raw_malloc(root_stack_size)
if self.unused_full_stack == llmemory.NULL:
raise MemoryError
def _malloc(self, type_id, size):
tid = llop.combine_ushort(lltype.Signed, type_id, 0)
x = llmemory.raw_malloc(self.gcheaderbuilder.size_gc_header + size)
x += self.gcheaderbuilder.size_gc_header
return x, tid
def __init__(self):
self.addr = llmemory.raw_malloc(SIZE)
def alloc1():
return llmemory.raw_malloc(16)
def alloc1():
return llmemory.raw_malloc(16)
def __init__(self):
self.addr = llmemory.raw_malloc(SIZE)
def _prepare_unused_stack(self):
if self.unused_full_stack == llmemory.NULL:
root_stack_size = sizeofaddr * self.root_stack_depth
self.unused_full_stack = llmemory.raw_malloc(root_stack_size)
if self.unused_full_stack == llmemory.NULL:
raise MemoryError
def allocate_external_object(self, totalsize):
# XXX maybe we should use arena_malloc() above a certain size?
# If so, we'd also use arena_reset() in malloc_varsize_marknsweep().
return llmemory.raw_malloc(totalsize)
def _malloc(self, type_id, size):
tid = llop.combine_ushort(lltype.Signed, type_id, 0)
x = llmemory.raw_malloc(self.gcheaderbuilder.size_gc_header + size)
x += self.gcheaderbuilder.size_gc_header
return x, tid
def op_raw_malloc(self, size):
assert lltype.typeOf(size) == lltype.Signed
return llmemory.raw_malloc(size)
def allocate_external_object(self, totalsize):
# XXX maybe we should use arena_malloc() above a certain size?
# If so, we'd also use arena_reset() in malloc_varsize_marknsweep().
return llmemory.raw_malloc(totalsize)
