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_OBJECTS_H_

#define V8_OBJECTS_H_

#include "allocation.h"

#include "assert-scope.h"

#include "builtins.h"

#include "elements-kind.h"

#include "flags.h"

#include "list.h"

#include "property-details.h"

#include "smart-pointers.h"

#include "unicode-inl.h"

#if V8_TARGET_ARCH_ARM

#include "arm/constants-arm.h"

#elif V8_TARGET_ARCH_MIPS

#include "mips/constants-mips.h"

#endif

#include "v8checks.h"

#include "zone.h"

//

// Most object types in the V8 JavaScript are described in this file.

//

// Inheritance hierarchy:

// - MaybeObject    (an object or a failure)

//   - Failure      (immediate for marking failed operation)

//   - Object

//     - Smi          (immediate small integer)

//     - HeapObject   (superclass for everything allocated in the heap)

//       - JSReceiver  (suitable for property access)

//         - JSObject

//           - JSArray

//           - JSArrayBuffer

//           - JSArrayBufferView

//             - JSTypedArray

//             - JSDataView

//           - JSSet

//           - JSMap

//           - JSWeakCollection

//             - JSWeakMap

//             - JSWeakSet

//           - JSRegExp

//           - JSFunction

//           - JSGeneratorObject

//           - JSModule

//           - GlobalObject

//             - JSGlobalObject

//             - JSBuiltinsObject

//           - JSGlobalProxy

//           - JSValue

//             - JSDate

//           - JSMessageObject

//         - JSProxy

//           - JSFunctionProxy

//       - FixedArrayBase

//         - ByteArray

//         - FixedArray

//           - DescriptorArray

//           - HashTable

//             - Dictionary

//             - StringTable

//             - CompilationCacheTable

//             - CodeCacheHashTable

//             - MapCache

//           - Context

//           - JSFunctionResultCache

//           - ScopeInfo

//           - TransitionArray

//         - FixedDoubleArray

//         - ExternalArray

//           - ExternalPixelArray

//           - ExternalByteArray

//           - ExternalUnsignedByteArray

//           - ExternalShortArray

//           - ExternalUnsignedShortArray

//           - ExternalIntArray

//           - ExternalUnsignedIntArray

//           - ExternalFloatArray

//       - Name

//         - String

//           - SeqString

//             - SeqOneByteString

//             - SeqTwoByteString

//           - SlicedString

//           - ConsString

//           - ExternalString

//             - ExternalAsciiString

//             - ExternalTwoByteString

//           - InternalizedString

//             - SeqInternalizedString

//               - SeqOneByteInternalizedString

//               - SeqTwoByteInternalizedString

//             - ConsInternalizedString

//             - ExternalInternalizedString

//               - ExternalAsciiInternalizedString

//               - ExternalTwoByteInternalizedString

//         - Symbol

//       - HeapNumber

//       - Cell

//         - PropertyCell

//       - Code

//       - Map

//       - Oddball

//       - Foreign

//       - SharedFunctionInfo

//       - Struct

//         - Box

//         - DeclaredAccessorDescriptor

//         - AccessorInfo

//           - DeclaredAccessorInfo

//           - ExecutableAccessorInfo

//         - AccessorPair

//         - AccessCheckInfo

//         - InterceptorInfo

//         - CallHandlerInfo

//         - TemplateInfo

//           - FunctionTemplateInfo

//           - ObjectTemplateInfo

//         - Script

//         - SignatureInfo

//         - TypeSwitchInfo

//         - DebugInfo

//         - BreakPointInfo

//         - CodeCache

//

// Formats of Object*:

//  Smi:        [31 bit signed int] 0

//  HeapObject: [32 bit direct pointer] (4 byte aligned) | 01

//  Failure:    [30 bit signed int] 11

namespace v8 {

namespace internal {

enum KeyedAccessStoreMode {

  STANDARD_STORE,

  STORE_TRANSITION_SMI_TO_OBJECT,

  STORE_TRANSITION_SMI_TO_DOUBLE,

  STORE_TRANSITION_DOUBLE_TO_OBJECT,

  STORE_TRANSITION_HOLEY_SMI_TO_OBJECT,

  STORE_TRANSITION_HOLEY_SMI_TO_DOUBLE,

  STORE_TRANSITION_HOLEY_DOUBLE_TO_OBJECT,

  STORE_AND_GROW_NO_TRANSITION,

  STORE_AND_GROW_TRANSITION_SMI_TO_OBJECT,

  STORE_AND_GROW_TRANSITION_SMI_TO_DOUBLE,

  STORE_AND_GROW_TRANSITION_DOUBLE_TO_OBJECT,

  STORE_AND_GROW_TRANSITION_HOLEY_SMI_TO_OBJECT,

  STORE_AND_GROW_TRANSITION_HOLEY_SMI_TO_DOUBLE,

  STORE_AND_GROW_TRANSITION_HOLEY_DOUBLE_TO_OBJECT,

  STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS,

  STORE_NO_TRANSITION_HANDLE_COW

};

static const int kGrowICDelta = STORE_AND_GROW_NO_TRANSITION -

    STANDARD_STORE;

STATIC_ASSERT(STANDARD_STORE == 0);

STATIC_ASSERT(kGrowICDelta ==

              STORE_AND_GROW_TRANSITION_SMI_TO_OBJECT -

              STORE_TRANSITION_SMI_TO_OBJECT);

STATIC_ASSERT(kGrowICDelta ==

              STORE_AND_GROW_TRANSITION_SMI_TO_DOUBLE -

              STORE_TRANSITION_SMI_TO_DOUBLE);

STATIC_ASSERT(kGrowICDelta ==

              STORE_AND_GROW_TRANSITION_DOUBLE_TO_OBJECT -

              STORE_TRANSITION_DOUBLE_TO_OBJECT);

static inline KeyedAccessStoreMode GetGrowStoreMode(

    KeyedAccessStoreMode store_mode) {

  if (store_mode < STORE_AND_GROW_NO_TRANSITION) {

    store_mode = static_cast<KeyedAccessStoreMode>(

        static_cast<int>(store_mode) + kGrowICDelta);

  }

  return store_mode;

}

static inline bool IsTransitionStoreMode(KeyedAccessStoreMode store_mode) {

  return store_mode > STANDARD_STORE &&

      store_mode <= STORE_AND_GROW_TRANSITION_HOLEY_DOUBLE_TO_OBJECT &&

      store_mode != STORE_AND_GROW_NO_TRANSITION;

}

static inline KeyedAccessStoreMode GetNonTransitioningStoreMode(

    KeyedAccessStoreMode store_mode) {

  if (store_mode >= STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS) {

    return store_mode;

  }

  if (store_mode >= STORE_AND_GROW_NO_TRANSITION) {

    return STORE_AND_GROW_NO_TRANSITION;

  }

  return STANDARD_STORE;

}

static inline bool IsGrowStoreMode(KeyedAccessStoreMode store_mode) {

  return store_mode >= STORE_AND_GROW_NO_TRANSITION &&

      store_mode <= STORE_AND_GROW_TRANSITION_HOLEY_DOUBLE_TO_OBJECT;

}

// Setter that skips the write barrier if mode is SKIP_WRITE_BARRIER.

enum WriteBarrierMode { SKIP_WRITE_BARRIER, UPDATE_WRITE_BARRIER };

// Indicates whether a value can be loaded as a constant.

enum StoreMode {

  ALLOW_AS_CONSTANT,

  FORCE_FIELD

};

// PropertyNormalizationMode is used to specify whether to keep

// inobject properties when normalizing properties of a JSObject.

enum PropertyNormalizationMode {

  CLEAR_INOBJECT_PROPERTIES,

  KEEP_INOBJECT_PROPERTIES

};

// NormalizedMapSharingMode is used to specify whether a map may be shared

// by different objects with normalized properties.

enum NormalizedMapSharingMode {

  UNIQUE_NORMALIZED_MAP,

  SHARED_NORMALIZED_MAP

};

// Indicates whether a get method should implicitly create the object looked up.

enum CreationFlag {

  ALLOW_CREATION,

  OMIT_CREATION

};

// Indicates whether transitions can be added to a source map or not.

enum TransitionFlag {

