CSE2410 Fall 2014 Bounce

// Copyright 2009 the V8 project authors. All rights reserved.

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//     * Redistributions of source code must retain the above copyright

//       notice, this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above

//       copyright notice, this list of conditions and the following

//       disclaimer in the documentation and/or other materials provided

//       with the distribution.

//     * Neither the name of Google Inc. nor the names of its

//       contributors may be used to endorse or promote products derived

//       from this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#include "v8.h"

#include "accessors.h"

#include "api.h"

#include "bootstrapper.h"

#include "codegen-inl.h"

#include "compilation-cache.h"

#include "debug.h"

#include "global-handles.h"

#include "mark-compact.h"

#include "natives.h"

#include "scanner.h"

#include "scopeinfo.h"

#include "v8threads.h"

namespace v8 { namespace internal {

#define ROOT_ALLOCATION(type, name) type* Heap::name##_;

  ROOT_LIST(ROOT_ALLOCATION)

#undef ROOT_ALLOCATION

#define STRUCT_ALLOCATION(NAME, Name, name) Map* Heap::name##_map_;

  STRUCT_LIST(STRUCT_ALLOCATION)

#undef STRUCT_ALLOCATION

#define SYMBOL_ALLOCATION(name, string) String* Heap::name##_;

  SYMBOL_LIST(SYMBOL_ALLOCATION)

#undef SYMBOL_ALLOCATION

String* Heap::hidden_symbol_;

NewSpace Heap::new_space_;

OldSpace* Heap::old_pointer_space_ = NULL;

OldSpace* Heap::old_data_space_ = NULL;

OldSpace* Heap::code_space_ = NULL;

MapSpace* Heap::map_space_ = NULL;

LargeObjectSpace* Heap::lo_space_ = NULL;

static const int kMinimumPromotionLimit = 2*MB;

static const int kMinimumAllocationLimit = 8*MB;

int Heap::old_gen_promotion_limit_ = kMinimumPromotionLimit;

int Heap::old_gen_allocation_limit_ = kMinimumAllocationLimit;

int Heap::old_gen_exhausted_ = false;

int Heap::amount_of_external_allocated_memory_ = 0;

int Heap::amount_of_external_allocated_memory_at_last_global_gc_ = 0;

// semispace_size_ should be a power of 2 and old_generation_size_ should be

// a multiple of Page::kPageSize.

int Heap::semispace_size_  = 2*MB;

int Heap::old_generation_size_ = 512*MB;

int Heap::initial_semispace_size_ = 256*KB;

GCCallback Heap::global_gc_prologue_callback_ = NULL;

GCCallback Heap::global_gc_epilogue_callback_ = NULL;

// Variables set based on semispace_size_ and old_generation_size_ in

// ConfigureHeap.

int Heap::young_generation_size_ = 0;  // Will be 2 * semispace_size_.

// Double the new space after this many scavenge collections.

int Heap::new_space_growth_limit_ = 8;

int Heap::scavenge_count_ = 0;

Heap::HeapState Heap::gc_state_ = NOT_IN_GC;

int Heap::mc_count_ = 0;

int Heap::gc_count_ = 0;

int Heap::always_allocate_scope_depth_ = 0;

bool Heap::context_disposed_pending_ = false;

#ifdef DEBUG

bool Heap::allocation_allowed_ = true;

int Heap::allocation_timeout_ = 0;

bool Heap::disallow_allocation_failure_ = false;

#endif  // DEBUG

int Heap::Capacity() {

  if (!HasBeenSetup()) return 0;

  return new_space_.Capacity() +

      old_pointer_space_->Capacity() +

      old_data_space_->Capacity() +

      code_space_->Capacity() +

      map_space_->Capacity();

}

int Heap::Available() {

  if (!HasBeenSetup()) return 0;

  return new_space_.Available() +

      old_pointer_space_->Available() +

      old_data_space_->Available() +

      code_space_->Available() +

      map_space_->Available();

}

bool Heap::HasBeenSetup() {

  return old_pointer_space_ != NULL &&

         old_data_space_ != NULL &&

         code_space_ != NULL &&

         map_space_ != NULL &&

         lo_space_ != NULL;

}

GarbageCollector Heap::SelectGarbageCollector(AllocationSpace space) {

  // Is global GC requested?

  if (space != NEW_SPACE || FLAG_gc_global) {

    Counters::gc_compactor_caused_by_request.Increment();

    return MARK_COMPACTOR;

  }

  // Is enough data promoted to justify a global GC?

  if (OldGenerationPromotionLimitReached()) {

    Counters::gc_compactor_caused_by_promoted_data.Increment();

    return MARK_COMPACTOR;

  }

  // Have allocation in OLD and LO failed?

  if (old_gen_exhausted_) {

    Counters::gc_compactor_caused_by_oldspace_exhaustion.Increment();

    return MARK_COMPACTOR;

  }

  // Is there enough space left in OLD to guarantee that a scavenge can

  // succeed?

  //

  // Note that MemoryAllocator->MaxAvailable() undercounts the memory available

  // for object promotion. It counts only the bytes that the memory

  // allocator has not yet allocated from the OS and assigned to any space,

  // and does not count available bytes already in the old space or code

  // space.  Undercounting is safe---we may get an unrequested full GC when

  // a scavenge would have succeeded.

  if (MemoryAllocator::MaxAvailable() <= new_space_.Size()) {

    Counters::gc_compactor_caused_by_oldspace_exhaustion.Increment();

    return MARK_COMPACTOR;

  }

  // Default

  return SCAVENGER;

}

// TODO(1238405): Combine the infrastructure for --heap-stats and

// --log-gc to avoid the complicated preprocessor and flag testing.

#if defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)

void Heap::ReportStatisticsBeforeGC() {

  // Heap::ReportHeapStatistics will also log NewSpace statistics when

  // compiled with ENABLE_LOGGING_AND_PROFILING and --log-gc is set.  The

  // following logic is used to avoid double logging.

#if defined(DEBUG) && defined(ENABLE_LOGGING_AND_PROFILING)

  if (FLAG_heap_stats || FLAG_log_gc) new_space_.CollectStatistics();

  if (FLAG_heap_stats) {

    ReportHeapStatistics("Before GC");

  } else if (FLAG_log_gc) {

    new_space_.ReportStatistics();

  }

  if (FLAG_heap_stats || FLAG_log_gc) new_space_.ClearHistograms();

#elif defined(DEBUG)

  if (FLAG_heap_stats) {

    new_space_.CollectStatistics();

    ReportHeapStatistics("Before GC");

    new_space_.ClearHistograms();

  }

#elif defined(ENABLE_LOGGING_AND_PROFILING)

  if (FLAG_log_gc) {

    new_space_.CollectStatistics();

    new_space_.ReportStatistics();

    new_space_.ClearHistograms();

  }

#endif

}

// TODO(1238405): Combine the infrastructure for --heap-stats and

// --log-gc to avoid the complicated preprocessor and flag testing.

void Heap::ReportStatisticsAfterGC() {

  // Similar to the before GC, we use some complicated logic to ensure that

  // NewSpace statistics are logged exactly once when --log-gc is turned on.

#if defined(DEBUG) && defined(ENABLE_LOGGING_AND_PROFILING)

  if (FLAG_heap_stats) {

    ReportHeapStatistics("After GC");

  } else if (FLAG_log_gc) {

    new_space_.ReportStatistics();

  }

#elif defined(DEBUG)

  if (FLAG_heap_stats) ReportHeapStatistics("After GC");

#elif defined(ENABLE_LOGGING_AND_PROFILING)

  if (FLAG_log_gc) new_space_.ReportStatistics();

#endif

}

#endif  // defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)

void Heap::GarbageCollectionPrologue() {

  gc_count_++;

#ifdef DEBUG

  ASSERT(allocation_allowed_ && gc_state_ == NOT_IN_GC);

  allow_allocation(false);

  if (FLAG_verify_heap) {

    Verify();

  }

  if (FLAG_gc_verbose) Print();

  if (FLAG_print_rset) {

    // Not all spaces have remembered set bits that we care about.

    old_pointer_space_->PrintRSet();

    map_space_->PrintRSet();

    lo_space_->PrintRSet();

  }

#endif

#if defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)

  ReportStatisticsBeforeGC();

#endif

}

int Heap::SizeOfObjects() {

  int total = 0;

  AllSpaces spaces;

  while (Space* space = spaces.next()) total += space->Size();

  return total;

}

void Heap::GarbageCollectionEpilogue() {

#ifdef DEBUG

  allow_allocation(true);

  ZapFromSpace();

  if (FLAG_verify_heap) {

    Verify();

  }

  if (FLAG_print_global_handles) GlobalHandles::Print();

  if (FLAG_print_handles) PrintHandles();

  if (FLAG_gc_verbose) Print();

  if (FLAG_code_stats) ReportCodeStatistics("After GC");

#endif

  Counters::alive_after_last_gc.Set(SizeOfObjects());

  SymbolTable* symbol_table = SymbolTable::cast(Heap::symbol_table_);

  Counters::symbol_table_capacity.Set(symbol_table->Capacity());

  Counters::number_of_symbols.Set(symbol_table->NumberOfElements());

#if defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)

  ReportStatisticsAfterGC();

#endif

}

void Heap::CollectAllGarbage() {

  // Since we are ignoring the return value, the exact choice of space does

  // not matter, so long as we do not specify NEW_SPACE, which would not

  // cause a full GC.

  CollectGarbage(0, OLD_POINTER_SPACE);

}

void Heap::CollectAllGarbageIfContextDisposed() {

  // If the garbage collector interface is exposed through the global

  // gc() function, we avoid being clever about forcing GCs when

  // contexts are disposed and leave it to the embedder to make

  // informed decisions about when to force a collection.

  if (!FLAG_expose_gc && context_disposed_pending_) {

    HistogramTimerScope scope(&Counters::gc_context);

    CollectAllGarbage();

  }

  context_disposed_pending_ = false;

}

void Heap::NotifyContextDisposed() {

  context_disposed_pending_ = true;

}

bool Heap::CollectGarbage(int requested_size, AllocationSpace space) {

  // The VM is in the GC state until exiting this function.

  VMState state(GC);

#ifdef DEBUG

  // Reset the allocation timeout to the GC interval, but make sure to

  // allow at least a few allocations after a collection. The reason

  // for this is that we have a lot of allocation sequences and we

  // assume that a garbage collection will allow the subsequent

  // allocation attempts to go through.

  allocation_timeout_ = Max(6, FLAG_gc_interval);

#endif

  { GCTracer tracer;

    GarbageCollectionPrologue();

    // The GC count was incremented in the prologue.  Tell the tracer about

    // it.

    tracer.set_gc_count(gc_count_);

    GarbageCollector collector = SelectGarbageCollector(space);

    // Tell the tracer which collector we've selected.

    tracer.set_collector(collector);

    HistogramTimer* rate = (collector == SCAVENGER)

        ? &Counters::gc_scavenger

        : &Counters::gc_compactor;

    rate->Start();

    PerformGarbageCollection(space, collector, &tracer);

    rate->Stop();

    GarbageCollectionEpilogue();

  }

#ifdef ENABLE_LOGGING_AND_PROFILING

  if (FLAG_log_gc) HeapProfiler::WriteSample();

#endif

  switch (space) {

    case NEW_SPACE:

      return new_space_.Available() >= requested_size;

    case OLD_POINTER_SPACE:

      return old_pointer_space_->Available() >= requested_size;

    case OLD_DATA_SPACE:

      return old_data_space_->Available() >= requested_size;

    case CODE_SPACE:

      return code_space_->Available() >= requested_size;

    case MAP_SPACE:

      return map_space_->Available() >= requested_size;

    case LO_SPACE:

      return lo_space_->Available() >= requested_size;

  }

  return false;

}

void Heap::PerformScavenge() {

  GCTracer tracer;

  PerformGarbageCollection(NEW_SPACE, SCAVENGER, &tracer);

}

#ifdef DEBUG

// Helper class for verifying the symbol table.

class SymbolTableVerifier : public ObjectVisitor {

