CSE2410 Fall 2014 Bounce

// Copyright 2006-2008 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 "builtins.h"

#include "code-stubs.h"

#include "smart-pointer.h"

#include "unicode-inl.h"

//

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

//

// Inheritance hierarchy:

//   - Object

//     - Smi          (immediate small integer)

//     - Failure      (immediate for marking failed operation)

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

//       - JSObject

//         - JSArray

//         - JSRegExp

//         - JSFunction

//         - GlobalObject

//           - JSGlobalObject

//           - JSBuiltinsObject

//         - JSGlobalProxy

//         - JSValue

//         - Script

//       - Array

//         - ByteArray

//         - FixedArray

//           - DescriptorArray

//           - HashTable

//             - Dictionary

//             - SymbolTable

//             - CompilationCacheTable

//             - MapCache

//             - LookupCache

//           - Context

//           - GlobalContext

//       - String

//         - SeqString

//           - SeqAsciiString

//           - SeqTwoByteString

//         - ConsString

//         - SlicedString

//         - ExternalString

//           - ExternalAsciiString

//           - ExternalTwoByteString

//       - HeapNumber

//       - Code

//       - Map

//       - Oddball

//       - Proxy

//       - SharedFunctionInfo

//       - Struct

//         - AccessorInfo

//         - AccessCheckInfo

//         - InterceptorInfo

//         - CallHandlerInfo

//         - FunctionTemplateInfo

//         - ObjectTemplateInfo

//         - SignatureInfo

//         - TypeSwitchInfo

//         - DebugInfo

//         - BreakPointInfo

//

// Formats of Object*:

//  Smi:        [31 bit signed int] 0

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

//  Failure:    [30 bit signed int] 11

// Ecma-262 3rd 8.6.1

enum PropertyAttributes {

  NONE              = v8::None,

  READ_ONLY         = v8::ReadOnly,

  DONT_ENUM         = v8::DontEnum,

  DONT_DELETE       = v8::DontDelete,

  ABSENT            = 16  // Used in runtime to indicate a property is absent.

  // ABSENT can never be stored in or returned from a descriptor's attributes

  // bitfield.  It is only used as a return value meaning the attributes of

  // a non-existent property.

};

namespace v8 { namespace internal {

// PropertyDetails captures type and attributes for a property.

// They are used both in property dictionaries and instance descriptors.

class PropertyDetails BASE_EMBEDDED {

 public:

  PropertyDetails(PropertyAttributes attributes,

                  PropertyType type,

                  int index = 0) {

    ASSERT(TypeField::is_valid(type));

    ASSERT(AttributesField::is_valid(attributes));

    ASSERT(IndexField::is_valid(index));

    value_ = TypeField::encode(type)

        | AttributesField::encode(attributes)

        | IndexField::encode(index);

    ASSERT(type == this->type());

    ASSERT(attributes == this->attributes());

    ASSERT(index == this->index());

  }

  // Conversion for storing details as Object*.

  inline PropertyDetails(Smi* smi);

  inline Smi* AsSmi();

  PropertyType type() { return TypeField::decode(value_); }

  bool IsTransition() {

    PropertyType t = type();

    ASSERT(t != INTERCEPTOR);

    return t == MAP_TRANSITION || t == CONSTANT_TRANSITION;

  }

  bool IsProperty() {

    return type() < FIRST_PHANTOM_PROPERTY_TYPE;

  }

  PropertyAttributes attributes() { return AttributesField::decode(value_); }

  int index() { return IndexField::decode(value_); }

  static bool IsValidIndex(int index) { return IndexField::is_valid(index); }

  bool IsReadOnly() { return (attributes() & READ_ONLY) != 0; }

  bool IsDontDelete() { return (attributes() & DONT_DELETE) != 0; }

  bool IsDontEnum() { return (attributes() & DONT_ENUM) != 0; }

  // Bit fields in value_ (type, shift, size). Must be public so the

  // constants can be embedded in generated code.

  class TypeField:       public BitField<PropertyType,       0, 3> {};

  class AttributesField: public BitField<PropertyAttributes, 3, 3> {};

  class IndexField:      public BitField<uint32_t,           6, 32-6> {};

  static const int kInitialIndex = 1;

 private:

  uint32_t value_;

};

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

enum WriteBarrierMode { SKIP_WRITE_BARRIER, UPDATE_WRITE_BARRIER };

// PropertyNormalizationMode is used to specify whether to keep

// inobject properties when normalizing properties of a JSObject.

enum PropertyNormalizationMode {

  CLEAR_INOBJECT_PROPERTIES,

  KEEP_INOBJECT_PROPERTIES

};

// 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 length

// (SHORT, MEDIUM, or LONG) is always mentioned.  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 (eg, CONS, SLICED, EXTERNAL) are explicitly mentioned.

// Finally, the string is either a SYMBOL_TYPE (if it is a symbol) or a

// STRING_TYPE (if it is not a symbol).

//

// 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(SHORT_SYMBOL_TYPE)                          \

  V(MEDIUM_SYMBOL_TYPE)                         \

  V(LONG_SYMBOL_TYPE)                           \

