CSE2410 Fall 2014 Bounce

// Copyright 2012 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.

#ifndef V8_HEAP_H_

#define V8_HEAP_H_

#include <cmath>

#include "allocation.h"

#include "assert-scope.h"

#include "globals.h"

#include "incremental-marking.h"

#include "list.h"

#include "mark-compact.h"

#include "objects-visiting.h"

#include "spaces.h"

#include "splay-tree-inl.h"

#include "store-buffer.h"

#include "v8-counters.h"

#include "v8globals.h"

namespace v8 {

namespace internal {

// Defines all the roots in Heap.

#define STRONG_ROOT_LIST(V)                                                    \

  V(Map, byte_array_map, ByteArrayMap)                                         \

  V(Map, free_space_map, FreeSpaceMap)                                         \

  V(Map, one_pointer_filler_map, OnePointerFillerMap)                          \

  V(Map, two_pointer_filler_map, TwoPointerFillerMap)                          \

  /* Cluster the most popular ones in a few cache lines here at the top.    */ \

  V(Smi, store_buffer_top, StoreBufferTop)                                     \

  V(Oddball, undefined_value, UndefinedValue)                                  \

  V(Oddball, the_hole_value, TheHoleValue)                                     \

  V(Oddball, null_value, NullValue)                                            \

  V(Oddball, true_value, TrueValue)                                            \

  V(Oddball, false_value, FalseValue)                                          \

  V(Oddball, uninitialized_value, UninitializedValue)                          \

  V(Map, cell_map, CellMap)                                                    \

  V(Map, global_property_cell_map, GlobalPropertyCellMap)                      \

  V(Map, shared_function_info_map, SharedFunctionInfoMap)                      \

  V(Map, meta_map, MetaMap)                                                    \

  V(Map, heap_number_map, HeapNumberMap)                                       \

  V(Map, native_context_map, NativeContextMap)                                 \

  V(Map, fixed_array_map, FixedArrayMap)                                       \

  V(Map, code_map, CodeMap)                                                    \

  V(Map, scope_info_map, ScopeInfoMap)                                         \

  V(Map, fixed_cow_array_map, FixedCOWArrayMap)                                \

  V(Map, fixed_double_array_map, FixedDoubleArrayMap)                          \

  V(Map, constant_pool_array_map, ConstantPoolArrayMap)                        \

  V(Object, no_interceptor_result_sentinel, NoInterceptorResultSentinel)       \

  V(Map, hash_table_map, HashTableMap)                                         \

  V(FixedArray, empty_fixed_array, EmptyFixedArray)                            \

  V(ByteArray, empty_byte_array, EmptyByteArray)                               \

  V(DescriptorArray, empty_descriptor_array, EmptyDescriptorArray)             \

  V(Smi, stack_limit, StackLimit)                                              \

  V(Oddball, arguments_marker, ArgumentsMarker)                                \

  /* The roots above this line should be boring from a GC point of view.    */ \

  /* This means they are never in new space and never on a page that is     */ \

  /* being compacted.                                                       */ \

  V(FixedArray, number_string_cache, NumberStringCache)                        \

  V(Object, instanceof_cache_function, InstanceofCacheFunction)                \

  V(Object, instanceof_cache_map, InstanceofCacheMap)                          \

  V(Object, instanceof_cache_answer, InstanceofCacheAnswer)                    \

  V(FixedArray, single_character_string_cache, SingleCharacterStringCache)     \

  V(FixedArray, string_split_cache, StringSplitCache)                          \

  V(FixedArray, regexp_multiple_cache, RegExpMultipleCache)                    \

  V(Object, termination_exception, TerminationException)                       \

  V(Smi, hash_seed, HashSeed)                                                  \

  V(Map, symbol_map, SymbolMap)                                                \

  V(Map, string_map, StringMap)                                                \

  V(Map, ascii_string_map, AsciiStringMap)                                     \

  V(Map, cons_string_map, ConsStringMap)                                       \

  V(Map, cons_ascii_string_map, ConsAsciiStringMap)                            \

  V(Map, sliced_string_map, SlicedStringMap)                                   \

  V(Map, sliced_ascii_string_map, SlicedAsciiStringMap)                        \

  V(Map, external_string_map, ExternalStringMap)                               \

  V(Map,                                                                       \

    external_string_with_one_byte_data_map,                                    \

    ExternalStringWithOneByteDataMap)                                          \

  V(Map, external_ascii_string_map, ExternalAsciiStringMap)                    \

  V(Map, short_external_string_map, ShortExternalStringMap)                    \

  V(Map,                                                                       \

    short_external_string_with_one_byte_data_map,                              \

    ShortExternalStringWithOneByteDataMap)                                     \

  V(Map, internalized_string_map, InternalizedStringMap)                       \

  V(Map, ascii_internalized_string_map, AsciiInternalizedStringMap)            \

  V(Map, cons_internalized_string_map, ConsInternalizedStringMap)              \

  V(Map, cons_ascii_internalized_string_map, ConsAsciiInternalizedStringMap)   \

  V(Map,                                                                       \

    external_internalized_string_map,                                          \

    ExternalInternalizedStringMap)                                             \

  V(Map,                                                                       \

    external_internalized_string_with_one_byte_data_map,                       \

    ExternalInternalizedStringWithOneByteDataMap)                              \

  V(Map,                                                                       \

    external_ascii_internalized_string_map,                                    \

    ExternalAsciiInternalizedStringMap)                                        \

  V(Map,                                                                       \

    short_external_internalized_string_map,                                    \

    ShortExternalInternalizedStringMap)                                        \

  V(Map,                                                                       \

    short_external_internalized_string_with_one_byte_data_map,                 \

    ShortExternalInternalizedStringWithOneByteDataMap)                         \

  V(Map,                                                                       \

    short_external_ascii_internalized_string_map,                              \

    ShortExternalAsciiInternalizedStringMap)                                   \

  V(Map, short_external_ascii_string_map, ShortExternalAsciiStringMap)         \

  V(Map, undetectable_string_map, UndetectableStringMap)                       \

  V(Map, undetectable_ascii_string_map, UndetectableAsciiStringMap)            \

  V(Map, external_byte_array_map, ExternalByteArrayMap)                        \

  V(Map, external_unsigned_byte_array_map, ExternalUnsignedByteArrayMap)       \

  V(Map, external_short_array_map, ExternalShortArrayMap)                      \

  V(Map, external_unsigned_short_array_map, ExternalUnsignedShortArrayMap)     \

  V(Map, external_int_array_map, ExternalIntArrayMap)                          \

  V(Map, external_unsigned_int_array_map, ExternalUnsignedIntArrayMap)         \

  V(Map, external_float_array_map, ExternalFloatArrayMap)                      \

  V(Map, external_double_array_map, ExternalDoubleArrayMap)                    \

  V(Map, external_pixel_array_map, ExternalPixelArrayMap)                      \

  V(ExternalArray, empty_external_byte_array,                                  \

      EmptyExternalByteArray)                                                  \