  INSERT_TRANSITION,

  OMIT_TRANSITION

};

enum DebugExtraICState {

  DEBUG_BREAK,

  DEBUG_PREPARE_STEP_IN

};

// Indicates whether the transition is simple: the target map of the transition

// either extends the current map with a new property, or it modifies the

// property that was added last to the current map.

enum SimpleTransitionFlag {

  SIMPLE_TRANSITION,

  FULL_TRANSITION

};

// Indicates whether we are only interested in the descriptors of a particular

// map, or in all descriptors in the descriptor array.

enum DescriptorFlag {

  ALL_DESCRIPTORS,

  OWN_DESCRIPTORS

};

// The GC maintains a bit of information, the MarkingParity, which toggles

// from odd to even and back every time marking is completed. Incremental

// marking can visit an object twice during a marking phase, so algorithms that

// that piggy-back on marking can use the parity to ensure that they only

// perform an operation on an object once per marking phase: they record the

// MarkingParity when they visit an object, and only re-visit the object when it

// is marked again and the MarkingParity changes.

enum MarkingParity {

  NO_MARKING_PARITY,

  ODD_MARKING_PARITY,

  EVEN_MARKING_PARITY

};

// Instance size sentinel for objects of variable size.

const int kVariableSizeSentinel = 0;

const int kStubMajorKeyBits = 6;

const int kStubMinorKeyBits = kBitsPerInt - kSmiTagSize - kStubMajorKeyBits;

// All Maps have a field instance_type containing a InstanceType.

// It describes the type of the instances.

//

// As an example, a JavaScript object is a heap object and its map

// instance_type is JS_OBJECT_TYPE.

//

// The names of the string instance types are intended to systematically

// mirror their encoding in the instance_type field of the map.  The default

// encoding is considered TWO_BYTE.  It is not mentioned in the name.  ASCII

// encoding is mentioned explicitly in the name.  Likewise, the default

// representation is considered sequential.  It is not mentioned in the

// name.  The other representations (e.g. CONS, EXTERNAL) are explicitly

// mentioned.  Finally, the string is either a STRING_TYPE (if it is a normal

// string) or a INTERNALIZED_STRING_TYPE (if it is a internalized string).

//

// NOTE: The following things are some that depend on the string types having

// instance_types that are less than those of all other types:

// HeapObject::Size, HeapObject::IterateBody, the typeof operator, and

// Object::IsString.

//

// NOTE: Everything following JS_VALUE_TYPE is considered a

// JSObject for GC purposes. The first four entries here have typeof

// 'object', whereas JS_FUNCTION_TYPE has typeof 'function'.

#define INSTANCE_TYPE_LIST(V)                                                  \

  V(STRING_TYPE)                                                               \

  V(ASCII_STRING_TYPE)                                                         \

  V(CONS_STRING_TYPE)                                                          \

  V(CONS_ASCII_STRING_TYPE)                                                    \

  V(SLICED_STRING_TYPE)                                                        \

  V(SLICED_ASCII_STRING_TYPE)                                                  \

  V(EXTERNAL_STRING_TYPE)                                                      \

  V(EXTERNAL_ASCII_STRING_TYPE)                                                \

  V(EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE)                                   \

  V(SHORT_EXTERNAL_STRING_TYPE)                                                \

  V(SHORT_EXTERNAL_ASCII_STRING_TYPE)                                          \

  V(SHORT_EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE)                             \

                                                                               \

  V(INTERNALIZED_STRING_TYPE)                                                  \

  V(ASCII_INTERNALIZED_STRING_TYPE)                                            \

  V(CONS_INTERNALIZED_STRING_TYPE)                                             \

  V(CONS_ASCII_INTERNALIZED_STRING_TYPE)                                       \

  V(EXTERNAL_INTERNALIZED_STRING_TYPE)                                         \

  V(EXTERNAL_ASCII_INTERNALIZED_STRING_TYPE)                                   \

  V(EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE)                      \

  V(SHORT_EXTERNAL_INTERNALIZED_STRING_TYPE)                                   \

  V(SHORT_EXTERNAL_ASCII_INTERNALIZED_STRING_TYPE)                             \

  V(SHORT_EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE)                \

                                                                               \

  V(SYMBOL_TYPE)                                                               \

  V(MAP_TYPE)                                                                  \

  V(CODE_TYPE)                                                                 \

  V(ODDBALL_TYPE)                                                              \

  V(CELL_TYPE)                                                                 \

  V(PROPERTY_CELL_TYPE)                                                        \

                                                                               \

  V(HEAP_NUMBER_TYPE)                                                          \

  V(FOREIGN_TYPE)                                                              \

  V(BYTE_ARRAY_TYPE)                                                           \

  V(FREE_SPACE_TYPE)                                                           \

  /* Note: the order of these external array */                                \

  /* types is relied upon in */                                                \

  /* Object::IsExternalArray(). */                                             \

  V(EXTERNAL_BYTE_ARRAY_TYPE)                                                  \

  V(EXTERNAL_UNSIGNED_BYTE_ARRAY_TYPE)                                         \

  V(EXTERNAL_SHORT_ARRAY_TYPE)                                                 \

  V(EXTERNAL_UNSIGNED_SHORT_ARRAY_TYPE)                                        \

  V(EXTERNAL_INT_ARRAY_TYPE)                                                   \

  V(EXTERNAL_UNSIGNED_INT_ARRAY_TYPE)                                          \

  V(EXTERNAL_FLOAT_ARRAY_TYPE)                                                 \

  V(EXTERNAL_DOUBLE_ARRAY_TYPE)                                                \

  V(EXTERNAL_PIXEL_ARRAY_TYPE)                                                 \

  V(FILLER_TYPE)                                                               \

                                                                               \

  V(DECLARED_ACCESSOR_DESCRIPTOR_TYPE)                                         \

  V(DECLARED_ACCESSOR_INFO_TYPE)                                               \

  V(EXECUTABLE_ACCESSOR_INFO_TYPE)                                             \

  V(ACCESSOR_PAIR_TYPE)                                                        \

  V(ACCESS_CHECK_INFO_TYPE)                                                    \

  V(INTERCEPTOR_INFO_TYPE)                                                     \

  V(CALL_HANDLER_INFO_TYPE)                                                    \

  V(FUNCTION_TEMPLATE_INFO_TYPE)                                               \

  V(OBJECT_TEMPLATE_INFO_TYPE)                                                 \

  V(SIGNATURE_INFO_TYPE)                                                       \

  V(TYPE_SWITCH_INFO_TYPE)                                                     \

  V(ALLOCATION_MEMENTO_TYPE)                                                   \

  V(ALLOCATION_SITE_TYPE)                                                      \

  V(SCRIPT_TYPE)                                                               \

  V(CODE_CACHE_TYPE)                                                           \

  V(POLYMORPHIC_CODE_CACHE_TYPE)                                               \

  V(TYPE_FEEDBACK_INFO_TYPE)                                                   \

  V(ALIASED_ARGUMENTS_ENTRY_TYPE)                                              \

  V(BOX_TYPE)                                                                  \

                                                                               \

  V(FIXED_ARRAY_TYPE)                                                          \

  V(FIXED_DOUBLE_ARRAY_TYPE)                                                   \

  V(CONSTANT_POOL_ARRAY_TYPE)                                                  \

  V(SHARED_FUNCTION_INFO_TYPE)                                                 \

                                                                               \

  V(JS_MESSAGE_OBJECT_TYPE)                                                    \

                                                                               \

  V(JS_VALUE_TYPE)                                                             \

  V(JS_DATE_TYPE)                                                              \

  V(JS_OBJECT_TYPE)                                                            \

  V(JS_CONTEXT_EXTENSION_OBJECT_TYPE)                                          \

  V(JS_GENERATOR_OBJECT_TYPE)                                                  \

  V(JS_MODULE_TYPE)                                                            \

  V(JS_GLOBAL_OBJECT_TYPE)                                                     \

  V(JS_BUILTINS_OBJECT_TYPE)                                                   \

  V(JS_GLOBAL_PROXY_TYPE)                                                      \

  V(JS_ARRAY_TYPE)                                                             \