  V(SHORT_ASCII_SYMBOL_TYPE)                    \

  V(MEDIUM_ASCII_SYMBOL_TYPE)                   \

  V(LONG_ASCII_SYMBOL_TYPE)                     \

  V(SHORT_CONS_SYMBOL_TYPE)                     \

  V(MEDIUM_CONS_SYMBOL_TYPE)                    \

  V(LONG_CONS_SYMBOL_TYPE)                      \

  V(SHORT_CONS_ASCII_SYMBOL_TYPE)               \

  V(MEDIUM_CONS_ASCII_SYMBOL_TYPE)              \

  V(LONG_CONS_ASCII_SYMBOL_TYPE)                \

  V(SHORT_SLICED_SYMBOL_TYPE)                   \

  V(MEDIUM_SLICED_SYMBOL_TYPE)                  \

  V(LONG_SLICED_SYMBOL_TYPE)                    \

  V(SHORT_SLICED_ASCII_SYMBOL_TYPE)             \

  V(MEDIUM_SLICED_ASCII_SYMBOL_TYPE)            \

  V(LONG_SLICED_ASCII_SYMBOL_TYPE)              \

  V(SHORT_EXTERNAL_SYMBOL_TYPE)                 \

  V(MEDIUM_EXTERNAL_SYMBOL_TYPE)                \

  V(LONG_EXTERNAL_SYMBOL_TYPE)                  \

  V(SHORT_EXTERNAL_ASCII_SYMBOL_TYPE)           \

  V(MEDIUM_EXTERNAL_ASCII_SYMBOL_TYPE)          \

  V(LONG_EXTERNAL_ASCII_SYMBOL_TYPE)            \

  V(SHORT_STRING_TYPE)                          \

  V(MEDIUM_STRING_TYPE)                         \

  V(LONG_STRING_TYPE)                           \

  V(SHORT_ASCII_STRING_TYPE)                    \

  V(MEDIUM_ASCII_STRING_TYPE)                   \

  V(LONG_ASCII_STRING_TYPE)                     \

  V(SHORT_CONS_STRING_TYPE)                     \

  V(MEDIUM_CONS_STRING_TYPE)                    \

  V(LONG_CONS_STRING_TYPE)                      \

  V(SHORT_CONS_ASCII_STRING_TYPE)               \

  V(MEDIUM_CONS_ASCII_STRING_TYPE)              \

  V(LONG_CONS_ASCII_STRING_TYPE)                \

  V(SHORT_SLICED_STRING_TYPE)                   \

  V(MEDIUM_SLICED_STRING_TYPE)                  \

  V(LONG_SLICED_STRING_TYPE)                    \

  V(SHORT_SLICED_ASCII_STRING_TYPE)             \

  V(MEDIUM_SLICED_ASCII_STRING_TYPE)            \

  V(LONG_SLICED_ASCII_STRING_TYPE)              \

  V(SHORT_EXTERNAL_STRING_TYPE)                 \

  V(MEDIUM_EXTERNAL_STRING_TYPE)                \

  V(LONG_EXTERNAL_STRING_TYPE)                  \

  V(SHORT_EXTERNAL_ASCII_STRING_TYPE)           \

  V(MEDIUM_EXTERNAL_ASCII_STRING_TYPE)          \

  V(LONG_EXTERNAL_ASCII_STRING_TYPE)            \

  V(LONG_PRIVATE_EXTERNAL_ASCII_STRING_TYPE)    \

                                                \

  V(MAP_TYPE)                                   \

  V(HEAP_NUMBER_TYPE)                           \

  V(FIXED_ARRAY_TYPE)                           \

  V(CODE_TYPE)                                  \

  V(ODDBALL_TYPE)                               \

  V(PROXY_TYPE)                                 \

  V(BYTE_ARRAY_TYPE)                            \

  V(FILLER_TYPE)                                \

                                                \

  V(ACCESSOR_INFO_TYPE)                         \

  V(ACCESS_CHECK_INFO_TYPE)                     \

  V(INTERCEPTOR_INFO_TYPE)                      \