  V(ExternalArray, empty_external_unsigned_byte_array,                         \

      EmptyExternalUnsignedByteArray)                                          \

  V(ExternalArray, empty_external_short_array, EmptyExternalShortArray)        \

  V(ExternalArray, empty_external_unsigned_short_array,                        \

      EmptyExternalUnsignedShortArray)                                         \

  V(ExternalArray, empty_external_int_array, EmptyExternalIntArray)            \

  V(ExternalArray, empty_external_unsigned_int_array,                          \

      EmptyExternalUnsignedIntArray)                                           \

  V(ExternalArray, empty_external_float_array, EmptyExternalFloatArray)        \

  V(ExternalArray, empty_external_double_array, EmptyExternalDoubleArray)      \

  V(ExternalArray, empty_external_pixel_array,                                 \

      EmptyExternalPixelArray)                                                 \

  V(Map, non_strict_arguments_elements_map, NonStrictArgumentsElementsMap)     \

  V(Map, function_context_map, FunctionContextMap)                             \

  V(Map, catch_context_map, CatchContextMap)                                   \

  V(Map, with_context_map, WithContextMap)                                     \

  V(Map, block_context_map, BlockContextMap)                                   \

  V(Map, module_context_map, ModuleContextMap)                                 \

  V(Map, global_context_map, GlobalContextMap)                                 \

  V(Map, oddball_map, OddballMap)                                              \

  V(Map, message_object_map, JSMessageObjectMap)                               \

  V(Map, foreign_map, ForeignMap)                                              \

  V(HeapNumber, nan_value, NanValue)                                           \

  V(HeapNumber, infinity_value, InfinityValue)                                 \

  V(HeapNumber, minus_zero_value, MinusZeroValue)                              \

  V(Map, neander_map, NeanderMap)                                              \

  V(JSObject, message_listeners, MessageListeners)                             \

  V(UnseededNumberDictionary, code_stubs, CodeStubs)                           \

  V(UnseededNumberDictionary, non_monomorphic_cache, NonMonomorphicCache)      \

  V(PolymorphicCodeCache, polymorphic_code_cache, PolymorphicCodeCache)        \

  V(Code, js_entry_code, JsEntryCode)                                          \

  V(Code, js_construct_entry_code, JsConstructEntryCode)                       \

  V(FixedArray, natives_source_cache, NativesSourceCache)                      \

  V(Smi, last_script_id, LastScriptId)                                         \

  V(Script, empty_script, EmptyScript)                                         \

  V(Smi, real_stack_limit, RealStackLimit)                                     \

  V(NameDictionary, intrinsic_function_names, IntrinsicFunctionNames)          \

  V(Smi, arguments_adaptor_deopt_pc_offset, ArgumentsAdaptorDeoptPCOffset)     \

  V(Smi, construct_stub_deopt_pc_offset, ConstructStubDeoptPCOffset)           \

  V(Smi, getter_stub_deopt_pc_offset, GetterStubDeoptPCOffset)                 \

  V(Smi, setter_stub_deopt_pc_offset, SetterStubDeoptPCOffset)                 \

  V(JSObject, observation_state, ObservationState)                             \

  V(Map, external_map, ExternalMap)                                            \

  V(Symbol, frozen_symbol, FrozenSymbol)                                       \

  V(Symbol, elements_transition_symbol, ElementsTransitionSymbol)              \

  V(SeededNumberDictionary, empty_slow_element_dictionary,                     \

      EmptySlowElementDictionary)                                              \

  V(Symbol, observed_symbol, ObservedSymbol)

#define ROOT_LIST(V)                                  \

  STRONG_ROOT_LIST(V)                                 \

  V(StringTable, string_table, StringTable)

#define INTERNALIZED_STRING_LIST(V)                                      \

  V(Array_string, "Array")                                               \

  V(Object_string, "Object")                                             \

  V(proto_string, "__proto__")                                           \

  V(arguments_string, "arguments")                                       \

  V(Arguments_string, "Arguments")                                       \

  V(call_string, "call")                                                 \

  V(apply_string, "apply")                                               \

  V(caller_string, "caller")                                             \

  V(boolean_string, "boolean")                                           \

  V(Boolean_string, "Boolean")                                           \

  V(callee_string, "callee")                                             \

  V(constructor_string, "constructor")                                   \

  V(result_string, ".result")                                            \

  V(dot_for_string, ".for.")                                             \

  V(eval_string, "eval")                                                 \

  V(empty_string, "")                                                    \

  V(function_string, "function")                                         \

  V(length_string, "length")                                             \

  V(module_string, "module")                                             \

  V(name_string, "name")                                                 \

  V(native_string, "native")                                             \

  V(null_string, "null")                                                 \

  V(number_string, "number")                                             \

  V(Number_string, "Number")                                             \

  V(nan_string, "NaN")                                                   \

  V(RegExp_string, "RegExp")                                             \

  V(source_string, "source")                                             \

  V(global_string, "global")                                             \

  V(ignore_case_string, "ignoreCase")                                    \

  V(multiline_string, "multiline")                                       \

  V(input_string, "input")                                               \

  V(index_string, "index")                                               \

  V(last_index_string, "lastIndex")                                      \

  V(object_string, "object")                                             \

  V(literals_string, "literals")                                         \

  V(prototype_string, "prototype")                                       \

  V(string_string, "string")                                             \

  V(String_string, "String")                                             \

  V(symbol_string, "symbol")                                             \

  V(Symbol_string, "Symbol")                                             \

  V(Date_string, "Date")                                                 \

  V(this_string, "this")                                                 \

  V(to_string_string, "toString")                                        \

  V(char_at_string, "CharAt")                                            \

  V(undefined_string, "undefined")                                       \

  V(value_of_string, "valueOf")                                          \

  V(stack_string, "stack")                                               \

  V(toJSON_string, "toJSON")                                             \

  V(InitializeVarGlobal_string, "InitializeVarGlobal")                   \

  V(InitializeConstGlobal_string, "InitializeConstGlobal")               \

  V(KeyedLoadElementMonomorphic_string,                                  \

    "KeyedLoadElementMonomorphic")                                       \

  V(KeyedStoreElementMonomorphic_string,                                 \

    "KeyedStoreElementMonomorphic")                                      \

  V(stack_overflow_string, "kStackOverflowBoilerplate")                  \

  V(illegal_access_string, "illegal access")                             \

  V(illegal_execution_state_string, "illegal execution state")           \

  V(get_string, "get")                                                   \

  V(set_string, "set")                                                   \

  V(map_field_string, "%map")                                            \

  V(elements_field_string, "%elements")                                  \

  V(length_field_string, "%length")                                      \

  V(cell_value_string, "%cell_value")                                    \

  V(function_class_string, "Function")                                   \

  V(illegal_argument_string, "illegal argument")                         \

  V(MakeReferenceError_string, "MakeReferenceError")                     \