  V(JS_ARRAY_BUFFER_TYPE)                                                      \

  V(JS_TYPED_ARRAY_TYPE)                                                       \

  V(JS_DATA_VIEW_TYPE)                                                         \

  V(JS_PROXY_TYPE)                                                             \

  V(JS_SET_TYPE)                                                               \

  V(JS_MAP_TYPE)                                                               \

  V(JS_WEAK_MAP_TYPE)                                                          \

  V(JS_WEAK_SET_TYPE)                                                          \

  V(JS_REGEXP_TYPE)                                                            \

                                                                               \

  V(JS_FUNCTION_TYPE)                                                          \

  V(JS_FUNCTION_PROXY_TYPE)                                                    \

  V(DEBUG_INFO_TYPE)                                                           \

  V(BREAK_POINT_INFO_TYPE)

// Since string types are not consecutive, this macro is used to

// iterate over them.

#define STRING_TYPE_LIST(V)                                                    \

  V(STRING_TYPE,                                                               \

    kVariableSizeSentinel,                                                     \

    string,                                                                    \

    String)                                                                    \

  V(ASCII_STRING_TYPE,                                                         \

    kVariableSizeSentinel,                                                     \

    ascii_string,                                                              \

    AsciiString)                                                               \

  V(CONS_STRING_TYPE,                                                          \

    ConsString::kSize,                                                         \

    cons_string,                                                               \

    ConsString)                                                                \

  V(CONS_ASCII_STRING_TYPE,                                                    \

    ConsString::kSize,                                                         \

    cons_ascii_string,                                                         \

    ConsAsciiString)                                                           \

  V(SLICED_STRING_TYPE,                                                        \

    SlicedString::kSize,                                                       \

    sliced_string,                                                             \

    SlicedString)                                                              \

  V(SLICED_ASCII_STRING_TYPE,                                                  \

    SlicedString::kSize,                                                       \

    sliced_ascii_string,                                                       \

    SlicedAsciiString)                                                         \

  V(EXTERNAL_STRING_TYPE,                                                      \

    ExternalTwoByteString::kSize,                                              \

    external_string,                                                           \

    ExternalString)                                                            \

  V(EXTERNAL_ASCII_STRING_TYPE,                                                \

    ExternalAsciiString::kSize,                                                \

    external_ascii_string,                                                     \

    ExternalAsciiString)                                                       \

  V(EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE,                                   \

    ExternalTwoByteString::kSize,                                              \

    external_string_with_one_bytei_data,                                       \

    ExternalStringWithOneByteData)                                             \

  V(SHORT_EXTERNAL_STRING_TYPE,                                                \

    ExternalTwoByteString::kShortSize,                                         \

    short_external_string,                                                     \

    ShortExternalString)                                                       \

  V(SHORT_EXTERNAL_ASCII_STRING_TYPE,                                          \

    ExternalAsciiString::kShortSize,                                           \

    short_external_ascii_string,                                               \

    ShortExternalAsciiString)                                                  \

  V(SHORT_EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE,                             \

    ExternalTwoByteString::kShortSize,                                         \

    short_external_string_with_one_byte_data,                                  \

    ShortExternalStringWithOneByteData)                                        \

                                                                               \

  V(INTERNALIZED_STRING_TYPE,                                                  \

    kVariableSizeSentinel,                                                     \

    internalized_string,                                                       \

    InternalizedString)                                                        \

  V(ASCII_INTERNALIZED_STRING_TYPE,                                            \

    kVariableSizeSentinel,                                                     \

    ascii_internalized_string,                                                 \

    AsciiInternalizedString)                                                   \

  V(CONS_INTERNALIZED_STRING_TYPE,                                             \

    ConsString::kSize,                                                         \

    cons_internalized_string,                                                  \

    ConsInternalizedString)                                                    \

  V(CONS_ASCII_INTERNALIZED_STRING_TYPE,                                       \

    ConsString::kSize,                                                         \

    cons_ascii_internalized_string,                                            \

    ConsAsciiInternalizedString)                                               \

  V(EXTERNAL_INTERNALIZED_STRING_TYPE,                                         \

    ExternalTwoByteString::kSize,                                              \

    external_internalized_string,                                              \

    ExternalInternalizedString)                                                \

  V(EXTERNAL_ASCII_INTERNALIZED_STRING_TYPE,                                   \

    ExternalAsciiString::kSize,                                                \

    external_ascii_internalized_string,                                        \

    ExternalAsciiInternalizedString)                                           \

  V(EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE,                      \

    ExternalTwoByteString::kSize,                                              \

    external_internalized_string_with_one_byte_data,                           \

    ExternalInternalizedStringWithOneByteData)                                 \

  V(SHORT_EXTERNAL_INTERNALIZED_STRING_TYPE,                                   \

    ExternalTwoByteString::kShortSize,                                         \

    short_external_internalized_string,                                        \

    ShortExternalInternalizedString)                                           \

  V(SHORT_EXTERNAL_ASCII_INTERNALIZED_STRING_TYPE,                             \

    ExternalAsciiString::kShortSize,                                           \

    short_external_ascii_internalized_string,                                  \

    ShortExternalAsciiInternalizedString)                                      \

  V(SHORT_EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE,                \

    ExternalTwoByteString::kShortSize,                                         \

    short_external_internalized_string_with_one_byte_data,                     \

    ShortExternalInternalizedStringWithOneByteData)                            \

// A struct is a simple object a set of object-valued fields.  Including an

// object type in this causes the compiler to generate most of the boilerplate

// code for the class including allocation and garbage collection routines,

// casts and predicates.  All you need to define is the class, methods and

// object verification routines.  Easy, no?

//

// Note that for subtle reasons related to the ordering or numerical values of

// type tags, elements in this list have to be added to the INSTANCE_TYPE_LIST

// manually.

#define STRUCT_LIST_ALL(V)                                                     \

  V(BOX, Box, box)                                                             \

  V(DECLARED_ACCESSOR_DESCRIPTOR,                                              \

    DeclaredAccessorDescriptor,                                                \

    declared_accessor_descriptor)                                              \

  V(DECLARED_ACCESSOR_INFO, DeclaredAccessorInfo, declared_accessor_info)      \

  V(EXECUTABLE_ACCESSOR_INFO, ExecutableAccessorInfo, executable_accessor_info)\

  V(ACCESSOR_PAIR, AccessorPair, accessor_pair)                                \

  V(ACCESS_CHECK_INFO, AccessCheckInfo, access_check_info)                     \

  V(INTERCEPTOR_INFO, InterceptorInfo, interceptor_info)                       \

  V(CALL_HANDLER_INFO, CallHandlerInfo, call_handler_info)                     \

  V(FUNCTION_TEMPLATE_INFO, FunctionTemplateInfo, function_template_info)      \

  V(OBJECT_TEMPLATE_INFO, ObjectTemplateInfo, object_template_info)            \

  V(SIGNATURE_INFO, SignatureInfo, signature_info)                             \

  V(TYPE_SWITCH_INFO, TypeSwitchInfo, type_switch_info)                        \

  V(SCRIPT, Script, script)                                                    \

  V(ALLOCATION_SITE, AllocationSite, allocation_site)                          \

  V(ALLOCATION_MEMENTO, AllocationMemento, allocation_memento)                 \

  V(CODE_CACHE, CodeCache, code_cache)                                         \

  V(POLYMORPHIC_CODE_CACHE, PolymorphicCodeCache, polymorphic_code_cache)      \

  V(TYPE_FEEDBACK_INFO, TypeFeedbackInfo, type_feedback_info)                  \

  V(ALIASED_ARGUMENTS_ENTRY, AliasedArgumentsEntry, aliased_arguments_entry)

#ifdef ENABLE_DEBUGGER_SUPPORT

#define STRUCT_LIST_DEBUGGER(V)                                                \

  V(DEBUG_INFO, DebugInfo, debug_info)                                         \

  V(BREAK_POINT_INFO, BreakPointInfo, break_point_info)

#else

#define STRUCT_LIST_DEBUGGER(V)

#endif

#define STRUCT_LIST(V)                                                         \

  STRUCT_LIST_ALL(V)                                                           \

