Lines Matching defs:address
37 __attribute__((no_sanitize("address")))
827 * to the required valid alignment of the returned address. Requests of
871 * on most current architectures (with 32-bit or 64-bit address buses).
946 * on a page boundary. This is a reserved virtual address space for the
949 * usually an address range reservation for <Big> bytes, unless all pages within
1017 /* The address of the arena, as returned by malloc. Note that 0
1022 uintptr_t address;
1060 /* Round pointer P down to the closest pool-aligned address <= P, as a poolp */
1126 blocks, that means we simply haven't yet gotten to one of the higher-address
1213 is on this list if and only if its .address member is 0.
1283 if (arenas[i].address == 0) {
1287 uintptr_t base = (uintptr_t)_Py_ALIGN_UP(arenas[i].address, POOL_SIZE);
1304 memory address bit allocation for keys
1367 /* the lower bits of the address that are not ignored */
1399 /* Return the ignored part of the pointer address. Those bits should be same
1486 * away 24 bits of the address. That reduces the space requirement of
1489 * computation to check an address.
1491 * Tracking coverage is done by "ideal" arena address. It is easier to
1494 * pointer address is inside an actual arena, we have to check two ideal
1497 * (e.g. base address of arena is 200) then we only have to check one
1498 * ideal address.
1500 * The tree nodes for 200 and 300 both store the address of arena.
1522 /* is ideal arena address */
1526 /* arena_base address is not ideal (aligned to arena size) and
1534 /* If arena_base is a legit arena address, so is arena_base_next - 1
1535 * (last address in arena). If arena_base_next overflows then it
1574 * allocate a new arena, and return the address of an arena_object
1583 void *address;
1626 arenas[i].address = 0; /* mark as unassociated */
1640 assert(arenaobj->address == 0);
1641 address = _PyObject_Arena.alloc(_PyObject_Arena.ctx, ARENA_SIZE);
1643 if (address != NULL) {
1644 if (!arena_map_mark_used((uintptr_t)address, 1)) {
1646 _PyObject_Arena.free(_PyObject_Arena.ctx, address, ARENA_SIZE);
1647 address = NULL;
1651 if (address == NULL) {
1659 arenaobj->address = (uintptr_t)address;
1666 /* pool_address <- first pool-aligned address in the arena
1668 arenaobj->pool_address = (block*)arenaobj->address;
1670 excess = (uint)(arenaobj->address & POOL_SIZE_MASK);
1683 /* Return true if and only if P is an address that was allocated by
1695 Return true if and only if P is an address that was allocated by pymalloc.
1696 POOL must be the pool address associated with P, i.e., POOL = POOL_ADDR(P)
1702 Tricky: Let B be the arena base address associated with the pool, B =
1703 arenas[(POOL)->arenaindex].address. Then P belongs to the arena if and only if
1721 stores, etc), POOL is the correct address of P's pool, AO.address is the
1722 correct base address of the pool's arena, and P must be within ARENA_SIZE of
1723 AO.address. In addition, AO.address is not 0 (no arena can start at address 0
1734 allocated arena, obmalloc controls all the memory in slice AO.address :
1735 AO.address+ARENA_SIZE. By case assumption, P is not controlled by obmalloc,
1741 AO.address is 0, and the second test in the macro reduces to:
1747 of the test still passes, and the third clause (AO.address != 0) is necessary
1748 to get the correct result: AO.address is 0 in this case, so the macro
1750 slice AO.address : AO.address + ARENA_SIZE).
1752 Note: The third (AO.address != 0) clause was added in Python 2.5. Before
1761 that this test determines whether an arbitrary address is controlled by
1779 (uintptr_t)p - arenas[arenaindex].address < ARENA_SIZE &&
1780 arenas[arenaindex].address != 0;
1832 assert(usable_arenas->address != 0);
1865 assert(usable_arenas->address != 0);
1876 (block*)usable_arenas->address +
1885 assert((block*)pool <= (block*)usable_arenas->address +
1901 assert(usable_arenas->address != 0);
2100 ao->prevarena->address != 0);
2102 ao->nextarena->address != 0);
2110 usable_arenas->address != 0);
2131 arena_map_mark_used(ao->address, 0);
2136 (void *)ao->address, ARENA_SIZE);
2137 ao->address = 0; /* mark unassociated */
2154 assert(usable_arenas->address != 0);
2232 /* We allocated this address. */
2284 /* pymalloc didn't allocate this address */
2434 /* Write n as a big-endian size_t, MSB at address p, LSB at
2482 uint8_t *p; /* base address of malloc'ed pad block */
2568 uint8_t *q = (uint8_t *)p - 2*SST; /* address returned from malloc */
2587 uint8_t *head; /* base address of malloc'ed pad block */
2777 fprintf(stderr, "Debug memory block at address p=%p:", p);
3002 uintptr_t base = arenas[i].address;
3005 if (arenas[i].address == (uintptr_t)NULL)