  V(SHARED_FUNCTION_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(DEBUG_INFO_TYPE)                            \

  V(BREAK_POINT_INFO_TYPE)                      \

  V(SCRIPT_TYPE)                                \

                                                \

  V(JS_VALUE_TYPE)                              \

  V(JS_OBJECT_TYPE)                             \

  V(JS_CONTEXT_EXTENSION_OBJECT_TYPE)           \

  V(JS_GLOBAL_OBJECT_TYPE)                      \

  V(JS_BUILTINS_OBJECT_TYPE)                    \

  V(JS_GLOBAL_PROXY_TYPE)                       \

  V(JS_ARRAY_TYPE)                              \

  V(JS_REGEXP_TYPE)                             \

                                                \

  V(JS_FUNCTION_TYPE)                           \

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

// iterate over them.

#define STRING_TYPE_LIST(V)                                                    \

  V(SHORT_SYMBOL_TYPE, SeqTwoByteString::kHeaderSize, short_symbol)            \

  V(MEDIUM_SYMBOL_TYPE, SeqTwoByteString::kHeaderSize, medium_symbol)          \

  V(LONG_SYMBOL_TYPE, SeqTwoByteString::kHeaderSize, long_symbol)              \

  V(SHORT_ASCII_SYMBOL_TYPE, SeqAsciiString::kHeaderSize, short_ascii_symbol)  \

  V(MEDIUM_ASCII_SYMBOL_TYPE, SeqAsciiString::kHeaderSize, medium_ascii_symbol)\

  V(LONG_ASCII_SYMBOL_TYPE, SeqAsciiString::kHeaderSize, long_ascii_symbol)    \

  V(SHORT_CONS_SYMBOL_TYPE, ConsString::kSize, short_cons_symbol)              \

  V(MEDIUM_CONS_SYMBOL_TYPE, ConsString::kSize, medium_cons_symbol)            \

  V(LONG_CONS_SYMBOL_TYPE, ConsString::kSize, long_cons_symbol)                \

  V(SHORT_CONS_ASCII_SYMBOL_TYPE, ConsString::kSize, short_cons_ascii_symbol)  \

  V(MEDIUM_CONS_ASCII_SYMBOL_TYPE, ConsString::kSize, medium_cons_ascii_symbol)\

  V(LONG_CONS_ASCII_SYMBOL_TYPE, ConsString::kSize, long_cons_ascii_symbol)    \

  V(SHORT_SLICED_SYMBOL_TYPE, SlicedString::kSize, short_sliced_symbol)        \

  V(MEDIUM_SLICED_SYMBOL_TYPE, SlicedString::kSize, medium_sliced_symbol)      \

  V(LONG_SLICED_SYMBOL_TYPE, SlicedString::kSize, long_sliced_symbol)          \

  V(SHORT_SLICED_ASCII_SYMBOL_TYPE,                                            \

    SlicedString::kSize,                                                       \

    short_sliced_ascii_symbol)                                                 \

  V(MEDIUM_SLICED_ASCII_SYMBOL_TYPE,                                           \

    SlicedString::kSize,                                                       \

    medium_sliced_ascii_symbol)                                                \

  V(LONG_SLICED_ASCII_SYMBOL_TYPE,                                             \

    SlicedString::kSize,                                                       \

    long_sliced_ascii_symbol)                                                  \

  V(SHORT_EXTERNAL_SYMBOL_TYPE,                                                \

    ExternalTwoByteString::kSize,                                              \

    short_external_symbol)                                                     \

  V(MEDIUM_EXTERNAL_SYMBOL_TYPE,                                               \

    ExternalTwoByteString::kSize,                                              \

    medium_external_symbol)                                                    \

  V(LONG_EXTERNAL_SYMBOL_TYPE,                                                 \

    ExternalTwoByteString::kSize,                                              \

    long_external_symbol)                                                      \

  V(SHORT_EXTERNAL_ASCII_SYMBOL_TYPE,                                          \

    ExternalAsciiString::kSize,                                                \

    short_external_ascii_symbol)                                               \

  V(MEDIUM_EXTERNAL_ASCII_SYMBOL_TYPE,                                         \

    ExternalAsciiString::kSize,                                                \

    medium_external_ascii_symbol)                                              \

  V(LONG_EXTERNAL_ASCII_SYMBOL_TYPE,                                           \

    ExternalAsciiString::kSize,                                                \

    long_external_ascii_symbol)                                                \

  V(SHORT_STRING_TYPE, SeqTwoByteString::kHeaderSize, short_string)            \

  V(MEDIUM_STRING_TYPE, SeqTwoByteString::kHeaderSize, medium_string)          \

  V(LONG_STRING_TYPE, SeqTwoByteString::kHeaderSize, long_string)              \

  V(SHORT_ASCII_STRING_TYPE, SeqAsciiString::kHeaderSize, short_ascii_string)  \

  V(MEDIUM_ASCII_STRING_TYPE, SeqAsciiString::kHeaderSize, medium_ascii_string)\

  V(LONG_ASCII_STRING_TYPE, SeqAsciiString::kHeaderSize, long_ascii_string)    \

  V(SHORT_CONS_STRING_TYPE, ConsString::kSize, short_cons_string)              \

  V(MEDIUM_CONS_STRING_TYPE, ConsString::kSize, medium_cons_string)            \

  V(LONG_CONS_STRING_TYPE, ConsString::kSize, long_cons_string)                \

  V(SHORT_CONS_ASCII_STRING_TYPE, ConsString::kSize, short_cons_ascii_string)  \

  V(MEDIUM_CONS_ASCII_STRING_TYPE, ConsString::kSize, medium_cons_ascii_string)\

  V(LONG_CONS_ASCII_STRING_TYPE, ConsString::kSize, long_cons_ascii_string)    \

  V(SHORT_SLICED_STRING_TYPE, SlicedString::kSize, short_sliced_string)        \

  V(MEDIUM_SLICED_STRING_TYPE, SlicedString::kSize, medium_sliced_string)      \

  V(LONG_SLICED_STRING_TYPE, SlicedString::kSize, long_sliced_string)          \

  V(SHORT_SLICED_ASCII_STRING_TYPE,                                            \

    SlicedString::kSize,                                                       \

    short_sliced_ascii_string)                                                 \

  V(MEDIUM_SLICED_ASCII_STRING_TYPE,                                           \

    SlicedString::kSize,                                                       \

    medium_sliced_ascii_string)                                                \

  V(LONG_SLICED_ASCII_STRING_TYPE,                                             \

    SlicedString::kSize,                                                       \

    long_sliced_ascii_string)                                                  \

  V(SHORT_EXTERNAL_STRING_TYPE,                                                \

    ExternalTwoByteString::kSize,                                              \

    short_external_string)                                                     \

  V(MEDIUM_EXTERNAL_STRING_TYPE,                                               \

    ExternalTwoByteString::kSize,                                              \

    medium_external_string)                                                    \

  V(LONG_EXTERNAL_STRING_TYPE,                                                 \

    ExternalTwoByteString::kSize,                                              \

    long_external_string)                                                      \

  V(SHORT_EXTERNAL_ASCII_STRING_TYPE,                                          \

    ExternalAsciiString::kSize,                                                \

    short_external_ascii_string)                                               \

  V(MEDIUM_EXTERNAL_ASCII_STRING_TYPE,                                         \

    ExternalAsciiString::kSize,                                                \

    medium_external_ascii_string)                                              \

  V(LONG_EXTERNAL_ASCII_STRING_TYPE,                                           \

    ExternalAsciiString::kSize,                                                \

    long_external_ascii_string)

// 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(V)                                                    \

  V(ACCESSOR_INFO, AccessorInfo, accessor_info)                           \

  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(DEBUG_INFO, DebugInfo, debug_info)                                    \

  V(BREAK_POINT_INFO, BreakPointInfo, break_point_info)                   \

  V(SCRIPT, Script, script)

// 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;

// If bit 7 is clear, bit 5 indicates that the string is a symbol (if set) or

// not (if cleared).

const uint32_t kIsSymbolMask = 0x20;

const uint32_t kNotSymbolTag = 0x0;

const uint32_t kSymbolTag = 0x20;

// If bit 7 is clear, bits 3 and 4 are the string's size (short, medium or

// long).  These values are very special in that they are also used to shift

// the length field to get the length, removing the hash value.  This avoids

// using if or switch when getting the length of a string.

const uint32_t kStringSizeMask = 0x18;

const uint32_t kShortStringTag = 0x18;

const uint32_t kMediumStringTag = 0x10;

const uint32_t kLongStringTag = 0x00;

// 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 kAsciiStringTag = 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,

  kSlicedStringTag = 0x2,

  kExternalStringTag = 0x3

};

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

// for being shortcut by the garbage collector unless it is a

// symbol. It's not common to have non-flat symbols, so we do not

// shortcut them thereby avoiding turning symbols into strings. See

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

const uint32_t kShortcutTypeMask =