  STRUCT_LIST_DEBUGGER(V)

// We use the full 8 bits of the instance_type field to encode heap object

// instance types.  The high-order bit (bit 7) is set if the object is not a

// string, and cleared if it is a string.

const uint32_t kIsNotStringMask = 0x80;

const uint32_t kStringTag = 0x0;

const uint32_t kNotStringTag = 0x80;

// Bit 6 indicates that the object is an internalized string (if set) or not.

// Bit 7 has to be clear as well.

const uint32_t kIsNotInternalizedMask = 0x40;

const uint32_t kNotInternalizedTag = 0x40;

const uint32_t kInternalizedTag = 0x0;

// If bit 7 is clear then bit 2 indicates whether the string consists of

// two-byte characters or one-byte characters.

const uint32_t kStringEncodingMask = 0x4;

const uint32_t kTwoByteStringTag = 0x0;

const uint32_t kOneByteStringTag = 0x4;

// If bit 7 is clear, the low-order 2 bits indicate the representation

// of the string.

const uint32_t kStringRepresentationMask = 0x03;

enum StringRepresentationTag {

  kSeqStringTag = 0x0,

  kConsStringTag = 0x1,

  kExternalStringTag = 0x2,

  kSlicedStringTag = 0x3

};

const uint32_t kIsIndirectStringMask = 0x1;

const uint32_t kIsIndirectStringTag = 0x1;

STATIC_ASSERT((kSeqStringTag & kIsIndirectStringMask) == 0);

STATIC_ASSERT((kExternalStringTag & kIsIndirectStringMask) == 0);

STATIC_ASSERT(

    (kConsStringTag & kIsIndirectStringMask) == kIsIndirectStringTag);

STATIC_ASSERT(

    (kSlicedStringTag & kIsIndirectStringMask) == kIsIndirectStringTag);

// Use this mask to distinguish between cons and slice only after making

// sure that the string is one of the two (an indirect string).

const uint32_t kSlicedNotConsMask = kSlicedStringTag & ~kConsStringTag;

STATIC_ASSERT(IS_POWER_OF_TWO(kSlicedNotConsMask) && kSlicedNotConsMask != 0);

// If bit 7 is clear, then bit 3 indicates whether this two-byte

// string actually contains one byte data.

const uint32_t kOneByteDataHintMask = 0x08;

const uint32_t kOneByteDataHintTag = 0x08;

// If bit 7 is clear and string representation indicates an external string,

// then bit 4 indicates whether the data pointer is cached.

const uint32_t kShortExternalStringMask = 0x10;

const uint32_t kShortExternalStringTag = 0x10;

// A ConsString with an empty string as the right side is a candidate

// for being shortcut by the garbage collector unless it is internalized.

// It's not common to have non-flat internalized strings, so we do not

// shortcut them thereby avoiding turning internalized strings into strings.

// See heap.cc and mark-compact.cc.

const uint32_t kShortcutTypeMask =

    kIsNotStringMask |

    kIsNotInternalizedMask |

    kStringRepresentationMask;

const uint32_t kShortcutTypeTag = kConsStringTag | kNotInternalizedTag;

enum InstanceType {

  // String types.

  INTERNALIZED_STRING_TYPE = kTwoByteStringTag | kSeqStringTag

      | kInternalizedTag,

  ASCII_INTERNALIZED_STRING_TYPE = kOneByteStringTag | kSeqStringTag

      | kInternalizedTag,

  CONS_INTERNALIZED_STRING_TYPE = kTwoByteStringTag | kConsStringTag

      | kInternalizedTag,

  CONS_ASCII_INTERNALIZED_STRING_TYPE = kOneByteStringTag | kConsStringTag

      | kInternalizedTag,

  EXTERNAL_INTERNALIZED_STRING_TYPE = kTwoByteStringTag | kExternalStringTag

      | kInternalizedTag,

  EXTERNAL_ASCII_INTERNALIZED_STRING_TYPE = kOneByteStringTag

      | kExternalStringTag | kInternalizedTag,

  EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE =

      EXTERNAL_INTERNALIZED_STRING_TYPE | kOneByteDataHintTag

      | kInternalizedTag,

  SHORT_EXTERNAL_INTERNALIZED_STRING_TYPE =

      EXTERNAL_INTERNALIZED_STRING_TYPE | kShortExternalStringTag

      | kInternalizedTag,

  SHORT_EXTERNAL_ASCII_INTERNALIZED_STRING_TYPE =

      EXTERNAL_ASCII_INTERNALIZED_STRING_TYPE | kShortExternalStringTag

      | kInternalizedTag,

  SHORT_EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE =

      EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE

      | kShortExternalStringTag | kInternalizedTag,

  STRING_TYPE = INTERNALIZED_STRING_TYPE | kNotInternalizedTag,

  ASCII_STRING_TYPE = ASCII_INTERNALIZED_STRING_TYPE | kNotInternalizedTag,

  CONS_STRING_TYPE = CONS_INTERNALIZED_STRING_TYPE | kNotInternalizedTag,

  CONS_ASCII_STRING_TYPE =

      CONS_ASCII_INTERNALIZED_STRING_TYPE | kNotInternalizedTag,

  SLICED_STRING_TYPE =

      kTwoByteStringTag | kSlicedStringTag | kNotInternalizedTag,

  SLICED_ASCII_STRING_TYPE =

      kOneByteStringTag | kSlicedStringTag | kNotInternalizedTag,

  EXTERNAL_STRING_TYPE =

  EXTERNAL_INTERNALIZED_STRING_TYPE | kNotInternalizedTag,

  EXTERNAL_ASCII_STRING_TYPE =

  EXTERNAL_ASCII_INTERNALIZED_STRING_TYPE | kNotInternalizedTag,

  EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE =

      EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE

      | kNotInternalizedTag,

  SHORT_EXTERNAL_STRING_TYPE =

      SHORT_EXTERNAL_INTERNALIZED_STRING_TYPE | kNotInternalizedTag,

  SHORT_EXTERNAL_ASCII_STRING_TYPE =

      SHORT_EXTERNAL_ASCII_INTERNALIZED_STRING_TYPE | kNotInternalizedTag,

  SHORT_EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE =

      SHORT_EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE

      | kNotInternalizedTag,

  // Non-string names

  SYMBOL_TYPE = kNotStringTag,  // LAST_NAME_TYPE, FIRST_NONSTRING_TYPE

  // Objects allocated in their own spaces (never in new space).

  MAP_TYPE,

  CODE_TYPE,

  ODDBALL_TYPE,

  CELL_TYPE,

  PROPERTY_CELL_TYPE,

  // "Data", objects that cannot contain non-map-word pointers to heap

  // objects.

  HEAP_NUMBER_TYPE,

  FOREIGN_TYPE,

  BYTE_ARRAY_TYPE,

  FREE_SPACE_TYPE,

  EXTERNAL_BYTE_ARRAY_TYPE,  // FIRST_EXTERNAL_ARRAY_TYPE

  EXTERNAL_UNSIGNED_BYTE_ARRAY_TYPE,

  EXTERNAL_SHORT_ARRAY_TYPE,

  EXTERNAL_UNSIGNED_SHORT_ARRAY_TYPE,

  EXTERNAL_INT_ARRAY_TYPE,

  EXTERNAL_UNSIGNED_INT_ARRAY_TYPE,

  EXTERNAL_FLOAT_ARRAY_TYPE,

  EXTERNAL_DOUBLE_ARRAY_TYPE,

  EXTERNAL_PIXEL_ARRAY_TYPE,  // LAST_EXTERNAL_ARRAY_TYPE

  FIXED_DOUBLE_ARRAY_TYPE,

  CONSTANT_POOL_ARRAY_TYPE,

  FILLER_TYPE,  // LAST_DATA_TYPE

  // Structs.

  DECLARED_ACCESSOR_DESCRIPTOR_TYPE,

  DECLARED_ACCESSOR_INFO_TYPE,

  EXECUTABLE_ACCESSOR_INFO_TYPE,

  ACCESSOR_PAIR_TYPE,

  ACCESS_CHECK_INFO_TYPE,

  INTERCEPTOR_INFO_TYPE,

  CALL_HANDLER_INFO_TYPE,