 public:

  SymbolTableVerifier() { }

  void VisitPointers(Object** start, Object** end) {

    // Visit all HeapObject pointers in [start, end).

    for (Object** p = start; p < end; p++) {

      if ((*p)->IsHeapObject()) {

        // Check that the symbol is actually a symbol.

        ASSERT((*p)->IsNull() || (*p)->IsUndefined() || (*p)->IsSymbol());

      }

    }

  }

};

#endif  // DEBUG

static void VerifySymbolTable() {

#ifdef DEBUG

  SymbolTableVerifier verifier;

  SymbolTable* symbol_table = SymbolTable::cast(Heap::symbol_table());

  symbol_table->IterateElements(&verifier);

#endif  // DEBUG

}

void Heap::PerformGarbageCollection(AllocationSpace space,

                                    GarbageCollector collector,

                                    GCTracer* tracer) {

  VerifySymbolTable();

  if (collector == MARK_COMPACTOR && global_gc_prologue_callback_) {

    ASSERT(!allocation_allowed_);

    global_gc_prologue_callback_();

  }

  if (collector == MARK_COMPACTOR) {

    MarkCompact(tracer);

    int old_gen_size = PromotedSpaceSize();

    old_gen_promotion_limit_ =

        old_gen_size + Max(kMinimumPromotionLimit, old_gen_size / 3);

    old_gen_allocation_limit_ =

        old_gen_size + Max(kMinimumAllocationLimit, old_gen_size / 3);

    old_gen_exhausted_ = false;

    // If we have used the mark-compact collector to collect the new

    // space, and it has not compacted the new space, we force a

    // separate scavenge collection.  This is a hack.  It covers the

    // case where (1) a new space collection was requested, (2) the

    // collector selection policy selected the mark-compact collector,

    // and (3) the mark-compact collector policy selected not to

    // compact the new space.  In that case, there is no more (usable)

    // free space in the new space after the collection compared to

    // before.

    if (space == NEW_SPACE && !MarkCompactCollector::HasCompacted()) {

      Scavenge();

    }

  } else {

    Scavenge();

  }

  Counters::objs_since_last_young.Set(0);

  PostGarbageCollectionProcessing();

  if (collector == MARK_COMPACTOR) {

    // Register the amount of external allocated memory.

    amount_of_external_allocated_memory_at_last_global_gc_ =

        amount_of_external_allocated_memory_;

  }

  if (collector == MARK_COMPACTOR && global_gc_epilogue_callback_) {

    ASSERT(!allocation_allowed_);

    global_gc_epilogue_callback_();

  }

  VerifySymbolTable();

}

void Heap::PostGarbageCollectionProcessing() {

  // Process weak handles post gc.

  GlobalHandles::PostGarbageCollectionProcessing();

  // Update flat string readers.

  FlatStringReader::PostGarbageCollectionProcessing();

}

void Heap::MarkCompact(GCTracer* tracer) {

  gc_state_ = MARK_COMPACT;

  mc_count_++;

  tracer->set_full_gc_count(mc_count_);

  LOG(ResourceEvent("markcompact", "begin"));

  MarkCompactCollector::Prepare(tracer);

  bool is_compacting = MarkCompactCollector::IsCompacting();

  MarkCompactPrologue(is_compacting);

  MarkCompactCollector::CollectGarbage();

  MarkCompactEpilogue(is_compacting);

  LOG(ResourceEvent("markcompact", "end"));

  gc_state_ = NOT_IN_GC;

  Shrink();

  Counters::objs_since_last_full.Set(0);

  context_disposed_pending_ = false;

}

void Heap::MarkCompactPrologue(bool is_compacting) {

  // At any old GC clear the keyed lookup cache to enable collection of unused

  // maps.

  ClearKeyedLookupCache();

  CompilationCache::MarkCompactPrologue();

  Top::MarkCompactPrologue(is_compacting);

  ThreadManager::MarkCompactPrologue(is_compacting);

}

void Heap::MarkCompactEpilogue(bool is_compacting) {

  Top::MarkCompactEpilogue(is_compacting);

  ThreadManager::MarkCompactEpilogue(is_compacting);

}

Object* Heap::FindCodeObject(Address a) {

  Object* obj = code_space_->FindObject(a);

  if (obj->IsFailure()) {

    obj = lo_space_->FindObject(a);

  }

  ASSERT(!obj->IsFailure());

  return obj;

}

// Helper class for copying HeapObjects

class ScavengeVisitor: public ObjectVisitor {