    kIsNotStringMask |

    kIsSymbolMask |

    kStringRepresentationMask;

const uint32_t kShortcutTypeTag = kConsStringTag;

enum InstanceType {

  SHORT_SYMBOL_TYPE = kShortStringTag | kSymbolTag | kSeqStringTag,

  MEDIUM_SYMBOL_TYPE = kMediumStringTag | kSymbolTag | kSeqStringTag,

  LONG_SYMBOL_TYPE = kLongStringTag | kSymbolTag | kSeqStringTag,

  SHORT_ASCII_SYMBOL_TYPE =

      kShortStringTag | kAsciiStringTag | kSymbolTag | kSeqStringTag,

  MEDIUM_ASCII_SYMBOL_TYPE =

      kMediumStringTag | kAsciiStringTag | kSymbolTag | kSeqStringTag,

  LONG_ASCII_SYMBOL_TYPE =

      kLongStringTag | kAsciiStringTag | kSymbolTag | kSeqStringTag,

  SHORT_CONS_SYMBOL_TYPE = kShortStringTag | kSymbolTag | kConsStringTag,

  MEDIUM_CONS_SYMBOL_TYPE = kMediumStringTag | kSymbolTag | kConsStringTag,

  LONG_CONS_SYMBOL_TYPE = kLongStringTag | kSymbolTag | kConsStringTag,

  SHORT_CONS_ASCII_SYMBOL_TYPE =

      kShortStringTag | kAsciiStringTag | kSymbolTag | kConsStringTag,

  MEDIUM_CONS_ASCII_SYMBOL_TYPE =

      kMediumStringTag | kAsciiStringTag | kSymbolTag | kConsStringTag,

  LONG_CONS_ASCII_SYMBOL_TYPE =

      kLongStringTag | kAsciiStringTag | kSymbolTag | kConsStringTag,

  SHORT_SLICED_SYMBOL_TYPE = kShortStringTag | kSymbolTag | kSlicedStringTag,

  MEDIUM_SLICED_SYMBOL_TYPE = kMediumStringTag | kSymbolTag | kSlicedStringTag,

  LONG_SLICED_SYMBOL_TYPE = kLongStringTag | kSymbolTag | kSlicedStringTag,