  FUNCTION_TEMPLATE_INFO_TYPE,

  OBJECT_TEMPLATE_INFO_TYPE,

  SIGNATURE_INFO_TYPE,

  TYPE_SWITCH_INFO_TYPE,

  ALLOCATION_SITE_TYPE,

  ALLOCATION_MEMENTO_TYPE,

  SCRIPT_TYPE,

  CODE_CACHE_TYPE,

  POLYMORPHIC_CODE_CACHE_TYPE,

  TYPE_FEEDBACK_INFO_TYPE,

  ALIASED_ARGUMENTS_ENTRY_TYPE,

  BOX_TYPE,

  // The following two instance types are only used when ENABLE_DEBUGGER_SUPPORT

  // is defined. However as include/v8.h contain some of the instance type

  // constants always having them avoids them getting different numbers

  // depending on whether ENABLE_DEBUGGER_SUPPORT is defined or not.

  DEBUG_INFO_TYPE,

  BREAK_POINT_INFO_TYPE,

  FIXED_ARRAY_TYPE,

  SHARED_FUNCTION_INFO_TYPE,

  JS_MESSAGE_OBJECT_TYPE,

  // All the following types are subtypes of JSReceiver, which corresponds to

  // objects in the JS sense. The first and the last type in this range are

  // the two forms of function. This organization enables using the same

  // compares for checking the JS_RECEIVER/SPEC_OBJECT range and the

  // NONCALLABLE_JS_OBJECT range.

  JS_FUNCTION_PROXY_TYPE,  // FIRST_JS_RECEIVER_TYPE, FIRST_JS_PROXY_TYPE

  JS_PROXY_TYPE,  // LAST_JS_PROXY_TYPE

  JS_VALUE_TYPE,  // FIRST_JS_OBJECT_TYPE

  JS_DATE_TYPE,

  JS_OBJECT_TYPE,

  JS_CONTEXT_EXTENSION_OBJECT_TYPE,

  JS_GENERATOR_OBJECT_TYPE,

  JS_MODULE_TYPE,

  JS_GLOBAL_OBJECT_TYPE,

  JS_BUILTINS_OBJECT_TYPE,

  JS_GLOBAL_PROXY_TYPE,

  JS_ARRAY_TYPE,

  JS_ARRAY_BUFFER_TYPE,

  JS_TYPED_ARRAY_TYPE,

  JS_DATA_VIEW_TYPE,

  JS_SET_TYPE,

  JS_MAP_TYPE,

  JS_WEAK_MAP_TYPE,

  JS_WEAK_SET_TYPE,

  JS_REGEXP_TYPE,

  JS_FUNCTION_TYPE,  // LAST_JS_OBJECT_TYPE, LAST_JS_RECEIVER_TYPE

  // Pseudo-types

  FIRST_TYPE = 0x0,

  LAST_TYPE = JS_FUNCTION_TYPE,

  FIRST_NAME_TYPE = FIRST_TYPE,

  LAST_NAME_TYPE = SYMBOL_TYPE,

  FIRST_UNIQUE_NAME_TYPE = INTERNALIZED_STRING_TYPE,

  LAST_UNIQUE_NAME_TYPE = SYMBOL_TYPE,

  FIRST_NONSTRING_TYPE = SYMBOL_TYPE,

  // Boundaries for testing for an external array.

  FIRST_EXTERNAL_ARRAY_TYPE = EXTERNAL_BYTE_ARRAY_TYPE,

  LAST_EXTERNAL_ARRAY_TYPE = EXTERNAL_PIXEL_ARRAY_TYPE,

  // Boundary for promotion to old data space/old pointer space.

  LAST_DATA_TYPE = FILLER_TYPE,

  // Boundary for objects represented as JSReceiver (i.e. JSObject or JSProxy).

  // Note that there is no range for JSObject or JSProxy, since their subtypes

  // are not continuous in this enum! The enum ranges instead reflect the

  // external class names, where proxies are treated as either ordinary objects,

  // or functions.

  FIRST_JS_RECEIVER_TYPE = JS_FUNCTION_PROXY_TYPE,

  LAST_JS_RECEIVER_TYPE = LAST_TYPE,

  // Boundaries for testing the types represented as JSObject

  FIRST_JS_OBJECT_TYPE = JS_VALUE_TYPE,

  LAST_JS_OBJECT_TYPE = LAST_TYPE,

  // Boundaries for testing the types represented as JSProxy

  FIRST_JS_PROXY_TYPE = JS_FUNCTION_PROXY_TYPE,

  LAST_JS_PROXY_TYPE = JS_PROXY_TYPE,

  // Boundaries for testing whether the type is a JavaScript object.

  FIRST_SPEC_OBJECT_TYPE = FIRST_JS_RECEIVER_TYPE,

  LAST_SPEC_OBJECT_TYPE = LAST_JS_RECEIVER_TYPE,

  // Boundaries for testing the types for which typeof is "object".

  FIRST_NONCALLABLE_SPEC_OBJECT_TYPE = JS_PROXY_TYPE,

  LAST_NONCALLABLE_SPEC_OBJECT_TYPE = JS_REGEXP_TYPE,

  // Note that the types for which typeof is "function" are not continuous.

  // Define this so that we can put assertions on discrete checks.

  NUM_OF_CALLABLE_SPEC_OBJECT_TYPES = 2

};

const int kExternalArrayTypeCount =

    LAST_EXTERNAL_ARRAY_TYPE - FIRST_EXTERNAL_ARRAY_TYPE + 1;

STATIC_CHECK(JS_OBJECT_TYPE == Internals::kJSObjectType);

STATIC_CHECK(FIRST_NONSTRING_TYPE == Internals::kFirstNonstringType);

STATIC_CHECK(ODDBALL_TYPE == Internals::kOddballType);

STATIC_CHECK(FOREIGN_TYPE == Internals::kForeignType);

#define FIXED_ARRAY_SUB_INSTANCE_TYPE_LIST(V) \

  V(FAST_ELEMENTS_SUB_TYPE)                   \

  V(DICTIONARY_ELEMENTS_SUB_TYPE)             \

  V(FAST_PROPERTIES_SUB_TYPE)                 \

  V(DICTIONARY_PROPERTIES_SUB_TYPE)           \

  V(MAP_CODE_CACHE_SUB_TYPE)                  \

  V(SCOPE_INFO_SUB_TYPE)                      \

  V(STRING_TABLE_SUB_TYPE)                    \

  V(DESCRIPTOR_ARRAY_SUB_TYPE)                \

  V(TRANSITION_ARRAY_SUB_TYPE)

enum FixedArraySubInstanceType {

#define DEFINE_FIXED_ARRAY_SUB_INSTANCE_TYPE(name) name,

  FIXED_ARRAY_SUB_INSTANCE_TYPE_LIST(DEFINE_FIXED_ARRAY_SUB_INSTANCE_TYPE)

#undef DEFINE_FIXED_ARRAY_SUB_INSTANCE_TYPE

  LAST_FIXED_ARRAY_SUB_TYPE = TRANSITION_ARRAY_SUB_TYPE

};

enum CompareResult {

  LESS      = -1,

  EQUAL     =  0,

  GREATER   =  1,

  NOT_EQUAL = GREATER

};

#define DECL_BOOLEAN_ACCESSORS(name)   \

  inline bool name();                  \

  inline void set_##name(bool value);  \

#define DECL_ACCESSORS(name, type)                                      \

  inline type* name();                                                  \

  inline void set_##name(type* value,                                   \

                         WriteBarrierMode mode = UPDATE_WRITE_BARRIER); \

class AccessorPair;

class AllocationSite;

class AllocationSiteContext;

class DictionaryElementsAccessor;

class ElementsAccessor;

class Failure;

class FixedArrayBase;

class ObjectVisitor;

class StringStream;

class Type;

struct ValueInfo : public Malloced {

  ValueInfo() : type(FIRST_TYPE), ptr(NULL), str(NULL), number(0) { }

  InstanceType type;

  Object* ptr;

  const char* str;