 public:

  void VisitPointer(Object** p) { ScavengePointer(p); }

  void VisitPointers(Object** start, Object** end) {

    // Copy all HeapObject pointers in [start, end)

    for (Object** p = start; p < end; p++) ScavengePointer(p);

  }

 private:

  void ScavengePointer(Object** p) {

    Object* object = *p;

    if (!Heap::InNewSpace(object)) return;

    Heap::ScavengeObject(reinterpret_cast<HeapObject**>(p),

                         reinterpret_cast<HeapObject*>(object));

  }

};

// Shared state read by the scavenge collector and set by ScavengeObject.

static Address promoted_top = NULL;

#ifdef DEBUG

// Visitor class to verify pointers in code or data space do not point into

// new space.

class VerifyNonPointerSpacePointersVisitor: public ObjectVisitor {

 public:

  void VisitPointers(Object** start, Object**end) {

    for (Object** current = start; current < end; current++) {

      if ((*current)->IsHeapObject()) {

        ASSERT(!Heap::InNewSpace(HeapObject::cast(*current)));

      }

    }

  }

};

#endif

void Heap::Scavenge() {

#ifdef DEBUG

  if (FLAG_enable_slow_asserts) {

    VerifyNonPointerSpacePointersVisitor v;

    HeapObjectIterator it(code_space_);

    while (it.has_next()) {

      HeapObject* object = it.next();

      if (object->IsCode()) {

        Code::cast(object)->ConvertICTargetsFromAddressToObject();

      }

      object->Iterate(&v);

      if (object->IsCode()) {

        Code::cast(object)->ConvertICTargetsFromObjectToAddress();

      }

    }

  }

#endif

  gc_state_ = SCAVENGE;

  // Implements Cheney's copying algorithm

  LOG(ResourceEvent("scavenge", "begin"));

  scavenge_count_++;

  if (new_space_.Capacity() < new_space_.MaximumCapacity() &&

      scavenge_count_ > new_space_growth_limit_) {

    // Double the size of the new space, and double the limit.  The next

    // doubling attempt will occur after the current new_space_growth_limit_

    // more collections.

    // TODO(1240712): NewSpace::Double has a return value which is

    // ignored here.

    new_space_.Double();

    new_space_growth_limit_ *= 2;

  }

  // Flip the semispaces.  After flipping, to space is empty, from space has

  // live objects.

  new_space_.Flip();

  new_space_.ResetAllocationInfo();

  // We need to sweep newly copied objects which can be in either the to space

  // or the old space.  For to space objects, we use a mark.  Newly copied

  // objects lie between the mark and the allocation top.  For objects

  // promoted to old space, we write their addresses downward from the top of

  // the new space.  Sweeping newly promoted objects requires an allocation

  // pointer and a mark.  Note that the allocation pointer 'top' actually

  // moves downward from the high address in the to space.

  //

  // There is guaranteed to be enough room at the top of the to space for the

  // addresses of promoted objects: every object promoted frees up its size in

  // bytes from the top of the new space, and objects are at least one pointer

  // in size.  Using the new space to record promoted addresses makes the

  // scavenge collector agnostic to the allocation strategy (eg, linear or

  // free-list) used in old space.

  Address new_mark = new_space_.ToSpaceLow();

  Address promoted_mark = new_space_.ToSpaceHigh();

  promoted_top = new_space_.ToSpaceHigh();

  ScavengeVisitor scavenge_visitor;

  // Copy roots.

  IterateRoots(&scavenge_visitor);

  // Copy objects reachable from the old generation.  By definition, there

  // are no intergenerational pointers in code or data spaces.

  IterateRSet(old_pointer_space_, &ScavengePointer);

  IterateRSet(map_space_, &ScavengePointer);

  lo_space_->IterateRSet(&ScavengePointer);

  bool has_processed_weak_pointers = false;

  while (true) {

    ASSERT(new_mark <= new_space_.top());

    ASSERT(promoted_mark >= promoted_top);

    // Copy objects reachable from newly copied objects.

    while (new_mark < new_space_.top() || promoted_mark > promoted_top) {

      // Sweep newly copied objects in the to space.  The allocation pointer

      // can change during sweeping.

      Address previous_top = new_space_.top();

      SemiSpaceIterator new_it(new_space(), new_mark);

      while (new_it.has_next()) {

        new_it.next()->Iterate(&scavenge_visitor);

      }

      new_mark = previous_top;

      // Sweep newly copied objects in the old space.  The promotion 'top'

      // pointer could change during sweeping.

      previous_top = promoted_top;

      for (Address current = promoted_mark - kPointerSize;

           current >= previous_top;

           current -= kPointerSize) {

        HeapObject* object = HeapObject::cast(Memory::Object_at(current));

        object->Iterate(&scavenge_visitor);

        UpdateRSet(object);

      }

      promoted_mark = previous_top;

    }

    if (has_processed_weak_pointers) break;  // We are done.

    // Copy objects reachable from weak pointers.

    GlobalHandles::IterateWeakRoots(&scavenge_visitor);

    has_processed_weak_pointers = true;

  }

  // Set age mark.

  new_space_.set_age_mark(new_mark);

  LOG(ResourceEvent("scavenge", "end"));

  gc_state_ = NOT_IN_GC;

}

void Heap::ClearRSetRange(Address start, int size_in_bytes) {

  uint32_t start_bit;

  Address start_word_address =

      Page::ComputeRSetBitPosition(start, 0, &start_bit);

  uint32_t end_bit;

  Address end_word_address =

      Page::ComputeRSetBitPosition(start + size_in_bytes - kIntSize,

                                   0,

                                   &end_bit);

  // We want to clear the bits in the starting word starting with the

  // first bit, and in the ending word up to and including the last

  // bit.  Build a pair of bitmasks to do that.

  uint32_t start_bitmask = start_bit - 1;

  uint32_t end_bitmask = ~((end_bit << 1) - 1);

  // If the start address and end address are the same, we mask that

  // word once, otherwise mask the starting and ending word

  // separately and all the ones in between.

  if (start_word_address == end_word_address) {

    Memory::uint32_at(start_word_address) &= (start_bitmask | end_bitmask);

  } else {

    Memory::uint32_at(start_word_address) &= start_bitmask;

    Memory::uint32_at(end_word_address) &= end_bitmask;

    start_word_address += kIntSize;

    memset(start_word_address, 0, end_word_address - start_word_address);

  }

}

class UpdateRSetVisitor: public ObjectVisitor {

