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)