  double number;

};

// A template-ized version of the IsXXX functions.

template <class C> inline bool Is(Object* obj);

#ifdef VERIFY_HEAP

#define DECLARE_VERIFIER(Name) void Name##Verify();

#else

#define DECLARE_VERIFIER(Name)

#endif

#ifdef OBJECT_PRINT

#define DECLARE_PRINTER(Name) void Name##Print(FILE* out = stdout);

#else

#define DECLARE_PRINTER(Name)

#endif

class MaybeObject BASE_EMBEDDED {

 public:

  inline bool IsFailure();

  inline bool IsRetryAfterGC();

  inline bool IsOutOfMemory();

  inline bool IsException();

  INLINE(bool IsTheHole());

  INLINE(bool IsUninitialized());

  inline bool ToObject(Object** obj) {

    if (IsFailure()) return false;

    *obj = reinterpret_cast<Object*>(this);

    return true;

  }

  inline Failure* ToFailureUnchecked() {

    ASSERT(IsFailure());

    return reinterpret_cast<Failure*>(this);

  }

  inline Object* ToObjectUnchecked() {

    // TODO(jkummerow): Turn this back into an ASSERT when we can be certain

    // that it never fires in Release mode in the wild.

    CHECK(!IsFailure());

    return reinterpret_cast<Object*>(this);

  }

  inline Object* ToObjectChecked() {

    CHECK(!IsFailure());

    return reinterpret_cast<Object*>(this);

  }

  template<typename T>

  inline bool To(T** obj) {

    if (IsFailure()) return false;

    *obj = T::cast(reinterpret_cast<Object*>(this));

    return true;

  }

  template<typename T>

    inline bool ToHandle(Handle<T>* obj, Isolate* isolate) {

    if (IsFailure()) return false;

    *obj = handle(T::cast(reinterpret_cast<Object*>(this)), isolate);

    return true;

  }

#ifdef OBJECT_PRINT

  // Prints this object with details.

  void Print();

  void Print(FILE* out);

  void PrintLn();

  void PrintLn(FILE* out);

#endif

#ifdef VERIFY_HEAP

  // Verifies the object.

  void Verify();

#endif

};

#define OBJECT_TYPE_LIST(V)                    \

  V(Smi)                                       \

  V(HeapObject)                                \

  V(Number)                                    \

#define HEAP_OBJECT_TYPE_LIST(V)               \

  V(HeapNumber)                                \

  V(Name)                                      \

  V(UniqueName)                                \

  V(String)                                    \

  V(SeqString)                                 \

  V(ExternalString)                            \

  V(ConsString)                                \

  V(SlicedString)                              \

  V(ExternalTwoByteString)                     \

  V(ExternalAsciiString)                       \

  V(SeqTwoByteString)                          \

  V(SeqOneByteString)                          \

  V(InternalizedString)                        \

  V(Symbol)                                    \

                                               \

  V(ExternalArray)                             \

  V(ExternalByteArray)                         \

  V(ExternalUnsignedByteArray)                 \

  V(ExternalShortArray)                        \

  V(ExternalUnsignedShortArray)                \

  V(ExternalIntArray)                          \

  V(ExternalUnsignedIntArray)                  \

  V(ExternalFloatArray)                        \

  V(ExternalDoubleArray)                       \

  V(ExternalPixelArray)                        \

  V(ByteArray)                                 \

  V(FreeSpace)                                 \

  V(JSReceiver)                                \

  V(JSObject)                                  \

  V(JSContextExtensionObject)                  \

  V(JSGeneratorObject)                         \

  V(JSModule)                                  \

  V(Map)                                       \

  V(DescriptorArray)                           \

  V(TransitionArray)                           \

  V(DeoptimizationInputData)                   \

  V(DeoptimizationOutputData)                  \

  V(DependentCode)                             \

  V(TypeFeedbackCells)                         \

  V(FixedArray)                                \

  V(FixedDoubleArray)                          \

  V(ConstantPoolArray)                         \

  V(Context)                                   \

  V(NativeContext)                             \

  V(ScopeInfo)                                 \

  V(JSFunction)                                \

  V(Code)                                      \

  V(Oddball)                                   \

  V(SharedFunctionInfo)                        \

  V(JSValue)                                   \

  V(JSDate)                                    \

  V(JSMessageObject)                           \

  V(StringWrapper)                             \

  V(Foreign)                                   \

  V(Boolean)                                   \

  V(JSArray)                                   \

  V(JSArrayBuffer)                             \

  V(JSArrayBufferView)                         \

  V(JSTypedArray)                              \

  V(JSDataView)                                \

  V(JSProxy)                                   \

  V(JSFunctionProxy)                           \

  V(JSSet)                                     \

  V(JSMap)                                     \

  V(JSWeakCollection)                          \

  V(JSWeakMap)                                 \

  V(JSWeakSet)                                 \

  V(JSRegExp)                                  \

  V(HashTable)                                 \

  V(Dictionary)                                \

  V(StringTable)                               \

  V(JSFunctionResultCache)                     \

  V(NormalizedMapCache)                        \

  V(CompilationCacheTable)                     \

  V(CodeCacheHashTable)                        \

  V(PolymorphicCodeCacheHashTable)             \

  V(MapCache)                                  \

  V(Primitive)                                 \

  V(GlobalObject)                              \

  V(JSGlobalObject)                            \

  V(JSBuiltinsObject)                          \

  V(JSGlobalProxy)                             \

  V(UndetectableObject)                        \

  V(AccessCheckNeeded)                         \

  V(Cell)                                      \

  V(PropertyCell)                              \

  V(ObjectHashTable)                           \

  V(WeakHashTable)

#define ERROR_MESSAGES_LIST(V) \

  V(kNoReason, "no reason")                                                   \

                                                                              \

  V(k32BitValueInRegisterIsNotZeroExtended,                                   \

    "32 bit value in register is not zero-extended")                          \

  V(kAlignmentMarkerExpected, "alignment marker expected")                    \

  V(kAllocationIsNotDoubleAligned, "Allocation is not double aligned")        \

  V(kAPICallReturnedInvalidObject, "API call returned invalid object")        \

  V(kArgumentsObjectValueInATestContext,                                      \

    "arguments object value in a test context")                               \

  V(kArrayBoilerplateCreationFailed, "array boilerplate creation failed")     \

  V(kArrayIndexConstantValueTooBig, "array index constant value too big")     \

  V(kAssignmentToArguments, "assignment to arguments")                        \

  V(kAssignmentToLetVariableBeforeInitialization,                             \

    "assignment to let variable before initialization")                       \

  V(kAssignmentToLOOKUPVariable, "assignment to LOOKUP variable")             \

  V(kAssignmentToParameterFunctionUsesArgumentsObject,                        \

    "assignment to parameter, function uses arguments object")                \

  V(kAssignmentToParameterInArgumentsObject,                                  \

    "assignment to parameter in arguments object")                            \

  V(kAttemptToUseUndefinedCache, "Attempt to use undefined cache")            \

  V(kBadValueContextForArgumentsObjectValue,                                  \

    "bad value context for arguments object value")                           \

  V(kBadValueContextForArgumentsValue,                                        \

    "bad value context for arguments value")                                  \

  V(kBailedOutDueToDependencyChange, "bailed out due to dependency change")   \

  V(kBailoutWasNotPrepared, "bailout was not prepared")                       \

  V(kBinaryStubGenerateFloatingPointCode,                                     \

    "BinaryStub_GenerateFloatingPointCode")                                   \

  V(kBothRegistersWereSmisInSelectNonSmi,                                     \

    "Both registers were smis in SelectNonSmi")                               \

  V(kCallToAJavaScriptRuntimeFunction,                                        \

    "call to a JavaScript runtime function")                                  \

  V(kCannotTranslatePositionInChangedArea,                                    \

    "Cannot translate position in changed area")                              \

  V(kCodeGenerationFailed, "code generation failed")                          \

  V(kCodeObjectNotProperlyPatched, "code object not properly patched")        \

  V(kCompoundAssignmentToLookupSlot, "compound assignment to lookup slot")    \

  V(kContextAllocatedArguments, "context-allocated arguments")                \

  V(kDebuggerIsActive, "debugger is active")                                  \

  V(kDebuggerStatement, "DebuggerStatement")                                  \

  V(kDeclarationInCatchContext, "Declaration in catch context")               \