 public:

  void VisitPointer(Object** p) {

    UpdateRSet(p);

  }

  void VisitPointers(Object** start, Object** end) {

    // Update a store into slots [start, end), used (a) to update remembered

    // set when promoting a young object to old space or (b) to rebuild

    // remembered sets after a mark-compact collection.

    for (Object** p = start; p < end; p++) UpdateRSet(p);

  }

 private:

  void UpdateRSet(Object** p) {

    // The remembered set should not be set.  It should be clear for objects

    // newly copied to old space, and it is cleared before rebuilding in the

    // mark-compact collector.

    ASSERT(!Page::IsRSetSet(reinterpret_cast<Address>(p), 0));

    if (Heap::InNewSpace(*p)) {

      Page::SetRSet(reinterpret_cast<Address>(p), 0);

    }

  }

};

int Heap::UpdateRSet(HeapObject* obj) {

  ASSERT(!InNewSpace(obj));

  // Special handling of fixed arrays to iterate the body based on the start

  // address and offset.  Just iterating the pointers as in UpdateRSetVisitor

  // will not work because Page::SetRSet needs to have the start of the

  // object.

  if (obj->IsFixedArray()) {

    FixedArray* array = FixedArray::cast(obj);

    int length = array->length();

    for (int i = 0; i < length; i++) {

      int offset = FixedArray::kHeaderSize + i * kPointerSize;

      ASSERT(!Page::IsRSetSet(obj->address(), offset));

      if (Heap::InNewSpace(array->get(i))) {

        Page::SetRSet(obj->address(), offset);

      }

    }

  } else if (!obj->IsCode()) {

    // Skip code object, we know it does not contain inter-generational

    // pointers.

    UpdateRSetVisitor v;

    obj->Iterate(&v);

  }

  return obj->Size();

}

void Heap::RebuildRSets() {

  // By definition, we do not care about remembered set bits in code or data

  // spaces.

  map_space_->ClearRSet();

  RebuildRSets(map_space_);

  old_pointer_space_->ClearRSet();

  RebuildRSets(old_pointer_space_);

  Heap::lo_space_->ClearRSet();

  RebuildRSets(lo_space_);

}

void Heap::RebuildRSets(PagedSpace* space) {

  HeapObjectIterator it(space);

  while (it.has_next()) Heap::UpdateRSet(it.next());

}

void Heap::RebuildRSets(LargeObjectSpace* space) {

  LargeObjectIterator it(space);

  while (it.has_next()) Heap::UpdateRSet(it.next());

}

#if defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)

void Heap::RecordCopiedObject(HeapObject* obj) {

  bool should_record = false;

#ifdef DEBUG

  should_record = FLAG_heap_stats;

#endif

#ifdef ENABLE_LOGGING_AND_PROFILING

  should_record = should_record || FLAG_log_gc;

#endif

  if (should_record) {

    if (new_space_.Contains(obj)) {

      new_space_.RecordAllocation(obj);

    } else {

      new_space_.RecordPromotion(obj);

    }

  }

}

#endif  // defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)

HeapObject* Heap::MigrateObject(HeapObject* source,

                                HeapObject* target,

                                int size) {

  // Copy the content of source to target.

  CopyBlock(reinterpret_cast<Object**>(target->address()),

            reinterpret_cast<Object**>(source->address()),

            size);

  // Set the forwarding address.

  source->set_map_word(MapWord::FromForwardingAddress(target));

  // Update NewSpace stats if necessary.

#if defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)

  RecordCopiedObject(target);

#endif

  return target;

}

// Inlined function.

void Heap::ScavengeObject(HeapObject** p, HeapObject* object) {

  ASSERT(InFromSpace(object));

  // We use the first word (where the map pointer usually is) of a heap

  // object to record the forwarding pointer.  A forwarding pointer can

  // point to an old space, the code space, or the to space of the new

  // generation.

  MapWord first_word = object->map_word();

  // If the first word is a forwarding address, the object has already been

  // copied.

  if (first_word.IsForwardingAddress()) {

    *p = first_word.ToForwardingAddress();

    return;

  }

  // Call the slow part of scavenge object.

  return ScavengeObjectSlow(p, object);

}

static inline bool IsShortcutCandidate(HeapObject* object, Map* map) {

  STATIC_ASSERT(kNotStringTag != 0 && kSymbolTag != 0);

  ASSERT(object->map() == map);

  InstanceType type = map->instance_type();

  if ((type & kShortcutTypeMask) != kShortcutTypeTag) return false;

  ASSERT(object->IsString() && !object->IsSymbol());

  return ConsString::cast(object)->unchecked_second() == Heap::empty_string();

}

void Heap::ScavengeObjectSlow(HeapObject** p, HeapObject* object) {

  ASSERT(InFromSpace(object));

  MapWord first_word = object->map_word();

  ASSERT(!first_word.IsForwardingAddress());

  // Optimization: Bypass flattened ConsString objects.

  if (IsShortcutCandidate(object, first_word.ToMap())) {

    object = HeapObject::cast(ConsString::cast(object)->unchecked_first());

    *p = object;

    // After patching *p we have to repeat the checks that object is in the

    // active semispace of the young generation and not already copied.

    if (!InNewSpace(object)) return;

    first_word = object->map_word();

    if (first_word.IsForwardingAddress()) {

      *p = first_word.ToForwardingAddress();

      return;

    }

  }

  int object_size = object->SizeFromMap(first_word.ToMap());

  // If the object should be promoted, we try to copy it to old space.

  if (ShouldBePromoted(object->address(), object_size)) {

    OldSpace* target_space = Heap::TargetSpace(object);

    ASSERT(target_space == Heap::old_pointer_space_ ||

           target_space == Heap::old_data_space_);

    Object* result = target_space->AllocateRaw(object_size);

    if (!result->IsFailure()) {

      *p = MigrateObject(object, HeapObject::cast(result), object_size);

      if (target_space == Heap::old_pointer_space_) {

        // Record the object's address at the top of the to space, to allow

        // it to be swept by the scavenger.

        promoted_top -= kPointerSize;

        Memory::Object_at(promoted_top) = *p;

      } else {

#ifdef DEBUG

        // Objects promoted to the data space should not have pointers to

        // new space.

        VerifyNonPointerSpacePointersVisitor v;

        (*p)->Iterate(&v);

#endif

      }

      return;

    }

  }

  // The object should remain in new space or the old space allocation failed.

  Object* result = new_space_.AllocateRaw(object_size);

  // Failed allocation at this point is utterly unexpected.

  ASSERT(!result->IsFailure());

  *p = MigrateObject(object, HeapObject::cast(result), object_size);

}

void Heap::ScavengePointer(HeapObject** p) {

  ScavengeObject(p, *p);

}

Object* Heap::AllocatePartialMap(InstanceType instance_type,

                                 int instance_size) {

  Object* result = AllocateRawMap(Map::kSize);

  if (result->IsFailure()) return result;

  // Map::cast cannot be used due to uninitialized map field.

  reinterpret_cast<Map*>(result)->set_map(meta_map());

  reinterpret_cast<Map*>(result)->set_instance_type(instance_type);

  reinterpret_cast<Map*>(result)->set_instance_size(instance_size);

  reinterpret_cast<Map*>(result)->set_inobject_properties(0);

  reinterpret_cast<Map*>(result)->set_unused_property_fields(0);

  return result;

}

Object* Heap::AllocateMap(InstanceType instance_type, int instance_size) {

  Object* result = AllocateRawMap(Map::kSize);

  if (result->IsFailure()) return result;

  Map* map = reinterpret_cast<Map*>(result);

  map->set_map(meta_map());

  map->set_instance_type(instance_type);

  map->set_prototype(null_value());

  map->set_constructor(null_value());

  map->set_instance_size(instance_size);

  map->set_inobject_properties(0);

  map->set_instance_descriptors(empty_descriptor_array());

  map->set_code_cache(empty_fixed_array());

  map->set_unused_property_fields(0);

  map->set_bit_field(0);

  return map;

}

bool Heap::CreateInitialMaps() {

  Object* obj = AllocatePartialMap(MAP_TYPE, Map::kSize);

  if (obj->IsFailure()) return false;

  // Map::cast cannot be used due to uninitialized map field.

  meta_map_ = reinterpret_cast<Map*>(obj);

  meta_map()->set_map(meta_map());

  obj = AllocatePartialMap(FIXED_ARRAY_TYPE, Array::kHeaderSize);

  if (obj->IsFailure()) return false;

  fixed_array_map_ = Map::cast(obj);

  obj = AllocatePartialMap(ODDBALL_TYPE, Oddball::kSize);

  if (obj->IsFailure()) return false;

  oddball_map_ = Map::cast(obj);

  // Allocate the empty array

  obj = AllocateEmptyFixedArray();

  if (obj->IsFailure()) return false;

  empty_fixed_array_ = FixedArray::cast(obj);

  obj = Allocate(oddball_map(), OLD_DATA_SPACE);

  if (obj->IsFailure()) return false;

  null_value_ = obj;

  // Allocate the empty descriptor array.  AllocateMap can now be used.

  obj = AllocateEmptyFixedArray();

  if (obj->IsFailure()) return false;

  // There is a check against empty_descriptor_array() in cast().

  empty_descriptor_array_ = reinterpret_cast<DescriptorArray*>(obj);

  // Fix the instance_descriptors for the existing maps.

  meta_map()->set_instance_descriptors(empty_descriptor_array());

  meta_map()->set_code_cache(empty_fixed_array());

  fixed_array_map()->set_instance_descriptors(empty_descriptor_array());

  fixed_array_map()->set_code_cache(empty_fixed_array());

  oddball_map()->set_instance_descriptors(empty_descriptor_array());

  oddball_map()->set_code_cache(empty_fixed_array());

  // Fix prototype object for existing maps.

  meta_map()->set_prototype(null_value());

  meta_map()->set_constructor(null_value());

  fixed_array_map()->set_prototype(null_value());

  fixed_array_map()->set_constructor(null_value());

  oddball_map()->set_prototype(null_value());

  oddball_map()->set_constructor(null_value());

  obj = AllocateMap(HEAP_NUMBER_TYPE, HeapNumber::kSize);

  if (obj->IsFailure()) return false;

  heap_number_map_ = Map::cast(obj);

  obj = AllocateMap(PROXY_TYPE, Proxy::kSize);

  if (obj->IsFailure()) return false;

  proxy_map_ = Map::cast(obj);

#define ALLOCATE_STRING_MAP(type, size, name)   \

    obj = AllocateMap(type, size);              \

    if (obj->IsFailure()) return false;         \

    name##_map_ = Map::cast(obj);

  STRING_TYPE_LIST(ALLOCATE_STRING_MAP);

#undef ALLOCATE_STRING_MAP

  obj = AllocateMap(SHORT_STRING_TYPE, SeqTwoByteString::kHeaderSize);

  if (obj->IsFailure()) return false;

  undetectable_short_string_map_ = Map::cast(obj);

  undetectable_short_string_map_->set_is_undetectable();

  obj = AllocateMap(MEDIUM_STRING_TYPE, SeqTwoByteString::kHeaderSize);

  if (obj->IsFailure()) return false;

  undetectable_medium_string_map_ = Map::cast(obj);

  undetectable_medium_string_map_->set_is_undetectable();

  obj = AllocateMap(LONG_STRING_TYPE, SeqTwoByteString::kHeaderSize);

  if (obj->IsFailure()) return false;

  undetectable_long_string_map_ = Map::cast(obj);

  undetectable_long_string_map_->set_is_undetectable();

  obj = AllocateMap(SHORT_ASCII_STRING_TYPE, SeqAsciiString::kHeaderSize);

  if (obj->IsFailure()) return false;

  undetectable_short_ascii_string_map_ = Map::cast(obj);

  undetectable_short_ascii_string_map_->set_is_undetectable();

  obj = AllocateMap(MEDIUM_ASCII_STRING_TYPE, SeqAsciiString::kHeaderSize);

  if (obj->IsFailure()) return false;

  undetectable_medium_ascii_string_map_ = Map::cast(obj);

  undetectable_medium_ascii_string_map_->set_is_undetectable();

  obj = AllocateMap(LONG_ASCII_STRING_TYPE, SeqAsciiString::kHeaderSize);

  if (obj->IsFailure()) return false;

  undetectable_long_ascii_string_map_ = Map::cast(obj);

  undetectable_long_ascii_string_map_->set_is_undetectable();

  obj = AllocateMap(BYTE_ARRAY_TYPE, Array::kHeaderSize);

  if (obj->IsFailure()) return false;

  byte_array_map_ = Map::cast(obj);

  obj = AllocateMap(CODE_TYPE, Code::kHeaderSize);

  if (obj->IsFailure()) return false;

  code_map_ = Map::cast(obj);

  obj = AllocateMap(FILLER_TYPE, kPointerSize);

  if (obj->IsFailure()) return false;

  one_word_filler_map_ = Map::cast(obj);

  obj = AllocateMap(FILLER_TYPE, 2 * kPointerSize);

  if (obj->IsFailure()) return false;

  two_word_filler_map_ = Map::cast(obj);

#define ALLOCATE_STRUCT_MAP(NAME, Name, name)      \

  obj = AllocateMap(NAME##_TYPE, Name::kSize);     \

  if (obj->IsFailure()) return false;              \

  name##_map_ = Map::cast(obj);

  STRUCT_LIST(ALLOCATE_STRUCT_MAP)

#undef ALLOCATE_STRUCT_MAP

  obj = AllocateMap(FIXED_ARRAY_TYPE, HeapObject::kHeaderSize);

  if (obj->IsFailure()) return false;

  hash_table_map_ = Map::cast(obj);

  obj = AllocateMap(FIXED_ARRAY_TYPE, HeapObject::kHeaderSize);

  if (obj->IsFailure()) return false;

  context_map_ = Map::cast(obj);

  obj = AllocateMap(FIXED_ARRAY_TYPE, HeapObject::kHeaderSize);

  if (obj->IsFailure()) return false;

  catch_context_map_ = Map::cast(obj);

  obj = AllocateMap(FIXED_ARRAY_TYPE, HeapObject::kHeaderSize);

  if (obj->IsFailure()) return false;

  global_context_map_ = Map::cast(obj);

  obj = AllocateMap(JS_FUNCTION_TYPE, JSFunction::kSize);

  if (obj->IsFailure()) return false;

  boilerplate_function_map_ = Map::cast(obj);

  obj = AllocateMap(SHARED_FUNCTION_INFO_TYPE, SharedFunctionInfo::kSize);

  if (obj->IsFailure()) return false;

  shared_function_info_map_ = Map::cast(obj);

  ASSERT(!Heap::InNewSpace(Heap::empty_fixed_array()));

  return true;

}

Object* Heap::AllocateHeapNumber(double value, PretenureFlag pretenure) {

  // Statically ensure that it is safe to allocate heap numbers in paged

  // spaces.

  STATIC_ASSERT(HeapNumber::kSize <= Page::kMaxHeapObjectSize);

  AllocationSpace space = (pretenure == TENURED) ? OLD_DATA_SPACE : NEW_SPACE;

  Object* result = AllocateRaw(HeapNumber::kSize, space, OLD_DATA_SPACE);

  if (result->IsFailure()) return result;

  HeapObject::cast(result)->set_map(heap_number_map());

  HeapNumber::cast(result)->set_value(value);

  return result;

}

Object* Heap::AllocateHeapNumber(double value) {

  // Use general version, if we're forced to always allocate.

  if (always_allocate()) return AllocateHeapNumber(value, NOT_TENURED);

  // This version of AllocateHeapNumber is optimized for

  // allocation in new space.

  STATIC_ASSERT(HeapNumber::kSize <= Page::kMaxHeapObjectSize);

  ASSERT(allocation_allowed_ && gc_state_ == NOT_IN_GC);

  Object* result = new_space_.AllocateRaw(HeapNumber::kSize);

  if (result->IsFailure()) return result;

  HeapObject::cast(result)->set_map(heap_number_map());

  HeapNumber::cast(result)->set_value(value);

  return result;

}

Object* Heap::CreateOddball(Map* map,

                            const char* to_string,

                            Object* to_number) {

  Object* result = Allocate(map, OLD_DATA_SPACE);

  if (result->IsFailure()) return result;

  return Oddball::cast(result)->Initialize(to_string, to_number);

}

bool Heap::CreateApiObjects() {

  Object* obj;

  obj = AllocateMap(JS_OBJECT_TYPE, JSObject::kHeaderSize);

  if (obj->IsFailure()) return false;

  neander_map_ = Map::cast(obj);

  obj = Heap::AllocateJSObjectFromMap(neander_map_);

  if (obj->IsFailure()) return false;

  Object* elements = AllocateFixedArray(2);

  if (elements->IsFailure()) return false;

  FixedArray::cast(elements)->set(0, Smi::FromInt(0));

  JSObject::cast(obj)->set_elements(FixedArray::cast(elements));

  message_listeners_ = JSObject::cast(obj);

  return true;

}

void Heap::CreateFixedStubs() {

  // Here we create roots for fixed stubs. They are needed at GC

  // for cooking and uncooking (check out frames.cc).

  // The eliminates the need for doing dictionary lookup in the

  // stub cache for these stubs.

  HandleScope scope;

  {

    CEntryStub stub;

    c_entry_code_ = *stub.GetCode();

  }

  {

    CEntryDebugBreakStub stub;

    c_entry_debug_break_code_ = *stub.GetCode();

  }

  {

    JSEntryStub stub;

    js_entry_code_ = *stub.GetCode();

  }

  {

    JSConstructEntryStub stub;

    js_construct_entry_code_ = *stub.GetCode();

  }

}

bool Heap::CreateInitialObjects() {

  Object* obj;

  // The -0 value must be set before NumberFromDouble works.

  obj = AllocateHeapNumber(-0.0, TENURED);

  if (obj->IsFailure()) return false;

  minus_zero_value_ = obj;

  ASSERT(signbit(minus_zero_value_->Number()) != 0);

  obj = AllocateHeapNumber(OS::nan_value(), TENURED);

  if (obj->IsFailure()) return false;

  nan_value_ = obj;

  obj = Allocate(oddball_map(), OLD_DATA_SPACE);

  if (obj->IsFailure()) return false;

  undefined_value_ = obj;

  ASSERT(!InNewSpace(undefined_value()));

  // Allocate initial symbol table.

  obj = SymbolTable::Allocate(kInitialSymbolTableSize);

  if (obj->IsFailure()) return false;

  symbol_table_ = obj;

  // Assign the print strings for oddballs after creating symboltable.

  Object* symbol = LookupAsciiSymbol("undefined");

  if (symbol->IsFailure()) return false;

  Oddball::cast(undefined_value_)->set_to_string(String::cast(symbol));

  Oddball::cast(undefined_value_)->set_to_number(nan_value_);

  // Assign the print strings for oddballs after creating symboltable.

  symbol = LookupAsciiSymbol("null");

  if (symbol->IsFailure()) return false;

  Oddball::cast(null_value_)->set_to_string(String::cast(symbol));

  Oddball::cast(null_value_)->set_to_number(Smi::FromInt(0));

  // Allocate the null_value

  obj = Oddball::cast(null_value())->Initialize("null", Smi::FromInt(0));

  if (obj->IsFailure()) return false;

  obj = CreateOddball(oddball_map(), "true", Smi::FromInt(1));

  if (obj->IsFailure()) return false;

  true_value_ = obj;

  obj = CreateOddball(oddball_map(), "false", Smi::FromInt(0));

  if (obj->IsFailure()) return false;

  false_value_ = obj;

  obj = CreateOddball(oddball_map(), "hole", Smi::FromInt(-1));

  if (obj->IsFailure()) return false;

  the_hole_value_ = obj;

  // Allocate the empty string.

  obj = AllocateRawAsciiString(0, TENURED);

  if (obj->IsFailure()) return false;

  empty_string_ = String::cast(obj);

#define SYMBOL_INITIALIZE(name, string)                 \

  obj = LookupAsciiSymbol(string);                      \

  if (obj->IsFailure()) return false;                   \

  (name##_) = String::cast(obj);

  SYMBOL_LIST(SYMBOL_INITIALIZE)

#undef SYMBOL_INITIALIZE

  // Allocate the hidden symbol which is used to identify the hidden properties

  // in JSObjects. The hash code has a special value so that it will not match

  // the empty string when searching for the property. It cannot be part of the

  // SYMBOL_LIST because it needs to be allocated manually with the special

  // hash code in place. The hash code for the hidden_symbol is zero to ensure

  // that it will always be at the first entry in property descriptors.

  obj = AllocateSymbol(CStrVector(""), 0, String::kHashComputedMask);

  if (obj->IsFailure()) return false;

  hidden_symbol_ = String::cast(obj);

  // Allocate the proxy for __proto__.

  obj = AllocateProxy((Address) &Accessors::ObjectPrototype);

  if (obj->IsFailure()) return false;

  prototype_accessors_ = Proxy::cast(obj);

  // Allocate the code_stubs dictionary.

  obj = Dictionary::Allocate(4);

  if (obj->IsFailure()) return false;

  code_stubs_ = Dictionary::cast(obj);

  // Allocate the non_monomorphic_cache used in stub-cache.cc

  obj = Dictionary::Allocate(4);

  if (obj->IsFailure()) return false;

  non_monomorphic_cache_ =  Dictionary::cast(obj);

  CreateFixedStubs();

  // Allocate the number->string conversion cache

  obj = AllocateFixedArray(kNumberStringCacheSize * 2);

  if (obj->IsFailure()) return false;

  number_string_cache_ = FixedArray::cast(obj);

  // Allocate cache for single character strings.

  obj = AllocateFixedArray(String::kMaxAsciiCharCode+1);

  if (obj->IsFailure()) return false;

  single_character_string_cache_ = FixedArray::cast(obj);

  // Allocate cache for external strings pointing to native source code.

  obj = AllocateFixedArray(Natives::GetBuiltinsCount());

  if (obj->IsFailure()) return false;

  natives_source_cache_ = FixedArray::cast(obj);

  // Handling of script id generation is in Factory::NewScript.

  last_script_id_ = undefined_value();

  // Initialize keyed lookup cache.

  ClearKeyedLookupCache();

  // Initialize compilation cache.

  CompilationCache::Clear();

  return true;

}

static inline int double_get_hash(double d) {

  DoubleRepresentation rep(d);

  return ((static_cast<int>(rep.bits) ^ static_cast<int>(rep.bits >> 32)) &

          (Heap::kNumberStringCacheSize - 1));

}

static inline int smi_get_hash(Smi* smi) {

  return (smi->value() & (Heap::kNumberStringCacheSize - 1));

}

Object* Heap::GetNumberStringCache(Object* number) {

  int hash;

  if (number->IsSmi()) {

    hash = smi_get_hash(Smi::cast(number));

  } else {

    hash = double_get_hash(number->Number());

  }

  Object* key = number_string_cache_->get(hash * 2);

  if (key == number) {

    return String::cast(number_string_cache_->get(hash * 2 + 1));

  } else if (key->IsHeapNumber() &&

             number->IsHeapNumber() &&

             key->Number() == number->Number()) {

    return String::cast(number_string_cache_->get(hash * 2 + 1));

  }

  return undefined_value();

}

void Heap::SetNumberStringCache(Object* number, String* string) {

  int hash;

  if (number->IsSmi()) {

    hash = smi_get_hash(Smi::cast(number));

    number_string_cache_->set(hash * 2, number, SKIP_WRITE_BARRIER);

  } else {

    hash = double_get_hash(number->Number());

    number_string_cache_->set(hash * 2, number);

  }

  number_string_cache_->set(hash * 2 + 1, string);

}

Object* Heap::SmiOrNumberFromDouble(double value,

                                    bool new_object,

                                    PretenureFlag pretenure) {

  // We need to distinguish the minus zero value and this cannot be

  // done after conversion to int. Doing this by comparing bit

  // patterns is faster than using fpclassify() et al.

  static const DoubleRepresentation plus_zero(0.0);

  static const DoubleRepresentation minus_zero(-0.0);

  static const DoubleRepresentation nan(OS::nan_value());

  ASSERT(minus_zero_value_ != NULL);

  ASSERT(sizeof(plus_zero.value) == sizeof(plus_zero.bits));

  DoubleRepresentation rep(value);

  if (rep.bits == plus_zero.bits) return Smi::FromInt(0);  // not uncommon

  if (rep.bits == minus_zero.bits) {

    return new_object ? AllocateHeapNumber(-0.0, pretenure)

                      : minus_zero_value_;

  }

  if (rep.bits == nan.bits) {

    return new_object

        ? AllocateHeapNumber(OS::nan_value(), pretenure)

        : nan_value_;

  }

  // Try to represent the value as a tagged small integer.

  int int_value = FastD2I(value);

  if (value == FastI2D(int_value) && Smi::IsValid(int_value)) {

    return Smi::FromInt(int_value);

  }

  // Materialize the value in the heap.

  return AllocateHeapNumber(value, pretenure);

}

Object* Heap::NewNumberFromDouble(double value, PretenureFlag pretenure) {

  return SmiOrNumberFromDouble(value,

                               true /* number object must be new */,

                               pretenure);

}

Object* Heap::NumberFromDouble(double value, PretenureFlag pretenure) {

  return SmiOrNumberFromDouble(value,

                               false /* use preallocated NaN, -0.0 */,

                               pretenure);

}

Object* Heap::AllocateProxy(Address proxy, PretenureFlag pretenure) {

  // Statically ensure that it is safe to allocate proxies in paged spaces.

  STATIC_ASSERT(Proxy::kSize <= Page::kMaxHeapObjectSize);

  AllocationSpace space =

      (pretenure == TENURED) ? OLD_DATA_SPACE : NEW_SPACE;

  Object* result = Allocate(proxy_map(), space);

  if (result->IsFailure()) return result;