  V(MakeSyntaxError_string, "MakeSyntaxError")                           \

  V(MakeTypeError_string, "MakeTypeError")                               \

  V(invalid_lhs_in_assignment_string, "invalid_lhs_in_assignment")       \

  V(invalid_lhs_in_for_in_string, "invalid_lhs_in_for_in")               \

  V(invalid_lhs_in_postfix_op_string, "invalid_lhs_in_postfix_op")       \

  V(invalid_lhs_in_prefix_op_string, "invalid_lhs_in_prefix_op")         \

  V(illegal_return_string, "illegal_return")                             \

  V(illegal_break_string, "illegal_break")                               \

  V(illegal_continue_string, "illegal_continue")                         \

  V(unknown_label_string, "unknown_label")                               \

  V(redeclaration_string, "redeclaration")                               \

  V(space_string, " ")                                                   \

  V(exec_string, "exec")                                                 \

  V(zero_string, "0")                                                    \

  V(global_eval_string, "GlobalEval")                                    \

  V(identity_hash_string, "v8::IdentityHash")                            \

  V(closure_string, "(closure)")                                         \

  V(use_strict_string, "use strict")                                     \

  V(dot_string, ".")                                                     \

  V(anonymous_function_string, "(anonymous function)")                   \

  V(compare_ic_string, "==")                                             \

  V(strict_compare_ic_string, "===")                                     \

  V(infinity_string, "Infinity")                                         \

  V(minus_infinity_string, "-Infinity")                                  \

  V(hidden_stack_trace_string, "v8::hidden_stack_trace")                 \

  V(query_colon_string, "(?:)")                                          \

  V(Generator_string, "Generator")                                       \

  V(throw_string, "throw")                                               \

  V(done_string, "done")                                                 \

  V(value_string, "value")                                               \

  V(next_string, "next")                                                 \

  V(byte_length_string, "byteLength")                                    \

  V(byte_offset_string, "byteOffset")                                    \

  V(buffer_string, "buffer")

// Forward declarations.

class GCTracer;

class HeapStats;

class Isolate;

class WeakObjectRetainer;

typedef String* (*ExternalStringTableUpdaterCallback)(Heap* heap,

                                                      Object** pointer);

class StoreBufferRebuilder {

 public:

  explicit StoreBufferRebuilder(StoreBuffer* store_buffer)

      : store_buffer_(store_buffer) {

  }

  void Callback(MemoryChunk* page, StoreBufferEvent event);

 private:

  StoreBuffer* store_buffer_;

  // We record in this variable how full the store buffer was when we started

  // iterating over the current page, finding pointers to new space.  If the

  // store buffer overflows again we can exempt the page from the store buffer

  // by rewinding to this point instead of having to search the store buffer.

  Object*** start_of_current_page_;

  // The current page we are scanning in the store buffer iterator.

  MemoryChunk* current_page_;

};

// A queue of objects promoted during scavenge. Each object is accompanied

// by it's size to avoid dereferencing a map pointer for scanning.

class PromotionQueue {

 public:

  explicit PromotionQueue(Heap* heap)

      : front_(NULL),

        rear_(NULL),

        limit_(NULL),

        emergency_stack_(0),

        heap_(heap) { }

  void Initialize();

  void Destroy() {

    ASSERT(is_empty());

    delete emergency_stack_;

    emergency_stack_ = NULL;

  }

  inline void ActivateGuardIfOnTheSamePage();

  Page* GetHeadPage() {

    return Page::FromAllocationTop(reinterpret_cast<Address>(rear_));

  }

  void SetNewLimit(Address limit) {

    if (!guard_) {

      return;

    }

    ASSERT(GetHeadPage() == Page::FromAllocationTop(limit));

    limit_ = reinterpret_cast<intptr_t*>(limit);

    if (limit_ <= rear_) {

      return;

    }

    RelocateQueueHead();

  }

  bool is_empty() {

    return (front_ == rear_) &&

        (emergency_stack_ == NULL || emergency_stack_->length() == 0);

  }

  inline void insert(HeapObject* target, int size);

  void remove(HeapObject** target, int* size) {

    ASSERT(!is_empty());

    if (front_ == rear_) {

      Entry e = emergency_stack_->RemoveLast();

      *target = e.obj_;

      *size = e.size_;

      return;

    }

    if (NewSpacePage::IsAtStart(reinterpret_cast<Address>(front_))) {

      NewSpacePage* front_page =

          NewSpacePage::FromAddress(reinterpret_cast<Address>(front_));

      ASSERT(!front_page->prev_page()->is_anchor());

      front_ =

          reinterpret_cast<intptr_t*>(front_page->prev_page()->area_end());

    }

    *target = reinterpret_cast<HeapObject*>(*(--front_));

    *size = static_cast<int>(*(--front_));

    // Assert no underflow.

    SemiSpace::AssertValidRange(reinterpret_cast<Address>(rear_),

                                reinterpret_cast<Address>(front_));

  }

 private:

  // The front of the queue is higher in the memory page chain than the rear.

  intptr_t* front_;

  intptr_t* rear_;

  intptr_t* limit_;

  bool guard_;

  static const int kEntrySizeInWords = 2;

  struct Entry {

    Entry(HeapObject* obj, int size) : obj_(obj), size_(size) { }

    HeapObject* obj_;

    int size_;

  };

  List<Entry>* emergency_stack_;

  Heap* heap_;

  void RelocateQueueHead();

  DISALLOW_COPY_AND_ASSIGN(PromotionQueue);

};

typedef void (*ScavengingCallback)(Map* map,

                                   HeapObject** slot,

                                   HeapObject* object);

// External strings table is a place where all external strings are

// registered.  We need to keep track of such strings to properly

// finalize them.

class ExternalStringTable {

 public:

  // Registers an external string.

  inline void AddString(String* string);

  inline void Iterate(ObjectVisitor* v);

  // Restores internal invariant and gets rid of collected strings.

  // Must be called after each Iterate() that modified the strings.

  void CleanUp();

  // Destroys all allocated memory.

  void TearDown();

 private:

  ExternalStringTable() { }

  friend class Heap;

  inline void Verify();

  inline void AddOldString(String* string);

  // Notifies the table that only a prefix of the new list is valid.

  inline void ShrinkNewStrings(int position);

  // To speed up scavenge collections new space string are kept

  // separate from old space strings.

  List<Object*> new_space_strings_;

  List<Object*> old_space_strings_;

  Heap* heap_;

  DISALLOW_COPY_AND_ASSIGN(ExternalStringTable);

};

enum ArrayStorageAllocationMode {

  DONT_INITIALIZE_ARRAY_ELEMENTS,

  INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE

};

class Heap {

 public:

  // Configure heap size before setup. Return false if the heap has been

  // set up already.

  bool ConfigureHeap(int max_semispace_size,

                     intptr_t max_old_gen_size,

                     intptr_t max_executable_size);

  bool ConfigureHeapDefault();

  // Prepares the heap, setting up memory areas that are needed in the isolate