  V(kDeclarationInWithContext, "Declaration in with context")                 \

  V(kDefaultNaNModeNotSet, "Default NaN mode not set")                        \

  V(kDeleteWithGlobalVariable, "delete with global variable")                 \

  V(kDeleteWithNonGlobalVariable, "delete with non-global variable")          \

  V(kDestinationOfCopyNotAligned, "Destination of copy not aligned")          \

  V(kDontDeleteCellsCannotContainTheHole,                                     \

    "DontDelete cells can't contain the hole")                                \

  V(kDoPushArgumentNotImplementedForDoubleType,                               \

    "DoPushArgument not implemented for double type")                         \

  V(kEmitLoadRegisterUnsupportedDoubleImmediate,                              \

    "EmitLoadRegister: Unsupported double immediate")                         \

  V(kEval, "eval")                                                            \

  V(kExpected0AsASmiSentinel, "Expected 0 as a Smi sentinel")                 \

  V(kExpectedAlignmentMarker, "expected alignment marker")                    \

  V(kExpectedAllocationSiteInCell,                                            \

    "Expected AllocationSite in property cell")                               \

  V(kExpectedPropertyCellInRegisterA2,                                        \

    "Expected property cell in register a2")                                  \

  V(kExpectedPropertyCellInRegisterEbx,                                       \

    "Expected property cell in register ebx")                                 \

  V(kExpectedPropertyCellInRegisterRbx,                                       \

    "Expected property cell in register rbx")                                 \

  V(kExpectingAlignmentForCopyBytes,                                          \

    "Expecting alignment for CopyBytes")                                      \

  V(kExportDeclaration, "Export declaration")                                 \

  V(kExternalStringExpectedButNotFound,                                       \

    "external string expected, but not found")                                \

  V(kFailedBailedOutLastTime, "failed/bailed out last time")                  \

  V(kForInStatementIsNotFastCase, "ForInStatement is not fast case")          \

  V(kForInStatementOptimizationIsDisabled,                                    \

    "ForInStatement optimization is disabled")                                \

  V(kForInStatementWithNonLocalEachVariable,                                  \

    "ForInStatement with non-local each variable")                            \

  V(kForOfStatement, "ForOfStatement")                                        \

  V(kFrameIsExpectedToBeAligned, "frame is expected to be aligned")           \

  V(kFunctionCallsEval, "function calls eval")                                \

  V(kFunctionIsAGenerator, "function is a generator")                         \

  V(kFunctionWithIllegalRedeclaration, "function with illegal redeclaration") \

  V(kGeneratedCodeIsTooLarge, "Generated code is too large")                  \

  V(kGeneratorFailedToResume, "Generator failed to resume")                   \

  V(kGenerator, "generator")                                                  \

  V(kGlobalFunctionsMustHaveInitialMap,                                       \

    "Global functions must have initial map")                                 \

  V(kHeapNumberMapRegisterClobbered, "HeapNumberMap register clobbered")      \

  V(kImportDeclaration, "Import declaration")                                 \

  V(kImproperObjectOnPrototypeChainForStore,                                  \

    "improper object on prototype chain for store")                           \

  V(kIndexIsNegative, "Index is negative")                                    \

  V(kIndexIsTooLarge, "Index is too large")                                   \

  V(kInlinedRuntimeFunctionClassOf, "inlined runtime function: ClassOf")      \

  V(kInlinedRuntimeFunctionFastAsciiArrayJoin,                                \

    "inlined runtime function: FastAsciiArrayJoin")                           \

  V(kInlinedRuntimeFunctionGeneratorNext,                                     \

    "inlined runtime function: GeneratorNext")                                \

  V(kInlinedRuntimeFunctionGeneratorThrow,                                    \

    "inlined runtime function: GeneratorThrow")                               \

  V(kInlinedRuntimeFunctionGetFromCache,                                      \

    "inlined runtime function: GetFromCache")                                 \

  V(kInlinedRuntimeFunctionIsNonNegativeSmi,                                  \

    "inlined runtime function: IsNonNegativeSmi")                             \

  V(kInlinedRuntimeFunctionIsRegExpEquivalent,                                \

    "inlined runtime function: IsRegExpEquivalent")                           \

  V(kInlinedRuntimeFunctionIsStringWrapperSafeForDefaultValueOf,              \

    "inlined runtime function: IsStringWrapperSafeForDefaultValueOf")         \

  V(kInliningBailedOut, "inlining bailed out")                                \

  V(kInputGPRIsExpectedToHaveUpper32Cleared,                                  \

    "input GPR is expected to have upper32 cleared")                          \

  V(kInstanceofStubUnexpectedCallSiteCacheCheck,                              \

    "InstanceofStub unexpected call site cache (check)")                      \

  V(kInstanceofStubUnexpectedCallSiteCacheCmp1,                               \

    "InstanceofStub unexpected call site cache (cmp 1)")                      \

  V(kInstanceofStubUnexpectedCallSiteCacheCmp2,                               \

    "InstanceofStub unexpected call site cache (cmp 2)")                      \

  V(kInstanceofStubUnexpectedCallSiteCacheMov,                                \

    "InstanceofStub unexpected call site cache (mov)")                        \

  V(kInteger32ToSmiFieldWritingToNonSmiLocation,                              \

    "Integer32ToSmiField writing to non-smi location")                        \

  V(kInvalidCaptureReferenced, "Invalid capture referenced")                  \

  V(kInvalidElementsKindForInternalArrayOrInternalPackedArray,                \

    "Invalid ElementsKind for InternalArray or InternalPackedArray")          \

  V(kInvalidHandleScopeLevel, "Invalid HandleScope level")                    \

  V(kInvalidLeftHandSideInAssignment, "invalid left-hand side in assignment") \

  V(kInvalidLhsInCompoundAssignment, "invalid lhs in compound assignment")    \

  V(kInvalidLhsInCountOperation, "invalid lhs in count operation")            \

  V(kInvalidMinLength, "Invalid min_length")                                  \

  V(kJSGlobalObjectNativeContextShouldBeANativeContext,                       \

    "JSGlobalObject::native_context should be a native context")              \

  V(kJSGlobalProxyContextShouldNotBeNull,                                     \

    "JSGlobalProxy::context() should not be null")                            \

  V(kJSObjectWithFastElementsMapHasSlowElements,                              \

    "JSObject with fast elements map has slow elements")                      \

  V(kLetBindingReInitialization, "Let binding re-initialization")             \

  V(kLiveBytesCountOverflowChunkSize, "Live Bytes Count overflow chunk size") \

  V(kLiveEditFrameDroppingIsNotSupportedOnArm,                                \

    "LiveEdit frame dropping is not supported on arm")                        \

  V(kLiveEditFrameDroppingIsNotSupportedOnMips,                               \

    "LiveEdit frame dropping is not supported on mips")                       \

  V(kLiveEdit, "LiveEdit")                                                    \

  V(kLookupVariableInCountOperation,                                          \

    "lookup variable in count operation")                                     \

  V(kMapIsNoLongerInEax, "Map is no longer in eax")                           \

  V(kModuleDeclaration, "Module declaration")                                 \

  V(kModuleLiteral, "Module literal")                                         \

  V(kModulePath, "Module path")                                               \

  V(kModuleStatement, "Module statement")                                     \

  V(kModuleVariable, "Module variable")                                       \

  V(kModuleUrl, "Module url")                                                 \

  V(kNativeFunctionLiteral, "Native function literal")                        \

  V(kNoCasesLeft, "no cases left")                                            \

  V(kNoEmptyArraysHereInEmitFastAsciiArrayJoin,                               \

    "No empty arrays here in EmitFastAsciiArrayJoin")                         \

  V(kNonInitializerAssignmentToConst,                                         \

    "non-initializer assignment to const")                                    \

  V(kNonSmiIndex, "Non-smi index")                                            \

  V(kNonSmiKeyInArrayLiteral, "Non-smi key in array literal")                 \

  V(kNonSmiValue, "Non-smi value")                                            \

  V(kNotEnoughVirtualRegistersForValues,                                      \

    "not enough virtual registers for values")                                \

  V(kNotEnoughSpillSlotsForOsr,                                               \

    "not enough spill slots for OSR")                                         \