  SHORT_SLICED_ASCII_SYMBOL_TYPE =

      kShortStringTag | kAsciiStringTag | kSymbolTag | kSlicedStringTag,

  MEDIUM_SLICED_ASCII_SYMBOL_TYPE =

      kMediumStringTag | kAsciiStringTag | kSymbolTag | kSlicedStringTag,

  LONG_SLICED_ASCII_SYMBOL_TYPE =

      kLongStringTag | kAsciiStringTag | kSymbolTag | kSlicedStringTag,

  SHORT_EXTERNAL_SYMBOL_TYPE =

      kShortStringTag | kSymbolTag | kExternalStringTag,

  MEDIUM_EXTERNAL_SYMBOL_TYPE =

      kMediumStringTag | kSymbolTag | kExternalStringTag,

  LONG_EXTERNAL_SYMBOL_TYPE = kLongStringTag | kSymbolTag | kExternalStringTag,

  SHORT_EXTERNAL_ASCII_SYMBOL_TYPE =

      kShortStringTag | kAsciiStringTag | kSymbolTag | kExternalStringTag,

  MEDIUM_EXTERNAL_ASCII_SYMBOL_TYPE =

      kMediumStringTag | kAsciiStringTag | kSymbolTag | kExternalStringTag,

  LONG_EXTERNAL_ASCII_SYMBOL_TYPE =

      kLongStringTag | kAsciiStringTag | kSymbolTag | kExternalStringTag,

  SHORT_STRING_TYPE = kShortStringTag | kSeqStringTag,

  MEDIUM_STRING_TYPE = kMediumStringTag | kSeqStringTag,

  LONG_STRING_TYPE = kLongStringTag | kSeqStringTag,

  SHORT_ASCII_STRING_TYPE = kShortStringTag | kAsciiStringTag | kSeqStringTag,

  MEDIUM_ASCII_STRING_TYPE = kMediumStringTag | kAsciiStringTag | kSeqStringTag,

  LONG_ASCII_STRING_TYPE = kLongStringTag | kAsciiStringTag | kSeqStringTag,

  SHORT_CONS_STRING_TYPE = kShortStringTag | kConsStringTag,

  MEDIUM_CONS_STRING_TYPE = kMediumStringTag | kConsStringTag,

  LONG_CONS_STRING_TYPE = kLongStringTag | kConsStringTag,

  SHORT_CONS_ASCII_STRING_TYPE =

      kShortStringTag | kAsciiStringTag | kConsStringTag,

  MEDIUM_CONS_ASCII_STRING_TYPE =

      kMediumStringTag | kAsciiStringTag | kConsStringTag,

  LONG_CONS_ASCII_STRING_TYPE =

      kLongStringTag | kAsciiStringTag | kConsStringTag,

  SHORT_SLICED_STRING_TYPE = kShortStringTag | kSlicedStringTag,

  MEDIUM_SLICED_STRING_TYPE = kMediumStringTag | kSlicedStringTag,

  LONG_SLICED_STRING_TYPE = kLongStringTag | kSlicedStringTag,

  SHORT_SLICED_ASCII_STRING_TYPE =

      kShortStringTag | kAsciiStringTag | kSlicedStringTag,

  MEDIUM_SLICED_ASCII_STRING_TYPE =

      kMediumStringTag | kAsciiStringTag | kSlicedStringTag,

  LONG_SLICED_ASCII_STRING_TYPE =

      kLongStringTag | kAsciiStringTag | kSlicedStringTag,

  SHORT_EXTERNAL_STRING_TYPE = kShortStringTag | kExternalStringTag,

  MEDIUM_EXTERNAL_STRING_TYPE = kMediumStringTag | kExternalStringTag,

  LONG_EXTERNAL_STRING_TYPE = kLongStringTag | kExternalStringTag,

  SHORT_EXTERNAL_ASCII_STRING_TYPE =

      kShortStringTag | kAsciiStringTag | kExternalStringTag,

  MEDIUM_EXTERNAL_ASCII_STRING_TYPE =

      kMediumStringTag | kAsciiStringTag | kExternalStringTag,

  LONG_EXTERNAL_ASCII_STRING_TYPE =

      kLongStringTag | kAsciiStringTag | kExternalStringTag,

  LONG_PRIVATE_EXTERNAL_ASCII_STRING_TYPE = LONG_EXTERNAL_ASCII_STRING_TYPE,

  MAP_TYPE = kNotStringTag,

  HEAP_NUMBER_TYPE,

  FIXED_ARRAY_TYPE,

  CODE_TYPE,

  ODDBALL_TYPE,

  PROXY_TYPE,

  BYTE_ARRAY_TYPE,

  FILLER_TYPE,

  SMI_TYPE,

  ACCESSOR_INFO_TYPE,

  ACCESS_CHECK_INFO_TYPE,

  INTERCEPTOR_INFO_TYPE,

  SHARED_FUNCTION_INFO_TYPE,

  CALL_HANDLER_INFO_TYPE,

  FUNCTION_TEMPLATE_INFO_TYPE,