  // without actually creating any objects.

  bool SetUp();

  // Bootstraps the object heap with the core set of objects required to run.

  // Returns whether it succeeded.

  bool CreateHeapObjects();

  // Destroys all memory allocated by the heap.

  void TearDown();

  // Set the stack limit in the roots_ array.  Some architectures generate

  // code that looks here, because it is faster than loading from the static

  // jslimit_/real_jslimit_ variable in the StackGuard.

  void SetStackLimits();

  // Returns whether SetUp has been called.

  bool HasBeenSetUp();

  // Returns the maximum amount of memory reserved for the heap.  For

  // the young generation, we reserve 4 times the amount needed for a

  // semi space.  The young generation consists of two semi spaces and

  // we reserve twice the amount needed for those in order to ensure

  // that new space can be aligned to its size.

  intptr_t MaxReserved() {

    return 4 * reserved_semispace_size_ + max_old_generation_size_;

  }

  int MaxSemiSpaceSize() { return max_semispace_size_; }

  int ReservedSemiSpaceSize() { return reserved_semispace_size_; }

  int InitialSemiSpaceSize() { return initial_semispace_size_; }

  intptr_t MaxOldGenerationSize() { return max_old_generation_size_; }

  intptr_t MaxExecutableSize() { return max_executable_size_; }

  int MaxRegularSpaceAllocationSize() { return InitialSemiSpaceSize() * 4/5; }

  // Returns the capacity of the heap in bytes w/o growing. Heap grows when

  // more spaces are needed until it reaches the limit.

  intptr_t Capacity();

  // Returns the amount of memory currently committed for the heap.

  intptr_t CommittedMemory();

  // Returns the amount of executable memory currently committed for the heap.

  intptr_t CommittedMemoryExecutable();

  // Returns the amount of phyical memory currently committed for the heap.

  size_t CommittedPhysicalMemory();

  // Returns the available bytes in space w/o growing.

  // Heap doesn't guarantee that it can allocate an object that requires

  // all available bytes. Check MaxHeapObjectSize() instead.

  intptr_t Available();

  // Returns of size of all objects residing in the heap.

  intptr_t SizeOfObjects();

  // Return the starting address and a mask for the new space.  And-masking an

  // address with the mask will result in the start address of the new space

  // for all addresses in either semispace.

  Address NewSpaceStart() { return new_space_.start(); }

  uintptr_t NewSpaceMask() { return new_space_.mask(); }

  Address NewSpaceTop() { return new_space_.top(); }

  NewSpace* new_space() { return &new_space_; }

  OldSpace* old_pointer_space() { return old_pointer_space_; }

  OldSpace* old_data_space() { return old_data_space_; }

  OldSpace* code_space() { return code_space_; }

  MapSpace* map_space() { return map_space_; }

  CellSpace* cell_space() { return cell_space_; }

  PropertyCellSpace* property_cell_space() {

    return property_cell_space_;

  }

  LargeObjectSpace* lo_space() { return lo_space_; }

  PagedSpace* paged_space(int idx) {

    switch (idx) {

      case OLD_POINTER_SPACE:

        return old_pointer_space();

      case OLD_DATA_SPACE:

        return old_data_space();

      case MAP_SPACE:

        return map_space();

      case CELL_SPACE:

        return cell_space();

      case PROPERTY_CELL_SPACE:

        return property_cell_space();

      case CODE_SPACE:

        return code_space();

      case NEW_SPACE:

      case LO_SPACE:

        UNREACHABLE();

    }

    return NULL;

  }

  bool always_allocate() { return always_allocate_scope_depth_ != 0; }

  Address always_allocate_scope_depth_address() {

    return reinterpret_cast<Address>(&always_allocate_scope_depth_);

  }

  bool linear_allocation() {

    return linear_allocation_scope_depth_ != 0;

  }

  Address* NewSpaceAllocationTopAddress() {

    return new_space_.allocation_top_address();

  }

  Address* NewSpaceAllocationLimitAddress() {

    return new_space_.allocation_limit_address();

  }

  Address* OldPointerSpaceAllocationTopAddress() {

    return old_pointer_space_->allocation_top_address();

  }

  Address* OldPointerSpaceAllocationLimitAddress() {

    return old_pointer_space_->allocation_limit_address();

  }

  Address* OldDataSpaceAllocationTopAddress() {

    return old_data_space_->allocation_top_address();

  }

  Address* OldDataSpaceAllocationLimitAddress() {

    return old_data_space_->allocation_limit_address();

  }

  // Uncommit unused semi space.

  bool UncommitFromSpace() { return new_space_.UncommitFromSpace(); }

  // Allocates and initializes a new JavaScript object based on a

  // constructor.

  // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation

  // failed.

  // Please note this does not perform a garbage collection.

  MUST_USE_RESULT MaybeObject* AllocateJSObject(

      JSFunction* constructor,

      PretenureFlag pretenure = NOT_TENURED);

  MUST_USE_RESULT MaybeObject* AllocateJSObjectWithAllocationSite(

      JSFunction* constructor,

      Handle<AllocationSite> allocation_site);

  MUST_USE_RESULT MaybeObject* AllocateJSGeneratorObject(

      JSFunction* function);

  MUST_USE_RESULT MaybeObject* AllocateJSModule(Context* context,

                                                ScopeInfo* scope_info);

  // Allocate a JSArray with no elements

  MUST_USE_RESULT MaybeObject* AllocateEmptyJSArray(

      ElementsKind elements_kind,

      PretenureFlag pretenure = NOT_TENURED) {

    return AllocateJSArrayAndStorage(elements_kind, 0, 0,

                                     DONT_INITIALIZE_ARRAY_ELEMENTS,

                                     pretenure);

  }

  // Allocate a JSArray with a specified length but elements that are left

  // uninitialized.

  MUST_USE_RESULT MaybeObject* AllocateJSArrayAndStorage(

      ElementsKind elements_kind,

      int length,

      int capacity,

      ArrayStorageAllocationMode mode = DONT_INITIALIZE_ARRAY_ELEMENTS,

      PretenureFlag pretenure = NOT_TENURED);

  MUST_USE_RESULT MaybeObject* AllocateJSArrayStorage(

      JSArray* array,

      int length,

      int capacity,

      ArrayStorageAllocationMode mode = DONT_INITIALIZE_ARRAY_ELEMENTS);

  // Allocate a JSArray with no elements

  MUST_USE_RESULT MaybeObject* AllocateJSArrayWithElements(

      FixedArrayBase* array_base,

      ElementsKind elements_kind,

      int length,

      PretenureFlag pretenure = NOT_TENURED);

  // Returns a deep copy of the JavaScript object.

  // Properties and elements are copied too.

  // Returns failure if allocation failed.

  // Optionally takes an AllocationSite to be appended in an AllocationMemento.

  MUST_USE_RESULT MaybeObject* CopyJSObject(JSObject* source,

                                            AllocationSite* site = NULL);

