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(): 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 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_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 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)