  OBJECT_TEMPLATE_INFO_TYPE,

  SIGNATURE_INFO_TYPE,

  TYPE_SWITCH_INFO_TYPE,

  DEBUG_INFO_TYPE,

  BREAK_POINT_INFO_TYPE,

  SCRIPT_TYPE,

  JS_VALUE_TYPE,

  JS_OBJECT_TYPE,

  JS_CONTEXT_EXTENSION_OBJECT_TYPE,

  JS_GLOBAL_OBJECT_TYPE,

  JS_BUILTINS_OBJECT_TYPE,

  JS_GLOBAL_PROXY_TYPE,

  JS_ARRAY_TYPE,

  JS_REGEXP_TYPE,

  JS_FUNCTION_TYPE,

  // Pseudo-types

  FIRST_NONSTRING_TYPE = MAP_TYPE,

  FIRST_TYPE = 0x0,

  INVALID_TYPE = FIRST_TYPE - 1,

  LAST_TYPE = JS_FUNCTION_TYPE,

  // Boundaries for testing the type is a JavaScript "object".  Note that

  // function objects are not counted as objects, even though they are

  // implemented as such; only values whose typeof is "object" are included.

  FIRST_JS_OBJECT_TYPE = JS_VALUE_TYPE,

  LAST_JS_OBJECT_TYPE = JS_REGEXP_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 StringStream;

class ObjectVisitor;

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> static inline bool Is(Object* obj);

// Object is the abstract superclass for all classes in the

// object hierarchy.

// Object does not use any virtual functions to avoid the

// allocation of the C++ vtable.

// Since Smi and Failure are subclasses of Object no

// data members can be present in Object.

class Object BASE_EMBEDDED {

 public:

  // Type testing.

  inline bool IsSmi();

  inline bool IsHeapObject();

  inline bool IsHeapNumber();

  inline bool IsString();

  inline bool IsSymbol();

  inline bool IsSeqString();

  inline bool IsSlicedString();

  inline bool IsExternalString();

  inline bool IsConsString();

  inline bool IsExternalTwoByteString();

  inline bool IsExternalAsciiString();

  inline bool IsSeqTwoByteString();

  inline bool IsSeqAsciiString();

  inline bool IsNumber();

  inline bool IsByteArray();

  inline bool IsFailure();

  inline bool IsRetryAfterGC();

  inline bool IsOutOfMemoryFailure();

  inline bool IsException();

  inline bool IsJSObject();

  inline bool IsJSContextExtensionObject();

  inline bool IsMap();

  inline bool IsFixedArray();

  inline bool IsDescriptorArray();

  inline bool IsContext();

  inline bool IsCatchContext();

  inline bool IsGlobalContext();

  inline bool IsJSFunction();

  inline bool IsCode();

  inline bool IsOddball();

  inline bool IsSharedFunctionInfo();

  inline bool IsJSValue();

  inline bool IsStringWrapper();

  inline bool IsProxy();

  inline bool IsBoolean();

  inline bool IsJSArray();

  inline bool IsJSRegExp();

  inline bool IsHashTable();

  inline bool IsDictionary();

  inline bool IsSymbolTable();

  inline bool IsCompilationCacheTable();

  inline bool IsMapCache();

  inline bool IsLookupCache();

  inline bool IsPrimitive();

  inline bool IsGlobalObject();

  inline bool IsJSGlobalObject();

  inline bool IsJSBuiltinsObject();

  inline bool IsJSGlobalProxy();

  inline bool IsUndetectableObject();

  inline bool IsAccessCheckNeeded();

  // Returns true if this object is an instance of the specified

  // function template.

  bool IsInstanceOf(FunctionTemplateInfo* type);

  inline bool IsStruct();

#define DECLARE_STRUCT_PREDICATE(NAME, Name, name) inline bool Is##Name();

  STRUCT_LIST(DECLARE_STRUCT_PREDICATE)

#undef DECLARE_STRUCT_PREDICATE

  // Oddball testing.

  INLINE(bool IsUndefined());

  INLINE(bool IsTheHole());

  INLINE(bool IsNull());

  INLINE(bool IsTrue());

  INLINE(bool IsFalse());

  // Extract the number.

  inline double Number();

  inline bool HasSpecificClassOf(String* name);

  Object* ToObject();             // ECMA-262 9.9.

  Object* ToBoolean();            // ECMA-262 9.2.

  // Convert to a JSObject if needed.

  // global_context is used when creating wrapper object.

  Object* ToObject(Context* global_context);

  // Converts this to a Smi if possible.

  // Failure is returned otherwise.

  inline Object* ToSmi();

  void Lookup(String* name, LookupResult* result);

  // Property access.

  inline Object* GetProperty(String* key);

  inline Object* GetProperty(String* key, PropertyAttributes* attributes);

  Object* GetPropertyWithReceiver(Object* receiver,

                                  String* key,

                                  PropertyAttributes* attributes);

  Object* GetProperty(Object* receiver,

                      LookupResult* result,

                      String* key,

                      PropertyAttributes* attributes);

  Object* GetPropertyWithCallback(Object* receiver,

                                  Object* structure,

                                  String* name,

                                  Object* holder);