  // Allocates the function prototype.

  // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation

  // failed.

  // Please note this does not perform a garbage collection.

  MUST_USE_RESULT MaybeObject* AllocateFunctionPrototype(JSFunction* function);

  // Allocates a JS ArrayBuffer object.

  // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation

  // failed.

  // Please note this does not perform a garbage collection.

  MUST_USE_RESULT MaybeObject* AllocateJSArrayBuffer();

  // Allocates a Harmony proxy or function proxy.

  // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation

  // failed.

  // Please note this does not perform a garbage collection.

  MUST_USE_RESULT MaybeObject* AllocateJSProxy(Object* handler,

                                               Object* prototype);

  MUST_USE_RESULT MaybeObject* AllocateJSFunctionProxy(Object* handler,

                                                       Object* call_trap,

                                                       Object* construct_trap,

                                                       Object* prototype);

  // Reinitialize a JSReceiver into an (empty) JS object of respective type and

  // size, but keeping the original prototype.  The receiver must have at least

  // the size of the new object.  The object is reinitialized and behaves as an

  // object that has been freshly allocated.

  // Returns failure if an error occured, otherwise object.

  MUST_USE_RESULT MaybeObject* ReinitializeJSReceiver(JSReceiver* object,

                                                      InstanceType type,

                                                      int size);

  // Reinitialize an JSGlobalProxy based on a constructor.  The object

  // must have the same size as objects allocated using the

  // constructor.  The object is reinitialized and behaves as an

  // object that has been freshly allocated using the constructor.

  MUST_USE_RESULT MaybeObject* ReinitializeJSGlobalProxy(

      JSFunction* constructor, JSGlobalProxy* global);

  // Allocates and initializes a new JavaScript object based on a map.

  // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation

  // failed.

  // Please note this does not perform a garbage collection.

  MUST_USE_RESULT MaybeObject* AllocateJSObjectFromMap(

      Map* map, PretenureFlag pretenure = NOT_TENURED, bool alloc_props = true);

  MUST_USE_RESULT MaybeObject* AllocateJSObjectFromMapWithAllocationSite(

      Map* map, Handle<AllocationSite> allocation_site);

  // Allocates a heap object based on the map.

  // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation

  // failed.

  // Please note this function does not perform a garbage collection.

  MUST_USE_RESULT MaybeObject* Allocate(Map* map, AllocationSpace space);

  MUST_USE_RESULT MaybeObject* AllocateWithAllocationSite(Map* map,

      AllocationSpace space, Handle<AllocationSite> allocation_site);

  // Allocates a JS Map in the heap.

  // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation

  // failed.

  // Please note this function does not perform a garbage collection.

  MUST_USE_RESULT MaybeObject* AllocateMap(

      InstanceType instance_type,

      int instance_size,

      ElementsKind elements_kind = TERMINAL_FAST_ELEMENTS_KIND);

  // Allocates a partial map for bootstrapping.

  MUST_USE_RESULT MaybeObject* AllocatePartialMap(InstanceType instance_type,

                                                  int instance_size);

  // Allocate a map for the specified function

  MUST_USE_RESULT MaybeObject* AllocateInitialMap(JSFunction* fun);

  // Allocates an empty code cache.

  MUST_USE_RESULT MaybeObject* AllocateCodeCache();

  // Allocates a serialized scope info.

  MUST_USE_RESULT MaybeObject* AllocateScopeInfo(int length);

  // Allocates an External object for v8's external API.

  MUST_USE_RESULT MaybeObject* AllocateExternal(void* value);

  // Allocates an empty PolymorphicCodeCache.

  MUST_USE_RESULT MaybeObject* AllocatePolymorphicCodeCache();

  // Allocates a pre-tenured empty AccessorPair.

  MUST_USE_RESULT MaybeObject* AllocateAccessorPair();

  // Allocates an empty TypeFeedbackInfo.

  MUST_USE_RESULT MaybeObject* AllocateTypeFeedbackInfo();

  // Allocates an AliasedArgumentsEntry.

  MUST_USE_RESULT MaybeObject* AllocateAliasedArgumentsEntry(int slot);

  // Clear the Instanceof cache (used when a prototype changes).

  inline void ClearInstanceofCache();

  // For use during bootup.

  void RepairFreeListsAfterBoot();

  // Allocates and fully initializes a String.  There are two String

  // encodings: ASCII and two byte. One should choose between the three string

  // allocation functions based on the encoding of the string buffer used to

  // initialized the string.

  //   - ...FromAscii initializes the string from a buffer that is ASCII

  //     encoded (it does not check that the buffer is ASCII encoded) and the

  //     result will be ASCII encoded.

  //   - ...FromUTF8 initializes the string from a buffer that is UTF-8

  //     encoded.  If the characters are all single-byte characters, the

  //     result will be ASCII encoded, otherwise it will converted to two

  //     byte.

  //   - ...FromTwoByte initializes the string from a buffer that is two-byte

  //     encoded.  If the characters are all single-byte characters, the

  //     result will be converted to ASCII, otherwise it will be left as

  //     two-byte.

  // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation

  // failed.

  // Please note this does not perform a garbage collection.

  MUST_USE_RESULT MaybeObject* AllocateStringFromOneByte(

      Vector<const uint8_t> str,

      PretenureFlag pretenure = NOT_TENURED);

  // TODO(dcarney): remove this function.

  MUST_USE_RESULT inline MaybeObject* AllocateStringFromOneByte(

      Vector<const char> str,

      PretenureFlag pretenure = NOT_TENURED) {

    return AllocateStringFromOneByte(Vector<const uint8_t>::cast(str),

                                     pretenure);

  }

  MUST_USE_RESULT inline MaybeObject* AllocateStringFromUtf8(

      Vector<const char> str,

      PretenureFlag pretenure = NOT_TENURED);

  MUST_USE_RESULT MaybeObject* AllocateStringFromUtf8Slow(

      Vector<const char> str,

      int non_ascii_start,

      PretenureFlag pretenure = NOT_TENURED);

  MUST_USE_RESULT MaybeObject* AllocateStringFromTwoByte(

      Vector<const uc16> str,

      PretenureFlag pretenure = NOT_TENURED);

  // Allocates an internalized string in old space based on the character

  // stream. Returns Failure::RetryAfterGC(requested_bytes, space) if the

  // allocation failed.

  // Please note this function does not perform a garbage collection.

  MUST_USE_RESULT inline MaybeObject* AllocateInternalizedStringFromUtf8(

      Vector<const char> str,

      int chars,

      uint32_t hash_field);

  MUST_USE_RESULT inline MaybeObject* AllocateOneByteInternalizedString(

        Vector<const uint8_t> str,

        uint32_t hash_field);

  MUST_USE_RESULT inline MaybeObject* AllocateTwoByteInternalizedString(

        Vector<const uc16> str,

        uint32_t hash_field);

  template<typename T>

  static inline bool IsOneByte(T t, int chars);

