Lines Matching refs:address
59 HeapObjectIterator::HeapObjectIterator(PagedSpace* space, Address start) {
64 HeapObjectIterator::HeapObjectIterator(PagedSpace* space, Address start,
70 void HeapObjectIterator::Initialize(Address cur, Address end,
170 LOG(NewEvent("CodeRange", code_range_->address(), requested));
171 allocation_list_.Add(FreeBlock(code_range_->address(), code_range_->size()));
256 void CodeRange::FreeRawMemory(void* address, size_t length) {
257 free_list_.Add(FreeBlock(address, length));
258 code_range_->Uncommit(address, length);
329 if (chunks_[i].address() != NULL) DeleteChunk(i);
335 LOG(DeleteEvent("InitialChunk", initial_chunk_->address()));
361 ZapBlock(reinterpret_cast<Address>(mem), alloced);
370 ZapBlock(reinterpret_cast<Address>(mem), length);
372 if (CodeRange::contains(static_cast<Address>(mem))) {
396 LOG(NewEvent("InitialChunk", initial_chunk_->address(), requested));
398 return initial_chunk_->address();
402 static int PagesInChunk(Address start, size_t size) {
403 // The first page starts on the first page-aligned address from start onward
404 // and the last page ends on the last page-aligned address before
430 *allocated_pages = PagesInChunk(static_cast<Address>(chunk), chunk_size);
438 chunks_[chunk_id].init(static_cast<Address>(chunk), chunk_size, owner);
444 Page* MemoryAllocator::CommitPages(Address start, size_t size,
469 bool MemoryAllocator::CommitBlock(Address start,
487 bool MemoryAllocator::UncommitBlock(Address start, size_t size) {
500 void MemoryAllocator::ZapBlock(Address start, size_t size) {
512 Address chunk_start = chunks_[chunk_id].address();
514 Address low = RoundUp(chunk_start, Page::kPageSize);
518 Address high = RoundDown(chunk_start + chunk_size, Page::kPageSize);
523 Address page_addr = low;
579 if (InInitialChunk(c.address())) {
582 initial_chunk_->Uncommit(c.address(), c.size());
585 LOG(DeleteEvent("PagedChunk", c.address()));
586 FreeRawMemory(c.address(), c.size());
597 Address low = RoundUp(chunks_[chunk_id].address(), Page::kPageSize);
606 Address chunk_start = chunks_[chunk_id].address();
609 Address high = RoundDown(chunk_start + chunk_size, Page::kPageSize);
610 ASSERT(chunk_start <= p->address() && p->address() < high);
644 bool PagedSpace::Setup(Address start, size_t size) {
727 Object* PagedSpace::FindObject(Address addr) {
736 Address cur = p->ObjectAreaStart();
737 Address end = p->AllocationTop();
740 Address next = cur + obj->Size();
783 int PagedSpace::MCSpaceOffsetForAddress(Address addr) {
785 // The Contains function considers the address at the beginning of a
952 Address top = current_page->AllocationTop();
962 Address current = current_page->ObjectAreaStart();
1001 bool NewSpace::Setup(Address start, int size) {
1171 // There should be objects packed in from the low address up to the
1173 Address current = to_space_.low();
1227 bool SemiSpace::Setup(Address start,
1317 SemiSpaceIterator::SemiSpaceIterator(NewSpace* space, Address start) {
1322 void SemiSpaceIterator::Initialize(NewSpace* space, Address start,
1323 Address end,
1569 Address FreeListNode::next() {
1573 return Memory::Address_at(address() + kNextOffset);
1575 return Memory::Address_at(address() + kPointerSize);
1580 Address next) {
1584 Memory::Address_at(address() + kNextOffset) = next;
1586 Memory::Address_at(address() + kPointerSize) = next;
1621 int OldSpaceFreeList::Free(Address start, int size_in_bytes) {
1645 free_[index].head_node_ = node->address();
1700 free_[rem].head_node_ = rem_node->address();
1717 free_[rem].head_node_ = rem_node->address();
1729 Address cur_addr = free_[i].head_node_;
1753 void FixedSizeFreeList::Free(Address start) {
1762 head_ = node->address();
1848 Address limit = allocation_info_.limit;
1849 Address top = allocation_info_.top;
1855 Address limit = allocation_info_.limit;
1856 Address top = allocation_info_.top;
2116 for (Address rset_addr = p->RSetStart();
2123 static_cast<int>(rset_addr - p->address() - Page::kRSetOffset);
2128 Address slot = p->OffsetToAddress(bitpos << kObjectAlignmentBits);
2136 Address elm_start = slot + FixedArray::kHeaderSize;
2137 Address elm_stop = elm_start + fa->length() * kPointerSize;
2138 for (Address elm_addr = elm_start;
2188 static void PrintRSetRange(Address start, Address end, Object** object_p,
2189 Address allocation_top) {
2190 Address rset_address = start;
2300 Address page_top = page->AllocationTop();
2384 for (Address rset_addr = p->RSetStart();
2391 static_cast<int>(rset_addr - p->address() - Page::kRSetOffset);
2396 Address slot = p->OffsetToAddress(bitpos << kObjectAlignmentBits);
2441 page_addresses_[page_count++] = p->address();
2542 LOG(DeleteEvent("LargeObjectChunk", chunk->address()));
2543 MemoryAllocator::FreeRawMemory(chunk->address(), chunk->size());
2556 MemoryAllocator::Protect(chunk->address(), chunk->size());
2566 MemoryAllocator::Unprotect(chunk->address(), chunk->size(),
2599 // Set the object address and size in the page header and clear its
2601 Page* page = Page::FromAddress(RoundUp(chunk->address(), Page::kPageSize));
2602 Address object_address = page->ObjectAreaStart();
2645 Object* LargeObjectSpace::FindObject(Address a) {
2649 Address chunk_address = chunk->address();
2667 Page* page = Page::FromAddress(object->address());
2673 memset(object->address() + size, 0, extra_rset_bytes);
2696 Page* page = Page::FromAddress(object->address());
2697 Address object_end = object->address() + object->Size();
2727 Address chunk_address = current->address();
2750 Address address = object->address();
2751 Page* page = Page::FromAddress(address);
2754 || !FindObject(address)->IsFailure());
2770 Page* page = Page::FromAddress(object->address());
2771 ASSERT(object->address() == page->ObjectAreaStart());
2807 ASSERT(Page::IsRSetSet(object->address(),
2855 Page* page = Page::FromAddress(object->address());
2857 Address allocation_top = object->address() + object->Size();
2860 reinterpret_cast<Object**>(object->address()),
2869 reinterpret_cast<Object**>(object->address()