  V(kNotEnoughVirtualRegistersRegalloc,                                       \

    "not enough virtual registers (regalloc)")                                \

  V(kObjectFoundInSmiOnlyArray, "object found in smi-only array")             \

  V(kObjectLiteralWithComplexProperty,                                        \

    "Object literal with complex property")                                   \

  V(kOddballInStringTableIsNotUndefinedOrTheHole,                             \

    "oddball in string table is not undefined or the hole")                   \

  V(kOperandIsASmiAndNotAName, "Operand is a smi and not a name")             \

  V(kOperandIsASmiAndNotAString, "Operand is a smi and not a string")         \

  V(kOperandIsASmi, "Operand is a smi")                                       \

  V(kOperandIsNotAName, "Operand is not a name")                              \

  V(kOperandIsNotANumber, "Operand is not a number")                          \

  V(kOperandIsNotASmi, "Operand is not a smi")                                \

  V(kOperandIsNotAString, "Operand is not a string")                          \

  V(kOperandIsNotSmi, "Operand is not smi")                                   \

  V(kOperandNotANumber, "Operand not a number")                               \

  V(kOptimizedTooManyTimes, "optimized too many times")                       \

  V(kOutOfVirtualRegistersWhileTryingToAllocateTempRegister,                  \

    "Out of virtual registers while trying to allocate temp register")        \

  V(kParseScopeError, "parse/scope error")                                    \

  V(kPossibleDirectCallToEval, "possible direct call to eval")                \

  V(kPropertyAllocationCountFailed, "Property allocation count failed")       \

  V(kReceivedInvalidReturnAddress, "Received invalid return address")         \

  V(kReferenceToAVariableWhichRequiresDynamicLookup,                          \

    "reference to a variable which requires dynamic lookup")                  \

  V(kReferenceToGlobalLexicalVariable,                                        \

    "reference to global lexical variable")                                   \

  V(kReferenceToUninitializedVariable, "reference to uninitialized variable") \

  V(kRegisterDidNotMatchExpectedRoot, "Register did not match expected root") \

  V(kRegisterWasClobbered, "register was clobbered")                          \

  V(kScopedBlock, "ScopedBlock")                                              \

  V(kSmiAdditionOverflow, "Smi addition overflow")                            \

  V(kSmiSubtractionOverflow, "Smi subtraction overflow")                      \

  V(kStackFrameTypesMustMatch, "stack frame types must match")                \

  V(kSwitchStatementMixedOrNonLiteralSwitchLabels,                            \

    "SwitchStatement: mixed or non-literal switch labels")                    \

  V(kSwitchStatementTooManyClauses, "SwitchStatement: too many clauses")      \

  V(kTheInstructionShouldBeALui, "The instruction should be a lui")           \

  V(kTheInstructionShouldBeAnOri, "The instruction should be an ori")         \

  V(kTheInstructionToPatchShouldBeALoadFromPc,                                \

    "The instruction to patch should be a load from pc")                      \

  V(kTheInstructionToPatchShouldBeALui,                                       \

    "The instruction to patch should be a lui")                               \

  V(kTheInstructionToPatchShouldBeAnOri,                                      \

    "The instruction to patch should be an ori")                              \

  V(kTooManyParametersLocals, "too many parameters/locals")                   \

  V(kTooManyParameters, "too many parameters")                                \

  V(kTooManySpillSlotsNeededForOSR, "Too many spill slots needed for OSR")    \

  V(kToOperandIsDoubleRegisterUnimplemented,                                  \

    "ToOperand IsDoubleRegister unimplemented")                               \

  V(kToOperandUnsupportedDoubleImmediate,                                     \

    "ToOperand Unsupported double immediate")                                 \

  V(kTryCatchStatement, "TryCatchStatement")                                  \

  V(kTryFinallyStatement, "TryFinallyStatement")                              \

  V(kUnableToEncodeValueAsSmi, "Unable to encode value as smi")               \

  V(kUnalignedAllocationInNewSpace, "Unaligned allocation in new space")      \

  V(kUndefinedValueNotLoaded, "Undefined value not loaded")                   \

  V(kUndoAllocationOfNonAllocatedMemory,                                      \

    "Undo allocation of non allocated memory")                                \

  V(kUnexpectedAllocationTop, "Unexpected allocation top")                    \

  V(kUnexpectedElementsKindInArrayConstructor,                                \

    "Unexpected ElementsKind in array constructor")                           \

  V(kUnexpectedFallthroughFromCharCodeAtSlowCase,                             \

    "Unexpected fallthrough from CharCodeAt slow case")                       \

  V(kUnexpectedFallthroughFromCharFromCodeSlowCase,                           \

    "Unexpected fallthrough from CharFromCode slow case")                     \

  V(kUnexpectedFallThroughFromStringComparison,                               \

    "Unexpected fall-through from string comparison")                         \

  V(kUnexpectedFallThroughInBinaryStubGenerateFloatingPointCode,              \

    "Unexpected fall-through in BinaryStub_GenerateFloatingPointCode")        \

  V(kUnexpectedFallthroughToCharCodeAtSlowCase,                               \

    "Unexpected fallthrough to CharCodeAt slow case")                         \

  V(kUnexpectedFallthroughToCharFromCodeSlowCase,                             \

    "Unexpected fallthrough to CharFromCode slow case")                       \

  V(kUnexpectedFPUStackDepthAfterInstruction,                                 \

    "Unexpected FPU stack depth after instruction")                           \

  V(kUnexpectedInitialMapForArrayFunction1,                                   \

    "Unexpected initial map for Array function (1)")                          \

  V(kUnexpectedInitialMapForArrayFunction2,                                   \

    "Unexpected initial map for Array function (2)")                          \

  V(kUnexpectedInitialMapForArrayFunction,                                    \

    "Unexpected initial map for Array function")                              \

  V(kUnexpectedInitialMapForInternalArrayFunction,                            \

    "Unexpected initial map for InternalArray function")                      \

  V(kUnexpectedLevelAfterReturnFromApiCall,                                   \

    "Unexpected level after return from api call")                            \

  V(kUnexpectedNumberOfPreAllocatedPropertyFields,                            \

    "Unexpected number of pre-allocated property fields")                     \

  V(kUnexpectedStringFunction, "Unexpected String function")                  \

  V(kUnexpectedStringType, "Unexpected string type")                          \

  V(kUnexpectedStringWrapperInstanceSize,                                     \

    "Unexpected string wrapper instance size")                                \

  V(kUnexpectedTypeForRegExpDataFixedArrayExpected,                           \

    "Unexpected type for RegExp data, FixedArray expected")                   \

  V(kUnexpectedUnusedPropertiesOfStringWrapper,                               \

    "Unexpected unused properties of string wrapper")                         \

  V(kUninitializedKSmiConstantRegister, "Uninitialized kSmiConstantRegister") \

  V(kUnknown, "unknown")                                                      \

  V(kUnsupportedConstCompoundAssignment,                                      \

    "unsupported const compound assignment")                                  \

  V(kUnsupportedCountOperationWithConst,                                      \

    "unsupported count operation with const")                                 \

  V(kUnsupportedDoubleImmediate, "unsupported double immediate")              \

  V(kUnsupportedLetCompoundAssignment, "unsupported let compound assignment") \

  V(kUnsupportedLookupSlotInDeclaration,                                      \

    "unsupported lookup slot in declaration")                                 \

  V(kUnsupportedNonPrimitiveCompare, "Unsupported non-primitive compare")     \

  V(kUnsupportedPhiUseOfArguments, "Unsupported phi use of arguments")        \

  V(kUnsupportedPhiUseOfConstVariable,                                        \

    "Unsupported phi use of const variable")                                  \

  V(kUnsupportedTaggedImmediate, "unsupported tagged immediate")              \

  V(kVariableResolvedToWithContext, "Variable resolved to with context")      \

  V(kWeShouldNotHaveAnEmptyLexicalContext,                                    \

    "we should not have an empty lexical context")                            \

  V(kWithStatement, "WithStatement")                                          \

  V(kWrongAddressOrValuePassedToRecordWrite,                                  \

    "Wrong address or value passed to RecordWrite")                           \