  template<typename T>

  MUST_USE_RESULT inline MaybeObject* AllocateInternalizedStringImpl(

      T t, int chars, uint32_t hash_field);

  template<bool is_one_byte, typename T>

  MUST_USE_RESULT MaybeObject* AllocateInternalizedStringImpl(

      T t, int chars, uint32_t hash_field);

  // Allocates and partially initializes a String.  There are two String

  // encodings: ASCII and two byte.  These functions allocate a string of the

  // given length and set its map and length fields.  The characters of the

  // string are uninitialized.

  // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation

  // failed.

  // Please note this does not perform a garbage collection.

  MUST_USE_RESULT MaybeObject* AllocateRawOneByteString(

      int length,

      PretenureFlag pretenure = NOT_TENURED);

  MUST_USE_RESULT MaybeObject* AllocateRawTwoByteString(

      int length,

      PretenureFlag pretenure = NOT_TENURED);

  // Computes a single character string where the character has code.

  // A cache is used for ASCII codes.

  // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation

  // failed. Please note this does not perform a garbage collection.

  MUST_USE_RESULT MaybeObject* LookupSingleCharacterStringFromCode(

      uint16_t code);

  // Allocate a byte array of the specified length

  // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation

  // failed.

  // Please note this does not perform a garbage collection.

  MUST_USE_RESULT MaybeObject* AllocateByteArray(

      int length,

      PretenureFlag pretenure = NOT_TENURED);

  // Allocates an external array of the specified length and type.

  // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation

  // failed.

  // Please note this does not perform a garbage collection.

  MUST_USE_RESULT MaybeObject* AllocateExternalArray(

      int length,

      ExternalArrayType array_type,

      void* external_pointer,

      PretenureFlag pretenure);

  // Allocate a symbol in old space.

  // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation

  // failed.

  // Please note this does not perform a garbage collection.

  MUST_USE_RESULT MaybeObject* AllocateSymbol();

  // Allocate a tenured AllocationSite. It's payload is null

  MUST_USE_RESULT MaybeObject* AllocateAllocationSite();

  // Allocates a fixed array initialized with undefined values

  // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation

  // failed.

  // Please note this does not perform a garbage collection.

  MUST_USE_RESULT MaybeObject* AllocateFixedArray(

      int length,

      PretenureFlag pretenure = NOT_TENURED);

  // Allocates an uninitialized fixed array. It must be filled by the caller.

  //

  // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation

  // failed.

  // Please note this does not perform a garbage collection.

  MUST_USE_RESULT MaybeObject* AllocateUninitializedFixedArray(int length);

  // Move len elements within a given array from src_index index to dst_index

  // index.

  void MoveElements(FixedArray* array, int dst_index, int src_index, int len);

  // Make a copy of src and return it. Returns

  // Failure::RetryAfterGC(requested_bytes, space) if the allocation failed.

  MUST_USE_RESULT inline MaybeObject* CopyFixedArray(FixedArray* src);

  // Make a copy of src, set the map, and return the copy. Returns

  // Failure::RetryAfterGC(requested_bytes, space) if the allocation failed.

  MUST_USE_RESULT MaybeObject* CopyFixedArrayWithMap(FixedArray* src, Map* map);

  // Make a copy of src and return it. Returns

  // Failure::RetryAfterGC(requested_bytes, space) if the allocation failed.

  MUST_USE_RESULT inline MaybeObject* CopyFixedDoubleArray(

      FixedDoubleArray* src);

  // Make a copy of src, set the map, and return the copy. Returns

  // Failure::RetryAfterGC(requested_bytes, space) if the allocation failed.

  MUST_USE_RESULT MaybeObject* CopyFixedDoubleArrayWithMap(

      FixedDoubleArray* src, Map* map);

  // Make a copy of src and return it. Returns

  // Failure::RetryAfterGC(requested_bytes, space) if the allocation failed.

  MUST_USE_RESULT inline MaybeObject* CopyConstantPoolArray(

      ConstantPoolArray* src);

  // Make a copy of src, set the map, and return the copy. Returns

  // Failure::RetryAfterGC(requested_bytes, space) if the allocation failed.

  MUST_USE_RESULT MaybeObject* CopyConstantPoolArrayWithMap(

      ConstantPoolArray* src, Map* map);

  // Allocates a fixed array initialized with the hole values.

  // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation

  // failed.

  // Please note this does not perform a garbage collection.

  MUST_USE_RESULT MaybeObject* AllocateFixedArrayWithHoles(

      int length,

      PretenureFlag pretenure = NOT_TENURED);

  MUST_USE_RESULT MaybeObject* AllocateConstantPoolArray(

      int first_int64_index,

      int first_ptr_index,

      int first_int32_index);

  // Allocates a fixed double array with uninitialized values. Returns

  // Failure::RetryAfterGC(requested_bytes, space) if the allocation failed.

  // Please note this does not perform a garbage collection.

  MUST_USE_RESULT MaybeObject* AllocateUninitializedFixedDoubleArray(

      int length,

      PretenureFlag pretenure = NOT_TENURED);

  // Allocates a fixed double array with hole values. Returns

  // Failure::RetryAfterGC(requested_bytes, space) if the allocation failed.

  // Please note this does not perform a garbage collection.

  MUST_USE_RESULT MaybeObject* AllocateFixedDoubleArrayWithHoles(

      int length,

      PretenureFlag pretenure = NOT_TENURED);

  // AllocateHashTable is identical to AllocateFixedArray except

  // that the resulting object has hash_table_map as map.

  MUST_USE_RESULT MaybeObject* AllocateHashTable(

      int length, PretenureFlag pretenure = NOT_TENURED);

  // Allocate a native (but otherwise uninitialized) context.

  MUST_USE_RESULT MaybeObject* AllocateNativeContext();

  // Allocate a global context.

  MUST_USE_RESULT MaybeObject* AllocateGlobalContext(JSFunction* function,

                                                     ScopeInfo* scope_info);

  // Allocate a module context.

  MUST_USE_RESULT MaybeObject* AllocateModuleContext(ScopeInfo* scope_info);

  // Allocate a function context.

  MUST_USE_RESULT MaybeObject* AllocateFunctionContext(int length,

                                                       JSFunction* function);

  // Allocate a catch context.

  MUST_USE_RESULT MaybeObject* AllocateCatchContext(JSFunction* function,

                                                    Context* previous,

                                                    String* name,

                                                    Object* thrown_object);

  // Allocate a 'with' context.

  MUST_USE_RESULT MaybeObject* AllocateWithContext(JSFunction* function,

                                                   Context* previous,

                                                   JSReceiver* extension);

  // Allocate a block context.

  MUST_USE_RESULT MaybeObject* AllocateBlockContext(JSFunction* function,

                                                    Context* previous,

                                                    ScopeInfo* info);

  // Allocates a new utility object in the old generation.

  MUST_USE_RESULT MaybeObject* AllocateStruct(InstanceType type);

