Lines Matching full:address
42 void HeapObjectIterator::Initialize(PagedSpace* space, Address cur, Address end,
91 // in a kMaximalCodeRangeSize range of virtual address space, so that
122 Address base = reinterpret_cast<Address>(code_range_->address());
135 Address aligned_base = RoundUp(base, MemoryChunk::kAlignment);
141 LOG(isolate_, NewEvent("CodeRange", code_range_->address(), requested));
196 Address CodeRange::AllocateRawMemory(const size_t requested_size,
221 bool CodeRange::CommitRawMemory(Address start, size_t length) {
226 bool CodeRange::UncommitRawMemory(Address start, size_t length) {
231 void CodeRange::FreeRawMemory(Address address, size_t length) {
232 DCHECK(IsAddressAligned(address, MemoryChunk::kAlignment));
234 free_list_.Add(FreeBlock(address, length));
235 code_range_->Uncommit(address, length);
313 bool MemoryAllocator::CommitMemory(Address base, size_t size,
324 void MemoryAllocator::FreeNewSpaceMemory(Address addr,
344 static_cast<Address>(reservation->address())));
353 void MemoryAllocator::FreeMemory(Address base, size_t size,
357 isolate_->code_range()->contains(static_cast<Address>(base))) {
370 Address MemoryAllocator::ReserveAlignedMemory(size_t size, size_t alignment,
376 Address base =
377 RoundUp(static_cast<Address>(reservation.address()), alignment);
383 Address MemoryAllocator::AllocateAlignedMemory(
388 Address base = ReserveAlignedMemory(reserve_size, alignment, &reservation);
423 NewSpacePage* NewSpacePage::Initialize(Heap* heap, Address start,
425 Address area_start = start + NewSpacePage::kObjectStartOffset;
426 Address area_end = start + Page::kPageSize;
453 MemoryChunk* MemoryChunk::Initialize(Heap* heap, Address base, size_t size,
454 Address area_start, Address area_end,
458 DCHECK(base == chunk->address());
502 size_t header_size = area_start() - address() - guard_size;
512 Address start = address() + committed_size + guard_size;
535 Address start = address() + committed_size + guard_size - length;
579 Address base = NULL;
581 Address area_start = NULL;
582 Address area_end = NULL;
633 // Use code range only for large object space on mips64 to keep address
738 isolate_->heap()->RememberUnmappedPage(reinterpret_cast<Address>(chunk),
769 FreeMemory(chunk->address(), chunk->size(), chunk->executable());
780 bool MemoryAllocator::CommitBlock(Address start, size_t size,
793 bool MemoryAllocator::UncommitBlock(Address start, size_t size) {
800 void MemoryAllocator::ZapBlock(Address start, size_t size) {
893 Address start, size_t commit_size,
896 Address header = start;
902 Address body = start + CodePageAreaStartOffset();
925 MemoryChunk* chunk = MemoryChunk::FromAddress(object->address());
984 void PagedSpace::AddMemory(Address start, intptr_t size) {
1025 current_space->AddMemory(node->address(), node->size());
1074 AddMemory(node->address(), node->size());
1140 bool PagedSpace::ContainsSafe(Address addr) {
1150 Object* PagedSpace::FindObject(Address addr) {
1159 Address cur = obj->address();
1160 Address next = cur + obj->Size();
1284 Address end_of_previous_object = page->area_start();
1285 Address top = page->area_end();
1288 CHECK(end_of_previous_object <= object->address());
1309 CHECK(object->address() + size <= top);
1310 end_of_previous_object = object->address() + size;
1333 Address base = heap()->isolate()->memory_allocator()->ReserveAlignedMemory(
1531 Address old_top = allocation_info_.top();
1547 Address high = to_space_.page_high();
1548 Address new_top = allocation_info_.top() + size_in_bytes;
1556 Address high = to_space_.page_high();
1557 Address new_top = allocation_info_.top() + size_in_bytes;
1558 Address new_limit = new_top + GetNextInlineAllocationStepSize() - 1;
1566 Address top = allocation_info_.top();
1593 Address limit = NewSpacePage::FromLimit(top)->area_end();
1615 Address old_top = allocation_info_.top();
1616 Address high = to_space_.page_high();
1641 Address new_top = old_top + aligned_size_in_bytes;
1642 Address soon_object = old_top + filler_size;
1703 void NewSpace::InlineAllocationStep(Address top, Address new_top,
1704 Address soon_object, size_t size) {
1722 // There should be objects packed in from the low address up to the
1724 Address current = to_space_.first_page()->area_start();
1774 void SemiSpace::SetUp(Address start, int initial_capacity, int target_capacity,
1830 Address start = start_ + maximum_total_capacity_ - total_capacity_;
1878 Address page_address = start_ + i * Page::kPageSize;
1933 // Fixup back-pointers to anchor. Address of anchor changes
1977 // Fixup back-pointers to the page list anchor now that its address
1993 void SemiSpace::set_age_mark(Address mark) {
2041 void SemiSpace::AssertValidRange(Address start, Address end) {
2047 // Start address is before end address, either on same page,
2048 // or end address is on a later page in the linked list of
2070 void SemiSpaceIterator::Initialize(Address start, Address end) {
2297 Page* page_for_node = Page::FromAddress(cur_node->address());
2326 if (Page::FromAddress(node->address()) == p) return true;
2337 Page* page = Page::FromAddress(node->address());
2378 Page* page_for_node = Page::FromAddress(cur_node->address());
2422 Map** map_location = reinterpret_cast<Map**>(n->address());
2479 int FreeList::Free(Address start, int size_in_bytes) {
2518 Page::FromAddress(node->address())
2547 page = Page::FromAddress(node->address());
2557 page = Page::FromAddress(node->address());
2564 page = Page::FromAddress(node->address());
2571 page = Page::FromAddress(node->address());
2604 Free(node->address() + hint_size_in_bytes, static_cast<int>(left_over));
2642 reinterpret_cast<Object**>(new_node->address())[i] =
2661 owner_->Free(new_node->address() + size_in_bytes, bytes_left);
2670 owner_->Free(new_node->address() + size_in_bytes + linear_size,
2672 owner_->SetTopAndLimit(new_node->address() + size_in_bytes,
2673 new_node->address() + size_in_bytes + linear_size);
2677 owner_->SetTopAndLimit(new_node->address() + size_in_bytes,
2678 new_node->address() + new_node_size);
2796 Address address = page->OffsetToAddress(Page::kPageSize - size);
2797 heap()->CreateFillerObjectAt(address, size);
3087 LOG(heap()->isolate(), DeleteEvent("LargeObjectChunk", page->address()));
3131 MSAN_ALLOCATED_UNINITIALIZED_MEMORY(object->address(), object_size);
3136 reinterpret_cast<Object**>(object->address())[0] =
3138 reinterpret_cast<Object**>(object->address())[1] = Smi::FromInt(0);
3159 Object* LargeObjectSpace::FindObject(Address a) {
3168 LargePage* LargeObjectSpace::FindPage(Address a) {
3191 Page::FromAddress(object->address())->ResetProgressBar();
3192 Page::FromAddress(object->address())->ResetLiveBytes();
3244 Address address = object->address();
3245 MemoryChunk* chunk = MemoryChunk::FromAddress(address);
3249 SLOW_DCHECK(!owned || FindObject(address)->IsHeapObject());
3255 bool LargeObjectSpace::Contains(Address address) {
3256 return FindPage(address) != NULL;
3269 Page* page = Page::FromAddress(object->address());
3270 CHECK(object->address() == page->area_start());
3351 PrintF("Page@%p in %s\n", this->address(),