  Object* GetPropertyWithDefinedGetter(Object* receiver,

                                       JSFunction* getter);

  inline Object* GetElement(uint32_t index);

  Object* GetElementWithReceiver(Object* receiver, uint32_t index);

  // Return the object's prototype (might be Heap::null_value()).

  Object* GetPrototype();

  // Returns true if this is a JSValue containing a string and the index is

  // < the length of the string.  Used to implement [] on strings.

  inline bool IsStringObjectWithCharacterAt(uint32_t index);

#ifdef DEBUG

  // Prints this object with details.

  void Print();

  void PrintLn();

  // Verifies the object.

  void Verify();

  // Verify a pointer is a valid object pointer.

  static void VerifyPointer(Object* p);

#endif

  // Prints this object without details.

  void ShortPrint();

  // Prints this object without details to a message accumulator.

  void ShortPrint(StringStream* accumulator);

  // Casting: This cast is only needed to satisfy macros in objects-inl.h.

  static Object* cast(Object* value) { return value; }

  // Layout description.

  static const int kHeaderSize = 0;  // Object does not take up any space.

 private:

  DISALLOW_IMPLICIT_CONSTRUCTORS(Object);

};

// Smi represents integer Numbers that can be stored in 31 bits.

// Smis are immediate which means they are NOT allocated in the heap.

// The this pointer has the following format: [31 bit signed int] 0

// Smi stands for small integer.

class Smi: public Object {

 public:

  // Returns the integer value.

  inline int value();

  // Convert a value to a Smi object.

  static inline Smi* FromInt(int value);

  // Returns whether value can be represented in a Smi.

  static inline bool IsValid(int value);

  // Casting.

  static inline Smi* cast(Object* object);

  // Dispatched behavior.

  void SmiPrint();

  void SmiPrint(StringStream* accumulator);

#ifdef DEBUG

  void SmiVerify();

#endif

  // Min and max limits for Smi values.

  static const int kMinValue = -(1 << (kBitsPerPointer - (kSmiTagSize + 1)));

  static const int kMaxValue = (1 << (kBitsPerPointer - (kSmiTagSize + 1))) - 1;

 private:

  DISALLOW_IMPLICIT_CONSTRUCTORS(Smi);

};

// Failure is used for reporting out of memory situations and

// propagating exceptions through the runtime system.  Failure objects

// are transient and cannot occur as part of the objects graph.

//

// Failures are a single word, encoded as follows:

// +-------------------------+---+--+--+

// |rrrrrrrrrrrrrrrrrrrrrrrrr|sss|tt|11|

// +-------------------------+---+--+--+

//

// The low two bits, 0-1, are the failure tag, 11.  The next two bits,

// 2-3, are a failure type tag 'tt' with possible values:

//   00 RETRY_AFTER_GC

//   01 EXCEPTION

//   10 INTERNAL_ERROR

//   11 OUT_OF_MEMORY_EXCEPTION

//

// The next three bits, 4-6, are an allocation space tag 'sss'.  The

// allocation space tag is 000 for all failure types except

// RETRY_AFTER_GC.  For RETRY_AFTER_GC, the possible values are

// (the encoding is found in globals.h):

//   000 NEW_SPACE

//   001 OLD_SPACE

//   010 CODE_SPACE

//   011 MAP_SPACE

//   100 LO_SPACE

//

// The remaining bits is the number of words requested by the

// allocation request that failed, and is zeroed except for

// RETRY_AFTER_GC failures.  The 25 bits (on a 32 bit platform) gives

// a representable range of 2^27 bytes (128MB).

// Failure type tag info.

const int kFailureTypeTagSize = 2;

const int kFailureTypeTagMask = (1 << kFailureTypeTagSize) - 1;

class Failure: public Object {

 public:

  // RuntimeStubs assumes EXCEPTION = 1 in the compiler-generated code.

  enum Type {

    RETRY_AFTER_GC = 0,

    EXCEPTION = 1,       // Returning this marker tells the real exception

                         // is in Top::pending_exception.

    INTERNAL_ERROR = 2,

    OUT_OF_MEMORY_EXCEPTION = 3

  };

  inline Type type() const;

  // Returns the space that needs to be collected for RetryAfterGC failures.

  inline AllocationSpace allocation_space() const;

  // Returns the number of bytes requested (up to the representable maximum)

  // for RetryAfterGC failures.

  inline int requested() const;

  inline bool IsInternalError() const;

  inline bool IsOutOfMemoryException() const;

  static Failure* RetryAfterGC(int requested_bytes, AllocationSpace space);

  static inline Failure* RetryAfterGC(int requested_bytes);  // NEW_SPACE

  static inline Failure* Exception();

  static inline Failure* InternalError();

  static inline Failure* OutOfMemoryException();

  // Casting.

  static inline Failure* cast(Object* object);

  // Dispatched behavior.

  void FailurePrint();

  void FailurePrint(StringStream* accumulator);

#ifdef DEBUG

  void FailureVerify();

#endif

 private:

  inline int value() const;

