src/objects.h

   1 // Copyright 2012 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef V8_OBJECTS_H_
   6 #define V8_OBJECTS_H_
   7
   8 #include <iosfwd>
   9
  10 #include "src/allocation.h"
  11 #include "src/assert-scope.h"
  12 #include "src/bailout-reason.h"
  13 #include "src/base/bits.h"
  14 #include "src/base/smart-pointers.h"
  15 #include "src/builtins.h"
  16 #include "src/checks.h"
  17 #include "src/elements-kind.h"
  18 #include "src/field-index.h"
  19 #include "src/flags.h"
  20 #include "src/list.h"
  21 #include "src/property-details.h"
  22 #include "src/unicode.h"
  23 #include "src/unicode-decoder.h"
  24 #include "src/zone.h"
  25
  26 #if V8_TARGET_ARCH_ARM
  27 #include "src/arm/constants-arm.h"  // NOLINT
  28 #elif V8_TARGET_ARCH_ARM64
  29 #include "src/arm64/constants-arm64.h"  // NOLINT
  30 #elif V8_TARGET_ARCH_MIPS
  31 #include "src/mips/constants-mips.h"  // NOLINT
  32 #elif V8_TARGET_ARCH_MIPS64
  33 #include "src/mips64/constants-mips64.h"  // NOLINT
  34 #elif V8_TARGET_ARCH_PPC
  35 #include "src/ppc/constants-ppc.h"  // NOLINT
  36 #endif
  37
  38
  39 //
  40 // Most object types in the V8 JavaScript are described in this file.
  41 //
  42 // Inheritance hierarchy:
  43 // - Object
  44 //   - Smi          (immediate small integer)
  45 //   - HeapObject   (superclass for everything allocated in the heap)
  46 //     - JSReceiver  (suitable for property access)
  47 //       - JSObject
  48 //         - JSArray
  49 //         - JSArrayBuffer
  50 //         - JSArrayBufferView
  51 //           - JSTypedArray
  52 //           - JSDataView
  53 //         - JSCollection
  54 //           - JSSet
  55 //           - JSMap
  56 //         - JSSetIterator
  57 //         - JSMapIterator
  58 //         - JSWeakCollection
  59 //           - JSWeakMap
  60 //           - JSWeakSet
  61 //         - JSRegExp
  62 //         - JSFunction
  63 //         - JSGeneratorObject
  64 //         - JSModule
  65 //         - GlobalObject
  66 //           - JSGlobalObject
  67 //           - JSBuiltinsObject
  68 //         - JSGlobalProxy
  69 //         - JSValue
  70 //           - JSDate
  71 //         - JSMessageObject
  72 //       - JSProxy
  73 //         - JSFunctionProxy
  74 //     - FixedArrayBase
  75 //       - ByteArray
  76 //       - BytecodeArray
  77 //       - FixedArray
  78 //         - DescriptorArray
  79 //         - HashTable
  80 //           - Dictionary
  81 //           - StringTable
  82 //           - CompilationCacheTable
  83 //           - CodeCacheHashTable
  84 //           - MapCache
  85 //         - OrderedHashTable
  86 //           - OrderedHashSet
  87 //           - OrderedHashMap
  88 //         - Context
  89 //         - TypeFeedbackVector
  90 //         - ScopeInfo
  91 //         - TransitionArray
  92 //         - ScriptContextTable
  93 //         - WeakFixedArray
  94 //       - FixedDoubleArray
  95 //     - Name
  96 //       - String
  97 //         - SeqString
  98 //           - SeqOneByteString
  99 //           - SeqTwoByteString
 100 //         - SlicedString
 101 //         - ConsString
 102 //         - ExternalString
 103 //           - ExternalOneByteString
 104 //           - ExternalTwoByteString
 105 //         - InternalizedString
 106 //           - SeqInternalizedString
 107 //             - SeqOneByteInternalizedString
 108 //             - SeqTwoByteInternalizedString
 109 //           - ConsInternalizedString
 110 //           - ExternalInternalizedString
 111 //             - ExternalOneByteInternalizedString
 112 //             - ExternalTwoByteInternalizedString
 113 //       - Symbol
 114 //     - HeapNumber
 115 //     - Simd128Value
 116 //       - Float32x4
 117 //       - Int32x4
 118 //       - Uint32x4
 119 //       - Bool32x4
 120 //       - Int16x8
 121 //       - Uint16x8
 122 //       - Bool16x8
 123 //       - Int8x16
 124 //       - Uint8x16
 125 //       - Bool8x16
 126 //     - Cell
 127 //     - PropertyCell
 128 //     - Code
 129 //     - Map
 130 //     - Oddball
 131 //     - Foreign
 132 //     - SharedFunctionInfo
 133 //     - Struct
 134 //       - Box
 135 //       - AccessorInfo
 136 //         - ExecutableAccessorInfo
 137 //       - AccessorPair
 138 //       - AccessCheckInfo
 139 //       - InterceptorInfo
 140 //       - CallHandlerInfo
 141 //       - TemplateInfo
 142 //         - FunctionTemplateInfo
 143 //         - ObjectTemplateInfo
 144 //       - Script
 145 //       - TypeSwitchInfo
 146 //       - DebugInfo
 147 //       - BreakPointInfo
 148 //       - CodeCache
 149 //       - PrototypeInfo
 150 //     - WeakCell
 151 //
 152 // Formats of Object*:
 153 //  Smi:        [31 bit signed int] 0
 154 //  HeapObject: [32 bit direct pointer] (4 byte aligned) | 01
 155
 156 namespace v8 {
 157 namespace internal {
 158
 159 enum KeyedAccessStoreMode {
 160   STANDARD_STORE,
 161   STORE_TRANSITION_TO_OBJECT,
 162   STORE_TRANSITION_TO_DOUBLE,
 163   STORE_AND_GROW_NO_TRANSITION,
 164   STORE_AND_GROW_TRANSITION_TO_OBJECT,
 165   STORE_AND_GROW_TRANSITION_TO_DOUBLE,
 166   STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS,
 167   STORE_NO_TRANSITION_HANDLE_COW
 168 };
 169
 170
 171 enum TypeofMode { INSIDE_TYPEOF, NOT_INSIDE_TYPEOF };
 172
 173
 174 enum MutableMode {
 175   MUTABLE,
 176   IMMUTABLE
 177 };
 178
 179
 180 enum ExternalArrayType {
 181   kExternalInt8Array = 1,
 182   kExternalUint8Array,
 183   kExternalInt16Array,
 184   kExternalUint16Array,
 185   kExternalInt32Array,
 186   kExternalUint32Array,
 187   kExternalFloat32Array,
 188   kExternalFloat64Array,
 189   kExternalUint8ClampedArray,
 190 };
 191
 192
 193 static inline bool IsTransitionStoreMode(KeyedAccessStoreMode store_mode) {
 194   return store_mode == STORE_TRANSITION_TO_OBJECT ||
 195          store_mode == STORE_TRANSITION_TO_DOUBLE ||
 196          store_mode == STORE_AND_GROW_TRANSITION_TO_OBJECT ||
 197          store_mode == STORE_AND_GROW_TRANSITION_TO_DOUBLE;
 198 }
 199
 200
 201 static inline KeyedAccessStoreMode GetNonTransitioningStoreMode(
 202     KeyedAccessStoreMode store_mode) {
 203   if (store_mode >= STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS) {
 204     return store_mode;
 205   }
 206   if (store_mode >= STORE_AND_GROW_NO_TRANSITION) {
 207     return STORE_AND_GROW_NO_TRANSITION;
 208   }
 209   return STANDARD_STORE;
 210 }
 211
 212
 213 static inline bool IsGrowStoreMode(KeyedAccessStoreMode store_mode) {
 214   return store_mode >= STORE_AND_GROW_NO_TRANSITION &&
 215          store_mode <= STORE_AND_GROW_TRANSITION_TO_DOUBLE;
 216 }
 217
 218
 219 enum IcCheckType { ELEMENT, PROPERTY };
 220
 221
 222 // SKIP_WRITE_BARRIER skips the write barrier.
 223 // UPDATE_WEAK_WRITE_BARRIER skips the marking part of the write barrier and
 224 // only performs the generational part.
 225 // UPDATE_WRITE_BARRIER is doing the full barrier, marking and generational.
 226 enum WriteBarrierMode {
 227   SKIP_WRITE_BARRIER,
 228   UPDATE_WEAK_WRITE_BARRIER,
 229   UPDATE_WRITE_BARRIER
 230 };
 231
 232
 233 // Indicates whether a value can be loaded as a constant.
 234 enum StoreMode { ALLOW_IN_DESCRIPTOR, FORCE_FIELD };
 235
 236
 237 // PropertyNormalizationMode is used to specify whether to keep
 238 // inobject properties when normalizing properties of a JSObject.
 239 enum PropertyNormalizationMode {
 240   CLEAR_INOBJECT_PROPERTIES,
 241   KEEP_INOBJECT_PROPERTIES
 242 };
 243
 244
 245 // Indicates how aggressively the prototype should be optimized. FAST_PROTOTYPE
 246 // will give the fastest result by tailoring the map to the prototype, but that
 247 // will cause polymorphism with other objects. REGULAR_PROTOTYPE is to be used
 248 // (at least for now) when dynamically modifying the prototype chain of an
 249 // object using __proto__ or Object.setPrototypeOf.
 250 enum PrototypeOptimizationMode { REGULAR_PROTOTYPE, FAST_PROTOTYPE };
 251
 252
 253 // Indicates whether transitions can be added to a source map or not.
 254 enum TransitionFlag {
 255   INSERT_TRANSITION,
 256   OMIT_TRANSITION
 257 };
 258
 259
 260 // Indicates whether the transition is simple: the target map of the transition
 261 // either extends the current map with a new property, or it modifies the
 262 // property that was added last to the current map.
 263 enum SimpleTransitionFlag {
 264   SIMPLE_PROPERTY_TRANSITION,
 265   PROPERTY_TRANSITION,
 266   SPECIAL_TRANSITION
 267 };
 268
 269
 270 // Indicates whether we are only interested in the descriptors of a particular
 271 // map, or in all descriptors in the descriptor array.
 272 enum DescriptorFlag {
 273   ALL_DESCRIPTORS,
 274   OWN_DESCRIPTORS
 275 };
 276
 277 // The GC maintains a bit of information, the MarkingParity, which toggles
 278 // from odd to even and back every time marking is completed. Incremental
 279 // marking can visit an object twice during a marking phase, so algorithms that
 280 // that piggy-back on marking can use the parity to ensure that they only
 281 // perform an operation on an object once per marking phase: they record the
 282 // MarkingParity when they visit an object, and only re-visit the object when it
 283 // is marked again and the MarkingParity changes.
 284 enum MarkingParity {
 285   NO_MARKING_PARITY,
 286   ODD_MARKING_PARITY,
 287   EVEN_MARKING_PARITY
 288 };
 289
 290 // ICs store extra state in a Code object. The default extra state is
 291 // kNoExtraICState.
 292 typedef int ExtraICState;
 293 static const ExtraICState kNoExtraICState = 0;
 294
 295 // Instance size sentinel for objects of variable size.
 296 const int kVariableSizeSentinel = 0;
 297
 298 // We may store the unsigned bit field as signed Smi value and do not
 299 // use the sign bit.
 300 const int kStubMajorKeyBits = 7;
 301 const int kStubMinorKeyBits = kSmiValueSize - kStubMajorKeyBits - 1;
 302
 303 // All Maps have a field instance_type containing a InstanceType.
 304 // It describes the type of the instances.
 305 //
 306 // As an example, a JavaScript object is a heap object and its map
 307 // instance_type is JS_OBJECT_TYPE.
 308 //
 309 // The names of the string instance types are intended to systematically
 310 // mirror their encoding in the instance_type field of the map.  The default
 311 // encoding is considered TWO_BYTE.  It is not mentioned in the name.  ONE_BYTE
 312 // encoding is mentioned explicitly in the name.  Likewise, the default
 313 // representation is considered sequential.  It is not mentioned in the
 314 // name.  The other representations (e.g. CONS, EXTERNAL) are explicitly
 315 // mentioned.  Finally, the string is either a STRING_TYPE (if it is a normal
 316 // string) or a INTERNALIZED_STRING_TYPE (if it is a internalized string).
 317 //
 318 // NOTE: The following things are some that depend on the string types having
 319 // instance_types that are less than those of all other types:
 320 // HeapObject::Size, HeapObject::IterateBody, the typeof operator, and
 321 // Object::IsString.
 322 //
 323 // NOTE: Everything following JS_VALUE_TYPE is considered a
 324 // JSObject for GC purposes. The first four entries here have typeof
 325 // 'object', whereas JS_FUNCTION_TYPE has typeof 'function'.
 326 #define INSTANCE_TYPE_LIST(V)                                   \
 327   V(STRING_TYPE)                                                \
 328   V(ONE_BYTE_STRING_TYPE)                                       \
 329   V(CONS_STRING_TYPE)                                           \
 330   V(CONS_ONE_BYTE_STRING_TYPE)                                  \
 331   V(SLICED_STRING_TYPE)                                         \
 332   V(SLICED_ONE_BYTE_STRING_TYPE)                                \
 333   V(EXTERNAL_STRING_TYPE)                                       \
 334   V(EXTERNAL_ONE_BYTE_STRING_TYPE)                              \
 335   V(EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE)                    \
 336   V(SHORT_EXTERNAL_STRING_TYPE)                                 \
 337   V(SHORT_EXTERNAL_ONE_BYTE_STRING_TYPE)                        \
 338   V(SHORT_EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE)              \
 339                                                                 \
 340   V(INTERNALIZED_STRING_TYPE)                                   \
 341   V(ONE_BYTE_INTERNALIZED_STRING_TYPE)                          \
 342   V(EXTERNAL_INTERNALIZED_STRING_TYPE)                          \
 343   V(EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE)                 \
 344   V(EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE)       \
 345   V(SHORT_EXTERNAL_INTERNALIZED_STRING_TYPE)                    \
 346   V(SHORT_EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE)           \
 347   V(SHORT_EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE) \
 348                                                                 \
 349   V(SYMBOL_TYPE)                                                \
 350   V(SIMD128_VALUE_TYPE)                                         \
 351                                                                 \
 352   V(MAP_TYPE)                                                   \
 353   V(CODE_TYPE)                                                  \
 354   V(ODDBALL_TYPE)                                               \
 355   V(CELL_TYPE)                                                  \
 356   V(PROPERTY_CELL_TYPE)                                         \
 357                                                                 \
 358   V(HEAP_NUMBER_TYPE)                                           \
 359   V(MUTABLE_HEAP_NUMBER_TYPE)                                   \
 360   V(FOREIGN_TYPE)                                               \
 361   V(BYTE_ARRAY_TYPE)                                            \
 362   V(BYTECODE_ARRAY_TYPE)                                        \
 363   V(FREE_SPACE_TYPE)                                            \
 364                                                                 \
 365   V(FIXED_INT8_ARRAY_TYPE)                                      \
 366   V(FIXED_UINT8_ARRAY_TYPE)                                     \
 367   V(FIXED_INT16_ARRAY_TYPE)                                     \
 368   V(FIXED_UINT16_ARRAY_TYPE)                                    \
 369   V(FIXED_INT32_ARRAY_TYPE)                                     \
 370   V(FIXED_UINT32_ARRAY_TYPE)                                    \
 371   V(FIXED_FLOAT32_ARRAY_TYPE)                                   \
 372   V(FIXED_FLOAT64_ARRAY_TYPE)                                   \
 373   V(FIXED_UINT8_CLAMPED_ARRAY_TYPE)                             \
 374                                                                 \
 375   V(FILLER_TYPE)                                                \
 376                                                                 \
 377   V(DECLARED_ACCESSOR_DESCRIPTOR_TYPE)                          \
 378   V(DECLARED_ACCESSOR_INFO_TYPE)                                \
 379   V(EXECUTABLE_ACCESSOR_INFO_TYPE)                              \
 380   V(ACCESSOR_PAIR_TYPE)                                         \
 381   V(ACCESS_CHECK_INFO_TYPE)                                     \
 382   V(INTERCEPTOR_INFO_TYPE)                                      \
 383   V(CALL_HANDLER_INFO_TYPE)                                     \
 384   V(FUNCTION_TEMPLATE_INFO_TYPE)                                \
 385   V(OBJECT_TEMPLATE_INFO_TYPE)                                  \
 386   V(SIGNATURE_INFO_TYPE)                                        \
 387   V(TYPE_SWITCH_INFO_TYPE)                                      \
 388   V(ALLOCATION_MEMENTO_TYPE)                                    \
 389   V(ALLOCATION_SITE_TYPE)                                       \
 390   V(SCRIPT_TYPE)                                                \
 391   V(CODE_CACHE_TYPE)                                            \
 392   V(POLYMORPHIC_CODE_CACHE_TYPE)                                \
 393   V(TYPE_FEEDBACK_INFO_TYPE)                                    \
 394   V(ALIASED_ARGUMENTS_ENTRY_TYPE)                               \
 395   V(BOX_TYPE)                                                   \
 396   V(PROTOTYPE_INFO_TYPE)                                        \
 397   V(SLOPPY_BLOCK_WITH_EVAL_CONTEXT_EXTENSION_TYPE)              \
 398                                                                 \
 399   V(FIXED_ARRAY_TYPE)                                           \
 400   V(FIXED_DOUBLE_ARRAY_TYPE)                                    \
 401   V(SHARED_FUNCTION_INFO_TYPE)                                  \
 402   V(WEAK_CELL_TYPE)                                             \
 403                                                                 \
 404   V(JS_MESSAGE_OBJECT_TYPE)                                     \
 405                                                                 \
 406   V(JS_VALUE_TYPE)                                              \
 407   V(JS_DATE_TYPE)                                               \
 408   V(JS_OBJECT_TYPE)                                             \
 409   V(JS_CONTEXT_EXTENSION_OBJECT_TYPE)                           \
 410   V(JS_GENERATOR_OBJECT_TYPE)                                   \
 411   V(JS_MODULE_TYPE)                                             \
 412   V(JS_GLOBAL_OBJECT_TYPE)                                      \
 413   V(JS_BUILTINS_OBJECT_TYPE)                                    \
 414   V(JS_GLOBAL_PROXY_TYPE)                                       \
 415   V(JS_ARRAY_TYPE)                                              \
 416   V(JS_ARRAY_BUFFER_TYPE)                                       \
 417   V(JS_TYPED_ARRAY_TYPE)                                        \
 418   V(JS_DATA_VIEW_TYPE)                                          \
 419   V(JS_PROXY_TYPE)                                              \
 420   V(JS_SET_TYPE)                                                \
 421   V(JS_MAP_TYPE)                                                \
 422   V(JS_SET_ITERATOR_TYPE)                                       \
 423   V(JS_MAP_ITERATOR_TYPE)                                       \
 424   V(JS_WEAK_MAP_TYPE)                                           \
 425   V(JS_WEAK_SET_TYPE)                                           \
 426   V(JS_REGEXP_TYPE)                                             \
 427                                                                 \
 428   V(JS_FUNCTION_TYPE)                                           \
 429   V(JS_FUNCTION_PROXY_TYPE)                                     \
 430   V(DEBUG_INFO_TYPE)                                            \
 431   V(BREAK_POINT_INFO_TYPE)
 432
 433
 434 // Since string types are not consecutive, this macro is used to
 435 // iterate over them.
 436 #define STRING_TYPE_LIST(V)                                                   \
 437   V(STRING_TYPE, kVariableSizeSentinel, string, String)                       \
 438   V(ONE_BYTE_STRING_TYPE, kVariableSizeSentinel, one_byte_string,             \
 439     OneByteString)                                                            \
 440   V(CONS_STRING_TYPE, ConsString::kSize, cons_string, ConsString)             \
 441   V(CONS_ONE_BYTE_STRING_TYPE, ConsString::kSize, cons_one_byte_string,       \
 442     ConsOneByteString)                                                        \
 443   V(SLICED_STRING_TYPE, SlicedString::kSize, sliced_string, SlicedString)     \
 444   V(SLICED_ONE_BYTE_STRING_TYPE, SlicedString::kSize, sliced_one_byte_string, \
 445     SlicedOneByteString)                                                      \
 446   V(EXTERNAL_STRING_TYPE, ExternalTwoByteString::kSize, external_string,      \
 447     ExternalString)                                                           \
 448   V(EXTERNAL_ONE_BYTE_STRING_TYPE, ExternalOneByteString::kSize,              \
 449     external_one_byte_string, ExternalOneByteString)                          \
 450   V(EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE, ExternalTwoByteString::kSize,    \
 451     external_string_with_one_byte_data, ExternalStringWithOneByteData)        \
 452   V(SHORT_EXTERNAL_STRING_TYPE, ExternalTwoByteString::kShortSize,            \
 453     short_external_string, ShortExternalString)                               \
 454   V(SHORT_EXTERNAL_ONE_BYTE_STRING_TYPE, ExternalOneByteString::kShortSize,   \
 455     short_external_one_byte_string, ShortExternalOneByteString)               \
 456   V(SHORT_EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE,                            \
 457     ExternalTwoByteString::kShortSize,                                        \
 458     short_external_string_with_one_byte_data,                                 \
 459     ShortExternalStringWithOneByteData)                                       \
 460                                                                               \
 461   V(INTERNALIZED_STRING_TYPE, kVariableSizeSentinel, internalized_string,     \
 462     InternalizedString)                                                       \
 463   V(ONE_BYTE_INTERNALIZED_STRING_TYPE, kVariableSizeSentinel,                 \
 464     one_byte_internalized_string, OneByteInternalizedString)                  \
 465   V(EXTERNAL_INTERNALIZED_STRING_TYPE, ExternalTwoByteString::kSize,          \
 466     external_internalized_string, ExternalInternalizedString)                 \
 467   V(EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE, ExternalOneByteString::kSize, \
 468     external_one_byte_internalized_string, ExternalOneByteInternalizedString) \
 469   V(EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE,                     \
 470     ExternalTwoByteString::kSize,                                             \
 471     external_internalized_string_with_one_byte_data,                          \
 472     ExternalInternalizedStringWithOneByteData)                                \
 473   V(SHORT_EXTERNAL_INTERNALIZED_STRING_TYPE,                                  \
 474     ExternalTwoByteString::kShortSize, short_external_internalized_string,    \
 475     ShortExternalInternalizedString)                                          \
 476   V(SHORT_EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE,                         \
 477     ExternalOneByteString::kShortSize,                                        \
 478     short_external_one_byte_internalized_string,                              \
 479     ShortExternalOneByteInternalizedString)                                   \
 480   V(SHORT_EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE,               \
 481     ExternalTwoByteString::kShortSize,                                        \
 482     short_external_internalized_string_with_one_byte_data,                    \
 483     ShortExternalInternalizedStringWithOneByteData)
 484
 485 // A struct is a simple object a set of object-valued fields.  Including an
 486 // object type in this causes the compiler to generate most of the boilerplate
 487 // code for the class including allocation and garbage collection routines,
 488 // casts and predicates.  All you need to define is the class, methods and
 489 // object verification routines.  Easy, no?
 490 //
 491 // Note that for subtle reasons related to the ordering or numerical values of
 492 // type tags, elements in this list have to be added to the INSTANCE_TYPE_LIST
 493 // manually.
 494 #define STRUCT_LIST(V)                                                       \
 495   V(BOX, Box, box)                                                           \
 496   V(EXECUTABLE_ACCESSOR_INFO, ExecutableAccessorInfo,                        \
 497     executable_accessor_info)                                                \
 498   V(ACCESSOR_PAIR, AccessorPair, accessor_pair)                              \
 499   V(ACCESS_CHECK_INFO, AccessCheckInfo, access_check_info)                   \
 500   V(INTERCEPTOR_INFO, InterceptorInfo, interceptor_info)                     \
 501   V(CALL_HANDLER_INFO, CallHandlerInfo, call_handler_info)                   \
 502   V(FUNCTION_TEMPLATE_INFO, FunctionTemplateInfo, function_template_info)    \
 503   V(OBJECT_TEMPLATE_INFO, ObjectTemplateInfo, object_template_info)          \
 504   V(TYPE_SWITCH_INFO, TypeSwitchInfo, type_switch_info)                      \
 505   V(SCRIPT, Script, script)                                                  \
 506   V(ALLOCATION_SITE, AllocationSite, allocation_site)                        \
 507   V(ALLOCATION_MEMENTO, AllocationMemento, allocation_memento)               \
 508   V(CODE_CACHE, CodeCache, code_cache)                                       \
 509   V(POLYMORPHIC_CODE_CACHE, PolymorphicCodeCache, polymorphic_code_cache)    \
 510   V(TYPE_FEEDBACK_INFO, TypeFeedbackInfo, type_feedback_info)                \
 511   V(ALIASED_ARGUMENTS_ENTRY, AliasedArgumentsEntry, aliased_arguments_entry) \
 512   V(DEBUG_INFO, DebugInfo, debug_info)                                       \
 513   V(BREAK_POINT_INFO, BreakPointInfo, break_point_info)                      \
 514   V(PROTOTYPE_INFO, PrototypeInfo, prototype_info)                           \
 515   V(SLOPPY_BLOCK_WITH_EVAL_CONTEXT_EXTENSION,                                \
 516     SloppyBlockWithEvalContextExtension,                                     \
 517     sloppy_block_with_eval_context_extension)
 518
 519 // We use the full 8 bits of the instance_type field to encode heap object
 520 // instance types.  The high-order bit (bit 7) is set if the object is not a
 521 // string, and cleared if it is a string.
 522 const uint32_t kIsNotStringMask = 0x80;
 523 const uint32_t kStringTag = 0x0;
 524 const uint32_t kNotStringTag = 0x80;
 525
 526 // Bit 6 indicates that the object is an internalized string (if set) or not.
 527 // Bit 7 has to be clear as well.
 528 const uint32_t kIsNotInternalizedMask = 0x40;
 529 const uint32_t kNotInternalizedTag = 0x40;
 530 const uint32_t kInternalizedTag = 0x0;
 531
 532 // If bit 7 is clear then bit 2 indicates whether the string consists of
 533 // two-byte characters or one-byte characters.
 534 const uint32_t kStringEncodingMask = 0x4;
 535 const uint32_t kTwoByteStringTag = 0x0;
 536 const uint32_t kOneByteStringTag = 0x4;
 537
 538 // If bit 7 is clear, the low-order 2 bits indicate the representation
 539 // of the string.
 540 const uint32_t kStringRepresentationMask = 0x03;
 541 enum StringRepresentationTag {
 542   kSeqStringTag = 0x0,
 543   kConsStringTag = 0x1,
 544   kExternalStringTag = 0x2,
 545   kSlicedStringTag = 0x3
 546 };
 547 const uint32_t kIsIndirectStringMask = 0x1;
 548 const uint32_t kIsIndirectStringTag = 0x1;
 549 STATIC_ASSERT((kSeqStringTag & kIsIndirectStringMask) == 0);  // NOLINT
 550 STATIC_ASSERT((kExternalStringTag & kIsIndirectStringMask) == 0);  // NOLINT
 551 STATIC_ASSERT((kConsStringTag &
 552                kIsIndirectStringMask) == kIsIndirectStringTag);  // NOLINT
 553 STATIC_ASSERT((kSlicedStringTag &
 554                kIsIndirectStringMask) == kIsIndirectStringTag);  // NOLINT
 555
 556 // Use this mask to distinguish between cons and slice only after making
 557 // sure that the string is one of the two (an indirect string).
 558 const uint32_t kSlicedNotConsMask = kSlicedStringTag & ~kConsStringTag;
 559 STATIC_ASSERT(IS_POWER_OF_TWO(kSlicedNotConsMask));
 560
 561 // If bit 7 is clear, then bit 3 indicates whether this two-byte
 562 // string actually contains one byte data.
 563 const uint32_t kOneByteDataHintMask = 0x08;
 564 const uint32_t kOneByteDataHintTag = 0x08;
 565
 566 // If bit 7 is clear and string representation indicates an external string,
 567 // then bit 4 indicates whether the data pointer is cached.
 568 const uint32_t kShortExternalStringMask = 0x10;
 569 const uint32_t kShortExternalStringTag = 0x10;
 570
 571
 572 // A ConsString with an empty string as the right side is a candidate
 573 // for being shortcut by the garbage collector. We don't allocate any
 574 // non-flat internalized strings, so we do not shortcut them thereby
 575 // avoiding turning internalized strings into strings. The bit-masks
 576 // below contain the internalized bit as additional safety.
 577 // See heap.cc, mark-compact.cc and objects-visiting.cc.
 578 const uint32_t kShortcutTypeMask =
 579     kIsNotStringMask |
 580     kIsNotInternalizedMask |
 581     kStringRepresentationMask;
 582 const uint32_t kShortcutTypeTag = kConsStringTag | kNotInternalizedTag;
 583
 584 static inline bool IsShortcutCandidate(int type) {
 585   return ((type & kShortcutTypeMask) == kShortcutTypeTag);
 586 }
 587
 588
 589 enum InstanceType {
 590   // String types.
 591   INTERNALIZED_STRING_TYPE = kTwoByteStringTag | kSeqStringTag |
 592                              kInternalizedTag,  // FIRST_PRIMITIVE_TYPE
 593   ONE_BYTE_INTERNALIZED_STRING_TYPE =
 594       kOneByteStringTag | kSeqStringTag | kInternalizedTag,
 595   EXTERNAL_INTERNALIZED_STRING_TYPE =
 596       kTwoByteStringTag | kExternalStringTag | kInternalizedTag,
 597   EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE =
 598       kOneByteStringTag | kExternalStringTag | kInternalizedTag,
 599   EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE =
 600       EXTERNAL_INTERNALIZED_STRING_TYPE | kOneByteDataHintTag |
 601       kInternalizedTag,
 602   SHORT_EXTERNAL_INTERNALIZED_STRING_TYPE = EXTERNAL_INTERNALIZED_STRING_TYPE |
 603                                             kShortExternalStringTag |
 604                                             kInternalizedTag,
 605   SHORT_EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE =
 606       EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE | kShortExternalStringTag |
 607       kInternalizedTag,
 608   SHORT_EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE =
 609       EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE |
 610       kShortExternalStringTag | kInternalizedTag,
 611   STRING_TYPE = INTERNALIZED_STRING_TYPE | kNotInternalizedTag,
 612   ONE_BYTE_STRING_TYPE =
 613       ONE_BYTE_INTERNALIZED_STRING_TYPE | kNotInternalizedTag,
 614   CONS_STRING_TYPE = kTwoByteStringTag | kConsStringTag | kNotInternalizedTag,
 615   CONS_ONE_BYTE_STRING_TYPE =
 616       kOneByteStringTag | kConsStringTag | kNotInternalizedTag,
 617   SLICED_STRING_TYPE =
 618       kTwoByteStringTag | kSlicedStringTag | kNotInternalizedTag,
 619   SLICED_ONE_BYTE_STRING_TYPE =
 620       kOneByteStringTag | kSlicedStringTag | kNotInternalizedTag,
 621   EXTERNAL_STRING_TYPE =
 622       EXTERNAL_INTERNALIZED_STRING_TYPE | kNotInternalizedTag,
 623   EXTERNAL_ONE_BYTE_STRING_TYPE =
 624       EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE | kNotInternalizedTag,
 625   EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE =
 626       EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE |
 627       kNotInternalizedTag,
 628   SHORT_EXTERNAL_STRING_TYPE =
 629       SHORT_EXTERNAL_INTERNALIZED_STRING_TYPE | kNotInternalizedTag,
 630   SHORT_EXTERNAL_ONE_BYTE_STRING_TYPE =
 631       SHORT_EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE | kNotInternalizedTag,
 632   SHORT_EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE =
 633       SHORT_EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE |
 634       kNotInternalizedTag,
 635
 636   // Non-string names
 637   SYMBOL_TYPE = kNotStringTag,  // FIRST_NONSTRING_TYPE, LAST_NAME_TYPE
 638
 639   // Other primitives (cannot contain non-map-word pointers to heap objects).
 640   HEAP_NUMBER_TYPE,
 641   SIMD128_VALUE_TYPE,
 642   ODDBALL_TYPE,  // LAST_PRIMITIVE_TYPE
 643
 644   // Objects allocated in their own spaces (never in new space).
 645   MAP_TYPE,
 646   CODE_TYPE,
 647
 648   // "Data", objects that cannot contain non-map-word pointers to heap
 649   // objects.
 650   MUTABLE_HEAP_NUMBER_TYPE,
 651   FOREIGN_TYPE,
 652   BYTE_ARRAY_TYPE,
 653   BYTECODE_ARRAY_TYPE,
 654   FREE_SPACE_TYPE,
 655   FIXED_INT8_ARRAY_TYPE,  // FIRST_FIXED_TYPED_ARRAY_TYPE
 656   FIXED_UINT8_ARRAY_TYPE,
 657   FIXED_INT16_ARRAY_TYPE,
 658   FIXED_UINT16_ARRAY_TYPE,
 659   FIXED_INT32_ARRAY_TYPE,
 660   FIXED_UINT32_ARRAY_TYPE,
 661   FIXED_FLOAT32_ARRAY_TYPE,
 662   FIXED_FLOAT64_ARRAY_TYPE,
 663   FIXED_UINT8_CLAMPED_ARRAY_TYPE,  // LAST_FIXED_TYPED_ARRAY_TYPE
 664   FIXED_DOUBLE_ARRAY_TYPE,
 665   FILLER_TYPE,  // LAST_DATA_TYPE
 666
 667   // Structs.
 668   DECLARED_ACCESSOR_DESCRIPTOR_TYPE,
 669   DECLARED_ACCESSOR_INFO_TYPE,
 670   EXECUTABLE_ACCESSOR_INFO_TYPE,
 671   ACCESSOR_PAIR_TYPE,
 672   ACCESS_CHECK_INFO_TYPE,
 673   INTERCEPTOR_INFO_TYPE,
 674   CALL_HANDLER_INFO_TYPE,
 675   FUNCTION_TEMPLATE_INFO_TYPE,
 676   OBJECT_TEMPLATE_INFO_TYPE,
 677   SIGNATURE_INFO_TYPE,
 678   TYPE_SWITCH_INFO_TYPE,
 679   ALLOCATION_SITE_TYPE,
 680   ALLOCATION_MEMENTO_TYPE,
 681   SCRIPT_TYPE,
 682   CODE_CACHE_TYPE,
 683   POLYMORPHIC_CODE_CACHE_TYPE,
 684   TYPE_FEEDBACK_INFO_TYPE,
 685   ALIASED_ARGUMENTS_ENTRY_TYPE,
 686   BOX_TYPE,
 687   DEBUG_INFO_TYPE,
 688   BREAK_POINT_INFO_TYPE,
 689   FIXED_ARRAY_TYPE,
 690   SHARED_FUNCTION_INFO_TYPE,
 691   CELL_TYPE,
 692   WEAK_CELL_TYPE,
 693   PROPERTY_CELL_TYPE,
 694   PROTOTYPE_INFO_TYPE,
 695   SLOPPY_BLOCK_WITH_EVAL_CONTEXT_EXTENSION_TYPE,
 696
 697   // All the following types are subtypes of JSReceiver, which corresponds to
 698   // objects in the JS sense. The first and the last type in this range are
 699   // the two forms of function. This organization enables using the same
 700   // compares for checking the JS_RECEIVER/SPEC_OBJECT range and the
 701   // NONCALLABLE_JS_OBJECT range.
 702   JS_FUNCTION_PROXY_TYPE,  // FIRST_JS_RECEIVER_TYPE, FIRST_JS_PROXY_TYPE
 703   JS_PROXY_TYPE,           // LAST_JS_PROXY_TYPE
 704   JS_VALUE_TYPE,           // FIRST_JS_OBJECT_TYPE
 705   JS_MESSAGE_OBJECT_TYPE,
 706   JS_DATE_TYPE,
 707   JS_OBJECT_TYPE,
 708   JS_CONTEXT_EXTENSION_OBJECT_TYPE,
 709   JS_GENERATOR_OBJECT_TYPE,
 710   JS_MODULE_TYPE,
 711   JS_GLOBAL_OBJECT_TYPE,
 712   JS_BUILTINS_OBJECT_TYPE,
 713   JS_GLOBAL_PROXY_TYPE,
 714   JS_ARRAY_TYPE,
 715   JS_ARRAY_BUFFER_TYPE,
 716   JS_TYPED_ARRAY_TYPE,
 717   JS_DATA_VIEW_TYPE,
 718   JS_SET_TYPE,
 719   JS_MAP_TYPE,
 720   JS_SET_ITERATOR_TYPE,
 721   JS_MAP_ITERATOR_TYPE,
 722   JS_WEAK_MAP_TYPE,
 723   JS_WEAK_SET_TYPE,
 724   JS_REGEXP_TYPE,
 725   JS_FUNCTION_TYPE,  // LAST_JS_OBJECT_TYPE, LAST_JS_RECEIVER_TYPE
 726
 727   // Pseudo-types
 728   FIRST_TYPE = 0x0,
 729   LAST_TYPE = JS_FUNCTION_TYPE,
 730   FIRST_NAME_TYPE = FIRST_TYPE,
 731   LAST_NAME_TYPE = SYMBOL_TYPE,
 732   FIRST_UNIQUE_NAME_TYPE = INTERNALIZED_STRING_TYPE,
 733   LAST_UNIQUE_NAME_TYPE = SYMBOL_TYPE,
 734   FIRST_NONSTRING_TYPE = SYMBOL_TYPE,
 735   FIRST_PRIMITIVE_TYPE = FIRST_NAME_TYPE,
 736   LAST_PRIMITIVE_TYPE = ODDBALL_TYPE,
 737   // Boundaries for testing for a fixed typed array.
 738   FIRST_FIXED_TYPED_ARRAY_TYPE = FIXED_INT8_ARRAY_TYPE,
 739   LAST_FIXED_TYPED_ARRAY_TYPE = FIXED_UINT8_CLAMPED_ARRAY_TYPE,
 740   // Boundary for promotion to old space.
 741   LAST_DATA_TYPE = FILLER_TYPE,
 742   // Boundary for objects represented as JSReceiver (i.e. JSObject or JSProxy).
 743   // Note that there is no range for JSObject or JSProxy, since their subtypes
 744   // are not continuous in this enum! The enum ranges instead reflect the
 745   // external class names, where proxies are treated as either ordinary objects,
 746   // or functions.
 747   FIRST_JS_RECEIVER_TYPE = JS_FUNCTION_PROXY_TYPE,
 748   LAST_JS_RECEIVER_TYPE = LAST_TYPE,
 749   // Boundaries for testing the types represented as JSObject
 750   FIRST_JS_OBJECT_TYPE = JS_VALUE_TYPE,
 751   LAST_JS_OBJECT_TYPE = LAST_TYPE,
 752   // Boundaries for testing the types represented as JSProxy
 753   FIRST_JS_PROXY_TYPE = JS_FUNCTION_PROXY_TYPE,
 754   LAST_JS_PROXY_TYPE = JS_PROXY_TYPE,
 755   // Boundaries for testing whether the type is a JavaScript object.
 756   FIRST_SPEC_OBJECT_TYPE = FIRST_JS_RECEIVER_TYPE,
 757   LAST_SPEC_OBJECT_TYPE = LAST_JS_RECEIVER_TYPE,
 758   // Boundaries for testing the types for which typeof is "object".
 759   FIRST_NONCALLABLE_SPEC_OBJECT_TYPE = JS_PROXY_TYPE,
 760   LAST_NONCALLABLE_SPEC_OBJECT_TYPE = JS_REGEXP_TYPE,
 761   // Note that the types for which typeof is "function" are not continuous.
 762   // Define this so that we can put assertions on discrete checks.
 763   NUM_OF_CALLABLE_SPEC_OBJECT_TYPES = 2
 764 };
 765
 766 STATIC_ASSERT(JS_OBJECT_TYPE == Internals::kJSObjectType);
 767 STATIC_ASSERT(FIRST_NONSTRING_TYPE == Internals::kFirstNonstringType);
 768 STATIC_ASSERT(ODDBALL_TYPE == Internals::kOddballType);
 769 STATIC_ASSERT(FOREIGN_TYPE == Internals::kForeignType);
 770
 771
 772 #define FIXED_ARRAY_SUB_INSTANCE_TYPE_LIST(V) \
 773   V(FAST_ELEMENTS_SUB_TYPE)                   \
 774   V(DICTIONARY_ELEMENTS_SUB_TYPE)             \
 775   V(FAST_PROPERTIES_SUB_TYPE)                 \
 776   V(DICTIONARY_PROPERTIES_SUB_TYPE)           \
 777   V(MAP_CODE_CACHE_SUB_TYPE)                  \
 778   V(SCOPE_INFO_SUB_TYPE)                      \
 779   V(STRING_TABLE_SUB_TYPE)                    \
 780   V(DESCRIPTOR_ARRAY_SUB_TYPE)                \
 781   V(TRANSITION_ARRAY_SUB_TYPE)
 782
 783 enum FixedArraySubInstanceType {
 784 #define DEFINE_FIXED_ARRAY_SUB_INSTANCE_TYPE(name) name,
 785   FIXED_ARRAY_SUB_INSTANCE_TYPE_LIST(DEFINE_FIXED_ARRAY_SUB_INSTANCE_TYPE)
 786 #undef DEFINE_FIXED_ARRAY_SUB_INSTANCE_TYPE
 787   LAST_FIXED_ARRAY_SUB_TYPE = TRANSITION_ARRAY_SUB_TYPE
 788 };
 789
 790
 791 enum CompareResult {
 792   LESS      = -1,
 793   EQUAL     =  0,
 794   GREATER   =  1,
 795
 796   NOT_EQUAL = GREATER
 797 };
 798
 799
 800 #define DECL_BOOLEAN_ACCESSORS(name)   \
 801   inline bool name() const;            \
 802   inline void set_##name(bool value);  \
 803
 804
 805 #define DECL_ACCESSORS(name, type)                                      \
 806   inline type* name() const;                                            \
 807   inline void set_##name(type* value,                                   \
 808                          WriteBarrierMode mode = UPDATE_WRITE_BARRIER); \
 809
 810
 811 #define DECLARE_CAST(type)                              \
 812   INLINE(static type* cast(Object* object));            \
 813   INLINE(static const type* cast(const Object* object));
 814
 815
 816 class AccessorPair;
 817 class AllocationSite;
 818 class AllocationSiteCreationContext;
 819 class AllocationSiteUsageContext;
 820 class Cell;
 821 class ConsString;
 822 class ElementsAccessor;
 823 class FixedArrayBase;
 824 class FunctionLiteral;
 825 class GlobalObject;
 826 class JSBuiltinsObject;
 827 class LayoutDescriptor;
 828 class LookupIterator;
 829 class ObjectHashTable;
 830 class ObjectVisitor;
 831 class PropertyCell;
 832 class SafepointEntry;
 833 class SharedFunctionInfo;
 834 class StringStream;
 835 class TypeFeedbackInfo;
 836 class TypeFeedbackVector;
 837 class WeakCell;
 838
 839 // We cannot just say "class HeapType;" if it is created from a template... =8-?
 840 template<class> class TypeImpl;
 841 struct HeapTypeConfig;
 842 typedef TypeImpl<HeapTypeConfig> HeapType;
 843
 844
 845 // A template-ized version of the IsXXX functions.
 846 template <class C> inline bool Is(Object* obj);
 847
 848 #ifdef VERIFY_HEAP
 849 #define DECLARE_VERIFIER(Name) void Name##Verify();
 850 #else
 851 #define DECLARE_VERIFIER(Name)
 852 #endif
 853
 854 #ifdef OBJECT_PRINT
 855 #define DECLARE_PRINTER(Name) void Name##Print(std::ostream& os);  // NOLINT
 856 #else
 857 #define DECLARE_PRINTER(Name)
 858 #endif
 859
 860
 861 #define OBJECT_TYPE_LIST(V) \
 862   V(Smi)                    \
 863   V(HeapObject)             \
 864   V(Number)
 865
 866 #define HEAP_OBJECT_TYPE_LIST(V)   \
 867   V(HeapNumber)                    \
 868   V(MutableHeapNumber)             \
 869   V(Simd128Value)                  \
 870   V(Float32x4)                     \
 871   V(Int32x4)                       \
 872   V(Uint32x4)                      \
 873   V(Bool32x4)                      \
 874   V(Int16x8)                       \
 875   V(Uint16x8)                      \
 876   V(Bool16x8)                      \
 877   V(Int8x16)                       \
 878   V(Uint8x16)                      \
 879   V(Bool8x16)                      \
 880   V(Name)                          \
 881   V(UniqueName)                    \
 882   V(String)                        \
 883   V(SeqString)                     \
 884   V(ExternalString)                \
 885   V(ConsString)                    \
 886   V(SlicedString)                  \
 887   V(ExternalTwoByteString)         \
 888   V(ExternalOneByteString)         \
 889   V(SeqTwoByteString)              \
 890   V(SeqOneByteString)              \
 891   V(InternalizedString)            \
 892   V(Symbol)                        \
 893                                    \
 894   V(FixedTypedArrayBase)           \
 895   V(FixedUint8Array)               \
 896   V(FixedInt8Array)                \
 897   V(FixedUint16Array)              \
 898   V(FixedInt16Array)               \
 899   V(FixedUint32Array)              \
 900   V(FixedInt32Array)               \
 901   V(FixedFloat32Array)             \
 902   V(FixedFloat64Array)             \
 903   V(FixedUint8ClampedArray)        \
 904   V(ByteArray)                     \
 905   V(BytecodeArray)                 \
 906   V(FreeSpace)                     \
 907   V(JSReceiver)                    \
 908   V(JSObject)                      \
 909   V(JSContextExtensionObject)      \
 910   V(JSGeneratorObject)             \
 911   V(JSModule)                      \
 912   V(LayoutDescriptor)              \
 913   V(Map)                           \
 914   V(DescriptorArray)               \
 915   V(TransitionArray)               \
 916   V(TypeFeedbackVector)            \
 917   V(DeoptimizationInputData)       \
 918   V(DeoptimizationOutputData)      \
 919   V(DependentCode)                 \
 920   V(HandlerTable)                  \
 921   V(FixedArray)                    \
 922   V(FixedDoubleArray)              \
 923   V(WeakFixedArray)                \
 924   V(ArrayList)                     \
 925   V(Context)                       \
 926   V(ScriptContextTable)            \
 927   V(NativeContext)                 \
 928   V(ScopeInfo)                     \
 929   V(JSFunction)                    \
 930   V(Code)                          \
 931   V(Oddball)                       \
 932   V(SharedFunctionInfo)            \
 933   V(JSValue)                       \
 934   V(JSDate)                        \
 935   V(JSMessageObject)               \
 936   V(StringWrapper)                 \
 937   V(Foreign)                       \
 938   V(Boolean)                       \
 939   V(JSArray)                       \
 940   V(JSArrayBuffer)                 \
 941   V(JSArrayBufferView)             \
 942   V(JSTypedArray)                  \
 943   V(JSDataView)                    \
 944   V(JSProxy)                       \
 945   V(JSFunctionProxy)               \
 946   V(JSSet)                         \
 947   V(JSMap)                         \
 948   V(JSSetIterator)                 \
 949   V(JSMapIterator)                 \
 950   V(JSWeakCollection)              \
 951   V(JSWeakMap)                     \
 952   V(JSWeakSet)                     \
 953   V(JSRegExp)                      \
 954   V(HashTable)                     \
 955   V(Dictionary)                    \
 956   V(StringTable)                   \
 957   V(NormalizedMapCache)            \
 958   V(CompilationCacheTable)         \
 959   V(CodeCacheHashTable)            \
 960   V(PolymorphicCodeCacheHashTable) \
 961   V(MapCache)                      \
 962   V(Primitive)                     \
 963   V(GlobalObject)                  \
 964   V(JSGlobalObject)                \
 965   V(JSBuiltinsObject)              \
 966   V(JSGlobalProxy)                 \
 967   V(UndetectableObject)            \
 968   V(AccessCheckNeeded)             \
 969   V(Cell)                          \
 970   V(PropertyCell)                  \
 971   V(WeakCell)                      \
 972   V(ObjectHashTable)               \
 973   V(WeakHashTable)                 \
 974   V(OrderedHashTable)
 975
 976 // Object is the abstract superclass for all classes in the
 977 // object hierarchy.
 978 // Object does not use any virtual functions to avoid the
 979 // allocation of the C++ vtable.
 980 // Since both Smi and HeapObject are subclasses of Object no
 981 // data members can be present in Object.
 982 class Object {
 983  public:
 984   // Type testing.
 985   bool IsObject() const { return true; }
 986
 987 #define IS_TYPE_FUNCTION_DECL(type_)  INLINE(bool Is##type_() const);
 988   OBJECT_TYPE_LIST(IS_TYPE_FUNCTION_DECL)
 989   HEAP_OBJECT_TYPE_LIST(IS_TYPE_FUNCTION_DECL)
 990 #undef IS_TYPE_FUNCTION_DECL
 991
 992   // A non-keyed store is of the form a.x = foo or a["x"] = foo whereas
 993   // a keyed store is of the form a[expression] = foo.
 994   enum StoreFromKeyed {
 995     MAY_BE_STORE_FROM_KEYED,
 996     CERTAINLY_NOT_STORE_FROM_KEYED
 997   };
 998
 999   INLINE(bool IsFixedArrayBase() const);
1000   INLINE(bool IsExternal() const);
1001   INLINE(bool IsAccessorInfo() const);
1002
1003   INLINE(bool IsStruct() const);
1004 #define DECLARE_STRUCT_PREDICATE(NAME, Name, name) \
1005   INLINE(bool Is##Name() const);
1006   STRUCT_LIST(DECLARE_STRUCT_PREDICATE)
1007 #undef DECLARE_STRUCT_PREDICATE
1008
1009   INLINE(bool IsSpecObject()) const;
1010   INLINE(bool IsSpecFunction()) const;
1011   INLINE(bool IsTemplateInfo()) const;
1012   INLINE(bool IsNameDictionary() const);
1013   INLINE(bool IsGlobalDictionary() const);
1014   INLINE(bool IsSeededNumberDictionary() const);
1015   INLINE(bool IsUnseededNumberDictionary() const);
1016   INLINE(bool IsOrderedHashSet() const);
1017   INLINE(bool IsOrderedHashMap() const);
1018   bool IsCallable() const;
1019   static bool IsPromise(Handle<Object> object);
1020
1021   // Oddball testing.
1022   INLINE(bool IsUndefined() const);
1023   INLINE(bool IsNull() const);
1024   INLINE(bool IsTheHole() const);
1025   INLINE(bool IsException() const);
1026   INLINE(bool IsUninitialized() const);
1027   INLINE(bool IsTrue() const);
1028   INLINE(bool IsFalse() const);
1029   INLINE(bool IsArgumentsMarker() const);
1030
1031   // Filler objects (fillers and free space objects).
1032   INLINE(bool IsFiller() const);
1033
1034   // Extract the number.
1035   inline double Number();
1036   INLINE(bool IsNaN() const);
1037   INLINE(bool IsMinusZero() const);
1038   bool ToInt32(int32_t* value);
1039   bool ToUint32(uint32_t* value);
1040
1041   inline Representation OptimalRepresentation();
1042
1043   inline ElementsKind OptimalElementsKind();
1044
1045   inline bool FitsRepresentation(Representation representation);
1046
1047   // Checks whether two valid primitive encodings of a property name resolve to
1048   // the same logical property. E.g., the smi 1, the string "1" and the double
1049   // 1 all refer to the same property, so this helper will return true.
1050   inline bool KeyEquals(Object* other);
1051
1052   Handle<HeapType> OptimalType(Isolate* isolate, Representation representation);
1053
1054   inline static Handle<Object> NewStorageFor(Isolate* isolate,
1055                                              Handle<Object> object,
1056                                              Representation representation);
1057
1058   inline static Handle<Object> WrapForRead(Isolate* isolate,
1059                                            Handle<Object> object,
1060                                            Representation representation);
1061
1062   // Returns true if the object is of the correct type to be used as a
1063   // implementation of a JSObject's elements.
1064   inline bool HasValidElements();
1065
1066   inline bool HasSpecificClassOf(String* name);
1067
1068   bool BooleanValue();                                      // ECMA-262 9.2.
1069
1070   // ES6 section 7.2.13 Strict Equality Comparison
1071   bool StrictEquals(Object* that);
1072
1073   // Convert to a JSObject if needed.
1074   // native_context is used when creating wrapper object.
1075   static inline MaybeHandle<JSReceiver> ToObject(Isolate* isolate,
1076                                                  Handle<Object> object);
1077   static MaybeHandle<JSReceiver> ToObject(Isolate* isolate,
1078                                           Handle<Object> object,
1079                                           Handle<Context> context);
1080
1081   MUST_USE_RESULT static MaybeHandle<Object> GetProperty(
1082       LookupIterator* it, LanguageMode language_mode = SLOPPY);
1083
1084   // Implementation of [[Put]], ECMA-262 5th edition, section 8.12.5.
1085   MUST_USE_RESULT static MaybeHandle<Object> SetProperty(
1086       Handle<Object> object, Handle<Name> name, Handle<Object> value,
1087       LanguageMode language_mode,
1088       StoreFromKeyed store_mode = MAY_BE_STORE_FROM_KEYED);
1089
1090   MUST_USE_RESULT static MaybeHandle<Object> SetProperty(
1091       LookupIterator* it, Handle<Object> value, LanguageMode language_mode,
1092       StoreFromKeyed store_mode);
1093
1094   MUST_USE_RESULT static MaybeHandle<Object> SetSuperProperty(
1095       LookupIterator* it, Handle<Object> value, LanguageMode language_mode,
1096       StoreFromKeyed store_mode);
1097
1098   MUST_USE_RESULT static MaybeHandle<Object> ReadAbsentProperty(
1099       LookupIterator* it, LanguageMode language_mode);
1100   MUST_USE_RESULT static MaybeHandle<Object> ReadAbsentProperty(
1101       Isolate* isolate, Handle<Object> receiver, Handle<Object> name,
1102       LanguageMode language_mode);
1103   MUST_USE_RESULT static MaybeHandle<Object> WriteToReadOnlyProperty(
1104       LookupIterator* it, Handle<Object> value, LanguageMode language_mode);
1105   MUST_USE_RESULT static MaybeHandle<Object> WriteToReadOnlyProperty(
1106       Isolate* isolate, Handle<Object> receiver, Handle<Object> name,
1107       Handle<Object> value, LanguageMode language_mode);
1108   MUST_USE_RESULT static MaybeHandle<Object> RedefineNonconfigurableProperty(
1109       Isolate* isolate, Handle<Object> name, Handle<Object> value,
1110       LanguageMode language_mode);
1111   MUST_USE_RESULT static MaybeHandle<Object> SetDataProperty(
1112       LookupIterator* it, Handle<Object> value);
1113   MUST_USE_RESULT static MaybeHandle<Object> AddDataProperty(
1114       LookupIterator* it, Handle<Object> value, PropertyAttributes attributes,
1115       LanguageMode language_mode, StoreFromKeyed store_mode);
1116   MUST_USE_RESULT static inline MaybeHandle<Object> GetPropertyOrElement(
1117       Handle<Object> object, Handle<Name> name,
1118       LanguageMode language_mode = SLOPPY);
1119   MUST_USE_RESULT static inline MaybeHandle<Object> GetProperty(
1120       Isolate* isolate, Handle<Object> object, const char* key,
1121       LanguageMode language_mode = SLOPPY);
1122   MUST_USE_RESULT static inline MaybeHandle<Object> GetProperty(
1123       Handle<Object> object, Handle<Name> name,
1124       LanguageMode language_mode = SLOPPY);
1125
1126   MUST_USE_RESULT static MaybeHandle<Object> GetPropertyWithAccessor(
1127       LookupIterator* it, LanguageMode language_mode);
1128   MUST_USE_RESULT static MaybeHandle<Object> SetPropertyWithAccessor(
1129       LookupIterator* it, Handle<Object> value, LanguageMode language_mode);
1130
1131   MUST_USE_RESULT static MaybeHandle<Object> GetPropertyWithDefinedGetter(
1132       Handle<Object> receiver,
1133       Handle<JSReceiver> getter);
1134   MUST_USE_RESULT static MaybeHandle<Object> SetPropertyWithDefinedSetter(
1135       Handle<Object> receiver,
1136       Handle<JSReceiver> setter,
1137       Handle<Object> value);
1138
1139   MUST_USE_RESULT static inline MaybeHandle<Object> GetElement(
1140       Isolate* isolate, Handle<Object> object, uint32_t index,
1141       LanguageMode language_mode = SLOPPY);
1142
1143   MUST_USE_RESULT static inline MaybeHandle<Object> SetElement(
1144       Isolate* isolate, Handle<Object> object, uint32_t index,
1145       Handle<Object> value, LanguageMode language_mode);
1146
1147   static inline Handle<Object> GetPrototypeSkipHiddenPrototypes(
1148       Isolate* isolate, Handle<Object> receiver);
1149
1150   bool HasInPrototypeChain(Isolate* isolate, Object* object);
1151
1152   // Returns the permanent hash code associated with this object. May return
1153   // undefined if not yet created.
1154   Object* GetHash();
1155
1156   // Returns undefined for JSObjects, but returns the hash code for simple
1157   // objects.  This avoids a double lookup in the cases where we know we will
1158   // add the hash to the JSObject if it does not already exist.
1159   Object* GetSimpleHash();
1160
1161   // Returns the permanent hash code associated with this object depending on
1162   // the actual object type. May create and store a hash code if needed and none
1163   // exists.
1164   static Handle<Smi> GetOrCreateHash(Isolate* isolate, Handle<Object> object);
1165
1166   // Checks whether this object has the same value as the given one.  This
1167   // function is implemented according to ES5, section 9.12 and can be used
1168   // to implement the Harmony "egal" function.
1169   bool SameValue(Object* other);
1170
1171   // Checks whether this object has the same value as the given one.
1172   // +0 and -0 are treated equal. Everything else is the same as SameValue.
1173   // This function is implemented according to ES6, section 7.2.4 and is used
1174   // by ES6 Map and Set.
1175   bool SameValueZero(Object* other);
1176
1177   // Tries to convert an object to an array length. Returns true and sets the
1178   // output parameter if it succeeds.
1179   inline bool ToArrayLength(uint32_t* index);
1180
1181   // Tries to convert an object to an array index. Returns true and sets the
1182   // output parameter if it succeeds. Equivalent to ToArrayLength, but does not
1183   // allow kMaxUInt32.
1184   inline bool ToArrayIndex(uint32_t* index);
1185
1186   // Returns true if this is a JSValue containing a string and the index is
1187   // < the length of the string.  Used to implement [] on strings.
1188   inline bool IsStringObjectWithCharacterAt(uint32_t index);
1189
1190   DECLARE_VERIFIER(Object)
1191 #ifdef VERIFY_HEAP
1192   // Verify a pointer is a valid object pointer.
1193   static void VerifyPointer(Object* p);
1194 #endif
1195
1196   inline void VerifyApiCallResultType();
1197
1198   // Prints this object without details.
1199   void ShortPrint(FILE* out = stdout);
1200
1201   // Prints this object without details to a message accumulator.
1202   void ShortPrint(StringStream* accumulator);
1203
1204   void ShortPrint(std::ostream& os);  // NOLINT
1205
1206   DECLARE_CAST(Object)
1207
1208   // Layout description.
1209   static const int kHeaderSize = 0;  // Object does not take up any space.
1210
1211 #ifdef OBJECT_PRINT
1212   // For our gdb macros, we should perhaps change these in the future.
1213   void Print();
1214
1215   // Prints this object with details.
1216   void Print(std::ostream& os);  // NOLINT
1217 #else
1218   void Print() { ShortPrint(); }
1219   void Print(std::ostream& os) { ShortPrint(os); }  // NOLINT
1220 #endif
1221
1222  private:
1223   friend class LookupIterator;
1224   friend class PrototypeIterator;
1225
1226   // Return the map of the root of object's prototype chain.
1227   Map* GetRootMap(Isolate* isolate);
1228
1229   // Helper for SetProperty and SetSuperProperty.
1230   MUST_USE_RESULT static MaybeHandle<Object> SetPropertyInternal(
1231       LookupIterator* it, Handle<Object> value, LanguageMode language_mode,
1232       StoreFromKeyed store_mode, bool* found);
1233
1234   DISALLOW_IMPLICIT_CONSTRUCTORS(Object);
1235 };
1236
1237
1238 // In objects.h to be usable without objects-inl.h inclusion.
1239 bool Object::IsSmi() const { return HAS_SMI_TAG(this); }
1240 bool Object::IsHeapObject() const { return Internals::HasHeapObjectTag(this); }
1241
1242
1243 struct Brief {
1244   explicit Brief(const Object* const v) : value(v) {}
1245   const Object* value;
1246 };
1247
1248
1249 std::ostream& operator<<(std::ostream& os, const Brief& v);
1250
1251
1252 // Smi represents integer Numbers that can be stored in 31 bits.
1253 // Smis are immediate which means they are NOT allocated in the heap.
1254 // The this pointer has the following format: [31 bit signed int] 0
1255 // For long smis it has the following format:
1256 //     [32 bit signed int] [31 bits zero padding] 0
1257 // Smi stands for small integer.
1258 class Smi: public Object {
1259  public:
1260   // Returns the integer value.
1261   inline int value() const { return Internals::SmiValue(this); }
1262
1263   // Convert a value to a Smi object.
1264   static inline Smi* FromInt(int value) {
1265     DCHECK(Smi::IsValid(value));
1266     return reinterpret_cast<Smi*>(Internals::IntToSmi(value));
1267   }
1268
1269   static inline Smi* FromIntptr(intptr_t value) {
1270     DCHECK(Smi::IsValid(value));
1271     int smi_shift_bits = kSmiTagSize + kSmiShiftSize;
1272     return reinterpret_cast<Smi*>((value << smi_shift_bits) | kSmiTag);
1273   }
1274
1275   // Returns whether value can be represented in a Smi.
1276   static inline bool IsValid(intptr_t value) {
1277     bool result = Internals::IsValidSmi(value);
1278     DCHECK_EQ(result, value >= kMinValue && value <= kMaxValue);
1279     return result;
1280   }
1281
1282   DECLARE_CAST(Smi)
1283
1284   // Dispatched behavior.
1285   void SmiPrint(std::ostream& os) const;  // NOLINT
1286   DECLARE_VERIFIER(Smi)
1287
1288   static const int kMinValue =
1289       (static_cast<unsigned int>(-1)) << (kSmiValueSize - 1);
1290   static const int kMaxValue = -(kMinValue + 1);
1291
1292  private:
1293   DISALLOW_IMPLICIT_CONSTRUCTORS(Smi);
1294 };
1295
1296
1297 // Heap objects typically have a map pointer in their first word.  However,
1298 // during GC other data (e.g. mark bits, forwarding addresses) is sometimes
1299 // encoded in the first word.  The class MapWord is an abstraction of the
1300 // value in a heap object's first word.
1301 class MapWord BASE_EMBEDDED {
1302  public:
1303   // Normal state: the map word contains a map pointer.
1304
1305   // Create a map word from a map pointer.
1306   static inline MapWord FromMap(const Map* map);
1307
1308   // View this map word as a map pointer.
1309   inline Map* ToMap();
1310
1311
1312   // Scavenge collection: the map word of live objects in the from space
1313   // contains a forwarding address (a heap object pointer in the to space).
1314
1315   // True if this map word is a forwarding address for a scavenge
1316   // collection.  Only valid during a scavenge collection (specifically,
1317   // when all map words are heap object pointers, i.e. not during a full GC).
1318   inline bool IsForwardingAddress();
1319
1320   // Create a map word from a forwarding address.
1321   static inline MapWord FromForwardingAddress(HeapObject* object);
1322
1323   // View this map word as a forwarding address.
1324   inline HeapObject* ToForwardingAddress();
1325
1326   static inline MapWord FromRawValue(uintptr_t value) {
1327     return MapWord(value);
1328   }
1329
1330   inline uintptr_t ToRawValue() {
1331     return value_;
1332   }
1333
1334  private:
1335   // HeapObject calls the private constructor and directly reads the value.
1336   friend class HeapObject;
1337
1338   explicit MapWord(uintptr_t value) : value_(value) {}
1339
1340   uintptr_t value_;
1341 };
1342
1343
1344 // The content of an heap object (except for the map pointer). kTaggedValues
1345 // objects can contain both heap pointers and Smis, kMixedValues can contain
1346 // heap pointers, Smis, and raw values (e.g. doubles or strings), and kRawValues
1347 // objects can contain raw values and Smis.
1348 enum class HeapObjectContents { kTaggedValues, kMixedValues, kRawValues };
1349
1350
1351 // HeapObject is the superclass for all classes describing heap allocated
1352 // objects.
1353 class HeapObject: public Object {
1354  public:
1355   // [map]: Contains a map which contains the object's reflective
1356   // information.
1357   inline Map* map() const;
1358   inline void set_map(Map* value);
1359   // The no-write-barrier version.  This is OK if the object is white and in
1360   // new space, or if the value is an immortal immutable object, like the maps
1361   // of primitive (non-JS) objects like strings, heap numbers etc.
1362   inline void set_map_no_write_barrier(Map* value);
1363
1364   // Get the map using acquire load.
1365   inline Map* synchronized_map();
1366   inline MapWord synchronized_map_word() const;
1367
1368   // Set the map using release store
1369   inline void synchronized_set_map(Map* value);
1370   inline void synchronized_set_map_no_write_barrier(Map* value);
1371   inline void synchronized_set_map_word(MapWord map_word);
1372
1373   // During garbage collection, the map word of a heap object does not
1374   // necessarily contain a map pointer.
1375   inline MapWord map_word() const;
1376   inline void set_map_word(MapWord map_word);
1377
1378   // The Heap the object was allocated in. Used also to access Isolate.
1379   inline Heap* GetHeap() const;
1380
1381   // Convenience method to get current isolate.
1382   inline Isolate* GetIsolate() const;
1383
1384   // Converts an address to a HeapObject pointer.
1385   static inline HeapObject* FromAddress(Address address) {
1386     DCHECK_TAG_ALIGNED(address);
1387     return reinterpret_cast<HeapObject*>(address + kHeapObjectTag);
1388   }
1389
1390   // Returns the address of this HeapObject.
1391   inline Address address() {
1392     return reinterpret_cast<Address>(this) - kHeapObjectTag;
1393   }
1394
1395   // Iterates over pointers contained in the object (including the Map)
1396   void Iterate(ObjectVisitor* v);
1397
1398   // Iterates over all pointers contained in the object except the
1399   // first map pointer.  The object type is given in the first
1400   // parameter. This function does not access the map pointer in the
1401   // object, and so is safe to call while the map pointer is modified.
1402   void IterateBody(InstanceType type, int object_size, ObjectVisitor* v);
1403
1404   // Returns the heap object's size in bytes
1405   inline int Size();
1406
1407   // Indicates what type of values this heap object may contain.
1408   inline HeapObjectContents ContentType();
1409
1410   // Given a heap object's map pointer, returns the heap size in bytes
1411   // Useful when the map pointer field is used for other purposes.
1412   // GC internal.
1413   inline int SizeFromMap(Map* map);
1414
1415   // Returns the field at offset in obj, as a read/write Object* reference.
1416   // Does no checking, and is safe to use during GC, while maps are invalid.
1417   // Does not invoke write barrier, so should only be assigned to
1418   // during marking GC.
1419   static inline Object** RawField(HeapObject* obj, int offset);
1420
1421   // Adds the |code| object related to |name| to the code cache of this map. If
1422   // this map is a dictionary map that is shared, the map copied and installed
1423   // onto the object.
1424   static void UpdateMapCodeCache(Handle<HeapObject> object,
1425                                  Handle<Name> name,
1426                                  Handle<Code> code);
1427
1428   DECLARE_CAST(HeapObject)
1429
1430   // Return the write barrier mode for this. Callers of this function
1431   // must be able to present a reference to an DisallowHeapAllocation
1432   // object as a sign that they are not going to use this function
1433   // from code that allocates and thus invalidates the returned write
1434   // barrier mode.
1435   inline WriteBarrierMode GetWriteBarrierMode(
1436       const DisallowHeapAllocation& promise);
1437
1438   // Dispatched behavior.
1439   void HeapObjectShortPrint(std::ostream& os);  // NOLINT
1440 #ifdef OBJECT_PRINT
1441   void PrintHeader(std::ostream& os, const char* id);  // NOLINT
1442 #endif
1443   DECLARE_PRINTER(HeapObject)
1444   DECLARE_VERIFIER(HeapObject)
1445 #ifdef VERIFY_HEAP
1446   inline void VerifyObjectField(int offset);
1447   inline void VerifySmiField(int offset);
1448
1449   // Verify a pointer is a valid HeapObject pointer that points to object
1450   // areas in the heap.
1451   static void VerifyHeapPointer(Object* p);
1452 #endif
1453
1454   inline AllocationAlignment RequiredAlignment();
1455
1456   // Layout description.
1457   // First field in a heap object is map.
1458   static const int kMapOffset = Object::kHeaderSize;
1459   static const int kHeaderSize = kMapOffset + kPointerSize;
1460
1461   STATIC_ASSERT(kMapOffset == Internals::kHeapObjectMapOffset);
1462
1463  protected:
1464   // helpers for calling an ObjectVisitor to iterate over pointers in the
1465   // half-open range [start, end) specified as integer offsets
1466   inline void IteratePointers(ObjectVisitor* v, int start, int end);
1467   // as above, for the single element at "offset"
1468   inline void IteratePointer(ObjectVisitor* v, int offset);
1469   // as above, for the next code link of a code object.
1470   inline void IterateNextCodeLink(ObjectVisitor* v, int offset);
1471
1472  private:
1473   DISALLOW_IMPLICIT_CONSTRUCTORS(HeapObject);
1474 };
1475
1476
1477 // This class describes a body of an object of a fixed size
1478 // in which all pointer fields are located in the [start_offset, end_offset)
1479 // interval.
1480 template<int start_offset, int end_offset, int size>
1481 class FixedBodyDescriptor {
1482  public:
1483   static const int kStartOffset = start_offset;
1484   static const int kEndOffset = end_offset;
1485   static const int kSize = size;
1486
1487   static inline void IterateBody(HeapObject* obj, ObjectVisitor* v);
1488
1489   template<typename StaticVisitor>
1490   static inline void IterateBody(HeapObject* obj) {
1491     StaticVisitor::VisitPointers(HeapObject::RawField(obj, start_offset),
1492                                  HeapObject::RawField(obj, end_offset));
1493   }
1494 };
1495
1496
1497 // This class describes a body of an object of a variable size
1498 // in which all pointer fields are located in the [start_offset, object_size)
1499 // interval.
1500 template<int start_offset>
1501 class FlexibleBodyDescriptor {
1502  public:
1503   static const int kStartOffset = start_offset;
1504
1505   static inline void IterateBody(HeapObject* obj,
1506                                  int object_size,
1507                                  ObjectVisitor* v);
1508
1509   template<typename StaticVisitor>
1510   static inline void IterateBody(HeapObject* obj, int object_size) {
1511     StaticVisitor::VisitPointers(HeapObject::RawField(obj, start_offset),
1512                                  HeapObject::RawField(obj, object_size));
1513   }
1514 };
1515
1516
1517 // The HeapNumber class describes heap allocated numbers that cannot be
1518 // represented in a Smi (small integer)
1519 class HeapNumber: public HeapObject {
1520  public:
1521   // [value]: number value.
1522   inline double value() const;
1523   inline void set_value(double value);
1524
1525   DECLARE_CAST(HeapNumber)
1526
1527   // Dispatched behavior.
1528   bool HeapNumberBooleanValue();
1529
1530   void HeapNumberPrint(std::ostream& os);  // NOLINT
1531   DECLARE_VERIFIER(HeapNumber)
1532
1533   inline int get_exponent();
1534   inline int get_sign();
1535
1536   // Layout description.
1537   static const int kValueOffset = HeapObject::kHeaderSize;
1538   // IEEE doubles are two 32 bit words.  The first is just mantissa, the second
1539   // is a mixture of sign, exponent and mantissa. The offsets of two 32 bit
1540   // words within double numbers are endian dependent and they are set
1541   // accordingly.
1542 #if defined(V8_TARGET_LITTLE_ENDIAN)
1543   static const int kMantissaOffset = kValueOffset;
1544   static const int kExponentOffset = kValueOffset + 4;
1545 #elif defined(V8_TARGET_BIG_ENDIAN)
1546   static const int kMantissaOffset = kValueOffset + 4;
1547   static const int kExponentOffset = kValueOffset;
1548 #else
1549 #error Unknown byte ordering
1550 #endif
1551
1552   static const int kSize = kValueOffset + kDoubleSize;
1553   static const uint32_t kSignMask = 0x80000000u;
1554   static const uint32_t kExponentMask = 0x7ff00000u;
1555   static const uint32_t kMantissaMask = 0xfffffu;
1556   static const int kMantissaBits = 52;
1557   static const int kExponentBits = 11;
1558   static const int kExponentBias = 1023;
1559   static const int kExponentShift = 20;
1560   static const int kInfinityOrNanExponent =
1561       (kExponentMask >> kExponentShift) - kExponentBias;
1562   static const int kMantissaBitsInTopWord = 20;
1563   static const int kNonMantissaBitsInTopWord = 12;
1564
1565  private:
1566   DISALLOW_IMPLICIT_CONSTRUCTORS(HeapNumber);
1567 };
1568
1569
1570 // The Simd128Value class describes heap allocated 128 bit SIMD values.
1571 class Simd128Value : public HeapObject {
1572  public:
1573   DECLARE_CAST(Simd128Value)
1574
1575   DECLARE_PRINTER(Simd128Value)
1576   DECLARE_VERIFIER(Simd128Value)
1577
1578   // Equality operations.
1579   inline bool Equals(Simd128Value* that);
1580
1581   // Checks that another instance is bit-wise equal.
1582   bool BitwiseEquals(const Simd128Value* other) const;
1583   // Computes a hash from the 128 bit value, viewed as 4 32-bit integers.
1584   uint32_t Hash() const;
1585   // Copies the 16 bytes of SIMD data to the destination address.
1586   void CopyBits(void* destination) const;
1587
1588   // Layout description.
1589   static const int kValueOffset = HeapObject::kHeaderSize;
1590   static const int kSize = kValueOffset + kSimd128Size;
1591
1592  private:
1593   DISALLOW_IMPLICIT_CONSTRUCTORS(Simd128Value);
1594 };
1595
1596
1597 // V has parameters (TYPE, Type, type, lane count, lane type)
1598 #define SIMD128_TYPES(V)                       \
1599   V(FLOAT32X4, Float32x4, float32x4, 4, float) \
1600   V(INT32X4, Int32x4, int32x4, 4, int32_t)     \
1601   V(UINT32X4, Uint32x4, uint32x4, 4, uint32_t) \
1602   V(BOOL32X4, Bool32x4, bool32x4, 4, bool)     \
1603   V(INT16X8, Int16x8, int16x8, 8, int16_t)     \
1604   V(UINT16X8, Uint16x8, uint16x8, 8, uint16_t) \
1605   V(BOOL16X8, Bool16x8, bool16x8, 8, bool)     \
1606   V(INT8X16, Int8x16, int8x16, 16, int8_t)     \
1607   V(UINT8X16, Uint8x16, uint8x16, 16, uint8_t) \
1608   V(BOOL8X16, Bool8x16, bool8x16, 16, bool)
1609
1610 #define SIMD128_VALUE_CLASS(TYPE, Type, type, lane_count, lane_type) \
1611   class Type final : public Simd128Value {                           \
1612    public:                                                           \
1613     inline lane_type get_lane(int lane) const;                       \
1614     inline void set_lane(int lane, lane_type value);                 \
1615                                                                      \
1616     DECLARE_CAST(Type)                                               \
1617                                                                      \
1618     DECLARE_PRINTER(Type)                                            \
1619                                                                      \
1620     inline bool Equals(Type* that);                                  \
1621                                                                      \
1622    private:                                                          \
1623     DISALLOW_IMPLICIT_CONSTRUCTORS(Type);                            \
1624   };
1625 SIMD128_TYPES(SIMD128_VALUE_CLASS)
1626 #undef SIMD128_VALUE_CLASS
1627
1628
1629 enum EnsureElementsMode {
1630   DONT_ALLOW_DOUBLE_ELEMENTS,
1631   ALLOW_COPIED_DOUBLE_ELEMENTS,
1632   ALLOW_CONVERTED_DOUBLE_ELEMENTS
1633 };
1634
1635
1636 // Indicator for one component of an AccessorPair.
1637 enum AccessorComponent {
1638   ACCESSOR_GETTER,
1639   ACCESSOR_SETTER
1640 };
1641
1642
1643 // JSReceiver includes types on which properties can be defined, i.e.,
1644 // JSObject and JSProxy.
1645 class JSReceiver: public HeapObject {
1646  public:
1647   DECLARE_CAST(JSReceiver)
1648
1649   // Implementation of [[HasProperty]], ECMA-262 5th edition, section 8.12.6.
1650   MUST_USE_RESULT static inline Maybe<bool> HasProperty(
1651       Handle<JSReceiver> object, Handle<Name> name);
1652   MUST_USE_RESULT static inline Maybe<bool> HasOwnProperty(Handle<JSReceiver>,
1653                                                            Handle<Name> name);
1654   MUST_USE_RESULT static inline Maybe<bool> HasElement(
1655       Handle<JSReceiver> object, uint32_t index);
1656   MUST_USE_RESULT static inline Maybe<bool> HasOwnElement(
1657       Handle<JSReceiver> object, uint32_t index);
1658
1659   // Implementation of [[Delete]], ECMA-262 5th edition, section 8.12.7.
1660   MUST_USE_RESULT static MaybeHandle<Object> DeletePropertyOrElement(
1661       Handle<JSReceiver> object, Handle<Name> name,
1662       LanguageMode language_mode = SLOPPY);
1663   MUST_USE_RESULT static MaybeHandle<Object> DeleteProperty(
1664       Handle<JSReceiver> object, Handle<Name> name,
1665       LanguageMode language_mode = SLOPPY);
1666   MUST_USE_RESULT static MaybeHandle<Object> DeleteProperty(
1667       LookupIterator* it, LanguageMode language_mode);
1668   MUST_USE_RESULT static MaybeHandle<Object> DeleteElement(
1669       Handle<JSReceiver> object, uint32_t index,
1670       LanguageMode language_mode = SLOPPY);
1671
1672   // Tests for the fast common case for property enumeration.
1673   bool IsSimpleEnum();
1674
1675   // Returns the class name ([[Class]] property in the specification).
1676   String* class_name();
1677
1678   // Returns the constructor name (the name (possibly, inferred name) of the
1679   // function that was used to instantiate the object).
1680   String* constructor_name();
1681
1682   MUST_USE_RESULT static inline Maybe<PropertyAttributes> GetPropertyAttributes(
1683       Handle<JSReceiver> object, Handle<Name> name);
1684   MUST_USE_RESULT static inline Maybe<PropertyAttributes>
1685   GetOwnPropertyAttributes(Handle<JSReceiver> object, Handle<Name> name);
1686
1687   MUST_USE_RESULT static inline Maybe<PropertyAttributes> GetElementAttributes(
1688       Handle<JSReceiver> object, uint32_t index);
1689   MUST_USE_RESULT static inline Maybe<PropertyAttributes>
1690   GetOwnElementAttributes(Handle<JSReceiver> object, uint32_t index);
1691
1692   MUST_USE_RESULT static Maybe<PropertyAttributes> GetPropertyAttributes(
1693       LookupIterator* it);
1694
1695
1696   static Handle<Object> GetDataProperty(Handle<JSReceiver> object,
1697                                         Handle<Name> name);
1698   static Handle<Object> GetDataProperty(LookupIterator* it);
1699
1700
1701   // Retrieves a permanent object identity hash code. The undefined value might
1702   // be returned in case no hash was created yet.
1703   inline Object* GetIdentityHash();
1704
1705   // Retrieves a permanent object identity hash code. May create and store a
1706   // hash code if needed and none exists.
1707   inline static Handle<Smi> GetOrCreateIdentityHash(
1708       Handle<JSReceiver> object);
1709
1710   enum KeyCollectionType { OWN_ONLY, INCLUDE_PROTOS };
1711
1712   // Computes the enumerable keys for a JSObject. Used for implementing
1713   // "for (n in object) { }".
1714   MUST_USE_RESULT static MaybeHandle<FixedArray> GetKeys(
1715       Handle<JSReceiver> object,
1716       KeyCollectionType type);
1717
1718  private:
1719   DISALLOW_IMPLICIT_CONSTRUCTORS(JSReceiver);
1720 };
1721
1722
1723 // The JSObject describes real heap allocated JavaScript objects with
1724 // properties.
1725 // Note that the map of JSObject changes during execution to enable inline
1726 // caching.
1727 class JSObject: public JSReceiver {
1728  public:
1729   // [properties]: Backing storage for properties.
1730   // properties is a FixedArray in the fast case and a Dictionary in the
1731   // slow case.
1732   DECL_ACCESSORS(properties, FixedArray)  // Get and set fast properties.
1733   inline void initialize_properties();
1734   inline bool HasFastProperties();
1735   // Gets slow properties for non-global objects.
1736   inline NameDictionary* property_dictionary();
1737   // Gets global object properties.
1738   inline GlobalDictionary* global_dictionary();
1739
1740   // [elements]: The elements (properties with names that are integers).
1741   //
1742   // Elements can be in two general modes: fast and slow. Each mode
1743   // corrensponds to a set of object representations of elements that
1744   // have something in common.
1745   //
1746   // In the fast mode elements is a FixedArray and so each element can
1747   // be quickly accessed. This fact is used in the generated code. The
1748   // elements array can have one of three maps in this mode:
1749   // fixed_array_map, sloppy_arguments_elements_map or
1750   // fixed_cow_array_map (for copy-on-write arrays). In the latter case
1751   // the elements array may be shared by a few objects and so before
1752   // writing to any element the array must be copied. Use
1753   // EnsureWritableFastElements in this case.
1754   //
1755   // In the slow mode the elements is either a NumberDictionary, a
1756   // FixedArray parameter map for a (sloppy) arguments object.
1757   DECL_ACCESSORS(elements, FixedArrayBase)
1758   inline void initialize_elements();
1759   static void ResetElements(Handle<JSObject> object);
1760   static inline void SetMapAndElements(Handle<JSObject> object,
1761                                        Handle<Map> map,
1762                                        Handle<FixedArrayBase> elements);
1763   inline ElementsKind GetElementsKind();
1764   ElementsAccessor* GetElementsAccessor();
1765   // Returns true if an object has elements of FAST_SMI_ELEMENTS ElementsKind.
1766   inline bool HasFastSmiElements();
1767   // Returns true if an object has elements of FAST_ELEMENTS ElementsKind.
1768   inline bool HasFastObjectElements();
1769   // Returns true if an object has elements of FAST_ELEMENTS or
1770   // FAST_SMI_ONLY_ELEMENTS.
1771   inline bool HasFastSmiOrObjectElements();
1772   // Returns true if an object has any of the fast elements kinds.
1773   inline bool HasFastElements();
1774   // Returns true if an object has elements of FAST_DOUBLE_ELEMENTS
1775   // ElementsKind.
1776   inline bool HasFastDoubleElements();
1777   // Returns true if an object has elements of FAST_HOLEY_*_ELEMENTS
1778   // ElementsKind.
1779   inline bool HasFastHoleyElements();
1780   inline bool HasSloppyArgumentsElements();
1781   inline bool HasDictionaryElements();
1782
1783   inline bool HasFixedTypedArrayElements();
1784
1785   inline bool HasFixedUint8ClampedElements();
1786   inline bool HasFixedArrayElements();
1787   inline bool HasFixedInt8Elements();
1788   inline bool HasFixedUint8Elements();
1789   inline bool HasFixedInt16Elements();
1790   inline bool HasFixedUint16Elements();
1791   inline bool HasFixedInt32Elements();
1792   inline bool HasFixedUint32Elements();
1793   inline bool HasFixedFloat32Elements();
1794   inline bool HasFixedFloat64Elements();
1795
1796   inline bool HasFastArgumentsElements();
1797   inline bool HasSlowArgumentsElements();
1798   inline SeededNumberDictionary* element_dictionary();  // Gets slow elements.
1799
1800   // Requires: HasFastElements().
1801   static Handle<FixedArray> EnsureWritableFastElements(
1802       Handle<JSObject> object);
1803
1804   // Collects elements starting at index 0.
1805   // Undefined values are placed after non-undefined values.
1806   // Returns the number of non-undefined values.
1807   static Handle<Object> PrepareElementsForSort(Handle<JSObject> object,
1808                                                uint32_t limit);
1809   // As PrepareElementsForSort, but only on objects where elements is
1810   // a dictionary, and it will stay a dictionary.  Collates undefined and
1811   // unexisting elements below limit from position zero of the elements.
1812   static Handle<Object> PrepareSlowElementsForSort(Handle<JSObject> object,
1813                                                    uint32_t limit);
1814
1815   MUST_USE_RESULT static MaybeHandle<Object> SetPropertyWithInterceptor(
1816       LookupIterator* it, Handle<Object> value);
1817
1818   // SetLocalPropertyIgnoreAttributes converts callbacks to fields. We need to
1819   // grant an exemption to ExecutableAccessor callbacks in some cases.
1820   enum ExecutableAccessorInfoHandling { DEFAULT_HANDLING, DONT_FORCE_FIELD };
1821
1822   MUST_USE_RESULT static MaybeHandle<Object> DefineOwnPropertyIgnoreAttributes(
1823       LookupIterator* it, Handle<Object> value, PropertyAttributes attributes,
1824       ExecutableAccessorInfoHandling handling = DEFAULT_HANDLING);
1825
1826   MUST_USE_RESULT static MaybeHandle<Object> SetOwnPropertyIgnoreAttributes(
1827       Handle<JSObject> object, Handle<Name> name, Handle<Object> value,
1828       PropertyAttributes attributes,
1829       ExecutableAccessorInfoHandling handling = DEFAULT_HANDLING);
1830
1831   MUST_USE_RESULT static MaybeHandle<Object> SetOwnElementIgnoreAttributes(
1832       Handle<JSObject> object, uint32_t index, Handle<Object> value,
1833       PropertyAttributes attributes,
1834       ExecutableAccessorInfoHandling handling = DEFAULT_HANDLING);
1835
1836   // Equivalent to one of the above depending on whether |name| can be converted
1837   // to an array index.
1838   MUST_USE_RESULT static MaybeHandle<Object>
1839   DefinePropertyOrElementIgnoreAttributes(
1840       Handle<JSObject> object, Handle<Name> name, Handle<Object> value,
1841       PropertyAttributes attributes = NONE,
1842       ExecutableAccessorInfoHandling handling = DEFAULT_HANDLING);
1843
1844   // Adds or reconfigures a property to attributes NONE. It will fail when it
1845   // cannot.
1846   MUST_USE_RESULT static Maybe<bool> CreateDataProperty(LookupIterator* it,
1847                                                         Handle<Object> value);
1848
1849   static void AddProperty(Handle<JSObject> object, Handle<Name> name,
1850                           Handle<Object> value, PropertyAttributes attributes);
1851
1852   MUST_USE_RESULT static MaybeHandle<Object> AddDataElement(
1853       Handle<JSObject> receiver, uint32_t index, Handle<Object> value,
1854       PropertyAttributes attributes);
1855
1856   // Extend the receiver with a single fast property appeared first in the
1857   // passed map. This also extends the property backing store if necessary.
1858   static void AllocateStorageForMap(Handle<JSObject> object, Handle<Map> map);
1859
1860   // Migrates the given object to a map whose field representations are the
1861   // lowest upper bound of all known representations for that field.
1862   static void MigrateInstance(Handle<JSObject> instance);
1863
1864   // Migrates the given object only if the target map is already available,
1865   // or returns false if such a map is not yet available.
1866   static bool TryMigrateInstance(Handle<JSObject> instance);
1867
1868   // Sets the property value in a normalized object given (key, value, details).
1869   // Handles the special representation of JS global objects.
1870   static void SetNormalizedProperty(Handle<JSObject> object, Handle<Name> name,
1871                                     Handle<Object> value,
1872                                     PropertyDetails details);
1873   static void SetDictionaryElement(Handle<JSObject> object, uint32_t index,
1874                                    Handle<Object> value,
1875                                    PropertyAttributes attributes);
1876   static void SetDictionaryArgumentsElement(Handle<JSObject> object,
1877                                             uint32_t index,
1878                                             Handle<Object> value,
1879                                             PropertyAttributes attributes);
1880
1881   static void OptimizeAsPrototype(Handle<JSObject> object,
1882                                   PrototypeOptimizationMode mode);
1883   static void ReoptimizeIfPrototype(Handle<JSObject> object);
1884   static void LazyRegisterPrototypeUser(Handle<Map> user, Isolate* isolate);
1885   static bool UnregisterPrototypeUser(Handle<Map> user, Isolate* isolate);
1886   static void InvalidatePrototypeChains(Map* map);
1887
1888   // Alternative implementation of WeakFixedArray::NullCallback.
1889   class PrototypeRegistryCompactionCallback {
1890    public:
1891     static void Callback(Object* value, int old_index, int new_index);
1892   };
1893
1894   // Retrieve interceptors.
1895   InterceptorInfo* GetNamedInterceptor();
1896   InterceptorInfo* GetIndexedInterceptor();
1897
1898   // Used from JSReceiver.
1899   MUST_USE_RESULT static Maybe<PropertyAttributes>
1900   GetPropertyAttributesWithInterceptor(LookupIterator* it);
1901   MUST_USE_RESULT static Maybe<PropertyAttributes>
1902       GetPropertyAttributesWithFailedAccessCheck(LookupIterator* it);
1903
1904   // Retrieves an AccessorPair property from the given object. Might return
1905   // undefined if the property doesn't exist or is of a different kind.
1906   MUST_USE_RESULT static MaybeHandle<Object> GetAccessor(
1907       Handle<JSObject> object,
1908       Handle<Name> name,
1909       AccessorComponent component);
1910
1911   // Defines an AccessorPair property on the given object.
1912   // TODO(mstarzinger): Rename to SetAccessor().
1913   static MaybeHandle<Object> DefineAccessor(Handle<JSObject> object,
1914                                             Handle<Name> name,
1915                                             Handle<Object> getter,
1916                                             Handle<Object> setter,
1917                                             PropertyAttributes attributes);
1918
1919   // Defines an AccessorInfo property on the given object.
1920   MUST_USE_RESULT static MaybeHandle<Object> SetAccessor(
1921       Handle<JSObject> object,
1922       Handle<AccessorInfo> info);
1923
1924   // The result must be checked first for exceptions. If there's no exception,
1925   // the output parameter |done| indicates whether the interceptor has a result
1926   // or not.
1927   MUST_USE_RESULT static MaybeHandle<Object> GetPropertyWithInterceptor(
1928       LookupIterator* it, bool* done);
1929
1930   // Accessors for hidden properties object.
1931   //
1932   // Hidden properties are not own properties of the object itself.
1933   // Instead they are stored in an auxiliary structure kept as an own
1934   // property with a special name Heap::hidden_string(). But if the
1935   // receiver is a JSGlobalProxy then the auxiliary object is a property
1936   // of its prototype, and if it's a detached proxy, then you can't have
1937   // hidden properties.
1938
1939   // Sets a hidden property on this object. Returns this object if successful,
1940   // undefined if called on a detached proxy.
1941   static Handle<Object> SetHiddenProperty(Handle<JSObject> object,
1942                                           Handle<Name> key,
1943                                           Handle<Object> value);
1944   // Gets the value of a hidden property with the given key. Returns the hole
1945   // if the property doesn't exist (or if called on a detached proxy),
1946   // otherwise returns the value set for the key.
1947   Object* GetHiddenProperty(Handle<Name> key);
1948   // Deletes a hidden property. Deleting a non-existing property is
1949   // considered successful.
1950   static void DeleteHiddenProperty(Handle<JSObject> object,
1951                                    Handle<Name> key);
1952   // Returns true if the object has a property with the hidden string as name.
1953   static bool HasHiddenProperties(Handle<JSObject> object);
1954
1955   static void SetIdentityHash(Handle<JSObject> object, Handle<Smi> hash);
1956
1957   static void ValidateElements(Handle<JSObject> object);
1958
1959   // Makes sure that this object can contain HeapObject as elements.
1960   static inline void EnsureCanContainHeapObjectElements(Handle<JSObject> obj);
1961
1962   // Makes sure that this object can contain the specified elements.
1963   static inline void EnsureCanContainElements(
1964       Handle<JSObject> object,
1965       Object** elements,
1966       uint32_t count,
1967       EnsureElementsMode mode);
1968   static inline void EnsureCanContainElements(
1969       Handle<JSObject> object,
1970       Handle<FixedArrayBase> elements,
1971       uint32_t length,
1972       EnsureElementsMode mode);
1973   static void EnsureCanContainElements(
1974       Handle<JSObject> object,
1975       Arguments* arguments,
1976       uint32_t first_arg,
1977       uint32_t arg_count,
1978       EnsureElementsMode mode);
1979
1980   // Would we convert a fast elements array to dictionary mode given
1981   // an access at key?
1982   bool WouldConvertToSlowElements(uint32_t index);
1983
1984   // Computes the new capacity when expanding the elements of a JSObject.
1985   static uint32_t NewElementsCapacity(uint32_t old_capacity) {
1986     // (old_capacity + 50%) + 16
1987     return old_capacity + (old_capacity >> 1) + 16;
1988   }
1989
1990   // These methods do not perform access checks!
1991   static void UpdateAllocationSite(Handle<JSObject> object,
1992                                    ElementsKind to_kind);
1993
1994   // Lookup interceptors are used for handling properties controlled by host
1995   // objects.
1996   inline bool HasNamedInterceptor();
1997   inline bool HasIndexedInterceptor();
1998
1999   // Computes the enumerable keys from interceptors. Used for debug mirrors and
2000   // by JSReceiver::GetKeys.
2001   MUST_USE_RESULT static MaybeHandle<JSObject> GetKeysForNamedInterceptor(
2002       Handle<JSObject> object,
2003       Handle<JSReceiver> receiver);
2004   MUST_USE_RESULT static MaybeHandle<JSObject> GetKeysForIndexedInterceptor(
2005       Handle<JSObject> object,
2006       Handle<JSReceiver> receiver);
2007
2008   // Support functions for v8 api (needed for correct interceptor behavior).
2009   MUST_USE_RESULT static Maybe<bool> HasRealNamedProperty(
2010       Handle<JSObject> object, Handle<Name> name);
2011   MUST_USE_RESULT static Maybe<bool> HasRealElementProperty(
2012       Handle<JSObject> object, uint32_t index);
2013   MUST_USE_RESULT static Maybe<bool> HasRealNamedCallbackProperty(
2014       Handle<JSObject> object, Handle<Name> name);
2015
2016   // Get the header size for a JSObject.  Used to compute the index of
2017   // internal fields as well as the number of internal fields.
2018   inline int GetHeaderSize();
2019
2020   inline int GetInternalFieldCount();
2021   inline int GetInternalFieldOffset(int index);
2022   inline Object* GetInternalField(int index);
2023   inline void SetInternalField(int index, Object* value);
2024   inline void SetInternalField(int index, Smi* value);
2025
2026   // Returns the number of properties on this object filtering out properties
2027   // with the specified attributes (ignoring interceptors).
2028   int NumberOfOwnProperties(PropertyAttributes filter = NONE);
2029   // Fill in details for properties into storage starting at the specified
2030   // index. Returns the number of properties added.
2031   int GetOwnPropertyNames(FixedArray* storage, int index,
2032                           PropertyAttributes filter = NONE);
2033
2034   // Returns the number of properties on this object filtering out properties
2035   // with the specified attributes (ignoring interceptors).
2036   int NumberOfOwnElements(PropertyAttributes filter);
2037   // Returns the number of enumerable elements (ignoring interceptors).
2038   int NumberOfEnumElements();
2039   // Returns the number of elements on this object filtering out elements
2040   // with the specified attributes (ignoring interceptors).
2041   int GetOwnElementKeys(FixedArray* storage, PropertyAttributes filter);
2042   // Count and fill in the enumerable elements into storage.
2043   // (storage->length() == NumberOfEnumElements()).
2044   // If storage is NULL, will count the elements without adding
2045   // them to any storage.
2046   // Returns the number of enumerable elements.
2047   int GetEnumElementKeys(FixedArray* storage);
2048
2049   static Handle<FixedArray> GetEnumPropertyKeys(Handle<JSObject> object,
2050                                                 bool cache_result);
2051
2052   // Returns a new map with all transitions dropped from the object's current
2053   // map and the ElementsKind set.
2054   static Handle<Map> GetElementsTransitionMap(Handle<JSObject> object,
2055                                               ElementsKind to_kind);
2056   static void TransitionElementsKind(Handle<JSObject> object,
2057                                      ElementsKind to_kind);
2058
2059   // Always use this to migrate an object to a new map.
2060   // |expected_additional_properties| is only used for fast-to-slow transitions
2061   // and ignored otherwise.
2062   static void MigrateToMap(Handle<JSObject> object, Handle<Map> new_map,
2063                            int expected_additional_properties = 0);
2064
2065   // Convert the object to use the canonical dictionary
2066   // representation. If the object is expected to have additional properties
2067   // added this number can be indicated to have the backing store allocated to
2068   // an initial capacity for holding these properties.
2069   static void NormalizeProperties(Handle<JSObject> object,
2070                                   PropertyNormalizationMode mode,
2071                                   int expected_additional_properties,
2072                                   const char* reason);
2073
2074   // Convert and update the elements backing store to be a
2075   // SeededNumberDictionary dictionary.  Returns the backing after conversion.
2076   static Handle<SeededNumberDictionary> NormalizeElements(
2077       Handle<JSObject> object);
2078
2079   void RequireSlowElements(SeededNumberDictionary* dictionary);
2080
2081   // Transform slow named properties to fast variants.
2082   static void MigrateSlowToFast(Handle<JSObject> object,
2083                                 int unused_property_fields, const char* reason);
2084
2085   inline bool IsUnboxedDoubleField(FieldIndex index);
2086
2087   // Access fast-case object properties at index.
2088   static Handle<Object> FastPropertyAt(Handle<JSObject> object,
2089                                        Representation representation,
2090                                        FieldIndex index);
2091   inline Object* RawFastPropertyAt(FieldIndex index);
2092   inline double RawFastDoublePropertyAt(FieldIndex index);
2093
2094   inline void FastPropertyAtPut(FieldIndex index, Object* value);
2095   inline void RawFastPropertyAtPut(FieldIndex index, Object* value);
2096   inline void RawFastDoublePropertyAtPut(FieldIndex index, double value);
2097   inline void WriteToField(int descriptor, Object* value);
2098
2099   // Access to in object properties.
2100   inline int GetInObjectPropertyOffset(int index);
2101   inline Object* InObjectPropertyAt(int index);
2102   inline Object* InObjectPropertyAtPut(int index,
2103                                        Object* value,
2104                                        WriteBarrierMode mode
2105                                        = UPDATE_WRITE_BARRIER);
2106
2107   // Set the object's prototype (only JSReceiver and null are allowed values).
2108   MUST_USE_RESULT static MaybeHandle<Object> SetPrototype(
2109       Handle<JSObject> object, Handle<Object> value, bool from_javascript);
2110
2111   // Initializes the body after properties slot, properties slot is
2112   // initialized by set_properties.  Fill the pre-allocated fields with
2113   // pre_allocated_value and the rest with filler_value.
2114   // Note: this call does not update write barrier, the caller is responsible
2115   // to ensure that |filler_value| can be collected without WB here.
2116   inline void InitializeBody(Map* map,
2117                              Object* pre_allocated_value,
2118                              Object* filler_value);
2119
2120   // Check whether this object references another object
2121   bool ReferencesObject(Object* obj);
2122
2123   // Disalow further properties to be added to the oject.
2124   MUST_USE_RESULT static MaybeHandle<Object> PreventExtensions(
2125       Handle<JSObject> object);
2126
2127   bool IsExtensible();
2128
2129   // ES5 Object.seal
2130   MUST_USE_RESULT static MaybeHandle<Object> Seal(Handle<JSObject> object);
2131
2132   // ES5 Object.freeze
2133   MUST_USE_RESULT static MaybeHandle<Object> Freeze(Handle<JSObject> object);
2134
2135   // Called the first time an object is observed with ES7 Object.observe.
2136   static void SetObserved(Handle<JSObject> object);
2137
2138   // Copy object.
2139   enum DeepCopyHints { kNoHints = 0, kObjectIsShallow = 1 };
2140
2141   MUST_USE_RESULT static MaybeHandle<JSObject> DeepCopy(
2142       Handle<JSObject> object,
2143       AllocationSiteUsageContext* site_context,
2144       DeepCopyHints hints = kNoHints);
2145   MUST_USE_RESULT static MaybeHandle<JSObject> DeepWalk(
2146       Handle<JSObject> object,
2147       AllocationSiteCreationContext* site_context);
2148
2149   DECLARE_CAST(JSObject)
2150
2151   // Dispatched behavior.
2152   void JSObjectShortPrint(StringStream* accumulator);
2153   DECLARE_PRINTER(JSObject)
2154   DECLARE_VERIFIER(JSObject)
2155 #ifdef OBJECT_PRINT
2156   void PrintProperties(std::ostream& os);   // NOLINT
2157   void PrintElements(std::ostream& os);     // NOLINT
2158 #endif
2159 #if defined(DEBUG) || defined(OBJECT_PRINT)
2160   void PrintTransitions(std::ostream& os);  // NOLINT
2161 #endif
2162
2163   static void PrintElementsTransition(
2164       FILE* file, Handle<JSObject> object,
2165       ElementsKind from_kind, Handle<FixedArrayBase> from_elements,
2166       ElementsKind to_kind, Handle<FixedArrayBase> to_elements);
2167
2168   void PrintInstanceMigration(FILE* file, Map* original_map, Map* new_map);
2169
2170 #ifdef DEBUG
2171   // Structure for collecting spill information about JSObjects.
2172   class SpillInformation {
2173    public:
2174     void Clear();
2175     void Print();
2176     int number_of_objects_;
2177     int number_of_objects_with_fast_properties_;
2178     int number_of_objects_with_fast_elements_;
2179     int number_of_fast_used_fields_;
2180     int number_of_fast_unused_fields_;
2181     int number_of_slow_used_properties_;
2182     int number_of_slow_unused_properties_;
2183     int number_of_fast_used_elements_;
2184     int number_of_fast_unused_elements_;
2185     int number_of_slow_used_elements_;
2186     int number_of_slow_unused_elements_;
2187   };
2188
2189   void IncrementSpillStatistics(SpillInformation* info);
2190 #endif
2191
2192 #ifdef VERIFY_HEAP
2193   // If a GC was caused while constructing this object, the elements pointer
2194   // may point to a one pointer filler map. The object won't be rooted, but
2195   // our heap verification code could stumble across it.
2196   bool ElementsAreSafeToExamine();
2197 #endif
2198
2199   Object* SlowReverseLookup(Object* value);
2200
2201   // Maximal number of elements (numbered 0 .. kMaxElementCount - 1).
2202   // Also maximal value of JSArray's length property.
2203   static const uint32_t kMaxElementCount = 0xffffffffu;
2204
2205   // Constants for heuristics controlling conversion of fast elements
2206   // to slow elements.
2207
2208   // Maximal gap that can be introduced by adding an element beyond
2209   // the current elements length.
2210   static const uint32_t kMaxGap = 1024;
2211
2212   // Maximal length of fast elements array that won't be checked for
2213   // being dense enough on expansion.
2214   static const int kMaxUncheckedFastElementsLength = 5000;
2215
2216   // Same as above but for old arrays. This limit is more strict. We
2217   // don't want to be wasteful with long lived objects.
2218   static const int kMaxUncheckedOldFastElementsLength = 500;
2219
2220   // Note that Page::kMaxRegularHeapObjectSize puts a limit on
2221   // permissible values (see the DCHECK in heap.cc).
2222   static const int kInitialMaxFastElementArray = 100000;
2223
2224   // This constant applies only to the initial map of "global.Object" and
2225   // not to arbitrary other JSObject maps.
2226   static const int kInitialGlobalObjectUnusedPropertiesCount = 4;
2227
2228   static const int kMaxInstanceSize = 255 * kPointerSize;
2229   // When extending the backing storage for property values, we increase
2230   // its size by more than the 1 entry necessary, so sequentially adding fields
2231   // to the same object requires fewer allocations and copies.
2232   static const int kFieldsAdded = 3;
2233
2234   // Layout description.
2235   static const int kPropertiesOffset = HeapObject::kHeaderSize;
2236   static const int kElementsOffset = kPropertiesOffset + kPointerSize;
2237   static const int kHeaderSize = kElementsOffset + kPointerSize;
2238
2239   STATIC_ASSERT(kHeaderSize == Internals::kJSObjectHeaderSize);
2240
2241   class BodyDescriptor : public FlexibleBodyDescriptor<kPropertiesOffset> {
2242    public:
2243     static inline int SizeOf(Map* map, HeapObject* object);
2244   };
2245
2246   Context* GetCreationContext();
2247
2248   // Enqueue change record for Object.observe. May cause GC.
2249   MUST_USE_RESULT static MaybeHandle<Object> EnqueueChangeRecord(
2250       Handle<JSObject> object, const char* type, Handle<Name> name,
2251       Handle<Object> old_value);
2252
2253   // Gets the number of currently used elements.
2254   int GetFastElementsUsage();
2255
2256   // Deletes an existing named property in a normalized object.
2257   static void DeleteNormalizedProperty(Handle<JSObject> object,
2258                                        Handle<Name> name, int entry);
2259
2260   static bool AllCanRead(LookupIterator* it);
2261   static bool AllCanWrite(LookupIterator* it);
2262
2263  private:
2264   friend class JSReceiver;
2265   friend class Object;
2266
2267   static void MigrateFastToFast(Handle<JSObject> object, Handle<Map> new_map);
2268   static void MigrateFastToSlow(Handle<JSObject> object,
2269                                 Handle<Map> new_map,
2270                                 int expected_additional_properties);
2271
2272   // Used from Object::GetProperty().
2273   MUST_USE_RESULT static MaybeHandle<Object> GetPropertyWithFailedAccessCheck(
2274       LookupIterator* it);
2275
2276   MUST_USE_RESULT static MaybeHandle<Object> SetPropertyWithFailedAccessCheck(
2277       LookupIterator* it, Handle<Object> value);
2278
2279   // Add a property to a slow-case object.
2280   static void AddSlowProperty(Handle<JSObject> object,
2281                               Handle<Name> name,
2282                               Handle<Object> value,
2283                               PropertyAttributes attributes);
2284
2285   MUST_USE_RESULT static MaybeHandle<Object> DeletePropertyWithInterceptor(
2286       LookupIterator* it);
2287
2288   bool ReferencesObjectFromElements(FixedArray* elements,
2289                                     ElementsKind kind,
2290                                     Object* object);
2291
2292   // Return the hash table backing store or the inline stored identity hash,
2293   // whatever is found.
2294   MUST_USE_RESULT Object* GetHiddenPropertiesHashTable();
2295
2296   // Return the hash table backing store for hidden properties.  If there is no
2297   // backing store, allocate one.
2298   static Handle<ObjectHashTable> GetOrCreateHiddenPropertiesHashtable(
2299       Handle<JSObject> object);
2300
2301   // Set the hidden property backing store to either a hash table or
2302   // the inline-stored identity hash.
2303   static Handle<Object> SetHiddenPropertiesHashTable(
2304       Handle<JSObject> object,
2305       Handle<Object> value);
2306
2307   MUST_USE_RESULT Object* GetIdentityHash();
2308
2309   static Handle<Smi> GetOrCreateIdentityHash(Handle<JSObject> object);
2310
2311   static Handle<SeededNumberDictionary> GetNormalizedElementDictionary(
2312       Handle<JSObject> object, Handle<FixedArrayBase> elements);
2313
2314   // Helper for fast versions of preventExtensions, seal, and freeze.
2315   // attrs is one of NONE, SEALED, or FROZEN (depending on the operation).
2316   template <PropertyAttributes attrs>
2317   MUST_USE_RESULT static MaybeHandle<Object> PreventExtensionsWithTransition(
2318       Handle<JSObject> object);
2319
2320   DISALLOW_IMPLICIT_CONSTRUCTORS(JSObject);
2321 };
2322
2323
2324 // Common superclass for FixedArrays that allow implementations to share
2325 // common accessors and some code paths.
2326 class FixedArrayBase: public HeapObject {
2327  public:
2328   // [length]: length of the array.
2329   inline int length() const;
2330   inline void set_length(int value);
2331
2332   // Get and set the length using acquire loads and release stores.
2333   inline int synchronized_length() const;
2334   inline void synchronized_set_length(int value);
2335
2336   DECLARE_CAST(FixedArrayBase)
2337
2338   // Layout description.
2339   // Length is smi tagged when it is stored.
2340   static const int kLengthOffset = HeapObject::kHeaderSize;
2341   static const int kHeaderSize = kLengthOffset + kPointerSize;
2342 };
2343
2344
2345 class FixedDoubleArray;
2346 class IncrementalMarking;
2347
2348
2349 // FixedArray describes fixed-sized arrays with element type Object*.
2350 class FixedArray: public FixedArrayBase {
2351  public:
2352   // Setter and getter for elements.
2353   inline Object* get(int index) const;
2354   void SetValue(uint32_t index, Object* value);
2355   static inline Handle<Object> get(Handle<FixedArray> array, int index);
2356   // Setter that uses write barrier.
2357   inline void set(int index, Object* value);
2358   inline bool is_the_hole(int index);
2359
2360   // Setter that doesn't need write barrier.
2361   inline void set(int index, Smi* value);
2362   // Setter with explicit barrier mode.
2363   inline void set(int index, Object* value, WriteBarrierMode mode);
2364
2365   // Setters for frequently used oddballs located in old space.
2366   inline void set_undefined(int index);
2367   inline void set_null(int index);
2368   inline void set_the_hole(int index);
2369
2370   inline Object** GetFirstElementAddress();
2371   inline bool ContainsOnlySmisOrHoles();
2372
2373   // Gives access to raw memory which stores the array's data.
2374   inline Object** data_start();
2375
2376   inline void FillWithHoles(int from, int to);
2377
2378   // Shrink length and insert filler objects.
2379   void Shrink(int length);
2380
2381   enum KeyFilter { ALL_KEYS, NON_SYMBOL_KEYS };
2382
2383   // Add the elements of a JSArray to this FixedArray.
2384   MUST_USE_RESULT static MaybeHandle<FixedArray> AddKeysFromArrayLike(
2385       Handle<FixedArray> content, Handle<JSObject> array,
2386       KeyFilter filter = ALL_KEYS);
2387
2388   // Computes the union of keys and return the result.
2389   // Used for implementing "for (n in object) { }"
2390   MUST_USE_RESULT static MaybeHandle<FixedArray> UnionOfKeys(
2391       Handle<FixedArray> first,
2392       Handle<FixedArray> second);
2393
2394   // Copy a sub array from the receiver to dest.
2395   void CopyTo(int pos, FixedArray* dest, int dest_pos, int len);
2396
2397   // Garbage collection support.
2398   static int SizeFor(int length) { return kHeaderSize + length * kPointerSize; }
2399
2400   // Code Generation support.
2401   static int OffsetOfElementAt(int index) { return SizeFor(index); }
2402
2403   // Garbage collection support.
2404   inline Object** RawFieldOfElementAt(int index);
2405
2406   DECLARE_CAST(FixedArray)
2407
2408   // Maximal allowed size, in bytes, of a single FixedArray.
2409   // Prevents overflowing size computations, as well as extreme memory
2410   // consumption.
2411   static const int kMaxSize = 128 * MB * kPointerSize;
2412   // Maximally allowed length of a FixedArray.
2413   static const int kMaxLength = (kMaxSize - kHeaderSize) / kPointerSize;
2414
2415   // Dispatched behavior.
2416   DECLARE_PRINTER(FixedArray)
2417   DECLARE_VERIFIER(FixedArray)
2418 #ifdef DEBUG
2419   // Checks if two FixedArrays have identical contents.
2420   bool IsEqualTo(FixedArray* other);
2421 #endif
2422
2423   // Swap two elements in a pair of arrays.  If this array and the
2424   // numbers array are the same object, the elements are only swapped
2425   // once.
2426   void SwapPairs(FixedArray* numbers, int i, int j);
2427
2428   // Sort prefix of this array and the numbers array as pairs wrt. the
2429   // numbers.  If the numbers array and the this array are the same
2430   // object, the prefix of this array is sorted.
2431   void SortPairs(FixedArray* numbers, uint32_t len);
2432
2433   class BodyDescriptor : public FlexibleBodyDescriptor<kHeaderSize> {
2434    public:
2435     static inline int SizeOf(Map* map, HeapObject* object);
2436   };
2437
2438  protected:
2439   // Set operation on FixedArray without using write barriers. Can
2440   // only be used for storing old space objects or smis.
2441   static inline void NoWriteBarrierSet(FixedArray* array,
2442                                        int index,
2443                                        Object* value);
2444
2445   // Set operation on FixedArray without incremental write barrier. Can
2446   // only be used if the object is guaranteed to be white (whiteness witness
2447   // is present).
2448   static inline void NoIncrementalWriteBarrierSet(FixedArray* array,
2449                                                   int index,
2450                                                   Object* value);
2451
2452  private:
2453   STATIC_ASSERT(kHeaderSize == Internals::kFixedArrayHeaderSize);
2454
2455   DISALLOW_IMPLICIT_CONSTRUCTORS(FixedArray);
2456 };
2457
2458
2459 // FixedDoubleArray describes fixed-sized arrays with element type double.
2460 class FixedDoubleArray: public FixedArrayBase {
2461  public:
2462   // Setter and getter for elements.
2463   inline double get_scalar(int index);
2464   inline uint64_t get_representation(int index);
2465   static inline Handle<Object> get(Handle<FixedDoubleArray> array, int index);
2466   // This accessor has to get a Number as |value|.
2467   void SetValue(uint32_t index, Object* value);
2468   inline void set(int index, double value);
2469   inline void set_the_hole(int index);
2470
2471   // Checking for the hole.
2472   inline bool is_the_hole(int index);
2473
2474   // Garbage collection support.
2475   inline static int SizeFor(int length) {
2476     return kHeaderSize + length * kDoubleSize;
2477   }
2478
2479   // Gives access to raw memory which stores the array's data.
2480   inline double* data_start();
2481
2482   inline void FillWithHoles(int from, int to);
2483
2484   // Code Generation support.
2485   static int OffsetOfElementAt(int index) { return SizeFor(index); }
2486
2487   DECLARE_CAST(FixedDoubleArray)
2488
2489   // Maximal allowed size, in bytes, of a single FixedDoubleArray.
2490   // Prevents overflowing size computations, as well as extreme memory
2491   // consumption.
2492   static const int kMaxSize = 512 * MB;
2493   // Maximally allowed length of a FixedArray.
2494   static const int kMaxLength = (kMaxSize - kHeaderSize) / kDoubleSize;
2495
2496   // Dispatched behavior.
2497   DECLARE_PRINTER(FixedDoubleArray)
2498   DECLARE_VERIFIER(FixedDoubleArray)
2499
2500  private:
2501   DISALLOW_IMPLICIT_CONSTRUCTORS(FixedDoubleArray);
2502 };
2503
2504
2505 class WeakFixedArray : public FixedArray {
2506  public:
2507   // If |maybe_array| is not a WeakFixedArray, a fresh one will be allocated.
2508   // This function does not check if the value exists already, callers must
2509   // ensure this themselves if necessary.
2510   static Handle<WeakFixedArray> Add(Handle<Object> maybe_array,
2511                                     Handle<HeapObject> value,
2512                                     int* assigned_index = NULL);
2513
2514   // Returns true if an entry was found and removed.
2515   bool Remove(Handle<HeapObject> value);
2516
2517   class NullCallback {
2518    public:
2519     static void Callback(Object* value, int old_index, int new_index) {}
2520   };
2521
2522   template <class CompactionCallback>
2523   void Compact();
2524
2525   inline Object* Get(int index) const;
2526   inline void Clear(int index);
2527   inline int Length() const;
2528
2529   inline bool IsEmptySlot(int index) const;
2530   static Object* Empty() { return Smi::FromInt(0); }
2531
2532   class Iterator {
2533    public:
2534     explicit Iterator(Object* maybe_array) : list_(NULL) { Reset(maybe_array); }
2535     void Reset(Object* maybe_array);
2536
2537     template <class T>
2538     inline T* Next();
2539
2540    private:
2541     int index_;
2542     WeakFixedArray* list_;
2543 #ifdef DEBUG
2544     int last_used_index_;
2545     DisallowHeapAllocation no_gc_;
2546 #endif  // DEBUG
2547     DISALLOW_COPY_AND_ASSIGN(Iterator);
2548   };
2549
2550   DECLARE_CAST(WeakFixedArray)
2551
2552  private:
2553   static const int kLastUsedIndexIndex = 0;
2554   static const int kFirstIndex = 1;
2555
2556   static Handle<WeakFixedArray> Allocate(
2557       Isolate* isolate, int size, Handle<WeakFixedArray> initialize_from);
2558
2559   static void Set(Handle<WeakFixedArray> array, int index,
2560                   Handle<HeapObject> value);
2561   inline void clear(int index);
2562
2563   inline int last_used_index() const;
2564   inline void set_last_used_index(int index);
2565
2566   // Disallow inherited setters.
2567   void set(int index, Smi* value);
2568   void set(int index, Object* value);
2569   void set(int index, Object* value, WriteBarrierMode mode);
2570   DISALLOW_IMPLICIT_CONSTRUCTORS(WeakFixedArray);
2571 };
2572
2573
2574 // Generic array grows dynamically with O(1) amortized insertion.
2575 class ArrayList : public FixedArray {
2576  public:
2577   enum AddMode {
2578     kNone,
2579     // Use this if GC can delete elements from the array.
2580     kReloadLengthAfterAllocation,
2581   };
2582   static Handle<ArrayList> Add(Handle<ArrayList> array, Handle<Object> obj,
2583                                AddMode mode = kNone);
2584   static Handle<ArrayList> Add(Handle<ArrayList> array, Handle<Object> obj1,
2585                                Handle<Object> obj2, AddMode = kNone);
2586   inline int Length();
2587   inline void SetLength(int length);
2588   inline Object* Get(int index);
2589   inline Object** Slot(int index);
2590   inline void Set(int index, Object* obj);
2591   inline void Clear(int index, Object* undefined);
2592   DECLARE_CAST(ArrayList)
2593
2594  private:
2595   static Handle<ArrayList> EnsureSpace(Handle<ArrayList> array, int length);
2596   static const int kLengthIndex = 0;
2597   static const int kFirstIndex = 1;
2598   DISALLOW_IMPLICIT_CONSTRUCTORS(ArrayList);
2599 };
2600
2601
2602 // DescriptorArrays are fixed arrays used to hold instance descriptors.
2603 // The format of the these objects is:
2604 //   [0]: Number of descriptors
2605 //   [1]: Either Smi(0) if uninitialized, or a pointer to small fixed array:
2606 //          [0]: pointer to fixed array with enum cache
2607 //          [1]: either Smi(0) or pointer to fixed array with indices
2608 //   [2]: first key
2609 //   [2 + number of descriptors * kDescriptorSize]: start of slack
2610 class DescriptorArray: public FixedArray {
2611  public:
2612   // Returns true for both shared empty_descriptor_array and for smis, which the
2613   // map uses to encode additional bit fields when the descriptor array is not
2614   // yet used.
2615   inline bool IsEmpty();
2616
2617   // Returns the number of descriptors in the array.
2618   inline int number_of_descriptors();
2619
2620   inline int number_of_descriptors_storage();
2621
2622   inline int NumberOfSlackDescriptors();
2623
2624   inline void SetNumberOfDescriptors(int number_of_descriptors);
2625   inline int number_of_entries();
2626
2627   inline bool HasEnumCache();
2628
2629   inline void CopyEnumCacheFrom(DescriptorArray* array);
2630
2631   inline FixedArray* GetEnumCache();
2632
2633   inline bool HasEnumIndicesCache();
2634
2635   inline FixedArray* GetEnumIndicesCache();
2636
2637   inline Object** GetEnumCacheSlot();
2638
2639   void ClearEnumCache();
2640
2641   // Initialize or change the enum cache,
2642   // using the supplied storage for the small "bridge".
2643   void SetEnumCache(FixedArray* bridge_storage,
2644                     FixedArray* new_cache,
2645                     Object* new_index_cache);
2646
2647   bool CanHoldValue(int descriptor, Object* value);
2648
2649   // Accessors for fetching instance descriptor at descriptor number.
2650   inline Name* GetKey(int descriptor_number);
2651   inline Object** GetKeySlot(int descriptor_number);
2652   inline Object* GetValue(int descriptor_number);
2653   inline void SetValue(int descriptor_number, Object* value);
2654   inline Object** GetValueSlot(int descriptor_number);
2655   static inline int GetValueOffset(int descriptor_number);
2656   inline Object** GetDescriptorStartSlot(int descriptor_number);
2657   inline Object** GetDescriptorEndSlot(int descriptor_number);
2658   inline PropertyDetails GetDetails(int descriptor_number);
2659   inline PropertyType GetType(int descriptor_number);
2660   inline int GetFieldIndex(int descriptor_number);
2661   inline HeapType* GetFieldType(int descriptor_number);
2662   inline Object* GetConstant(int descriptor_number);
2663   inline Object* GetCallbacksObject(int descriptor_number);
2664   inline AccessorDescriptor* GetCallbacks(int descriptor_number);
2665
2666   inline Name* GetSortedKey(int descriptor_number);
2667   inline int GetSortedKeyIndex(int descriptor_number);
2668   inline void SetSortedKey(int pointer, int descriptor_number);
2669   inline void SetRepresentation(int descriptor_number,
2670                                 Representation representation);
2671
2672   // Accessor for complete descriptor.
2673   inline void Get(int descriptor_number, Descriptor* desc);
2674   inline void Set(int descriptor_number, Descriptor* desc);
2675   void Replace(int descriptor_number, Descriptor* descriptor);
2676
2677   // Append automatically sets the enumeration index. This should only be used
2678   // to add descriptors in bulk at the end, followed by sorting the descriptor
2679   // array.
2680   inline void Append(Descriptor* desc);
2681
2682   static Handle<DescriptorArray> CopyUpTo(Handle<DescriptorArray> desc,
2683                                           int enumeration_index,
2684                                           int slack = 0);
2685
2686   static Handle<DescriptorArray> CopyUpToAddAttributes(
2687       Handle<DescriptorArray> desc,
2688       int enumeration_index,
2689       PropertyAttributes attributes,
2690       int slack = 0);
2691
2692   // Sort the instance descriptors by the hash codes of their keys.
2693   void Sort();
2694
2695   // Search the instance descriptors for given name.
2696   INLINE(int Search(Name* name, int number_of_own_descriptors));
2697
2698   // As the above, but uses DescriptorLookupCache and updates it when
2699   // necessary.
2700   INLINE(int SearchWithCache(Name* name, Map* map));
2701
2702   // Allocates a DescriptorArray, but returns the singleton
2703   // empty descriptor array object if number_of_descriptors is 0.
2704   static Handle<DescriptorArray> Allocate(Isolate* isolate,
2705                                           int number_of_descriptors,
2706                                           int slack = 0);
2707
2708   DECLARE_CAST(DescriptorArray)
2709
2710   // Constant for denoting key was not found.
2711   static const int kNotFound = -1;
2712
2713   static const int kDescriptorLengthIndex = 0;
2714   static const int kEnumCacheIndex = 1;
2715   static const int kFirstIndex = 2;
2716
2717   // The length of the "bridge" to the enum cache.
2718   static const int kEnumCacheBridgeLength = 2;
2719   static const int kEnumCacheBridgeCacheIndex = 0;
2720   static const int kEnumCacheBridgeIndicesCacheIndex = 1;
2721
2722   // Layout description.
2723   static const int kDescriptorLengthOffset = FixedArray::kHeaderSize;
2724   static const int kEnumCacheOffset = kDescriptorLengthOffset + kPointerSize;
2725   static const int kFirstOffset = kEnumCacheOffset + kPointerSize;
2726
2727   // Layout description for the bridge array.
2728   static const int kEnumCacheBridgeCacheOffset = FixedArray::kHeaderSize;
2729
2730   // Layout of descriptor.
2731   static const int kDescriptorKey = 0;
2732   static const int kDescriptorDetails = 1;
2733   static const int kDescriptorValue = 2;
2734   static const int kDescriptorSize = 3;
2735
2736 #if defined(DEBUG) || defined(OBJECT_PRINT)
2737   // For our gdb macros, we should perhaps change these in the future.
2738   void Print();
2739
2740   // Print all the descriptors.
2741   void PrintDescriptors(std::ostream& os);  // NOLINT
2742 #endif
2743
2744 #ifdef DEBUG
2745   // Is the descriptor array sorted and without duplicates?
2746   bool IsSortedNoDuplicates(int valid_descriptors = -1);
2747
2748   // Is the descriptor array consistent with the back pointers in targets?
2749   bool IsConsistentWithBackPointers(Map* current_map);
2750
2751   // Are two DescriptorArrays equal?
2752   bool IsEqualTo(DescriptorArray* other);
2753 #endif
2754
2755   // Returns the fixed array length required to hold number_of_descriptors
2756   // descriptors.
2757   static int LengthFor(int number_of_descriptors) {
2758     return ToKeyIndex(number_of_descriptors);
2759   }
2760
2761  private:
2762   // WhitenessWitness is used to prove that a descriptor array is white
2763   // (unmarked), so incremental write barriers can be skipped because the
2764   // marking invariant cannot be broken and slots pointing into evacuation
2765   // candidates will be discovered when the object is scanned. A witness is
2766   // always stack-allocated right after creating an array. By allocating a
2767   // witness, incremental marking is globally disabled. The witness is then
2768   // passed along wherever needed to statically prove that the array is known to
2769   // be white.
2770   class WhitenessWitness {
2771    public:
2772     inline explicit WhitenessWitness(DescriptorArray* array);
2773     inline ~WhitenessWitness();
2774
2775    private:
2776     IncrementalMarking* marking_;
2777   };
2778
2779   // An entry in a DescriptorArray, represented as an (array, index) pair.
2780   class Entry {
2781    public:
2782     inline explicit Entry(DescriptorArray* descs, int index) :
2783         descs_(descs), index_(index) { }
2784
2785     inline PropertyType type();
2786     inline Object* GetCallbackObject();
2787
2788    private:
2789     DescriptorArray* descs_;
2790     int index_;
2791   };
2792
2793   // Conversion from descriptor number to array indices.
2794   static int ToKeyIndex(int descriptor_number) {
2795     return kFirstIndex +
2796            (descriptor_number * kDescriptorSize) +
2797            kDescriptorKey;
2798   }
2799
2800   static int ToDetailsIndex(int descriptor_number) {
2801     return kFirstIndex +
2802            (descriptor_number * kDescriptorSize) +
2803            kDescriptorDetails;
2804   }
2805
2806   static int ToValueIndex(int descriptor_number) {
2807     return kFirstIndex +
2808            (descriptor_number * kDescriptorSize) +
2809            kDescriptorValue;
2810   }
2811
2812   // Transfer a complete descriptor from the src descriptor array to this
2813   // descriptor array.
2814   void CopyFrom(int index, DescriptorArray* src, const WhitenessWitness&);
2815
2816   inline void Set(int descriptor_number,
2817                   Descriptor* desc,
2818                   const WhitenessWitness&);
2819
2820   // Swap first and second descriptor.
2821   inline void SwapSortedKeys(int first, int second);
2822
2823   DISALLOW_IMPLICIT_CONSTRUCTORS(DescriptorArray);
2824 };
2825
2826
2827 enum SearchMode { ALL_ENTRIES, VALID_ENTRIES };
2828
2829 template <SearchMode search_mode, typename T>
2830 inline int Search(T* array, Name* name, int valid_entries = 0,
2831                   int* out_insertion_index = NULL);
2832
2833
2834 // HashTable is a subclass of FixedArray that implements a hash table
2835 // that uses open addressing and quadratic probing.
2836 //
2837 // In order for the quadratic probing to work, elements that have not
2838 // yet been used and elements that have been deleted are
2839 // distinguished.  Probing continues when deleted elements are
2840 // encountered and stops when unused elements are encountered.
2841 //
2842 // - Elements with key == undefined have not been used yet.
2843 // - Elements with key == the_hole have been deleted.
2844 //
2845 // The hash table class is parameterized with a Shape and a Key.
2846 // Shape must be a class with the following interface:
2847 //   class ExampleShape {
2848 //    public:
2849 //      // Tells whether key matches other.
2850 //     static bool IsMatch(Key key, Object* other);
2851 //     // Returns the hash value for key.
2852 //     static uint32_t Hash(Key key);
2853 //     // Returns the hash value for object.
2854 //     static uint32_t HashForObject(Key key, Object* object);
2855 //     // Convert key to an object.
2856 //     static inline Handle<Object> AsHandle(Isolate* isolate, Key key);
2857 //     // The prefix size indicates number of elements in the beginning
2858 //     // of the backing storage.
2859 //     static const int kPrefixSize = ..;
2860 //     // The Element size indicates number of elements per entry.
2861 //     static const int kEntrySize = ..;
2862 //   };
2863 // The prefix size indicates an amount of memory in the
2864 // beginning of the backing storage that can be used for non-element
2865 // information by subclasses.
2866
2867 template<typename Key>
2868 class BaseShape {
2869  public:
2870   static const bool UsesSeed = false;
2871   static uint32_t Hash(Key key) { return 0; }
2872   static uint32_t SeededHash(Key key, uint32_t seed) {
2873     DCHECK(UsesSeed);
2874     return Hash(key);
2875   }
2876   static uint32_t HashForObject(Key key, Object* object) { return 0; }
2877   static uint32_t SeededHashForObject(Key key, uint32_t seed, Object* object) {
2878     DCHECK(UsesSeed);
2879     return HashForObject(key, object);
2880   }
2881 };
2882
2883
2884 class HashTableBase : public FixedArray {
2885  public:
2886   // Returns the number of elements in the hash table.
2887   inline int NumberOfElements();
2888
2889   // Returns the number of deleted elements in the hash table.
2890   inline int NumberOfDeletedElements();
2891
2892   // Returns the capacity of the hash table.
2893   inline int Capacity();
2894
2895   // ElementAdded should be called whenever an element is added to a
2896   // hash table.
2897   inline void ElementAdded();
2898
2899   // ElementRemoved should be called whenever an element is removed from
2900   // a hash table.
2901   inline void ElementRemoved();
2902   inline void ElementsRemoved(int n);
2903
2904   // Computes the required capacity for a table holding the given
2905   // number of elements. May be more than HashTable::kMaxCapacity.
2906   static inline int ComputeCapacity(int at_least_space_for);
2907
2908   // Tells whether k is a real key.  The hole and undefined are not allowed
2909   // as keys and can be used to indicate missing or deleted elements.
2910   inline bool IsKey(Object* k);
2911
2912   // Compute the probe offset (quadratic probing).
2913   INLINE(static uint32_t GetProbeOffset(uint32_t n)) {
2914     return (n + n * n) >> 1;
2915   }
2916
2917   static const int kNumberOfElementsIndex = 0;
2918   static const int kNumberOfDeletedElementsIndex = 1;
2919   static const int kCapacityIndex = 2;
2920   static const int kPrefixStartIndex = 3;
2921
2922   // Constant used for denoting a absent entry.
2923   static const int kNotFound = -1;
2924
2925  protected:
2926   // Update the number of elements in the hash table.
2927   inline void SetNumberOfElements(int nof);
2928
2929   // Update the number of deleted elements in the hash table.
2930   inline void SetNumberOfDeletedElements(int nod);
2931
2932   // Returns probe entry.
2933   static uint32_t GetProbe(uint32_t hash, uint32_t number, uint32_t size) {
2934     DCHECK(base::bits::IsPowerOfTwo32(size));
2935     return (hash + GetProbeOffset(number)) & (size - 1);
2936   }
2937
2938   inline static uint32_t FirstProbe(uint32_t hash, uint32_t size) {
2939     return hash & (size - 1);
2940   }
2941
2942   inline static uint32_t NextProbe(
2943       uint32_t last, uint32_t number, uint32_t size) {
2944     return (last + number) & (size - 1);
2945   }
2946 };
2947
2948
2949 template <typename Derived, typename Shape, typename Key>
2950 class HashTable : public HashTableBase {
2951  public:
2952   // Wrapper methods
2953   inline uint32_t Hash(Key key) {
2954     if (Shape::UsesSeed) {
2955       return Shape::SeededHash(key, GetHeap()->HashSeed());
2956     } else {
2957       return Shape::Hash(key);
2958     }
2959   }
2960
2961   inline uint32_t HashForObject(Key key, Object* object) {
2962     if (Shape::UsesSeed) {
2963       return Shape::SeededHashForObject(key, GetHeap()->HashSeed(), object);
2964     } else {
2965       return Shape::HashForObject(key, object);
2966     }
2967   }
2968
2969   // Returns a new HashTable object.
2970   MUST_USE_RESULT static Handle<Derived> New(
2971       Isolate* isolate, int at_least_space_for,
2972       MinimumCapacity capacity_option = USE_DEFAULT_MINIMUM_CAPACITY,
2973       PretenureFlag pretenure = NOT_TENURED);
2974
2975   DECLARE_CAST(HashTable)
2976
2977   // Garbage collection support.
2978   void IteratePrefix(ObjectVisitor* visitor);
2979   void IterateElements(ObjectVisitor* visitor);
2980
2981   // Find entry for key otherwise return kNotFound.
2982   inline int FindEntry(Key key);
2983   inline int FindEntry(Isolate* isolate, Key key, int32_t hash);
2984   int FindEntry(Isolate* isolate, Key key);
2985
2986   // Rehashes the table in-place.
2987   void Rehash(Key key);
2988
2989   // Returns the key at entry.
2990   Object* KeyAt(int entry) { return get(EntryToIndex(entry)); }
2991
2992   static const int kElementsStartIndex = kPrefixStartIndex + Shape::kPrefixSize;
2993   static const int kEntrySize = Shape::kEntrySize;
2994   static const int kElementsStartOffset =
2995       kHeaderSize + kElementsStartIndex * kPointerSize;
2996   static const int kCapacityOffset =
2997       kHeaderSize + kCapacityIndex * kPointerSize;
2998
2999   // Returns the index for an entry (of the key)
3000   static inline int EntryToIndex(int entry) {
3001     return (entry * kEntrySize) + kElementsStartIndex;
3002   }
3003
3004  protected:
3005   friend class ObjectHashTable;
3006
3007   // Find the entry at which to insert element with the given key that
3008   // has the given hash value.
3009   uint32_t FindInsertionEntry(uint32_t hash);
3010
3011   // Attempt to shrink hash table after removal of key.
3012   MUST_USE_RESULT static Handle<Derived> Shrink(Handle<Derived> table, Key key);
3013
3014   // Ensure enough space for n additional elements.
3015   MUST_USE_RESULT static Handle<Derived> EnsureCapacity(
3016       Handle<Derived> table,
3017       int n,
3018       Key key,
3019       PretenureFlag pretenure = NOT_TENURED);
3020
3021   // Sets the capacity of the hash table.
3022   void SetCapacity(int capacity) {
3023     // To scale a computed hash code to fit within the hash table, we
3024     // use bit-wise AND with a mask, so the capacity must be positive
3025     // and non-zero.
3026     DCHECK(capacity > 0);
3027     DCHECK(capacity <= kMaxCapacity);
3028     set(kCapacityIndex, Smi::FromInt(capacity));
3029   }
3030
3031   // Maximal capacity of HashTable. Based on maximal length of underlying
3032   // FixedArray. Staying below kMaxCapacity also ensures that EntryToIndex
3033   // cannot overflow.
3034   static const int kMaxCapacity =
3035       (FixedArray::kMaxLength - kElementsStartOffset) / kEntrySize;
3036
3037  private:
3038   // Returns _expected_ if one of entries given by the first _probe_ probes is
3039   // equal to  _expected_. Otherwise, returns the entry given by the probe
3040   // number _probe_.
3041   uint32_t EntryForProbe(Key key, Object* k, int probe, uint32_t expected);
3042
3043   void Swap(uint32_t entry1, uint32_t entry2, WriteBarrierMode mode);
3044
3045   // Rehashes this hash-table into the new table.
3046   void Rehash(Handle<Derived> new_table, Key key);
3047 };
3048
3049
3050 // HashTableKey is an abstract superclass for virtual key behavior.
3051 class HashTableKey {
3052  public:
3053   // Returns whether the other object matches this key.
3054   virtual bool IsMatch(Object* other) = 0;
3055   // Returns the hash value for this key.
3056   virtual uint32_t Hash() = 0;
3057   // Returns the hash value for object.
3058   virtual uint32_t HashForObject(Object* key) = 0;
3059   // Returns the key object for storing into the hash table.
3060   MUST_USE_RESULT virtual Handle<Object> AsHandle(Isolate* isolate) = 0;
3061   // Required.
3062   virtual ~HashTableKey() {}
3063 };
3064
3065
3066 class StringTableShape : public BaseShape<HashTableKey*> {
3067  public:
3068   static inline bool IsMatch(HashTableKey* key, Object* value) {
3069     return key->IsMatch(value);
3070   }
3071
3072   static inline uint32_t Hash(HashTableKey* key) {
3073     return key->Hash();
3074   }
3075
3076   static inline uint32_t HashForObject(HashTableKey* key, Object* object) {
3077     return key->HashForObject(object);
3078   }
3079
3080   static inline Handle<Object> AsHandle(Isolate* isolate, HashTableKey* key);
3081
3082   static const int kPrefixSize = 0;
3083   static const int kEntrySize = 1;
3084 };
3085
3086 class SeqOneByteString;
3087
3088 // StringTable.
3089 //
3090 // No special elements in the prefix and the element size is 1
3091 // because only the string itself (the key) needs to be stored.
3092 class StringTable: public HashTable<StringTable,
3093                                     StringTableShape,
3094                                     HashTableKey*> {
3095  public:
3096   // Find string in the string table. If it is not there yet, it is
3097   // added. The return value is the string found.
3098   static Handle<String> LookupString(Isolate* isolate, Handle<String> key);
3099   static Handle<String> LookupKey(Isolate* isolate, HashTableKey* key);
3100   static String* LookupKeyIfExists(Isolate* isolate, HashTableKey* key);
3101
3102   // Tries to internalize given string and returns string handle on success
3103   // or an empty handle otherwise.
3104   MUST_USE_RESULT static MaybeHandle<String> InternalizeStringIfExists(
3105       Isolate* isolate,
3106       Handle<String> string);
3107
3108   // Looks up a string that is equal to the given string and returns
3109   // string handle if it is found, or an empty handle otherwise.
3110   MUST_USE_RESULT static MaybeHandle<String> LookupStringIfExists(
3111       Isolate* isolate,
3112       Handle<String> str);
3113   MUST_USE_RESULT static MaybeHandle<String> LookupTwoCharsStringIfExists(
3114       Isolate* isolate,
3115       uint16_t c1,
3116       uint16_t c2);
3117
3118   static void EnsureCapacityForDeserialization(Isolate* isolate, int expected);
3119
3120   DECLARE_CAST(StringTable)
3121
3122  private:
3123   template <bool seq_one_byte>
3124   friend class JsonParser;
3125
3126   DISALLOW_IMPLICIT_CONSTRUCTORS(StringTable);
3127 };
3128
3129
3130 template <typename Derived, typename Shape, typename Key>
3131 class Dictionary: public HashTable<Derived, Shape, Key> {
3132   typedef HashTable<Derived, Shape, Key> DerivedHashTable;
3133
3134  public:
3135   // Returns the value at entry.
3136   Object* ValueAt(int entry) {
3137     return this->get(Derived::EntryToIndex(entry) + 1);
3138   }
3139
3140   // Set the value for entry.
3141   void ValueAtPut(int entry, Object* value) {
3142     this->set(Derived::EntryToIndex(entry) + 1, value);
3143   }
3144
3145   // Returns the property details for the property at entry.
3146   PropertyDetails DetailsAt(int entry) {
3147     return Shape::DetailsAt(static_cast<Derived*>(this), entry);
3148   }
3149
3150   // Set the details for entry.
3151   void DetailsAtPut(int entry, PropertyDetails value) {
3152     Shape::DetailsAtPut(static_cast<Derived*>(this), entry, value);
3153   }
3154
3155   // Returns true if property at given entry is deleted.
3156   bool IsDeleted(int entry) {
3157     return Shape::IsDeleted(static_cast<Derived*>(this), entry);
3158   }
3159
3160   // Delete a property from the dictionary.
3161   static Handle<Object> DeleteProperty(Handle<Derived> dictionary, int entry);
3162
3163   // Attempt to shrink the dictionary after deletion of key.
3164   MUST_USE_RESULT static inline Handle<Derived> Shrink(
3165       Handle<Derived> dictionary,
3166       Key key) {
3167     return DerivedHashTable::Shrink(dictionary, key);
3168   }
3169
3170   // Sorting support
3171   // TODO(dcarney): templatize or move to SeededNumberDictionary
3172   void CopyValuesTo(FixedArray* elements);
3173
3174   // Returns the number of elements in the dictionary filtering out properties
3175   // with the specified attributes.
3176   int NumberOfElementsFilterAttributes(PropertyAttributes filter);
3177
3178   // Returns the number of enumerable elements in the dictionary.
3179   int NumberOfEnumElements() {
3180     return NumberOfElementsFilterAttributes(
3181         static_cast<PropertyAttributes>(DONT_ENUM | SYMBOLIC));
3182   }
3183
3184   // Returns true if the dictionary contains any elements that are non-writable,
3185   // non-configurable, non-enumerable, or have getters/setters.
3186   bool HasComplexElements();
3187
3188   enum SortMode { UNSORTED, SORTED };
3189
3190   // Fill in details for properties into storage.
3191   // Returns the number of properties added.
3192   int CopyKeysTo(FixedArray* storage, int index, PropertyAttributes filter,
3193                  SortMode sort_mode);
3194
3195   // Copies enumerable keys to preallocated fixed array.
3196   void CopyEnumKeysTo(FixedArray* storage);
3197
3198   // Accessors for next enumeration index.
3199   void SetNextEnumerationIndex(int index) {
3200     DCHECK(index != 0);
3201     this->set(kNextEnumerationIndexIndex, Smi::FromInt(index));
3202   }
3203
3204   int NextEnumerationIndex() {
3205     return Smi::cast(this->get(kNextEnumerationIndexIndex))->value();
3206   }
3207
3208   // Creates a new dictionary.
3209   MUST_USE_RESULT static Handle<Derived> New(
3210       Isolate* isolate,
3211       int at_least_space_for,
3212       PretenureFlag pretenure = NOT_TENURED);
3213
3214   // Ensure enough space for n additional elements.
3215   static Handle<Derived> EnsureCapacity(Handle<Derived> obj, int n, Key key);
3216
3217 #ifdef OBJECT_PRINT
3218   void Print(std::ostream& os);  // NOLINT
3219 #endif
3220   // Returns the key (slow).
3221   Object* SlowReverseLookup(Object* value);
3222
3223   // Sets the entry to (key, value) pair.
3224   inline void SetEntry(int entry,
3225                        Handle<Object> key,
3226                        Handle<Object> value);
3227   inline void SetEntry(int entry,
3228                        Handle<Object> key,
3229                        Handle<Object> value,
3230                        PropertyDetails details);
3231
3232   MUST_USE_RESULT static Handle<Derived> Add(
3233       Handle<Derived> dictionary,
3234       Key key,
3235       Handle<Object> value,
3236       PropertyDetails details);
3237
3238   // Returns iteration indices array for the |dictionary|.
3239   // Values are direct indices in the |HashTable| array.
3240   static Handle<FixedArray> BuildIterationIndicesArray(
3241       Handle<Derived> dictionary);
3242
3243  protected:
3244   // Generic at put operation.
3245   MUST_USE_RESULT static Handle<Derived> AtPut(
3246       Handle<Derived> dictionary,
3247       Key key,
3248       Handle<Object> value);
3249
3250   // Add entry to dictionary.
3251   static void AddEntry(
3252       Handle<Derived> dictionary,
3253       Key key,
3254       Handle<Object> value,
3255       PropertyDetails details,
3256       uint32_t hash);
3257
3258   // Generate new enumeration indices to avoid enumeration index overflow.
3259   // Returns iteration indices array for the |dictionary|.
3260   static Handle<FixedArray> GenerateNewEnumerationIndices(
3261       Handle<Derived> dictionary);
3262   static const int kMaxNumberKeyIndex = DerivedHashTable::kPrefixStartIndex;
3263   static const int kNextEnumerationIndexIndex = kMaxNumberKeyIndex + 1;
3264 };
3265
3266
3267 template <typename Derived, typename Shape>
3268 class NameDictionaryBase : public Dictionary<Derived, Shape, Handle<Name> > {
3269   typedef Dictionary<Derived, Shape, Handle<Name> > DerivedDictionary;
3270
3271  public:
3272   // Find entry for key, otherwise return kNotFound. Optimized version of
3273   // HashTable::FindEntry.
3274   int FindEntry(Handle<Name> key);
3275 };
3276
3277
3278 template <typename Key>
3279 class BaseDictionaryShape : public BaseShape<Key> {
3280  public:
3281   template <typename Dictionary>
3282   static inline PropertyDetails DetailsAt(Dictionary* dict, int entry) {
3283     STATIC_ASSERT(Dictionary::kEntrySize == 3);
3284     DCHECK(entry >= 0);  // Not found is -1, which is not caught by get().
3285     return PropertyDetails(
3286         Smi::cast(dict->get(Dictionary::EntryToIndex(entry) + 2)));
3287   }
3288
3289   template <typename Dictionary>
3290   static inline void DetailsAtPut(Dictionary* dict, int entry,
3291                                   PropertyDetails value) {
3292     STATIC_ASSERT(Dictionary::kEntrySize == 3);
3293     dict->set(Dictionary::EntryToIndex(entry) + 2, value.AsSmi());
3294   }
3295
3296   template <typename Dictionary>
3297   static bool IsDeleted(Dictionary* dict, int entry) {
3298     return false;
3299   }
3300
3301   template <typename Dictionary>
3302   static inline void SetEntry(Dictionary* dict, int entry, Handle<Object> key,
3303                               Handle<Object> value, PropertyDetails details);
3304 };
3305
3306
3307 class NameDictionaryShape : public BaseDictionaryShape<Handle<Name> > {
3308  public:
3309   static inline bool IsMatch(Handle<Name> key, Object* other);
3310   static inline uint32_t Hash(Handle<Name> key);
3311   static inline uint32_t HashForObject(Handle<Name> key, Object* object);
3312   static inline Handle<Object> AsHandle(Isolate* isolate, Handle<Name> key);
3313   static const int kPrefixSize = 2;
3314   static const int kEntrySize = 3;
3315   static const bool kIsEnumerable = true;
3316 };
3317
3318
3319 class NameDictionary
3320     : public NameDictionaryBase<NameDictionary, NameDictionaryShape> {
3321   typedef NameDictionaryBase<NameDictionary, NameDictionaryShape>
3322       DerivedDictionary;
3323
3324  public:
3325   DECLARE_CAST(NameDictionary)
3326
3327   inline static Handle<FixedArray> DoGenerateNewEnumerationIndices(
3328       Handle<NameDictionary> dictionary);
3329 };
3330
3331
3332 class GlobalDictionaryShape : public NameDictionaryShape {
3333  public:
3334   static const int kEntrySize = 2;  // Overrides NameDictionaryShape::kEntrySize
3335
3336   template <typename Dictionary>
3337   static inline PropertyDetails DetailsAt(Dictionary* dict, int entry);
3338
3339   template <typename Dictionary>
3340   static inline void DetailsAtPut(Dictionary* dict, int entry,
3341                                   PropertyDetails value);
3342
3343   template <typename Dictionary>
3344   static bool IsDeleted(Dictionary* dict, int entry);
3345
3346   template <typename Dictionary>
3347   static inline void SetEntry(Dictionary* dict, int entry, Handle<Object> key,
3348                               Handle<Object> value, PropertyDetails details);
3349 };
3350
3351
3352 class GlobalDictionary
3353     : public NameDictionaryBase<GlobalDictionary, GlobalDictionaryShape> {
3354  public:
3355   DECLARE_CAST(GlobalDictionary)
3356 };
3357
3358
3359 class NumberDictionaryShape : public BaseDictionaryShape<uint32_t> {
3360  public:
3361   static inline bool IsMatch(uint32_t key, Object* other);
3362   static inline Handle<Object> AsHandle(Isolate* isolate, uint32_t key);
3363   static const int kEntrySize = 3;
3364   static const bool kIsEnumerable = false;
3365 };
3366
3367
3368 class SeededNumberDictionaryShape : public NumberDictionaryShape {
3369  public:
3370   static const bool UsesSeed = true;
3371   static const int kPrefixSize = 2;
3372
3373   static inline uint32_t SeededHash(uint32_t key, uint32_t seed);
3374   static inline uint32_t SeededHashForObject(uint32_t key,
3375                                              uint32_t seed,
3376                                              Object* object);
3377 };
3378
3379
3380 class UnseededNumberDictionaryShape : public NumberDictionaryShape {
3381  public:
3382   static const int kPrefixSize = 0;
3383
3384   static inline uint32_t Hash(uint32_t key);
3385   static inline uint32_t HashForObject(uint32_t key, Object* object);
3386 };
3387
3388
3389 class SeededNumberDictionary
3390     : public Dictionary<SeededNumberDictionary,
3391                         SeededNumberDictionaryShape,
3392                         uint32_t> {
3393  public:
3394   DECLARE_CAST(SeededNumberDictionary)
3395
3396   // Type specific at put (default NONE attributes is used when adding).
3397   MUST_USE_RESULT static Handle<SeededNumberDictionary> AtNumberPut(
3398       Handle<SeededNumberDictionary> dictionary, uint32_t key,
3399       Handle<Object> value, bool used_as_prototype);
3400   MUST_USE_RESULT static Handle<SeededNumberDictionary> AddNumberEntry(
3401       Handle<SeededNumberDictionary> dictionary, uint32_t key,
3402       Handle<Object> value, PropertyDetails details, bool used_as_prototype);
3403
3404   // Set an existing entry or add a new one if needed.
3405   // Return the updated dictionary.
3406   MUST_USE_RESULT static Handle<SeededNumberDictionary> Set(
3407       Handle<SeededNumberDictionary> dictionary, uint32_t key,
3408       Handle<Object> value, PropertyDetails details, bool used_as_prototype);
3409
3410   void UpdateMaxNumberKey(uint32_t key, bool used_as_prototype);
3411
3412   // If slow elements are required we will never go back to fast-case
3413   // for the elements kept in this dictionary.  We require slow
3414   // elements if an element has been added at an index larger than
3415   // kRequiresSlowElementsLimit or set_requires_slow_elements() has been called
3416   // when defining a getter or setter with a number key.
3417   inline bool requires_slow_elements();
3418   inline void set_requires_slow_elements();
3419
3420   // Get the value of the max number key that has been added to this
3421   // dictionary.  max_number_key can only be called if
3422   // requires_slow_elements returns false.
3423   inline uint32_t max_number_key();
3424
3425   // Bit masks.
3426   static const int kRequiresSlowElementsMask = 1;
3427   static const int kRequiresSlowElementsTagSize = 1;
3428   static const uint32_t kRequiresSlowElementsLimit = (1 << 29) - 1;
3429 };
3430
3431
3432 class UnseededNumberDictionary
3433     : public Dictionary<UnseededNumberDictionary,
3434                         UnseededNumberDictionaryShape,
3435                         uint32_t> {
3436  public:
3437   DECLARE_CAST(UnseededNumberDictionary)
3438
3439   // Type specific at put (default NONE attributes is used when adding).
3440   MUST_USE_RESULT static Handle<UnseededNumberDictionary> AtNumberPut(
3441       Handle<UnseededNumberDictionary> dictionary,
3442       uint32_t key,
3443       Handle<Object> value);
3444   MUST_USE_RESULT static Handle<UnseededNumberDictionary> AddNumberEntry(
3445       Handle<UnseededNumberDictionary> dictionary,
3446       uint32_t key,
3447       Handle<Object> value);
3448
3449   // Set an existing entry or add a new one if needed.
3450   // Return the updated dictionary.
3451   MUST_USE_RESULT static Handle<UnseededNumberDictionary> Set(
3452       Handle<UnseededNumberDictionary> dictionary,
3453       uint32_t key,
3454       Handle<Object> value);
3455 };
3456
3457
3458 class ObjectHashTableShape : public BaseShape<Handle<Object> > {
3459  public:
3460   static inline bool IsMatch(Handle<Object> key, Object* other);
3461   static inline uint32_t Hash(Handle<Object> key);
3462   static inline uint32_t HashForObject(Handle<Object> key, Object* object);
3463   static inline Handle<Object> AsHandle(Isolate* isolate, Handle<Object> key);
3464   static const int kPrefixSize = 0;
3465   static const int kEntrySize = 2;
3466 };
3467
3468
3469 // ObjectHashTable maps keys that are arbitrary objects to object values by
3470 // using the identity hash of the key for hashing purposes.
3471 class ObjectHashTable: public HashTable<ObjectHashTable,
3472                                         ObjectHashTableShape,
3473                                         Handle<Object> > {
3474   typedef HashTable<
3475       ObjectHashTable, ObjectHashTableShape, Handle<Object> > DerivedHashTable;
3476  public:
3477   DECLARE_CAST(ObjectHashTable)
3478
3479   // Attempt to shrink hash table after removal of key.
3480   MUST_USE_RESULT static inline Handle<ObjectHashTable> Shrink(
3481       Handle<ObjectHashTable> table,
3482       Handle<Object> key);
3483
3484   // Looks up the value associated with the given key. The hole value is
3485   // returned in case the key is not present.
3486   Object* Lookup(Handle<Object> key);
3487   Object* Lookup(Handle<Object> key, int32_t hash);
3488   Object* Lookup(Isolate* isolate, Handle<Object> key, int32_t hash);
3489
3490   // Adds (or overwrites) the value associated with the given key.
3491   static Handle<ObjectHashTable> Put(Handle<ObjectHashTable> table,
3492                                      Handle<Object> key,
3493                                      Handle<Object> value);
3494   static Handle<ObjectHashTable> Put(Handle<ObjectHashTable> table,
3495                                      Handle<Object> key, Handle<Object> value,
3496                                      int32_t hash);
3497
3498   // Returns an ObjectHashTable (possibly |table|) where |key| has been removed.
3499   static Handle<ObjectHashTable> Remove(Handle<ObjectHashTable> table,
3500                                         Handle<Object> key,
3501                                         bool* was_present);
3502   static Handle<ObjectHashTable> Remove(Handle<ObjectHashTable> table,
3503                                         Handle<Object> key, bool* was_present,
3504                                         int32_t hash);
3505
3506  protected:
3507   friend class MarkCompactCollector;
3508
3509   void AddEntry(int entry, Object* key, Object* value);
3510   void RemoveEntry(int entry);
3511
3512   // Returns the index to the value of an entry.
3513   static inline int EntryToValueIndex(int entry) {
3514     return EntryToIndex(entry) + 1;
3515   }
3516 };
3517
3518
3519 // OrderedHashTable is a HashTable with Object keys that preserves
3520 // insertion order. There are Map and Set interfaces (OrderedHashMap
3521 // and OrderedHashTable, below). It is meant to be used by JSMap/JSSet.
3522 //
3523 // Only Object* keys are supported, with Object::SameValueZero() used as the
3524 // equality operator and Object::GetHash() for the hash function.
3525 //
3526 // Based on the "Deterministic Hash Table" as described by Jason Orendorff at
3527 // https://wiki.mozilla.org/User:Jorend/Deterministic_hash_tables
3528 // Originally attributed to Tyler Close.
3529 //
3530 // Memory layout:
3531 //   [0]: bucket count
3532 //   [1]: element count
3533 //   [2]: deleted element count
3534 //   [3..(3 + NumberOfBuckets() - 1)]: "hash table", where each item is an
3535 //                            offset into the data table (see below) where the
3536 //                            first item in this bucket is stored.
3537 //   [3 + NumberOfBuckets()..length]: "data table", an array of length
3538 //                            Capacity() * kEntrySize, where the first entrysize
3539 //                            items are handled by the derived class and the
3540 //                            item at kChainOffset is another entry into the
3541 //                            data table indicating the next entry in this hash
3542 //                            bucket.
3543 //
3544 // When we transition the table to a new version we obsolete it and reuse parts
3545 // of the memory to store information how to transition an iterator to the new
3546 // table:
3547 //
3548 // Memory layout for obsolete table:
3549 //   [0]: bucket count
3550 //   [1]: Next newer table
3551 //   [2]: Number of removed holes or -1 when the table was cleared.
3552 //   [3..(3 + NumberOfRemovedHoles() - 1)]: The indexes of the removed holes.
3553 //   [3 + NumberOfRemovedHoles()..length]: Not used
3554 //
3555 template<class Derived, class Iterator, int entrysize>
3556 class OrderedHashTable: public FixedArray {
3557  public:
3558   // Returns an OrderedHashTable with a capacity of at least |capacity|.
3559   static Handle<Derived> Allocate(
3560       Isolate* isolate, int capacity, PretenureFlag pretenure = NOT_TENURED);
3561
3562   // Returns an OrderedHashTable (possibly |table|) with enough space
3563   // to add at least one new element.
3564   static Handle<Derived> EnsureGrowable(Handle<Derived> table);
3565
3566   // Returns an OrderedHashTable (possibly |table|) that's shrunken
3567   // if possible.
3568   static Handle<Derived> Shrink(Handle<Derived> table);
3569
3570   // Returns a new empty OrderedHashTable and records the clearing so that
3571   // exisiting iterators can be updated.
3572   static Handle<Derived> Clear(Handle<Derived> table);
3573
3574   int NumberOfElements() {
3575     return Smi::cast(get(kNumberOfElementsIndex))->value();
3576   }
3577
3578   int NumberOfDeletedElements() {
3579     return Smi::cast(get(kNumberOfDeletedElementsIndex))->value();
3580   }
3581
3582   int UsedCapacity() { return NumberOfElements() + NumberOfDeletedElements(); }
3583
3584   int NumberOfBuckets() {
3585     return Smi::cast(get(kNumberOfBucketsIndex))->value();
3586   }
3587
3588   // Returns an index into |this| for the given entry.
3589   int EntryToIndex(int entry) {
3590     return kHashTableStartIndex + NumberOfBuckets() + (entry * kEntrySize);
3591   }
3592
3593   Object* KeyAt(int entry) { return get(EntryToIndex(entry)); }
3594
3595   bool IsObsolete() {
3596     return !get(kNextTableIndex)->IsSmi();
3597   }
3598
3599   // The next newer table. This is only valid if the table is obsolete.
3600   Derived* NextTable() {
3601     return Derived::cast(get(kNextTableIndex));
3602   }
3603
3604   // When the table is obsolete we store the indexes of the removed holes.
3605   int RemovedIndexAt(int index) {
3606     return Smi::cast(get(kRemovedHolesIndex + index))->value();
3607   }
3608
3609   static const int kNotFound = -1;
3610   static const int kMinCapacity = 4;
3611
3612   static const int kNumberOfBucketsIndex = 0;
3613   static const int kNumberOfElementsIndex = kNumberOfBucketsIndex + 1;
3614   static const int kNumberOfDeletedElementsIndex = kNumberOfElementsIndex + 1;
3615   static const int kHashTableStartIndex = kNumberOfDeletedElementsIndex + 1;
3616   static const int kNextTableIndex = kNumberOfElementsIndex;
3617
3618   static const int kNumberOfBucketsOffset =
3619       kHeaderSize + kNumberOfBucketsIndex * kPointerSize;
3620   static const int kNumberOfElementsOffset =
3621       kHeaderSize + kNumberOfElementsIndex * kPointerSize;
3622   static const int kNumberOfDeletedElementsOffset =
3623       kHeaderSize + kNumberOfDeletedElementsIndex * kPointerSize;
3624   static const int kHashTableStartOffset =
3625       kHeaderSize + kHashTableStartIndex * kPointerSize;
3626   static const int kNextTableOffset =
3627       kHeaderSize + kNextTableIndex * kPointerSize;
3628
3629   static const int kEntrySize = entrysize + 1;
3630   static const int kChainOffset = entrysize;
3631
3632   static const int kLoadFactor = 2;
3633
3634   // NumberOfDeletedElements is set to kClearedTableSentinel when
3635   // the table is cleared, which allows iterator transitions to
3636   // optimize that case.
3637   static const int kClearedTableSentinel = -1;
3638
3639  private:
3640   static Handle<Derived> Rehash(Handle<Derived> table, int new_capacity);
3641
3642   void SetNumberOfBuckets(int num) {
3643     set(kNumberOfBucketsIndex, Smi::FromInt(num));
3644   }
3645
3646   void SetNumberOfElements(int num) {
3647     set(kNumberOfElementsIndex, Smi::FromInt(num));
3648   }
3649
3650   void SetNumberOfDeletedElements(int num) {
3651     set(kNumberOfDeletedElementsIndex, Smi::FromInt(num));
3652   }
3653
3654   int Capacity() {
3655     return NumberOfBuckets() * kLoadFactor;
3656   }
3657
3658   void SetNextTable(Derived* next_table) {
3659     set(kNextTableIndex, next_table);
3660   }
3661
3662   void SetRemovedIndexAt(int index, int removed_index) {
3663     return set(kRemovedHolesIndex + index, Smi::FromInt(removed_index));
3664   }
3665
3666   static const int kRemovedHolesIndex = kHashTableStartIndex;
3667
3668   static const int kMaxCapacity =
3669       (FixedArray::kMaxLength - kHashTableStartIndex)
3670       / (1 + (kEntrySize * kLoadFactor));
3671 };
3672
3673
3674 class JSSetIterator;
3675
3676
3677 class OrderedHashSet: public OrderedHashTable<
3678     OrderedHashSet, JSSetIterator, 1> {
3679  public:
3680   DECLARE_CAST(OrderedHashSet)
3681 };
3682
3683
3684 class JSMapIterator;
3685
3686
3687 class OrderedHashMap
3688     : public OrderedHashTable<OrderedHashMap, JSMapIterator, 2> {
3689  public:
3690   DECLARE_CAST(OrderedHashMap)
3691
3692   inline Object* ValueAt(int entry);
3693
3694   static const int kValueOffset = 1;
3695 };
3696
3697
3698 template <int entrysize>
3699 class WeakHashTableShape : public BaseShape<Handle<Object> > {
3700  public:
3701   static inline bool IsMatch(Handle<Object> key, Object* other);
3702   static inline uint32_t Hash(Handle<Object> key);
3703   static inline uint32_t HashForObject(Handle<Object> key, Object* object);
3704   static inline Handle<Object> AsHandle(Isolate* isolate, Handle<Object> key);
3705   static const int kPrefixSize = 0;
3706   static const int kEntrySize = entrysize;
3707 };
3708
3709
3710 // WeakHashTable maps keys that are arbitrary heap objects to heap object
3711 // values. The table wraps the keys in weak cells and store values directly.
3712 // Thus it references keys weakly and values strongly.
3713 class WeakHashTable: public HashTable<WeakHashTable,
3714                                       WeakHashTableShape<2>,
3715                                       Handle<Object> > {
3716   typedef HashTable<
3717       WeakHashTable, WeakHashTableShape<2>, Handle<Object> > DerivedHashTable;
3718  public:
3719   DECLARE_CAST(WeakHashTable)
3720
3721   // Looks up the value associated with the given key. The hole value is
3722   // returned in case the key is not present.
3723   Object* Lookup(Handle<HeapObject> key);
3724
3725   // Adds (or overwrites) the value associated with the given key. Mapping a
3726   // key to the hole value causes removal of the whole entry.
3727   MUST_USE_RESULT static Handle<WeakHashTable> Put(Handle<WeakHashTable> table,
3728                                                    Handle<HeapObject> key,
3729                                                    Handle<HeapObject> value);
3730
3731   static Handle<FixedArray> GetValues(Handle<WeakHashTable> table);
3732
3733  private:
3734   friend class MarkCompactCollector;
3735
3736   void AddEntry(int entry, Handle<WeakCell> key, Handle<HeapObject> value);
3737
3738   // Returns the index to the value of an entry.
3739   static inline int EntryToValueIndex(int entry) {
3740     return EntryToIndex(entry) + 1;
3741   }
3742 };
3743
3744
3745 // ScopeInfo represents information about different scopes of a source
3746 // program  and the allocation of the scope's variables. Scope information
3747 // is stored in a compressed form in ScopeInfo objects and is used
3748 // at runtime (stack dumps, deoptimization, etc.).
3749
3750 // This object provides quick access to scope info details for runtime
3751 // routines.
3752 class ScopeInfo : public FixedArray {
3753  public:
3754   DECLARE_CAST(ScopeInfo)
3755
3756   // Return the type of this scope.
3757   ScopeType scope_type();
3758
3759   // Does this scope call eval?
3760   bool CallsEval();
3761
3762   // Return the language mode of this scope.
3763   LanguageMode language_mode();
3764
3765   // True if this scope is a (var) declaration scope.
3766   bool is_declaration_scope();
3767
3768   // Does this scope make a sloppy eval call?
3769   bool CallsSloppyEval() { return CallsEval() && is_sloppy(language_mode()); }
3770
3771   // Return the total number of locals allocated on the stack and in the
3772   // context. This includes the parameters that are allocated in the context.
3773   int LocalCount();
3774
3775   // Return the number of stack slots for code. This number consists of two
3776   // parts:
3777   //  1. One stack slot per stack allocated local.
3778   //  2. One stack slot for the function name if it is stack allocated.
3779   int StackSlotCount();
3780
3781   // Return the number of context slots for code if a context is allocated. This
3782   // number consists of three parts:
3783   //  1. Size of fixed header for every context: Context::MIN_CONTEXT_SLOTS
3784   //  2. One context slot per context allocated local.
3785   //  3. One context slot for the function name if it is context allocated.
3786   // Parameters allocated in the context count as context allocated locals. If
3787   // no contexts are allocated for this scope ContextLength returns 0.
3788   int ContextLength();
3789
3790   // Does this scope declare a "this" binding?
3791   bool HasReceiver();
3792
3793   // Does this scope declare a "this" binding, and the "this" binding is stack-
3794   // or context-allocated?
3795   bool HasAllocatedReceiver();
3796
3797   // Is this scope the scope of a named function expression?
3798   bool HasFunctionName();
3799
3800   // Return if this has context allocated locals.
3801   bool HasHeapAllocatedLocals();
3802
3803   // Return if contexts are allocated for this scope.
3804   bool HasContext();
3805
3806   // Return if this is a function scope with "use asm".
3807   inline bool IsAsmModule();
3808
3809   // Return if this is a nested function within an asm module scope.
3810   inline bool IsAsmFunction();
3811
3812   inline bool HasSimpleParameters();
3813
3814   // Return the function_name if present.
3815   String* FunctionName();
3816
3817   // Return the name of the given parameter.
3818   String* ParameterName(int var);
3819
3820   // Return the name of the given local.
3821   String* LocalName(int var);
3822
3823   // Return the name of the given stack local.
3824   String* StackLocalName(int var);
3825
3826   // Return the name of the given stack local.
3827   int StackLocalIndex(int var);
3828
3829   // Return the name of the given context local.
3830   String* ContextLocalName(int var);
3831
3832   // Return the mode of the given context local.
3833   VariableMode ContextLocalMode(int var);
3834
3835   // Return the initialization flag of the given context local.
3836   InitializationFlag ContextLocalInitFlag(int var);
3837
3838   // Return the initialization flag of the given context local.
3839   MaybeAssignedFlag ContextLocalMaybeAssignedFlag(int var);
3840
3841   // Return true if this local was introduced by the compiler, and should not be
3842   // exposed to the user in a debugger.
3843   bool LocalIsSynthetic(int var);
3844
3845   String* StrongModeFreeVariableName(int var);
3846   int StrongModeFreeVariableStartPosition(int var);
3847   int StrongModeFreeVariableEndPosition(int var);
3848
3849   // Lookup support for serialized scope info. Returns the
3850   // the stack slot index for a given slot name if the slot is
3851   // present; otherwise returns a value < 0. The name must be an internalized
3852   // string.
3853   int StackSlotIndex(String* name);
3854
3855   // Lookup support for serialized scope info. Returns the
3856   // context slot index for a given slot name if the slot is present; otherwise
3857   // returns a value < 0. The name must be an internalized string.
3858   // If the slot is present and mode != NULL, sets *mode to the corresponding
3859   // mode for that variable.
3860   static int ContextSlotIndex(Handle<ScopeInfo> scope_info, Handle<String> name,
3861                               VariableMode* mode, VariableLocation* location,
3862                               InitializationFlag* init_flag,
3863                               MaybeAssignedFlag* maybe_assigned_flag);
3864
3865   // Lookup the name of a certain context slot by its index.
3866   String* ContextSlotName(int slot_index);
3867
3868   // Lookup support for serialized scope info. Returns the
3869   // parameter index for a given parameter name if the parameter is present;
3870   // otherwise returns a value < 0. The name must be an internalized string.
3871   int ParameterIndex(String* name);
3872
3873   // Lookup support for serialized scope info. Returns the function context
3874   // slot index if the function name is present and context-allocated (named
3875   // function expressions, only), otherwise returns a value < 0. The name
3876   // must be an internalized string.
3877   int FunctionContextSlotIndex(String* name, VariableMode* mode);
3878
3879   // Lookup support for serialized scope info.  Returns the receiver context
3880   // slot index if scope has a "this" binding, and the binding is
3881   // context-allocated.  Otherwise returns a value < 0.
3882   int ReceiverContextSlotIndex();
3883
3884   FunctionKind function_kind();
3885
3886   static Handle<ScopeInfo> Create(Isolate* isolate, Zone* zone, Scope* scope);
3887   static Handle<ScopeInfo> CreateGlobalThisBinding(Isolate* isolate);
3888
3889   // Serializes empty scope info.
3890   static ScopeInfo* Empty(Isolate* isolate);
3891
3892 #ifdef DEBUG
3893   void Print();
3894 #endif
3895
3896   // The layout of the static part of a ScopeInfo is as follows. Each entry is
3897   // numeric and occupies one array slot.
3898   // 1. A set of properties of the scope
3899   // 2. The number of parameters. This only applies to function scopes. For
3900   //    non-function scopes this is 0.
3901   // 3. The number of non-parameter variables allocated on the stack.
3902   // 4. The number of non-parameter and parameter variables allocated in the
3903   //    context.
3904 #define FOR_EACH_SCOPE_INFO_NUMERIC_FIELD(V) \
3905   V(Flags)                                   \
3906   V(ParameterCount)                          \
3907   V(StackLocalCount)                         \
3908   V(ContextLocalCount)                       \
3909   V(ContextGlobalCount)                      \
3910   V(StrongModeFreeVariableCount)
3911
3912 #define FIELD_ACCESSORS(name)       \
3913   inline void Set##name(int value); \
3914   inline int name();
3915   FOR_EACH_SCOPE_INFO_NUMERIC_FIELD(FIELD_ACCESSORS)
3916 #undef FIELD_ACCESSORS
3917
3918  private:
3919   enum {
3920 #define DECL_INDEX(name) k##name,
3921     FOR_EACH_SCOPE_INFO_NUMERIC_FIELD(DECL_INDEX)
3922 #undef DECL_INDEX
3923     kVariablePartIndex
3924   };
3925
3926   // The layout of the variable part of a ScopeInfo is as follows:
3927   // 1. ParameterEntries:
3928   //    This part stores the names of the parameters for function scopes. One
3929   //    slot is used per parameter, so in total this part occupies
3930   //    ParameterCount() slots in the array. For other scopes than function
3931   //    scopes ParameterCount() is 0.
3932   // 2. StackLocalFirstSlot:
3933   //    Index of a first stack slot for stack local. Stack locals belonging to
3934   //    this scope are located on a stack at slots starting from this index.
3935   // 3. StackLocalEntries:
3936   //    Contains the names of local variables that are allocated on the stack,
3937   //    in increasing order of the stack slot index. First local variable has
3938   //    a stack slot index defined in StackLocalFirstSlot (point 2 above).
3939   //    One slot is used per stack local, so in total this part occupies
3940   //    StackLocalCount() slots in the array.
3941   // 4. ContextLocalNameEntries:
3942   //    Contains the names of local variables and parameters that are allocated
3943   //    in the context. They are stored in increasing order of the context slot
3944   //    index starting with Context::MIN_CONTEXT_SLOTS. One slot is used per
3945   //    context local, so in total this part occupies ContextLocalCount() slots
3946   //    in the array.
3947   // 5. ContextLocalInfoEntries:
3948   //    Contains the variable modes and initialization flags corresponding to
3949   //    the context locals in ContextLocalNameEntries. One slot is used per
3950   //    context local, so in total this part occupies ContextLocalCount()
3951   //    slots in the array.
3952   // 6. StrongModeFreeVariableNameEntries:
3953   //    Stores the names of strong mode free variables.
3954   // 7. StrongModeFreeVariablePositionEntries:
3955   //    Stores the locations (start and end position) of strong mode free
3956   //    variables.
3957   // 8. RecieverEntryIndex:
3958   //    If the scope binds a "this" value, one slot is reserved to hold the
3959   //    context or stack slot index for the variable.
3960   // 9. FunctionNameEntryIndex:
3961   //    If the scope belongs to a named function expression this part contains
3962   //    information about the function variable. It always occupies two array
3963   //    slots:  a. The name of the function variable.
3964   //            b. The context or stack slot index for the variable.
3965   int ParameterEntriesIndex();
3966   int StackLocalFirstSlotIndex();
3967   int StackLocalEntriesIndex();
3968   int ContextLocalNameEntriesIndex();
3969   int ContextGlobalNameEntriesIndex();
3970   int ContextLocalInfoEntriesIndex();
3971   int ContextGlobalInfoEntriesIndex();
3972   int StrongModeFreeVariableNameEntriesIndex();
3973   int StrongModeFreeVariablePositionEntriesIndex();
3974   int ReceiverEntryIndex();
3975   int FunctionNameEntryIndex();
3976
3977   int Lookup(Handle<String> name, int start, int end, VariableMode* mode,
3978              VariableLocation* location, InitializationFlag* init_flag,
3979              MaybeAssignedFlag* maybe_assigned_flag);
3980
3981   // Used for the function name variable for named function expressions, and for
3982   // the receiver.
3983   enum VariableAllocationInfo { NONE, STACK, CONTEXT, UNUSED };
3984
3985   // Properties of scopes.
3986   class ScopeTypeField : public BitField<ScopeType, 0, 4> {};
3987   class CallsEvalField : public BitField<bool, ScopeTypeField::kNext, 1> {};
3988   STATIC_ASSERT(LANGUAGE_END == 3);
3989   class LanguageModeField
3990       : public BitField<LanguageMode, CallsEvalField::kNext, 2> {};
3991   class DeclarationScopeField
3992       : public BitField<bool, LanguageModeField::kNext, 1> {};
3993   class ReceiverVariableField
3994       : public BitField<VariableAllocationInfo, DeclarationScopeField::kNext,
3995                         2> {};
3996   class FunctionVariableField
3997       : public BitField<VariableAllocationInfo, ReceiverVariableField::kNext,
3998                         2> {};
3999   class FunctionVariableMode
4000       : public BitField<VariableMode, FunctionVariableField::kNext, 3> {};
4001   class AsmModuleField : public BitField<bool, FunctionVariableMode::kNext, 1> {
4002   };
4003   class AsmFunctionField : public BitField<bool, AsmModuleField::kNext, 1> {};
4004   class HasSimpleParametersField
4005       : public BitField<bool, AsmFunctionField::kNext, 1> {};
4006   class FunctionKindField
4007       : public BitField<FunctionKind, HasSimpleParametersField::kNext, 8> {};
4008
4009   // BitFields representing the encoded information for context locals in the
4010   // ContextLocalInfoEntries part.
4011   class ContextLocalMode:      public BitField<VariableMode,         0, 3> {};
4012   class ContextLocalInitFlag:  public BitField<InitializationFlag,   3, 1> {};
4013   class ContextLocalMaybeAssignedFlag
4014       : public BitField<MaybeAssignedFlag, 4, 1> {};
4015
4016   friend class ScopeIterator;
4017 };
4018
4019
4020 // The cache for maps used by normalized (dictionary mode) objects.
4021 // Such maps do not have property descriptors, so a typical program
4022 // needs very limited number of distinct normalized maps.
4023 class NormalizedMapCache: public FixedArray {
4024  public:
4025   static Handle<NormalizedMapCache> New(Isolate* isolate);
4026
4027   MUST_USE_RESULT MaybeHandle<Map> Get(Handle<Map> fast_map,
4028                                        PropertyNormalizationMode mode);
4029   void Set(Handle<Map> fast_map, Handle<Map> normalized_map);
4030
4031   void Clear();
4032
4033   DECLARE_CAST(NormalizedMapCache)
4034
4035   static inline bool IsNormalizedMapCache(const Object* obj);
4036
4037   DECLARE_VERIFIER(NormalizedMapCache)
4038  private:
4039   static const int kEntries = 64;
4040
4041   static inline int GetIndex(Handle<Map> map);
4042
4043   // The following declarations hide base class methods.
4044   Object* get(int index);
4045   void set(int index, Object* value);
4046 };
4047
4048
4049 // ByteArray represents fixed sized byte arrays.  Used for the relocation info
4050 // that is attached to code objects.
4051 class ByteArray: public FixedArrayBase {
4052  public:
4053   inline int Size();
4054
4055   // Setter and getter.
4056   inline byte get(int index);
4057   inline void set(int index, byte value);
4058
4059   // Treat contents as an int array.
4060   inline int get_int(int index);
4061
4062   static int SizeFor(int length) {
4063     return OBJECT_POINTER_ALIGN(kHeaderSize + length);
4064   }
4065   // We use byte arrays for free blocks in the heap.  Given a desired size in
4066   // bytes that is a multiple of the word size and big enough to hold a byte
4067   // array, this function returns the number of elements a byte array should
4068   // have.
4069   static int LengthFor(int size_in_bytes) {
4070     DCHECK(IsAligned(size_in_bytes, kPointerSize));
4071     DCHECK(size_in_bytes >= kHeaderSize);
4072     return size_in_bytes - kHeaderSize;
4073   }
4074
4075   // Returns data start address.
4076   inline Address GetDataStartAddress();
4077
4078   // Returns a pointer to the ByteArray object for a given data start address.
4079   static inline ByteArray* FromDataStartAddress(Address address);
4080
4081   DECLARE_CAST(ByteArray)
4082
4083   // Dispatched behavior.
4084   inline int ByteArraySize();
4085   DECLARE_PRINTER(ByteArray)
4086   DECLARE_VERIFIER(ByteArray)
4087
4088   // Layout description.
4089   static const int kAlignedSize = OBJECT_POINTER_ALIGN(kHeaderSize);
4090
4091   // Maximal memory consumption for a single ByteArray.
4092   static const int kMaxSize = 512 * MB;
4093   // Maximal length of a single ByteArray.
4094   static const int kMaxLength = kMaxSize - kHeaderSize;
4095
4096  private:
4097   DISALLOW_IMPLICIT_CONSTRUCTORS(ByteArray);
4098 };
4099
4100
4101 // BytecodeArray represents a sequence of interpreter bytecodes.
4102 class BytecodeArray : public FixedArrayBase {
4103  public:
4104   static int SizeFor(int length) {
4105     return OBJECT_POINTER_ALIGN(kHeaderSize + length);
4106   }
4107
4108   // Setter and getter
4109   inline byte get(int index);
4110   inline void set(int index, byte value);
4111
4112   // Returns data start address.
4113   inline Address GetFirstBytecodeAddress();
4114
4115   // Accessors for frame size and the number of locals
4116   inline int frame_size() const;
4117   inline void set_frame_size(int value);
4118
4119   DECLARE_CAST(BytecodeArray)
4120
4121   // Dispatched behavior.
4122   inline int BytecodeArraySize();
4123
4124   DECLARE_PRINTER(BytecodeArray)
4125   DECLARE_VERIFIER(BytecodeArray)
4126
4127   void Disassemble(std::ostream& os);
4128
4129   // Layout description.
4130   static const int kFrameSizeOffset = FixedArrayBase::kHeaderSize;
4131   static const int kHeaderSize = kFrameSizeOffset + kIntSize;
4132
4133   static const int kAlignedSize = OBJECT_POINTER_ALIGN(kHeaderSize);
4134
4135   // Maximal memory consumption for a single BytecodeArray.
4136   static const int kMaxSize = 512 * MB;
4137   // Maximal length of a single BytecodeArray.
4138   static const int kMaxLength = kMaxSize - kHeaderSize;
4139
4140  private:
4141   DISALLOW_IMPLICIT_CONSTRUCTORS(BytecodeArray);
4142 };
4143
4144
4145 // FreeSpace are fixed-size free memory blocks used by the heap and GC.
4146 // They look like heap objects (are heap object tagged and have a map) so that
4147 // the heap remains iterable.  They have a size and a next pointer.
4148 // The next pointer is the raw address of the next FreeSpace object (or NULL)
4149 // in the free list.
4150 class FreeSpace: public HeapObject {
4151  public:
4152   // [size]: size of the free space including the header.
4153   inline int size() const;
4154   inline void set_size(int value);
4155
4156   inline int nobarrier_size() const;
4157   inline void nobarrier_set_size(int value);
4158
4159   inline int Size();
4160
4161   // Accessors for the next field.
4162   inline FreeSpace* next();
4163   inline FreeSpace** next_address();
4164   inline void set_next(FreeSpace* next);
4165
4166   inline static FreeSpace* cast(HeapObject* obj);
4167
4168   // Dispatched behavior.
4169   DECLARE_PRINTER(FreeSpace)
4170   DECLARE_VERIFIER(FreeSpace)
4171
4172   // Layout description.
4173   // Size is smi tagged when it is stored.
4174   static const int kSizeOffset = HeapObject::kHeaderSize;
4175   static const int kNextOffset = POINTER_SIZE_ALIGN(kSizeOffset + kPointerSize);
4176
4177  private:
4178   DISALLOW_IMPLICIT_CONSTRUCTORS(FreeSpace);
4179 };
4180
4181
4182 // V has parameters (Type, type, TYPE, C type, element_size)
4183 #define TYPED_ARRAYS(V) \
4184   V(Uint8, uint8, UINT8, uint8_t, 1)                                           \
4185   V(Int8, int8, INT8, int8_t, 1)                                               \
4186   V(Uint16, uint16, UINT16, uint16_t, 2)                                       \
4187   V(Int16, int16, INT16, int16_t, 2)                                           \
4188   V(Uint32, uint32, UINT32, uint32_t, 4)                                       \
4189   V(Int32, int32, INT32, int32_t, 4)                                           \
4190   V(Float32, float32, FLOAT32, float, 4)                                       \
4191   V(Float64, float64, FLOAT64, double, 8)                                      \
4192   V(Uint8Clamped, uint8_clamped, UINT8_CLAMPED, uint8_t, 1)
4193
4194
4195 class FixedTypedArrayBase: public FixedArrayBase {
4196  public:
4197   // [base_pointer]: Either points to the FixedTypedArrayBase itself or nullptr.
4198   DECL_ACCESSORS(base_pointer, Object)
4199
4200   // [external_pointer]: Contains the offset between base_pointer and the start
4201   // of the data. If the base_pointer is a nullptr, the external_pointer
4202   // therefore points to the actual backing store.
4203   DECL_ACCESSORS(external_pointer, void)
4204
4205   // Dispatched behavior.
4206   inline void FixedTypedArrayBaseIterateBody(ObjectVisitor* v);
4207
4208   template <typename StaticVisitor>
4209   inline void FixedTypedArrayBaseIterateBody();
4210
4211   DECLARE_CAST(FixedTypedArrayBase)
4212
4213   static const int kBasePointerOffset = FixedArrayBase::kHeaderSize;
4214   static const int kExternalPointerOffset = kBasePointerOffset + kPointerSize;
4215   static const int kHeaderSize =
4216       DOUBLE_POINTER_ALIGN(kExternalPointerOffset + kPointerSize);
4217
4218   static const int kDataOffset = kHeaderSize;
4219
4220   inline int size();
4221
4222   static inline int TypedArraySize(InstanceType type, int length);
4223   inline int TypedArraySize(InstanceType type);
4224
4225   // Use with care: returns raw pointer into heap.
4226   inline void* DataPtr();
4227
4228   inline int DataSize();
4229
4230  private:
4231   static inline int ElementSize(InstanceType type);
4232
4233   inline int DataSize(InstanceType type);
4234
4235   DISALLOW_IMPLICIT_CONSTRUCTORS(FixedTypedArrayBase);
4236 };
4237
4238
4239 template <class Traits>
4240 class FixedTypedArray: public FixedTypedArrayBase {
4241  public:
4242   typedef typename Traits::ElementType ElementType;
4243   static const InstanceType kInstanceType = Traits::kInstanceType;
4244
4245   DECLARE_CAST(FixedTypedArray<Traits>)
4246
4247   inline ElementType get_scalar(int index);
4248   static inline Handle<Object> get(Handle<FixedTypedArray> array, int index);
4249   inline void set(int index, ElementType value);
4250
4251   static inline ElementType from_int(int value);
4252   static inline ElementType from_double(double value);
4253
4254   // This accessor applies the correct conversion from Smi, HeapNumber
4255   // and undefined.
4256   void SetValue(uint32_t index, Object* value);
4257
4258   DECLARE_PRINTER(FixedTypedArray)
4259   DECLARE_VERIFIER(FixedTypedArray)
4260
4261  private:
4262   DISALLOW_IMPLICIT_CONSTRUCTORS(FixedTypedArray);
4263 };
4264
4265 #define FIXED_TYPED_ARRAY_TRAITS(Type, type, TYPE, elementType, size)         \
4266   class Type##ArrayTraits {                                                   \
4267    public:   /* NOLINT */                                                     \
4268     typedef elementType ElementType;                                          \
4269     static const InstanceType kInstanceType = FIXED_##TYPE##_ARRAY_TYPE;      \
4270     static const char* Designator() { return #type " array"; }                \
4271     static inline Handle<Object> ToHandle(Isolate* isolate,                   \
4272                                           elementType scalar);                \
4273     static inline elementType defaultValue();                                 \
4274   };                                                                          \
4275                                                                               \
4276   typedef FixedTypedArray<Type##ArrayTraits> Fixed##Type##Array;
4277
4278 TYPED_ARRAYS(FIXED_TYPED_ARRAY_TRAITS)
4279
4280 #undef FIXED_TYPED_ARRAY_TRAITS
4281
4282
4283 // DeoptimizationInputData is a fixed array used to hold the deoptimization
4284 // data for code generated by the Hydrogen/Lithium compiler.  It also
4285 // contains information about functions that were inlined.  If N different
4286 // functions were inlined then first N elements of the literal array will
4287 // contain these functions.
4288 //
4289 // It can be empty.
4290 class DeoptimizationInputData: public FixedArray {
4291  public:
4292   // Layout description.  Indices in the array.
4293   static const int kTranslationByteArrayIndex = 0;
4294   static const int kInlinedFunctionCountIndex = 1;
4295   static const int kLiteralArrayIndex = 2;
4296   static const int kOsrAstIdIndex = 3;
4297   static const int kOsrPcOffsetIndex = 4;
4298   static const int kOptimizationIdIndex = 5;
4299   static const int kSharedFunctionInfoIndex = 6;
4300   static const int kWeakCellCacheIndex = 7;
4301   static const int kFirstDeoptEntryIndex = 8;
4302
4303   // Offsets of deopt entry elements relative to the start of the entry.
4304   static const int kAstIdRawOffset = 0;
4305   static const int kTranslationIndexOffset = 1;
4306   static const int kArgumentsStackHeightOffset = 2;
4307   static const int kPcOffset = 3;
4308   static const int kDeoptEntrySize = 4;
4309
4310   // Simple element accessors.
4311 #define DECLARE_ELEMENT_ACCESSORS(name, type) \
4312   inline type* name();                        \
4313   inline void Set##name(type* value);
4314
4315   DECLARE_ELEMENT_ACCESSORS(TranslationByteArray, ByteArray)
4316   DECLARE_ELEMENT_ACCESSORS(InlinedFunctionCount, Smi)
4317   DECLARE_ELEMENT_ACCESSORS(LiteralArray, FixedArray)
4318   DECLARE_ELEMENT_ACCESSORS(OsrAstId, Smi)
4319   DECLARE_ELEMENT_ACCESSORS(OsrPcOffset, Smi)
4320   DECLARE_ELEMENT_ACCESSORS(OptimizationId, Smi)
4321   DECLARE_ELEMENT_ACCESSORS(SharedFunctionInfo, Object)
4322   DECLARE_ELEMENT_ACCESSORS(WeakCellCache, Object)
4323
4324 #undef DECLARE_ELEMENT_ACCESSORS
4325
4326   // Accessors for elements of the ith deoptimization entry.
4327 #define DECLARE_ENTRY_ACCESSORS(name, type) \
4328   inline type* name(int i);                 \
4329   inline void Set##name(int i, type* value);
4330
4331   DECLARE_ENTRY_ACCESSORS(AstIdRaw, Smi)
4332   DECLARE_ENTRY_ACCESSORS(TranslationIndex, Smi)
4333   DECLARE_ENTRY_ACCESSORS(ArgumentsStackHeight, Smi)
4334   DECLARE_ENTRY_ACCESSORS(Pc, Smi)
4335
4336 #undef DECLARE_ENTRY_ACCESSORS
4337
4338   inline BailoutId AstId(int i);
4339
4340   inline void SetAstId(int i, BailoutId value);
4341
4342   inline int DeoptCount();
4343
4344   // Allocates a DeoptimizationInputData.
4345   static Handle<DeoptimizationInputData> New(Isolate* isolate,
4346                                              int deopt_entry_count,
4347                                              PretenureFlag pretenure);
4348
4349   DECLARE_CAST(DeoptimizationInputData)
4350
4351 #ifdef ENABLE_DISASSEMBLER
4352   void DeoptimizationInputDataPrint(std::ostream& os);  // NOLINT
4353 #endif
4354
4355  private:
4356   static int IndexForEntry(int i) {
4357     return kFirstDeoptEntryIndex + (i * kDeoptEntrySize);
4358   }
4359
4360
4361   static int LengthFor(int entry_count) { return IndexForEntry(entry_count); }
4362 };
4363
4364
4365 // DeoptimizationOutputData is a fixed array used to hold the deoptimization
4366 // data for code generated by the full compiler.
4367 // The format of the these objects is
4368 //   [i * 2]: Ast ID for ith deoptimization.
4369 //   [i * 2 + 1]: PC and state of ith deoptimization
4370 class DeoptimizationOutputData: public FixedArray {
4371  public:
4372   inline int DeoptPoints();
4373
4374   inline BailoutId AstId(int index);
4375
4376   inline void SetAstId(int index, BailoutId id);
4377
4378   inline Smi* PcAndState(int index);
4379   inline void SetPcAndState(int index, Smi* offset);
4380
4381   static int LengthOfFixedArray(int deopt_points) {
4382     return deopt_points * 2;
4383   }
4384
4385   // Allocates a DeoptimizationOutputData.
4386   static Handle<DeoptimizationOutputData> New(Isolate* isolate,
4387                                               int number_of_deopt_points,
4388                                               PretenureFlag pretenure);
4389
4390   DECLARE_CAST(DeoptimizationOutputData)
4391
4392 #if defined(OBJECT_PRINT) || defined(ENABLE_DISASSEMBLER)
4393   void DeoptimizationOutputDataPrint(std::ostream& os);  // NOLINT
4394 #endif
4395 };
4396
4397
4398 // HandlerTable is a fixed array containing entries for exception handlers in
4399 // the code object it is associated with. The tables comes in two flavors:
4400 // 1) Based on ranges: Used for unoptimized code. Contains one entry per
4401 //    exception handler and a range representing the try-block covered by that
4402 //    handler. Layout looks as follows:
4403 //      [ range-start , range-end , handler-offset , stack-depth ]
4404 // 2) Based on return addresses: Used for turbofanned code. Contains one entry
4405 //    per call-site that could throw an exception. Layout looks as follows:
4406 //      [ return-address-offset , handler-offset ]
4407 class HandlerTable : public FixedArray {
4408  public:
4409   // Conservative prediction whether a given handler will locally catch an
4410   // exception or cause a re-throw to outside the code boundary. Since this is
4411   // undecidable it is merely an approximation (e.g. useful for debugger).
4412   enum CatchPrediction { UNCAUGHT, CAUGHT };
4413
4414   // Accessors for handler table based on ranges.
4415   inline void SetRangeStart(int index, int value);
4416   inline void SetRangeEnd(int index, int value);
4417   inline void SetRangeHandler(int index, int offset, CatchPrediction pred);
4418   inline void SetRangeDepth(int index, int value);
4419
4420   // Accessors for handler table based on return addresses.
4421   inline void SetReturnOffset(int index, int value);
4422   inline void SetReturnHandler(int index, int offset, CatchPrediction pred);
4423
4424   // Lookup handler in a table based on ranges.
4425   int LookupRange(int pc_offset, int* stack_depth, CatchPrediction* prediction);
4426
4427   // Lookup handler in a table based on return addresses.
4428   int LookupReturn(int pc_offset, CatchPrediction* prediction);
4429
4430   // Returns the required length of the underlying fixed array.
4431   static int LengthForRange(int entries) { return entries * kRangeEntrySize; }
4432   static int LengthForReturn(int entries) { return entries * kReturnEntrySize; }
4433
4434   DECLARE_CAST(HandlerTable)
4435
4436 #if defined(OBJECT_PRINT) || defined(ENABLE_DISASSEMBLER)
4437   void HandlerTableRangePrint(std::ostream& os);   // NOLINT
4438   void HandlerTableReturnPrint(std::ostream& os);  // NOLINT
4439 #endif
4440
4441  private:
4442   // Layout description for handler table based on ranges.
4443   static const int kRangeStartIndex = 0;
4444   static const int kRangeEndIndex = 1;
4445   static const int kRangeHandlerIndex = 2;
4446   static const int kRangeDepthIndex = 3;
4447   static const int kRangeEntrySize = 4;
4448
4449   // Layout description for handler table based on return addresses.
4450   static const int kReturnOffsetIndex = 0;
4451   static const int kReturnHandlerIndex = 1;
4452   static const int kReturnEntrySize = 2;
4453
4454   // Encoding of the {handler} field.
4455   class HandlerPredictionField : public BitField<CatchPrediction, 0, 1> {};
4456   class HandlerOffsetField : public BitField<int, 1, 30> {};
4457 };
4458
4459
4460 // Code describes objects with on-the-fly generated machine code.
4461 class Code: public HeapObject {
4462  public:
4463   // Opaque data type for encapsulating code flags like kind, inline
4464   // cache state, and arguments count.
4465   typedef uint32_t Flags;
4466
4467 #define NON_IC_KIND_LIST(V) \
4468   V(FUNCTION)               \
4469   V(OPTIMIZED_FUNCTION)     \
4470   V(STUB)                   \
4471   V(HANDLER)                \
4472   V(BUILTIN)                \
4473   V(REGEXP)                 \
4474   V(PLACEHOLDER)
4475
4476 #define IC_KIND_LIST(V) \
4477   V(LOAD_IC)            \
4478   V(KEYED_LOAD_IC)      \
4479   V(CALL_IC)            \
4480   V(STORE_IC)           \
4481   V(KEYED_STORE_IC)     \
4482   V(BINARY_OP_IC)       \
4483   V(COMPARE_IC)         \
4484   V(COMPARE_NIL_IC)     \
4485   V(TO_BOOLEAN_IC)
4486
4487 #define CODE_KIND_LIST(V) \
4488   NON_IC_KIND_LIST(V)     \
4489   IC_KIND_LIST(V)
4490
4491   enum Kind {
4492 #define DEFINE_CODE_KIND_ENUM(name) name,
4493     CODE_KIND_LIST(DEFINE_CODE_KIND_ENUM)
4494 #undef DEFINE_CODE_KIND_ENUM
4495     NUMBER_OF_KINDS
4496   };
4497
4498   // No more than 16 kinds. The value is currently encoded in four bits in
4499   // Flags.
4500   STATIC_ASSERT(NUMBER_OF_KINDS <= 16);
4501
4502   static const char* Kind2String(Kind kind);
4503
4504   // Types of stubs.
4505   enum StubType {
4506     NORMAL,
4507     FAST
4508   };
4509
4510   static const int kPrologueOffsetNotSet = -1;
4511
4512 #ifdef ENABLE_DISASSEMBLER
4513   // Printing
4514   static const char* ICState2String(InlineCacheState state);
4515   static const char* StubType2String(StubType type);
4516   static void PrintExtraICState(std::ostream& os,  // NOLINT
4517                                 Kind kind, ExtraICState extra);
4518   void Disassemble(const char* name, std::ostream& os);  // NOLINT
4519 #endif  // ENABLE_DISASSEMBLER
4520
4521   // [instruction_size]: Size of the native instructions
4522   inline int instruction_size() const;
4523   inline void set_instruction_size(int value);
4524
4525   // [relocation_info]: Code relocation information
4526   DECL_ACCESSORS(relocation_info, ByteArray)
4527   void InvalidateRelocation();
4528   void InvalidateEmbeddedObjects();
4529
4530   // [handler_table]: Fixed array containing offsets of exception handlers.
4531   DECL_ACCESSORS(handler_table, FixedArray)
4532
4533   // [deoptimization_data]: Array containing data for deopt.
4534   DECL_ACCESSORS(deoptimization_data, FixedArray)
4535
4536   // [raw_type_feedback_info]: This field stores various things, depending on
4537   // the kind of the code object.
4538   //   FUNCTION           => type feedback information.
4539   //   STUB and ICs       => major/minor key as Smi.
4540   DECL_ACCESSORS(raw_type_feedback_info, Object)
4541   inline Object* type_feedback_info();
4542   inline void set_type_feedback_info(
4543       Object* value, WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
4544   inline uint32_t stub_key();
4545   inline void set_stub_key(uint32_t key);
4546
4547   // [next_code_link]: Link for lists of optimized or deoptimized code.
4548   // Note that storage for this field is overlapped with typefeedback_info.
4549   DECL_ACCESSORS(next_code_link, Object)
4550
4551   // [gc_metadata]: Field used to hold GC related metadata. The contents of this
4552   // field does not have to be traced during garbage collection since
4553   // it is only used by the garbage collector itself.
4554   DECL_ACCESSORS(gc_metadata, Object)
4555
4556   // [ic_age]: Inline caching age: the value of the Heap::global_ic_age
4557   // at the moment when this object was created.
4558   inline void set_ic_age(int count);
4559   inline int ic_age() const;
4560
4561   // [prologue_offset]: Offset of the function prologue, used for aging
4562   // FUNCTIONs and OPTIMIZED_FUNCTIONs.
4563   inline int prologue_offset() const;
4564   inline void set_prologue_offset(int offset);
4565
4566   // [constant_pool offset]: Offset of the constant pool.
4567   // Valid for FLAG_enable_embedded_constant_pool only
4568   inline int constant_pool_offset() const;
4569   inline void set_constant_pool_offset(int offset);
4570
4571   // Unchecked accessors to be used during GC.
4572   inline ByteArray* unchecked_relocation_info();
4573
4574   inline int relocation_size();
4575
4576   // [flags]: Various code flags.
4577   inline Flags flags();
4578   inline void set_flags(Flags flags);
4579
4580   // [flags]: Access to specific code flags.
4581   inline Kind kind();
4582   inline InlineCacheState ic_state();  // Only valid for IC stubs.
4583   inline ExtraICState extra_ic_state();  // Only valid for IC stubs.
4584
4585   inline StubType type();  // Only valid for monomorphic IC stubs.
4586
4587   // Testers for IC stub kinds.
4588   inline bool is_inline_cache_stub();
4589   inline bool is_debug_stub();
4590   inline bool is_handler();
4591   inline bool is_load_stub();
4592   inline bool is_keyed_load_stub();
4593   inline bool is_store_stub();
4594   inline bool is_keyed_store_stub();
4595   inline bool is_call_stub();
4596   inline bool is_binary_op_stub();
4597   inline bool is_compare_ic_stub();
4598   inline bool is_compare_nil_ic_stub();
4599   inline bool is_to_boolean_ic_stub();
4600   inline bool is_keyed_stub();
4601   inline bool is_optimized_code();
4602   inline bool embeds_maps_weakly();
4603
4604   inline bool IsCodeStubOrIC();
4605   inline bool IsJavaScriptCode();
4606
4607   inline void set_raw_kind_specific_flags1(int value);
4608   inline void set_raw_kind_specific_flags2(int value);
4609
4610   // [is_crankshafted]: For kind STUB or ICs, tells whether or not a code
4611   // object was generated by either the hydrogen or the TurboFan optimizing
4612   // compiler (but it may not be an optimized function).
4613   inline bool is_crankshafted();
4614   inline bool is_hydrogen_stub();  // Crankshafted, but not a function.
4615   inline void set_is_crankshafted(bool value);
4616
4617   // [is_turbofanned]: For kind STUB or OPTIMIZED_FUNCTION, tells whether the
4618   // code object was generated by the TurboFan optimizing compiler.
4619   inline bool is_turbofanned();
4620   inline void set_is_turbofanned(bool value);
4621
4622   // [can_have_weak_objects]: For kind OPTIMIZED_FUNCTION, tells whether the
4623   // embedded objects in code should be treated weakly.
4624   inline bool can_have_weak_objects();
4625   inline void set_can_have_weak_objects(bool value);
4626
4627   // [has_deoptimization_support]: For FUNCTION kind, tells if it has
4628   // deoptimization support.
4629   inline bool has_deoptimization_support();
4630   inline void set_has_deoptimization_support(bool value);
4631
4632   // [has_debug_break_slots]: For FUNCTION kind, tells if it has
4633   // been compiled with debug break slots.
4634   inline bool has_debug_break_slots();
4635   inline void set_has_debug_break_slots(bool value);
4636
4637   // [has_reloc_info_for_serialization]: For FUNCTION kind, tells if its
4638   // reloc info includes runtime and external references to support
4639   // serialization/deserialization.
4640   inline bool has_reloc_info_for_serialization();
4641   inline void set_has_reloc_info_for_serialization(bool value);
4642
4643   // [allow_osr_at_loop_nesting_level]: For FUNCTION kind, tells for
4644   // how long the function has been marked for OSR and therefore which
4645   // level of loop nesting we are willing to do on-stack replacement
4646   // for.
4647   inline void set_allow_osr_at_loop_nesting_level(int level);
4648   inline int allow_osr_at_loop_nesting_level();
4649
4650   // [profiler_ticks]: For FUNCTION kind, tells for how many profiler ticks
4651   // the code object was seen on the stack with no IC patching going on.
4652   inline int profiler_ticks();
4653   inline void set_profiler_ticks(int ticks);
4654
4655   // [builtin_index]: For BUILTIN kind, tells which builtin index it has.
4656   // For builtins, tells which builtin index it has.
4657   // Note that builtins can have a code kind other than BUILTIN, which means
4658   // that for arbitrary code objects, this index value may be random garbage.
4659   // To verify in that case, compare the code object to the indexed builtin.
4660   inline int builtin_index();
4661   inline void set_builtin_index(int id);
4662
4663   // [stack_slots]: For kind OPTIMIZED_FUNCTION, the number of stack slots
4664   // reserved in the code prologue.
4665   inline unsigned stack_slots();
4666   inline void set_stack_slots(unsigned slots);
4667
4668   // [safepoint_table_start]: For kind OPTIMIZED_FUNCTION, the offset in
4669   // the instruction stream where the safepoint table starts.
4670   inline unsigned safepoint_table_offset();
4671   inline void set_safepoint_table_offset(unsigned offset);
4672
4673   // [back_edge_table_start]: For kind FUNCTION, the offset in the
4674   // instruction stream where the back edge table starts.
4675   inline unsigned back_edge_table_offset();
4676   inline void set_back_edge_table_offset(unsigned offset);
4677
4678   inline bool back_edges_patched_for_osr();
4679
4680   // [to_boolean_foo]: For kind TO_BOOLEAN_IC tells what state the stub is in.
4681   inline uint16_t to_boolean_state();
4682
4683   // [has_function_cache]: For kind STUB tells whether there is a function
4684   // cache is passed to the stub.
4685   inline bool has_function_cache();
4686   inline void set_has_function_cache(bool flag);
4687
4688
4689   // [marked_for_deoptimization]: For kind OPTIMIZED_FUNCTION tells whether
4690   // the code is going to be deoptimized because of dead embedded maps.
4691   inline bool marked_for_deoptimization();
4692   inline void set_marked_for_deoptimization(bool flag);
4693
4694   // [constant_pool]: The constant pool for this function.
4695   inline Address constant_pool();
4696
4697   // Get the safepoint entry for the given pc.
4698   SafepointEntry GetSafepointEntry(Address pc);
4699
4700   // Find an object in a stub with a specified map
4701   Object* FindNthObject(int n, Map* match_map);
4702
4703   // Find the first allocation site in an IC stub.
4704   AllocationSite* FindFirstAllocationSite();
4705
4706   // Find the first map in an IC stub.
4707   Map* FindFirstMap();
4708   void FindAllMaps(MapHandleList* maps);
4709
4710   // Find the first handler in an IC stub.
4711   Code* FindFirstHandler();
4712
4713   // Find |length| handlers and put them into |code_list|. Returns false if not
4714   // enough handlers can be found.
4715   bool FindHandlers(CodeHandleList* code_list, int length = -1);
4716
4717   // Find the handler for |map|.
4718   MaybeHandle<Code> FindHandlerForMap(Map* map);
4719
4720   // Find the first name in an IC stub.
4721   Name* FindFirstName();
4722
4723   class FindAndReplacePattern;
4724   // For each (map-to-find, object-to-replace) pair in the pattern, this
4725   // function replaces the corresponding placeholder in the code with the
4726   // object-to-replace. The function assumes that pairs in the pattern come in
4727   // the same order as the placeholders in the code.
4728   // If the placeholder is a weak cell, then the value of weak cell is matched
4729   // against the map-to-find.
4730   void FindAndReplace(const FindAndReplacePattern& pattern);
4731
4732   // The entire code object including its header is copied verbatim to the
4733   // snapshot so that it can be written in one, fast, memcpy during
4734   // deserialization. The deserializer will overwrite some pointers, rather
4735   // like a runtime linker, but the random allocation addresses used in the
4736   // mksnapshot process would still be present in the unlinked snapshot data,
4737   // which would make snapshot production non-reproducible. This method wipes
4738   // out the to-be-overwritten header data for reproducible snapshots.
4739   inline void WipeOutHeader();
4740
4741   // Flags operations.
4742   static inline Flags ComputeFlags(
4743       Kind kind, InlineCacheState ic_state = UNINITIALIZED,
4744       ExtraICState extra_ic_state = kNoExtraICState, StubType type = NORMAL,
4745       CacheHolderFlag holder = kCacheOnReceiver);
4746
4747   static inline Flags ComputeMonomorphicFlags(
4748       Kind kind, ExtraICState extra_ic_state = kNoExtraICState,
4749       CacheHolderFlag holder = kCacheOnReceiver, StubType type = NORMAL);
4750
4751   static inline Flags ComputeHandlerFlags(
4752       Kind handler_kind, StubType type = NORMAL,
4753       CacheHolderFlag holder = kCacheOnReceiver);
4754
4755   static inline InlineCacheState ExtractICStateFromFlags(Flags flags);
4756   static inline StubType ExtractTypeFromFlags(Flags flags);
4757   static inline CacheHolderFlag ExtractCacheHolderFromFlags(Flags flags);
4758   static inline Kind ExtractKindFromFlags(Flags flags);
4759   static inline ExtraICState ExtractExtraICStateFromFlags(Flags flags);
4760
4761   static inline Flags RemoveTypeFromFlags(Flags flags);
4762   static inline Flags RemoveTypeAndHolderFromFlags(Flags flags);
4763
4764   // Convert a target address into a code object.
4765   static inline Code* GetCodeFromTargetAddress(Address address);
4766
4767   // Convert an entry address into an object.
4768   static inline Object* GetObjectFromEntryAddress(Address location_of_address);
4769
4770   // Returns the address of the first instruction.
4771   inline byte* instruction_start();
4772
4773   // Returns the address right after the last instruction.
4774   inline byte* instruction_end();
4775
4776   // Returns the size of the instructions, padding, and relocation information.
4777   inline int body_size();
4778
4779   // Returns the address of the first relocation info (read backwards!).
4780   inline byte* relocation_start();
4781
4782   // Code entry point.
4783   inline byte* entry();
4784
4785   // Returns true if pc is inside this object's instructions.
4786   inline bool contains(byte* pc);
4787
4788   // Relocate the code by delta bytes. Called to signal that this code
4789   // object has been moved by delta bytes.
4790   void Relocate(intptr_t delta);
4791
4792   // Migrate code described by desc.
4793   void CopyFrom(const CodeDesc& desc);
4794
4795   // Returns the object size for a given body (used for allocation).
4796   static int SizeFor(int body_size) {
4797     DCHECK_SIZE_TAG_ALIGNED(body_size);
4798     return RoundUp(kHeaderSize + body_size, kCodeAlignment);
4799   }
4800
4801   // Calculate the size of the code object to report for log events. This takes
4802   // the layout of the code object into account.
4803   inline int ExecutableSize();
4804
4805   // Locating source position.
4806   int SourcePosition(Address pc);
4807   int SourceStatementPosition(Address pc);
4808
4809   DECLARE_CAST(Code)
4810
4811   // Dispatched behavior.
4812   inline int CodeSize();
4813   inline void CodeIterateBody(ObjectVisitor* v);
4814
4815   template<typename StaticVisitor>
4816   inline void CodeIterateBody(Heap* heap);
4817
4818   DECLARE_PRINTER(Code)
4819   DECLARE_VERIFIER(Code)
4820
4821   void ClearInlineCaches();
4822   void ClearInlineCaches(Kind kind);
4823
4824   BailoutId TranslatePcOffsetToAstId(uint32_t pc_offset);
4825   uint32_t TranslateAstIdToPcOffset(BailoutId ast_id);
4826
4827 #define DECLARE_CODE_AGE_ENUM(X) k##X##CodeAge,
4828   enum Age {
4829     kToBeExecutedOnceCodeAge = -3,
4830     kNotExecutedCodeAge = -2,
4831     kExecutedOnceCodeAge = -1,
4832     kNoAgeCodeAge = 0,
4833     CODE_AGE_LIST(DECLARE_CODE_AGE_ENUM)
4834     kAfterLastCodeAge,
4835     kFirstCodeAge = kToBeExecutedOnceCodeAge,
4836     kLastCodeAge = kAfterLastCodeAge - 1,
4837     kCodeAgeCount = kAfterLastCodeAge - kFirstCodeAge - 1,
4838     kIsOldCodeAge = kSexagenarianCodeAge,
4839     kPreAgedCodeAge = kIsOldCodeAge - 1
4840   };
4841 #undef DECLARE_CODE_AGE_ENUM
4842
4843   // Code aging.  Indicates how many full GCs this code has survived without
4844   // being entered through the prologue.  Used to determine when it is
4845   // relatively safe to flush this code object and replace it with the lazy
4846   // compilation stub.
4847   static void MakeCodeAgeSequenceYoung(byte* sequence, Isolate* isolate);
4848   static void MarkCodeAsExecuted(byte* sequence, Isolate* isolate);
4849   void MakeYoung(Isolate* isolate);
4850   void MarkToBeExecutedOnce(Isolate* isolate);
4851   void MakeOlder(MarkingParity);
4852   static bool IsYoungSequence(Isolate* isolate, byte* sequence);
4853   bool IsOld();
4854   Age GetAge();
4855   static inline Code* GetPreAgedCodeAgeStub(Isolate* isolate) {
4856     return GetCodeAgeStub(isolate, kNotExecutedCodeAge, NO_MARKING_PARITY);
4857   }
4858
4859   void PrintDeoptLocation(FILE* out, Address pc);
4860   bool CanDeoptAt(Address pc);
4861
4862 #ifdef VERIFY_HEAP
4863   void VerifyEmbeddedObjectsDependency();
4864 #endif
4865
4866 #ifdef DEBUG
4867   enum VerifyMode { kNoContextSpecificPointers, kNoContextRetainingPointers };
4868   void VerifyEmbeddedObjects(VerifyMode mode = kNoContextRetainingPointers);
4869   static void VerifyRecompiledCode(Code* old_code, Code* new_code);
4870 #endif  // DEBUG
4871
4872   inline bool CanContainWeakObjects();
4873
4874   inline bool IsWeakObject(Object* object);
4875
4876   static inline bool IsWeakObjectInOptimizedCode(Object* object);
4877
4878   static Handle<WeakCell> WeakCellFor(Handle<Code> code);
4879   WeakCell* CachedWeakCell();
4880
4881   // Max loop nesting marker used to postpose OSR. We don't take loop
4882   // nesting that is deeper than 5 levels into account.
4883   static const int kMaxLoopNestingMarker = 6;
4884
4885   static const int kConstantPoolSize =
4886       FLAG_enable_embedded_constant_pool ? kIntSize : 0;
4887
4888   // Layout description.
4889   static const int kRelocationInfoOffset = HeapObject::kHeaderSize;
4890   static const int kHandlerTableOffset = kRelocationInfoOffset + kPointerSize;
4891   static const int kDeoptimizationDataOffset =
4892       kHandlerTableOffset + kPointerSize;
4893   // For FUNCTION kind, we store the type feedback info here.
4894   static const int kTypeFeedbackInfoOffset =
4895       kDeoptimizationDataOffset + kPointerSize;
4896   static const int kNextCodeLinkOffset = kTypeFeedbackInfoOffset + kPointerSize;
4897   static const int kGCMetadataOffset = kNextCodeLinkOffset + kPointerSize;
4898   static const int kInstructionSizeOffset = kGCMetadataOffset + kPointerSize;
4899   static const int kICAgeOffset = kInstructionSizeOffset + kIntSize;
4900   static const int kFlagsOffset = kICAgeOffset + kIntSize;
4901   static const int kKindSpecificFlags1Offset = kFlagsOffset + kIntSize;
4902   static const int kKindSpecificFlags2Offset =
4903       kKindSpecificFlags1Offset + kIntSize;
4904   // Note: We might be able to squeeze this into the flags above.
4905   static const int kPrologueOffset = kKindSpecificFlags2Offset + kIntSize;
4906   static const int kConstantPoolOffset = kPrologueOffset + kIntSize;
4907   static const int kHeaderPaddingStart =
4908       kConstantPoolOffset + kConstantPoolSize;
4909
4910   // Add padding to align the instruction start following right after
4911   // the Code object header.
4912   static const int kHeaderSize =
4913       (kHeaderPaddingStart + kCodeAlignmentMask) & ~kCodeAlignmentMask;
4914
4915   // Byte offsets within kKindSpecificFlags1Offset.
4916   static const int kFullCodeFlags = kKindSpecificFlags1Offset;
4917   class FullCodeFlagsHasDeoptimizationSupportField:
4918       public BitField<bool, 0, 1> {};  // NOLINT
4919   class FullCodeFlagsHasDebugBreakSlotsField: public BitField<bool, 1, 1> {};
4920   class FullCodeFlagsHasRelocInfoForSerialization
4921       : public BitField<bool, 2, 1> {};
4922   // Bit 3 in this bitfield is unused.
4923   class ProfilerTicksField : public BitField<int, 4, 28> {};
4924
4925   // Flags layout.  BitField<type, shift, size>.
4926   class ICStateField : public BitField<InlineCacheState, 0, 4> {};
4927   class TypeField : public BitField<StubType, 4, 1> {};
4928   class CacheHolderField : public BitField<CacheHolderFlag, 5, 2> {};
4929   class KindField : public BitField<Kind, 7, 4> {};
4930   class ExtraICStateField: public BitField<ExtraICState, 11,
4931       PlatformSmiTagging::kSmiValueSize - 11 + 1> {};  // NOLINT
4932
4933   // KindSpecificFlags1 layout (STUB and OPTIMIZED_FUNCTION)
4934   static const int kStackSlotsFirstBit = 0;
4935   static const int kStackSlotsBitCount = 24;
4936   static const int kHasFunctionCacheBit =
4937       kStackSlotsFirstBit + kStackSlotsBitCount;
4938   static const int kMarkedForDeoptimizationBit = kHasFunctionCacheBit + 1;
4939   static const int kIsTurbofannedBit = kMarkedForDeoptimizationBit + 1;
4940   static const int kCanHaveWeakObjects = kIsTurbofannedBit + 1;
4941
4942   STATIC_ASSERT(kStackSlotsFirstBit + kStackSlotsBitCount <= 32);
4943   STATIC_ASSERT(kCanHaveWeakObjects + 1 <= 32);
4944
4945   class StackSlotsField: public BitField<int,
4946       kStackSlotsFirstBit, kStackSlotsBitCount> {};  // NOLINT
4947   class HasFunctionCacheField : public BitField<bool, kHasFunctionCacheBit, 1> {
4948   };  // NOLINT
4949   class MarkedForDeoptimizationField
4950       : public BitField<bool, kMarkedForDeoptimizationBit, 1> {};   // NOLINT
4951   class IsTurbofannedField : public BitField<bool, kIsTurbofannedBit, 1> {
4952   };  // NOLINT
4953   class CanHaveWeakObjectsField
4954       : public BitField<bool, kCanHaveWeakObjects, 1> {};  // NOLINT
4955
4956   // KindSpecificFlags2 layout (ALL)
4957   static const int kIsCrankshaftedBit = 0;
4958   class IsCrankshaftedField: public BitField<bool,
4959       kIsCrankshaftedBit, 1> {};  // NOLINT
4960
4961   // KindSpecificFlags2 layout (STUB and OPTIMIZED_FUNCTION)
4962   static const int kSafepointTableOffsetFirstBit = kIsCrankshaftedBit + 1;
4963   static const int kSafepointTableOffsetBitCount = 30;
4964
4965   STATIC_ASSERT(kSafepointTableOffsetFirstBit +
4966                 kSafepointTableOffsetBitCount <= 32);
4967   STATIC_ASSERT(1 + kSafepointTableOffsetBitCount <= 32);
4968
4969   class SafepointTableOffsetField: public BitField<int,
4970       kSafepointTableOffsetFirstBit,
4971       kSafepointTableOffsetBitCount> {};  // NOLINT
4972
4973   // KindSpecificFlags2 layout (FUNCTION)
4974   class BackEdgeTableOffsetField: public BitField<int,
4975       kIsCrankshaftedBit + 1, 27> {};  // NOLINT
4976   class AllowOSRAtLoopNestingLevelField: public BitField<int,
4977       kIsCrankshaftedBit + 1 + 27, 4> {};  // NOLINT
4978   STATIC_ASSERT(AllowOSRAtLoopNestingLevelField::kMax >= kMaxLoopNestingMarker);
4979
4980   static const int kArgumentsBits = 16;
4981   static const int kMaxArguments = (1 << kArgumentsBits) - 1;
4982
4983   // This constant should be encodable in an ARM instruction.
4984   static const int kFlagsNotUsedInLookup =
4985       TypeField::kMask | CacheHolderField::kMask;
4986
4987  private:
4988   friend class RelocIterator;
4989   friend class Deoptimizer;  // For FindCodeAgeSequence.
4990
4991   void ClearInlineCaches(Kind* kind);
4992
4993   // Code aging
4994   byte* FindCodeAgeSequence();
4995   static void GetCodeAgeAndParity(Code* code, Age* age,
4996                                   MarkingParity* parity);
4997   static void GetCodeAgeAndParity(Isolate* isolate, byte* sequence, Age* age,
4998                                   MarkingParity* parity);
4999   static Code* GetCodeAgeStub(Isolate* isolate, Age age, MarkingParity parity);
5000
5001   // Code aging -- platform-specific
5002   static void PatchPlatformCodeAge(Isolate* isolate,
5003                                    byte* sequence, Age age,
5004                                    MarkingParity parity);
5005
5006   DISALLOW_IMPLICIT_CONSTRUCTORS(Code);
5007 };
5008
5009
5010 // This class describes the layout of dependent codes array of a map. The
5011 // array is partitioned into several groups of dependent codes. Each group
5012 // contains codes with the same dependency on the map. The array has the
5013 // following layout for n dependency groups:
5014 //
5015 // +----+----+-----+----+---------+----------+-----+---------+-----------+
5016 // | C1 | C2 | ... | Cn | group 1 |  group 2 | ... | group n | undefined |
5017 // +----+----+-----+----+---------+----------+-----+---------+-----------+
5018 //
5019 // The first n elements are Smis, each of them specifies the number of codes
5020 // in the corresponding group. The subsequent elements contain grouped code
5021 // objects in weak cells. The suffix of the array can be filled with the
5022 // undefined value if the number of codes is less than the length of the
5023 // array. The order of the code objects within a group is not preserved.
5024 //
5025 // All code indexes used in the class are counted starting from the first
5026 // code object of the first group. In other words, code index 0 corresponds
5027 // to array index n = kCodesStartIndex.
5028
5029 class DependentCode: public FixedArray {
5030  public:
5031   enum DependencyGroup {
5032     // Group of code that weakly embed this map and depend on being
5033     // deoptimized when the map is garbage collected.
5034     kWeakCodeGroup,
5035     // Group of code that embed a transition to this map, and depend on being
5036     // deoptimized when the transition is replaced by a new version.
5037     kTransitionGroup,
5038     // Group of code that omit run-time prototype checks for prototypes
5039     // described by this map. The group is deoptimized whenever an object
5040     // described by this map changes shape (and transitions to a new map),
5041     // possibly invalidating the assumptions embedded in the code.
5042     kPrototypeCheckGroup,
5043     // Group of code that depends on global property values in property cells
5044     // not being changed.
5045     kPropertyCellChangedGroup,
5046     // Group of code that omit run-time type checks for the field(s) introduced
5047     // by this map.
5048     kFieldTypeGroup,
5049     // Group of code that omit run-time type checks for initial maps of
5050     // constructors.
5051     kInitialMapChangedGroup,
5052     // Group of code that depends on tenuring information in AllocationSites
5053     // not being changed.
5054     kAllocationSiteTenuringChangedGroup,
5055     // Group of code that depends on element transition information in
5056     // AllocationSites not being changed.
5057     kAllocationSiteTransitionChangedGroup
5058   };
5059
5060   static const int kGroupCount = kAllocationSiteTransitionChangedGroup + 1;
5061
5062   // Array for holding the index of the first code object of each group.
5063   // The last element stores the total number of code objects.
5064   class GroupStartIndexes {
5065    public:
5066     explicit GroupStartIndexes(DependentCode* entries);
5067     void Recompute(DependentCode* entries);
5068     int at(int i) { return start_indexes_[i]; }
5069     int number_of_entries() { return start_indexes_[kGroupCount]; }
5070    private:
5071     int start_indexes_[kGroupCount + 1];
5072   };
5073
5074   bool Contains(DependencyGroup group, WeakCell* code_cell);
5075
5076   static Handle<DependentCode> InsertCompilationDependencies(
5077       Handle<DependentCode> entries, DependencyGroup group,
5078       Handle<Foreign> info);
5079
5080   static Handle<DependentCode> InsertWeakCode(Handle<DependentCode> entries,
5081                                               DependencyGroup group,
5082                                               Handle<WeakCell> code_cell);
5083
5084   void UpdateToFinishedCode(DependencyGroup group, Foreign* info,
5085                             WeakCell* code_cell);
5086
5087   void RemoveCompilationDependencies(DependentCode::DependencyGroup group,
5088                                      Foreign* info);
5089
5090   void DeoptimizeDependentCodeGroup(Isolate* isolate,
5091                                     DependentCode::DependencyGroup group);
5092
5093   bool MarkCodeForDeoptimization(Isolate* isolate,
5094                                  DependentCode::DependencyGroup group);
5095
5096   // The following low-level accessors should only be used by this class
5097   // and the mark compact collector.
5098   inline int number_of_entries(DependencyGroup group);
5099   inline void set_number_of_entries(DependencyGroup group, int value);
5100   inline Object* object_at(int i);
5101   inline void set_object_at(int i, Object* object);
5102   inline void clear_at(int i);
5103   inline void copy(int from, int to);
5104   DECLARE_CAST(DependentCode)
5105
5106   static const char* DependencyGroupName(DependencyGroup group);
5107   static void SetMarkedForDeoptimization(Code* code, DependencyGroup group);
5108
5109  private:
5110   static Handle<DependentCode> Insert(Handle<DependentCode> entries,
5111                                       DependencyGroup group,
5112                                       Handle<Object> object);
5113   static Handle<DependentCode> EnsureSpace(Handle<DependentCode> entries);
5114   // Make a room at the end of the given group by moving out the first
5115   // code objects of the subsequent groups.
5116   inline void ExtendGroup(DependencyGroup group);
5117   // Compact by removing cleared weak cells and return true if there was
5118   // any cleared weak cell.
5119   bool Compact();
5120   static int Grow(int number_of_entries) {
5121     if (number_of_entries < 5) return number_of_entries + 1;
5122     return number_of_entries * 5 / 4;
5123   }
5124   static const int kCodesStartIndex = kGroupCount;
5125 };
5126
5127
5128 class PrototypeInfo;
5129
5130
5131 // All heap objects have a Map that describes their structure.
5132 //  A Map contains information about:
5133 //  - Size information about the object
5134 //  - How to iterate over an object (for garbage collection)
5135 class Map: public HeapObject {
5136  public:
5137   // Instance size.
5138   // Size in bytes or kVariableSizeSentinel if instances do not have
5139   // a fixed size.
5140   inline int instance_size();
5141   inline void set_instance_size(int value);
5142
5143   // Only to clear an unused byte, remove once byte is used.
5144   inline void clear_unused();
5145
5146   // [inobject_properties_or_constructor_function_index]: Provides access
5147   // to the inobject properties in case of JSObject maps, or the constructor
5148   // function index in case of primitive maps.
5149   inline int inobject_properties_or_constructor_function_index();
5150   inline void set_inobject_properties_or_constructor_function_index(int value);
5151   // Count of properties allocated in the object (JSObject only).
5152   inline int GetInObjectProperties();
5153   inline void SetInObjectProperties(int value);
5154   // Index of the constructor function in the native context (primitives only),
5155   // or the special sentinel value to indicate that there is no object wrapper
5156   // for the primitive (i.e. in case of null or undefined).
5157   static const int kNoConstructorFunctionIndex = 0;
5158   inline int GetConstructorFunctionIndex();
5159   inline void SetConstructorFunctionIndex(int value);
5160
5161   // Instance type.
5162   inline InstanceType instance_type();
5163   inline void set_instance_type(InstanceType value);
5164
5165   // Tells how many unused property fields are available in the
5166   // instance (only used for JSObject in fast mode).
5167   inline int unused_property_fields();
5168   inline void set_unused_property_fields(int value);
5169
5170   // Bit field.
5171   inline byte bit_field() const;
5172   inline void set_bit_field(byte value);
5173
5174   // Bit field 2.
5175   inline byte bit_field2() const;
5176   inline void set_bit_field2(byte value);
5177
5178   // Bit field 3.
5179   inline uint32_t bit_field3() const;
5180   inline void set_bit_field3(uint32_t bits);
5181
5182   class EnumLengthBits:             public BitField<int,
5183       0, kDescriptorIndexBitCount> {};  // NOLINT
5184   class NumberOfOwnDescriptorsBits: public BitField<int,
5185       kDescriptorIndexBitCount, kDescriptorIndexBitCount> {};  // NOLINT
5186   STATIC_ASSERT(kDescriptorIndexBitCount + kDescriptorIndexBitCount == 20);
5187   class DictionaryMap : public BitField<bool, 20, 1> {};
5188   class OwnsDescriptors : public BitField<bool, 21, 1> {};
5189   class HasInstanceCallHandler : public BitField<bool, 22, 1> {};
5190   class Deprecated : public BitField<bool, 23, 1> {};
5191   class IsUnstable : public BitField<bool, 24, 1> {};
5192   class IsMigrationTarget : public BitField<bool, 25, 1> {};
5193   class IsStrong : public BitField<bool, 26, 1> {};
5194   // Bit 27 is free.
5195
5196   // Keep this bit field at the very end for better code in
5197   // Builtins::kJSConstructStubGeneric stub.
5198   // This counter is used for in-object slack tracking and for map aging.
5199   // The in-object slack tracking is considered enabled when the counter is
5200   // in the range [kSlackTrackingCounterStart, kSlackTrackingCounterEnd].
5201   class Counter : public BitField<int, 28, 4> {};
5202   static const int kSlackTrackingCounterStart = 14;
5203   static const int kSlackTrackingCounterEnd = 8;
5204   static const int kRetainingCounterStart = kSlackTrackingCounterEnd - 1;
5205   static const int kRetainingCounterEnd = 0;
5206
5207   // Tells whether the object in the prototype property will be used
5208   // for instances created from this function.  If the prototype
5209   // property is set to a value that is not a JSObject, the prototype
5210   // property will not be used to create instances of the function.
5211   // See ECMA-262, 13.2.2.
5212   inline void set_non_instance_prototype(bool value);
5213   inline bool has_non_instance_prototype();
5214
5215   // Tells whether function has special prototype property. If not, prototype
5216   // property will not be created when accessed (will return undefined),
5217   // and construction from this function will not be allowed.
5218   inline void set_function_with_prototype(bool value);
5219   inline bool function_with_prototype();
5220
5221   // Tells whether the instance with this map should be ignored by the
5222   // Object.getPrototypeOf() function and the __proto__ accessor.
5223   inline void set_is_hidden_prototype();
5224   inline bool is_hidden_prototype();
5225
5226   // Records and queries whether the instance has a named interceptor.
5227   inline void set_has_named_interceptor();
5228   inline bool has_named_interceptor();
5229
5230   // Records and queries whether the instance has an indexed interceptor.
5231   inline void set_has_indexed_interceptor();
5232   inline bool has_indexed_interceptor();
5233
5234   // Tells whether the instance is undetectable.
5235   // An undetectable object is a special class of JSObject: 'typeof' operator
5236   // returns undefined, ToBoolean returns false. Otherwise it behaves like
5237   // a normal JS object.  It is useful for implementing undetectable
5238   // document.all in Firefox & Safari.
5239   // See https://bugzilla.mozilla.org/show_bug.cgi?id=248549.
5240   inline void set_is_undetectable();
5241   inline bool is_undetectable();
5242
5243   // Tells whether the instance has a call-as-function handler.
5244   inline void set_is_observed();
5245   inline bool is_observed();
5246
5247   inline void set_is_strong();
5248   inline bool is_strong();
5249   inline void set_is_extensible(bool value);
5250   inline bool is_extensible();
5251   inline void set_is_prototype_map(bool value);
5252   inline bool is_prototype_map() const;
5253
5254   inline void set_elements_kind(ElementsKind elements_kind);
5255   inline ElementsKind elements_kind();
5256
5257   // Tells whether the instance has fast elements that are only Smis.
5258   inline bool has_fast_smi_elements();
5259
5260   // Tells whether the instance has fast elements.
5261   inline bool has_fast_object_elements();
5262   inline bool has_fast_smi_or_object_elements();
5263   inline bool has_fast_double_elements();
5264   inline bool has_fast_elements();
5265   inline bool has_sloppy_arguments_elements();
5266   inline bool has_fixed_typed_array_elements();
5267   inline bool has_dictionary_elements();
5268
5269   static bool IsValidElementsTransition(ElementsKind from_kind,
5270                                         ElementsKind to_kind);
5271
5272   // Returns true if the current map doesn't have DICTIONARY_ELEMENTS but if a
5273   // map with DICTIONARY_ELEMENTS was found in the prototype chain.
5274   bool DictionaryElementsInPrototypeChainOnly();
5275
5276   inline Map* ElementsTransitionMap();
5277
5278   inline FixedArrayBase* GetInitialElements();
5279
5280   // [raw_transitions]: Provides access to the transitions storage field.
5281   // Don't call set_raw_transitions() directly to overwrite transitions, use
5282   // the TransitionArray::ReplaceTransitions() wrapper instead!
5283   DECL_ACCESSORS(raw_transitions, Object)
5284   // [prototype_info]: Per-prototype metadata. Aliased with transitions
5285   // (which prototype maps don't have).
5286   DECL_ACCESSORS(prototype_info, Object)
5287   // PrototypeInfo is created lazily using this helper (which installs it on
5288   // the given prototype's map).
5289   static Handle<PrototypeInfo> GetOrCreatePrototypeInfo(
5290       Handle<JSObject> prototype, Isolate* isolate);
5291   static Handle<PrototypeInfo> GetOrCreatePrototypeInfo(
5292       Handle<Map> prototype_map, Isolate* isolate);
5293
5294   // [prototype chain validity cell]: Associated with a prototype object,
5295   // stored in that object's map's PrototypeInfo, indicates that prototype
5296   // chains through this object are currently valid. The cell will be
5297   // invalidated and replaced when the prototype chain changes.
5298   static Handle<Cell> GetOrCreatePrototypeChainValidityCell(Handle<Map> map,
5299                                                             Isolate* isolate);
5300   static const int kPrototypeChainValid = 0;
5301   static const int kPrototypeChainInvalid = 1;
5302
5303   Map* FindRootMap();
5304   Map* FindFieldOwner(int descriptor);
5305
5306   inline int GetInObjectPropertyOffset(int index);
5307
5308   int NumberOfFields();
5309
5310   // TODO(ishell): candidate with JSObject::MigrateToMap().
5311   bool InstancesNeedRewriting(Map* target, int target_number_of_fields,
5312                               int target_inobject, int target_unused,
5313                               int* old_number_of_fields);
5314   // TODO(ishell): moveit!
5315   static Handle<Map> GeneralizeAllFieldRepresentations(Handle<Map> map);
5316   MUST_USE_RESULT static Handle<HeapType> GeneralizeFieldType(
5317       Handle<HeapType> type1,
5318       Handle<HeapType> type2,
5319       Isolate* isolate);
5320   static void GeneralizeFieldType(Handle<Map> map, int modify_index,
5321                                   Representation new_representation,
5322                                   Handle<HeapType> new_field_type);
5323   static Handle<Map> ReconfigureProperty(Handle<Map> map, int modify_index,
5324                                          PropertyKind new_kind,
5325                                          PropertyAttributes new_attributes,
5326                                          Representation new_representation,
5327                                          Handle<HeapType> new_field_type,
5328                                          StoreMode store_mode);
5329   static Handle<Map> CopyGeneralizeAllRepresentations(
5330       Handle<Map> map, int modify_index, StoreMode store_mode,
5331       PropertyKind kind, PropertyAttributes attributes, const char* reason);
5332
5333   static Handle<Map> PrepareForDataProperty(Handle<Map> old_map,
5334                                             int descriptor_number,
5335                                             Handle<Object> value);
5336
5337   static Handle<Map> Normalize(Handle<Map> map, PropertyNormalizationMode mode,
5338                                const char* reason);
5339
5340   // Returns the constructor name (the name (possibly, inferred name) of the
5341   // function that was used to instantiate the object).
5342   String* constructor_name();
5343
5344   // Tells whether the map is used for JSObjects in dictionary mode (ie
5345   // normalized objects, ie objects for which HasFastProperties returns false).
5346   // A map can never be used for both dictionary mode and fast mode JSObjects.
5347   // False by default and for HeapObjects that are not JSObjects.
5348   inline void set_dictionary_map(bool value);
5349   inline bool is_dictionary_map();
5350
5351   // Tells whether the instance needs security checks when accessing its
5352   // properties.
5353   inline void set_is_access_check_needed(bool access_check_needed);
5354   inline bool is_access_check_needed();
5355
5356   // Returns true if map has a non-empty stub code cache.
5357   inline bool has_code_cache();
5358
5359   // [prototype]: implicit prototype object.
5360   DECL_ACCESSORS(prototype, Object)
5361   // TODO(jkummerow): make set_prototype private.
5362   static void SetPrototype(
5363       Handle<Map> map, Handle<Object> prototype,
5364       PrototypeOptimizationMode proto_mode = FAST_PROTOTYPE);
5365
5366   // [constructor]: points back to the function responsible for this map.
5367   // The field overlaps with the back pointer. All maps in a transition tree
5368   // have the same constructor, so maps with back pointers can walk the
5369   // back pointer chain until they find the map holding their constructor.
5370   DECL_ACCESSORS(constructor_or_backpointer, Object)
5371   inline Object* GetConstructor() const;
5372   inline void SetConstructor(Object* constructor,
5373                              WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
5374   // [back pointer]: points back to the parent map from which a transition
5375   // leads to this map. The field overlaps with the constructor (see above).
5376   inline Object* GetBackPointer();
5377   inline void SetBackPointer(Object* value,
5378                              WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
5379
5380   // [instance descriptors]: describes the object.
5381   DECL_ACCESSORS(instance_descriptors, DescriptorArray)
5382
5383   // [layout descriptor]: describes the object layout.
5384   DECL_ACCESSORS(layout_descriptor, LayoutDescriptor)
5385   // |layout descriptor| accessor which can be used from GC.
5386   inline LayoutDescriptor* layout_descriptor_gc_safe();
5387   inline bool HasFastPointerLayout() const;
5388
5389   // |layout descriptor| accessor that is safe to call even when
5390   // FLAG_unbox_double_fields is disabled (in this case Map does not contain
5391   // |layout_descriptor| field at all).
5392   inline LayoutDescriptor* GetLayoutDescriptor();
5393
5394   inline void UpdateDescriptors(DescriptorArray* descriptors,
5395                                 LayoutDescriptor* layout_descriptor);
5396   inline void InitializeDescriptors(DescriptorArray* descriptors,
5397                                     LayoutDescriptor* layout_descriptor);
5398
5399   // [stub cache]: contains stubs compiled for this map.
5400   DECL_ACCESSORS(code_cache, Object)
5401
5402   // [dependent code]: list of optimized codes that weakly embed this map.
5403   DECL_ACCESSORS(dependent_code, DependentCode)
5404
5405   // [weak cell cache]: cache that stores a weak cell pointing to this map.
5406   DECL_ACCESSORS(weak_cell_cache, Object)
5407
5408   inline PropertyDetails GetLastDescriptorDetails();
5409
5410   inline int LastAdded();
5411
5412   inline int NumberOfOwnDescriptors();
5413   inline void SetNumberOfOwnDescriptors(int number);
5414
5415   inline Cell* RetrieveDescriptorsPointer();
5416
5417   inline int EnumLength();
5418   inline void SetEnumLength(int length);
5419
5420   inline bool owns_descriptors();
5421   inline void set_owns_descriptors(bool owns_descriptors);
5422   inline bool has_instance_call_handler();
5423   inline void set_has_instance_call_handler();
5424   inline void mark_unstable();
5425   inline bool is_stable();
5426   inline void set_migration_target(bool value);
5427   inline bool is_migration_target();
5428   inline void set_counter(int value);
5429   inline int counter();
5430   inline void deprecate();
5431   inline bool is_deprecated();
5432   inline bool CanBeDeprecated();
5433   // Returns a non-deprecated version of the input. If the input was not
5434   // deprecated, it is directly returned. Otherwise, the non-deprecated version
5435   // is found by re-transitioning from the root of the transition tree using the
5436   // descriptor array of the map. Returns MaybeHandle<Map>() if no updated map
5437   // is found.
5438   static MaybeHandle<Map> TryUpdate(Handle<Map> map) WARN_UNUSED_RESULT;
5439
5440   // Returns a non-deprecated version of the input. This method may deprecate
5441   // existing maps along the way if encodings conflict. Not for use while
5442   // gathering type feedback. Use TryUpdate in those cases instead.
5443   static Handle<Map> Update(Handle<Map> map);
5444
5445   static Handle<Map> CopyDropDescriptors(Handle<Map> map);
5446   static Handle<Map> CopyInsertDescriptor(Handle<Map> map,
5447                                           Descriptor* descriptor,
5448                                           TransitionFlag flag);
5449
5450   MUST_USE_RESULT static MaybeHandle<Map> CopyWithField(
5451       Handle<Map> map,
5452       Handle<Name> name,
5453       Handle<HeapType> type,
5454       PropertyAttributes attributes,
5455       Representation representation,
5456       TransitionFlag flag);
5457
5458   MUST_USE_RESULT static MaybeHandle<Map> CopyWithConstant(
5459       Handle<Map> map,
5460       Handle<Name> name,
5461       Handle<Object> constant,
5462       PropertyAttributes attributes,
5463       TransitionFlag flag);
5464
5465   // Returns a new map with all transitions dropped from the given map and
5466   // the ElementsKind set.
5467   static Handle<Map> TransitionElementsTo(Handle<Map> map,
5468                                           ElementsKind to_kind);
5469
5470   static Handle<Map> AsElementsKind(Handle<Map> map, ElementsKind kind);
5471
5472   static Handle<Map> CopyAsElementsKind(Handle<Map> map,
5473                                         ElementsKind kind,
5474                                         TransitionFlag flag);
5475
5476   static Handle<Map> CopyForObserved(Handle<Map> map);
5477
5478   static Handle<Map> CopyForPreventExtensions(Handle<Map> map,
5479                                               PropertyAttributes attrs_to_add,
5480                                               Handle<Symbol> transition_marker,
5481                                               const char* reason);
5482
5483   static Handle<Map> FixProxy(Handle<Map> map, InstanceType type, int size);
5484
5485
5486   // Maximal number of fast properties. Used to restrict the number of map
5487   // transitions to avoid an explosion in the number of maps for objects used as
5488   // dictionaries.
5489   inline bool TooManyFastProperties(StoreFromKeyed store_mode);
5490   static Handle<Map> TransitionToDataProperty(Handle<Map> map,
5491                                               Handle<Name> name,
5492                                               Handle<Object> value,
5493                                               PropertyAttributes attributes,
5494                                               StoreFromKeyed store_mode);
5495   static Handle<Map> TransitionToAccessorProperty(
5496       Handle<Map> map, Handle<Name> name, AccessorComponent component,
5497       Handle<Object> accessor, PropertyAttributes attributes);
5498   static Handle<Map> ReconfigureExistingProperty(Handle<Map> map,
5499                                                  int descriptor,
5500                                                  PropertyKind kind,
5501                                                  PropertyAttributes attributes);
5502
5503   inline void AppendDescriptor(Descriptor* desc);
5504
5505   // Returns a copy of the map, prepared for inserting into the transition
5506   // tree (if the |map| owns descriptors then the new one will share
5507   // descriptors with |map|).
5508   static Handle<Map> CopyForTransition(Handle<Map> map, const char* reason);
5509
5510   // Returns a copy of the map, with all transitions dropped from the
5511   // instance descriptors.
5512   static Handle<Map> Copy(Handle<Map> map, const char* reason);
5513   static Handle<Map> Create(Isolate* isolate, int inobject_properties);
5514
5515   // Returns the next free property index (only valid for FAST MODE).
5516   int NextFreePropertyIndex();
5517
5518   // Returns the number of properties described in instance_descriptors
5519   // filtering out properties with the specified attributes.
5520   int NumberOfDescribedProperties(DescriptorFlag which = OWN_DESCRIPTORS,
5521                                   PropertyAttributes filter = NONE);
5522
5523   DECLARE_CAST(Map)
5524
5525   // Code cache operations.
5526
5527   // Clears the code cache.
5528   inline void ClearCodeCache(Heap* heap);
5529
5530   // Update code cache.
5531   static void UpdateCodeCache(Handle<Map> map,
5532                               Handle<Name> name,
5533                               Handle<Code> code);
5534
5535   // Extend the descriptor array of the map with the list of descriptors.
5536   // In case of duplicates, the latest descriptor is used.
5537   static void AppendCallbackDescriptors(Handle<Map> map,
5538                                         Handle<Object> descriptors);
5539
5540   static inline int SlackForArraySize(int old_size, int size_limit);
5541
5542   static void EnsureDescriptorSlack(Handle<Map> map, int slack);
5543
5544   // Returns the found code or undefined if absent.
5545   Object* FindInCodeCache(Name* name, Code::Flags flags);
5546
5547   // Returns the non-negative index of the code object if it is in the
5548   // cache and -1 otherwise.
5549   int IndexInCodeCache(Object* name, Code* code);
5550
5551   // Removes a code object from the code cache at the given index.
5552   void RemoveFromCodeCache(Name* name, Code* code, int index);
5553
5554   // Computes a hash value for this map, to be used in HashTables and such.
5555   int Hash();
5556
5557   // Returns the map that this map transitions to if its elements_kind
5558   // is changed to |elements_kind|, or NULL if no such map is cached yet.
5559   // |safe_to_add_transitions| is set to false if adding transitions is not
5560   // allowed.
5561   Map* LookupElementsTransitionMap(ElementsKind elements_kind);
5562
5563   // Returns the transitioned map for this map with the most generic
5564   // elements_kind that's found in |candidates|, or null handle if no match is
5565   // found at all.
5566   static Handle<Map> FindTransitionedMap(Handle<Map> map,
5567                                          MapHandleList* candidates);
5568
5569   inline bool CanTransition();
5570
5571   inline bool IsPrimitiveMap();
5572   inline bool IsJSObjectMap();
5573   inline bool IsJSArrayMap();
5574   inline bool IsStringMap();
5575   inline bool IsJSProxyMap();
5576   inline bool IsJSGlobalProxyMap();
5577   inline bool IsJSGlobalObjectMap();
5578   inline bool IsGlobalObjectMap();
5579
5580   inline bool CanOmitMapChecks();
5581
5582   static void AddDependentCode(Handle<Map> map,
5583                                DependentCode::DependencyGroup group,
5584                                Handle<Code> code);
5585
5586   bool IsMapInArrayPrototypeChain();
5587
5588   static Handle<WeakCell> WeakCellForMap(Handle<Map> map);
5589
5590   // Dispatched behavior.
5591   DECLARE_PRINTER(Map)
5592   DECLARE_VERIFIER(Map)
5593
5594 #ifdef VERIFY_HEAP
5595   void DictionaryMapVerify();
5596   void VerifyOmittedMapChecks();
5597 #endif
5598
5599   inline int visitor_id();
5600   inline void set_visitor_id(int visitor_id);
5601
5602   static Handle<Map> TransitionToPrototype(Handle<Map> map,
5603                                            Handle<Object> prototype,
5604                                            PrototypeOptimizationMode mode);
5605
5606   static const int kMaxPreAllocatedPropertyFields = 255;
5607
5608   // Layout description.
5609   static const int kInstanceSizesOffset = HeapObject::kHeaderSize;
5610   static const int kInstanceAttributesOffset = kInstanceSizesOffset + kIntSize;
5611   static const int kBitField3Offset = kInstanceAttributesOffset + kIntSize;
5612   static const int kPrototypeOffset = kBitField3Offset + kPointerSize;
5613   static const int kConstructorOrBackPointerOffset =
5614       kPrototypeOffset + kPointerSize;
5615   // When there is only one transition, it is stored directly in this field;
5616   // otherwise a transition array is used.
5617   // For prototype maps, this slot is used to store this map's PrototypeInfo
5618   // struct.
5619   static const int kTransitionsOrPrototypeInfoOffset =
5620       kConstructorOrBackPointerOffset + kPointerSize;
5621   static const int kDescriptorsOffset =
5622       kTransitionsOrPrototypeInfoOffset + kPointerSize;
5623 #if V8_DOUBLE_FIELDS_UNBOXING
5624   static const int kLayoutDecriptorOffset = kDescriptorsOffset + kPointerSize;
5625   static const int kCodeCacheOffset = kLayoutDecriptorOffset + kPointerSize;
5626 #else
5627   static const int kLayoutDecriptorOffset = 1;  // Must not be ever accessed.
5628   static const int kCodeCacheOffset = kDescriptorsOffset + kPointerSize;
5629 #endif
5630   static const int kDependentCodeOffset = kCodeCacheOffset + kPointerSize;
5631   static const int kWeakCellCacheOffset = kDependentCodeOffset + kPointerSize;
5632   static const int kSize = kWeakCellCacheOffset + kPointerSize;
5633
5634   // Layout of pointer fields. Heap iteration code relies on them
5635   // being continuously allocated.
5636   static const int kPointerFieldsBeginOffset = Map::kPrototypeOffset;
5637   static const int kPointerFieldsEndOffset = kSize;
5638
5639   // Byte offsets within kInstanceSizesOffset.
5640   static const int kInstanceSizeOffset = kInstanceSizesOffset + 0;
5641   static const int kInObjectPropertiesOrConstructorFunctionIndexByte = 1;
5642   static const int kInObjectPropertiesOrConstructorFunctionIndexOffset =
5643       kInstanceSizesOffset + kInObjectPropertiesOrConstructorFunctionIndexByte;
5644   // Note there is one byte available for use here.
5645   static const int kUnusedByte = 2;
5646   static const int kUnusedOffset = kInstanceSizesOffset + kUnusedByte;
5647   static const int kVisitorIdByte = 3;
5648   static const int kVisitorIdOffset = kInstanceSizesOffset + kVisitorIdByte;
5649
5650   // Byte offsets within kInstanceAttributesOffset attributes.
5651 #if V8_TARGET_LITTLE_ENDIAN
5652   // Order instance type and bit field together such that they can be loaded
5653   // together as a 16-bit word with instance type in the lower 8 bits regardless
5654   // of endianess. Also provide endian-independent offset to that 16-bit word.
5655   static const int kInstanceTypeOffset = kInstanceAttributesOffset + 0;
5656   static const int kBitFieldOffset = kInstanceAttributesOffset + 1;
5657 #else
5658   static const int kBitFieldOffset = kInstanceAttributesOffset + 0;
5659   static const int kInstanceTypeOffset = kInstanceAttributesOffset + 1;
5660 #endif
5661   static const int kInstanceTypeAndBitFieldOffset =
5662       kInstanceAttributesOffset + 0;
5663   static const int kBitField2Offset = kInstanceAttributesOffset + 2;
5664   static const int kUnusedPropertyFieldsByte = 3;
5665   static const int kUnusedPropertyFieldsOffset = kInstanceAttributesOffset + 3;
5666
5667   STATIC_ASSERT(kInstanceTypeAndBitFieldOffset ==
5668                 Internals::kMapInstanceTypeAndBitFieldOffset);
5669
5670   // Bit positions for bit field.
5671   static const int kHasNonInstancePrototype = 0;
5672   static const int kIsHiddenPrototype = 1;
5673   static const int kHasNamedInterceptor = 2;
5674   static const int kHasIndexedInterceptor = 3;
5675   static const int kIsUndetectable = 4;
5676   static const int kIsObserved = 5;
5677   static const int kIsAccessCheckNeeded = 6;
5678   class FunctionWithPrototype: public BitField<bool, 7,  1> {};
5679
5680   // Bit positions for bit field 2
5681   static const int kIsExtensible = 0;
5682   static const int kStringWrapperSafeForDefaultValueOf = 1;
5683   class IsPrototypeMapBits : public BitField<bool, 2, 1> {};
5684   class ElementsKindBits: public BitField<ElementsKind, 3, 5> {};
5685
5686   // Derived values from bit field 2
5687   static const int8_t kMaximumBitField2FastElementValue = static_cast<int8_t>(
5688       (FAST_ELEMENTS + 1) << Map::ElementsKindBits::kShift) - 1;
5689   static const int8_t kMaximumBitField2FastSmiElementValue =
5690       static_cast<int8_t>((FAST_SMI_ELEMENTS + 1) <<
5691                           Map::ElementsKindBits::kShift) - 1;
5692   static const int8_t kMaximumBitField2FastHoleyElementValue =
5693       static_cast<int8_t>((FAST_HOLEY_ELEMENTS + 1) <<
5694                           Map::ElementsKindBits::kShift) - 1;
5695   static const int8_t kMaximumBitField2FastHoleySmiElementValue =
5696       static_cast<int8_t>((FAST_HOLEY_SMI_ELEMENTS + 1) <<
5697                           Map::ElementsKindBits::kShift) - 1;
5698
5699   typedef FixedBodyDescriptor<kPointerFieldsBeginOffset,
5700                               kPointerFieldsEndOffset,
5701                               kSize> BodyDescriptor;
5702
5703   // Compares this map to another to see if they describe equivalent objects.
5704   // If |mode| is set to CLEAR_INOBJECT_PROPERTIES, |other| is treated as if
5705   // it had exactly zero inobject properties.
5706   // The "shared" flags of both this map and |other| are ignored.
5707   bool EquivalentToForNormalization(Map* other, PropertyNormalizationMode mode);
5708
5709   // Returns true if given field is unboxed double.
5710   inline bool IsUnboxedDoubleField(FieldIndex index);
5711
5712 #if TRACE_MAPS
5713   static void TraceTransition(const char* what, Map* from, Map* to, Name* name);
5714   static void TraceAllTransitions(Map* map);
5715 #endif
5716
5717   static inline Handle<Map> CopyInstallDescriptorsForTesting(
5718       Handle<Map> map, int new_descriptor, Handle<DescriptorArray> descriptors,
5719       Handle<LayoutDescriptor> layout_descriptor);
5720
5721  private:
5722   static void ConnectTransition(Handle<Map> parent, Handle<Map> child,
5723                                 Handle<Name> name, SimpleTransitionFlag flag);
5724
5725   bool EquivalentToForTransition(Map* other);
5726   static Handle<Map> RawCopy(Handle<Map> map, int instance_size);
5727   static Handle<Map> ShareDescriptor(Handle<Map> map,
5728                                      Handle<DescriptorArray> descriptors,
5729                                      Descriptor* descriptor);
5730   static Handle<Map> CopyInstallDescriptors(
5731       Handle<Map> map, int new_descriptor, Handle<DescriptorArray> descriptors,
5732       Handle<LayoutDescriptor> layout_descriptor);
5733   static Handle<Map> CopyAddDescriptor(Handle<Map> map,
5734                                        Descriptor* descriptor,
5735                                        TransitionFlag flag);
5736   static Handle<Map> CopyReplaceDescriptors(
5737       Handle<Map> map, Handle<DescriptorArray> descriptors,
5738       Handle<LayoutDescriptor> layout_descriptor, TransitionFlag flag,
5739       MaybeHandle<Name> maybe_name, const char* reason,
5740       SimpleTransitionFlag simple_flag);
5741
5742   static Handle<Map> CopyReplaceDescriptor(Handle<Map> map,
5743                                            Handle<DescriptorArray> descriptors,
5744                                            Descriptor* descriptor,
5745                                            int index,
5746                                            TransitionFlag flag);
5747   static MUST_USE_RESULT MaybeHandle<Map> TryReconfigureExistingProperty(
5748       Handle<Map> map, int descriptor, PropertyKind kind,
5749       PropertyAttributes attributes, const char** reason);
5750
5751   static Handle<Map> CopyNormalized(Handle<Map> map,
5752                                     PropertyNormalizationMode mode);
5753
5754   // Fires when the layout of an object with a leaf map changes.
5755   // This includes adding transitions to the leaf map or changing
5756   // the descriptor array.
5757   inline void NotifyLeafMapLayoutChange();
5758
5759   void DeprecateTransitionTree();
5760   bool DeprecateTarget(PropertyKind kind, Name* key,
5761                        PropertyAttributes attributes,
5762                        DescriptorArray* new_descriptors,
5763                        LayoutDescriptor* new_layout_descriptor);
5764
5765   Map* FindLastMatchMap(int verbatim, int length, DescriptorArray* descriptors);
5766
5767   // Update field type of the given descriptor to new representation and new
5768   // type. The type must be prepared for storing in descriptor array:
5769   // it must be either a simple type or a map wrapped in a weak cell.
5770   void UpdateFieldType(int descriptor_number, Handle<Name> name,
5771                        Representation new_representation,
5772                        Handle<Object> new_wrapped_type);
5773
5774   void PrintReconfiguration(FILE* file, int modify_index, PropertyKind kind,
5775                             PropertyAttributes attributes);
5776   void PrintGeneralization(FILE* file,
5777                            const char* reason,
5778                            int modify_index,
5779                            int split,
5780                            int descriptors,
5781                            bool constant_to_field,
5782                            Representation old_representation,
5783                            Representation new_representation,
5784                            HeapType* old_field_type,
5785                            HeapType* new_field_type);
5786
5787   static const int kFastPropertiesSoftLimit = 12;
5788   static const int kMaxFastProperties = 128;
5789
5790   DISALLOW_IMPLICIT_CONSTRUCTORS(Map);
5791 };
5792
5793
5794 // An abstract superclass, a marker class really, for simple structure classes.
5795 // It doesn't carry much functionality but allows struct classes to be
5796 // identified in the type system.
5797 class Struct: public HeapObject {
5798  public:
5799   inline void InitializeBody(int object_size);
5800   DECLARE_CAST(Struct)
5801 };
5802
5803
5804 // A simple one-element struct, useful where smis need to be boxed.
5805 class Box : public Struct {
5806  public:
5807   // [value]: the boxed contents.
5808   DECL_ACCESSORS(value, Object)
5809
5810   DECLARE_CAST(Box)
5811
5812   // Dispatched behavior.
5813   DECLARE_PRINTER(Box)
5814   DECLARE_VERIFIER(Box)
5815
5816   static const int kValueOffset = HeapObject::kHeaderSize;
5817   static const int kSize = kValueOffset + kPointerSize;
5818
5819  private:
5820   DISALLOW_IMPLICIT_CONSTRUCTORS(Box);
5821 };
5822
5823
5824 // Container for metadata stored on each prototype map.
5825 class PrototypeInfo : public Struct {
5826  public:
5827   static const int UNREGISTERED = -1;
5828
5829   // [prototype_users]: WeakFixedArray containing maps using this prototype,
5830   // or Smi(0) if uninitialized.
5831   DECL_ACCESSORS(prototype_users, Object)
5832   // [registry_slot]: Slot in prototype's user registry where this user
5833   // is stored. Returns UNREGISTERED if this prototype has not been registered.
5834   inline int registry_slot() const;
5835   inline void set_registry_slot(int slot);
5836   // [validity_cell]: Cell containing the validity bit for prototype chains
5837   // going through this object, or Smi(0) if uninitialized.
5838   DECL_ACCESSORS(validity_cell, Object)
5839   // [constructor_name]: User-friendly name of the original constructor.
5840   DECL_ACCESSORS(constructor_name, Object)
5841
5842   DECLARE_CAST(PrototypeInfo)
5843
5844   // Dispatched behavior.
5845   DECLARE_PRINTER(PrototypeInfo)
5846   DECLARE_VERIFIER(PrototypeInfo)
5847
5848   static const int kPrototypeUsersOffset = HeapObject::kHeaderSize;
5849   static const int kRegistrySlotOffset = kPrototypeUsersOffset + kPointerSize;
5850   static const int kValidityCellOffset = kRegistrySlotOffset + kPointerSize;
5851   static const int kConstructorNameOffset = kValidityCellOffset + kPointerSize;
5852   static const int kSize = kConstructorNameOffset + kPointerSize;
5853
5854  private:
5855   DISALLOW_IMPLICIT_CONSTRUCTORS(PrototypeInfo);
5856 };
5857
5858
5859 // Pair used to store both a ScopeInfo and an extension object in the extension
5860 // slot of a block context. Needed in the rare case where a declaration block
5861 // scope (a "varblock" as used to desugar parameter destructuring) also contains
5862 // a sloppy direct eval. (In no other case both are needed at the same time.)
5863 class SloppyBlockWithEvalContextExtension : public Struct {
5864  public:
5865   // [scope_info]: Scope info.
5866   DECL_ACCESSORS(scope_info, ScopeInfo)
5867   // [extension]: Extension object.
5868   DECL_ACCESSORS(extension, JSObject)
5869
5870   DECLARE_CAST(SloppyBlockWithEvalContextExtension)
5871
5872   // Dispatched behavior.
5873   DECLARE_PRINTER(SloppyBlockWithEvalContextExtension)
5874   DECLARE_VERIFIER(SloppyBlockWithEvalContextExtension)
5875
5876   static const int kScopeInfoOffset = HeapObject::kHeaderSize;
5877   static const int kExtensionOffset = kScopeInfoOffset + kPointerSize;
5878   static const int kSize = kExtensionOffset + kPointerSize;
5879
5880  private:
5881   DISALLOW_IMPLICIT_CONSTRUCTORS(SloppyBlockWithEvalContextExtension);
5882 };
5883
5884
5885 // Script describes a script which has been added to the VM.
5886 class Script: public Struct {
5887  public:
5888   // Script types.
5889   enum Type {
5890     TYPE_NATIVE = 0,
5891     TYPE_EXTENSION = 1,
5892     TYPE_NORMAL = 2
5893   };
5894
5895   // Script compilation types.
5896   enum CompilationType {
5897     COMPILATION_TYPE_HOST = 0,
5898     COMPILATION_TYPE_EVAL = 1
5899   };
5900
5901   // Script compilation state.
5902   enum CompilationState {
5903     COMPILATION_STATE_INITIAL = 0,
5904     COMPILATION_STATE_COMPILED = 1
5905   };
5906
5907   // [source]: the script source.
5908   DECL_ACCESSORS(source, Object)
5909
5910   // [name]: the script name.
5911   DECL_ACCESSORS(name, Object)
5912
5913   // [id]: the script id.
5914   DECL_ACCESSORS(id, Smi)
5915
5916   // [line_offset]: script line offset in resource from where it was extracted.
5917   DECL_ACCESSORS(line_offset, Smi)
5918
5919   // [column_offset]: script column offset in resource from where it was
5920   // extracted.
5921   DECL_ACCESSORS(column_offset, Smi)
5922
5923   // [context_data]: context data for the context this script was compiled in.
5924   DECL_ACCESSORS(context_data, Object)
5925
5926   // [wrapper]: the wrapper cache.  This is either undefined or a WeakCell.
5927   DECL_ACCESSORS(wrapper, HeapObject)
5928
5929   // [type]: the script type.
5930   DECL_ACCESSORS(type, Smi)
5931
5932   // [line_ends]: FixedArray of line ends positions.
5933   DECL_ACCESSORS(line_ends, Object)
5934
5935   // [eval_from_shared]: for eval scripts the shared funcion info for the
5936   // function from which eval was called.
5937   DECL_ACCESSORS(eval_from_shared, Object)
5938
5939   // [eval_from_instructions_offset]: the instruction offset in the code for the
5940   // function from which eval was called where eval was called.
5941   DECL_ACCESSORS(eval_from_instructions_offset, Smi)
5942
5943   // [shared_function_infos]: weak fixed array containing all shared
5944   // function infos created from this script.
5945   DECL_ACCESSORS(shared_function_infos, Object)
5946
5947   // [flags]: Holds an exciting bitfield.
5948   DECL_ACCESSORS(flags, Smi)
5949
5950   // [source_url]: sourceURL from magic comment
5951   DECL_ACCESSORS(source_url, Object)
5952
5953   // [source_url]: sourceMappingURL magic comment
5954   DECL_ACCESSORS(source_mapping_url, Object)
5955
5956   // [compilation_type]: how the the script was compiled. Encoded in the
5957   // 'flags' field.
5958   inline CompilationType compilation_type();
5959   inline void set_compilation_type(CompilationType type);
5960
5961   // [compilation_state]: determines whether the script has already been
5962   // compiled. Encoded in the 'flags' field.
5963   inline CompilationState compilation_state();
5964   inline void set_compilation_state(CompilationState state);
5965
5966   // [hide_source]: determines whether the script source can be exposed as
5967   // function source. Encoded in the 'flags' field.
5968   inline bool hide_source();
5969   inline void set_hide_source(bool value);
5970
5971   // [origin_options]: optional attributes set by the embedder via ScriptOrigin,
5972   // and used by the embedder to make decisions about the script. V8 just passes
5973   // this through. Encoded in the 'flags' field.
5974   inline v8::ScriptOriginOptions origin_options();
5975   inline void set_origin_options(ScriptOriginOptions origin_options);
5976
5977   DECLARE_CAST(Script)
5978
5979   // If script source is an external string, check that the underlying
5980   // resource is accessible. Otherwise, always return true.
5981   inline bool HasValidSource();
5982
5983   // Convert code position into column number.
5984   static int GetColumnNumber(Handle<Script> script, int code_pos);
5985
5986   // Convert code position into (zero-based) line number.
5987   // The non-handlified version does not allocate, but may be much slower.
5988   static int GetLineNumber(Handle<Script> script, int code_pos);
5989   int GetLineNumber(int code_pos);
5990
5991   static Handle<Object> GetNameOrSourceURL(Handle<Script> script);
5992
5993   // Init line_ends array with code positions of line ends inside script source.
5994   static void InitLineEnds(Handle<Script> script);
5995
5996   // Get the JS object wrapping the given script; create it if none exists.
5997   static Handle<JSObject> GetWrapper(Handle<Script> script);
5998
5999   // Look through the list of existing shared function infos to find one
6000   // that matches the function literal.  Return empty handle if not found.
6001   MaybeHandle<SharedFunctionInfo> FindSharedFunctionInfo(FunctionLiteral* fun);
6002
6003   // Iterate over all script objects on the heap.
6004   class Iterator {
6005    public:
6006     explicit Iterator(Isolate* isolate);
6007     Script* Next();
6008
6009    private:
6010     WeakFixedArray::Iterator iterator_;
6011     DISALLOW_COPY_AND_ASSIGN(Iterator);
6012   };
6013
6014   // Dispatched behavior.
6015   DECLARE_PRINTER(Script)
6016   DECLARE_VERIFIER(Script)
6017
6018   static const int kSourceOffset = HeapObject::kHeaderSize;
6019   static const int kNameOffset = kSourceOffset + kPointerSize;
6020   static const int kLineOffsetOffset = kNameOffset + kPointerSize;
6021   static const int kColumnOffsetOffset = kLineOffsetOffset + kPointerSize;
6022   static const int kContextOffset = kColumnOffsetOffset + kPointerSize;
6023   static const int kWrapperOffset = kContextOffset + kPointerSize;
6024   static const int kTypeOffset = kWrapperOffset + kPointerSize;
6025   static const int kLineEndsOffset = kTypeOffset + kPointerSize;
6026   static const int kIdOffset = kLineEndsOffset + kPointerSize;
6027   static const int kEvalFromSharedOffset = kIdOffset + kPointerSize;
6028   static const int kEvalFrominstructionsOffsetOffset =
6029       kEvalFromSharedOffset + kPointerSize;
6030   static const int kSharedFunctionInfosOffset =
6031       kEvalFrominstructionsOffsetOffset + kPointerSize;
6032   static const int kFlagsOffset = kSharedFunctionInfosOffset + kPointerSize;
6033   static const int kSourceUrlOffset = kFlagsOffset + kPointerSize;
6034   static const int kSourceMappingUrlOffset = kSourceUrlOffset + kPointerSize;
6035   static const int kSize = kSourceMappingUrlOffset + kPointerSize;
6036
6037  private:
6038   int GetLineNumberWithArray(int code_pos);
6039
6040   // Bit positions in the flags field.
6041   static const int kCompilationTypeBit = 0;
6042   static const int kCompilationStateBit = 1;
6043   static const int kHideSourceBit = 2;
6044   static const int kOriginOptionsShift = 3;
6045   static const int kOriginOptionsSize = 3;
6046   static const int kOriginOptionsMask = ((1 << kOriginOptionsSize) - 1)
6047                                         << kOriginOptionsShift;
6048
6049   DISALLOW_IMPLICIT_CONSTRUCTORS(Script);
6050 };
6051
6052
6053 // List of builtin functions we want to identify to improve code
6054 // generation.
6055 //
6056 // Each entry has a name of a global object property holding an object
6057 // optionally followed by ".prototype", a name of a builtin function
6058 // on the object (the one the id is set for), and a label.
6059 //
6060 // Installation of ids for the selected builtin functions is handled
6061 // by the bootstrapper.
6062 #define FUNCTIONS_WITH_ID_LIST(V)                   \
6063   V(Array.prototype, indexOf, ArrayIndexOf)         \
6064   V(Array.prototype, lastIndexOf, ArrayLastIndexOf) \
6065   V(Array.prototype, push, ArrayPush)               \
6066   V(Array.prototype, pop, ArrayPop)                 \
6067   V(Array.prototype, shift, ArrayShift)             \
6068   V(Function.prototype, apply, FunctionApply)       \
6069   V(Function.prototype, call, FunctionCall)         \
6070   V(String.prototype, charCodeAt, StringCharCodeAt) \
6071   V(String.prototype, charAt, StringCharAt)         \
6072   V(String, fromCharCode, StringFromCharCode)       \
6073   V(Math, random, MathRandom)                       \
6074   V(Math, floor, MathFloor)                         \
6075   V(Math, round, MathRound)                         \
6076   V(Math, ceil, MathCeil)                           \
6077   V(Math, abs, MathAbs)                             \
6078   V(Math, log, MathLog)                             \
6079   V(Math, exp, MathExp)                             \
6080   V(Math, sqrt, MathSqrt)                           \
6081   V(Math, pow, MathPow)                             \
6082   V(Math, max, MathMax)                             \
6083   V(Math, min, MathMin)                             \
6084   V(Math, cos, MathCos)                             \
6085   V(Math, sin, MathSin)                             \
6086   V(Math, tan, MathTan)                             \
6087   V(Math, acos, MathAcos)                           \
6088   V(Math, asin, MathAsin)                           \
6089   V(Math, atan, MathAtan)                           \
6090   V(Math, atan2, MathAtan2)                         \
6091   V(Math, imul, MathImul)                           \
6092   V(Math, clz32, MathClz32)                         \
6093   V(Math, fround, MathFround)
6094
6095 #define ATOMIC_FUNCTIONS_WITH_ID_LIST(V) \
6096   V(Atomics, load, AtomicsLoad)          \
6097   V(Atomics, store, AtomicsStore)
6098
6099 enum BuiltinFunctionId {
6100   kArrayCode,
6101 #define DECLARE_FUNCTION_ID(ignored1, ignore2, name)    \
6102   k##name,
6103   FUNCTIONS_WITH_ID_LIST(DECLARE_FUNCTION_ID)
6104       ATOMIC_FUNCTIONS_WITH_ID_LIST(DECLARE_FUNCTION_ID)
6105 #undef DECLARE_FUNCTION_ID
6106   // Fake id for a special case of Math.pow. Note, it continues the
6107   // list of math functions.
6108   kMathPowHalf
6109 };
6110
6111
6112 // Result of searching in an optimized code map of a SharedFunctionInfo. Note
6113 // that both {code} and {literals} can be NULL to pass search result status.
6114 struct CodeAndLiterals {
6115   Code* code;            // Cached optimized code.
6116   FixedArray* literals;  // Cached literals array.
6117 };
6118
6119
6120 // SharedFunctionInfo describes the JSFunction information that can be
6121 // shared by multiple instances of the function.
6122 class SharedFunctionInfo: public HeapObject {
6123  public:
6124   // [name]: Function name.
6125   DECL_ACCESSORS(name, Object)
6126
6127   // [code]: Function code.
6128   DECL_ACCESSORS(code, Code)
6129   inline void ReplaceCode(Code* code);
6130
6131   // [optimized_code_map]: Map from native context to optimized code
6132   // and a shared literals array or Smi(0) if none.
6133   DECL_ACCESSORS(optimized_code_map, Object)
6134
6135   // Returns entry from optimized code map for specified context and OSR entry.
6136   // Note that {code == nullptr} indicates no matching entry has been found,
6137   // whereas {literals == nullptr} indicates the code is context-independent.
6138   CodeAndLiterals SearchOptimizedCodeMap(Context* native_context,
6139                                          BailoutId osr_ast_id);
6140
6141   // Clear optimized code map.
6142   void ClearOptimizedCodeMap();
6143
6144   // Removed a specific optimized code object from the optimized code map.
6145   void EvictFromOptimizedCodeMap(Code* optimized_code, const char* reason);
6146
6147   // Trims the optimized code map after entries have been removed.
6148   void TrimOptimizedCodeMap(int shrink_by);
6149
6150   // Add a new entry to the optimized code map for context-independent code.
6151   static void AddSharedCodeToOptimizedCodeMap(Handle<SharedFunctionInfo> shared,
6152                                               Handle<Code> code);
6153
6154   // Add a new entry to the optimized code map for context-dependent code.
6155   static void AddToOptimizedCodeMap(Handle<SharedFunctionInfo> shared,
6156                                     Handle<Context> native_context,
6157                                     Handle<Code> code,
6158                                     Handle<FixedArray> literals,
6159                                     BailoutId osr_ast_id);
6160
6161   // Set up the link between shared function info and the script. The shared
6162   // function info is added to the list on the script.
6163   static void SetScript(Handle<SharedFunctionInfo> shared,
6164                         Handle<Object> script_object);
6165
6166   // Layout description of the optimized code map.
6167   static const int kNextMapIndex = 0;
6168   static const int kSharedCodeIndex = 1;
6169   static const int kEntriesStart = 2;
6170   static const int kContextOffset = 0;
6171   static const int kCachedCodeOffset = 1;
6172   static const int kLiteralsOffset = 2;
6173   static const int kOsrAstIdOffset = 3;
6174   static const int kEntryLength = 4;
6175   static const int kInitialLength = kEntriesStart + kEntryLength;
6176
6177   // [scope_info]: Scope info.
6178   DECL_ACCESSORS(scope_info, ScopeInfo)
6179
6180   // [construct stub]: Code stub for constructing instances of this function.
6181   DECL_ACCESSORS(construct_stub, Code)
6182
6183   // Returns if this function has been compiled to native code yet.
6184   inline bool is_compiled();
6185
6186   // [length]: The function length - usually the number of declared parameters.
6187   // Use up to 2^30 parameters.
6188   inline int length() const;
6189   inline void set_length(int value);
6190
6191   // [internal formal parameter count]: The declared number of parameters.
6192   // For subclass constructors, also includes new.target.
6193   // The size of function's frame is internal_formal_parameter_count + 1.
6194   inline int internal_formal_parameter_count() const;
6195   inline void set_internal_formal_parameter_count(int value);
6196
6197   // Set the formal parameter count so the function code will be
6198   // called without using argument adaptor frames.
6199   inline void DontAdaptArguments();
6200
6201   // [expected_nof_properties]: Expected number of properties for the function.
6202   inline int expected_nof_properties() const;
6203   inline void set_expected_nof_properties(int value);
6204
6205   // [feedback_vector] - accumulates ast node feedback from full-codegen and
6206   // (increasingly) from crankshafted code where sufficient feedback isn't
6207   // available.
6208   DECL_ACCESSORS(feedback_vector, TypeFeedbackVector)
6209
6210   // Unconditionally clear the type feedback vector (including vector ICs).
6211   void ClearTypeFeedbackInfo();
6212
6213   // Clear the type feedback vector with a more subtle policy at GC time.
6214   void ClearTypeFeedbackInfoAtGCTime();
6215
6216 #if TRACE_MAPS
6217   // [unique_id] - For --trace-maps purposes, an identifier that's persistent
6218   // even if the GC moves this SharedFunctionInfo.
6219   inline int unique_id() const;
6220   inline void set_unique_id(int value);
6221 #endif
6222
6223   // [instance class name]: class name for instances.
6224   DECL_ACCESSORS(instance_class_name, Object)
6225
6226   // [function data]: This field holds some additional data for function.
6227   // Currently it has one of:
6228   //  - a FunctionTemplateInfo to make benefit the API [IsApiFunction()].
6229   //  - a Smi identifying a builtin function [HasBuiltinFunctionId()].
6230   //  - a BytecodeArray for the interpreter [HasBytecodeArray()].
6231   // In the long run we don't want all functions to have this field but
6232   // we can fix that when we have a better model for storing hidden data
6233   // on objects.
6234   DECL_ACCESSORS(function_data, Object)
6235
6236   inline bool IsApiFunction();
6237   inline FunctionTemplateInfo* get_api_func_data();
6238   inline bool HasBuiltinFunctionId();
6239   inline BuiltinFunctionId builtin_function_id();
6240   inline bool HasBytecodeArray();
6241   inline BytecodeArray* bytecode_array();
6242
6243   // [script info]: Script from which the function originates.
6244   DECL_ACCESSORS(script, Object)
6245
6246   // [num_literals]: Number of literals used by this function.
6247   inline int num_literals() const;
6248   inline void set_num_literals(int value);
6249
6250   // [start_position_and_type]: Field used to store both the source code
6251   // position, whether or not the function is a function expression,
6252   // and whether or not the function is a toplevel function. The two
6253   // least significants bit indicates whether the function is an
6254   // expression and the rest contains the source code position.
6255   inline int start_position_and_type() const;
6256   inline void set_start_position_and_type(int value);
6257
6258   // The function is subject to debugging if a debug info is attached.
6259   inline bool HasDebugInfo();
6260   inline DebugInfo* GetDebugInfo();
6261
6262   // A function has debug code if the compiled code has debug break slots.
6263   inline bool HasDebugCode();
6264
6265   // [debug info]: Debug information.
6266   DECL_ACCESSORS(debug_info, Object)
6267
6268   // [inferred name]: Name inferred from variable or property
6269   // assignment of this function. Used to facilitate debugging and
6270   // profiling of JavaScript code written in OO style, where almost
6271   // all functions are anonymous but are assigned to object
6272   // properties.
6273   DECL_ACCESSORS(inferred_name, String)
6274
6275   // The function's name if it is non-empty, otherwise the inferred name.
6276   String* DebugName();
6277
6278   // Position of the 'function' token in the script source.
6279   inline int function_token_position() const;
6280   inline void set_function_token_position(int function_token_position);
6281
6282   // Position of this function in the script source.
6283   inline int start_position() const;
6284   inline void set_start_position(int start_position);
6285
6286   // End position of this function in the script source.
6287   inline int end_position() const;
6288   inline void set_end_position(int end_position);
6289
6290   // Is this function a function expression in the source code.
6291   DECL_BOOLEAN_ACCESSORS(is_expression)
6292
6293   // Is this function a top-level function (scripts, evals).
6294   DECL_BOOLEAN_ACCESSORS(is_toplevel)
6295
6296   // Bit field containing various information collected by the compiler to
6297   // drive optimization.
6298   inline int compiler_hints() const;
6299   inline void set_compiler_hints(int value);
6300
6301   inline int ast_node_count() const;
6302   inline void set_ast_node_count(int count);
6303
6304   inline int profiler_ticks() const;
6305   inline void set_profiler_ticks(int ticks);
6306
6307   // Inline cache age is used to infer whether the function survived a context
6308   // disposal or not. In the former case we reset the opt_count.
6309   inline int ic_age();
6310   inline void set_ic_age(int age);
6311
6312   // Indicates if this function can be lazy compiled.
6313   // This is used to determine if we can safely flush code from a function
6314   // when doing GC if we expect that the function will no longer be used.
6315   DECL_BOOLEAN_ACCESSORS(allows_lazy_compilation)
6316
6317   // Indicates if this function can be lazy compiled without a context.
6318   // This is used to determine if we can force compilation without reaching
6319   // the function through program execution but through other means (e.g. heap
6320   // iteration by the debugger).
6321   DECL_BOOLEAN_ACCESSORS(allows_lazy_compilation_without_context)
6322
6323   // Indicates whether optimizations have been disabled for this
6324   // shared function info. If a function is repeatedly optimized or if
6325   // we cannot optimize the function we disable optimization to avoid
6326   // spending time attempting to optimize it again.
6327   DECL_BOOLEAN_ACCESSORS(optimization_disabled)
6328
6329   // Indicates the language mode.
6330   inline LanguageMode language_mode();
6331   inline void set_language_mode(LanguageMode language_mode);
6332
6333   // False if the function definitely does not allocate an arguments object.
6334   DECL_BOOLEAN_ACCESSORS(uses_arguments)
6335
6336   // Indicates that this function uses a super property (or an eval that may
6337   // use a super property).
6338   // This is needed to set up the [[HomeObject]] on the function instance.
6339   DECL_BOOLEAN_ACCESSORS(needs_home_object)
6340
6341   // True if the function has any duplicated parameter names.
6342   DECL_BOOLEAN_ACCESSORS(has_duplicate_parameters)
6343
6344   // Indicates whether the function is a native function.
6345   // These needs special treatment in .call and .apply since
6346   // null passed as the receiver should not be translated to the
6347   // global object.
6348   DECL_BOOLEAN_ACCESSORS(native)
6349
6350   // Indicate that this function should always be inlined in optimized code.
6351   DECL_BOOLEAN_ACCESSORS(force_inline)
6352
6353   // Indicates that the function was created by the Function function.
6354   // Though it's anonymous, toString should treat it as if it had the name
6355   // "anonymous".  We don't set the name itself so that the system does not
6356   // see a binding for it.
6357   DECL_BOOLEAN_ACCESSORS(name_should_print_as_anonymous)
6358
6359   // Indicates whether the function is a bound function created using
6360   // the bind function.
6361   DECL_BOOLEAN_ACCESSORS(bound)
6362
6363   // Indicates that the function is anonymous (the name field can be set
6364   // through the API, which does not change this flag).
6365   DECL_BOOLEAN_ACCESSORS(is_anonymous)
6366
6367   // Is this a function or top-level/eval code.
6368   DECL_BOOLEAN_ACCESSORS(is_function)
6369
6370   // Indicates that code for this function cannot be compiled with Crankshaft.
6371   DECL_BOOLEAN_ACCESSORS(dont_crankshaft)
6372
6373   // Indicates that code for this function cannot be flushed.
6374   DECL_BOOLEAN_ACCESSORS(dont_flush)
6375
6376   // Indicates that this function is a generator.
6377   DECL_BOOLEAN_ACCESSORS(is_generator)
6378
6379   // Indicates that this function is an arrow function.
6380   DECL_BOOLEAN_ACCESSORS(is_arrow)
6381
6382   // Indicates that this function is a concise method.
6383   DECL_BOOLEAN_ACCESSORS(is_concise_method)
6384
6385   // Indicates that this function is an accessor (getter or setter).
6386   DECL_BOOLEAN_ACCESSORS(is_accessor_function)
6387
6388   // Indicates that this function is a default constructor.
6389   DECL_BOOLEAN_ACCESSORS(is_default_constructor)
6390
6391   // Indicates that this function is an asm function.
6392   DECL_BOOLEAN_ACCESSORS(asm_function)
6393
6394   // Indicates that the the shared function info is deserialized from cache.
6395   DECL_BOOLEAN_ACCESSORS(deserialized)
6396
6397   // Indicates that the the shared function info has never been compiled before.
6398   DECL_BOOLEAN_ACCESSORS(never_compiled)
6399
6400   inline FunctionKind kind();
6401   inline void set_kind(FunctionKind kind);
6402
6403   // Indicates whether or not the code in the shared function support
6404   // deoptimization.
6405   inline bool has_deoptimization_support();
6406
6407   // Enable deoptimization support through recompiled code.
6408   void EnableDeoptimizationSupport(Code* recompiled);
6409
6410   // Disable (further) attempted optimization of all functions sharing this
6411   // shared function info.
6412   void DisableOptimization(BailoutReason reason);
6413
6414   inline BailoutReason disable_optimization_reason();
6415
6416   // Lookup the bailout ID and DCHECK that it exists in the non-optimized
6417   // code, returns whether it asserted (i.e., always true if assertions are
6418   // disabled).
6419   bool VerifyBailoutId(BailoutId id);
6420
6421   // [source code]: Source code for the function.
6422   bool HasSourceCode() const;
6423   Handle<Object> GetSourceCode();
6424
6425   // Number of times the function was optimized.
6426   inline int opt_count();
6427   inline void set_opt_count(int opt_count);
6428
6429   // Number of times the function was deoptimized.
6430   inline void set_deopt_count(int value);
6431   inline int deopt_count();
6432   inline void increment_deopt_count();
6433
6434   // Number of time we tried to re-enable optimization after it
6435   // was disabled due to high number of deoptimizations.
6436   inline void set_opt_reenable_tries(int value);
6437   inline int opt_reenable_tries();
6438
6439   inline void TryReenableOptimization();
6440
6441   // Stores deopt_count, opt_reenable_tries and ic_age as bit-fields.
6442   inline void set_counters(int value);
6443   inline int counters() const;
6444
6445   // Stores opt_count and bailout_reason as bit-fields.
6446   inline void set_opt_count_and_bailout_reason(int value);
6447   inline int opt_count_and_bailout_reason() const;
6448
6449   inline void set_disable_optimization_reason(BailoutReason reason);
6450
6451   // Tells whether this function should be subject to debugging.
6452   inline bool IsSubjectToDebugging();
6453
6454   // Whether this function is defined in native code or extensions.
6455   inline bool IsBuiltin();
6456
6457   // Check whether or not this function is inlineable.
6458   bool IsInlineable();
6459
6460   // Source size of this function.
6461   int SourceSize();
6462
6463   // Calculate the instance size.
6464   int CalculateInstanceSize();
6465
6466   // Calculate the number of in-object properties.
6467   int CalculateInObjectProperties();
6468
6469   inline bool has_simple_parameters();
6470
6471   // Initialize a SharedFunctionInfo from a parsed function literal.
6472   static void InitFromFunctionLiteral(Handle<SharedFunctionInfo> shared_info,
6473                                       FunctionLiteral* lit);
6474
6475   // Dispatched behavior.
6476   DECLARE_PRINTER(SharedFunctionInfo)
6477   DECLARE_VERIFIER(SharedFunctionInfo)
6478
6479   void ResetForNewContext(int new_ic_age);
6480
6481   // Iterate over all shared function infos that are created from a script.
6482   // That excludes shared function infos created for API functions and C++
6483   // builtins.
6484   class Iterator {
6485    public:
6486     explicit Iterator(Isolate* isolate);
6487     SharedFunctionInfo* Next();
6488
6489    private:
6490     bool NextScript();
6491
6492     Script::Iterator script_iterator_;
6493     WeakFixedArray::Iterator sfi_iterator_;
6494     DisallowHeapAllocation no_gc_;
6495     DISALLOW_COPY_AND_ASSIGN(Iterator);
6496   };
6497
6498   DECLARE_CAST(SharedFunctionInfo)
6499
6500   // Constants.
6501   static const int kDontAdaptArgumentsSentinel = -1;
6502
6503   // Layout description.
6504   // Pointer fields.
6505   static const int kNameOffset = HeapObject::kHeaderSize;
6506   static const int kCodeOffset = kNameOffset + kPointerSize;
6507   static const int kOptimizedCodeMapOffset = kCodeOffset + kPointerSize;
6508   static const int kScopeInfoOffset = kOptimizedCodeMapOffset + kPointerSize;
6509   static const int kConstructStubOffset = kScopeInfoOffset + kPointerSize;
6510   static const int kInstanceClassNameOffset =
6511       kConstructStubOffset + kPointerSize;
6512   static const int kFunctionDataOffset =
6513       kInstanceClassNameOffset + kPointerSize;
6514   static const int kScriptOffset = kFunctionDataOffset + kPointerSize;
6515   static const int kDebugInfoOffset = kScriptOffset + kPointerSize;
6516   static const int kInferredNameOffset = kDebugInfoOffset + kPointerSize;
6517   static const int kFeedbackVectorOffset =
6518       kInferredNameOffset + kPointerSize;
6519 #if TRACE_MAPS
6520   static const int kUniqueIdOffset = kFeedbackVectorOffset + kPointerSize;
6521   static const int kLastPointerFieldOffset = kUniqueIdOffset;
6522 #else
6523   // Just to not break the postmortrem support with conditional offsets
6524   static const int kUniqueIdOffset = kFeedbackVectorOffset;
6525   static const int kLastPointerFieldOffset = kFeedbackVectorOffset;
6526 #endif
6527
6528 #if V8_HOST_ARCH_32_BIT
6529   // Smi fields.
6530   static const int kLengthOffset = kLastPointerFieldOffset + kPointerSize;
6531   static const int kFormalParameterCountOffset = kLengthOffset + kPointerSize;
6532   static const int kExpectedNofPropertiesOffset =
6533       kFormalParameterCountOffset + kPointerSize;
6534   static const int kNumLiteralsOffset =
6535       kExpectedNofPropertiesOffset + kPointerSize;
6536   static const int kStartPositionAndTypeOffset =
6537       kNumLiteralsOffset + kPointerSize;
6538   static const int kEndPositionOffset =
6539       kStartPositionAndTypeOffset + kPointerSize;
6540   static const int kFunctionTokenPositionOffset =
6541       kEndPositionOffset + kPointerSize;
6542   static const int kCompilerHintsOffset =
6543       kFunctionTokenPositionOffset + kPointerSize;
6544   static const int kOptCountAndBailoutReasonOffset =
6545       kCompilerHintsOffset + kPointerSize;
6546   static const int kCountersOffset =
6547       kOptCountAndBailoutReasonOffset + kPointerSize;
6548   static const int kAstNodeCountOffset =
6549       kCountersOffset + kPointerSize;
6550   static const int kProfilerTicksOffset =
6551       kAstNodeCountOffset + kPointerSize;
6552
6553   // Total size.
6554   static const int kSize = kProfilerTicksOffset + kPointerSize;
6555 #else
6556   // The only reason to use smi fields instead of int fields
6557   // is to allow iteration without maps decoding during
6558   // garbage collections.
6559   // To avoid wasting space on 64-bit architectures we use
6560   // the following trick: we group integer fields into pairs
6561 // The least significant integer in each pair is shifted left by 1.
6562 // By doing this we guarantee that LSB of each kPointerSize aligned
6563 // word is not set and thus this word cannot be treated as pointer
6564 // to HeapObject during old space traversal.
6565 #if V8_TARGET_LITTLE_ENDIAN
6566   static const int kLengthOffset = kLastPointerFieldOffset + kPointerSize;
6567   static const int kFormalParameterCountOffset =
6568       kLengthOffset + kIntSize;
6569
6570   static const int kExpectedNofPropertiesOffset =
6571       kFormalParameterCountOffset + kIntSize;
6572   static const int kNumLiteralsOffset =
6573       kExpectedNofPropertiesOffset + kIntSize;
6574
6575   static const int kEndPositionOffset =
6576       kNumLiteralsOffset + kIntSize;
6577   static const int kStartPositionAndTypeOffset =
6578       kEndPositionOffset + kIntSize;
6579
6580   static const int kFunctionTokenPositionOffset =
6581       kStartPositionAndTypeOffset + kIntSize;
6582   static const int kCompilerHintsOffset =
6583       kFunctionTokenPositionOffset + kIntSize;
6584
6585   static const int kOptCountAndBailoutReasonOffset =
6586       kCompilerHintsOffset + kIntSize;
6587   static const int kCountersOffset =
6588       kOptCountAndBailoutReasonOffset + kIntSize;
6589
6590   static const int kAstNodeCountOffset =
6591       kCountersOffset + kIntSize;
6592   static const int kProfilerTicksOffset =
6593       kAstNodeCountOffset + kIntSize;
6594
6595   // Total size.
6596   static const int kSize = kProfilerTicksOffset + kIntSize;
6597
6598 #elif V8_TARGET_BIG_ENDIAN
6599   static const int kFormalParameterCountOffset =
6600       kLastPointerFieldOffset + kPointerSize;
6601   static const int kLengthOffset = kFormalParameterCountOffset + kIntSize;
6602
6603   static const int kNumLiteralsOffset = kLengthOffset + kIntSize;
6604   static const int kExpectedNofPropertiesOffset = kNumLiteralsOffset + kIntSize;
6605
6606   static const int kStartPositionAndTypeOffset =
6607       kExpectedNofPropertiesOffset + kIntSize;
6608   static const int kEndPositionOffset = kStartPositionAndTypeOffset + kIntSize;
6609
6610   static const int kCompilerHintsOffset = kEndPositionOffset + kIntSize;
6611   static const int kFunctionTokenPositionOffset =
6612       kCompilerHintsOffset + kIntSize;
6613
6614   static const int kCountersOffset = kFunctionTokenPositionOffset + kIntSize;
6615   static const int kOptCountAndBailoutReasonOffset = kCountersOffset + kIntSize;
6616
6617   static const int kProfilerTicksOffset =
6618       kOptCountAndBailoutReasonOffset + kIntSize;
6619   static const int kAstNodeCountOffset = kProfilerTicksOffset + kIntSize;
6620
6621   // Total size.
6622   static const int kSize = kAstNodeCountOffset + kIntSize;
6623
6624 #else
6625 #error Unknown byte ordering
6626 #endif  // Big endian
6627 #endif  // 64-bit
6628
6629
6630   static const int kAlignedSize = POINTER_SIZE_ALIGN(kSize);
6631
6632   typedef FixedBodyDescriptor<kNameOffset,
6633                               kLastPointerFieldOffset + kPointerSize,
6634                               kSize> BodyDescriptor;
6635
6636   // Bit positions in start_position_and_type.
6637   // The source code start position is in the 30 most significant bits of
6638   // the start_position_and_type field.
6639   static const int kIsExpressionBit    = 0;
6640   static const int kIsTopLevelBit      = 1;
6641   static const int kStartPositionShift = 2;
6642   static const int kStartPositionMask  = ~((1 << kStartPositionShift) - 1);
6643
6644   // Bit positions in compiler_hints.
6645   enum CompilerHints {
6646     kAllowLazyCompilation,
6647     kAllowLazyCompilationWithoutContext,
6648     kOptimizationDisabled,
6649     kStrictModeFunction,
6650     kStrongModeFunction,
6651     kUsesArguments,
6652     kNeedsHomeObject,
6653     kHasDuplicateParameters,
6654     kNative,
6655     kForceInline,
6656     kBoundFunction,
6657     kIsAnonymous,
6658     kNameShouldPrintAsAnonymous,
6659     kIsFunction,
6660     kDontCrankshaft,
6661     kDontFlush,
6662     kIsArrow,
6663     kIsGenerator,
6664     kIsConciseMethod,
6665     kIsAccessorFunction,
6666     kIsDefaultConstructor,
6667     kIsSubclassConstructor,
6668     kIsBaseConstructor,
6669     kInClassLiteral,
6670     kIsAsmFunction,
6671     kDeserialized,
6672     kNeverCompiled,
6673     kCompilerHintsCount  // Pseudo entry
6674   };
6675   // Add hints for other modes when they're added.
6676   STATIC_ASSERT(LANGUAGE_END == 3);
6677
6678   class FunctionKindBits : public BitField<FunctionKind, kIsArrow, 8> {};
6679
6680   class DeoptCountBits : public BitField<int, 0, 4> {};
6681   class OptReenableTriesBits : public BitField<int, 4, 18> {};
6682   class ICAgeBits : public BitField<int, 22, 8> {};
6683
6684   class OptCountBits : public BitField<int, 0, 22> {};
6685   class DisabledOptimizationReasonBits : public BitField<int, 22, 8> {};
6686
6687  private:
6688 #if V8_HOST_ARCH_32_BIT
6689   // On 32 bit platforms, compiler hints is a smi.
6690   static const int kCompilerHintsSmiTagSize = kSmiTagSize;
6691   static const int kCompilerHintsSize = kPointerSize;
6692 #else
6693   // On 64 bit platforms, compiler hints is not a smi, see comment above.
6694   static const int kCompilerHintsSmiTagSize = 0;
6695   static const int kCompilerHintsSize = kIntSize;
6696 #endif
6697
6698   STATIC_ASSERT(SharedFunctionInfo::kCompilerHintsCount <=
6699                 SharedFunctionInfo::kCompilerHintsSize * kBitsPerByte);
6700
6701  public:
6702   // Constants for optimizing codegen for strict mode function and
6703   // native tests.
6704   // Allows to use byte-width instructions.
6705   static const int kStrictModeBitWithinByte =
6706       (kStrictModeFunction + kCompilerHintsSmiTagSize) % kBitsPerByte;
6707   static const int kStrongModeBitWithinByte =
6708       (kStrongModeFunction + kCompilerHintsSmiTagSize) % kBitsPerByte;
6709
6710   static const int kNativeBitWithinByte =
6711       (kNative + kCompilerHintsSmiTagSize) % kBitsPerByte;
6712
6713   static const int kBoundBitWithinByte =
6714       (kBoundFunction + kCompilerHintsSmiTagSize) % kBitsPerByte;
6715
6716 #if defined(V8_TARGET_LITTLE_ENDIAN)
6717   static const int kStrictModeByteOffset = kCompilerHintsOffset +
6718       (kStrictModeFunction + kCompilerHintsSmiTagSize) / kBitsPerByte;
6719   static const int kStrongModeByteOffset =
6720       kCompilerHintsOffset +
6721       (kStrongModeFunction + kCompilerHintsSmiTagSize) / kBitsPerByte;
6722   static const int kNativeByteOffset = kCompilerHintsOffset +
6723       (kNative + kCompilerHintsSmiTagSize) / kBitsPerByte;
6724   static const int kBoundByteOffset =
6725       kCompilerHintsOffset +
6726       (kBoundFunction + kCompilerHintsSmiTagSize) / kBitsPerByte;
6727 #elif defined(V8_TARGET_BIG_ENDIAN)
6728   static const int kStrictModeByteOffset = kCompilerHintsOffset +
6729       (kCompilerHintsSize - 1) -
6730       ((kStrictModeFunction + kCompilerHintsSmiTagSize) / kBitsPerByte);
6731   static const int kStrongModeByteOffset =
6732       kCompilerHintsOffset + (kCompilerHintsSize - 1) -
6733       ((kStrongModeFunction + kCompilerHintsSmiTagSize) / kBitsPerByte);
6734   static const int kNativeByteOffset = kCompilerHintsOffset +
6735       (kCompilerHintsSize - 1) -
6736       ((kNative + kCompilerHintsSmiTagSize) / kBitsPerByte);
6737   static const int kBoundByteOffset =
6738       kCompilerHintsOffset + (kCompilerHintsSize - 1) -
6739       ((kBoundFunction + kCompilerHintsSmiTagSize) / kBitsPerByte);
6740 #else
6741 #error Unknown byte ordering
6742 #endif
6743
6744  private:
6745   DISALLOW_IMPLICIT_CONSTRUCTORS(SharedFunctionInfo);
6746 };
6747
6748
6749 // Printing support.
6750 struct SourceCodeOf {
6751   explicit SourceCodeOf(SharedFunctionInfo* v, int max = -1)
6752       : value(v), max_length(max) {}
6753   const SharedFunctionInfo* value;
6754   int max_length;
6755 };
6756
6757
6758 std::ostream& operator<<(std::ostream& os, const SourceCodeOf& v);
6759
6760
6761 class JSGeneratorObject: public JSObject {
6762  public:
6763   // [function]: The function corresponding to this generator object.
6764   DECL_ACCESSORS(function, JSFunction)
6765
6766   // [context]: The context of the suspended computation.
6767   DECL_ACCESSORS(context, Context)
6768
6769   // [receiver]: The receiver of the suspended computation.
6770   DECL_ACCESSORS(receiver, Object)
6771
6772   // [continuation]: Offset into code of continuation.
6773   //
6774   // A positive offset indicates a suspended generator.  The special
6775   // kGeneratorExecuting and kGeneratorClosed values indicate that a generator
6776   // cannot be resumed.
6777   inline int continuation() const;
6778   inline void set_continuation(int continuation);
6779   inline bool is_closed();
6780   inline bool is_executing();
6781   inline bool is_suspended();
6782
6783   // [operand_stack]: Saved operand stack.
6784   DECL_ACCESSORS(operand_stack, FixedArray)
6785
6786   DECLARE_CAST(JSGeneratorObject)
6787
6788   // Dispatched behavior.
6789   DECLARE_PRINTER(JSGeneratorObject)
6790   DECLARE_VERIFIER(JSGeneratorObject)
6791
6792   // Magic sentinel values for the continuation.
6793   static const int kGeneratorExecuting = -1;
6794   static const int kGeneratorClosed = 0;
6795
6796   // Layout description.
6797   static const int kFunctionOffset = JSObject::kHeaderSize;
6798   static const int kContextOffset = kFunctionOffset + kPointerSize;
6799   static const int kReceiverOffset = kContextOffset + kPointerSize;
6800   static const int kContinuationOffset = kReceiverOffset + kPointerSize;
6801   static const int kOperandStackOffset = kContinuationOffset + kPointerSize;
6802   static const int kSize = kOperandStackOffset + kPointerSize;
6803
6804   // Resume mode, for use by runtime functions.
6805   enum ResumeMode { NEXT, THROW };
6806
6807   // Yielding from a generator returns an object with the following inobject
6808   // properties.  See Context::iterator_result_map() for the map.
6809   static const int kResultValuePropertyIndex = 0;
6810   static const int kResultDonePropertyIndex = 1;
6811   static const int kResultPropertyCount = 2;
6812
6813   static const int kResultValuePropertyOffset = JSObject::kHeaderSize;
6814   static const int kResultDonePropertyOffset =
6815       kResultValuePropertyOffset + kPointerSize;
6816   static const int kResultSize = kResultDonePropertyOffset + kPointerSize;
6817
6818  private:
6819   DISALLOW_IMPLICIT_CONSTRUCTORS(JSGeneratorObject);
6820 };
6821
6822
6823 // Representation for module instance objects.
6824 class JSModule: public JSObject {
6825  public:
6826   // [context]: the context holding the module's locals, or undefined if none.
6827   DECL_ACCESSORS(context, Object)
6828
6829   // [scope_info]: Scope info.
6830   DECL_ACCESSORS(scope_info, ScopeInfo)
6831
6832   DECLARE_CAST(JSModule)
6833
6834   // Dispatched behavior.
6835   DECLARE_PRINTER(JSModule)
6836   DECLARE_VERIFIER(JSModule)
6837
6838   // Layout description.
6839   static const int kContextOffset = JSObject::kHeaderSize;
6840   static const int kScopeInfoOffset = kContextOffset + kPointerSize;
6841   static const int kSize = kScopeInfoOffset + kPointerSize;
6842
6843  private:
6844   DISALLOW_IMPLICIT_CONSTRUCTORS(JSModule);
6845 };
6846
6847
6848 // JSFunction describes JavaScript functions.
6849 class JSFunction: public JSObject {
6850  public:
6851   // [prototype_or_initial_map]:
6852   DECL_ACCESSORS(prototype_or_initial_map, Object)
6853
6854   // [shared]: The information about the function that
6855   // can be shared by instances.
6856   DECL_ACCESSORS(shared, SharedFunctionInfo)
6857
6858   // [context]: The context for this function.
6859   inline Context* context();
6860   inline void set_context(Object* context);
6861   inline JSObject* global_proxy();
6862
6863   // [code]: The generated code object for this function.  Executed
6864   // when the function is invoked, e.g. foo() or new foo(). See
6865   // [[Call]] and [[Construct]] description in ECMA-262, section
6866   // 8.6.2, page 27.
6867   inline Code* code();
6868   inline void set_code(Code* code);
6869   inline void set_code_no_write_barrier(Code* code);
6870   inline void ReplaceCode(Code* code);
6871
6872   // Tells whether this function is builtin.
6873   inline bool IsBuiltin();
6874
6875   // Tells whether this function inlines the given shared function info.
6876   bool Inlines(SharedFunctionInfo* candidate);
6877
6878   // Tells whether this function should be subject to debugging.
6879   inline bool IsSubjectToDebugging();
6880
6881   // Tells whether or not the function needs arguments adaption.
6882   inline bool NeedsArgumentsAdaption();
6883
6884   // Tells whether or not this function has been optimized.
6885   inline bool IsOptimized();
6886
6887   // Mark this function for lazy recompilation. The function will be
6888   // recompiled the next time it is executed.
6889   void MarkForOptimization();
6890   void AttemptConcurrentOptimization();
6891
6892   // Tells whether or not the function is already marked for lazy
6893   // recompilation.
6894   inline bool IsMarkedForOptimization();
6895   inline bool IsMarkedForConcurrentOptimization();
6896
6897   // Tells whether or not the function is on the concurrent recompilation queue.
6898   inline bool IsInOptimizationQueue();
6899
6900   // Inobject slack tracking is the way to reclaim unused inobject space.
6901   //
6902   // The instance size is initially determined by adding some slack to
6903   // expected_nof_properties (to allow for a few extra properties added
6904   // after the constructor). There is no guarantee that the extra space
6905   // will not be wasted.
6906   //
6907   // Here is the algorithm to reclaim the unused inobject space:
6908   // - Detect the first constructor call for this JSFunction.
6909   //   When it happens enter the "in progress" state: initialize construction
6910   //   counter in the initial_map.
6911   // - While the tracking is in progress create objects filled with
6912   //   one_pointer_filler_map instead of undefined_value. This way they can be
6913   //   resized quickly and safely.
6914   // - Once enough objects have been created  compute the 'slack'
6915   //   (traverse the map transition tree starting from the
6916   //   initial_map and find the lowest value of unused_property_fields).
6917   // - Traverse the transition tree again and decrease the instance size
6918   //   of every map. Existing objects will resize automatically (they are
6919   //   filled with one_pointer_filler_map). All further allocations will
6920   //   use the adjusted instance size.
6921   // - SharedFunctionInfo's expected_nof_properties left unmodified since
6922   //   allocations made using different closures could actually create different
6923   //   kind of objects (see prototype inheritance pattern).
6924   //
6925   //  Important: inobject slack tracking is not attempted during the snapshot
6926   //  creation.
6927
6928   // True if the initial_map is set and the object constructions countdown
6929   // counter is not zero.
6930   static const int kGenerousAllocationCount =
6931       Map::kSlackTrackingCounterStart - Map::kSlackTrackingCounterEnd + 1;
6932   inline bool IsInobjectSlackTrackingInProgress();
6933
6934   // Starts the tracking.
6935   // Initializes object constructions countdown counter in the initial map.
6936   void StartInobjectSlackTracking();
6937
6938   // Completes the tracking.
6939   void CompleteInobjectSlackTracking();
6940
6941   // [literals_or_bindings]: Fixed array holding either
6942   // the materialized literals or the bindings of a bound function.
6943   //
6944   // If the function contains object, regexp or array literals, the
6945   // literals array prefix contains the object, regexp, and array
6946   // function to be used when creating these literals.  This is
6947   // necessary so that we do not dynamically lookup the object, regexp
6948   // or array functions.  Performing a dynamic lookup, we might end up
6949   // using the functions from a new context that we should not have
6950   // access to.
6951   //
6952   // On bound functions, the array is a (copy-on-write) fixed-array containing
6953   // the function that was bound, bound this-value and any bound
6954   // arguments. Bound functions never contain literals.
6955   DECL_ACCESSORS(literals_or_bindings, FixedArray)
6956
6957   inline FixedArray* literals();
6958   inline void set_literals(FixedArray* literals);
6959
6960   inline FixedArray* function_bindings();
6961   inline void set_function_bindings(FixedArray* bindings);
6962
6963   // The initial map for an object created by this constructor.
6964   inline Map* initial_map();
6965   static void SetInitialMap(Handle<JSFunction> function, Handle<Map> map,
6966                             Handle<Object> prototype);
6967   inline bool has_initial_map();
6968   static void EnsureHasInitialMap(Handle<JSFunction> function);
6969
6970   // Get and set the prototype property on a JSFunction. If the
6971   // function has an initial map the prototype is set on the initial
6972   // map. Otherwise, the prototype is put in the initial map field
6973   // until an initial map is needed.
6974   inline bool has_prototype();
6975   inline bool has_instance_prototype();
6976   inline Object* prototype();
6977   inline Object* instance_prototype();
6978   static void SetPrototype(Handle<JSFunction> function,
6979                            Handle<Object> value);
6980   static void SetInstancePrototype(Handle<JSFunction> function,
6981                                    Handle<Object> value);
6982
6983   // Creates a new closure for the fucntion with the same bindings,
6984   // bound values, and prototype. An equivalent of spec operations
6985   // ``CloneMethod`` and ``CloneBoundFunction``.
6986   static Handle<JSFunction> CloneClosure(Handle<JSFunction> function);
6987
6988   // After prototype is removed, it will not be created when accessed, and
6989   // [[Construct]] from this function will not be allowed.
6990   bool RemovePrototype();
6991   inline bool should_have_prototype();
6992
6993   // Accessor for this function's initial map's [[class]]
6994   // property. This is primarily used by ECMA native functions.  This
6995   // method sets the class_name field of this function's initial map
6996   // to a given value. It creates an initial map if this function does
6997   // not have one. Note that this method does not copy the initial map
6998   // if it has one already, but simply replaces it with the new value.
6999   // Instances created afterwards will have a map whose [[class]] is
7000   // set to 'value', but there is no guarantees on instances created
7001   // before.
7002   void SetInstanceClassName(String* name);
7003
7004   // Returns if this function has been compiled to native code yet.
7005   inline bool is_compiled();
7006
7007   // Returns `false` if formal parameters include rest parameters, optional
7008   // parameters, or destructuring parameters.
7009   // TODO(caitp): make this a flag set during parsing
7010   inline bool has_simple_parameters();
7011
7012   // [next_function_link]: Links functions into various lists, e.g. the list
7013   // of optimized functions hanging off the native_context. The CodeFlusher
7014   // uses this link to chain together flushing candidates. Treated weakly
7015   // by the garbage collector.
7016   DECL_ACCESSORS(next_function_link, Object)
7017
7018   // Prints the name of the function using PrintF.
7019   void PrintName(FILE* out = stdout);
7020
7021   DECLARE_CAST(JSFunction)
7022
7023   // Iterates the objects, including code objects indirectly referenced
7024   // through pointers to the first instruction in the code object.
7025   void JSFunctionIterateBody(int object_size, ObjectVisitor* v);
7026
7027   // Dispatched behavior.
7028   DECLARE_PRINTER(JSFunction)
7029   DECLARE_VERIFIER(JSFunction)
7030
7031   // Returns the number of allocated literals.
7032   inline int NumberOfLiterals();
7033
7034   // Used for flags such as --hydrogen-filter.
7035   bool PassesFilter(const char* raw_filter);
7036
7037   // The function's name if it is configured, otherwise shared function info
7038   // debug name.
7039   static Handle<String> GetDebugName(Handle<JSFunction> function);
7040
7041   // Layout descriptors. The last property (from kNonWeakFieldsEndOffset to
7042   // kSize) is weak and has special handling during garbage collection.
7043   static const int kCodeEntryOffset = JSObject::kHeaderSize;
7044   static const int kPrototypeOrInitialMapOffset =
7045       kCodeEntryOffset + kPointerSize;
7046   static const int kSharedFunctionInfoOffset =
7047       kPrototypeOrInitialMapOffset + kPointerSize;
7048   static const int kContextOffset = kSharedFunctionInfoOffset + kPointerSize;
7049   static const int kLiteralsOffset = kContextOffset + kPointerSize;
7050   static const int kNonWeakFieldsEndOffset = kLiteralsOffset + kPointerSize;
7051   static const int kNextFunctionLinkOffset = kNonWeakFieldsEndOffset;
7052   static const int kSize = kNextFunctionLinkOffset + kPointerSize;
7053
7054   // Layout of the bound-function binding array.
7055   static const int kBoundFunctionIndex = 0;
7056   static const int kBoundThisIndex = 1;
7057   static const int kBoundArgumentsStartIndex = 2;
7058
7059  private:
7060   DISALLOW_IMPLICIT_CONSTRUCTORS(JSFunction);
7061 };
7062
7063
7064 // JSGlobalProxy's prototype must be a JSGlobalObject or null,
7065 // and the prototype is hidden. JSGlobalProxy always delegates
7066 // property accesses to its prototype if the prototype is not null.
7067 //
7068 // A JSGlobalProxy can be reinitialized which will preserve its identity.
7069 //
7070 // Accessing a JSGlobalProxy requires security check.
7071
7072 class JSGlobalProxy : public JSObject {
7073  public:
7074   // [native_context]: the owner native context of this global proxy object.
7075   // It is null value if this object is not used by any context.
7076   DECL_ACCESSORS(native_context, Object)
7077
7078   // [hash]: The hash code property (undefined if not initialized yet).
7079   DECL_ACCESSORS(hash, Object)
7080
7081   DECLARE_CAST(JSGlobalProxy)
7082
7083   inline bool IsDetachedFrom(GlobalObject* global) const;
7084
7085   // Dispatched behavior.
7086   DECLARE_PRINTER(JSGlobalProxy)
7087   DECLARE_VERIFIER(JSGlobalProxy)
7088
7089   // Layout description.
7090   static const int kNativeContextOffset = JSObject::kHeaderSize;
7091   static const int kHashOffset = kNativeContextOffset + kPointerSize;
7092   static const int kSize = kHashOffset + kPointerSize;
7093
7094  private:
7095   DISALLOW_IMPLICIT_CONSTRUCTORS(JSGlobalProxy);
7096 };
7097
7098
7099 // Common super class for JavaScript global objects and the special
7100 // builtins global objects.
7101 class GlobalObject: public JSObject {
7102  public:
7103   // [builtins]: the object holding the runtime routines written in JS.
7104   DECL_ACCESSORS(builtins, JSBuiltinsObject)
7105
7106   // [native context]: the natives corresponding to this global object.
7107   DECL_ACCESSORS(native_context, Context)
7108
7109   // [global proxy]: the global proxy object of the context
7110   DECL_ACCESSORS(global_proxy, JSObject)
7111
7112   DECLARE_CAST(GlobalObject)
7113
7114   static void InvalidatePropertyCell(Handle<GlobalObject> object,
7115                                      Handle<Name> name);
7116   // Ensure that the global object has a cell for the given property name.
7117   static Handle<PropertyCell> EnsurePropertyCell(Handle<GlobalObject> global,
7118                                                  Handle<Name> name);
7119
7120   // Layout description.
7121   static const int kBuiltinsOffset = JSObject::kHeaderSize;
7122   static const int kNativeContextOffset = kBuiltinsOffset + kPointerSize;
7123   static const int kGlobalProxyOffset = kNativeContextOffset + kPointerSize;
7124   static const int kHeaderSize = kGlobalProxyOffset + kPointerSize;
7125
7126  private:
7127   DISALLOW_IMPLICIT_CONSTRUCTORS(GlobalObject);
7128 };
7129
7130
7131 // JavaScript global object.
7132 class JSGlobalObject: public GlobalObject {
7133  public:
7134   DECLARE_CAST(JSGlobalObject)
7135
7136   inline bool IsDetached();
7137
7138   // Dispatched behavior.
7139   DECLARE_PRINTER(JSGlobalObject)
7140   DECLARE_VERIFIER(JSGlobalObject)
7141
7142   // Layout description.
7143   static const int kSize = GlobalObject::kHeaderSize;
7144
7145  private:
7146   DISALLOW_IMPLICIT_CONSTRUCTORS(JSGlobalObject);
7147 };
7148
7149
7150 // Builtins global object which holds the runtime routines written in
7151 // JavaScript.
7152 class JSBuiltinsObject: public GlobalObject {
7153  public:
7154   // Accessors for the runtime routines written in JavaScript.
7155   inline Object* javascript_builtin(Builtins::JavaScript id);
7156   inline void set_javascript_builtin(Builtins::JavaScript id, Object* value);
7157
7158   DECLARE_CAST(JSBuiltinsObject)
7159
7160   // Dispatched behavior.
7161   DECLARE_PRINTER(JSBuiltinsObject)
7162   DECLARE_VERIFIER(JSBuiltinsObject)
7163
7164   // Layout description.  The size of the builtins object includes
7165   // room for two pointers per runtime routine written in javascript
7166   // (function and code object).
7167   static const int kJSBuiltinsCount = Builtins::id_count;
7168   static const int kJSBuiltinsOffset = GlobalObject::kHeaderSize;
7169   static const int kSize =
7170       GlobalObject::kHeaderSize + (kJSBuiltinsCount * kPointerSize);
7171
7172   static int OffsetOfFunctionWithId(Builtins::JavaScript id) {
7173     return kJSBuiltinsOffset + id * kPointerSize;
7174   }
7175
7176  private:
7177   DISALLOW_IMPLICIT_CONSTRUCTORS(JSBuiltinsObject);
7178 };
7179
7180
7181 // Representation for JS Wrapper objects, String, Number, Boolean, etc.
7182 class JSValue: public JSObject {
7183  public:
7184   // [value]: the object being wrapped.
7185   DECL_ACCESSORS(value, Object)
7186
7187   DECLARE_CAST(JSValue)
7188
7189   // Dispatched behavior.
7190   DECLARE_PRINTER(JSValue)
7191   DECLARE_VERIFIER(JSValue)
7192
7193   // Layout description.
7194   static const int kValueOffset = JSObject::kHeaderSize;
7195   static const int kSize = kValueOffset + kPointerSize;
7196
7197  private:
7198   DISALLOW_IMPLICIT_CONSTRUCTORS(JSValue);
7199 };
7200
7201
7202 class DateCache;
7203
7204 // Representation for JS date objects.
7205 class JSDate: public JSObject {
7206  public:
7207   // If one component is NaN, all of them are, indicating a NaN time value.
7208   // [value]: the time value.
7209   DECL_ACCESSORS(value, Object)
7210   // [year]: caches year. Either undefined, smi, or NaN.
7211   DECL_ACCESSORS(year, Object)
7212   // [month]: caches month. Either undefined, smi, or NaN.
7213   DECL_ACCESSORS(month, Object)
7214   // [day]: caches day. Either undefined, smi, or NaN.
7215   DECL_ACCESSORS(day, Object)
7216   // [weekday]: caches day of week. Either undefined, smi, or NaN.
7217   DECL_ACCESSORS(weekday, Object)
7218   // [hour]: caches hours. Either undefined, smi, or NaN.
7219   DECL_ACCESSORS(hour, Object)
7220   // [min]: caches minutes. Either undefined, smi, or NaN.
7221   DECL_ACCESSORS(min, Object)
7222   // [sec]: caches seconds. Either undefined, smi, or NaN.
7223   DECL_ACCESSORS(sec, Object)
7224   // [cache stamp]: sample of the date cache stamp at the
7225   // moment when chached fields were cached.
7226   DECL_ACCESSORS(cache_stamp, Object)
7227
7228   DECLARE_CAST(JSDate)
7229
7230   // Returns the date field with the specified index.
7231   // See FieldIndex for the list of date fields.
7232   static Object* GetField(Object* date, Smi* index);
7233
7234   void SetValue(Object* value, bool is_value_nan);
7235
7236
7237   // Dispatched behavior.
7238   DECLARE_PRINTER(JSDate)
7239   DECLARE_VERIFIER(JSDate)
7240
7241   // The order is important. It must be kept in sync with date macros
7242   // in macros.py.
7243   enum FieldIndex {
7244     kDateValue,
7245     kYear,
7246     kMonth,
7247     kDay,
7248     kWeekday,
7249     kHour,
7250     kMinute,
7251     kSecond,
7252     kFirstUncachedField,
7253     kMillisecond = kFirstUncachedField,
7254     kDays,
7255     kTimeInDay,
7256     kFirstUTCField,
7257     kYearUTC = kFirstUTCField,
7258     kMonthUTC,
7259     kDayUTC,
7260     kWeekdayUTC,
7261     kHourUTC,
7262     kMinuteUTC,
7263     kSecondUTC,
7264     kMillisecondUTC,
7265     kDaysUTC,
7266     kTimeInDayUTC,
7267     kTimezoneOffset
7268   };
7269
7270   // Layout description.
7271   static const int kValueOffset = JSObject::kHeaderSize;
7272   static const int kYearOffset = kValueOffset + kPointerSize;
7273   static const int kMonthOffset = kYearOffset + kPointerSize;
7274   static const int kDayOffset = kMonthOffset + kPointerSize;
7275   static const int kWeekdayOffset = kDayOffset + kPointerSize;
7276   static const int kHourOffset = kWeekdayOffset  + kPointerSize;
7277   static const int kMinOffset = kHourOffset + kPointerSize;
7278   static const int kSecOffset = kMinOffset + kPointerSize;
7279   static const int kCacheStampOffset = kSecOffset + kPointerSize;
7280   static const int kSize = kCacheStampOffset + kPointerSize;
7281
7282  private:
7283   inline Object* DoGetField(FieldIndex index);
7284
7285   Object* GetUTCField(FieldIndex index, double value, DateCache* date_cache);
7286
7287   // Computes and caches the cacheable fields of the date.
7288   inline void SetCachedFields(int64_t local_time_ms, DateCache* date_cache);
7289
7290
7291   DISALLOW_IMPLICIT_CONSTRUCTORS(JSDate);
7292 };
7293
7294
7295 // Representation of message objects used for error reporting through
7296 // the API. The messages are formatted in JavaScript so this object is
7297 // a real JavaScript object. The information used for formatting the
7298 // error messages are not directly accessible from JavaScript to
7299 // prevent leaking information to user code called during error
7300 // formatting.
7301 class JSMessageObject: public JSObject {
7302  public:
7303   // [type]: the type of error message.
7304   inline int type() const;
7305   inline void set_type(int value);
7306
7307   // [arguments]: the arguments for formatting the error message.
7308   DECL_ACCESSORS(argument, Object)
7309
7310   // [script]: the script from which the error message originated.
7311   DECL_ACCESSORS(script, Object)
7312
7313   // [stack_frames]: an array of stack frames for this error object.
7314   DECL_ACCESSORS(stack_frames, Object)
7315
7316   // [start_position]: the start position in the script for the error message.
7317   inline int start_position() const;
7318   inline void set_start_position(int value);
7319
7320   // [end_position]: the end position in the script for the error message.
7321   inline int end_position() const;
7322   inline void set_end_position(int value);
7323
7324   DECLARE_CAST(JSMessageObject)
7325
7326   // Dispatched behavior.
7327   DECLARE_PRINTER(JSMessageObject)
7328   DECLARE_VERIFIER(JSMessageObject)
7329
7330   // Layout description.
7331   static const int kTypeOffset = JSObject::kHeaderSize;
7332   static const int kArgumentsOffset = kTypeOffset + kPointerSize;
7333   static const int kScriptOffset = kArgumentsOffset + kPointerSize;
7334   static const int kStackFramesOffset = kScriptOffset + kPointerSize;
7335   static const int kStartPositionOffset = kStackFramesOffset + kPointerSize;
7336   static const int kEndPositionOffset = kStartPositionOffset + kPointerSize;
7337   static const int kSize = kEndPositionOffset + kPointerSize;
7338
7339   typedef FixedBodyDescriptor<HeapObject::kMapOffset,
7340                               kStackFramesOffset + kPointerSize,
7341                               kSize> BodyDescriptor;
7342 };
7343
7344
7345 // Regular expressions
7346 // The regular expression holds a single reference to a FixedArray in
7347 // the kDataOffset field.
7348 // The FixedArray contains the following data:
7349 // - tag : type of regexp implementation (not compiled yet, atom or irregexp)
7350 // - reference to the original source string
7351 // - reference to the original flag string
7352 // If it is an atom regexp
7353 // - a reference to a literal string to search for
7354 // If it is an irregexp regexp:
7355 // - a reference to code for Latin1 inputs (bytecode or compiled), or a smi
7356 // used for tracking the last usage (used for code flushing).
7357 // - a reference to code for UC16 inputs (bytecode or compiled), or a smi
7358 // used for tracking the last usage (used for code flushing)..
7359 // - max number of registers used by irregexp implementations.
7360 // - number of capture registers (output values) of the regexp.
7361 class JSRegExp: public JSObject {
7362  public:
7363   // Meaning of Type:
7364   // NOT_COMPILED: Initial value. No data has been stored in the JSRegExp yet.
7365   // ATOM: A simple string to match against using an indexOf operation.
7366   // IRREGEXP: Compiled with Irregexp.
7367   // IRREGEXP_NATIVE: Compiled to native code with Irregexp.
7368   enum Type { NOT_COMPILED, ATOM, IRREGEXP };
7369   enum Flag {
7370     NONE = 0,
7371     GLOBAL = 1,
7372     IGNORE_CASE = 2,
7373     MULTILINE = 4,
7374     STICKY = 8,
7375     UNICODE_ESCAPES = 16
7376   };
7377
7378   class Flags {
7379    public:
7380     explicit Flags(uint32_t value) : value_(value) { }
7381     bool is_global() { return (value_ & GLOBAL) != 0; }
7382     bool is_ignore_case() { return (value_ & IGNORE_CASE) != 0; }
7383     bool is_multiline() { return (value_ & MULTILINE) != 0; }
7384     bool is_sticky() { return (value_ & STICKY) != 0; }
7385     bool is_unicode() { return (value_ & UNICODE_ESCAPES) != 0; }
7386     uint32_t value() { return value_; }
7387    private:
7388     uint32_t value_;
7389   };
7390
7391   DECL_ACCESSORS(data, Object)
7392
7393   inline Type TypeTag();
7394   inline int CaptureCount();
7395   inline Flags GetFlags();
7396   inline String* Pattern();
7397   inline Object* DataAt(int index);
7398   // Set implementation data after the object has been prepared.
7399   inline void SetDataAt(int index, Object* value);
7400
7401   static int code_index(bool is_latin1) {
7402     if (is_latin1) {
7403       return kIrregexpLatin1CodeIndex;
7404     } else {
7405       return kIrregexpUC16CodeIndex;
7406     }
7407   }
7408
7409   static int saved_code_index(bool is_latin1) {
7410     if (is_latin1) {
7411       return kIrregexpLatin1CodeSavedIndex;
7412     } else {
7413       return kIrregexpUC16CodeSavedIndex;
7414     }
7415   }
7416
7417   DECLARE_CAST(JSRegExp)
7418
7419   // Dispatched behavior.
7420   DECLARE_VERIFIER(JSRegExp)
7421
7422   static const int kDataOffset = JSObject::kHeaderSize;
7423   static const int kSize = kDataOffset + kPointerSize;
7424
7425   // Indices in the data array.
7426   static const int kTagIndex = 0;
7427   static const int kSourceIndex = kTagIndex + 1;
7428   static const int kFlagsIndex = kSourceIndex + 1;
7429   static const int kDataIndex = kFlagsIndex + 1;
7430   // The data fields are used in different ways depending on the
7431   // value of the tag.
7432   // Atom regexps (literal strings).
7433   static const int kAtomPatternIndex = kDataIndex;
7434
7435   static const int kAtomDataSize = kAtomPatternIndex + 1;
7436
7437   // Irregexp compiled code or bytecode for Latin1. If compilation
7438   // fails, this fields hold an exception object that should be
7439   // thrown if the regexp is used again.
7440   static const int kIrregexpLatin1CodeIndex = kDataIndex;
7441   // Irregexp compiled code or bytecode for UC16.  If compilation
7442   // fails, this fields hold an exception object that should be
7443   // thrown if the regexp is used again.
7444   static const int kIrregexpUC16CodeIndex = kDataIndex + 1;
7445
7446   // Saved instance of Irregexp compiled code or bytecode for Latin1 that
7447   // is a potential candidate for flushing.
7448   static const int kIrregexpLatin1CodeSavedIndex = kDataIndex + 2;
7449   // Saved instance of Irregexp compiled code or bytecode for UC16 that is
7450   // a potential candidate for flushing.
7451   static const int kIrregexpUC16CodeSavedIndex = kDataIndex + 3;
7452
7453   // Maximal number of registers used by either Latin1 or UC16.
7454   // Only used to check that there is enough stack space
7455   static const int kIrregexpMaxRegisterCountIndex = kDataIndex + 4;
7456   // Number of captures in the compiled regexp.
7457   static const int kIrregexpCaptureCountIndex = kDataIndex + 5;
7458
7459   static const int kIrregexpDataSize = kIrregexpCaptureCountIndex + 1;
7460
7461   // Offsets directly into the data fixed array.
7462   static const int kDataTagOffset =
7463       FixedArray::kHeaderSize + kTagIndex * kPointerSize;
7464   static const int kDataOneByteCodeOffset =
7465       FixedArray::kHeaderSize + kIrregexpLatin1CodeIndex * kPointerSize;
7466   static const int kDataUC16CodeOffset =
7467       FixedArray::kHeaderSize + kIrregexpUC16CodeIndex * kPointerSize;
7468   static const int kIrregexpCaptureCountOffset =
7469       FixedArray::kHeaderSize + kIrregexpCaptureCountIndex * kPointerSize;
7470
7471   // In-object fields.
7472   static const int kSourceFieldIndex = 0;
7473   static const int kGlobalFieldIndex = 1;
7474   static const int kIgnoreCaseFieldIndex = 2;
7475   static const int kMultilineFieldIndex = 3;
7476   static const int kLastIndexFieldIndex = 4;
7477   static const int kInObjectFieldCount = 5;
7478
7479   // The uninitialized value for a regexp code object.
7480   static const int kUninitializedValue = -1;
7481
7482   // The compilation error value for the regexp code object. The real error
7483   // object is in the saved code field.
7484   static const int kCompilationErrorValue = -2;
7485
7486   // When we store the sweep generation at which we moved the code from the
7487   // code index to the saved code index we mask it of to be in the [0:255]
7488   // range.
7489   static const int kCodeAgeMask = 0xff;
7490 };
7491
7492
7493 class CompilationCacheShape : public BaseShape<HashTableKey*> {
7494  public:
7495   static inline bool IsMatch(HashTableKey* key, Object* value) {
7496     return key->IsMatch(value);
7497   }
7498
7499   static inline uint32_t Hash(HashTableKey* key) {
7500     return key->Hash();
7501   }
7502
7503   static inline uint32_t HashForObject(HashTableKey* key, Object* object) {
7504     return key->HashForObject(object);
7505   }
7506
7507   static inline Handle<Object> AsHandle(Isolate* isolate, HashTableKey* key);
7508
7509   static const int kPrefixSize = 0;
7510   static const int kEntrySize = 2;
7511 };
7512
7513
7514 // This cache is used in two different variants. For regexp caching, it simply
7515 // maps identifying info of the regexp to the cached regexp object. Scripts and
7516 // eval code only gets cached after a second probe for the code object. To do
7517 // so, on first "put" only a hash identifying the source is entered into the
7518 // cache, mapping it to a lifetime count of the hash. On each call to Age all
7519 // such lifetimes get reduced, and removed once they reach zero. If a second put
7520 // is called while such a hash is live in the cache, the hash gets replaced by
7521 // an actual cache entry. Age also removes stale live entries from the cache.
7522 // Such entries are identified by SharedFunctionInfos pointing to either the
7523 // recompilation stub, or to "old" code. This avoids memory leaks due to
7524 // premature caching of scripts and eval strings that are never needed later.
7525 class CompilationCacheTable: public HashTable<CompilationCacheTable,
7526                                               CompilationCacheShape,
7527                                               HashTableKey*> {
7528  public:
7529   // Find cached value for a string key, otherwise return null.
7530   Handle<Object> Lookup(
7531       Handle<String> src, Handle<Context> context, LanguageMode language_mode);
7532   Handle<Object> LookupEval(
7533       Handle<String> src, Handle<SharedFunctionInfo> shared,
7534       LanguageMode language_mode, int scope_position);
7535   Handle<Object> LookupRegExp(Handle<String> source, JSRegExp::Flags flags);
7536   static Handle<CompilationCacheTable> Put(
7537       Handle<CompilationCacheTable> cache, Handle<String> src,
7538       Handle<Context> context, LanguageMode language_mode,
7539       Handle<Object> value);
7540   static Handle<CompilationCacheTable> PutEval(
7541       Handle<CompilationCacheTable> cache, Handle<String> src,
7542       Handle<SharedFunctionInfo> context, Handle<SharedFunctionInfo> value,
7543       int scope_position);
7544   static Handle<CompilationCacheTable> PutRegExp(
7545       Handle<CompilationCacheTable> cache, Handle<String> src,
7546       JSRegExp::Flags flags, Handle<FixedArray> value);
7547   void Remove(Object* value);
7548   void Age();
7549   static const int kHashGenerations = 10;
7550
7551   DECLARE_CAST(CompilationCacheTable)
7552
7553  private:
7554   DISALLOW_IMPLICIT_CONSTRUCTORS(CompilationCacheTable);
7555 };
7556
7557
7558 class CodeCache: public Struct {
7559  public:
7560   DECL_ACCESSORS(default_cache, FixedArray)
7561   DECL_ACCESSORS(normal_type_cache, Object)
7562
7563   // Add the code object to the cache.
7564   static void Update(
7565       Handle<CodeCache> cache, Handle<Name> name, Handle<Code> code);
7566
7567   // Lookup code object in the cache. Returns code object if found and undefined
7568   // if not.
7569   Object* Lookup(Name* name, Code::Flags flags);
7570
7571   // Get the internal index of a code object in the cache. Returns -1 if the
7572   // code object is not in that cache. This index can be used to later call
7573   // RemoveByIndex. The cache cannot be modified between a call to GetIndex and
7574   // RemoveByIndex.
7575   int GetIndex(Object* name, Code* code);
7576
7577   // Remove an object from the cache with the provided internal index.
7578   void RemoveByIndex(Object* name, Code* code, int index);
7579
7580   DECLARE_CAST(CodeCache)
7581
7582   // Dispatched behavior.
7583   DECLARE_PRINTER(CodeCache)
7584   DECLARE_VERIFIER(CodeCache)
7585
7586   static const int kDefaultCacheOffset = HeapObject::kHeaderSize;
7587   static const int kNormalTypeCacheOffset =
7588       kDefaultCacheOffset + kPointerSize;
7589   static const int kSize = kNormalTypeCacheOffset + kPointerSize;
7590
7591  private:
7592   static void UpdateDefaultCache(
7593       Handle<CodeCache> code_cache, Handle<Name> name, Handle<Code> code);
7594   static void UpdateNormalTypeCache(
7595       Handle<CodeCache> code_cache, Handle<Name> name, Handle<Code> code);
7596   Object* LookupDefaultCache(Name* name, Code::Flags flags);
7597   Object* LookupNormalTypeCache(Name* name, Code::Flags flags);
7598
7599   // Code cache layout of the default cache. Elements are alternating name and
7600   // code objects for non normal load/store/call IC's.
7601   static const int kCodeCacheEntrySize = 2;
7602   static const int kCodeCacheEntryNameOffset = 0;
7603   static const int kCodeCacheEntryCodeOffset = 1;
7604
7605   DISALLOW_IMPLICIT_CONSTRUCTORS(CodeCache);
7606 };
7607
7608
7609 class CodeCacheHashTableShape : public BaseShape<HashTableKey*> {
7610  public:
7611   static inline bool IsMatch(HashTableKey* key, Object* value) {
7612     return key->IsMatch(value);
7613   }
7614
7615   static inline uint32_t Hash(HashTableKey* key) {
7616     return key->Hash();
7617   }
7618
7619   static inline uint32_t HashForObject(HashTableKey* key, Object* object) {
7620     return key->HashForObject(object);
7621   }
7622
7623   static inline Handle<Object> AsHandle(Isolate* isolate, HashTableKey* key);
7624
7625   static const int kPrefixSize = 0;
7626   static const int kEntrySize = 2;
7627 };
7628
7629
7630 class CodeCacheHashTable: public HashTable<CodeCacheHashTable,
7631                                            CodeCacheHashTableShape,
7632                                            HashTableKey*> {
7633  public:
7634   Object* Lookup(Name* name, Code::Flags flags);
7635   static Handle<CodeCacheHashTable> Put(
7636       Handle<CodeCacheHashTable> table,
7637       Handle<Name> name,
7638       Handle<Code> code);
7639
7640   int GetIndex(Name* name, Code::Flags flags);
7641   void RemoveByIndex(int index);
7642
7643   DECLARE_CAST(CodeCacheHashTable)
7644
7645   // Initial size of the fixed array backing the hash table.
7646   static const int kInitialSize = 64;
7647
7648  private:
7649   DISALLOW_IMPLICIT_CONSTRUCTORS(CodeCacheHashTable);
7650 };
7651
7652
7653 class PolymorphicCodeCache: public Struct {
7654  public:
7655   DECL_ACCESSORS(cache, Object)
7656
7657   static void Update(Handle<PolymorphicCodeCache> cache,
7658                      MapHandleList* maps,
7659                      Code::Flags flags,
7660                      Handle<Code> code);
7661
7662
7663   // Returns an undefined value if the entry is not found.
7664   Handle<Object> Lookup(MapHandleList* maps, Code::Flags flags);
7665
7666   DECLARE_CAST(PolymorphicCodeCache)
7667
7668   // Dispatched behavior.
7669   DECLARE_PRINTER(PolymorphicCodeCache)
7670   DECLARE_VERIFIER(PolymorphicCodeCache)
7671
7672   static const int kCacheOffset = HeapObject::kHeaderSize;
7673   static const int kSize = kCacheOffset + kPointerSize;
7674
7675  private:
7676   DISALLOW_IMPLICIT_CONSTRUCTORS(PolymorphicCodeCache);
7677 };
7678
7679
7680 class PolymorphicCodeCacheHashTable
7681     : public HashTable<PolymorphicCodeCacheHashTable,
7682                        CodeCacheHashTableShape,
7683                        HashTableKey*> {
7684  public:
7685   Object* Lookup(MapHandleList* maps, int code_kind);
7686
7687   static Handle<PolymorphicCodeCacheHashTable> Put(
7688       Handle<PolymorphicCodeCacheHashTable> hash_table,
7689       MapHandleList* maps,
7690       int code_kind,
7691       Handle<Code> code);
7692
7693   DECLARE_CAST(PolymorphicCodeCacheHashTable)
7694
7695   static const int kInitialSize = 64;
7696  private:
7697   DISALLOW_IMPLICIT_CONSTRUCTORS(PolymorphicCodeCacheHashTable);
7698 };
7699
7700
7701 class TypeFeedbackInfo: public Struct {
7702  public:
7703   inline int ic_total_count();
7704   inline void set_ic_total_count(int count);
7705
7706   inline int ic_with_type_info_count();
7707   inline void change_ic_with_type_info_count(int delta);
7708
7709   inline int ic_generic_count();
7710   inline void change_ic_generic_count(int delta);
7711
7712   inline void initialize_storage();
7713
7714   inline void change_own_type_change_checksum();
7715   inline int own_type_change_checksum();
7716
7717   inline void set_inlined_type_change_checksum(int checksum);
7718   inline bool matches_inlined_type_change_checksum(int checksum);
7719
7720   DECLARE_CAST(TypeFeedbackInfo)
7721
7722   // Dispatched behavior.
7723   DECLARE_PRINTER(TypeFeedbackInfo)
7724   DECLARE_VERIFIER(TypeFeedbackInfo)
7725
7726   static const int kStorage1Offset = HeapObject::kHeaderSize;
7727   static const int kStorage2Offset = kStorage1Offset + kPointerSize;
7728   static const int kStorage3Offset = kStorage2Offset + kPointerSize;
7729   static const int kSize = kStorage3Offset + kPointerSize;
7730
7731  private:
7732   static const int kTypeChangeChecksumBits = 7;
7733
7734   class ICTotalCountField: public BitField<int, 0,
7735       kSmiValueSize - kTypeChangeChecksumBits> {};  // NOLINT
7736   class OwnTypeChangeChecksum: public BitField<int,
7737       kSmiValueSize - kTypeChangeChecksumBits,
7738       kTypeChangeChecksumBits> {};  // NOLINT
7739   class ICsWithTypeInfoCountField: public BitField<int, 0,
7740       kSmiValueSize - kTypeChangeChecksumBits> {};  // NOLINT
7741   class InlinedTypeChangeChecksum: public BitField<int,
7742       kSmiValueSize - kTypeChangeChecksumBits,
7743       kTypeChangeChecksumBits> {};  // NOLINT
7744
7745   DISALLOW_IMPLICIT_CONSTRUCTORS(TypeFeedbackInfo);
7746 };
7747
7748
7749 enum AllocationSiteMode {
7750   DONT_TRACK_ALLOCATION_SITE,
7751   TRACK_ALLOCATION_SITE,
7752   LAST_ALLOCATION_SITE_MODE = TRACK_ALLOCATION_SITE
7753 };
7754
7755
7756 class AllocationSite: public Struct {
7757  public:
7758   static const uint32_t kMaximumArrayBytesToPretransition = 8 * 1024;
7759   static const double kPretenureRatio;
7760   static const int kPretenureMinimumCreated = 100;
7761
7762   // Values for pretenure decision field.
7763   enum PretenureDecision {
7764     kUndecided = 0,
7765     kDontTenure = 1,
7766     kMaybeTenure = 2,
7767     kTenure = 3,
7768     kZombie = 4,
7769     kLastPretenureDecisionValue = kZombie
7770   };
7771
7772   const char* PretenureDecisionName(PretenureDecision decision);
7773
7774   DECL_ACCESSORS(transition_info, Object)
7775   // nested_site threads a list of sites that represent nested literals
7776   // walked in a particular order. So [[1, 2], 1, 2] will have one
7777   // nested_site, but [[1, 2], 3, [4]] will have a list of two.
7778   DECL_ACCESSORS(nested_site, Object)
7779   DECL_ACCESSORS(pretenure_data, Smi)
7780   DECL_ACCESSORS(pretenure_create_count, Smi)
7781   DECL_ACCESSORS(dependent_code, DependentCode)
7782   DECL_ACCESSORS(weak_next, Object)
7783
7784   inline void Initialize();
7785
7786   // This method is expensive, it should only be called for reporting.
7787   bool IsNestedSite();
7788
7789   // transition_info bitfields, for constructed array transition info.
7790   class ElementsKindBits:       public BitField<ElementsKind, 0,  15> {};
7791   class UnusedBits:             public BitField<int,          15, 14> {};
7792   class DoNotInlineBit:         public BitField<bool,         29,  1> {};
7793
7794   // Bitfields for pretenure_data
7795   class MementoFoundCountBits:  public BitField<int,               0, 26> {};
7796   class PretenureDecisionBits:  public BitField<PretenureDecision, 26, 3> {};
7797   class DeoptDependentCodeBit:  public BitField<bool,              29, 1> {};
7798   STATIC_ASSERT(PretenureDecisionBits::kMax >= kLastPretenureDecisionValue);
7799
7800   // Increments the mementos found counter and returns true when the first
7801   // memento was found for a given allocation site.
7802   inline bool IncrementMementoFoundCount();
7803
7804   inline void IncrementMementoCreateCount();
7805
7806   PretenureFlag GetPretenureMode();
7807
7808   void ResetPretenureDecision();
7809
7810   inline PretenureDecision pretenure_decision();
7811   inline void set_pretenure_decision(PretenureDecision decision);
7812
7813   inline bool deopt_dependent_code();
7814   inline void set_deopt_dependent_code(bool deopt);
7815
7816   inline int memento_found_count();
7817   inline void set_memento_found_count(int count);
7818
7819   inline int memento_create_count();
7820   inline void set_memento_create_count(int count);
7821
7822   // The pretenuring decision is made during gc, and the zombie state allows
7823   // us to recognize when an allocation site is just being kept alive because
7824   // a later traversal of new space may discover AllocationMementos that point
7825   // to this AllocationSite.
7826   inline bool IsZombie();
7827
7828   inline bool IsMaybeTenure();
7829
7830   inline void MarkZombie();
7831
7832   inline bool MakePretenureDecision(PretenureDecision current_decision,
7833                                     double ratio,
7834                                     bool maximum_size_scavenge);
7835
7836   inline bool DigestPretenuringFeedback(bool maximum_size_scavenge);
7837
7838   inline ElementsKind GetElementsKind();
7839   inline void SetElementsKind(ElementsKind kind);
7840
7841   inline bool CanInlineCall();
7842   inline void SetDoNotInlineCall();
7843
7844   inline bool SitePointsToLiteral();
7845
7846   static void DigestTransitionFeedback(Handle<AllocationSite> site,
7847                                        ElementsKind to_kind);
7848
7849   DECLARE_PRINTER(AllocationSite)
7850   DECLARE_VERIFIER(AllocationSite)
7851
7852   DECLARE_CAST(AllocationSite)
7853   static inline AllocationSiteMode GetMode(
7854       ElementsKind boilerplate_elements_kind);
7855   static inline AllocationSiteMode GetMode(ElementsKind from, ElementsKind to);
7856   static inline bool CanTrack(InstanceType type);
7857
7858   static const int kTransitionInfoOffset = HeapObject::kHeaderSize;
7859   static const int kNestedSiteOffset = kTransitionInfoOffset + kPointerSize;
7860   static const int kPretenureDataOffset = kNestedSiteOffset + kPointerSize;
7861   static const int kPretenureCreateCountOffset =
7862       kPretenureDataOffset + kPointerSize;
7863   static const int kDependentCodeOffset =
7864       kPretenureCreateCountOffset + kPointerSize;
7865   static const int kWeakNextOffset = kDependentCodeOffset + kPointerSize;
7866   static const int kSize = kWeakNextOffset + kPointerSize;
7867
7868   // During mark compact we need to take special care for the dependent code
7869   // field.
7870   static const int kPointerFieldsBeginOffset = kTransitionInfoOffset;
7871   static const int kPointerFieldsEndOffset = kWeakNextOffset;
7872
7873   // For other visitors, use the fixed body descriptor below.
7874   typedef FixedBodyDescriptor<HeapObject::kHeaderSize,
7875                               kDependentCodeOffset + kPointerSize,
7876                               kSize> BodyDescriptor;
7877
7878  private:
7879   inline bool PretenuringDecisionMade();
7880
7881   DISALLOW_IMPLICIT_CONSTRUCTORS(AllocationSite);
7882 };
7883
7884
7885 class AllocationMemento: public Struct {
7886  public:
7887   static const int kAllocationSiteOffset = HeapObject::kHeaderSize;
7888   static const int kSize = kAllocationSiteOffset + kPointerSize;
7889
7890   DECL_ACCESSORS(allocation_site, Object)
7891
7892   inline bool IsValid();
7893   inline AllocationSite* GetAllocationSite();
7894
7895   DECLARE_PRINTER(AllocationMemento)
7896   DECLARE_VERIFIER(AllocationMemento)
7897
7898   DECLARE_CAST(AllocationMemento)
7899
7900  private:
7901   DISALLOW_IMPLICIT_CONSTRUCTORS(AllocationMemento);
7902 };
7903
7904
7905 // Representation of a slow alias as part of a sloppy arguments objects.
7906 // For fast aliases (if HasSloppyArgumentsElements()):
7907 // - the parameter map contains an index into the context
7908 // - all attributes of the element have default values
7909 // For slow aliases (if HasDictionaryArgumentsElements()):
7910 // - the parameter map contains no fast alias mapping (i.e. the hole)
7911 // - this struct (in the slow backing store) contains an index into the context
7912 // - all attributes are available as part if the property details
7913 class AliasedArgumentsEntry: public Struct {
7914  public:
7915   inline int aliased_context_slot() const;
7916   inline void set_aliased_context_slot(int count);
7917
7918   DECLARE_CAST(AliasedArgumentsEntry)
7919
7920   // Dispatched behavior.
7921   DECLARE_PRINTER(AliasedArgumentsEntry)
7922   DECLARE_VERIFIER(AliasedArgumentsEntry)
7923
7924   static const int kAliasedContextSlot = HeapObject::kHeaderSize;
7925   static const int kSize = kAliasedContextSlot + kPointerSize;
7926
7927  private:
7928   DISALLOW_IMPLICIT_CONSTRUCTORS(AliasedArgumentsEntry);
7929 };
7930
7931
7932 enum AllowNullsFlag {ALLOW_NULLS, DISALLOW_NULLS};
7933 enum RobustnessFlag {ROBUST_STRING_TRAVERSAL, FAST_STRING_TRAVERSAL};
7934
7935
7936 class StringHasher {
7937  public:
7938   explicit inline StringHasher(int length, uint32_t seed);
7939
7940   template <typename schar>
7941   static inline uint32_t HashSequentialString(const schar* chars,
7942                                               int length,
7943                                               uint32_t seed);
7944
7945   // Reads all the data, even for long strings and computes the utf16 length.
7946   static uint32_t ComputeUtf8Hash(Vector<const char> chars,
7947                                   uint32_t seed,
7948                                   int* utf16_length_out);
7949
7950   // Calculated hash value for a string consisting of 1 to
7951   // String::kMaxArrayIndexSize digits with no leading zeros (except "0").
7952   // value is represented decimal value.
7953   static uint32_t MakeArrayIndexHash(uint32_t value, int length);
7954
7955   // No string is allowed to have a hash of zero.  That value is reserved
7956   // for internal properties.  If the hash calculation yields zero then we
7957   // use 27 instead.
7958   static const int kZeroHash = 27;
7959
7960   // Reusable parts of the hashing algorithm.
7961   INLINE(static uint32_t AddCharacterCore(uint32_t running_hash, uint16_t c));
7962   INLINE(static uint32_t GetHashCore(uint32_t running_hash));
7963   INLINE(static uint32_t ComputeRunningHash(uint32_t running_hash,
7964                                             const uc16* chars, int length));
7965   INLINE(static uint32_t ComputeRunningHashOneByte(uint32_t running_hash,
7966                                                    const char* chars,
7967                                                    int length));
7968
7969  protected:
7970   // Returns the value to store in the hash field of a string with
7971   // the given length and contents.
7972   uint32_t GetHashField();
7973   // Returns true if the hash of this string can be computed without
7974   // looking at the contents.
7975   inline bool has_trivial_hash();
7976   // Adds a block of characters to the hash.
7977   template<typename Char>
7978   inline void AddCharacters(const Char* chars, int len);
7979
7980  private:
7981   // Add a character to the hash.
7982   inline void AddCharacter(uint16_t c);
7983   // Update index. Returns true if string is still an index.
7984   inline bool UpdateIndex(uint16_t c);
7985
7986   int length_;
7987   uint32_t raw_running_hash_;
7988   uint32_t array_index_;
7989   bool is_array_index_;
7990   bool is_first_char_;
7991   DISALLOW_COPY_AND_ASSIGN(StringHasher);
7992 };
7993
7994
7995 class IteratingStringHasher : public StringHasher {
7996  public:
7997   static inline uint32_t Hash(String* string, uint32_t seed);
7998   inline void VisitOneByteString(const uint8_t* chars, int length);
7999   inline void VisitTwoByteString(const uint16_t* chars, int length);
8000
8001  private:
8002   inline IteratingStringHasher(int len, uint32_t seed);
8003   void VisitConsString(ConsString* cons_string);
8004   DISALLOW_COPY_AND_ASSIGN(IteratingStringHasher);
8005 };
8006
8007
8008 // The characteristics of a string are stored in its map.  Retrieving these
8009 // few bits of information is moderately expensive, involving two memory
8010 // loads where the second is dependent on the first.  To improve efficiency
8011 // the shape of the string is given its own class so that it can be retrieved
8012 // once and used for several string operations.  A StringShape is small enough
8013 // to be passed by value and is immutable, but be aware that flattening a
8014 // string can potentially alter its shape.  Also be aware that a GC caused by
8015 // something else can alter the shape of a string due to ConsString
8016 // shortcutting.  Keeping these restrictions in mind has proven to be error-
8017 // prone and so we no longer put StringShapes in variables unless there is a
8018 // concrete performance benefit at that particular point in the code.
8019 class StringShape BASE_EMBEDDED {
8020  public:
8021   inline explicit StringShape(const String* s);
8022   inline explicit StringShape(Map* s);
8023   inline explicit StringShape(InstanceType t);
8024   inline bool IsSequential();
8025   inline bool IsExternal();
8026   inline bool IsCons();
8027   inline bool IsSliced();
8028   inline bool IsIndirect();
8029   inline bool IsExternalOneByte();
8030   inline bool IsExternalTwoByte();
8031   inline bool IsSequentialOneByte();
8032   inline bool IsSequentialTwoByte();
8033   inline bool IsInternalized();
8034   inline StringRepresentationTag representation_tag();
8035   inline uint32_t encoding_tag();
8036   inline uint32_t full_representation_tag();
8037   inline uint32_t size_tag();
8038 #ifdef DEBUG
8039   inline uint32_t type() { return type_; }
8040   inline void invalidate() { valid_ = false; }
8041   inline bool valid() { return valid_; }
8042 #else
8043   inline void invalidate() { }
8044 #endif
8045
8046  private:
8047   uint32_t type_;
8048 #ifdef DEBUG
8049   inline void set_valid() { valid_ = true; }
8050   bool valid_;
8051 #else
8052   inline void set_valid() { }
8053 #endif
8054 };
8055
8056
8057 // The Name abstract class captures anything that can be used as a property
8058 // name, i.e., strings and symbols.  All names store a hash value.
8059 class Name: public HeapObject {
8060  public:
8061   // Get and set the hash field of the name.
8062   inline uint32_t hash_field();
8063   inline void set_hash_field(uint32_t value);
8064
8065   // Tells whether the hash code has been computed.
8066   inline bool HasHashCode();
8067
8068   // Returns a hash value used for the property table
8069   inline uint32_t Hash();
8070
8071   // Equality operations.
8072   inline bool Equals(Name* other);
8073   inline static bool Equals(Handle<Name> one, Handle<Name> two);
8074
8075   // Conversion.
8076   inline bool AsArrayIndex(uint32_t* index);
8077
8078   // If the name is private, it can only name own properties.
8079   inline bool IsPrivate();
8080
8081   // If the name is a non-flat string, this method returns a flat version of the
8082   // string. Otherwise it'll just return the input.
8083   static inline Handle<Name> Flatten(Handle<Name> name,
8084                                      PretenureFlag pretenure = NOT_TENURED);
8085
8086   DECLARE_CAST(Name)
8087
8088   DECLARE_PRINTER(Name)
8089 #if TRACE_MAPS
8090   void NameShortPrint();
8091   int NameShortPrint(Vector<char> str);
8092 #endif
8093
8094   // Layout description.
8095   static const int kHashFieldSlot = HeapObject::kHeaderSize;
8096 #if V8_TARGET_LITTLE_ENDIAN || !V8_HOST_ARCH_64_BIT
8097   static const int kHashFieldOffset = kHashFieldSlot;
8098 #else
8099   static const int kHashFieldOffset = kHashFieldSlot + kIntSize;
8100 #endif
8101   static const int kSize = kHashFieldSlot + kPointerSize;
8102
8103   // Mask constant for checking if a name has a computed hash code
8104   // and if it is a string that is an array index.  The least significant bit
8105   // indicates whether a hash code has been computed.  If the hash code has
8106   // been computed the 2nd bit tells whether the string can be used as an
8107   // array index.
8108   static const int kHashNotComputedMask = 1;
8109   static const int kIsNotArrayIndexMask = 1 << 1;
8110   static const int kNofHashBitFields = 2;
8111
8112   // Shift constant retrieving hash code from hash field.
8113   static const int kHashShift = kNofHashBitFields;
8114
8115   // Only these bits are relevant in the hash, since the top two are shifted
8116   // out.
8117   static const uint32_t kHashBitMask = 0xffffffffu >> kHashShift;
8118
8119   // Array index strings this short can keep their index in the hash field.
8120   static const int kMaxCachedArrayIndexLength = 7;
8121
8122   // For strings which are array indexes the hash value has the string length
8123   // mixed into the hash, mainly to avoid a hash value of zero which would be
8124   // the case for the string '0'. 24 bits are used for the array index value.
8125   static const int kArrayIndexValueBits = 24;
8126   static const int kArrayIndexLengthBits =
8127       kBitsPerInt - kArrayIndexValueBits - kNofHashBitFields;
8128
8129   STATIC_ASSERT((kArrayIndexLengthBits > 0));
8130
8131   class ArrayIndexValueBits : public BitField<unsigned int, kNofHashBitFields,
8132       kArrayIndexValueBits> {};  // NOLINT
8133   class ArrayIndexLengthBits : public BitField<unsigned int,
8134       kNofHashBitFields + kArrayIndexValueBits,
8135       kArrayIndexLengthBits> {};  // NOLINT
8136
8137   // Check that kMaxCachedArrayIndexLength + 1 is a power of two so we
8138   // could use a mask to test if the length of string is less than or equal to
8139   // kMaxCachedArrayIndexLength.
8140   STATIC_ASSERT(IS_POWER_OF_TWO(kMaxCachedArrayIndexLength + 1));
8141
8142   static const unsigned int kContainsCachedArrayIndexMask =
8143       (~static_cast<unsigned>(kMaxCachedArrayIndexLength)
8144        << ArrayIndexLengthBits::kShift) |
8145       kIsNotArrayIndexMask;
8146
8147   // Value of empty hash field indicating that the hash is not computed.
8148   static const int kEmptyHashField =
8149       kIsNotArrayIndexMask | kHashNotComputedMask;
8150
8151  protected:
8152   static inline bool IsHashFieldComputed(uint32_t field);
8153
8154  private:
8155   DISALLOW_IMPLICIT_CONSTRUCTORS(Name);
8156 };
8157
8158
8159 // ES6 symbols.
8160 class Symbol: public Name {
8161  public:
8162   // [name]: The print name of a symbol, or undefined if none.
8163   DECL_ACCESSORS(name, Object)
8164
8165   DECL_ACCESSORS(flags, Smi)
8166
8167   // [is_private]: Whether this is a private symbol.  Private symbols can only
8168   // be used to designate own properties of objects.
8169   DECL_BOOLEAN_ACCESSORS(is_private)
8170
8171   DECLARE_CAST(Symbol)
8172
8173   // Dispatched behavior.
8174   DECLARE_PRINTER(Symbol)
8175   DECLARE_VERIFIER(Symbol)
8176
8177   // Layout description.
8178   static const int kNameOffset = Name::kSize;
8179   static const int kFlagsOffset = kNameOffset + kPointerSize;
8180   static const int kSize = kFlagsOffset + kPointerSize;
8181
8182   typedef FixedBodyDescriptor<kNameOffset, kFlagsOffset, kSize> BodyDescriptor;
8183
8184   void SymbolShortPrint(std::ostream& os);
8185
8186  private:
8187   static const int kPrivateBit = 0;
8188
8189   const char* PrivateSymbolToName() const;
8190
8191 #if TRACE_MAPS
8192   friend class Name;  // For PrivateSymbolToName.
8193 #endif
8194
8195   DISALLOW_IMPLICIT_CONSTRUCTORS(Symbol);
8196 };
8197
8198
8199 class ConsString;
8200
8201 // The String abstract class captures JavaScript string values:
8202 //
8203 // Ecma-262:
8204 //  4.3.16 String Value
8205 //    A string value is a member of the type String and is a finite
8206 //    ordered sequence of zero or more 16-bit unsigned integer values.
8207 //
8208 // All string values have a length field.
8209 class String: public Name {
8210  public:
8211   enum Encoding { ONE_BYTE_ENCODING, TWO_BYTE_ENCODING };
8212
8213   // Array index strings this short can keep their index in the hash field.
8214   static const int kMaxCachedArrayIndexLength = 7;
8215
8216   // For strings which are array indexes the hash value has the string length
8217   // mixed into the hash, mainly to avoid a hash value of zero which would be
8218   // the case for the string '0'. 24 bits are used for the array index value.
8219   static const int kArrayIndexValueBits = 24;
8220   static const int kArrayIndexLengthBits =
8221       kBitsPerInt - kArrayIndexValueBits - kNofHashBitFields;
8222
8223   STATIC_ASSERT((kArrayIndexLengthBits > 0));
8224
8225   class ArrayIndexValueBits : public BitField<unsigned int, kNofHashBitFields,
8226       kArrayIndexValueBits> {};  // NOLINT
8227   class ArrayIndexLengthBits : public BitField<unsigned int,
8228       kNofHashBitFields + kArrayIndexValueBits,
8229       kArrayIndexLengthBits> {};  // NOLINT
8230
8231   // Check that kMaxCachedArrayIndexLength + 1 is a power of two so we
8232   // could use a mask to test if the length of string is less than or equal to
8233   // kMaxCachedArrayIndexLength.
8234   STATIC_ASSERT(IS_POWER_OF_TWO(kMaxCachedArrayIndexLength + 1));
8235
8236   static const unsigned int kContainsCachedArrayIndexMask =
8237       (~static_cast<unsigned>(kMaxCachedArrayIndexLength)
8238        << ArrayIndexLengthBits::kShift) |
8239       kIsNotArrayIndexMask;
8240
8241   class SubStringRange {
8242    public:
8243     explicit inline SubStringRange(String* string, int first = 0,
8244                                    int length = -1);
8245     class iterator;
8246     inline iterator begin();
8247     inline iterator end();
8248
8249    private:
8250     String* string_;
8251     int first_;
8252     int length_;
8253   };
8254
8255   // Representation of the flat content of a String.
8256   // A non-flat string doesn't have flat content.
8257   // A flat string has content that's encoded as a sequence of either
8258   // one-byte chars or two-byte UC16.
8259   // Returned by String::GetFlatContent().
8260   class FlatContent {
8261    public:
8262     // Returns true if the string is flat and this structure contains content.
8263     bool IsFlat() { return state_ != NON_FLAT; }
8264     // Returns true if the structure contains one-byte content.
8265     bool IsOneByte() { return state_ == ONE_BYTE; }
8266     // Returns true if the structure contains two-byte content.
8267     bool IsTwoByte() { return state_ == TWO_BYTE; }
8268
8269     // Return the one byte content of the string. Only use if IsOneByte()
8270     // returns true.
8271     Vector<const uint8_t> ToOneByteVector() {
8272       DCHECK_EQ(ONE_BYTE, state_);
8273       return Vector<const uint8_t>(onebyte_start, length_);
8274     }
8275     // Return the two-byte content of the string. Only use if IsTwoByte()
8276     // returns true.
8277     Vector<const uc16> ToUC16Vector() {
8278       DCHECK_EQ(TWO_BYTE, state_);
8279       return Vector<const uc16>(twobyte_start, length_);
8280     }
8281
8282     uc16 Get(int i) {
8283       DCHECK(i < length_);
8284       DCHECK(state_ != NON_FLAT);
8285       if (state_ == ONE_BYTE) return onebyte_start[i];
8286       return twobyte_start[i];
8287     }
8288
8289     bool UsesSameString(const FlatContent& other) const {
8290       return onebyte_start == other.onebyte_start;
8291     }
8292
8293    private:
8294     enum State { NON_FLAT, ONE_BYTE, TWO_BYTE };
8295
8296     // Constructors only used by String::GetFlatContent().
8297     explicit FlatContent(const uint8_t* start, int length)
8298         : onebyte_start(start), length_(length), state_(ONE_BYTE) {}
8299     explicit FlatContent(const uc16* start, int length)
8300         : twobyte_start(start), length_(length), state_(TWO_BYTE) { }
8301     FlatContent() : onebyte_start(NULL), length_(0), state_(NON_FLAT) { }
8302
8303     union {
8304       const uint8_t* onebyte_start;
8305       const uc16* twobyte_start;
8306     };
8307     int length_;
8308     State state_;
8309
8310     friend class String;
8311     friend class IterableSubString;
8312   };
8313
8314   template <typename Char>
8315   INLINE(Vector<const Char> GetCharVector());
8316
8317   // Get and set the length of the string.
8318   inline int length() const;
8319   inline void set_length(int value);
8320
8321   // Get and set the length of the string using acquire loads and release
8322   // stores.
8323   inline int synchronized_length() const;
8324   inline void synchronized_set_length(int value);
8325
8326   // Returns whether this string has only one-byte chars, i.e. all of them can
8327   // be one-byte encoded.  This might be the case even if the string is
8328   // two-byte.  Such strings may appear when the embedder prefers
8329   // two-byte external representations even for one-byte data.
8330   inline bool IsOneByteRepresentation() const;
8331   inline bool IsTwoByteRepresentation() const;
8332
8333   // Cons and slices have an encoding flag that may not represent the actual
8334   // encoding of the underlying string.  This is taken into account here.
8335   // Requires: this->IsFlat()
8336   inline bool IsOneByteRepresentationUnderneath();
8337   inline bool IsTwoByteRepresentationUnderneath();
8338
8339   // NOTE: this should be considered only a hint.  False negatives are
8340   // possible.
8341   inline bool HasOnlyOneByteChars();
8342
8343   // Get and set individual two byte chars in the string.
8344   inline void Set(int index, uint16_t value);
8345   // Get individual two byte char in the string.  Repeated calls
8346   // to this method are not efficient unless the string is flat.
8347   INLINE(uint16_t Get(int index));
8348
8349   // Flattens the string.  Checks first inline to see if it is
8350   // necessary.  Does nothing if the string is not a cons string.
8351   // Flattening allocates a sequential string with the same data as
8352   // the given string and mutates the cons string to a degenerate
8353   // form, where the first component is the new sequential string and
8354   // the second component is the empty string.  If allocation fails,
8355   // this function returns a failure.  If flattening succeeds, this
8356   // function returns the sequential string that is now the first
8357   // component of the cons string.
8358   //
8359   // Degenerate cons strings are handled specially by the garbage
8360   // collector (see IsShortcutCandidate).
8361
8362   static inline Handle<String> Flatten(Handle<String> string,
8363                                        PretenureFlag pretenure = NOT_TENURED);
8364
8365   // Tries to return the content of a flat string as a structure holding either
8366   // a flat vector of char or of uc16.
8367   // If the string isn't flat, and therefore doesn't have flat content, the
8368   // returned structure will report so, and can't provide a vector of either
8369   // kind.
8370   FlatContent GetFlatContent();
8371
8372   // Returns the parent of a sliced string or first part of a flat cons string.
8373   // Requires: StringShape(this).IsIndirect() && this->IsFlat()
8374   inline String* GetUnderlying();
8375
8376   // String equality operations.
8377   inline bool Equals(String* other);
8378   inline static bool Equals(Handle<String> one, Handle<String> two);
8379   bool IsUtf8EqualTo(Vector<const char> str, bool allow_prefix_match = false);
8380   bool IsOneByteEqualTo(Vector<const uint8_t> str);
8381   bool IsTwoByteEqualTo(Vector<const uc16> str);
8382
8383   // Return a UTF8 representation of the string.  The string is null
8384   // terminated but may optionally contain nulls.  Length is returned
8385   // in length_output if length_output is not a null pointer  The string
8386   // should be nearly flat, otherwise the performance of this method may
8387   // be very slow (quadratic in the length).  Setting robustness_flag to
8388   // ROBUST_STRING_TRAVERSAL invokes behaviour that is robust  This means it
8389   // handles unexpected data without causing assert failures and it does not
8390   // do any heap allocations.  This is useful when printing stack traces.
8391   base::SmartArrayPointer<char> ToCString(AllowNullsFlag allow_nulls,
8392                                           RobustnessFlag robustness_flag,
8393                                           int offset, int length,
8394                                           int* length_output = 0);
8395   base::SmartArrayPointer<char> ToCString(
8396       AllowNullsFlag allow_nulls = DISALLOW_NULLS,
8397       RobustnessFlag robustness_flag = FAST_STRING_TRAVERSAL,
8398       int* length_output = 0);
8399
8400   // Return a 16 bit Unicode representation of the string.
8401   // The string should be nearly flat, otherwise the performance of
8402   // of this method may be very bad.  Setting robustness_flag to
8403   // ROBUST_STRING_TRAVERSAL invokes behaviour that is robust  This means it
8404   // handles unexpected data without causing assert failures and it does not
8405   // do any heap allocations.  This is useful when printing stack traces.
8406   base::SmartArrayPointer<uc16> ToWideCString(
8407       RobustnessFlag robustness_flag = FAST_STRING_TRAVERSAL);
8408
8409   bool ComputeArrayIndex(uint32_t* index);
8410
8411   // Externalization.
8412   bool MakeExternal(v8::String::ExternalStringResource* resource);
8413   bool MakeExternal(v8::String::ExternalOneByteStringResource* resource);
8414
8415   // Conversion.
8416   inline bool AsArrayIndex(uint32_t* index);
8417
8418   DECLARE_CAST(String)
8419
8420   void PrintOn(FILE* out);
8421
8422   // For use during stack traces.  Performs rudimentary sanity check.
8423   bool LooksValid();
8424
8425   // Dispatched behavior.
8426   void StringShortPrint(StringStream* accumulator);
8427   void PrintUC16(std::ostream& os, int start = 0, int end = -1);  // NOLINT
8428 #if defined(DEBUG) || defined(OBJECT_PRINT)
8429   char* ToAsciiArray();
8430 #endif
8431   DECLARE_PRINTER(String)
8432   DECLARE_VERIFIER(String)
8433
8434   inline bool IsFlat();
8435
8436   // Layout description.
8437   static const int kLengthOffset = Name::kSize;
8438   static const int kSize = kLengthOffset + kPointerSize;
8439
8440   // Maximum number of characters to consider when trying to convert a string
8441   // value into an array index.
8442   static const int kMaxArrayIndexSize = 10;
8443   STATIC_ASSERT(kMaxArrayIndexSize < (1 << kArrayIndexLengthBits));
8444
8445   // Max char codes.
8446   static const int32_t kMaxOneByteCharCode = unibrow::Latin1::kMaxChar;
8447   static const uint32_t kMaxOneByteCharCodeU = unibrow::Latin1::kMaxChar;
8448   static const int kMaxUtf16CodeUnit = 0xffff;
8449   static const uint32_t kMaxUtf16CodeUnitU = kMaxUtf16CodeUnit;
8450
8451   // Value of hash field containing computed hash equal to zero.
8452   static const int kEmptyStringHash = kIsNotArrayIndexMask;
8453
8454   // Maximal string length.
8455   static const int kMaxLength = (1 << 28) - 16;
8456
8457   // Max length for computing hash. For strings longer than this limit the
8458   // string length is used as the hash value.
8459   static const int kMaxHashCalcLength = 16383;
8460
8461   // Limit for truncation in short printing.
8462   static const int kMaxShortPrintLength = 1024;
8463
8464   // Support for regular expressions.
8465   const uc16* GetTwoByteData(unsigned start);
8466
8467   // Helper function for flattening strings.
8468   template <typename sinkchar>
8469   static void WriteToFlat(String* source,
8470                           sinkchar* sink,
8471                           int from,
8472                           int to);
8473
8474   // The return value may point to the first aligned word containing the first
8475   // non-one-byte character, rather than directly to the non-one-byte character.
8476   // If the return value is >= the passed length, the entire string was
8477   // one-byte.
8478   static inline int NonAsciiStart(const char* chars, int length) {
8479     const char* start = chars;
8480     const char* limit = chars + length;
8481
8482     if (length >= kIntptrSize) {
8483       // Check unaligned bytes.
8484       while (!IsAligned(reinterpret_cast<intptr_t>(chars), sizeof(uintptr_t))) {
8485         if (static_cast<uint8_t>(*chars) > unibrow::Utf8::kMaxOneByteChar) {
8486           return static_cast<int>(chars - start);
8487         }
8488         ++chars;
8489       }
8490       // Check aligned words.
8491       DCHECK(unibrow::Utf8::kMaxOneByteChar == 0x7F);
8492       const uintptr_t non_one_byte_mask = kUintptrAllBitsSet / 0xFF * 0x80;
8493       while (chars + sizeof(uintptr_t) <= limit) {
8494         if (*reinterpret_cast<const uintptr_t*>(chars) & non_one_byte_mask) {
8495           return static_cast<int>(chars - start);
8496         }
8497         chars += sizeof(uintptr_t);
8498       }
8499     }
8500     // Check remaining unaligned bytes.
8501     while (chars < limit) {
8502       if (static_cast<uint8_t>(*chars) > unibrow::Utf8::kMaxOneByteChar) {
8503         return static_cast<int>(chars - start);
8504       }
8505       ++chars;
8506     }
8507
8508     return static_cast<int>(chars - start);
8509   }
8510
8511   static inline bool IsAscii(const char* chars, int length) {
8512     return NonAsciiStart(chars, length) >= length;
8513   }
8514
8515   static inline bool IsAscii(const uint8_t* chars, int length) {
8516     return
8517         NonAsciiStart(reinterpret_cast<const char*>(chars), length) >= length;
8518   }
8519
8520   static inline int NonOneByteStart(const uc16* chars, int length) {
8521     const uc16* limit = chars + length;
8522     const uc16* start = chars;
8523     while (chars < limit) {
8524       if (*chars > kMaxOneByteCharCodeU) return static_cast<int>(chars - start);
8525       ++chars;
8526     }
8527     return static_cast<int>(chars - start);
8528   }
8529
8530   static inline bool IsOneByte(const uc16* chars, int length) {
8531     return NonOneByteStart(chars, length) >= length;
8532   }
8533
8534   template<class Visitor>
8535   static inline ConsString* VisitFlat(Visitor* visitor,
8536                                       String* string,
8537                                       int offset = 0);
8538
8539   static Handle<FixedArray> CalculateLineEnds(Handle<String> string,
8540                                               bool include_ending_line);
8541
8542   // Use the hash field to forward to the canonical internalized string
8543   // when deserializing an internalized string.
8544   inline void SetForwardedInternalizedString(String* string);
8545   inline String* GetForwardedInternalizedString();
8546
8547  private:
8548   friend class Name;
8549   friend class StringTableInsertionKey;
8550
8551   static Handle<String> SlowFlatten(Handle<ConsString> cons,
8552                                     PretenureFlag tenure);
8553
8554   // Slow case of String::Equals.  This implementation works on any strings
8555   // but it is most efficient on strings that are almost flat.
8556   bool SlowEquals(String* other);
8557
8558   static bool SlowEquals(Handle<String> one, Handle<String> two);
8559
8560   // Slow case of AsArrayIndex.
8561   bool SlowAsArrayIndex(uint32_t* index);
8562
8563   // Compute and set the hash code.
8564   uint32_t ComputeAndSetHash();
8565
8566   DISALLOW_IMPLICIT_CONSTRUCTORS(String);
8567 };
8568
8569
8570 // The SeqString abstract class captures sequential string values.
8571 class SeqString: public String {
8572  public:
8573   DECLARE_CAST(SeqString)
8574
8575   // Layout description.
8576   static const int kHeaderSize = String::kSize;
8577
8578   // Truncate the string in-place if possible and return the result.
8579   // In case of new_length == 0, the empty string is returned without
8580   // truncating the original string.
8581   MUST_USE_RESULT static Handle<String> Truncate(Handle<SeqString> string,
8582                                                  int new_length);
8583  private:
8584   DISALLOW_IMPLICIT_CONSTRUCTORS(SeqString);
8585 };
8586
8587
8588 // The OneByteString class captures sequential one-byte string objects.
8589 // Each character in the OneByteString is an one-byte character.
8590 class SeqOneByteString: public SeqString {
8591  public:
8592   static const bool kHasOneByteEncoding = true;
8593
8594   // Dispatched behavior.
8595   inline uint16_t SeqOneByteStringGet(int index);
8596   inline void SeqOneByteStringSet(int index, uint16_t value);
8597
8598   // Get the address of the characters in this string.
8599   inline Address GetCharsAddress();
8600
8601   inline uint8_t* GetChars();
8602
8603   DECLARE_CAST(SeqOneByteString)
8604
8605   // Garbage collection support.  This method is called by the
8606   // garbage collector to compute the actual size of an OneByteString
8607   // instance.
8608   inline int SeqOneByteStringSize(InstanceType instance_type);
8609
8610   // Computes the size for an OneByteString instance of a given length.
8611   static int SizeFor(int length) {
8612     return OBJECT_POINTER_ALIGN(kHeaderSize + length * kCharSize);
8613   }
8614
8615   // Maximal memory usage for a single sequential one-byte string.
8616   static const int kMaxSize = 512 * MB - 1;
8617   STATIC_ASSERT((kMaxSize - kHeaderSize) >= String::kMaxLength);
8618
8619  private:
8620   DISALLOW_IMPLICIT_CONSTRUCTORS(SeqOneByteString);
8621 };
8622
8623
8624 // The TwoByteString class captures sequential unicode string objects.
8625 // Each character in the TwoByteString is a two-byte uint16_t.
8626 class SeqTwoByteString: public SeqString {
8627  public:
8628   static const bool kHasOneByteEncoding = false;
8629
8630   // Dispatched behavior.
8631   inline uint16_t SeqTwoByteStringGet(int index);
8632   inline void SeqTwoByteStringSet(int index, uint16_t value);
8633
8634   // Get the address of the characters in this string.
8635   inline Address GetCharsAddress();
8636
8637   inline uc16* GetChars();
8638
8639   // For regexp code.
8640   const uint16_t* SeqTwoByteStringGetData(unsigned start);
8641
8642   DECLARE_CAST(SeqTwoByteString)
8643
8644   // Garbage collection support.  This method is called by the
8645   // garbage collector to compute the actual size of a TwoByteString
8646   // instance.
8647   inline int SeqTwoByteStringSize(InstanceType instance_type);
8648
8649   // Computes the size for a TwoByteString instance of a given length.
8650   static int SizeFor(int length) {
8651     return OBJECT_POINTER_ALIGN(kHeaderSize + length * kShortSize);
8652   }
8653
8654   // Maximal memory usage for a single sequential two-byte string.
8655   static const int kMaxSize = 512 * MB - 1;
8656   STATIC_ASSERT(static_cast<int>((kMaxSize - kHeaderSize)/sizeof(uint16_t)) >=
8657                String::kMaxLength);
8658
8659  private:
8660   DISALLOW_IMPLICIT_CONSTRUCTORS(SeqTwoByteString);
8661 };
8662
8663
8664 // The ConsString class describes string values built by using the
8665 // addition operator on strings.  A ConsString is a pair where the
8666 // first and second components are pointers to other string values.
8667 // One or both components of a ConsString can be pointers to other
8668 // ConsStrings, creating a binary tree of ConsStrings where the leaves
8669 // are non-ConsString string values.  The string value represented by
8670 // a ConsString can be obtained by concatenating the leaf string
8671 // values in a left-to-right depth-first traversal of the tree.
8672 class ConsString: public String {
8673  public:
8674   // First string of the cons cell.
8675   inline String* first();
8676   // Doesn't check that the result is a string, even in debug mode.  This is
8677   // useful during GC where the mark bits confuse the checks.
8678   inline Object* unchecked_first();
8679   inline void set_first(String* first,
8680                         WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
8681
8682   // Second string of the cons cell.
8683   inline String* second();
8684   // Doesn't check that the result is a string, even in debug mode.  This is
8685   // useful during GC where the mark bits confuse the checks.
8686   inline Object* unchecked_second();
8687   inline void set_second(String* second,
8688                          WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
8689
8690   // Dispatched behavior.
8691   uint16_t ConsStringGet(int index);
8692
8693   DECLARE_CAST(ConsString)
8694
8695   // Layout description.
8696   static const int kFirstOffset = POINTER_SIZE_ALIGN(String::kSize);
8697   static const int kSecondOffset = kFirstOffset + kPointerSize;
8698   static const int kSize = kSecondOffset + kPointerSize;
8699
8700   // Minimum length for a cons string.
8701   static const int kMinLength = 13;
8702
8703   typedef FixedBodyDescriptor<kFirstOffset, kSecondOffset + kPointerSize, kSize>
8704           BodyDescriptor;
8705
8706   DECLARE_VERIFIER(ConsString)
8707
8708  private:
8709   DISALLOW_IMPLICIT_CONSTRUCTORS(ConsString);
8710 };
8711
8712
8713 // The Sliced String class describes strings that are substrings of another
8714 // sequential string.  The motivation is to save time and memory when creating
8715 // a substring.  A Sliced String is described as a pointer to the parent,
8716 // the offset from the start of the parent string and the length.  Using
8717 // a Sliced String therefore requires unpacking of the parent string and
8718 // adding the offset to the start address.  A substring of a Sliced String
8719 // are not nested since the double indirection is simplified when creating
8720 // such a substring.
8721 // Currently missing features are:
8722 //  - handling externalized parent strings
8723 //  - external strings as parent
8724 //  - truncating sliced string to enable otherwise unneeded parent to be GC'ed.
8725 class SlicedString: public String {
8726  public:
8727   inline String* parent();
8728   inline void set_parent(String* parent,
8729                          WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
8730   inline int offset() const;
8731   inline void set_offset(int offset);
8732
8733   // Dispatched behavior.
8734   uint16_t SlicedStringGet(int index);
8735
8736   DECLARE_CAST(SlicedString)
8737
8738   // Layout description.
8739   static const int kParentOffset = POINTER_SIZE_ALIGN(String::kSize);
8740   static const int kOffsetOffset = kParentOffset + kPointerSize;
8741   static const int kSize = kOffsetOffset + kPointerSize;
8742
8743   // Minimum length for a sliced string.
8744   static const int kMinLength = 13;
8745
8746   typedef FixedBodyDescriptor<kParentOffset,
8747                               kOffsetOffset + kPointerSize, kSize>
8748           BodyDescriptor;
8749
8750   DECLARE_VERIFIER(SlicedString)
8751
8752  private:
8753   DISALLOW_IMPLICIT_CONSTRUCTORS(SlicedString);
8754 };
8755
8756
8757 // The ExternalString class describes string values that are backed by
8758 // a string resource that lies outside the V8 heap.  ExternalStrings
8759 // consist of the length field common to all strings, a pointer to the
8760 // external resource.  It is important to ensure (externally) that the
8761 // resource is not deallocated while the ExternalString is live in the
8762 // V8 heap.
8763 //
8764 // The API expects that all ExternalStrings are created through the
8765 // API.  Therefore, ExternalStrings should not be used internally.
8766 class ExternalString: public String {
8767  public:
8768   DECLARE_CAST(ExternalString)
8769
8770   // Layout description.
8771   static const int kResourceOffset = POINTER_SIZE_ALIGN(String::kSize);
8772   static const int kShortSize = kResourceOffset + kPointerSize;
8773   static const int kResourceDataOffset = kResourceOffset + kPointerSize;
8774   static const int kSize = kResourceDataOffset + kPointerSize;
8775
8776   static const int kMaxShortLength =
8777       (kShortSize - SeqString::kHeaderSize) / kCharSize;
8778
8779   // Return whether external string is short (data pointer is not cached).
8780   inline bool is_short();
8781
8782   STATIC_ASSERT(kResourceOffset == Internals::kStringResourceOffset);
8783
8784  private:
8785   DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalString);
8786 };
8787
8788
8789 // The ExternalOneByteString class is an external string backed by an
8790 // one-byte string.
8791 class ExternalOneByteString : public ExternalString {
8792  public:
8793   static const bool kHasOneByteEncoding = true;
8794
8795   typedef v8::String::ExternalOneByteStringResource Resource;
8796
8797   // The underlying resource.
8798   inline const Resource* resource();
8799   inline void set_resource(const Resource* buffer);
8800
8801   // Update the pointer cache to the external character array.
8802   // The cached pointer is always valid, as the external character array does =
8803   // not move during lifetime.  Deserialization is the only exception, after
8804   // which the pointer cache has to be refreshed.
8805   inline void update_data_cache();
8806
8807   inline const uint8_t* GetChars();
8808
8809   // Dispatched behavior.
8810   inline uint16_t ExternalOneByteStringGet(int index);
8811
8812   DECLARE_CAST(ExternalOneByteString)
8813
8814   // Garbage collection support.
8815   inline void ExternalOneByteStringIterateBody(ObjectVisitor* v);
8816
8817   template <typename StaticVisitor>
8818   inline void ExternalOneByteStringIterateBody();
8819
8820  private:
8821   DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalOneByteString);
8822 };
8823
8824
8825 // The ExternalTwoByteString class is an external string backed by a UTF-16
8826 // encoded string.
8827 class ExternalTwoByteString: public ExternalString {
8828  public:
8829   static const bool kHasOneByteEncoding = false;
8830
8831   typedef v8::String::ExternalStringResource Resource;
8832
8833   // The underlying string resource.
8834   inline const Resource* resource();
8835   inline void set_resource(const Resource* buffer);
8836
8837   // Update the pointer cache to the external character array.
8838   // The cached pointer is always valid, as the external character array does =
8839   // not move during lifetime.  Deserialization is the only exception, after
8840   // which the pointer cache has to be refreshed.
8841   inline void update_data_cache();
8842
8843   inline const uint16_t* GetChars();
8844
8845   // Dispatched behavior.
8846   inline uint16_t ExternalTwoByteStringGet(int index);
8847
8848   // For regexp code.
8849   inline const uint16_t* ExternalTwoByteStringGetData(unsigned start);
8850
8851   DECLARE_CAST(ExternalTwoByteString)
8852
8853   // Garbage collection support.
8854   inline void ExternalTwoByteStringIterateBody(ObjectVisitor* v);
8855
8856   template<typename StaticVisitor>
8857   inline void ExternalTwoByteStringIterateBody();
8858
8859  private:
8860   DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalTwoByteString);
8861 };
8862
8863
8864 // Utility superclass for stack-allocated objects that must be updated
8865 // on gc.  It provides two ways for the gc to update instances, either
8866 // iterating or updating after gc.
8867 class Relocatable BASE_EMBEDDED {
8868  public:
8869   explicit inline Relocatable(Isolate* isolate);
8870   inline virtual ~Relocatable();
8871   virtual void IterateInstance(ObjectVisitor* v) { }
8872   virtual void PostGarbageCollection() { }
8873
8874   static void PostGarbageCollectionProcessing(Isolate* isolate);
8875   static int ArchiveSpacePerThread();
8876   static char* ArchiveState(Isolate* isolate, char* to);
8877   static char* RestoreState(Isolate* isolate, char* from);
8878   static void Iterate(Isolate* isolate, ObjectVisitor* v);
8879   static void Iterate(ObjectVisitor* v, Relocatable* top);
8880   static char* Iterate(ObjectVisitor* v, char* t);
8881
8882  private:
8883   Isolate* isolate_;
8884   Relocatable* prev_;
8885 };
8886
8887
8888 // A flat string reader provides random access to the contents of a
8889 // string independent of the character width of the string.  The handle
8890 // must be valid as long as the reader is being used.
8891 class FlatStringReader : public Relocatable {
8892  public:
8893   FlatStringReader(Isolate* isolate, Handle<String> str);
8894   FlatStringReader(Isolate* isolate, Vector<const char> input);
8895   void PostGarbageCollection();
8896   inline uc32 Get(int index);
8897   template <typename Char>
8898   inline Char Get(int index);
8899   int length() { return length_; }
8900  private:
8901   String** str_;
8902   bool is_one_byte_;
8903   int length_;
8904   const void* start_;
8905 };
8906
8907
8908 // This maintains an off-stack representation of the stack frames required
8909 // to traverse a ConsString, allowing an entirely iterative and restartable
8910 // traversal of the entire string
8911 class ConsStringIterator {
8912  public:
8913   inline ConsStringIterator() {}
8914   inline explicit ConsStringIterator(ConsString* cons_string, int offset = 0) {
8915     Reset(cons_string, offset);
8916   }
8917   inline void Reset(ConsString* cons_string, int offset = 0) {
8918     depth_ = 0;
8919     // Next will always return NULL.
8920     if (cons_string == NULL) return;
8921     Initialize(cons_string, offset);
8922   }
8923   // Returns NULL when complete.
8924   inline String* Next(int* offset_out) {
8925     *offset_out = 0;
8926     if (depth_ == 0) return NULL;
8927     return Continue(offset_out);
8928   }
8929
8930  private:
8931   static const int kStackSize = 32;
8932   // Use a mask instead of doing modulo operations for stack wrapping.
8933   static const int kDepthMask = kStackSize-1;
8934   STATIC_ASSERT(IS_POWER_OF_TWO(kStackSize));
8935   static inline int OffsetForDepth(int depth);
8936
8937   inline void PushLeft(ConsString* string);
8938   inline void PushRight(ConsString* string);
8939   inline void AdjustMaximumDepth();
8940   inline void Pop();
8941   inline bool StackBlown() { return maximum_depth_ - depth_ == kStackSize; }
8942   void Initialize(ConsString* cons_string, int offset);
8943   String* Continue(int* offset_out);
8944   String* NextLeaf(bool* blew_stack);
8945   String* Search(int* offset_out);
8946
8947   // Stack must always contain only frames for which right traversal
8948   // has not yet been performed.
8949   ConsString* frames_[kStackSize];
8950   ConsString* root_;
8951   int depth_;
8952   int maximum_depth_;
8953   int consumed_;
8954   DISALLOW_COPY_AND_ASSIGN(ConsStringIterator);
8955 };
8956
8957
8958 class StringCharacterStream {
8959  public:
8960   inline StringCharacterStream(String* string,
8961                                int offset = 0);
8962   inline uint16_t GetNext();
8963   inline bool HasMore();
8964   inline void Reset(String* string, int offset = 0);
8965   inline void VisitOneByteString(const uint8_t* chars, int length);
8966   inline void VisitTwoByteString(const uint16_t* chars, int length);
8967
8968  private:
8969   ConsStringIterator iter_;
8970   bool is_one_byte_;
8971   union {
8972     const uint8_t* buffer8_;
8973     const uint16_t* buffer16_;
8974   };
8975   const uint8_t* end_;
8976   DISALLOW_COPY_AND_ASSIGN(StringCharacterStream);
8977 };
8978
8979
8980 template <typename T>
8981 class VectorIterator {
8982  public:
8983   VectorIterator(T* d, int l) : data_(Vector<const T>(d, l)), index_(0) { }
8984   explicit VectorIterator(Vector<const T> data) : data_(data), index_(0) { }
8985   T GetNext() { return data_[index_++]; }
8986   bool has_more() { return index_ < data_.length(); }
8987  private:
8988   Vector<const T> data_;
8989   int index_;
8990 };
8991
8992
8993 // The Oddball describes objects null, undefined, true, and false.
8994 class Oddball: public HeapObject {
8995  public:
8996   // [to_string]: Cached to_string computed at startup.
8997   DECL_ACCESSORS(to_string, String)
8998
8999   // [to_number]: Cached to_number computed at startup.
9000   DECL_ACCESSORS(to_number, Object)
9001
9002   // [typeof]: Cached type_of computed at startup.
9003   DECL_ACCESSORS(type_of, String)
9004
9005   inline byte kind() const;
9006   inline void set_kind(byte kind);
9007
9008   DECLARE_CAST(Oddball)
9009
9010   // Dispatched behavior.
9011   DECLARE_VERIFIER(Oddball)
9012
9013   // Initialize the fields.
9014   static void Initialize(Isolate* isolate, Handle<Oddball> oddball,
9015                          const char* to_string, Handle<Object> to_number,
9016                          const char* type_of, byte kind);
9017
9018   // Layout description.
9019   static const int kToStringOffset = HeapObject::kHeaderSize;
9020   static const int kToNumberOffset = kToStringOffset + kPointerSize;
9021   static const int kTypeOfOffset = kToNumberOffset + kPointerSize;
9022   static const int kKindOffset = kTypeOfOffset + kPointerSize;
9023   static const int kSize = kKindOffset + kPointerSize;
9024
9025   static const byte kFalse = 0;
9026   static const byte kTrue = 1;
9027   static const byte kNotBooleanMask = ~1;
9028   static const byte kTheHole = 2;
9029   static const byte kNull = 3;
9030   static const byte kArgumentMarker = 4;
9031   static const byte kUndefined = 5;
9032   static const byte kUninitialized = 6;
9033   static const byte kOther = 7;
9034   static const byte kException = 8;
9035
9036   typedef FixedBodyDescriptor<kToStringOffset, kTypeOfOffset + kPointerSize,
9037                               kSize> BodyDescriptor;
9038
9039   STATIC_ASSERT(kKindOffset == Internals::kOddballKindOffset);
9040   STATIC_ASSERT(kNull == Internals::kNullOddballKind);
9041   STATIC_ASSERT(kUndefined == Internals::kUndefinedOddballKind);
9042
9043  private:
9044   DISALLOW_IMPLICIT_CONSTRUCTORS(Oddball);
9045 };
9046
9047
9048 class Cell: public HeapObject {
9049  public:
9050   // [value]: value of the cell.
9051   DECL_ACCESSORS(value, Object)
9052
9053   DECLARE_CAST(Cell)
9054
9055   static inline Cell* FromValueAddress(Address value) {
9056     Object* result = FromAddress(value - kValueOffset);
9057     return static_cast<Cell*>(result);
9058   }
9059
9060   inline Address ValueAddress() {
9061     return address() + kValueOffset;
9062   }
9063
9064   // Dispatched behavior.
9065   DECLARE_PRINTER(Cell)
9066   DECLARE_VERIFIER(Cell)
9067
9068   // Layout description.
9069   static const int kValueOffset = HeapObject::kHeaderSize;
9070   static const int kSize = kValueOffset + kPointerSize;
9071
9072   typedef FixedBodyDescriptor<kValueOffset,
9073                               kValueOffset + kPointerSize,
9074                               kSize> BodyDescriptor;
9075
9076  private:
9077   DISALLOW_IMPLICIT_CONSTRUCTORS(Cell);
9078 };
9079
9080
9081 class PropertyCell : public HeapObject {
9082  public:
9083   // [property_details]: details of the global property.
9084   DECL_ACCESSORS(property_details_raw, Object)
9085   // [value]: value of the global property.
9086   DECL_ACCESSORS(value, Object)
9087   // [dependent_code]: dependent code that depends on the type of the global
9088   // property.
9089   DECL_ACCESSORS(dependent_code, DependentCode)
9090
9091   inline PropertyDetails property_details();
9092   inline void set_property_details(PropertyDetails details);
9093
9094   PropertyCellConstantType GetConstantType();
9095
9096   // Computes the new type of the cell's contents for the given value, but
9097   // without actually modifying the details.
9098   static PropertyCellType UpdatedType(Handle<PropertyCell> cell,
9099                                       Handle<Object> value,
9100                                       PropertyDetails details);
9101   static void UpdateCell(Handle<GlobalDictionary> dictionary, int entry,
9102                          Handle<Object> value, PropertyDetails details);
9103
9104   static Handle<PropertyCell> InvalidateEntry(
9105       Handle<GlobalDictionary> dictionary, int entry);
9106
9107   static void SetValueWithInvalidation(Handle<PropertyCell> cell,
9108                                        Handle<Object> new_value);
9109
9110   DECLARE_CAST(PropertyCell)
9111
9112   // Dispatched behavior.
9113   DECLARE_PRINTER(PropertyCell)
9114   DECLARE_VERIFIER(PropertyCell)
9115
9116   // Layout description.
9117   static const int kDetailsOffset = HeapObject::kHeaderSize;
9118   static const int kValueOffset = kDetailsOffset + kPointerSize;
9119   static const int kDependentCodeOffset = kValueOffset + kPointerSize;
9120   static const int kSize = kDependentCodeOffset + kPointerSize;
9121
9122   static const int kPointerFieldsBeginOffset = kValueOffset;
9123   static const int kPointerFieldsEndOffset = kSize;
9124
9125   typedef FixedBodyDescriptor<kValueOffset,
9126                               kSize,
9127                               kSize> BodyDescriptor;
9128
9129  private:
9130   DISALLOW_IMPLICIT_CONSTRUCTORS(PropertyCell);
9131 };
9132
9133
9134 class WeakCell : public HeapObject {
9135  public:
9136   inline Object* value() const;
9137
9138   // This should not be called by anyone except GC.
9139   inline void clear();
9140
9141   // This should not be called by anyone except allocator.
9142   inline void initialize(HeapObject* value);
9143
9144   inline bool cleared() const;
9145
9146   DECL_ACCESSORS(next, Object)
9147
9148   inline void clear_next(Heap* heap);
9149
9150   inline bool next_cleared();
9151
9152   DECLARE_CAST(WeakCell)
9153
9154   DECLARE_PRINTER(WeakCell)
9155   DECLARE_VERIFIER(WeakCell)
9156
9157   // Layout description.
9158   static const int kValueOffset = HeapObject::kHeaderSize;
9159   static const int kNextOffset = kValueOffset + kPointerSize;
9160   static const int kSize = kNextOffset + kPointerSize;
9161
9162   typedef FixedBodyDescriptor<kValueOffset, kSize, kSize> BodyDescriptor;
9163
9164  private:
9165   DISALLOW_IMPLICIT_CONSTRUCTORS(WeakCell);
9166 };
9167
9168
9169 // The JSProxy describes EcmaScript Harmony proxies
9170 class JSProxy: public JSReceiver {
9171  public:
9172   // [handler]: The handler property.
9173   DECL_ACCESSORS(handler, Object)
9174
9175   // [hash]: The hash code property (undefined if not initialized yet).
9176   DECL_ACCESSORS(hash, Object)
9177
9178   DECLARE_CAST(JSProxy)
9179
9180   MUST_USE_RESULT static MaybeHandle<Object> GetPropertyWithHandler(
9181       Handle<JSProxy> proxy,
9182       Handle<Object> receiver,
9183       Handle<Name> name);
9184
9185   // If the handler defines an accessor property with a setter, invoke it.
9186   // If it defines an accessor property without a setter, or a data property
9187   // that is read-only, throw. In all these cases set '*done' to true,
9188   // otherwise set it to false.
9189   MUST_USE_RESULT
9190   static MaybeHandle<Object> SetPropertyViaPrototypesWithHandler(
9191       Handle<JSProxy> proxy, Handle<Object> receiver, Handle<Name> name,
9192       Handle<Object> value, LanguageMode language_mode, bool* done);
9193
9194   MUST_USE_RESULT static Maybe<PropertyAttributes>
9195       GetPropertyAttributesWithHandler(Handle<JSProxy> proxy,
9196                                        Handle<Object> receiver,
9197                                        Handle<Name> name);
9198   MUST_USE_RESULT static MaybeHandle<Object> SetPropertyWithHandler(
9199       Handle<JSProxy> proxy, Handle<Object> receiver, Handle<Name> name,
9200       Handle<Object> value, LanguageMode language_mode);
9201
9202   // Turn the proxy into an (empty) JSObject.
9203   static void Fix(Handle<JSProxy> proxy);
9204
9205   // Initializes the body after the handler slot.
9206   inline void InitializeBody(int object_size, Object* value);
9207
9208   // Invoke a trap by name. If the trap does not exist on this's handler,
9209   // but derived_trap is non-NULL, invoke that instead.  May cause GC.
9210   MUST_USE_RESULT static MaybeHandle<Object> CallTrap(
9211       Handle<JSProxy> proxy,
9212       const char* name,
9213       Handle<Object> derived_trap,
9214       int argc,
9215       Handle<Object> args[]);
9216
9217   // Dispatched behavior.
9218   DECLARE_PRINTER(JSProxy)
9219   DECLARE_VERIFIER(JSProxy)
9220
9221   // Layout description. We add padding so that a proxy has the same
9222   // size as a virgin JSObject. This is essential for becoming a JSObject
9223   // upon freeze.
9224   static const int kHandlerOffset = HeapObject::kHeaderSize;
9225   static const int kHashOffset = kHandlerOffset + kPointerSize;
9226   static const int kPaddingOffset = kHashOffset + kPointerSize;
9227   static const int kSize = JSObject::kHeaderSize;
9228   static const int kHeaderSize = kPaddingOffset;
9229   static const int kPaddingSize = kSize - kPaddingOffset;
9230
9231   STATIC_ASSERT(kPaddingSize >= 0);
9232
9233   typedef FixedBodyDescriptor<kHandlerOffset,
9234                               kPaddingOffset,
9235                               kSize> BodyDescriptor;
9236
9237  private:
9238   friend class JSReceiver;
9239
9240   MUST_USE_RESULT static Maybe<bool> HasPropertyWithHandler(
9241       Handle<JSProxy> proxy, Handle<Name> name);
9242
9243   MUST_USE_RESULT static MaybeHandle<Object> DeletePropertyWithHandler(
9244       Handle<JSProxy> proxy, Handle<Name> name, LanguageMode language_mode);
9245
9246   MUST_USE_RESULT Object* GetIdentityHash();
9247
9248   static Handle<Smi> GetOrCreateIdentityHash(Handle<JSProxy> proxy);
9249
9250   DISALLOW_IMPLICIT_CONSTRUCTORS(JSProxy);
9251 };
9252
9253
9254 class JSFunctionProxy: public JSProxy {
9255  public:
9256   // [call_trap]: The call trap.
9257   DECL_ACCESSORS(call_trap, Object)
9258
9259   // [construct_trap]: The construct trap.
9260   DECL_ACCESSORS(construct_trap, Object)
9261
9262   DECLARE_CAST(JSFunctionProxy)
9263
9264   // Dispatched behavior.
9265   DECLARE_PRINTER(JSFunctionProxy)
9266   DECLARE_VERIFIER(JSFunctionProxy)
9267
9268   // Layout description.
9269   static const int kCallTrapOffset = JSProxy::kPaddingOffset;
9270   static const int kConstructTrapOffset = kCallTrapOffset + kPointerSize;
9271   static const int kPaddingOffset = kConstructTrapOffset + kPointerSize;
9272   static const int kSize = JSFunction::kSize;
9273   static const int kPaddingSize = kSize - kPaddingOffset;
9274
9275   STATIC_ASSERT(kPaddingSize >= 0);
9276
9277   typedef FixedBodyDescriptor<kHandlerOffset,
9278                               kConstructTrapOffset + kPointerSize,
9279                               kSize> BodyDescriptor;
9280
9281  private:
9282   DISALLOW_IMPLICIT_CONSTRUCTORS(JSFunctionProxy);
9283 };
9284
9285
9286 class JSCollection : public JSObject {
9287  public:
9288   // [table]: the backing hash table
9289   DECL_ACCESSORS(table, Object)
9290
9291   static const int kTableOffset = JSObject::kHeaderSize;
9292   static const int kSize = kTableOffset + kPointerSize;
9293
9294  private:
9295   DISALLOW_IMPLICIT_CONSTRUCTORS(JSCollection);
9296 };
9297
9298
9299 // The JSSet describes EcmaScript Harmony sets
9300 class JSSet : public JSCollection {
9301  public:
9302   DECLARE_CAST(JSSet)
9303
9304   // Dispatched behavior.
9305   DECLARE_PRINTER(JSSet)
9306   DECLARE_VERIFIER(JSSet)
9307
9308  private:
9309   DISALLOW_IMPLICIT_CONSTRUCTORS(JSSet);
9310 };
9311
9312
9313 // The JSMap describes EcmaScript Harmony maps
9314 class JSMap : public JSCollection {
9315  public:
9316   DECLARE_CAST(JSMap)
9317
9318   // Dispatched behavior.
9319   DECLARE_PRINTER(JSMap)
9320   DECLARE_VERIFIER(JSMap)
9321
9322  private:
9323   DISALLOW_IMPLICIT_CONSTRUCTORS(JSMap);
9324 };
9325
9326
9327 // OrderedHashTableIterator is an iterator that iterates over the keys and
9328 // values of an OrderedHashTable.
9329 //
9330 // The iterator has a reference to the underlying OrderedHashTable data,
9331 // [table], as well as the current [index] the iterator is at.
9332 //
9333 // When the OrderedHashTable is rehashed it adds a reference from the old table
9334 // to the new table as well as storing enough data about the changes so that the
9335 // iterator [index] can be adjusted accordingly.
9336 //
9337 // When the [Next] result from the iterator is requested, the iterator checks if
9338 // there is a newer table that it needs to transition to.
9339 template<class Derived, class TableType>
9340 class OrderedHashTableIterator: public JSObject {
9341  public:
9342   // [table]: the backing hash table mapping keys to values.
9343   DECL_ACCESSORS(table, Object)
9344
9345   // [index]: The index into the data table.
9346   DECL_ACCESSORS(index, Object)
9347
9348   // [kind]: The kind of iteration this is. One of the [Kind] enum values.
9349   DECL_ACCESSORS(kind, Object)
9350
9351 #ifdef OBJECT_PRINT
9352   void OrderedHashTableIteratorPrint(std::ostream& os);  // NOLINT
9353 #endif
9354
9355   static const int kTableOffset = JSObject::kHeaderSize;
9356   static const int kIndexOffset = kTableOffset + kPointerSize;
9357   static const int kKindOffset = kIndexOffset + kPointerSize;
9358   static const int kSize = kKindOffset + kPointerSize;
9359
9360   enum Kind {
9361     kKindKeys = 1,
9362     kKindValues = 2,
9363     kKindEntries = 3
9364   };
9365
9366   // Whether the iterator has more elements. This needs to be called before
9367   // calling |CurrentKey| and/or |CurrentValue|.
9368   bool HasMore();
9369
9370   // Move the index forward one.
9371   void MoveNext() {
9372     set_index(Smi::FromInt(Smi::cast(index())->value() + 1));
9373   }
9374
9375   // Populates the array with the next key and value and then moves the iterator
9376   // forward.
9377   // This returns the |kind| or 0 if the iterator is already at the end.
9378   Smi* Next(JSArray* value_array);
9379
9380   // Returns the current key of the iterator. This should only be called when
9381   // |HasMore| returns true.
9382   inline Object* CurrentKey();
9383
9384  private:
9385   // Transitions the iterator to the non obsolete backing store. This is a NOP
9386   // if the [table] is not obsolete.
9387   void Transition();
9388
9389   DISALLOW_IMPLICIT_CONSTRUCTORS(OrderedHashTableIterator);
9390 };
9391
9392
9393 class JSSetIterator: public OrderedHashTableIterator<JSSetIterator,
9394                                                      OrderedHashSet> {
9395  public:
9396   // Dispatched behavior.
9397   DECLARE_PRINTER(JSSetIterator)
9398   DECLARE_VERIFIER(JSSetIterator)
9399
9400   DECLARE_CAST(JSSetIterator)
9401
9402   // Called by |Next| to populate the array. This allows the subclasses to
9403   // populate the array differently.
9404   inline void PopulateValueArray(FixedArray* array);
9405
9406  private:
9407   DISALLOW_IMPLICIT_CONSTRUCTORS(JSSetIterator);
9408 };
9409
9410
9411 class JSMapIterator: public OrderedHashTableIterator<JSMapIterator,
9412                                                      OrderedHashMap> {
9413  public:
9414   // Dispatched behavior.
9415   DECLARE_PRINTER(JSMapIterator)
9416   DECLARE_VERIFIER(JSMapIterator)
9417
9418   DECLARE_CAST(JSMapIterator)
9419
9420   // Called by |Next| to populate the array. This allows the subclasses to
9421   // populate the array differently.
9422   inline void PopulateValueArray(FixedArray* array);
9423
9424  private:
9425   // Returns the current value of the iterator. This should only be called when
9426   // |HasMore| returns true.
9427   inline Object* CurrentValue();
9428
9429   DISALLOW_IMPLICIT_CONSTRUCTORS(JSMapIterator);
9430 };
9431
9432
9433 // Base class for both JSWeakMap and JSWeakSet
9434 class JSWeakCollection: public JSObject {
9435  public:
9436   // [table]: the backing hash table mapping keys to values.
9437   DECL_ACCESSORS(table, Object)
9438
9439   // [next]: linked list of encountered weak maps during GC.
9440   DECL_ACCESSORS(next, Object)
9441
9442   static const int kTableOffset = JSObject::kHeaderSize;
9443   static const int kNextOffset = kTableOffset + kPointerSize;
9444   static const int kSize = kNextOffset + kPointerSize;
9445
9446  private:
9447   DISALLOW_IMPLICIT_CONSTRUCTORS(JSWeakCollection);
9448 };
9449
9450
9451 // The JSWeakMap describes EcmaScript Harmony weak maps
9452 class JSWeakMap: public JSWeakCollection {
9453  public:
9454   DECLARE_CAST(JSWeakMap)
9455
9456   // Dispatched behavior.
9457   DECLARE_PRINTER(JSWeakMap)
9458   DECLARE_VERIFIER(JSWeakMap)
9459
9460  private:
9461   DISALLOW_IMPLICIT_CONSTRUCTORS(JSWeakMap);
9462 };
9463
9464
9465 // The JSWeakSet describes EcmaScript Harmony weak sets
9466 class JSWeakSet: public JSWeakCollection {
9467  public:
9468   DECLARE_CAST(JSWeakSet)
9469
9470   // Dispatched behavior.
9471   DECLARE_PRINTER(JSWeakSet)
9472   DECLARE_VERIFIER(JSWeakSet)
9473
9474  private:
9475   DISALLOW_IMPLICIT_CONSTRUCTORS(JSWeakSet);
9476 };
9477
9478
9479 // Whether a JSArrayBuffer is a SharedArrayBuffer or not.
9480 enum class SharedFlag { kNotShared, kShared };
9481
9482
9483 class JSArrayBuffer: public JSObject {
9484  public:
9485   // [backing_store]: backing memory for this array
9486   DECL_ACCESSORS(backing_store, void)
9487
9488   // [byte_length]: length in bytes
9489   DECL_ACCESSORS(byte_length, Object)
9490
9491   inline uint32_t bit_field() const;
9492   inline void set_bit_field(uint32_t bits);
9493
9494   inline bool is_external();
9495   inline void set_is_external(bool value);
9496
9497   inline bool is_neuterable();
9498   inline void set_is_neuterable(bool value);
9499
9500   inline bool was_neutered();
9501   inline void set_was_neutered(bool value);
9502
9503   inline bool is_shared();
9504   inline void set_is_shared(bool value);
9505
9506   DECLARE_CAST(JSArrayBuffer)
9507
9508   void Neuter();
9509
9510   // Dispatched behavior.
9511   DECLARE_PRINTER(JSArrayBuffer)
9512   DECLARE_VERIFIER(JSArrayBuffer)
9513
9514   static const int kBackingStoreOffset = JSObject::kHeaderSize;
9515   static const int kByteLengthOffset = kBackingStoreOffset + kPointerSize;
9516   static const int kBitFieldSlot = kByteLengthOffset + kPointerSize;
9517 #if V8_TARGET_LITTLE_ENDIAN || !V8_HOST_ARCH_64_BIT
9518   static const int kBitFieldOffset = kBitFieldSlot;
9519 #else
9520   static const int kBitFieldOffset = kBitFieldSlot + kIntSize;
9521 #endif
9522   static const int kSize = kBitFieldSlot + kPointerSize;
9523
9524   static const int kSizeWithInternalFields =
9525       kSize + v8::ArrayBuffer::kInternalFieldCount * kPointerSize;
9526
9527   class IsExternal : public BitField<bool, 1, 1> {};
9528   class IsNeuterable : public BitField<bool, 2, 1> {};
9529   class WasNeutered : public BitField<bool, 3, 1> {};
9530   class IsShared : public BitField<bool, 4, 1> {};
9531
9532  private:
9533   DISALLOW_IMPLICIT_CONSTRUCTORS(JSArrayBuffer);
9534 };
9535
9536
9537 class JSArrayBufferView: public JSObject {
9538  public:
9539   // [buffer]: ArrayBuffer that this typed array views.
9540   DECL_ACCESSORS(buffer, Object)
9541
9542   // [byte_offset]: offset of typed array in bytes.
9543   DECL_ACCESSORS(byte_offset, Object)
9544
9545   // [byte_length]: length of typed array in bytes.
9546   DECL_ACCESSORS(byte_length, Object)
9547
9548   DECLARE_CAST(JSArrayBufferView)
9549
9550   DECLARE_VERIFIER(JSArrayBufferView)
9551
9552   inline bool WasNeutered() const;
9553
9554   static const int kBufferOffset = JSObject::kHeaderSize;
9555   static const int kByteOffsetOffset = kBufferOffset + kPointerSize;
9556   static const int kByteLengthOffset = kByteOffsetOffset + kPointerSize;
9557   static const int kViewSize = kByteLengthOffset + kPointerSize;
9558
9559  private:
9560 #ifdef VERIFY_HEAP
9561   DECL_ACCESSORS(raw_byte_offset, Object)
9562   DECL_ACCESSORS(raw_byte_length, Object)
9563 #endif
9564
9565   DISALLOW_IMPLICIT_CONSTRUCTORS(JSArrayBufferView);
9566 };
9567
9568
9569 class JSTypedArray: public JSArrayBufferView {
9570  public:
9571   // [length]: length of typed array in elements.
9572   DECL_ACCESSORS(length, Object)
9573   inline uint32_t length_value() const;
9574
9575   DECLARE_CAST(JSTypedArray)
9576
9577   ExternalArrayType type();
9578   size_t element_size();
9579
9580   Handle<JSArrayBuffer> GetBuffer();
9581
9582   // Dispatched behavior.
9583   DECLARE_PRINTER(JSTypedArray)
9584   DECLARE_VERIFIER(JSTypedArray)
9585
9586   static const int kLengthOffset = kViewSize + kPointerSize;
9587   static const int kSize = kLengthOffset + kPointerSize;
9588
9589   static const int kSizeWithInternalFields =
9590       kSize + v8::ArrayBufferView::kInternalFieldCount * kPointerSize;
9591
9592  private:
9593   static Handle<JSArrayBuffer> MaterializeArrayBuffer(
9594       Handle<JSTypedArray> typed_array);
9595 #ifdef VERIFY_HEAP
9596   DECL_ACCESSORS(raw_length, Object)
9597 #endif
9598
9599   DISALLOW_IMPLICIT_CONSTRUCTORS(JSTypedArray);
9600 };
9601
9602
9603 class JSDataView: public JSArrayBufferView {
9604  public:
9605   DECLARE_CAST(JSDataView)
9606
9607   // Dispatched behavior.
9608   DECLARE_PRINTER(JSDataView)
9609   DECLARE_VERIFIER(JSDataView)
9610
9611   static const int kSize = kViewSize;
9612
9613   static const int kSizeWithInternalFields =
9614       kSize + v8::ArrayBufferView::kInternalFieldCount * kPointerSize;
9615
9616  private:
9617   DISALLOW_IMPLICIT_CONSTRUCTORS(JSDataView);
9618 };
9619
9620
9621 // Foreign describes objects pointing from JavaScript to C structures.
9622 class Foreign: public HeapObject {
9623  public:
9624   // [address]: field containing the address.
9625   inline Address foreign_address();
9626   inline void set_foreign_address(Address value);
9627
9628   DECLARE_CAST(Foreign)
9629
9630   // Dispatched behavior.
9631   inline void ForeignIterateBody(ObjectVisitor* v);
9632
9633   template<typename StaticVisitor>
9634   inline void ForeignIterateBody();
9635
9636   // Dispatched behavior.
9637   DECLARE_PRINTER(Foreign)
9638   DECLARE_VERIFIER(Foreign)
9639
9640   // Layout description.
9641
9642   static const int kForeignAddressOffset = HeapObject::kHeaderSize;
9643   static const int kSize = kForeignAddressOffset + kPointerSize;
9644
9645   STATIC_ASSERT(kForeignAddressOffset == Internals::kForeignAddressOffset);
9646
9647  private:
9648   DISALLOW_IMPLICIT_CONSTRUCTORS(Foreign);
9649 };
9650
9651
9652 // The JSArray describes JavaScript Arrays
9653 //  Such an array can be in one of two modes:
9654 //    - fast, backing storage is a FixedArray and length <= elements.length();
9655 //       Please note: push and pop can be used to grow and shrink the array.
9656 //    - slow, backing storage is a HashTable with numbers as keys.
9657 class JSArray: public JSObject {
9658  public:
9659   // [length]: The length property.
9660   DECL_ACCESSORS(length, Object)
9661
9662   // Overload the length setter to skip write barrier when the length
9663   // is set to a smi. This matches the set function on FixedArray.
9664   inline void set_length(Smi* length);
9665
9666   static bool HasReadOnlyLength(Handle<JSArray> array);
9667   static bool WouldChangeReadOnlyLength(Handle<JSArray> array, uint32_t index);
9668   static MaybeHandle<Object> ReadOnlyLengthError(Handle<JSArray> array);
9669
9670   // Initialize the array with the given capacity. The function may
9671   // fail due to out-of-memory situations, but only if the requested
9672   // capacity is non-zero.
9673   static void Initialize(Handle<JSArray> array, int capacity, int length = 0);
9674
9675   // If the JSArray has fast elements, and new_length would result in
9676   // normalization, returns true.
9677   bool SetLengthWouldNormalize(uint32_t new_length);
9678   static inline bool SetLengthWouldNormalize(Heap* heap, uint32_t new_length);
9679
9680   // Initializes the array to a certain length.
9681   inline bool AllowsSetLength();
9682
9683   static void SetLength(Handle<JSArray> array, uint32_t length);
9684   // Same as above but will also queue splice records if |array| is observed.
9685   static MaybeHandle<Object> ObservableSetLength(Handle<JSArray> array,
9686                                                  uint32_t length);
9687
9688   // Set the content of the array to the content of storage.
9689   static inline void SetContent(Handle<JSArray> array,
9690                                 Handle<FixedArrayBase> storage);
9691
9692   DECLARE_CAST(JSArray)
9693
9694   // Dispatched behavior.
9695   DECLARE_PRINTER(JSArray)
9696   DECLARE_VERIFIER(JSArray)
9697
9698   // Number of element slots to pre-allocate for an empty array.
9699   static const int kPreallocatedArrayElements = 4;
9700
9701   // Layout description.
9702   static const int kLengthOffset = JSObject::kHeaderSize;
9703   static const int kSize = kLengthOffset + kPointerSize;
9704
9705  private:
9706   DISALLOW_IMPLICIT_CONSTRUCTORS(JSArray);
9707 };
9708
9709
9710 Handle<Object> CacheInitialJSArrayMaps(Handle<Context> native_context,
9711                                        Handle<Map> initial_map);
9712
9713
9714 // JSRegExpResult is just a JSArray with a specific initial map.
9715 // This initial map adds in-object properties for "index" and "input"
9716 // properties, as assigned by RegExp.prototype.exec, which allows
9717 // faster creation of RegExp exec results.
9718 // This class just holds constants used when creating the result.
9719 // After creation the result must be treated as a JSArray in all regards.
9720 class JSRegExpResult: public JSArray {
9721  public:
9722   // Offsets of object fields.
9723   static const int kIndexOffset = JSArray::kSize;
9724   static const int kInputOffset = kIndexOffset + kPointerSize;
9725   static const int kSize = kInputOffset + kPointerSize;
9726   // Indices of in-object properties.
9727   static const int kIndexIndex = 0;
9728   static const int kInputIndex = 1;
9729  private:
9730   DISALLOW_IMPLICIT_CONSTRUCTORS(JSRegExpResult);
9731 };
9732
9733
9734 class AccessorInfo: public Struct {
9735  public:
9736   DECL_ACCESSORS(name, Object)
9737   DECL_ACCESSORS(flag, Smi)
9738   DECL_ACCESSORS(expected_receiver_type, Object)
9739
9740   inline bool all_can_read();
9741   inline void set_all_can_read(bool value);
9742
9743   inline bool all_can_write();
9744   inline void set_all_can_write(bool value);
9745
9746   inline bool is_special_data_property();
9747   inline void set_is_special_data_property(bool value);
9748
9749   inline PropertyAttributes property_attributes();
9750   inline void set_property_attributes(PropertyAttributes attributes);
9751
9752   // Checks whether the given receiver is compatible with this accessor.
9753   static bool IsCompatibleReceiverMap(Isolate* isolate,
9754                                       Handle<AccessorInfo> info,
9755                                       Handle<Map> map);
9756   inline bool IsCompatibleReceiver(Object* receiver);
9757
9758   DECLARE_CAST(AccessorInfo)
9759
9760   // Dispatched behavior.
9761   DECLARE_VERIFIER(AccessorInfo)
9762
9763   // Append all descriptors to the array that are not already there.
9764   // Return number added.
9765   static int AppendUnique(Handle<Object> descriptors,
9766                           Handle<FixedArray> array,
9767                           int valid_descriptors);
9768
9769   static const int kNameOffset = HeapObject::kHeaderSize;
9770   static const int kFlagOffset = kNameOffset + kPointerSize;
9771   static const int kExpectedReceiverTypeOffset = kFlagOffset + kPointerSize;
9772   static const int kSize = kExpectedReceiverTypeOffset + kPointerSize;
9773
9774  private:
9775   inline bool HasExpectedReceiverType();
9776
9777   // Bit positions in flag.
9778   static const int kAllCanReadBit = 0;
9779   static const int kAllCanWriteBit = 1;
9780   static const int kSpecialDataProperty = 2;
9781   class AttributesField : public BitField<PropertyAttributes, 3, 3> {};
9782
9783   DISALLOW_IMPLICIT_CONSTRUCTORS(AccessorInfo);
9784 };
9785
9786
9787 // An accessor must have a getter, but can have no setter.
9788 //
9789 // When setting a property, V8 searches accessors in prototypes.
9790 // If an accessor was found and it does not have a setter,
9791 // the request is ignored.
9792 //
9793 // If the accessor in the prototype has the READ_ONLY property attribute, then
9794 // a new value is added to the derived object when the property is set.
9795 // This shadows the accessor in the prototype.
9796 class ExecutableAccessorInfo: public AccessorInfo {
9797  public:
9798   DECL_ACCESSORS(getter, Object)
9799   DECL_ACCESSORS(setter, Object)
9800   DECL_ACCESSORS(data, Object)
9801
9802   DECLARE_CAST(ExecutableAccessorInfo)
9803
9804   // Dispatched behavior.
9805   DECLARE_PRINTER(ExecutableAccessorInfo)
9806   DECLARE_VERIFIER(ExecutableAccessorInfo)
9807
9808   static const int kGetterOffset = AccessorInfo::kSize;
9809   static const int kSetterOffset = kGetterOffset + kPointerSize;
9810   static const int kDataOffset = kSetterOffset + kPointerSize;
9811   static const int kSize = kDataOffset + kPointerSize;
9812
9813   static void ClearSetter(Handle<ExecutableAccessorInfo> info);
9814
9815  private:
9816   DISALLOW_IMPLICIT_CONSTRUCTORS(ExecutableAccessorInfo);
9817 };
9818
9819
9820 // Support for JavaScript accessors: A pair of a getter and a setter. Each
9821 // accessor can either be
9822 //   * a pointer to a JavaScript function or proxy: a real accessor
9823 //   * undefined: considered an accessor by the spec, too, strangely enough
9824 //   * the hole: an accessor which has not been set
9825 //   * a pointer to a map: a transition used to ensure map sharing
9826 class AccessorPair: public Struct {
9827  public:
9828   DECL_ACCESSORS(getter, Object)
9829   DECL_ACCESSORS(setter, Object)
9830
9831   DECLARE_CAST(AccessorPair)
9832
9833   static Handle<AccessorPair> Copy(Handle<AccessorPair> pair);
9834
9835   inline Object* get(AccessorComponent component);
9836   inline void set(AccessorComponent component, Object* value);
9837
9838   // Note: Returns undefined instead in case of a hole.
9839   Object* GetComponent(AccessorComponent component);
9840
9841   // Set both components, skipping arguments which are a JavaScript null.
9842   inline void SetComponents(Object* getter, Object* setter);
9843
9844   inline bool Equals(AccessorPair* pair);
9845   inline bool Equals(Object* getter_value, Object* setter_value);
9846
9847   inline bool ContainsAccessor();
9848
9849   // Dispatched behavior.
9850   DECLARE_PRINTER(AccessorPair)
9851   DECLARE_VERIFIER(AccessorPair)
9852
9853   static const int kGetterOffset = HeapObject::kHeaderSize;
9854   static const int kSetterOffset = kGetterOffset + kPointerSize;
9855   static const int kSize = kSetterOffset + kPointerSize;
9856
9857  private:
9858   // Strangely enough, in addition to functions and harmony proxies, the spec
9859   // requires us to consider undefined as a kind of accessor, too:
9860   //    var obj = {};
9861   //    Object.defineProperty(obj, "foo", {get: undefined});
9862   //    assertTrue("foo" in obj);
9863   inline bool IsJSAccessor(Object* obj);
9864
9865   DISALLOW_IMPLICIT_CONSTRUCTORS(AccessorPair);
9866 };
9867
9868
9869 class AccessCheckInfo: public Struct {
9870  public:
9871   DECL_ACCESSORS(named_callback, Object)
9872   DECL_ACCESSORS(indexed_callback, Object)
9873   DECL_ACCESSORS(data, Object)
9874
9875   DECLARE_CAST(AccessCheckInfo)
9876
9877   // Dispatched behavior.
9878   DECLARE_PRINTER(AccessCheckInfo)
9879   DECLARE_VERIFIER(AccessCheckInfo)
9880
9881   static const int kNamedCallbackOffset   = HeapObject::kHeaderSize;
9882   static const int kIndexedCallbackOffset = kNamedCallbackOffset + kPointerSize;
9883   static const int kDataOffset = kIndexedCallbackOffset + kPointerSize;
9884   static const int kSize = kDataOffset + kPointerSize;
9885
9886  private:
9887   DISALLOW_IMPLICIT_CONSTRUCTORS(AccessCheckInfo);
9888 };
9889
9890
9891 class InterceptorInfo: public Struct {
9892  public:
9893   DECL_ACCESSORS(getter, Object)
9894   DECL_ACCESSORS(setter, Object)
9895   DECL_ACCESSORS(query, Object)
9896   DECL_ACCESSORS(deleter, Object)
9897   DECL_ACCESSORS(enumerator, Object)
9898   DECL_ACCESSORS(data, Object)
9899   DECL_BOOLEAN_ACCESSORS(can_intercept_symbols)
9900   DECL_BOOLEAN_ACCESSORS(all_can_read)
9901   DECL_BOOLEAN_ACCESSORS(non_masking)
9902
9903   inline int flags() const;
9904   inline void set_flags(int flags);
9905
9906   DECLARE_CAST(InterceptorInfo)
9907
9908   // Dispatched behavior.
9909   DECLARE_PRINTER(InterceptorInfo)
9910   DECLARE_VERIFIER(InterceptorInfo)
9911
9912   static const int kGetterOffset = HeapObject::kHeaderSize;
9913   static const int kSetterOffset = kGetterOffset + kPointerSize;
9914   static const int kQueryOffset = kSetterOffset + kPointerSize;
9915   static const int kDeleterOffset = kQueryOffset + kPointerSize;
9916   static const int kEnumeratorOffset = kDeleterOffset + kPointerSize;
9917   static const int kDataOffset = kEnumeratorOffset + kPointerSize;
9918   static const int kFlagsOffset = kDataOffset + kPointerSize;
9919   static const int kSize = kFlagsOffset + kPointerSize;
9920
9921   static const int kCanInterceptSymbolsBit = 0;
9922   static const int kAllCanReadBit = 1;
9923   static const int kNonMasking = 2;
9924
9925  private:
9926   DISALLOW_IMPLICIT_CONSTRUCTORS(InterceptorInfo);
9927 };
9928
9929
9930 class CallHandlerInfo: public Struct {
9931  public:
9932   DECL_ACCESSORS(callback, Object)
9933   DECL_ACCESSORS(data, Object)
9934
9935   DECLARE_CAST(CallHandlerInfo)
9936
9937   // Dispatched behavior.
9938   DECLARE_PRINTER(CallHandlerInfo)
9939   DECLARE_VERIFIER(CallHandlerInfo)
9940
9941   static const int kCallbackOffset = HeapObject::kHeaderSize;
9942   static const int kDataOffset = kCallbackOffset + kPointerSize;
9943   static const int kSize = kDataOffset + kPointerSize;
9944
9945  private:
9946   DISALLOW_IMPLICIT_CONSTRUCTORS(CallHandlerInfo);
9947 };
9948
9949
9950 class TemplateInfo: public Struct {
9951  public:
9952   DECL_ACCESSORS(tag, Object)
9953   inline int number_of_properties() const;
9954   inline void set_number_of_properties(int value);
9955   DECL_ACCESSORS(property_list, Object)
9956   DECL_ACCESSORS(property_accessors, Object)
9957
9958   DECLARE_VERIFIER(TemplateInfo)
9959
9960   static const int kTagOffset = HeapObject::kHeaderSize;
9961   static const int kNumberOfProperties = kTagOffset + kPointerSize;
9962   static const int kPropertyListOffset = kNumberOfProperties + kPointerSize;
9963   static const int kPropertyAccessorsOffset =
9964       kPropertyListOffset + kPointerSize;
9965   static const int kHeaderSize = kPropertyAccessorsOffset + kPointerSize;
9966
9967  private:
9968   DISALLOW_IMPLICIT_CONSTRUCTORS(TemplateInfo);
9969 };
9970
9971
9972 class FunctionTemplateInfo: public TemplateInfo {
9973  public:
9974   DECL_ACCESSORS(serial_number, Object)
9975   DECL_ACCESSORS(call_code, Object)
9976   DECL_ACCESSORS(prototype_template, Object)
9977   DECL_ACCESSORS(parent_template, Object)
9978   DECL_ACCESSORS(named_property_handler, Object)
9979   DECL_ACCESSORS(indexed_property_handler, Object)
9980   DECL_ACCESSORS(instance_template, Object)
9981   DECL_ACCESSORS(class_name, Object)
9982   DECL_ACCESSORS(signature, Object)
9983   DECL_ACCESSORS(instance_call_handler, Object)
9984   DECL_ACCESSORS(access_check_info, Object)
9985   DECL_ACCESSORS(flag, Smi)
9986
9987   inline int length() const;
9988   inline void set_length(int value);
9989
9990   // Following properties use flag bits.
9991   DECL_BOOLEAN_ACCESSORS(hidden_prototype)
9992   DECL_BOOLEAN_ACCESSORS(undetectable)
9993   // If the bit is set, object instances created by this function
9994   // requires access check.
9995   DECL_BOOLEAN_ACCESSORS(needs_access_check)
9996   DECL_BOOLEAN_ACCESSORS(read_only_prototype)
9997   DECL_BOOLEAN_ACCESSORS(remove_prototype)
9998   DECL_BOOLEAN_ACCESSORS(do_not_cache)
9999   DECL_BOOLEAN_ACCESSORS(instantiated)
10000   DECL_BOOLEAN_ACCESSORS(accept_any_receiver)
10001
10002   DECLARE_CAST(FunctionTemplateInfo)
10003
10004   // Dispatched behavior.
10005   DECLARE_PRINTER(FunctionTemplateInfo)
10006   DECLARE_VERIFIER(FunctionTemplateInfo)
10007
10008   static const int kSerialNumberOffset = TemplateInfo::kHeaderSize;
10009   static const int kCallCodeOffset = kSerialNumberOffset + kPointerSize;
10010   static const int kPrototypeTemplateOffset =
10011       kCallCodeOffset + kPointerSize;
10012   static const int kParentTemplateOffset =
10013       kPrototypeTemplateOffset + kPointerSize;
10014   static const int kNamedPropertyHandlerOffset =
10015       kParentTemplateOffset + kPointerSize;
10016   static const int kIndexedPropertyHandlerOffset =
10017       kNamedPropertyHandlerOffset + kPointerSize;
10018   static const int kInstanceTemplateOffset =
10019       kIndexedPropertyHandlerOffset + kPointerSize;
10020   static const int kClassNameOffset = kInstanceTemplateOffset + kPointerSize;
10021   static const int kSignatureOffset = kClassNameOffset + kPointerSize;
10022   static const int kInstanceCallHandlerOffset = kSignatureOffset + kPointerSize;
10023   static const int kAccessCheckInfoOffset =
10024       kInstanceCallHandlerOffset + kPointerSize;
10025   static const int kFlagOffset = kAccessCheckInfoOffset + kPointerSize;
10026   static const int kLengthOffset = kFlagOffset + kPointerSize;
10027   static const int kSize = kLengthOffset + kPointerSize;
10028
10029   // Returns true if |object| is an instance of this function template.
10030   bool IsTemplateFor(Object* object);
10031   bool IsTemplateFor(Map* map);
10032
10033   // Returns the holder JSObject if the function can legally be called with this
10034   // receiver.  Returns Heap::null_value() if the call is illegal.
10035   Object* GetCompatibleReceiver(Isolate* isolate, Object* receiver);
10036
10037  private:
10038   // Bit position in the flag, from least significant bit position.
10039   static const int kHiddenPrototypeBit   = 0;
10040   static const int kUndetectableBit      = 1;
10041   static const int kNeedsAccessCheckBit  = 2;
10042   static const int kReadOnlyPrototypeBit = 3;
10043   static const int kRemovePrototypeBit   = 4;
10044   static const int kDoNotCacheBit        = 5;
10045   static const int kInstantiatedBit      = 6;
10046   static const int kAcceptAnyReceiver = 7;
10047
10048   DISALLOW_IMPLICIT_CONSTRUCTORS(FunctionTemplateInfo);
10049 };
10050
10051
10052 class ObjectTemplateInfo: public TemplateInfo {
10053  public:
10054   DECL_ACCESSORS(constructor, Object)
10055   DECL_ACCESSORS(internal_field_count, Object)
10056
10057   DECLARE_CAST(ObjectTemplateInfo)
10058
10059   // Dispatched behavior.
10060   DECLARE_PRINTER(ObjectTemplateInfo)
10061   DECLARE_VERIFIER(ObjectTemplateInfo)
10062
10063   static const int kConstructorOffset = TemplateInfo::kHeaderSize;
10064   static const int kInternalFieldCountOffset =
10065       kConstructorOffset + kPointerSize;
10066   static const int kSize = kInternalFieldCountOffset + kPointerSize;
10067 };
10068
10069
10070 class TypeSwitchInfo: public Struct {
10071  public:
10072   DECL_ACCESSORS(types, Object)
10073
10074   DECLARE_CAST(TypeSwitchInfo)
10075
10076   // Dispatched behavior.
10077   DECLARE_PRINTER(TypeSwitchInfo)
10078   DECLARE_VERIFIER(TypeSwitchInfo)
10079
10080   static const int kTypesOffset = Struct::kHeaderSize;
10081   static const int kSize        = kTypesOffset + kPointerSize;
10082 };
10083
10084
10085 // The DebugInfo class holds additional information for a function being
10086 // debugged.
10087 class DebugInfo: public Struct {
10088  public:
10089   // The shared function info for the source being debugged.
10090   DECL_ACCESSORS(shared, SharedFunctionInfo)
10091   // Code object for the patched code. This code object is the code object
10092   // currently active for the function.
10093   DECL_ACCESSORS(code, Code)
10094   // Fixed array holding status information for each active break point.
10095   DECL_ACCESSORS(break_points, FixedArray)
10096
10097   // Check if there is a break point at a code position.
10098   bool HasBreakPoint(int code_position);
10099   // Get the break point info object for a code position.
10100   Object* GetBreakPointInfo(int code_position);
10101   // Clear a break point.
10102   static void ClearBreakPoint(Handle<DebugInfo> debug_info,
10103                               int code_position,
10104                               Handle<Object> break_point_object);
10105   // Set a break point.
10106   static void SetBreakPoint(Handle<DebugInfo> debug_info, int code_position,
10107                             int source_position, int statement_position,
10108                             Handle<Object> break_point_object);
10109   // Get the break point objects for a code position.
10110   Handle<Object> GetBreakPointObjects(int code_position);
10111   // Find the break point info holding this break point object.
10112   static Handle<Object> FindBreakPointInfo(Handle<DebugInfo> debug_info,
10113                                            Handle<Object> break_point_object);
10114   // Get the number of break points for this function.
10115   int GetBreakPointCount();
10116
10117   DECLARE_CAST(DebugInfo)
10118
10119   // Dispatched behavior.
10120   DECLARE_PRINTER(DebugInfo)
10121   DECLARE_VERIFIER(DebugInfo)
10122
10123   static const int kSharedFunctionInfoIndex = Struct::kHeaderSize;
10124   static const int kCodeIndex = kSharedFunctionInfoIndex + kPointerSize;
10125   static const int kBreakPointsStateIndex = kCodeIndex + kPointerSize;
10126   static const int kSize = kBreakPointsStateIndex + kPointerSize;
10127
10128   static const int kEstimatedNofBreakPointsInFunction = 16;
10129
10130  private:
10131   static const int kNoBreakPointInfo = -1;
10132
10133   // Lookup the index in the break_points array for a code position.
10134   int GetBreakPointInfoIndex(int code_position);
10135
10136   DISALLOW_IMPLICIT_CONSTRUCTORS(DebugInfo);
10137 };
10138
10139
10140 // The BreakPointInfo class holds information for break points set in a
10141 // function. The DebugInfo object holds a BreakPointInfo object for each code
10142 // position with one or more break points.
10143 class BreakPointInfo: public Struct {
10144  public:
10145   // The position in the code for the break point.
10146   DECL_ACCESSORS(code_position, Smi)
10147   // The position in the source for the break position.
10148   DECL_ACCESSORS(source_position, Smi)
10149   // The position in the source for the last statement before this break
10150   // position.
10151   DECL_ACCESSORS(statement_position, Smi)
10152   // List of related JavaScript break points.
10153   DECL_ACCESSORS(break_point_objects, Object)
10154
10155   // Removes a break point.
10156   static void ClearBreakPoint(Handle<BreakPointInfo> info,
10157                               Handle<Object> break_point_object);
10158   // Set a break point.
10159   static void SetBreakPoint(Handle<BreakPointInfo> info,
10160                             Handle<Object> break_point_object);
10161   // Check if break point info has this break point object.
10162   static bool HasBreakPointObject(Handle<BreakPointInfo> info,
10163                                   Handle<Object> break_point_object);
10164   // Get the number of break points for this code position.
10165   int GetBreakPointCount();
10166
10167   DECLARE_CAST(BreakPointInfo)
10168
10169   // Dispatched behavior.
10170   DECLARE_PRINTER(BreakPointInfo)
10171   DECLARE_VERIFIER(BreakPointInfo)
10172
10173   static const int kCodePositionIndex = Struct::kHeaderSize;
10174   static const int kSourcePositionIndex = kCodePositionIndex + kPointerSize;
10175   static const int kStatementPositionIndex =
10176       kSourcePositionIndex + kPointerSize;
10177   static const int kBreakPointObjectsIndex =
10178       kStatementPositionIndex + kPointerSize;
10179   static const int kSize = kBreakPointObjectsIndex + kPointerSize;
10180
10181  private:
10182   DISALLOW_IMPLICIT_CONSTRUCTORS(BreakPointInfo);
10183 };
10184
10185
10186 #undef DECL_BOOLEAN_ACCESSORS
10187 #undef DECL_ACCESSORS
10188 #undef DECLARE_CAST
10189 #undef DECLARE_VERIFIER
10190
10191 #define VISITOR_SYNCHRONIZATION_TAGS_LIST(V)                               \
10192   V(kStringTable, "string_table", "(Internalized strings)")                \
10193   V(kExternalStringsTable, "external_strings_table", "(External strings)") \
10194   V(kStrongRootList, "strong_root_list", "(Strong roots)")                 \
10195   V(kSmiRootList, "smi_root_list", "(Smi roots)")                          \
10196   V(kBootstrapper, "bootstrapper", "(Bootstrapper)")                       \
10197   V(kTop, "top", "(Isolate)")                                              \
10198   V(kRelocatable, "relocatable", "(Relocatable)")                          \
10199   V(kDebug, "debug", "(Debugger)")                                         \
10200   V(kCompilationCache, "compilationcache", "(Compilation cache)")          \
10201   V(kHandleScope, "handlescope", "(Handle scope)")                         \
10202   V(kBuiltins, "builtins", "(Builtins)")                                   \
10203   V(kGlobalHandles, "globalhandles", "(Global handles)")                   \
10204   V(kEternalHandles, "eternalhandles", "(Eternal handles)")                \
10205   V(kThreadManager, "threadmanager", "(Thread manager)")                   \
10206   V(kStrongRoots, "strong roots", "(Strong roots)")                        \
10207   V(kExtensions, "Extensions", "(Extensions)")
10208
10209 class VisitorSynchronization : public AllStatic {
10210  public:
10211 #define DECLARE_ENUM(enum_item, ignore1, ignore2) enum_item,
10212   enum SyncTag {
10213     VISITOR_SYNCHRONIZATION_TAGS_LIST(DECLARE_ENUM)
10214     kNumberOfSyncTags
10215   };
10216 #undef DECLARE_ENUM
10217
10218   static const char* const kTags[kNumberOfSyncTags];
10219   static const char* const kTagNames[kNumberOfSyncTags];
10220 };
10221
10222 // Abstract base class for visiting, and optionally modifying, the
10223 // pointers contained in Objects. Used in GC and serialization/deserialization.
10224 class ObjectVisitor BASE_EMBEDDED {
10225  public:
10226   virtual ~ObjectVisitor() {}
10227
10228   // Visits a contiguous arrays of pointers in the half-open range
10229   // [start, end). Any or all of the values may be modified on return.
10230   virtual void VisitPointers(Object** start, Object** end) = 0;
10231
10232   // Handy shorthand for visiting a single pointer.
10233   virtual void VisitPointer(Object** p) { VisitPointers(p, p + 1); }
10234
10235   // Visit weak next_code_link in Code object.
10236   virtual void VisitNextCodeLink(Object** p) { VisitPointers(p, p + 1); }
10237
10238   // To allow lazy clearing of inline caches the visitor has
10239   // a rich interface for iterating over Code objects..
10240
10241   // Visits a code target in the instruction stream.
10242   virtual void VisitCodeTarget(RelocInfo* rinfo);
10243
10244   // Visits a code entry in a JS function.
10245   virtual void VisitCodeEntry(Address entry_address);
10246
10247   // Visits a global property cell reference in the instruction stream.
10248   virtual void VisitCell(RelocInfo* rinfo);
10249
10250   // Visits a runtime entry in the instruction stream.
10251   virtual void VisitRuntimeEntry(RelocInfo* rinfo) {}
10252
10253   // Visits the resource of an one-byte or two-byte string.
10254   virtual void VisitExternalOneByteString(
10255       v8::String::ExternalOneByteStringResource** resource) {}
10256   virtual void VisitExternalTwoByteString(
10257       v8::String::ExternalStringResource** resource) {}
10258
10259   // Visits a debug call target in the instruction stream.
10260   virtual void VisitDebugTarget(RelocInfo* rinfo);
10261
10262   // Visits the byte sequence in a function's prologue that contains information
10263   // about the code's age.
10264   virtual void VisitCodeAgeSequence(RelocInfo* rinfo);
10265
10266   // Visit pointer embedded into a code object.
10267   virtual void VisitEmbeddedPointer(RelocInfo* rinfo);
10268
10269   // Visits an external reference embedded into a code object.
10270   virtual void VisitExternalReference(RelocInfo* rinfo);
10271
10272   // Visits an external reference.
10273   virtual void VisitExternalReference(Address* p) {}
10274
10275   // Visits an (encoded) internal reference.
10276   virtual void VisitInternalReference(RelocInfo* rinfo) {}
10277
10278   // Visits a handle that has an embedder-assigned class ID.
10279   virtual void VisitEmbedderReference(Object** p, uint16_t class_id) {}
10280
10281   // Intended for serialization/deserialization checking: insert, or
10282   // check for the presence of, a tag at this position in the stream.
10283   // Also used for marking up GC roots in heap snapshots.
10284   virtual void Synchronize(VisitorSynchronization::SyncTag tag) {}
10285 };
10286
10287
10288 class StructBodyDescriptor : public
10289   FlexibleBodyDescriptor<HeapObject::kHeaderSize> {
10290  public:
10291   static inline int SizeOf(Map* map, HeapObject* object);
10292 };
10293
10294
10295 // BooleanBit is a helper class for setting and getting a bit in an
10296 // integer or Smi.
10297 class BooleanBit : public AllStatic {
10298  public:
10299   static inline bool get(Smi* smi, int bit_position) {
10300     return get(smi->value(), bit_position);
10301   }
10302
10303   static inline bool get(int value, int bit_position) {
10304     return (value & (1 << bit_position)) != 0;
10305   }
10306
10307   static inline Smi* set(Smi* smi, int bit_position, bool v) {
10308     return Smi::FromInt(set(smi->value(), bit_position, v));
10309   }
10310
10311   static inline int set(int value, int bit_position, bool v) {
10312     if (v) {
10313       value |= (1 << bit_position);
10314     } else {
10315       value &= ~(1 << bit_position);
10316     }
10317     return value;
10318   }
10319 };
10320
10321 } }  // namespace v8::internal
10322
10323 #endif  // V8_OBJECTS_H_