Lines Matching refs:Address
59 // address and end as NULL, then the first iteration will move on
87 Address cur, Address end,
148 LOG(isolate_, NewEvent("CodeRange", code_range_->address(), requested));
149 Address base = reinterpret_cast<Address>(code_range_->address());
150 Address aligned_base =
151 RoundUp(reinterpret_cast<Address>(code_range_->address()),
211 Address CodeRange::AllocateRawMemory(const size_t requested,
245 void CodeRange::FreeRawMemory(Address address, size_t length) {
246 ASSERT(IsAddressAligned(address, MemoryChunk::kAlignment));
247 free_list_.Add(FreeBlock(address, length));
248 code_range_->Uncommit(address, length);
311 static_cast<Address>(reservation->address())));
317 void MemoryAllocator::FreeMemory(Address base,
330 if (isolate_->code_range()->contains(static_cast<Address>(base))) {
342 Address MemoryAllocator::ReserveAlignedMemory(size_t size,
349 Address base = RoundUp(static_cast<Address>(reservation.address()),
356 Address MemoryAllocator::AllocateAlignedMemory(size_t size,
361 Address base = ReserveAlignedMemory(size, alignment, &reservation);
394 Address start,
396 Address area_start = start + NewSpacePage::kObjectStartOffset;
397 Address area_end = start + Page::kPageSize;
431 Address base,
433 Address area_start,
434 Address area_end,
439 ASSERT(base == chunk->address());
495 Address base = NULL;
497 Address area_start = NULL;
498 Address area_end = NULL;
605 reinterpret_cast<Address>(chunk), chunk->IsEvacuationCandidate());
614 FreeMemory(chunk->address(),
621 bool MemoryAllocator::CommitBlock(Address start,
633 bool MemoryAllocator::UncommitBlock(Address start, size_t size) {
640 void MemoryAllocator::ZapBlock(Address start, size_t size) {
731 Address start,
765 void MemoryChunk::IncrementLiveBytesFromMutator(Address address, int by) {
766 MemoryChunk* chunk = MemoryChunk::FromAddress(address);
823 MaybeObject* PagedSpace::FindObject(Address addr) {
832 Address cur = obj->address();
833 Address next = cur + obj->Size();
969 Address end_of_previous_object = page->area_start();
970 Address top = page->area_end();
973 ASSERT(end_of_previous_object <= object->address());
994 ASSERT(object->address() + size <= top);
995 end_of_previous_object = object->address() + size;
1017 Address base =
1145 Address new_limit =
1166 Address top = allocation_info_.top;
1182 Address limit = NewSpacePage::FromLimit(top)->area_end();
1198 Address old_top = allocation_info_.top;
1199 Address new_top = old_top + size_in_bytes;
1200 Address high = to_space_.page_high();
1232 // There should be objects packed in from the low address up to the
1234 Address current = to_space_.first_page()->area_start();
1284 void SemiSpace::SetUp(Address start,
1315 Address end = start_ + maximum_capacity_;
1316 Address start = end - pages * Page::kPageSize;
1339 Address start = start_ + maximum_capacity_ - capacity_;
1361 Address end = start_ + maximum_capacity_;
1362 Address start = end - new_capacity;
1374 Address page_address = end - i * Page::kPageSize;
1397 Address space_end = start_ + maximum_capacity_;
1398 Address old_start = space_end - capacity_;
1423 // Fixup back-pointers to anchor. Address of anchor changes
1467 // Fixup back-pointers to the page list anchor now that its address
1478 void SemiSpace::set_age_mark(Address mark) {
1524 void SemiSpace::AssertValidRange(Address start, Address end) {
1530 // Start address is before end address, either on same page,
1531 // or end address is on a later page in the linked list of
1558 SemiSpaceIterator::SemiSpaceIterator(NewSpace* space, Address start) {
1563 SemiSpaceIterator::SemiSpaceIterator(Address from, Address to) {
1568 void SemiSpaceIterator::Initialize(Address start,
1569 Address end,
1819 Memory::Address_at(address() + kNextOffset));
1822 Memory::Address_at(address() + kPointerSize));
1831 return reinterpret_cast<FreeListNode**>(address() + kNextOffset);
1833 return reinterpret_cast<FreeListNode**>(address() + kPointerSize);
1845 Memory::Address_at(address() + kNextOffset) =
1846 reinterpret_cast<Address>(next);
1848 Memory::Address_at(address() + kPointerSize) =
1849 reinterpret_cast<Address>(next);
1869 int FreeList::Free(Address start, int size_in_bytes) {
1904 Page::FromAddress(node->address())->IsEvacuationCandidate()) {
1943 Page::FromAddress(cur_node->address())->IsEvacuationCandidate()) {
1996 reinterpret_cast<Object**>(new_node->address())[i] = Smi::FromInt(0);
2021 owner_->Free(new_node->address() + size_in_bytes + linear_size,
2023 owner_->SetTop(new_node->address() + size_in_bytes,
2024 new_node->address() + size_in_bytes + linear_size);
2028 owner_->SetTop(new_node->address() + size_in_bytes,
2029 new_node->address() + new_node_size);
2043 if (Page::FromAddress(n->address()) == p) {
2070 if (Page::FromAddress((*n)->address()) == p) {
2161 Address top = allocation_info_.top;
2162 if ((top - bytes) == allocation->address()) {
2163 allocation_info_.top = allocation->address();
2209 Address current_top = allocation_info_.top;
2210 Address new_top = current_top + size_in_bytes;
2223 SetTop(new_area->address(), new_area->address() + size_in_bytes);
2568 LOG(heap()->isolate(), DeleteEvent("LargeObjectChunk", page->address()));
2619 reinterpret_cast<Object**>(object->address())[0] =
2621 reinterpret_cast<Object**>(object->address())[1] = Smi::FromInt(0);
2630 MaybeObject* LargeObjectSpace::FindObject(Address a) {
2639 LargePage* LargeObjectSpace::FindPage(Address a) {
2667 MemoryChunk::IncrementLiveBytesFromGC(object->address(), -object->Size());
2710 Address address = object->address();
2711 MemoryChunk* chunk = MemoryChunk::FromAddress(address);
2715 SLOW_ASSERT(!owned || !FindObject(address)->IsFailure());
2731 Page* page = Page::FromAddress(object->address());
2732 ASSERT(object->address() == page->area_start());
2810 this->address(),