  static inline Failure* Construct(Type type, int value = 0);

  DISALLOW_IMPLICIT_CONSTRUCTORS(Failure);

};

// Heap objects typically have a map pointer in their first word.  However,

// during GC other data (eg, mark bits, forwarding addresses) is sometimes

// encoded in the first word.  The class MapWord is an abstraction of the

// value in a heap object's first word.

class MapWord BASE_EMBEDDED {

 public:

  // Normal state: the map word contains a map pointer.

  // Create a map word from a map pointer.

  static inline MapWord FromMap(Map* map);

  // View this map word as a map pointer.

  inline Map* ToMap();

  // Scavenge collection: the map word of live objects in the from space

  // contains a forwarding address (a heap object pointer in the to space).

  // True if this map word is a forwarding address for a scavenge

  // collection.  Only valid during a scavenge collection (specifically,

  // when all map words are heap object pointers, ie. not during a full GC).

  inline bool IsForwardingAddress();

  // Create a map word from a forwarding address.

  static inline MapWord FromForwardingAddress(HeapObject* object);

  // View this map word as a forwarding address.

  inline HeapObject* ToForwardingAddress();

  // Marking phase of full collection: the map word of live objects is

  // marked, and may be marked as overflowed (eg, the object is live, its

  // children have not been visited, and it does not fit in the marking

  // stack).

  // True if this map word's mark bit is set.

  inline bool IsMarked();

  // Return this map word but with its mark bit set.

  inline void SetMark();

  // Return this map word but with its mark bit cleared.

  inline void ClearMark();

  // True if this map word's overflow bit is set.

  inline bool IsOverflowed();

  // Return this map word but with its overflow bit set.

  inline void SetOverflow();

  // Return this map word but with its overflow bit cleared.

  inline void ClearOverflow();

  // Compacting phase of a full compacting collection: the map word of live

  // objects contains an encoding of the original map address along with the

  // forwarding address (represented as an offset from the first live object

  // in the same page as the (old) object address).

  // Create a map word from a map address and a forwarding address offset.

  static inline MapWord EncodeAddress(Address map_address, int offset);

  // Return the map address encoded in this map word.

  inline Address DecodeMapAddress(MapSpace* map_space);

  // Return the forwarding offset encoded in this map word.

  inline int DecodeOffset();

  // During serialization: the map word is used to hold an encoded

  // address, and possibly a mark bit (set and cleared with SetMark

  // and ClearMark).

  // Create a map word from an encoded address.

  static inline MapWord FromEncodedAddress(Address address);

  inline Address ToEncodedAddress();

 private:

  // HeapObject calls the private constructor and directly reads the value.

  friend class HeapObject;

  explicit MapWord(uintptr_t value) : value_(value) {}

  uintptr_t value_;

  // Bits used by the marking phase of the garbage collector.

  //

  // The first word of a heap object is normally a map pointer. The last two

  // bits are tagged as '01' (kHeapObjectTag). We reuse the last two bits to

  // mark an object as live and/or overflowed:

  //   last bit = 0, marked as alive

  //   second bit = 1, overflowed

  // An object is only marked as overflowed when it is marked as live while

  // the marking stack is overflowed.

  static const int kMarkingBit = 0;  // marking bit

  static const int kMarkingMask = (1 << kMarkingBit);  // marking mask

  static const int kOverflowBit = 1;  // overflow bit

  static const int kOverflowMask = (1 << kOverflowBit);  // overflow mask

  // Forwarding pointers and map pointer encoding

  //  31             21 20              10 9               0

  // +-----------------+------------------+-----------------+

  // |forwarding offset|page offset of map|page index of map|

  // +-----------------+------------------+-----------------+

  //  11 bits           11 bits            10 bits

  static const int kMapPageIndexBits = 10;

  static const int kMapPageOffsetBits = 11;

  static const int kForwardingOffsetBits = 11;

  static const int kMapPageIndexShift = 0;

  static const int kMapPageOffsetShift =

      kMapPageIndexShift + kMapPageIndexBits;

  static const int kForwardingOffsetShift =

      kMapPageOffsetShift + kMapPageOffsetBits;

  // 0x000003FF

  static const uint32_t kMapPageIndexMask =

      (1 << kMapPageOffsetShift) - 1;

  // 0x001FFC00

  static const uint32_t kMapPageOffsetMask =

      ((1 << kForwardingOffsetShift) - 1) & ~kMapPageIndexMask;

  // 0xFFE00000

  static const uint32_t kForwardingOffsetMask =

      ~(kMapPageIndexMask | kMapPageOffsetMask);

};

// HeapObject is the superclass for all classes describing heap allocated

// objects.

class HeapObject: public Object {

 public:

  // [map]: Contains a map which contains the object's reflective

  // information.

  inline Map* map();

  inline void set_map(Map* value);

  // During garbage collection, the map word of a heap object does not

  // necessarily contain a map pointer.

  inline MapWord map_word();

  inline void set_map_word(MapWord map_word);

  // Converts an address to a HeapObject pointer.

  static inline HeapObject* FromAddress(Address address);

  // Returns the address of this HeapObject.