  // Allocates a function initialized with a shared part.

  // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation

  // failed.

  // Please note this does not perform a garbage collection.

  MUST_USE_RESULT MaybeObject* AllocateFunction(

      Map* function_map,

      SharedFunctionInfo* shared,

      Object* prototype,

      PretenureFlag pretenure = TENURED);

  // Arguments object size.

  static const int kArgumentsObjectSize =

      JSObject::kHeaderSize + 2 * kPointerSize;

  // Strict mode arguments has no callee so it is smaller.

  static const int kArgumentsObjectSizeStrict =

      JSObject::kHeaderSize + 1 * kPointerSize;

  // Indicies for direct access into argument objects.

  static const int kArgumentsLengthIndex = 0;

  // callee is only valid in non-strict mode.

  static const int kArgumentsCalleeIndex = 1;

  // Allocates an arguments object - optionally with an elements array.

  // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation

  // failed.

  // Please note this does not perform a garbage collection.

  MUST_USE_RESULT MaybeObject* AllocateArgumentsObject(

      Object* callee, int length);

  // Same as NewNumberFromDouble, but may return a preallocated/immutable

  // number object (e.g., minus_zero_value_, nan_value_)

  MUST_USE_RESULT MaybeObject* NumberFromDouble(

      double value, PretenureFlag pretenure = NOT_TENURED);

  // Allocated a HeapNumber from value.

  MUST_USE_RESULT MaybeObject* AllocateHeapNumber(

      double value, PretenureFlag pretenure = NOT_TENURED);

  // Converts an int into either a Smi or a HeapNumber object.

  // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation

  // failed.

  // Please note this does not perform a garbage collection.

  MUST_USE_RESULT inline MaybeObject* NumberFromInt32(

      int32_t value, PretenureFlag pretenure = NOT_TENURED);

  // Converts an int into either a Smi or a HeapNumber object.

  // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation

  // failed.

  // Please note this does not perform a garbage collection.

  MUST_USE_RESULT inline MaybeObject* NumberFromUint32(

      uint32_t value, PretenureFlag pretenure = NOT_TENURED);

  // Allocates a new foreign object.

  // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation

  // failed.

  // Please note this does not perform a garbage collection.

  MUST_USE_RESULT MaybeObject* AllocateForeign(

      Address address, PretenureFlag pretenure = NOT_TENURED);

  // Allocates a new SharedFunctionInfo object.

  // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation

  // failed.

  // Please note this does not perform a garbage collection.

  MUST_USE_RESULT MaybeObject* AllocateSharedFunctionInfo(Object* name);

  // Allocates a new JSMessageObject object.

  // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation

  // failed.

  // Please note that this does not perform a garbage collection.

  MUST_USE_RESULT MaybeObject* AllocateJSMessageObject(

      String* type,

      JSArray* arguments,

      int start_position,

      int end_position,

      Object* script,

      Object* stack_trace,

      Object* stack_frames);

  // Allocates a new cons string object.

  // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation

  // failed.

  // Please note this does not perform a garbage collection.

  MUST_USE_RESULT MaybeObject* AllocateConsString(String* first,

                                                  String* second);

  // Allocates a new sub string object which is a substring of an underlying

  // string buffer stretching from the index start (inclusive) to the index

  // end (exclusive).

  // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation

  // failed.

  // Please note this does not perform a garbage collection.

  MUST_USE_RESULT MaybeObject* AllocateSubString(

      String* buffer,

      int start,

      int end,

      PretenureFlag pretenure = NOT_TENURED);

  // Allocate a new external string object, which is backed by a string

  // resource that resides outside the V8 heap.

  // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation

  // failed.

  // Please note this does not perform a garbage collection.

  MUST_USE_RESULT MaybeObject* AllocateExternalStringFromAscii(

      const ExternalAsciiString::Resource* resource);

  MUST_USE_RESULT MaybeObject* AllocateExternalStringFromTwoByte(

      const ExternalTwoByteString::Resource* resource);

  // Finalizes an external string by deleting the associated external

  // data and clearing the resource pointer.

  inline void FinalizeExternalString(String* string);

  // Allocates an uninitialized object.  The memory is non-executable if the

  // hardware and OS allow.

  // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation

  // failed.

  // Please note this function does not perform a garbage collection.

  MUST_USE_RESULT inline MaybeObject* AllocateRaw(int size_in_bytes,

                                                  AllocationSpace space,

                                                  AllocationSpace retry_space);

  // Initialize a filler object to keep the ability to iterate over the heap

  // when shortening objects.

  void CreateFillerObjectAt(Address addr, int size);

  // Makes a new native code object

  // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation

  // failed. On success, the pointer to the Code object is stored in the

  // self_reference. This allows generated code to reference its own Code

  // object by containing this pointer.

  // Please note this function does not perform a garbage collection.

  MUST_USE_RESULT MaybeObject* CreateCode(

      const CodeDesc& desc,

      Code::Flags flags,

      Handle<Object> self_reference,

      bool immovable = false,

      bool crankshafted = false,

      int prologue_offset = Code::kPrologueOffsetNotSet);

  MUST_USE_RESULT MaybeObject* CopyCode(Code* code);

  // Copy the code and scope info part of the code object, but insert

  // the provided data as the relocation information.

  MUST_USE_RESULT MaybeObject* CopyCode(Code* code, Vector<byte> reloc_info);

  // Finds the internalized copy for string in the string table.

  // If not found, a new string is added to the table and returned.

  // Returns Failure::RetryAfterGC(requested_bytes, space) if allocation

  // failed.

  // Please note this function does not perform a garbage collection.

  MUST_USE_RESULT MaybeObject* InternalizeUtf8String(Vector<const char> str);

  MUST_USE_RESULT MaybeObject* InternalizeUtf8String(const char* str) {

    return InternalizeUtf8String(CStrVector(str));

  }

  MUST_USE_RESULT MaybeObject* InternalizeOneByteString(

      Vector<const uint8_t> str);

  MUST_USE_RESULT MaybeObject* InternalizeTwoByteString(Vector<const uc16> str);

  MUST_USE_RESULT MaybeObject* InternalizeString(String* str);

  MUST_USE_RESULT MaybeObject* InternalizeOneByteString(

      Handle<SeqOneByteString> string, int from, int length);

  bool InternalizeStringIfExists(String* str, String** result);

  bool InternalizeTwoCharsStringIfExists(String* str, String** result);

  // Compute the matching internalized string map for a string if possible.

  // NULL is returned if string is in new space or not flattened.

  Map* InternalizedStringMapForString(String* str);

  // Tries to flatten a string before compare operation.

  //

  // Returns a failure in case it was decided that flattening was

  // necessary and failed.  Note, if flattening is not necessary the

  // string might stay non-flat even when not a failure is returned.

  //

  // Please note this function does not perform a garbage collection.

  MUST_USE_RESULT inline MaybeObject* PrepareForCompare(String* str);

  // Converts the given boolean condition to JavaScript boolean value.

  inline Object* ToBoolean(bool condition);

  // Code that should be run before and after each GC.  Includes some

  // reporting/verification activities when compiled with DEBUG set.

  void GarbageCollectionPrologue();

  void GarbageCollectionEpilogue();

  // Performs garbage collection operation.

  // Returns whether there is a chance that another major GC could

  // collect more garbage.

  bool CollectGarbage(AllocationSpace space,

                      GarbageCollector collector,

                      const char* gc_reason,

                      const char* collector_reason);

  // Performs garbage collection operation.

  // Returns whether there is a chance that another major GC could

  // collect more garbage.

  inline bool CollectGarbage(AllocationSpace space,

                             const char* gc_reason = NULL);

  static const int kNoGCFlags = 0;

  static const int kSweepPreciselyMask = 1;

  static const int kReduceMemoryFootprintMask = 2;

  static const int kAbortIncrementalMarkingMask = 4;

  // Making the heap iterable requires us to sweep precisely and abort any

  // incremental marking as well.

  static const int kMakeHeapIterableMask =

      kSweepPreciselyMask | kAbortIncrementalMarkingMask;

  // Performs a full garbage collection.  If (flags & kMakeHeapIterableMask) is

  // non-zero, then the slower precise sweeper is used, which leaves the heap

  // in a state where we can iterate over the heap visiting all objects.

  void CollectAllGarbage(int flags, const char* gc_reason = NULL);

  // Last hope GC, should try to squeeze as much as possible.

  void CollectAllAvailableGarbage(const char* gc_reason = NULL);

  // Check whether the heap is currently iterable.

  bool IsHeapIterable();

  // Ensure that we have swept all spaces in such a way that we can iterate

  // over all objects.  May cause a GC.

  void EnsureHeapIsIterable();

  // Notify the heap that a context has been disposed.

  int NotifyContextDisposed();

  // Utility to invoke the scavenger. This is needed in test code to

  // ensure correct callback for weak global handles.

  void PerformScavenge();

  inline void increment_scan_on_scavenge_pages() {

    scan_on_scavenge_pages_++;

    if (FLAG_gc_verbose) {

      PrintF("Scan-on-scavenge pages: %d\n", scan_on_scavenge_pages_);

    }

  }

  inline void decrement_scan_on_scavenge_pages() {

    scan_on_scavenge_pages_--;

    if (FLAG_gc_verbose) {

      PrintF("Scan-on-scavenge pages: %d\n", scan_on_scavenge_pages_);

    }

  }

  PromotionQueue* promotion_queue() { return &promotion_queue_; }

#ifdef DEBUG

  // Utility used with flag gc-greedy.

  void GarbageCollectionGreedyCheck();

#endif

  void AddGCPrologueCallback(v8::Isolate::GCPrologueCallback callback,

                             GCType gc_type_filter,

                             bool pass_isolate = true);

  void RemoveGCPrologueCallback(v8::Isolate::GCPrologueCallback callback);

  void AddGCEpilogueCallback(v8::Isolate::GCEpilogueCallback callback,

                             GCType gc_type_filter,

                             bool pass_isolate = true);

  void RemoveGCEpilogueCallback(v8::Isolate::GCEpilogueCallback callback);

  // Heap root getters.  We have versions with and without type::cast() here.

  // You can't use type::cast during GC because the assert fails.

  // TODO(1490): Try removing the unchecked accessors, now that GC marking does

  // not corrupt the map.

#define ROOT_ACCESSOR(type, name, camel_name)                                  \

  type* name() {                                                               \

    return type::cast(roots_[k##camel_name##RootIndex]);                       \

  }                                                                            \

  type* raw_unchecked_##name() {                                               \

    return reinterpret_cast<type*>(roots_[k##camel_name##RootIndex]);          \

  }

  ROOT_LIST(ROOT_ACCESSOR)

#undef ROOT_ACCESSOR

// Utility type maps

#define STRUCT_MAP_ACCESSOR(NAME, Name, name)                                  \

    Map* name##_map() {                                                        \

      return Map::cast(roots_[k##Name##MapRootIndex]);                         \

    }

  STRUCT_LIST(STRUCT_MAP_ACCESSOR)

#undef STRUCT_MAP_ACCESSOR

#define STRING_ACCESSOR(name, str) String* name() {                            \

    return String::cast(roots_[k##name##RootIndex]);                           \

  }

  INTERNALIZED_STRING_LIST(STRING_ACCESSOR)

#undef STRING_ACCESSOR

  // The hidden_string is special because it is the empty string, but does

  // not match the empty string.

  String* hidden_string() { return hidden_string_; }

  void set_native_contexts_list(Object* object) {

    native_contexts_list_ = object;

  }

  Object* native_contexts_list() { return native_contexts_list_; }

  void set_array_buffers_list(Object* object) {

    array_buffers_list_ = object;

  }

  Object* array_buffers_list() { return array_buffers_list_; }

  void set_allocation_sites_list(Object* object) {

    allocation_sites_list_ = object;

  }

  Object* allocation_sites_list() { return allocation_sites_list_; }

  Object** allocation_sites_list_address() { return &allocation_sites_list_; }

  Object* weak_object_to_code_table() { return weak_object_to_code_table_; }

  // Number of mark-sweeps.

  unsigned int ms_count() { return ms_count_; }

  // Iterates over all roots in the heap.

  void IterateRoots(ObjectVisitor* v, VisitMode mode);

  // Iterates over all strong roots in the heap.

  void IterateStrongRoots(ObjectVisitor* v, VisitMode mode);

  // Iterates over all the other roots in the heap.

  void IterateWeakRoots(ObjectVisitor* v, VisitMode mode);

  // Iterate pointers to from semispace of new space found in memory interval

  // from start to end.

  void IterateAndMarkPointersToFromSpace(Address start,

                                         Address end,

                                         ObjectSlotCallback callback);

  // Returns whether the object resides in new space.

  inline bool InNewSpace(Object* object);

  inline bool InNewSpace(Address address);

  inline bool InNewSpacePage(Address address);

  inline bool InFromSpace(Object* object);

  inline bool InToSpace(Object* object);

  // Returns whether the object resides in old pointer space.

  inline bool InOldPointerSpace(Address address);

  inline bool InOldPointerSpace(Object* object);

  // Returns whether the object resides in old data space.

  inline bool InOldDataSpace(Address address);

  inline bool InOldDataSpace(Object* object);

  // Checks whether an address/object in the heap (including auxiliary

  // area and unused area).

  bool Contains(Address addr);

  bool Contains(HeapObject* value);

  // Checks whether an address/object in a space.

  // Currently used by tests, serialization and heap verification only.

  bool InSpace(Address addr, AllocationSpace space);

  bool InSpace(HeapObject* value, AllocationSpace space);

  // Finds out which space an object should get promoted to based on its type.

  inline OldSpace* TargetSpace(HeapObject* object);