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
4475 #define IC_KIND_LIST(V) \
4476   V(LOAD_IC)            \
4477   V(KEYED_LOAD_IC)      \
4478   V(CALL_IC)            \
4479   V(STORE_IC)           \
4480   V(KEYED_STORE_IC)     \
4481   V(BINARY_OP_IC)       \
4482   V(COMPARE_IC)         \
4483   V(COMPARE_NIL_IC)     \
4484   V(TO_BOOLEAN_IC)
4485
4486 #define CODE_KIND_LIST(V) \
4487   NON_IC_KIND_LIST(V)     \
4488   IC_KIND_LIST(V)
4489
4490   enum Kind {
4491 #define DEFINE_CODE_KIND_ENUM(name) name,
4492     CODE_KIND_LIST(DEFINE_CODE_KIND_ENUM)
4493 #undef DEFINE_CODE_KIND_ENUM
4494     NUMBER_OF_KINDS
4495   };
4496
4497   // No more than 16 kinds. The value is currently encoded in four bits in
4498   // Flags.
4499   STATIC_ASSERT(NUMBER_OF_KINDS <= 16);
4500
4501   static const char* Kind2String(Kind kind);
4502
4503   // Types of stubs.
4504   enum StubType {
4505     NORMAL,
4506     FAST
4507   };
4508
4509   static const int kPrologueOffsetNotSet = -1;
4510
4511 #ifdef ENABLE_DISASSEMBLER
4512   // Printing
4513   static const char* ICState2String(InlineCacheState state);
4514   static const char* StubType2String(StubType type);
4515   static void PrintExtraICState(std::ostream& os,  // NOLINT
4516                                 Kind kind, ExtraICState extra);
4517   void Disassemble(const char* name, std::ostream& os);  // NOLINT
4518 #endif  // ENABLE_DISASSEMBLER
4519
4520   // [instruction_size]: Size of the native instructions
4521   inline int instruction_size() const;
4522   inline void set_instruction_size(int value);
4523
4524   // [relocation_info]: Code relocation information
4525   DECL_ACCESSORS(relocation_info, ByteArray)
4526   void InvalidateRelocation();
4527   void InvalidateEmbeddedObjects();
4528
4529   // [handler_table]: Fixed array containing offsets of exception handlers.
4530   DECL_ACCESSORS(handler_table, FixedArray)
4531
4532   // [deoptimization_data]: Array containing data for deopt.
4533   DECL_ACCESSORS(deoptimization_data, FixedArray)
4534
4535   // [raw_type_feedback_info]: This field stores various things, depending on
4536   // the kind of the code object.
4537   //   FUNCTION           => type feedback information.
4538   //   STUB and ICs       => major/minor key as Smi.
4539   DECL_ACCESSORS(raw_type_feedback_info, Object)
4540   inline Object* type_feedback_info();
4541   inline void set_type_feedback_info(
4542       Object* value, WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
4543   inline uint32_t stub_key();
4544   inline void set_stub_key(uint32_t key);
4545
4546   // [next_code_link]: Link for lists of optimized or deoptimized code.
4547   // Note that storage for this field is overlapped with typefeedback_info.
4548   DECL_ACCESSORS(next_code_link, Object)
4549
4550   // [gc_metadata]: Field used to hold GC related metadata. The contents of this
4551   // field does not have to be traced during garbage collection since
4552   // it is only used by the garbage collector itself.
4553   DECL_ACCESSORS(gc_metadata, Object)
4554
4555   // [ic_age]: Inline caching age: the value of the Heap::global_ic_age
4556   // at the moment when this object was created.
4557   inline void set_ic_age(int count);
4558   inline int ic_age() const;
4559
4560   // [prologue_offset]: Offset of the function prologue, used for aging
4561   // FUNCTIONs and OPTIMIZED_FUNCTIONs.
4562   inline int prologue_offset() const;
4563   inline void set_prologue_offset(int offset);
4564
4565   // [constant_pool offset]: Offset of the constant pool.
4566   // Valid for FLAG_enable_embedded_constant_pool only
4567   inline int constant_pool_offset() const;
4568   inline void set_constant_pool_offset(int offset);
4569
4570   // Unchecked accessors to be used during GC.
4571   inline ByteArray* unchecked_relocation_info();
4572
4573   inline int relocation_size();
4574
4575   // [flags]: Various code flags.
4576   inline Flags flags();
4577   inline void set_flags(Flags flags);
4578
4579   // [flags]: Access to specific code flags.
4580   inline Kind kind();
4581   inline InlineCacheState ic_state();  // Only valid for IC stubs.
4582   inline ExtraICState extra_ic_state();  // Only valid for IC stubs.
4583
4584   inline StubType type();  // Only valid for monomorphic IC stubs.
4585
4586   // Testers for IC stub kinds.
4587   inline bool is_inline_cache_stub();
4588   inline bool is_debug_stub();
4589   inline bool is_handler();
4590   inline bool is_load_stub();
4591   inline bool is_keyed_load_stub();
4592   inline bool is_store_stub();
4593   inline bool is_keyed_store_stub();
4594   inline bool is_call_stub();
4595   inline bool is_binary_op_stub();
4596   inline bool is_compare_ic_stub();
4597   inline bool is_compare_nil_ic_stub();
4598   inline bool is_to_boolean_ic_stub();
4599   inline bool is_keyed_stub();
4600   inline bool is_optimized_code();
4601   inline bool embeds_maps_weakly();
4602
4603   inline bool IsCodeStubOrIC();
4604   inline bool IsJavaScriptCode();
4605
4606   inline void set_raw_kind_specific_flags1(int value);
4607   inline void set_raw_kind_specific_flags2(int value);
4608
4609   // [is_crankshafted]: For kind STUB or ICs, tells whether or not a code
4610   // object was generated by either the hydrogen or the TurboFan optimizing
4611   // compiler (but it may not be an optimized function).
4612   inline bool is_crankshafted();
4613   inline bool is_hydrogen_stub();  // Crankshafted, but not a function.
4614   inline void set_is_crankshafted(bool value);
4615
4616   // [is_turbofanned]: For kind STUB or OPTIMIZED_FUNCTION, tells whether the
4617   // code object was generated by the TurboFan optimizing compiler.
4618   inline bool is_turbofanned();
4619   inline void set_is_turbofanned(bool value);
4620
4621   // [can_have_weak_objects]: For kind OPTIMIZED_FUNCTION, tells whether the
4622   // embedded objects in code should be treated weakly.
4623   inline bool can_have_weak_objects();
4624   inline void set_can_have_weak_objects(bool value);
4625
4626   // [has_deoptimization_support]: For FUNCTION kind, tells if it has
4627   // deoptimization support.
4628   inline bool has_deoptimization_support();
4629   inline void set_has_deoptimization_support(bool value);
4630
4631   // [has_debug_break_slots]: For FUNCTION kind, tells if it has
4632   // been compiled with debug break slots.
4633   inline bool has_debug_break_slots();
4634   inline void set_has_debug_break_slots(bool value);
4635
4636   // [has_reloc_info_for_serialization]: For FUNCTION kind, tells if its
4637   // reloc info includes runtime and external references to support
4638   // serialization/deserialization.
4639   inline bool has_reloc_info_for_serialization();
4640   inline void set_has_reloc_info_for_serialization(bool value);
4641
4642   // [allow_osr_at_loop_nesting_level]: For FUNCTION kind, tells for
4643   // how long the function has been marked for OSR and therefore which
4644   // level of loop nesting we are willing to do on-stack replacement
4645   // for.
4646   inline void set_allow_osr_at_loop_nesting_level(int level);
4647   inline int allow_osr_at_loop_nesting_level();
4648
4649   // [profiler_ticks]: For FUNCTION kind, tells for how many profiler ticks
4650   // the code object was seen on the stack with no IC patching going on.
4651   inline int profiler_ticks();
4652   inline void set_profiler_ticks(int ticks);
4653
4654   // [builtin_index]: For BUILTIN kind, tells which builtin index it has.
4655   // For builtins, tells which builtin index it has.
4656   // Note that builtins can have a code kind other than BUILTIN, which means
4657   // that for arbitrary code objects, this index value may be random garbage.
4658   // To verify in that case, compare the code object to the indexed builtin.
4659   inline int builtin_index();
4660   inline void set_builtin_index(int id);
4661
4662   // [stack_slots]: For kind OPTIMIZED_FUNCTION, the number of stack slots
4663   // reserved in the code prologue.
4664   inline unsigned stack_slots();
4665   inline void set_stack_slots(unsigned slots);
4666
4667   // [safepoint_table_start]: For kind OPTIMIZED_FUNCTION, the offset in
4668   // the instruction stream where the safepoint table starts.
4669   inline unsigned safepoint_table_offset();
4670   inline void set_safepoint_table_offset(unsigned offset);
4671
4672   // [back_edge_table_start]: For kind FUNCTION, the offset in the
4673   // instruction stream where the back edge table starts.
4674   inline unsigned back_edge_table_offset();
4675   inline void set_back_edge_table_offset(unsigned offset);
4676
4677   inline bool back_edges_patched_for_osr();
4678
4679   // [to_boolean_foo]: For kind TO_BOOLEAN_IC tells what state the stub is in.
4680   inline uint16_t to_boolean_state();
4681
4682   // [has_function_cache]: For kind STUB tells whether there is a function
4683   // cache is passed to the stub.
4684   inline bool has_function_cache();
4685   inline void set_has_function_cache(bool flag);
4686
4687
4688   // [marked_for_deoptimization]: For kind OPTIMIZED_FUNCTION tells whether
4689   // the code is going to be deoptimized because of dead embedded maps.
4690   inline bool marked_for_deoptimization();
4691   inline void set_marked_for_deoptimization(bool flag);
4692
4693   // [constant_pool]: The constant pool for this function.
4694   inline Address constant_pool();
4695
4696   // Get the safepoint entry for the given pc.
4697   SafepointEntry GetSafepointEntry(Address pc);
4698
4699   // Find an object in a stub with a specified map
4700   Object* FindNthObject(int n, Map* match_map);
4701
4702   // Find the first allocation site in an IC stub.
4703   AllocationSite* FindFirstAllocationSite();
4704
4705   // Find the first map in an IC stub.
4706   Map* FindFirstMap();
4707   void FindAllMaps(MapHandleList* maps);
4708
4709   // Find the first handler in an IC stub.
4710   Code* FindFirstHandler();
4711
4712   // Find |length| handlers and put them into |code_list|. Returns false if not
4713   // enough handlers can be found.
4714   bool FindHandlers(CodeHandleList* code_list, int length = -1);
4715
4716   // Find the handler for |map|.
4717   MaybeHandle<Code> FindHandlerForMap(Map* map);
4718
4719   // Find the first name in an IC stub.
4720   Name* FindFirstName();
4721
4722   class FindAndReplacePattern;
4723   // For each (map-to-find, object-to-replace) pair in the pattern, this
4724   // function replaces the corresponding placeholder in the code with the
4725   // object-to-replace. The function assumes that pairs in the pattern come in
4726   // the same order as the placeholders in the code.
4727   // If the placeholder is a weak cell, then the value of weak cell is matched
4728   // against the map-to-find.
4729   void FindAndReplace(const FindAndReplacePattern& pattern);
4730
4731   // The entire code object including its header is copied verbatim to the
4732   // snapshot so that it can be written in one, fast, memcpy during
4733   // deserialization. The deserializer will overwrite some pointers, rather
4734   // like a runtime linker, but the random allocation addresses used in the
4735   // mksnapshot process would still be present in the unlinked snapshot data,
4736   // which would make snapshot production non-reproducible. This method wipes
4737   // out the to-be-overwritten header data for reproducible snapshots.
4738   inline void WipeOutHeader();
4739
4740   // Flags operations.
4741   static inline Flags ComputeFlags(
4742       Kind kind, InlineCacheState ic_state = UNINITIALIZED,
4743       ExtraICState extra_ic_state = kNoExtraICState, StubType type = NORMAL,
4744       CacheHolderFlag holder = kCacheOnReceiver);
4745
4746   static inline Flags ComputeMonomorphicFlags(
4747       Kind kind, ExtraICState extra_ic_state = kNoExtraICState,
4748       CacheHolderFlag holder = kCacheOnReceiver, StubType type = NORMAL);
4749
4750   static inline Flags ComputeHandlerFlags(
4751       Kind handler_kind, StubType type = NORMAL,
4752       CacheHolderFlag holder = kCacheOnReceiver);
4753
4754   static inline InlineCacheState ExtractICStateFromFlags(Flags flags);
4755   static inline StubType ExtractTypeFromFlags(Flags flags);
4756   static inline CacheHolderFlag ExtractCacheHolderFromFlags(Flags flags);
4757   static inline Kind ExtractKindFromFlags(Flags flags);
4758   static inline ExtraICState ExtractExtraICStateFromFlags(Flags flags);
4759
4760   static inline Flags RemoveTypeFromFlags(Flags flags);
4761   static inline Flags RemoveTypeAndHolderFromFlags(Flags flags);
4762
4763   // Convert a target address into a code object.
4764   static inline Code* GetCodeFromTargetAddress(Address address);
4765
4766   // Convert an entry address into an object.
4767   static inline Object* GetObjectFromEntryAddress(Address location_of_address);
4768
4769   // Returns the address of the first instruction.
4770   inline byte* instruction_start();
4771
4772   // Returns the address right after the last instruction.
4773   inline byte* instruction_end();
4774
4775   // Returns the size of the instructions, padding, and relocation information.
4776   inline int body_size();
4777
4778   // Returns the address of the first relocation info (read backwards!).
4779   inline byte* relocation_start();
4780
4781   // Code entry point.
4782   inline byte* entry();
4783
4784   // Returns true if pc is inside this object's instructions.
4785   inline bool contains(byte* pc);
4786
4787   // Relocate the code by delta bytes. Called to signal that this code
4788   // object has been moved by delta bytes.
4789   void Relocate(intptr_t delta);
4790
4791   // Migrate code described by desc.
4792   void CopyFrom(const CodeDesc& desc);
4793
4794   // Returns the object size for a given body (used for allocation).
4795   static int SizeFor(int body_size) {
4796     DCHECK_SIZE_TAG_ALIGNED(body_size);
4797     return RoundUp(kHeaderSize + body_size, kCodeAlignment);
4798   }
4799
4800   // Calculate the size of the code object to report for log events. This takes
4801   // the layout of the code object into account.
4802   inline int ExecutableSize();
4803
4804   // Locating source position.
4805   int SourcePosition(Address pc);
4806   int SourceStatementPosition(Address pc);
4807
4808   DECLARE_CAST(Code)
4809
4810   // Dispatched behavior.
4811   inline int CodeSize();
4812   inline void CodeIterateBody(ObjectVisitor* v);
4813
4814   template<typename StaticVisitor>
4815   inline void CodeIterateBody(Heap* heap);
4816
4817   DECLARE_PRINTER(Code)
4818   DECLARE_VERIFIER(Code)
4819
4820   void ClearInlineCaches();
4821   void ClearInlineCaches(Kind kind);
4822
4823   BailoutId TranslatePcOffsetToAstId(uint32_t pc_offset);
4824   uint32_t TranslateAstIdToPcOffset(BailoutId ast_id);
4825
4826 #define DECLARE_CODE_AGE_ENUM(X) k##X##CodeAge,
4827   enum Age {
4828     kToBeExecutedOnceCodeAge = -3,
4829     kNotExecutedCodeAge = -2,
4830     kExecutedOnceCodeAge = -1,
4831     kNoAgeCodeAge = 0,
4832     CODE_AGE_LIST(DECLARE_CODE_AGE_ENUM)
4833     kAfterLastCodeAge,
4834     kFirstCodeAge = kToBeExecutedOnceCodeAge,
4835     kLastCodeAge = kAfterLastCodeAge - 1,
4836     kCodeAgeCount = kAfterLastCodeAge - kFirstCodeAge - 1,
4837     kIsOldCodeAge = kSexagenarianCodeAge,
4838     kPreAgedCodeAge = kIsOldCodeAge - 1
4839   };
4840 #undef DECLARE_CODE_AGE_ENUM
4841
4842   // Code aging.  Indicates how many full GCs this code has survived without
4843   // being entered through the prologue.  Used to determine when it is
4844   // relatively safe to flush this code object and replace it with the lazy
4845   // compilation stub.
4846   static void MakeCodeAgeSequenceYoung(byte* sequence, Isolate* isolate);
4847   static void MarkCodeAsExecuted(byte* sequence, Isolate* isolate);
4848   void MakeYoung(Isolate* isolate);
4849   void MarkToBeExecutedOnce(Isolate* isolate);
4850   void MakeOlder(MarkingParity);
4851   static bool IsYoungSequence(Isolate* isolate, byte* sequence);
4852   bool IsOld();
4853   Age GetAge();
4854   static inline Code* GetPreAgedCodeAgeStub(Isolate* isolate) {
4855     return GetCodeAgeStub(isolate, kNotExecutedCodeAge, NO_MARKING_PARITY);
4856   }
4857
4858   void PrintDeoptLocation(FILE* out, Address pc);
4859   bool CanDeoptAt(Address pc);
4860
4861 #ifdef VERIFY_HEAP
4862   void VerifyEmbeddedObjectsDependency();
4863 #endif
4864
4865 #ifdef DEBUG
4866   enum VerifyMode { kNoContextSpecificPointers, kNoContextRetainingPointers };
4867   void VerifyEmbeddedObjects(VerifyMode mode = kNoContextRetainingPointers);
4868   static void VerifyRecompiledCode(Code* old_code, Code* new_code);
4869 #endif  // DEBUG
4870
4871   inline bool CanContainWeakObjects();
4872
4873   inline bool IsWeakObject(Object* object);
4874
4875   static inline bool IsWeakObjectInOptimizedCode(Object* object);
4876
4877   static Handle<WeakCell> WeakCellFor(Handle<Code> code);
4878   WeakCell* CachedWeakCell();
4879
4880   // Max loop nesting marker used to postpose OSR. We don't take loop
4881   // nesting that is deeper than 5 levels into account.
4882   static const int kMaxLoopNestingMarker = 6;
4883
4884   static const int kConstantPoolSize =
4885       FLAG_enable_embedded_constant_pool ? kIntSize : 0;
4886
4887   // Layout description.
4888   static const int kRelocationInfoOffset = HeapObject::kHeaderSize;
4889   static const int kHandlerTableOffset = kRelocationInfoOffset + kPointerSize;
4890   static const int kDeoptimizationDataOffset =
4891       kHandlerTableOffset + kPointerSize;
4892   // For FUNCTION kind, we store the type feedback info here.
4893   static const int kTypeFeedbackInfoOffset =
4894       kDeoptimizationDataOffset + kPointerSize;
4895   static const int kNextCodeLinkOffset = kTypeFeedbackInfoOffset + kPointerSize;
4896   static const int kGCMetadataOffset = kNextCodeLinkOffset + kPointerSize;
4897   static const int kInstructionSizeOffset = kGCMetadataOffset + kPointerSize;
4898   static const int kICAgeOffset = kInstructionSizeOffset + kIntSize;
4899   static const int kFlagsOffset = kICAgeOffset + kIntSize;
4900   static const int kKindSpecificFlags1Offset = kFlagsOffset + kIntSize;
4901   static const int kKindSpecificFlags2Offset =
4902       kKindSpecificFlags1Offset + kIntSize;
4903   // Note: We might be able to squeeze this into the flags above.
4904   static const int kPrologueOffset = kKindSpecificFlags2Offset + kIntSize;
4905   static const int kConstantPoolOffset = kPrologueOffset + kIntSize;
4906   static const int kHeaderPaddingStart =
4907       kConstantPoolOffset + kConstantPoolSize;
4908
4909   // Add padding to align the instruction start following right after
4910   // the Code object header.
4911   static const int kHeaderSize =
4912       (kHeaderPaddingStart + kCodeAlignmentMask) & ~kCodeAlignmentMask;
4913
4914   // Byte offsets within kKindSpecificFlags1Offset.
4915   static const int kFullCodeFlags = kKindSpecificFlags1Offset;
4916   class FullCodeFlagsHasDeoptimizationSupportField:
4917       public BitField<bool, 0, 1> {};  // NOLINT
4918   class FullCodeFlagsHasDebugBreakSlotsField: public BitField<bool, 1, 1> {};
4919   class FullCodeFlagsHasRelocInfoForSerialization
4920       : public BitField<bool, 2, 1> {};
4921   // Bit 3 in this bitfield is unused.
4922   class ProfilerTicksField : public BitField<int, 4, 28> {};
4923
4924   // Flags layout.  BitField<type, shift, size>.
4925   class ICStateField : public BitField<InlineCacheState, 0, 4> {};
4926   class TypeField : public BitField<StubType, 4, 1> {};
4927   class CacheHolderField : public BitField<CacheHolderFlag, 5, 2> {};
4928   class KindField : public BitField<Kind, 7, 4> {};
4929   class ExtraICStateField: public BitField<ExtraICState, 11,
4930       PlatformSmiTagging::kSmiValueSize - 11 + 1> {};  // NOLINT
4931
4932   // KindSpecificFlags1 layout (STUB and OPTIMIZED_FUNCTION)
4933   static const int kStackSlotsFirstBit = 0;
4934   static const int kStackSlotsBitCount = 24;
4935   static const int kHasFunctionCacheBit =
4936       kStackSlotsFirstBit + kStackSlotsBitCount;
4937   static const int kMarkedForDeoptimizationBit = kHasFunctionCacheBit + 1;
4938   static const int kIsTurbofannedBit = kMarkedForDeoptimizationBit + 1;
4939   static const int kCanHaveWeakObjects = kIsTurbofannedBit + 1;
4940
4941   STATIC_ASSERT(kStackSlotsFirstBit + kStackSlotsBitCount <= 32);
4942   STATIC_ASSERT(kCanHaveWeakObjects + 1 <= 32);
4943
4944   class StackSlotsField: public BitField<int,
4945       kStackSlotsFirstBit, kStackSlotsBitCount> {};  // NOLINT
4946   class HasFunctionCacheField : public BitField<bool, kHasFunctionCacheBit, 1> {
4947   };  // NOLINT
4948   class MarkedForDeoptimizationField
4949       : public BitField<bool, kMarkedForDeoptimizationBit, 1> {};   // NOLINT
4950   class IsTurbofannedField : public BitField<bool, kIsTurbofannedBit, 1> {
4951   };  // NOLINT
4952   class CanHaveWeakObjectsField
4953       : public BitField<bool, kCanHaveWeakObjects, 1> {};  // NOLINT
4954
4955   // KindSpecificFlags2 layout (ALL)
4956   static const int kIsCrankshaftedBit = 0;
4957   class IsCrankshaftedField: public BitField<bool,
4958       kIsCrankshaftedBit, 1> {};  // NOLINT
4959
4960   // KindSpecificFlags2 layout (STUB and OPTIMIZED_FUNCTION)
4961   static const int kSafepointTableOffsetFirstBit = kIsCrankshaftedBit + 1;
4962   static const int kSafepointTableOffsetBitCount = 30;
4963
4964   STATIC_ASSERT(kSafepointTableOffsetFirstBit +
4965                 kSafepointTableOffsetBitCount <= 32);
4966   STATIC_ASSERT(1 + kSafepointTableOffsetBitCount <= 32);
4967
4968   class SafepointTableOffsetField: public BitField<int,
4969       kSafepointTableOffsetFirstBit,
4970       kSafepointTableOffsetBitCount> {};  // NOLINT
4971
4972   // KindSpecificFlags2 layout (FUNCTION)
4973   class BackEdgeTableOffsetField: public BitField<int,
4974       kIsCrankshaftedBit + 1, 27> {};  // NOLINT
4975   class AllowOSRAtLoopNestingLevelField: public BitField<int,
4976       kIsCrankshaftedBit + 1 + 27, 4> {};  // NOLINT
4977   STATIC_ASSERT(AllowOSRAtLoopNestingLevelField::kMax >= kMaxLoopNestingMarker);
4978
4979   static const int kArgumentsBits = 16;
4980   static const int kMaxArguments = (1 << kArgumentsBits) - 1;
4981
4982   // This constant should be encodable in an ARM instruction.
4983   static const int kFlagsNotUsedInLookup =
4984       TypeField::kMask | CacheHolderField::kMask;
4985
4986  private:
4987   friend class RelocIterator;
4988   friend class Deoptimizer;  // For FindCodeAgeSequence.
4989
4990   void ClearInlineCaches(Kind* kind);
4991
4992   // Code aging
4993   byte* FindCodeAgeSequence();
4994   static void GetCodeAgeAndParity(Code* code, Age* age,
4995                                   MarkingParity* parity);
4996   static void GetCodeAgeAndParity(Isolate* isolate, byte* sequence, Age* age,
4997                                   MarkingParity* parity);
4998   static Code* GetCodeAgeStub(Isolate* isolate, Age age, MarkingParity parity);
4999
5000   // Code aging -- platform-specific
5001   static void PatchPlatformCodeAge(Isolate* isolate,
5002                                    byte* sequence, Age age,
5003                                    MarkingParity parity);
5004
5005   DISALLOW_IMPLICIT_CONSTRUCTORS(Code);
5006 };
5007
5008
5009 // This class describes the layout of dependent codes array of a map. The
5010 // array is partitioned into several groups of dependent codes. Each group
5011 // contains codes with the same dependency on the map. The array has the
5012 // following layout for n dependency groups:
5013 //
5014 // +----+----+-----+----+---------+----------+-----+---------+-----------+
5015 // | C1 | C2 | ... | Cn | group 1 |  group 2 | ... | group n | undefined |
5016 // +----+----+-----+----+---------+----------+-----+---------+-----------+
5017 //
5018 // The first n elements are Smis, each of them specifies the number of codes
5019 // in the corresponding group. The subsequent elements contain grouped code
5020 // objects in weak cells. The suffix of the array can be filled with the
5021 // undefined value if the number of codes is less than the length of the
5022 // array. The order of the code objects within a group is not preserved.
5023 //
5024 // All code indexes used in the class are counted starting from the first
5025 // code object of the first group. In other words, code index 0 corresponds
5026 // to array index n = kCodesStartIndex.
5027
5028 class DependentCode: public FixedArray {
5029  public:
5030   enum DependencyGroup {
5031     // Group of code that weakly embed this map and depend on being
5032     // deoptimized when the map is garbage collected.
5033     kWeakCodeGroup,
5034     // Group of code that embed a transition to this map, and depend on being
5035     // deoptimized when the transition is replaced by a new version.
5036     kTransitionGroup,
5037     // Group of code that omit run-time prototype checks for prototypes
5038     // described by this map. The group is deoptimized whenever an object
5039     // described by this map changes shape (and transitions to a new map),
5040     // possibly invalidating the assumptions embedded in the code.
5041     kPrototypeCheckGroup,
5042     // Group of code that depends on global property values in property cells
5043     // not being changed.
5044     kPropertyCellChangedGroup,
5045     // Group of code that omit run-time type checks for the field(s) introduced
5046     // by this map.
5047     kFieldTypeGroup,
5048     // Group of code that omit run-time type checks for initial maps of
5049     // constructors.
5050     kInitialMapChangedGroup,
5051     // Group of code that depends on tenuring information in AllocationSites
5052     // not being changed.
5053     kAllocationSiteTenuringChangedGroup,
5054     // Group of code that depends on element transition information in
5055     // AllocationSites not being changed.
5056     kAllocationSiteTransitionChangedGroup
5057   };
5058
5059   static const int kGroupCount = kAllocationSiteTransitionChangedGroup + 1;
5060
5061   // Array for holding the index of the first code object of each group.
5062   // The last element stores the total number of code objects.
5063   class GroupStartIndexes {
5064    public:
5065     explicit GroupStartIndexes(DependentCode* entries);
5066     void Recompute(DependentCode* entries);
5067     int at(int i) { return start_indexes_[i]; }
5068     int number_of_entries() { return start_indexes_[kGroupCount]; }
5069    private:
5070     int start_indexes_[kGroupCount + 1];
5071   };
5072
5073   bool Contains(DependencyGroup group, WeakCell* code_cell);
5074
5075   static Handle<DependentCode> InsertCompilationDependencies(
5076       Handle<DependentCode> entries, DependencyGroup group,
5077       Handle<Foreign> info);
5078
5079   static Handle<DependentCode> InsertWeakCode(Handle<DependentCode> entries,
5080                                               DependencyGroup group,
5081                                               Handle<WeakCell> code_cell);
5082
5083   void UpdateToFinishedCode(DependencyGroup group, Foreign* info,
5084                             WeakCell* code_cell);
5085
5086   void RemoveCompilationDependencies(DependentCode::DependencyGroup group,
5087                                      Foreign* info);
5088
5089   void DeoptimizeDependentCodeGroup(Isolate* isolate,
5090                                     DependentCode::DependencyGroup group);
5091
5092   bool MarkCodeForDeoptimization(Isolate* isolate,
5093                                  DependentCode::DependencyGroup group);
5094
5095   // The following low-level accessors should only be used by this class
5096   // and the mark compact collector.
5097   inline int number_of_entries(DependencyGroup group);
5098   inline void set_number_of_entries(DependencyGroup group, int value);
5099   inline Object* object_at(int i);
5100   inline void set_object_at(int i, Object* object);
5101   inline void clear_at(int i);
5102   inline void copy(int from, int to);
5103   DECLARE_CAST(DependentCode)
5104
5105   static const char* DependencyGroupName(DependencyGroup group);
5106   static void SetMarkedForDeoptimization(Code* code, DependencyGroup group);
5107
5108  private:
5109   static Handle<DependentCode> Insert(Handle<DependentCode> entries,
5110                                       DependencyGroup group,
5111                                       Handle<Object> object);
5112   static Handle<DependentCode> EnsureSpace(Handle<DependentCode> entries);
5113   // Make a room at the end of the given group by moving out the first
5114   // code objects of the subsequent groups.
5115   inline void ExtendGroup(DependencyGroup group);
5116   // Compact by removing cleared weak cells and return true if there was
5117   // any cleared weak cell.
5118   bool Compact();
5119   static int Grow(int number_of_entries) {
5120     if (number_of_entries < 5) return number_of_entries + 1;
5121     return number_of_entries * 5 / 4;
5122   }
5123   static const int kCodesStartIndex = kGroupCount;
5124 };
5125
5126
5127 class PrototypeInfo;
5128
5129
5130 // All heap objects have a Map that describes their structure.
5131 //  A Map contains information about:
5132 //  - Size information about the object
5133 //  - How to iterate over an object (for garbage collection)
5134 class Map: public HeapObject {
5135  public:
5136   // Instance size.
5137   // Size in bytes or kVariableSizeSentinel if instances do not have
5138   // a fixed size.
5139   inline int instance_size();
5140   inline void set_instance_size(int value);
5141
5142   // Only to clear an unused byte, remove once byte is used.
5143   inline void clear_unused();
5144
5145   // [inobject_properties_or_constructor_function_index]: Provides access
5146   // to the inobject properties in case of JSObject maps, or the constructor
5147   // function index in case of primitive maps.
5148   inline int inobject_properties_or_constructor_function_index();
5149   inline void set_inobject_properties_or_constructor_function_index(int value);
5150   // Count of properties allocated in the object (JSObject only).
5151   inline int GetInObjectProperties();
5152   inline void SetInObjectProperties(int value);
5153   // Index of the constructor function in the native context (primitives only),
5154   // or the special sentinel value to indicate that there is no object wrapper
5155   // for the primitive (i.e. in case of null or undefined).
5156   static const int kNoConstructorFunctionIndex = 0;
5157   inline int GetConstructorFunctionIndex();
5158   inline void SetConstructorFunctionIndex(int value);
5159
5160   // Instance type.
5161   inline InstanceType instance_type();
5162   inline void set_instance_type(InstanceType value);
5163
5164   // Tells how many unused property fields are available in the
5165   // instance (only used for JSObject in fast mode).
5166   inline int unused_property_fields();
5167   inline void set_unused_property_fields(int value);
5168
5169   // Bit field.
5170   inline byte bit_field() const;
5171   inline void set_bit_field(byte value);
5172
5173   // Bit field 2.
5174   inline byte bit_field2() const;
5175   inline void set_bit_field2(byte value);
5176
5177   // Bit field 3.
5178   inline uint32_t bit_field3() const;
5179   inline void set_bit_field3(uint32_t bits);
5180
5181   class EnumLengthBits:             public BitField<int,
5182       0, kDescriptorIndexBitCount> {};  // NOLINT
5183   class NumberOfOwnDescriptorsBits: public BitField<int,
5184       kDescriptorIndexBitCount, kDescriptorIndexBitCount> {};  // NOLINT
5185   STATIC_ASSERT(kDescriptorIndexBitCount + kDescriptorIndexBitCount == 20);
5186   class DictionaryMap : public BitField<bool, 20, 1> {};
5187   class OwnsDescriptors : public BitField<bool, 21, 1> {};
5188   class HasInstanceCallHandler : public BitField<bool, 22, 1> {};
5189   class Deprecated : public BitField<bool, 23, 1> {};
5190   class IsUnstable : public BitField<bool, 24, 1> {};
5191   class IsMigrationTarget : public BitField<bool, 25, 1> {};
5192   class IsStrong : public BitField<bool, 26, 1> {};
5193   // Bit 27 is free.
5194
5195   // Keep this bit field at the very end for better code in
5196   // Builtins::kJSConstructStubGeneric stub.
5197   // This counter is used for in-object slack tracking and for map aging.
5198   // The in-object slack tracking is considered enabled when the counter is
5199   // in the range [kSlackTrackingCounterStart, kSlackTrackingCounterEnd].
5200   class Counter : public BitField<int, 28, 4> {};
5201   static const int kSlackTrackingCounterStart = 14;
5202   static const int kSlackTrackingCounterEnd = 8;
5203   static const int kRetainingCounterStart = kSlackTrackingCounterEnd - 1;
5204   static const int kRetainingCounterEnd = 0;
5205
5206   // Tells whether the object in the prototype property will be used
5207   // for instances created from this function.  If the prototype
5208   // property is set to a value that is not a JSObject, the prototype
5209   // property will not be used to create instances of the function.
5210   // See ECMA-262, 13.2.2.
5211   inline void set_non_instance_prototype(bool value);
5212   inline bool has_non_instance_prototype();
5213
5214   // Tells whether function has special prototype property. If not, prototype
5215   // property will not be created when accessed (will return undefined),
5216   // and construction from this function will not be allowed.
5217   inline void set_function_with_prototype(bool value);
5218   inline bool function_with_prototype();
5219
5220   // Tells whether the instance with this map should be ignored by the
5221   // Object.getPrototypeOf() function and the __proto__ accessor.
5222   inline void set_is_hidden_prototype();
5223   inline bool is_hidden_prototype();
5224
5225   // Records and queries whether the instance has a named interceptor.
5226   inline void set_has_named_interceptor();
5227   inline bool has_named_interceptor();
5228
5229   // Records and queries whether the instance has an indexed interceptor.
5230   inline void set_has_indexed_interceptor();
5231   inline bool has_indexed_interceptor();
5232
5233   // Tells whether the instance is undetectable.
5234   // An undetectable object is a special class of JSObject: 'typeof' operator
5235   // returns undefined, ToBoolean returns false. Otherwise it behaves like
5236   // a normal JS object.  It is useful for implementing undetectable
5237   // document.all in Firefox & Safari.
5238   // See https://bugzilla.mozilla.org/show_bug.cgi?id=248549.
5239   inline void set_is_undetectable();
5240   inline bool is_undetectable();
5241
5242   // Tells whether the instance has a call-as-function handler.
5243   inline void set_is_observed();
5244   inline bool is_observed();
5245
5246   inline void set_is_strong();
5247   inline bool is_strong();
5248   inline void set_is_extensible(bool value);
5249   inline bool is_extensible();
5250   inline void set_is_prototype_map(bool value);
5251   inline bool is_prototype_map() const;
5252
5253   inline void set_elements_kind(ElementsKind elements_kind);
5254   inline ElementsKind elements_kind();
5255
5256   // Tells whether the instance has fast elements that are only Smis.
5257   inline bool has_fast_smi_elements();
5258
5259   // Tells whether the instance has fast elements.
5260   inline bool has_fast_object_elements();
5261   inline bool has_fast_smi_or_object_elements();
5262   inline bool has_fast_double_elements();
5263   inline bool has_fast_elements();
5264   inline bool has_sloppy_arguments_elements();
5265   inline bool has_fixed_typed_array_elements();
5266   inline bool has_dictionary_elements();
5267
5268   static bool IsValidElementsTransition(ElementsKind from_kind,
5269                                         ElementsKind to_kind);
5270
5271   // Returns true if the current map doesn't have DICTIONARY_ELEMENTS but if a
5272   // map with DICTIONARY_ELEMENTS was found in the prototype chain.
5273   bool DictionaryElementsInPrototypeChainOnly();
5274
5275   inline Map* ElementsTransitionMap();
5276
5277   inline FixedArrayBase* GetInitialElements();
5278
5279   // [raw_transitions]: Provides access to the transitions storage field.
5280   // Don't call set_raw_transitions() directly to overwrite transitions, use
5281   // the TransitionArray::ReplaceTransitions() wrapper instead!
5282   DECL_ACCESSORS(raw_transitions, Object)
5283   // [prototype_info]: Per-prototype metadata. Aliased with transitions
5284   // (which prototype maps don't have).
5285   DECL_ACCESSORS(prototype_info, Object)
5286   // PrototypeInfo is created lazily using this helper (which installs it on
5287   // the given prototype's map).
5288   static Handle<PrototypeInfo> GetOrCreatePrototypeInfo(
5289       Handle<JSObject> prototype, Isolate* isolate);
5290   static Handle<PrototypeInfo> GetOrCreatePrototypeInfo(
5291       Handle<Map> prototype_map, Isolate* isolate);
5292
5293   // [prototype chain validity cell]: Associated with a prototype object,
5294   // stored in that object's map's PrototypeInfo, indicates that prototype
5295   // chains through this object are currently valid. The cell will be
5296   // invalidated and replaced when the prototype chain changes.
5297   static Handle<Cell> GetOrCreatePrototypeChainValidityCell(Handle<Map> map,
5298                                                             Isolate* isolate);
5299   static const int kPrototypeChainValid = 0;
5300   static const int kPrototypeChainInvalid = 1;
5301
5302   Map* FindRootMap();
5303   Map* FindFieldOwner(int descriptor);
5304
5305   inline int GetInObjectPropertyOffset(int index);
5306
5307   int NumberOfFields();
5308
5309   // TODO(ishell): candidate with JSObject::MigrateToMap().
5310   bool InstancesNeedRewriting(Map* target, int target_number_of_fields,
5311                               int target_inobject, int target_unused,
5312                               int* old_number_of_fields);
5313   // TODO(ishell): moveit!
5314   static Handle<Map> GeneralizeAllFieldRepresentations(Handle<Map> map);
5315   MUST_USE_RESULT static Handle<HeapType> GeneralizeFieldType(
5316       Handle<HeapType> type1,
5317       Handle<HeapType> type2,
5318       Isolate* isolate);
5319   static void GeneralizeFieldType(Handle<Map> map, int modify_index,
5320                                   Representation new_representation,
5321                                   Handle<HeapType> new_field_type);
5322   static Handle<Map> ReconfigureProperty(Handle<Map> map, int modify_index,
5323                                          PropertyKind new_kind,
5324                                          PropertyAttributes new_attributes,
5325                                          Representation new_representation,
5326                                          Handle<HeapType> new_field_type,
5327                                          StoreMode store_mode);
5328   static Handle<Map> CopyGeneralizeAllRepresentations(
5329       Handle<Map> map, int modify_index, StoreMode store_mode,
5330       PropertyKind kind, PropertyAttributes attributes, const char* reason);
5331
5332   static Handle<Map> PrepareForDataProperty(Handle<Map> old_map,
5333                                             int descriptor_number,
5334                                             Handle<Object> value);
5335
5336   static Handle<Map> Normalize(Handle<Map> map, PropertyNormalizationMode mode,
5337                                const char* reason);
5338
5339   // Returns the constructor name (the name (possibly, inferred name) of the
5340   // function that was used to instantiate the object).
5341   String* constructor_name();
5342
5343   // Tells whether the map is used for JSObjects in dictionary mode (ie
5344   // normalized objects, ie objects for which HasFastProperties returns false).
5345   // A map can never be used for both dictionary mode and fast mode JSObjects.
5346   // False by default and for HeapObjects that are not JSObjects.
5347   inline void set_dictionary_map(bool value);
5348   inline bool is_dictionary_map();
5349
5350   // Tells whether the instance needs security checks when accessing its
5351   // properties.
5352   inline void set_is_access_check_needed(bool access_check_needed);
5353   inline bool is_access_check_needed();
5354
5355   // Returns true if map has a non-empty stub code cache.
5356   inline bool has_code_cache();
5357
5358   // [prototype]: implicit prototype object.
5359   DECL_ACCESSORS(prototype, Object)
5360   // TODO(jkummerow): make set_prototype private.
5361   static void SetPrototype(
5362       Handle<Map> map, Handle<Object> prototype,
5363       PrototypeOptimizationMode proto_mode = FAST_PROTOTYPE);
5364
5365   // [constructor]: points back to the function responsible for this map.
5366   // The field overlaps with the back pointer. All maps in a transition tree
5367   // have the same constructor, so maps with back pointers can walk the
5368   // back pointer chain until they find the map holding their constructor.
5369   DECL_ACCESSORS(constructor_or_backpointer, Object)
5370   inline Object* GetConstructor() const;
5371   inline void SetConstructor(Object* constructor,
5372                              WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
5373   // [back pointer]: points back to the parent map from which a transition
5374   // leads to this map. The field overlaps with the constructor (see above).
5375   inline Object* GetBackPointer();
5376   inline void SetBackPointer(Object* value,
5377                              WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
5378
5379   // [instance descriptors]: describes the object.
5380   DECL_ACCESSORS(instance_descriptors, DescriptorArray)
5381
5382   // [layout descriptor]: describes the object layout.
5383   DECL_ACCESSORS(layout_descriptor, LayoutDescriptor)
5384   // |layout descriptor| accessor which can be used from GC.
5385   inline LayoutDescriptor* layout_descriptor_gc_safe();
5386   inline bool HasFastPointerLayout() const;
5387
5388   // |layout descriptor| accessor that is safe to call even when
5389   // FLAG_unbox_double_fields is disabled (in this case Map does not contain
5390   // |layout_descriptor| field at all).
5391   inline LayoutDescriptor* GetLayoutDescriptor();
5392
5393   inline void UpdateDescriptors(DescriptorArray* descriptors,
5394                                 LayoutDescriptor* layout_descriptor);
5395   inline void InitializeDescriptors(DescriptorArray* descriptors,
5396                                     LayoutDescriptor* layout_descriptor);
5397
5398   // [stub cache]: contains stubs compiled for this map.
5399   DECL_ACCESSORS(code_cache, Object)
5400
5401   // [dependent code]: list of optimized codes that weakly embed this map.
5402   DECL_ACCESSORS(dependent_code, DependentCode)
5403
5404   // [weak cell cache]: cache that stores a weak cell pointing to this map.
5405   DECL_ACCESSORS(weak_cell_cache, Object)
5406
5407   inline PropertyDetails GetLastDescriptorDetails();
5408
5409   inline int LastAdded();
5410
5411   inline int NumberOfOwnDescriptors();
5412   inline void SetNumberOfOwnDescriptors(int number);
5413
5414   inline Cell* RetrieveDescriptorsPointer();
5415
5416   inline int EnumLength();
5417   inline void SetEnumLength(int length);
5418
5419   inline bool owns_descriptors();
5420   inline void set_owns_descriptors(bool owns_descriptors);
5421   inline bool has_instance_call_handler();
5422   inline void set_has_instance_call_handler();
5423   inline void mark_unstable();
5424   inline bool is_stable();
5425   inline void set_migration_target(bool value);
5426   inline bool is_migration_target();
5427   inline void set_counter(int value);
5428   inline int counter();
5429   inline void deprecate();
5430   inline bool is_deprecated();
5431   inline bool CanBeDeprecated();
5432   // Returns a non-deprecated version of the input. If the input was not
5433   // deprecated, it is directly returned. Otherwise, the non-deprecated version
5434   // is found by re-transitioning from the root of the transition tree using the
5435   // descriptor array of the map. Returns MaybeHandle<Map>() if no updated map
5436   // is found.
5437   static MaybeHandle<Map> TryUpdate(Handle<Map> map) WARN_UNUSED_RESULT;
5438
5439   // Returns a non-deprecated version of the input. This method may deprecate
5440   // existing maps along the way if encodings conflict. Not for use while
5441   // gathering type feedback. Use TryUpdate in those cases instead.
5442   static Handle<Map> Update(Handle<Map> map);
5443
5444   static Handle<Map> CopyDropDescriptors(Handle<Map> map);
5445   static Handle<Map> CopyInsertDescriptor(Handle<Map> map,
5446                                           Descriptor* descriptor,
5447                                           TransitionFlag flag);
5448
5449   MUST_USE_RESULT static MaybeHandle<Map> CopyWithField(
5450       Handle<Map> map,
5451       Handle<Name> name,
5452       Handle<HeapType> type,
5453       PropertyAttributes attributes,
5454       Representation representation,
5455       TransitionFlag flag);
5456
5457   MUST_USE_RESULT static MaybeHandle<Map> CopyWithConstant(
5458       Handle<Map> map,
5459       Handle<Name> name,
5460       Handle<Object> constant,
5461       PropertyAttributes attributes,
5462       TransitionFlag flag);
5463
5464   // Returns a new map with all transitions dropped from the given map and
5465   // the ElementsKind set.
5466   static Handle<Map> TransitionElementsTo(Handle<Map> map,
5467                                           ElementsKind to_kind);
5468
5469   static Handle<Map> AsElementsKind(Handle<Map> map, ElementsKind kind);
5470
5471   static Handle<Map> CopyAsElementsKind(Handle<Map> map,
5472                                         ElementsKind kind,
5473                                         TransitionFlag flag);
5474
5475   static Handle<Map> CopyForObserved(Handle<Map> map);
5476
5477   static Handle<Map> CopyForPreventExtensions(Handle<Map> map,
5478                                               PropertyAttributes attrs_to_add,
5479                                               Handle<Symbol> transition_marker,
5480                                               const char* reason);
5481
5482   static Handle<Map> FixProxy(Handle<Map> map, InstanceType type, int size);
5483
5484
5485   // Maximal number of fast properties. Used to restrict the number of map
5486   // transitions to avoid an explosion in the number of maps for objects used as
5487   // dictionaries.
5488   inline bool TooManyFastProperties(StoreFromKeyed store_mode);
5489   static Handle<Map> TransitionToDataProperty(Handle<Map> map,
5490                                               Handle<Name> name,
5491                                               Handle<Object> value,
5492                                               PropertyAttributes attributes,
5493                                               StoreFromKeyed store_mode);
5494   static Handle<Map> TransitionToAccessorProperty(
5495       Handle<Map> map, Handle<Name> name, AccessorComponent component,
5496       Handle<Object> accessor, PropertyAttributes attributes);
5497   static Handle<Map> ReconfigureExistingProperty(Handle<Map> map,
5498                                                  int descriptor,
5499                                                  PropertyKind kind,
5500                                                  PropertyAttributes attributes);
5501
5502   inline void AppendDescriptor(Descriptor* desc);
5503
5504   // Returns a copy of the map, prepared for inserting into the transition
5505   // tree (if the |map| owns descriptors then the new one will share
5506   // descriptors with |map|).
5507   static Handle<Map> CopyForTransition(Handle<Map> map, const char* reason);
5508
5509   // Returns a copy of the map, with all transitions dropped from the
5510   // instance descriptors.
5511   static Handle<Map> Copy(Handle<Map> map, const char* reason);
5512   static Handle<Map> Create(Isolate* isolate, int inobject_properties);
5513
5514   // Returns the next free property index (only valid for FAST MODE).
5515   int NextFreePropertyIndex();
5516
5517   // Returns the number of properties described in instance_descriptors
5518   // filtering out properties with the specified attributes.
5519   int NumberOfDescribedProperties(DescriptorFlag which = OWN_DESCRIPTORS,
5520                                   PropertyAttributes filter = NONE);
5521
5522   DECLARE_CAST(Map)
5523
5524   // Code cache operations.
5525
5526   // Clears the code cache.
5527   inline void ClearCodeCache(Heap* heap);
5528
5529   // Update code cache.
5530   static void UpdateCodeCache(Handle<Map> map,
5531                               Handle<Name> name,
5532                               Handle<Code> code);
5533
5534   // Extend the descriptor array of the map with the list of descriptors.
5535   // In case of duplicates, the latest descriptor is used.
5536   static void AppendCallbackDescriptors(Handle<Map> map,
5537                                         Handle<Object> descriptors);
5538
5539   static inline int SlackForArraySize(int old_size, int size_limit);
5540
5541   static void EnsureDescriptorSlack(Handle<Map> map, int slack);
5542
5543   // Returns the found code or undefined if absent.
5544   Object* FindInCodeCache(Name* name, Code::Flags flags);
5545
5546   // Returns the non-negative index of the code object if it is in the
5547   // cache and -1 otherwise.
5548   int IndexInCodeCache(Object* name, Code* code);
5549
5550   // Removes a code object from the code cache at the given index.
5551   void RemoveFromCodeCache(Name* name, Code* code, int index);
5552
5553   // Computes a hash value for this map, to be used in HashTables and such.
5554   int Hash();
5555
5556   // Returns the map that this map transitions to if its elements_kind
5557   // is changed to |elements_kind|, or NULL if no such map is cached yet.
5558   // |safe_to_add_transitions| is set to false if adding transitions is not
5559   // allowed.
5560   Map* LookupElementsTransitionMap(ElementsKind elements_kind);
5561
5562   // Returns the transitioned map for this map with the most generic
5563   // elements_kind that's found in |candidates|, or null handle if no match is
5564   // found at all.
5565   static Handle<Map> FindTransitionedMap(Handle<Map> map,
5566                                          MapHandleList* candidates);
5567
5568   inline bool CanTransition();
5569
5570   inline bool IsPrimitiveMap();
5571   inline bool IsJSObjectMap();
5572   inline bool IsJSArrayMap();
5573   inline bool IsStringMap();
5574   inline bool IsJSProxyMap();
5575   inline bool IsJSGlobalProxyMap();
5576   inline bool IsJSGlobalObjectMap();
5577   inline bool IsGlobalObjectMap();
5578
5579   inline bool CanOmitMapChecks();
5580
5581   static void AddDependentCode(Handle<Map> map,
5582                                DependentCode::DependencyGroup group,
5583                                Handle<Code> code);
5584
5585   bool IsMapInArrayPrototypeChain();
5586
5587   static Handle<WeakCell> WeakCellForMap(Handle<Map> map);
5588
5589   // Dispatched behavior.
5590   DECLARE_PRINTER(Map)
5591   DECLARE_VERIFIER(Map)
5592
5593 #ifdef VERIFY_HEAP
5594   void DictionaryMapVerify();
5595   void VerifyOmittedMapChecks();
5596 #endif
5597
5598   inline int visitor_id();
5599   inline void set_visitor_id(int visitor_id);
5600
5601   static Handle<Map> TransitionToPrototype(Handle<Map> map,
5602                                            Handle<Object> prototype,
5603                                            PrototypeOptimizationMode mode);
5604
5605   static const int kMaxPreAllocatedPropertyFields = 255;
5606
5607   // Layout description.
5608   static const int kInstanceSizesOffset = HeapObject::kHeaderSize;
5609   static const int kInstanceAttributesOffset = kInstanceSizesOffset + kIntSize;
5610   static const int kBitField3Offset = kInstanceAttributesOffset + kIntSize;
5611   static const int kPrototypeOffset = kBitField3Offset + kPointerSize;
5612   static const int kConstructorOrBackPointerOffset =
5613       kPrototypeOffset + kPointerSize;
5614   // When there is only one transition, it is stored directly in this field;
5615   // otherwise a transition array is used.
5616   // For prototype maps, this slot is used to store this map's PrototypeInfo
5617   // struct.
5618   static const int kTransitionsOrPrototypeInfoOffset =
5619       kConstructorOrBackPointerOffset + kPointerSize;
5620   static const int kDescriptorsOffset =
5621       kTransitionsOrPrototypeInfoOffset + kPointerSize;
5622 #if V8_DOUBLE_FIELDS_UNBOXING
5623   static const int kLayoutDecriptorOffset = kDescriptorsOffset + kPointerSize;
5624   static const int kCodeCacheOffset = kLayoutDecriptorOffset + kPointerSize;
5625 #else
5626   static const int kLayoutDecriptorOffset = 1;  // Must not be ever accessed.
5627   static const int kCodeCacheOffset = kDescriptorsOffset + kPointerSize;
5628 #endif
5629   static const int kDependentCodeOffset = kCodeCacheOffset + kPointerSize;
5630   static const int kWeakCellCacheOffset = kDependentCodeOffset + kPointerSize;
5631   static const int kSize = kWeakCellCacheOffset + kPointerSize;
5632
5633   // Layout of pointer fields. Heap iteration code relies on them
5634   // being continuously allocated.
5635   static const int kPointerFieldsBeginOffset = Map::kPrototypeOffset;
5636   static const int kPointerFieldsEndOffset = kSize;
5637
5638   // Byte offsets within kInstanceSizesOffset.
5639   static const int kInstanceSizeOffset = kInstanceSizesOffset + 0;
5640   static const int kInObjectPropertiesOrConstructorFunctionIndexByte = 1;
5641   static const int kInObjectPropertiesOrConstructorFunctionIndexOffset =
5642       kInstanceSizesOffset + kInObjectPropertiesOrConstructorFunctionIndexByte;
5643   // Note there is one byte available for use here.
5644   static const int kUnusedByte = 2;
5645   static const int kUnusedOffset = kInstanceSizesOffset + kUnusedByte;
5646   static const int kVisitorIdByte = 3;
5647   static const int kVisitorIdOffset = kInstanceSizesOffset + kVisitorIdByte;
5648
5649   // Byte offsets within kInstanceAttributesOffset attributes.
5650 #if V8_TARGET_LITTLE_ENDIAN
5651   // Order instance type and bit field together such that they can be loaded
5652   // together as a 16-bit word with instance type in the lower 8 bits regardless
5653   // of endianess. Also provide endian-independent offset to that 16-bit word.
5654   static const int kInstanceTypeOffset = kInstanceAttributesOffset + 0;
5655   static const int kBitFieldOffset = kInstanceAttributesOffset + 1;
5656 #else
5657   static const int kBitFieldOffset = kInstanceAttributesOffset + 0;
5658   static const int kInstanceTypeOffset = kInstanceAttributesOffset + 1;
5659 #endif
5660   static const int kInstanceTypeAndBitFieldOffset =
5661       kInstanceAttributesOffset + 0;
5662   static const int kBitField2Offset = kInstanceAttributesOffset + 2;
5663   static const int kUnusedPropertyFieldsByte = 3;
5664   static const int kUnusedPropertyFieldsOffset = kInstanceAttributesOffset + 3;
5665
5666   STATIC_ASSERT(kInstanceTypeAndBitFieldOffset ==
5667                 Internals::kMapInstanceTypeAndBitFieldOffset);
5668
5669   // Bit positions for bit field.
5670   static const int kHasNonInstancePrototype = 0;
5671   static const int kIsHiddenPrototype = 1;
5672   static const int kHasNamedInterceptor = 2;
5673   static const int kHasIndexedInterceptor = 3;
5674   static const int kIsUndetectable = 4;
5675   static const int kIsObserved = 5;
5676   static const int kIsAccessCheckNeeded = 6;
5677   class FunctionWithPrototype: public BitField<bool, 7,  1> {};
5678
5679   // Bit positions for bit field 2
5680   static const int kIsExtensible = 0;
5681   static const int kStringWrapperSafeForDefaultValueOf = 1;
5682   class IsPrototypeMapBits : public BitField<bool, 2, 1> {};
5683   class ElementsKindBits: public BitField<ElementsKind, 3, 5> {};
5684
5685   // Derived values from bit field 2
5686   static const int8_t kMaximumBitField2FastElementValue = static_cast<int8_t>(
5687       (FAST_ELEMENTS + 1) << Map::ElementsKindBits::kShift) - 1;
5688   static const int8_t kMaximumBitField2FastSmiElementValue =
5689       static_cast<int8_t>((FAST_SMI_ELEMENTS + 1) <<
5690                           Map::ElementsKindBits::kShift) - 1;
5691   static const int8_t kMaximumBitField2FastHoleyElementValue =
5692       static_cast<int8_t>((FAST_HOLEY_ELEMENTS + 1) <<
5693                           Map::ElementsKindBits::kShift) - 1;
5694   static const int8_t kMaximumBitField2FastHoleySmiElementValue =
5695       static_cast<int8_t>((FAST_HOLEY_SMI_ELEMENTS + 1) <<
5696                           Map::ElementsKindBits::kShift) - 1;
5697
5698   typedef FixedBodyDescriptor<kPointerFieldsBeginOffset,
5699                               kPointerFieldsEndOffset,
5700                               kSize> BodyDescriptor;
5701
5702   // Compares this map to another to see if they describe equivalent objects.
5703   // If |mode| is set to CLEAR_INOBJECT_PROPERTIES, |other| is treated as if
5704   // it had exactly zero inobject properties.
5705   // The "shared" flags of both this map and |other| are ignored.
5706   bool EquivalentToForNormalization(Map* other, PropertyNormalizationMode mode);
5707
5708   // Returns true if given field is unboxed double.
5709   inline bool IsUnboxedDoubleField(FieldIndex index);
5710
5711 #if TRACE_MAPS
5712   static void TraceTransition(const char* what, Map* from, Map* to, Name* name);
5713   static void TraceAllTransitions(Map* map);
5714 #endif
5715
5716   static inline Handle<Map> CopyInstallDescriptorsForTesting(
5717       Handle<Map> map, int new_descriptor, Handle<DescriptorArray> descriptors,
5718       Handle<LayoutDescriptor> layout_descriptor);
5719
5720  private:
5721   static void ConnectTransition(Handle<Map> parent, Handle<Map> child,
5722                                 Handle<Name> name, SimpleTransitionFlag flag);
5723
5724   bool EquivalentToForTransition(Map* other);
5725   static Handle<Map> RawCopy(Handle<Map> map, int instance_size);
5726   static Handle<Map> ShareDescriptor(Handle<Map> map,
5727                                      Handle<DescriptorArray> descriptors,
5728                                      Descriptor* descriptor);
5729   static Handle<Map> CopyInstallDescriptors(
5730       Handle<Map> map, int new_descriptor, Handle<DescriptorArray> descriptors,
5731       Handle<LayoutDescriptor> layout_descriptor);
5732   static Handle<Map> CopyAddDescriptor(Handle<Map> map,
5733                                        Descriptor* descriptor,
5734                                        TransitionFlag flag);
5735   static Handle<Map> CopyReplaceDescriptors(
5736       Handle<Map> map, Handle<DescriptorArray> descriptors,
5737       Handle<LayoutDescriptor> layout_descriptor, TransitionFlag flag,
5738       MaybeHandle<Name> maybe_name, const char* reason,
5739       SimpleTransitionFlag simple_flag);
5740
5741   static Handle<Map> CopyReplaceDescriptor(Handle<Map> map,
5742                                            Handle<DescriptorArray> descriptors,
5743                                            Descriptor* descriptor,
5744                                            int index,
5745                                            TransitionFlag flag);
5746   static MUST_USE_RESULT MaybeHandle<Map> TryReconfigureExistingProperty(
5747       Handle<Map> map, int descriptor, PropertyKind kind,
5748       PropertyAttributes attributes, const char** reason);
5749
5750   static Handle<Map> CopyNormalized(Handle<Map> map,
5751                                     PropertyNormalizationMode mode);
5752
5753   // Fires when the layout of an object with a leaf map changes.
5754   // This includes adding transitions to the leaf map or changing
5755   // the descriptor array.
5756   inline void NotifyLeafMapLayoutChange();
5757
5758   void DeprecateTransitionTree();
5759   bool DeprecateTarget(PropertyKind kind, Name* key,
5760                        PropertyAttributes attributes,
5761                        DescriptorArray* new_descriptors,
5762                        LayoutDescriptor* new_layout_descriptor);
5763
5764   Map* FindLastMatchMap(int verbatim, int length, DescriptorArray* descriptors);
5765
5766   // Update field type of the given descriptor to new representation and new
5767   // type. The type must be prepared for storing in descriptor array:
5768   // it must be either a simple type or a map wrapped in a weak cell.
5769   void UpdateFieldType(int descriptor_number, Handle<Name> name,
5770                        Representation new_representation,
5771                        Handle<Object> new_wrapped_type);
5772
5773   void PrintReconfiguration(FILE* file, int modify_index, PropertyKind kind,
5774                             PropertyAttributes attributes);
5775   void PrintGeneralization(FILE* file,
5776                            const char* reason,
5777                            int modify_index,
5778                            int split,
5779                            int descriptors,
5780                            bool constant_to_field,
5781                            Representation old_representation,
5782                            Representation new_representation,
5783                            HeapType* old_field_type,
5784                            HeapType* new_field_type);
5785
5786   static const int kFastPropertiesSoftLimit = 12;
5787   static const int kMaxFastProperties = 128;
5788
5789   DISALLOW_IMPLICIT_CONSTRUCTORS(Map);
5790 };
5791
5792
5793 // An abstract superclass, a marker class really, for simple structure classes.
5794 // It doesn't carry much functionality but allows struct classes to be
5795 // identified in the type system.
5796 class Struct: public HeapObject {
5797  public:
5798   inline void InitializeBody(int object_size);
5799   DECLARE_CAST(Struct)
5800 };
5801
5802
5803 // A simple one-element struct, useful where smis need to be boxed.
5804 class Box : public Struct {
5805  public:
5806   // [value]: the boxed contents.
5807   DECL_ACCESSORS(value, Object)
5808
5809   DECLARE_CAST(Box)
5810
5811   // Dispatched behavior.
5812   DECLARE_PRINTER(Box)
5813   DECLARE_VERIFIER(Box)
5814
5815   static const int kValueOffset = HeapObject::kHeaderSize;
5816   static const int kSize = kValueOffset + kPointerSize;
5817
5818  private:
5819   DISALLOW_IMPLICIT_CONSTRUCTORS(Box);
5820 };
5821
5822
5823 // Container for metadata stored on each prototype map.
5824 class PrototypeInfo : public Struct {
5825  public:
5826   static const int UNREGISTERED = -1;
5827
5828   // [prototype_users]: WeakFixedArray containing maps using this prototype,
5829   // or Smi(0) if uninitialized.
5830   DECL_ACCESSORS(prototype_users, Object)
5831   // [registry_slot]: Slot in prototype's user registry where this user
5832   // is stored. Returns UNREGISTERED if this prototype has not been registered.
5833   inline int registry_slot() const;
5834   inline void set_registry_slot(int slot);
5835   // [validity_cell]: Cell containing the validity bit for prototype chains
5836   // going through this object, or Smi(0) if uninitialized.
5837   DECL_ACCESSORS(validity_cell, Object)
5838   // [constructor_name]: User-friendly name of the original constructor.
5839   DECL_ACCESSORS(constructor_name, Object)
5840
5841   DECLARE_CAST(PrototypeInfo)
5842
5843   // Dispatched behavior.
5844   DECLARE_PRINTER(PrototypeInfo)
5845   DECLARE_VERIFIER(PrototypeInfo)
5846
5847   static const int kPrototypeUsersOffset = HeapObject::kHeaderSize;
5848   static const int kRegistrySlotOffset = kPrototypeUsersOffset + kPointerSize;
5849   static const int kValidityCellOffset = kRegistrySlotOffset + kPointerSize;
5850   static const int kConstructorNameOffset = kValidityCellOffset + kPointerSize;
5851   static const int kSize = kConstructorNameOffset + kPointerSize;
5852
5853  private:
5854   DISALLOW_IMPLICIT_CONSTRUCTORS(PrototypeInfo);
5855 };
5856
5857
5858 // Pair used to store both a ScopeInfo and an extension object in the extension
5859 // slot of a block context. Needed in the rare case where a declaration block
5860 // scope (a "varblock" as used to desugar parameter destructuring) also contains
5861 // a sloppy direct eval. (In no other case both are needed at the same time.)
5862 class SloppyBlockWithEvalContextExtension : public Struct {
5863  public:
5864   // [scope_info]: Scope info.
5865   DECL_ACCESSORS(scope_info, ScopeInfo)
5866   // [extension]: Extension object.
5867   DECL_ACCESSORS(extension, JSObject)
5868
5869   DECLARE_CAST(SloppyBlockWithEvalContextExtension)
5870
5871   // Dispatched behavior.
5872   DECLARE_PRINTER(SloppyBlockWithEvalContextExtension)
5873   DECLARE_VERIFIER(SloppyBlockWithEvalContextExtension)
5874
5875   static const int kScopeInfoOffset = HeapObject::kHeaderSize;
5876   static const int kExtensionOffset = kScopeInfoOffset + kPointerSize;
5877   static const int kSize = kExtensionOffset + kPointerSize;
5878
5879  private:
5880   DISALLOW_IMPLICIT_CONSTRUCTORS(SloppyBlockWithEvalContextExtension);
5881 };
5882
5883
5884 // Script describes a script which has been added to the VM.
5885 class Script: public Struct {
5886  public:
5887   // Script types.
5888   enum Type {
5889     TYPE_NATIVE = 0,
5890     TYPE_EXTENSION = 1,
5891     TYPE_NORMAL = 2
5892   };
5893
5894   // Script compilation types.
5895   enum CompilationType {
5896     COMPILATION_TYPE_HOST = 0,
5897     COMPILATION_TYPE_EVAL = 1
5898   };
5899
5900   // Script compilation state.
5901   enum CompilationState {
5902     COMPILATION_STATE_INITIAL = 0,
5903     COMPILATION_STATE_COMPILED = 1
5904   };
5905
5906   // [source]: the script source.
5907   DECL_ACCESSORS(source, Object)
5908
5909   // [name]: the script name.
5910   DECL_ACCESSORS(name, Object)
5911
5912   // [id]: the script id.
5913   DECL_ACCESSORS(id, Smi)
5914
5915   // [line_offset]: script line offset in resource from where it was extracted.
5916   DECL_ACCESSORS(line_offset, Smi)
5917
5918   // [column_offset]: script column offset in resource from where it was
5919   // extracted.
5920   DECL_ACCESSORS(column_offset, Smi)
5921
5922   // [context_data]: context data for the context this script was compiled in.
5923   DECL_ACCESSORS(context_data, Object)
5924
5925   // [wrapper]: the wrapper cache.  This is either undefined or a WeakCell.
5926   DECL_ACCESSORS(wrapper, HeapObject)
5927
5928   // [type]: the script type.
5929   DECL_ACCESSORS(type, Smi)
5930
5931   // [line_ends]: FixedArray of line ends positions.
5932   DECL_ACCESSORS(line_ends, Object)
5933
5934   // [eval_from_shared]: for eval scripts the shared funcion info for the
5935   // function from which eval was called.
5936   DECL_ACCESSORS(eval_from_shared, Object)
5937
5938   // [eval_from_instructions_offset]: the instruction offset in the code for the
5939   // function from which eval was called where eval was called.
5940   DECL_ACCESSORS(eval_from_instructions_offset, Smi)
5941
5942   // [shared_function_infos]: weak fixed array containing all shared
5943   // function infos created from this script.
5944   DECL_ACCESSORS(shared_function_infos, Object)
5945
5946   // [flags]: Holds an exciting bitfield.
5947   DECL_ACCESSORS(flags, Smi)
5948
5949   // [source_url]: sourceURL from magic comment
5950   DECL_ACCESSORS(source_url, Object)
5951
5952   // [source_url]: sourceMappingURL magic comment
5953   DECL_ACCESSORS(source_mapping_url, Object)
5954
5955   // [compilation_type]: how the the script was compiled. Encoded in the
5956   // 'flags' field.
5957   inline CompilationType compilation_type();
5958   inline void set_compilation_type(CompilationType type);
5959
5960   // [compilation_state]: determines whether the script has already been
5961   // compiled. Encoded in the 'flags' field.
5962   inline CompilationState compilation_state();
5963   inline void set_compilation_state(CompilationState state);
5964
5965   // [hide_source]: determines whether the script source can be exposed as
5966   // function source. Encoded in the 'flags' field.
5967   inline bool hide_source();
5968   inline void set_hide_source(bool value);
5969
5970   // [origin_options]: optional attributes set by the embedder via ScriptOrigin,
5971   // and used by the embedder to make decisions about the script. V8 just passes
5972   // this through. Encoded in the 'flags' field.
5973   inline v8::ScriptOriginOptions origin_options();
5974   inline void set_origin_options(ScriptOriginOptions origin_options);
5975
5976   DECLARE_CAST(Script)
5977
5978   // If script source is an external string, check that the underlying
5979   // resource is accessible. Otherwise, always return true.
5980   inline bool HasValidSource();
5981
5982   // Convert code position into column number.
5983   static int GetColumnNumber(Handle<Script> script, int code_pos);
5984
5985   // Convert code position into (zero-based) line number.
5986   // The non-handlified version does not allocate, but may be much slower.
5987   static int GetLineNumber(Handle<Script> script, int code_pos);
5988   int GetLineNumber(int code_pos);
5989
5990   static Handle<Object> GetNameOrSourceURL(Handle<Script> script);
5991
5992   // Init line_ends array with code positions of line ends inside script source.
5993   static void InitLineEnds(Handle<Script> script);
5994
5995   // Get the JS object wrapping the given script; create it if none exists.
5996   static Handle<JSObject> GetWrapper(Handle<Script> script);
5997
5998   // Look through the list of existing shared function infos to find one
5999   // that matches the function literal.  Return empty handle if not found.
6000   MaybeHandle<SharedFunctionInfo> FindSharedFunctionInfo(FunctionLiteral* fun);
6001
6002   // Iterate over all script objects on the heap.
6003   class Iterator {
6004    public:
6005     explicit Iterator(Isolate* isolate);
6006     Script* Next();
6007
6008    private:
6009     WeakFixedArray::Iterator iterator_;
6010     DISALLOW_COPY_AND_ASSIGN(Iterator);
6011   };
6012
6013   // Dispatched behavior.
6014   DECLARE_PRINTER(Script)
6015   DECLARE_VERIFIER(Script)
6016
6017   static const int kSourceOffset = HeapObject::kHeaderSize;
6018   static const int kNameOffset = kSourceOffset + kPointerSize;
6019   static const int kLineOffsetOffset = kNameOffset + kPointerSize;
6020   static const int kColumnOffsetOffset = kLineOffsetOffset + kPointerSize;
6021   static const int kContextOffset = kColumnOffsetOffset + kPointerSize;
6022   static const int kWrapperOffset = kContextOffset + kPointerSize;
6023   static const int kTypeOffset = kWrapperOffset + kPointerSize;
6024   static const int kLineEndsOffset = kTypeOffset + kPointerSize;
6025   static const int kIdOffset = kLineEndsOffset + kPointerSize;
6026   static const int kEvalFromSharedOffset = kIdOffset + kPointerSize;
6027   static const int kEvalFrominstructionsOffsetOffset =
6028       kEvalFromSharedOffset + kPointerSize;
6029   static const int kSharedFunctionInfosOffset =
6030       kEvalFrominstructionsOffsetOffset + kPointerSize;
6031   static const int kFlagsOffset = kSharedFunctionInfosOffset + kPointerSize;
6032   static const int kSourceUrlOffset = kFlagsOffset + kPointerSize;
6033   static const int kSourceMappingUrlOffset = kSourceUrlOffset + kPointerSize;
6034   static const int kSize = kSourceMappingUrlOffset + kPointerSize;
6035
6036  private:
6037   int GetLineNumberWithArray(int code_pos);
6038
6039   // Bit positions in the flags field.
6040   static const int kCompilationTypeBit = 0;
6041   static const int kCompilationStateBit = 1;
6042   static const int kHideSourceBit = 2;
6043   static const int kOriginOptionsShift = 3;
6044   static const int kOriginOptionsSize = 3;
6045   static const int kOriginOptionsMask = ((1 << kOriginOptionsSize) - 1)
6046                                         << kOriginOptionsShift;
6047
6048   DISALLOW_IMPLICIT_CONSTRUCTORS(Script);
6049 };
6050
6051
6052 // List of builtin functions we want to identify to improve code
6053 // generation.
6054 //
6055 // Each entry has a name of a global object property holding an object
6056 // optionally followed by ".prototype", a name of a builtin function
6057 // on the object (the one the id is set for), and a label.
6058 //
6059 // Installation of ids for the selected builtin functions is handled
6060 // by the bootstrapper.
6061 #define FUNCTIONS_WITH_ID_LIST(V)                   \
6062   V(Array.prototype, indexOf, ArrayIndexOf)         \
6063   V(Array.prototype, lastIndexOf, ArrayLastIndexOf) \
6064   V(Array.prototype, push, ArrayPush)               \
6065   V(Array.prototype, pop, ArrayPop)                 \
6066   V(Array.prototype, shift, ArrayShift)             \
6067   V(Function.prototype, apply, FunctionApply)       \
6068   V(Function.prototype, call, FunctionCall)         \
6069   V(String.prototype, charCodeAt, StringCharCodeAt) \
6070   V(String.prototype, charAt, StringCharAt)         \
6071   V(String, fromCharCode, StringFromCharCode)       \
6072   V(Math, random, MathRandom)                       \
6073   V(Math, floor, MathFloor)                         \
6074   V(Math, round, MathRound)                         \
6075   V(Math, ceil, MathCeil)                           \
6076   V(Math, abs, MathAbs)                             \
6077   V(Math, log, MathLog)                             \
6078   V(Math, exp, MathExp)                             \
6079   V(Math, sqrt, MathSqrt)                           \
6080   V(Math, pow, MathPow)                             \
6081   V(Math, max, MathMax)                             \
6082   V(Math, min, MathMin)                             \
6083   V(Math, cos, MathCos)                             \
6084   V(Math, sin, MathSin)                             \
6085   V(Math, tan, MathTan)                             \
6086   V(Math, acos, MathAcos)                           \
6087   V(Math, asin, MathAsin)                           \
6088   V(Math, atan, MathAtan)                           \
6089   V(Math, atan2, MathAtan2)                         \
6090   V(Math, imul, MathImul)                           \
6091   V(Math, clz32, MathClz32)                         \
6092   V(Math, fround, MathFround)
6093
6094 #define ATOMIC_FUNCTIONS_WITH_ID_LIST(V) \
6095   V(Atomics, load, AtomicsLoad)          \
6096   V(Atomics, store, AtomicsStore)
6097
6098 enum BuiltinFunctionId {
6099   kArrayCode,
6100 #define DECLARE_FUNCTION_ID(ignored1, ignore2, name)    \
6101   k##name,
6102   FUNCTIONS_WITH_ID_LIST(DECLARE_FUNCTION_ID)
6103       ATOMIC_FUNCTIONS_WITH_ID_LIST(DECLARE_FUNCTION_ID)
6104 #undef DECLARE_FUNCTION_ID
6105   // Fake id for a special case of Math.pow. Note, it continues the
6106   // list of math functions.
6107   kMathPowHalf
6108 };
6109
6110
6111 // Result of searching in an optimized code map of a SharedFunctionInfo. Note
6112 // that both {code} and {literals} can be NULL to pass search result status.
6113 struct CodeAndLiterals {
6114   Code* code;            // Cached optimized code.
6115   FixedArray* literals;  // Cached literals array.
6116 };
6117
6118
6119 // SharedFunctionInfo describes the JSFunction information that can be
6120 // shared by multiple instances of the function.
6121 class SharedFunctionInfo: public HeapObject {
6122  public:
6123   // [name]: Function name.
6124   DECL_ACCESSORS(name, Object)
6125
6126   // [code]: Function code.
6127   DECL_ACCESSORS(code, Code)
6128   inline void ReplaceCode(Code* code);
6129
6130   // [optimized_code_map]: Map from native context to optimized code
6131   // and a shared literals array or Smi(0) if none.
6132   DECL_ACCESSORS(optimized_code_map, Object)
6133
6134   // Returns entry from optimized code map for specified context and OSR entry.
6135   // Note that {code == nullptr} indicates no matching entry has been found,
6136   // whereas {literals == nullptr} indicates the code is context-independent.
6137   CodeAndLiterals SearchOptimizedCodeMap(Context* native_context,
6138                                          BailoutId osr_ast_id);
6139
6140   // Clear optimized code map.
6141   void ClearOptimizedCodeMap();
6142
6143   // Removed a specific optimized code object from the optimized code map.
6144   void EvictFromOptimizedCodeMap(Code* optimized_code, const char* reason);
6145
6146   // Trims the optimized code map after entries have been removed.
6147   void TrimOptimizedCodeMap(int shrink_by);
6148
6149   // Add a new entry to the optimized code map for context-independent code.
6150   static void AddSharedCodeToOptimizedCodeMap(Handle<SharedFunctionInfo> shared,
6151                                               Handle<Code> code);
6152
6153   // Add a new entry to the optimized code map for context-dependent code.
6154   static void AddToOptimizedCodeMap(Handle<SharedFunctionInfo> shared,
6155                                     Handle<Context> native_context,
6156                                     Handle<Code> code,
6157                                     Handle<FixedArray> literals,
6158                                     BailoutId osr_ast_id);
6159
6160   // Set up the link between shared function info and the script. The shared
6161   // function info is added to the list on the script.
6162   static void SetScript(Handle<SharedFunctionInfo> shared,
6163                         Handle<Object> script_object);
6164
6165   // Layout description of the optimized code map.
6166   static const int kNextMapIndex = 0;
6167   static const int kSharedCodeIndex = 1;
6168   static const int kEntriesStart = 2;
6169   static const int kContextOffset = 0;
6170   static const int kCachedCodeOffset = 1;
6171   static const int kLiteralsOffset = 2;
6172   static const int kOsrAstIdOffset = 3;
6173   static const int kEntryLength = 4;
6174   static const int kInitialLength = kEntriesStart + kEntryLength;
6175
6176   // [scope_info]: Scope info.
6177   DECL_ACCESSORS(scope_info, ScopeInfo)
6178
6179   // [construct stub]: Code stub for constructing instances of this function.
6180   DECL_ACCESSORS(construct_stub, Code)
6181
6182   // Returns if this function has been compiled to native code yet.
6183   inline bool is_compiled();
6184
6185   // [length]: The function length - usually the number of declared parameters.
6186   // Use up to 2^30 parameters.
6187   inline int length() const;
6188   inline void set_length(int value);
6189
6190   // [internal formal parameter count]: The declared number of parameters.
6191   // For subclass constructors, also includes new.target.
6192   // The size of function's frame is internal_formal_parameter_count + 1.
6193   inline int internal_formal_parameter_count() const;
6194   inline void set_internal_formal_parameter_count(int value);
6195
6196   // Set the formal parameter count so the function code will be
6197   // called without using argument adaptor frames.
6198   inline void DontAdaptArguments();
6199
6200   // [expected_nof_properties]: Expected number of properties for the function.
6201   inline int expected_nof_properties() const;
6202   inline void set_expected_nof_properties(int value);
6203
6204   // [feedback_vector] - accumulates ast node feedback from full-codegen and
6205   // (increasingly) from crankshafted code where sufficient feedback isn't
6206   // available.
6207   DECL_ACCESSORS(feedback_vector, TypeFeedbackVector)
6208
6209   // Unconditionally clear the type feedback vector (including vector ICs).
6210   void ClearTypeFeedbackInfo();
6211
6212   // Clear the type feedback vector with a more subtle policy at GC time.
6213   void ClearTypeFeedbackInfoAtGCTime();
6214
6215 #if TRACE_MAPS
6216   // [unique_id] - For --trace-maps purposes, an identifier that's persistent
6217   // even if the GC moves this SharedFunctionInfo.
6218   inline int unique_id() const;
6219   inline void set_unique_id(int value);
6220 #endif
6221
6222   // [instance class name]: class name for instances.
6223   DECL_ACCESSORS(instance_class_name, Object)
6224
6225   // [function data]: This field holds some additional data for function.
6226   // Currently it has one of:
6227   //  - a FunctionTemplateInfo to make benefit the API [IsApiFunction()].
6228   //  - a Smi identifying a builtin function [HasBuiltinFunctionId()].
6229   //  - a BytecodeArray for the interpreter [HasBytecodeArray()].
6230   // In the long run we don't want all functions to have this field but
6231   // we can fix that when we have a better model for storing hidden data
6232   // on objects.
6233   DECL_ACCESSORS(function_data, Object)
6234
6235   inline bool IsApiFunction();
6236   inline FunctionTemplateInfo* get_api_func_data();
6237   inline bool HasBuiltinFunctionId();
6238   inline BuiltinFunctionId builtin_function_id();
6239   inline bool HasBytecodeArray();
6240   inline BytecodeArray* bytecode_array();
6241
6242   // [script info]: Script from which the function originates.
6243   DECL_ACCESSORS(script, Object)
6244
6245   // [num_literals]: Number of literals used by this function.
6246   inline int num_literals() const;
6247   inline void set_num_literals(int value);
6248
6249   // [start_position_and_type]: Field used to store both the source code
6250   // position, whether or not the function is a function expression,
6251   // and whether or not the function is a toplevel function. The two
6252   // least significants bit indicates whether the function is an
6253   // expression and the rest contains the source code position.
6254   inline int start_position_and_type() const;
6255   inline void set_start_position_and_type(int value);
6256
6257   // The function is subject to debugging if a debug info is attached.
6258   inline bool HasDebugInfo();
6259   inline DebugInfo* GetDebugInfo();
6260
6261   // A function has debug code if the compiled code has debug break slots.
6262   inline bool HasDebugCode();
6263
6264   // [debug info]: Debug information.
6265   DECL_ACCESSORS(debug_info, Object)
6266
6267   // [inferred name]: Name inferred from variable or property
6268   // assignment of this function. Used to facilitate debugging and
6269   // profiling of JavaScript code written in OO style, where almost
6270   // all functions are anonymous but are assigned to object
6271   // properties.
6272   DECL_ACCESSORS(inferred_name, String)
6273
6274   // The function's name if it is non-empty, otherwise the inferred name.
6275   String* DebugName();
6276
6277   // Position of the 'function' token in the script source.
6278   inline int function_token_position() const;
6279   inline void set_function_token_position(int function_token_position);
6280
6281   // Position of this function in the script source.
6282   inline int start_position() const;
6283   inline void set_start_position(int start_position);
6284
6285   // End position of this function in the script source.
6286   inline int end_position() const;
6287   inline void set_end_position(int end_position);
6288
6289   // Is this function a function expression in the source code.
6290   DECL_BOOLEAN_ACCESSORS(is_expression)
6291
6292   // Is this function a top-level function (scripts, evals).
6293   DECL_BOOLEAN_ACCESSORS(is_toplevel)
6294
6295   // Bit field containing various information collected by the compiler to
6296   // drive optimization.
6297   inline int compiler_hints() const;
6298   inline void set_compiler_hints(int value);
6299
6300   inline int ast_node_count() const;
6301   inline void set_ast_node_count(int count);
6302
6303   inline int profiler_ticks() const;
6304   inline void set_profiler_ticks(int ticks);
6305
6306   // Inline cache age is used to infer whether the function survived a context
6307   // disposal or not. In the former case we reset the opt_count.
6308   inline int ic_age();
6309   inline void set_ic_age(int age);
6310
6311   // Indicates if this function can be lazy compiled.
6312   // This is used to determine if we can safely flush code from a function
6313   // when doing GC if we expect that the function will no longer be used.
6314   DECL_BOOLEAN_ACCESSORS(allows_lazy_compilation)
6315
6316   // Indicates if this function can be lazy compiled without a context.
6317   // This is used to determine if we can force compilation without reaching
6318   // the function through program execution but through other means (e.g. heap
6319   // iteration by the debugger).
6320   DECL_BOOLEAN_ACCESSORS(allows_lazy_compilation_without_context)
6321
6322   // Indicates whether optimizations have been disabled for this
6323   // shared function info. If a function is repeatedly optimized or if
6324   // we cannot optimize the function we disable optimization to avoid
6325   // spending time attempting to optimize it again.
6326   DECL_BOOLEAN_ACCESSORS(optimization_disabled)
6327
6328   // Indicates the language mode.
6329   inline LanguageMode language_mode();
6330   inline void set_language_mode(LanguageMode language_mode);
6331
6332   // False if the function definitely does not allocate an arguments object.
6333   DECL_BOOLEAN_ACCESSORS(uses_arguments)
6334
6335   // Indicates that this function uses a super property (or an eval that may
6336   // use a super property).
6337   // This is needed to set up the [[HomeObject]] on the function instance.
6338   DECL_BOOLEAN_ACCESSORS(needs_home_object)
6339
6340   // True if the function has any duplicated parameter names.
6341   DECL_BOOLEAN_ACCESSORS(has_duplicate_parameters)
6342
6343   // Indicates whether the function is a native function.
6344   // These needs special treatment in .call and .apply since
6345   // null passed as the receiver should not be translated to the
6346   // global object.
6347   DECL_BOOLEAN_ACCESSORS(native)
6348
6349   // Indicate that this function should always be inlined in optimized code.
6350   DECL_BOOLEAN_ACCESSORS(force_inline)
6351
6352   // Indicates that the function was created by the Function function.
6353   // Though it's anonymous, toString should treat it as if it had the name
6354   // "anonymous".  We don't set the name itself so that the system does not
6355   // see a binding for it.
6356   DECL_BOOLEAN_ACCESSORS(name_should_print_as_anonymous)
6357
6358   // Indicates whether the function is a bound function created using
6359   // the bind function.
6360   DECL_BOOLEAN_ACCESSORS(bound)
6361
6362   // Indicates that the function is anonymous (the name field can be set
6363   // through the API, which does not change this flag).
6364   DECL_BOOLEAN_ACCESSORS(is_anonymous)
6365
6366   // Is this a function or top-level/eval code.
6367   DECL_BOOLEAN_ACCESSORS(is_function)
6368
6369   // Indicates that code for this function cannot be compiled with Crankshaft.
6370   DECL_BOOLEAN_ACCESSORS(dont_crankshaft)
6371
6372   // Indicates that code for this function cannot be flushed.
6373   DECL_BOOLEAN_ACCESSORS(dont_flush)
6374
6375   // Indicates that this function is a generator.
6376   DECL_BOOLEAN_ACCESSORS(is_generator)
6377
6378   // Indicates that this function is an arrow function.
6379   DECL_BOOLEAN_ACCESSORS(is_arrow)
6380
6381   // Indicates that this function is a concise method.
6382   DECL_BOOLEAN_ACCESSORS(is_concise_method)
6383
6384   // Indicates that this function is an accessor (getter or setter).
6385   DECL_BOOLEAN_ACCESSORS(is_accessor_function)
6386
6387   // Indicates that this function is a default constructor.
6388   DECL_BOOLEAN_ACCESSORS(is_default_constructor)
6389
6390   // Indicates that this function is an asm function.
6391   DECL_BOOLEAN_ACCESSORS(asm_function)
6392
6393   // Indicates that the the shared function info is deserialized from cache.
6394   DECL_BOOLEAN_ACCESSORS(deserialized)
6395
6396   // Indicates that the the shared function info has never been compiled before.
6397   DECL_BOOLEAN_ACCESSORS(never_compiled)
6398
6399   inline FunctionKind kind();
6400   inline void set_kind(FunctionKind kind);
6401
6402   // Indicates whether or not the code in the shared function support
6403   // deoptimization.
6404   inline bool has_deoptimization_support();
6405
6406   // Enable deoptimization support through recompiled code.
6407   void EnableDeoptimizationSupport(Code* recompiled);
6408
6409   // Disable (further) attempted optimization of all functions sharing this
6410   // shared function info.
6411   void DisableOptimization(BailoutReason reason);
6412
6413   inline BailoutReason disable_optimization_reason();
6414
6415   // Lookup the bailout ID and DCHECK that it exists in the non-optimized
6416   // code, returns whether it asserted (i.e., always true if assertions are
6417   // disabled).
6418   bool VerifyBailoutId(BailoutId id);
6419
6420   // [source code]: Source code for the function.
6421   bool HasSourceCode() const;
6422   Handle<Object> GetSourceCode();
6423
6424   // Number of times the function was optimized.
6425   inline int opt_count();
6426   inline void set_opt_count(int opt_count);
6427
6428   // Number of times the function was deoptimized.
6429   inline void set_deopt_count(int value);
6430   inline int deopt_count();
6431   inline void increment_deopt_count();
6432
6433   // Number of time we tried to re-enable optimization after it
6434   // was disabled due to high number of deoptimizations.
6435   inline void set_opt_reenable_tries(int value);
6436   inline int opt_reenable_tries();
6437
6438   inline void TryReenableOptimization();
6439
6440   // Stores deopt_count, opt_reenable_tries and ic_age as bit-fields.
6441   inline void set_counters(int value);
6442   inline int counters() const;
6443
6444   // Stores opt_count and bailout_reason as bit-fields.
6445   inline void set_opt_count_and_bailout_reason(int value);
6446   inline int opt_count_and_bailout_reason() const;
6447
6448   inline void set_disable_optimization_reason(BailoutReason reason);
6449
6450   // Tells whether this function should be subject to debugging.
6451   inline bool IsSubjectToDebugging();
6452
6453   // Whether this function is defined in native code or extensions.
6454   inline bool IsBuiltin();
6455
6456   // Check whether or not this function is inlineable.
6457   bool IsInlineable();
6458
6459   // Source size of this function.
6460   int SourceSize();
6461
6462   // Calculate the instance size.
6463   int CalculateInstanceSize();
6464
6465   // Calculate the number of in-object properties.
6466   int CalculateInObjectProperties();
6467
6468   inline bool has_simple_parameters();
6469
6470   // Initialize a SharedFunctionInfo from a parsed function literal.
6471   static void InitFromFunctionLiteral(Handle<SharedFunctionInfo> shared_info,
6472                                       FunctionLiteral* lit);
6473
6474   // Dispatched behavior.
6475   DECLARE_PRINTER(SharedFunctionInfo)
6476   DECLARE_VERIFIER(SharedFunctionInfo)
6477
6478   void ResetForNewContext(int new_ic_age);
6479
6480   // Iterate over all shared function infos that are created from a script.
6481   // That excludes shared function infos created for API functions and C++
6482   // builtins.
6483   class Iterator {
6484    public:
6485     explicit Iterator(Isolate* isolate);
6486     SharedFunctionInfo* Next();
6487
6488    private:
6489     bool NextScript();
6490
6491     Script::Iterator script_iterator_;
6492     WeakFixedArray::Iterator sfi_iterator_;
6493     DisallowHeapAllocation no_gc_;
6494     DISALLOW_COPY_AND_ASSIGN(Iterator);
6495   };
6496
6497   DECLARE_CAST(SharedFunctionInfo)
6498
6499   // Constants.
6500   static const int kDontAdaptArgumentsSentinel = -1;
6501
6502   // Layout description.
6503   // Pointer fields.
6504   static const int kNameOffset = HeapObject::kHeaderSize;
6505   static const int kCodeOffset = kNameOffset + kPointerSize;
6506   static const int kOptimizedCodeMapOffset = kCodeOffset + kPointerSize;
6507   static const int kScopeInfoOffset = kOptimizedCodeMapOffset + kPointerSize;
6508   static const int kConstructStubOffset = kScopeInfoOffset + kPointerSize;
6509   static const int kInstanceClassNameOffset =
6510       kConstructStubOffset + kPointerSize;
6511   static const int kFunctionDataOffset =
6512       kInstanceClassNameOffset + kPointerSize;
6513   static const int kScriptOffset = kFunctionDataOffset + kPointerSize;
6514   static const int kDebugInfoOffset = kScriptOffset + kPointerSize;
6515   static const int kInferredNameOffset = kDebugInfoOffset + kPointerSize;
6516   static const int kFeedbackVectorOffset =
6517       kInferredNameOffset + kPointerSize;
6518 #if TRACE_MAPS
6519   static const int kUniqueIdOffset = kFeedbackVectorOffset + kPointerSize;
6520   static const int kLastPointerFieldOffset = kUniqueIdOffset;
6521 #else
6522   // Just to not break the postmortrem support with conditional offsets
6523   static const int kUniqueIdOffset = kFeedbackVectorOffset;
6524   static const int kLastPointerFieldOffset = kFeedbackVectorOffset;
6525 #endif
6526
6527 #if V8_HOST_ARCH_32_BIT
6528   // Smi fields.
6529   static const int kLengthOffset = kLastPointerFieldOffset + kPointerSize;
6530   static const int kFormalParameterCountOffset = kLengthOffset + kPointerSize;
6531   static const int kExpectedNofPropertiesOffset =
6532       kFormalParameterCountOffset + kPointerSize;
6533   static const int kNumLiteralsOffset =
6534       kExpectedNofPropertiesOffset + kPointerSize;
6535   static const int kStartPositionAndTypeOffset =
6536       kNumLiteralsOffset + kPointerSize;
6537   static const int kEndPositionOffset =
6538       kStartPositionAndTypeOffset + kPointerSize;
6539   static const int kFunctionTokenPositionOffset =
6540       kEndPositionOffset + kPointerSize;
6541   static const int kCompilerHintsOffset =
6542       kFunctionTokenPositionOffset + kPointerSize;
6543   static const int kOptCountAndBailoutReasonOffset =
6544       kCompilerHintsOffset + kPointerSize;
6545   static const int kCountersOffset =
6546       kOptCountAndBailoutReasonOffset + kPointerSize;
6547   static const int kAstNodeCountOffset =
6548       kCountersOffset + kPointerSize;
6549   static const int kProfilerTicksOffset =
6550       kAstNodeCountOffset + kPointerSize;
6551
6552   // Total size.
6553   static const int kSize = kProfilerTicksOffset + kPointerSize;
6554 #else
6555   // The only reason to use smi fields instead of int fields
6556   // is to allow iteration without maps decoding during
6557   // garbage collections.
6558   // To avoid wasting space on 64-bit architectures we use
6559   // the following trick: we group integer fields into pairs
6560 // The least significant integer in each pair is shifted left by 1.
6561 // By doing this we guarantee that LSB of each kPointerSize aligned
6562 // word is not set and thus this word cannot be treated as pointer
6563 // to HeapObject during old space traversal.
6564 #if V8_TARGET_LITTLE_ENDIAN
6565   static const int kLengthOffset = kLastPointerFieldOffset + kPointerSize;
6566   static const int kFormalParameterCountOffset =
6567       kLengthOffset + kIntSize;
6568
6569   static const int kExpectedNofPropertiesOffset =
6570       kFormalParameterCountOffset + kIntSize;
6571   static const int kNumLiteralsOffset =
6572       kExpectedNofPropertiesOffset + kIntSize;
6573
6574   static const int kEndPositionOffset =
6575       kNumLiteralsOffset + kIntSize;
6576   static const int kStartPositionAndTypeOffset =
6577       kEndPositionOffset + kIntSize;
6578
6579   static const int kFunctionTokenPositionOffset =
6580       kStartPositionAndTypeOffset + kIntSize;
6581   static const int kCompilerHintsOffset =
6582       kFunctionTokenPositionOffset + kIntSize;
6583
6584   static const int kOptCountAndBailoutReasonOffset =
6585       kCompilerHintsOffset + kIntSize;
6586   static const int kCountersOffset =
6587       kOptCountAndBailoutReasonOffset + kIntSize;
6588
6589   static const int kAstNodeCountOffset =
6590       kCountersOffset + kIntSize;
6591   static const int kProfilerTicksOffset =
6592       kAstNodeCountOffset + kIntSize;
6593
6594   // Total size.
6595   static const int kSize = kProfilerTicksOffset + kIntSize;
6596
6597 #elif V8_TARGET_BIG_ENDIAN
6598   static const int kFormalParameterCountOffset =
6599       kLastPointerFieldOffset + kPointerSize;
6600   static const int kLengthOffset = kFormalParameterCountOffset + kIntSize;
6601
6602   static const int kNumLiteralsOffset = kLengthOffset + kIntSize;
6603   static const int kExpectedNofPropertiesOffset = kNumLiteralsOffset + kIntSize;
6604
6605   static const int kStartPositionAndTypeOffset =
6606       kExpectedNofPropertiesOffset + kIntSize;
6607   static const int kEndPositionOffset = kStartPositionAndTypeOffset + kIntSize;
6608
6609   static const int kCompilerHintsOffset = kEndPositionOffset + kIntSize;
6610   static const int kFunctionTokenPositionOffset =
6611       kCompilerHintsOffset + kIntSize;
6612
6613   static const int kCountersOffset = kFunctionTokenPositionOffset + kIntSize;
6614   static const int kOptCountAndBailoutReasonOffset = kCountersOffset + kIntSize;
6615
6616   static const int kProfilerTicksOffset =
6617       kOptCountAndBailoutReasonOffset + kIntSize;
6618   static const int kAstNodeCountOffset = kProfilerTicksOffset + kIntSize;
6619
6620   // Total size.
6621   static const int kSize = kAstNodeCountOffset + kIntSize;
6622
6623 #else
6624 #error Unknown byte ordering
6625 #endif  // Big endian
6626 #endif  // 64-bit
6627
6628
6629   static const int kAlignedSize = POINTER_SIZE_ALIGN(kSize);
6630
6631   typedef FixedBodyDescriptor<kNameOffset,
6632                               kLastPointerFieldOffset + kPointerSize,
6633                               kSize> BodyDescriptor;
6634
6635   // Bit positions in start_position_and_type.
6636   // The source code start position is in the 30 most significant bits of
6637   // the start_position_and_type field.
6638   static const int kIsExpressionBit    = 0;
6639   static const int kIsTopLevelBit      = 1;
6640   static const int kStartPositionShift = 2;
6641   static const int kStartPositionMask  = ~((1 << kStartPositionShift) - 1);
6642
6643   // Bit positions in compiler_hints.
6644   enum CompilerHints {
6645     kAllowLazyCompilation,
6646     kAllowLazyCompilationWithoutContext,
6647     kOptimizationDisabled,
6648     kStrictModeFunction,
6649     kStrongModeFunction,
6650     kUsesArguments,
6651     kNeedsHomeObject,
6652     kHasDuplicateParameters,
6653     kNative,
6654     kForceInline,
6655     kBoundFunction,
6656     kIsAnonymous,
6657     kNameShouldPrintAsAnonymous,
6658     kIsFunction,
6659     kDontCrankshaft,
6660     kDontFlush,
6661     kIsArrow,
6662     kIsGenerator,
6663     kIsConciseMethod,
6664     kIsAccessorFunction,
6665     kIsDefaultConstructor,
6666     kIsSubclassConstructor,
6667     kIsBaseConstructor,
6668     kInClassLiteral,
6669     kIsAsmFunction,
6670     kDeserialized,
6671     kNeverCompiled,
6672     kCompilerHintsCount  // Pseudo entry
6673   };
6674   // Add hints for other modes when they're added.
6675   STATIC_ASSERT(LANGUAGE_END == 3);
6676
6677   class FunctionKindBits : public BitField<FunctionKind, kIsArrow, 8> {};
6678
6679   class DeoptCountBits : public BitField<int, 0, 4> {};
6680   class OptReenableTriesBits : public BitField<int, 4, 18> {};
6681   class ICAgeBits : public BitField<int, 22, 8> {};
6682
6683   class OptCountBits : public BitField<int, 0, 22> {};
6684   class DisabledOptimizationReasonBits : public BitField<int, 22, 8> {};
6685
6686  private:
6687 #if V8_HOST_ARCH_32_BIT
6688   // On 32 bit platforms, compiler hints is a smi.
6689   static const int kCompilerHintsSmiTagSize = kSmiTagSize;
6690   static const int kCompilerHintsSize = kPointerSize;
6691 #else
6692   // On 64 bit platforms, compiler hints is not a smi, see comment above.
6693   static const int kCompilerHintsSmiTagSize = 0;
6694   static const int kCompilerHintsSize = kIntSize;
6695 #endif
6696
6697   STATIC_ASSERT(SharedFunctionInfo::kCompilerHintsCount <=
6698                 SharedFunctionInfo::kCompilerHintsSize * kBitsPerByte);
6699
6700  public:
6701   // Constants for optimizing codegen for strict mode function and
6702   // native tests.
6703   // Allows to use byte-width instructions.
6704   static const int kStrictModeBitWithinByte =
6705       (kStrictModeFunction + kCompilerHintsSmiTagSize) % kBitsPerByte;
6706   static const int kStrongModeBitWithinByte =
6707       (kStrongModeFunction + kCompilerHintsSmiTagSize) % kBitsPerByte;
6708
6709   static const int kNativeBitWithinByte =
6710       (kNative + kCompilerHintsSmiTagSize) % kBitsPerByte;
6711
6712 #if defined(V8_TARGET_LITTLE_ENDIAN)
6713   static const int kStrictModeByteOffset = kCompilerHintsOffset +
6714       (kStrictModeFunction + kCompilerHintsSmiTagSize) / kBitsPerByte;
6715   static const int kStrongModeByteOffset =
6716       kCompilerHintsOffset +
6717       (kStrongModeFunction + kCompilerHintsSmiTagSize) / kBitsPerByte;
6718   static const int kNativeByteOffset = kCompilerHintsOffset +
6719       (kNative + kCompilerHintsSmiTagSize) / kBitsPerByte;
6720 #elif defined(V8_TARGET_BIG_ENDIAN)
6721   static const int kStrictModeByteOffset = kCompilerHintsOffset +
6722       (kCompilerHintsSize - 1) -
6723       ((kStrictModeFunction + kCompilerHintsSmiTagSize) / kBitsPerByte);
6724   static const int kStrongModeByteOffset =
6725       kCompilerHintsOffset + (kCompilerHintsSize - 1) -
6726       ((kStrongModeFunction + kCompilerHintsSmiTagSize) / kBitsPerByte);
6727   static const int kNativeByteOffset = kCompilerHintsOffset +
6728       (kCompilerHintsSize - 1) -
6729       ((kNative + kCompilerHintsSmiTagSize) / kBitsPerByte);
6730 #else
6731 #error Unknown byte ordering
6732 #endif
6733
6734  private:
6735   DISALLOW_IMPLICIT_CONSTRUCTORS(SharedFunctionInfo);
6736 };
6737
6738
6739 // Printing support.
6740 struct SourceCodeOf {
6741   explicit SourceCodeOf(SharedFunctionInfo* v, int max = -1)
6742       : value(v), max_length(max) {}
6743   const SharedFunctionInfo* value;
6744   int max_length;
6745 };
6746
6747
6748 std::ostream& operator<<(std::ostream& os, const SourceCodeOf& v);
6749
6750
6751 class JSGeneratorObject: public JSObject {
6752  public:
6753   // [function]: The function corresponding to this generator object.
6754   DECL_ACCESSORS(function, JSFunction)
6755
6756   // [context]: The context of the suspended computation.
6757   DECL_ACCESSORS(context, Context)
6758
6759   // [receiver]: The receiver of the suspended computation.
6760   DECL_ACCESSORS(receiver, Object)
6761
6762   // [continuation]: Offset into code of continuation.
6763   //
6764   // A positive offset indicates a suspended generator.  The special
6765   // kGeneratorExecuting and kGeneratorClosed values indicate that a generator
6766   // cannot be resumed.
6767   inline int continuation() const;
6768   inline void set_continuation(int continuation);
6769   inline bool is_closed();
6770   inline bool is_executing();
6771   inline bool is_suspended();
6772
6773   // [operand_stack]: Saved operand stack.
6774   DECL_ACCESSORS(operand_stack, FixedArray)
6775
6776   DECLARE_CAST(JSGeneratorObject)
6777
6778   // Dispatched behavior.
6779   DECLARE_PRINTER(JSGeneratorObject)
6780   DECLARE_VERIFIER(JSGeneratorObject)
6781
6782   // Magic sentinel values for the continuation.
6783   static const int kGeneratorExecuting = -1;
6784   static const int kGeneratorClosed = 0;
6785
6786   // Layout description.
6787   static const int kFunctionOffset = JSObject::kHeaderSize;
6788   static const int kContextOffset = kFunctionOffset + kPointerSize;
6789   static const int kReceiverOffset = kContextOffset + kPointerSize;
6790   static const int kContinuationOffset = kReceiverOffset + kPointerSize;
6791   static const int kOperandStackOffset = kContinuationOffset + kPointerSize;
6792   static const int kSize = kOperandStackOffset + kPointerSize;
6793
6794   // Resume mode, for use by runtime functions.
6795   enum ResumeMode { NEXT, THROW };
6796
6797   // Yielding from a generator returns an object with the following inobject
6798   // properties.  See Context::iterator_result_map() for the map.
6799   static const int kResultValuePropertyIndex = 0;
6800   static const int kResultDonePropertyIndex = 1;
6801   static const int kResultPropertyCount = 2;
6802
6803   static const int kResultValuePropertyOffset = JSObject::kHeaderSize;
6804   static const int kResultDonePropertyOffset =
6805       kResultValuePropertyOffset + kPointerSize;
6806   static const int kResultSize = kResultDonePropertyOffset + kPointerSize;
6807
6808  private:
6809   DISALLOW_IMPLICIT_CONSTRUCTORS(JSGeneratorObject);
6810 };
6811
6812
6813 // Representation for module instance objects.
6814 class JSModule: public JSObject {
6815  public:
6816   // [context]: the context holding the module's locals, or undefined if none.
6817   DECL_ACCESSORS(context, Object)
6818
6819   // [scope_info]: Scope info.
6820   DECL_ACCESSORS(scope_info, ScopeInfo)
6821
6822   DECLARE_CAST(JSModule)
6823
6824   // Dispatched behavior.
6825   DECLARE_PRINTER(JSModule)
6826   DECLARE_VERIFIER(JSModule)
6827
6828   // Layout description.
6829   static const int kContextOffset = JSObject::kHeaderSize;
6830   static const int kScopeInfoOffset = kContextOffset + kPointerSize;
6831   static const int kSize = kScopeInfoOffset + kPointerSize;
6832
6833  private:
6834   DISALLOW_IMPLICIT_CONSTRUCTORS(JSModule);
6835 };
6836
6837
6838 // JSFunction describes JavaScript functions.
6839 class JSFunction: public JSObject {
6840  public:
6841   // [prototype_or_initial_map]:
6842   DECL_ACCESSORS(prototype_or_initial_map, Object)
6843
6844   // [shared]: The information about the function that
6845   // can be shared by instances.
6846   DECL_ACCESSORS(shared, SharedFunctionInfo)
6847
6848   // [context]: The context for this function.
6849   inline Context* context();
6850   inline void set_context(Object* context);
6851   inline JSObject* global_proxy();
6852
6853   // [code]: The generated code object for this function.  Executed
6854   // when the function is invoked, e.g. foo() or new foo(). See
6855   // [[Call]] and [[Construct]] description in ECMA-262, section
6856   // 8.6.2, page 27.
6857   inline Code* code();
6858   inline void set_code(Code* code);
6859   inline void set_code_no_write_barrier(Code* code);
6860   inline void ReplaceCode(Code* code);
6861
6862   // Tells whether this function is builtin.
6863   inline bool IsBuiltin();
6864
6865   // Tells whether this function inlines the given shared function info.
6866   bool Inlines(SharedFunctionInfo* candidate);
6867
6868   // Tells whether this function should be subject to debugging.
6869   inline bool IsSubjectToDebugging();
6870
6871   // Tells whether or not the function needs arguments adaption.
6872   inline bool NeedsArgumentsAdaption();
6873
6874   // Tells whether or not this function has been optimized.
6875   inline bool IsOptimized();
6876
6877   // Mark this function for lazy recompilation. The function will be
6878   // recompiled the next time it is executed.
6879   void MarkForOptimization();
6880   void AttemptConcurrentOptimization();
6881
6882   // Tells whether or not the function is already marked for lazy
6883   // recompilation.
6884   inline bool IsMarkedForOptimization();
6885   inline bool IsMarkedForConcurrentOptimization();
6886
6887   // Tells whether or not the function is on the concurrent recompilation queue.
6888   inline bool IsInOptimizationQueue();
6889
6890   // Inobject slack tracking is the way to reclaim unused inobject space.
6891   //
6892   // The instance size is initially determined by adding some slack to
6893   // expected_nof_properties (to allow for a few extra properties added
6894   // after the constructor). There is no guarantee that the extra space
6895   // will not be wasted.
6896   //
6897   // Here is the algorithm to reclaim the unused inobject space:
6898   // - Detect the first constructor call for this JSFunction.
6899   //   When it happens enter the "in progress" state: initialize construction
6900   //   counter in the initial_map.
6901   // - While the tracking is in progress create objects filled with
6902   //   one_pointer_filler_map instead of undefined_value. This way they can be
6903   //   resized quickly and safely.
6904   // - Once enough objects have been created  compute the 'slack'
6905   //   (traverse the map transition tree starting from the
6906   //   initial_map and find the lowest value of unused_property_fields).
6907   // - Traverse the transition tree again and decrease the instance size
6908   //   of every map. Existing objects will resize automatically (they are
6909   //   filled with one_pointer_filler_map). All further allocations will
6910   //   use the adjusted instance size.
6911   // - SharedFunctionInfo's expected_nof_properties left unmodified since
6912   //   allocations made using different closures could actually create different
6913   //   kind of objects (see prototype inheritance pattern).
6914   //
6915   //  Important: inobject slack tracking is not attempted during the snapshot
6916   //  creation.
6917
6918   // True if the initial_map is set and the object constructions countdown
6919   // counter is not zero.
6920   static const int kGenerousAllocationCount =
6921       Map::kSlackTrackingCounterStart - Map::kSlackTrackingCounterEnd + 1;
6922   inline bool IsInobjectSlackTrackingInProgress();
6923
6924   // Starts the tracking.
6925   // Initializes object constructions countdown counter in the initial map.
6926   void StartInobjectSlackTracking();
6927
6928   // Completes the tracking.
6929   void CompleteInobjectSlackTracking();
6930
6931   // [literals_or_bindings]: Fixed array holding either
6932   // the materialized literals or the bindings of a bound function.
6933   //
6934   // If the function contains object, regexp or array literals, the
6935   // literals array prefix contains the object, regexp, and array
6936   // function to be used when creating these literals.  This is
6937   // necessary so that we do not dynamically lookup the object, regexp
6938   // or array functions.  Performing a dynamic lookup, we might end up
6939   // using the functions from a new context that we should not have
6940   // access to.
6941   //
6942   // On bound functions, the array is a (copy-on-write) fixed-array containing
6943   // the function that was bound, bound this-value and any bound
6944   // arguments. Bound functions never contain literals.
6945   DECL_ACCESSORS(literals_or_bindings, FixedArray)
6946
6947   inline FixedArray* literals();
6948   inline void set_literals(FixedArray* literals);
6949
6950   inline FixedArray* function_bindings();
6951   inline void set_function_bindings(FixedArray* bindings);
6952
6953   // The initial map for an object created by this constructor.
6954   inline Map* initial_map();
6955   static void SetInitialMap(Handle<JSFunction> function, Handle<Map> map,
6956                             Handle<Object> prototype);
6957   inline bool has_initial_map();
6958   static void EnsureHasInitialMap(Handle<JSFunction> function);
6959
6960   // Get and set the prototype property on a JSFunction. If the
6961   // function has an initial map the prototype is set on the initial
6962   // map. Otherwise, the prototype is put in the initial map field
6963   // until an initial map is needed.
6964   inline bool has_prototype();
6965   inline bool has_instance_prototype();
6966   inline Object* prototype();
6967   inline Object* instance_prototype();
6968   static void SetPrototype(Handle<JSFunction> function,
6969                            Handle<Object> value);
6970   static void SetInstancePrototype(Handle<JSFunction> function,
6971                                    Handle<Object> value);
6972
6973   // Creates a new closure for the fucntion with the same bindings,
6974   // bound values, and prototype. An equivalent of spec operations
6975   // ``CloneMethod`` and ``CloneBoundFunction``.
6976   static Handle<JSFunction> CloneClosure(Handle<JSFunction> function);
6977
6978   // After prototype is removed, it will not be created when accessed, and
6979   // [[Construct]] from this function will not be allowed.
6980   bool RemovePrototype();
6981   inline bool should_have_prototype();
6982
6983   // Accessor for this function's initial map's [[class]]
6984   // property. This is primarily used by ECMA native functions.  This
6985   // method sets the class_name field of this function's initial map
6986   // to a given value. It creates an initial map if this function does
6987   // not have one. Note that this method does not copy the initial map
6988   // if it has one already, but simply replaces it with the new value.
6989   // Instances created afterwards will have a map whose [[class]] is
6990   // set to 'value', but there is no guarantees on instances created
6991   // before.
6992   void SetInstanceClassName(String* name);
6993
6994   // Returns if this function has been compiled to native code yet.
6995   inline bool is_compiled();
6996
6997   // Returns `false` if formal parameters include rest parameters, optional
6998   // parameters, or destructuring parameters.
6999   // TODO(caitp): make this a flag set during parsing
7000   inline bool has_simple_parameters();
7001
7002   // [next_function_link]: Links functions into various lists, e.g. the list
7003   // of optimized functions hanging off the native_context. The CodeFlusher
7004   // uses this link to chain together flushing candidates. Treated weakly
7005   // by the garbage collector.
7006   DECL_ACCESSORS(next_function_link, Object)
7007
7008   // Prints the name of the function using PrintF.
7009   void PrintName(FILE* out = stdout);
7010
7011   DECLARE_CAST(JSFunction)
7012
7013   // Iterates the objects, including code objects indirectly referenced
7014   // through pointers to the first instruction in the code object.
7015   void JSFunctionIterateBody(int object_size, ObjectVisitor* v);
7016
7017   // Dispatched behavior.
7018   DECLARE_PRINTER(JSFunction)
7019   DECLARE_VERIFIER(JSFunction)
7020
7021   // Returns the number of allocated literals.
7022   inline int NumberOfLiterals();
7023
7024   // Used for flags such as --hydrogen-filter.
7025   bool PassesFilter(const char* raw_filter);
7026
7027   // The function's name if it is configured, otherwise shared function info
7028   // debug name.
7029   static Handle<String> GetDebugName(Handle<JSFunction> function);
7030
7031   // Layout descriptors. The last property (from kNonWeakFieldsEndOffset to
7032   // kSize) is weak and has special handling during garbage collection.
7033   static const int kCodeEntryOffset = JSObject::kHeaderSize;
7034   static const int kPrototypeOrInitialMapOffset =
7035       kCodeEntryOffset + kPointerSize;
7036   static const int kSharedFunctionInfoOffset =
7037       kPrototypeOrInitialMapOffset + kPointerSize;
7038   static const int kContextOffset = kSharedFunctionInfoOffset + kPointerSize;
7039   static const int kLiteralsOffset = kContextOffset + kPointerSize;
7040   static const int kNonWeakFieldsEndOffset = kLiteralsOffset + kPointerSize;
7041   static const int kNextFunctionLinkOffset = kNonWeakFieldsEndOffset;
7042   static const int kSize = kNextFunctionLinkOffset + kPointerSize;
7043
7044   // Layout of the bound-function binding array.
7045   static const int kBoundFunctionIndex = 0;
7046   static const int kBoundThisIndex = 1;
7047   static const int kBoundArgumentsStartIndex = 2;
7048
7049  private:
7050   DISALLOW_IMPLICIT_CONSTRUCTORS(JSFunction);
7051 };
7052
7053
7054 // JSGlobalProxy's prototype must be a JSGlobalObject or null,
7055 // and the prototype is hidden. JSGlobalProxy always delegates
7056 // property accesses to its prototype if the prototype is not null.
7057 //
7058 // A JSGlobalProxy can be reinitialized which will preserve its identity.
7059 //
7060 // Accessing a JSGlobalProxy requires security check.
7061
7062 class JSGlobalProxy : public JSObject {
7063  public:
7064   // [native_context]: the owner native context of this global proxy object.
7065   // It is null value if this object is not used by any context.
7066   DECL_ACCESSORS(native_context, Object)
7067
7068   // [hash]: The hash code property (undefined if not initialized yet).
7069   DECL_ACCESSORS(hash, Object)
7070
7071   DECLARE_CAST(JSGlobalProxy)
7072
7073   inline bool IsDetachedFrom(GlobalObject* global) const;
7074
7075   // Dispatched behavior.
7076   DECLARE_PRINTER(JSGlobalProxy)
7077   DECLARE_VERIFIER(JSGlobalProxy)
7078
7079   // Layout description.
7080   static const int kNativeContextOffset = JSObject::kHeaderSize;
7081   static const int kHashOffset = kNativeContextOffset + kPointerSize;
7082   static const int kSize = kHashOffset + kPointerSize;
7083
7084  private:
7085   DISALLOW_IMPLICIT_CONSTRUCTORS(JSGlobalProxy);
7086 };
7087
7088
7089 // Common super class for JavaScript global objects and the special
7090 // builtins global objects.
7091 class GlobalObject: public JSObject {
7092  public:
7093   // [builtins]: the object holding the runtime routines written in JS.
7094   DECL_ACCESSORS(builtins, JSBuiltinsObject)
7095
7096   // [native context]: the natives corresponding to this global object.
7097   DECL_ACCESSORS(native_context, Context)
7098
7099   // [global proxy]: the global proxy object of the context
7100   DECL_ACCESSORS(global_proxy, JSObject)
7101
7102   DECLARE_CAST(GlobalObject)
7103
7104   static void InvalidatePropertyCell(Handle<GlobalObject> object,
7105                                      Handle<Name> name);
7106   // Ensure that the global object has a cell for the given property name.
7107   static Handle<PropertyCell> EnsurePropertyCell(Handle<GlobalObject> global,
7108                                                  Handle<Name> name);
7109
7110   // Layout description.
7111   static const int kBuiltinsOffset = JSObject::kHeaderSize;
7112   static const int kNativeContextOffset = kBuiltinsOffset + kPointerSize;
7113   static const int kGlobalProxyOffset = kNativeContextOffset + kPointerSize;
7114   static const int kHeaderSize = kGlobalProxyOffset + kPointerSize;
7115
7116  private:
7117   DISALLOW_IMPLICIT_CONSTRUCTORS(GlobalObject);
7118 };
7119
7120
7121 // JavaScript global object.
7122 class JSGlobalObject: public GlobalObject {
7123  public:
7124   DECLARE_CAST(JSGlobalObject)
7125
7126   inline bool IsDetached();
7127
7128   // Dispatched behavior.
7129   DECLARE_PRINTER(JSGlobalObject)
7130   DECLARE_VERIFIER(JSGlobalObject)
7131
7132   // Layout description.
7133   static const int kSize = GlobalObject::kHeaderSize;
7134
7135  private:
7136   DISALLOW_IMPLICIT_CONSTRUCTORS(JSGlobalObject);
7137 };
7138
7139
7140 // Builtins global object which holds the runtime routines written in
7141 // JavaScript.
7142 class JSBuiltinsObject: public GlobalObject {
7143  public:
7144   // Accessors for the runtime routines written in JavaScript.
7145   inline Object* javascript_builtin(Builtins::JavaScript id);
7146   inline void set_javascript_builtin(Builtins::JavaScript id, Object* value);
7147
7148   DECLARE_CAST(JSBuiltinsObject)
7149
7150   // Dispatched behavior.
7151   DECLARE_PRINTER(JSBuiltinsObject)
7152   DECLARE_VERIFIER(JSBuiltinsObject)
7153
7154   // Layout description.  The size of the builtins object includes
7155   // room for two pointers per runtime routine written in javascript
7156   // (function and code object).
7157   static const int kJSBuiltinsCount = Builtins::id_count;
7158   static const int kJSBuiltinsOffset = GlobalObject::kHeaderSize;
7159   static const int kSize =
7160       GlobalObject::kHeaderSize + (kJSBuiltinsCount * kPointerSize);
7161
7162   static int OffsetOfFunctionWithId(Builtins::JavaScript id) {
7163     return kJSBuiltinsOffset + id * kPointerSize;
7164   }
7165
7166  private:
7167   DISALLOW_IMPLICIT_CONSTRUCTORS(JSBuiltinsObject);
7168 };
7169
7170
7171 // Representation for JS Wrapper objects, String, Number, Boolean, etc.
7172 class JSValue: public JSObject {
7173  public:
7174   // [value]: the object being wrapped.
7175   DECL_ACCESSORS(value, Object)
7176
7177   DECLARE_CAST(JSValue)
7178
7179   // Dispatched behavior.
7180   DECLARE_PRINTER(JSValue)
7181   DECLARE_VERIFIER(JSValue)
7182
7183   // Layout description.
7184   static const int kValueOffset = JSObject::kHeaderSize;
7185   static const int kSize = kValueOffset + kPointerSize;
7186
7187  private:
7188   DISALLOW_IMPLICIT_CONSTRUCTORS(JSValue);
7189 };
7190
7191
7192 class DateCache;
7193
7194 // Representation for JS date objects.
7195 class JSDate: public JSObject {
7196  public:
7197   // If one component is NaN, all of them are, indicating a NaN time value.
7198   // [value]: the time value.
7199   DECL_ACCESSORS(value, Object)
7200   // [year]: caches year. Either undefined, smi, or NaN.
7201   DECL_ACCESSORS(year, Object)
7202   // [month]: caches month. Either undefined, smi, or NaN.
7203   DECL_ACCESSORS(month, Object)
7204   // [day]: caches day. Either undefined, smi, or NaN.
7205   DECL_ACCESSORS(day, Object)
7206   // [weekday]: caches day of week. Either undefined, smi, or NaN.
7207   DECL_ACCESSORS(weekday, Object)
7208   // [hour]: caches hours. Either undefined, smi, or NaN.
7209   DECL_ACCESSORS(hour, Object)
7210   // [min]: caches minutes. Either undefined, smi, or NaN.
7211   DECL_ACCESSORS(min, Object)
7212   // [sec]: caches seconds. Either undefined, smi, or NaN.
7213   DECL_ACCESSORS(sec, Object)
7214   // [cache stamp]: sample of the date cache stamp at the
7215   // moment when chached fields were cached.
7216   DECL_ACCESSORS(cache_stamp, Object)
7217
7218   DECLARE_CAST(JSDate)
7219
7220   // Returns the date field with the specified index.
7221   // See FieldIndex for the list of date fields.
7222   static Object* GetField(Object* date, Smi* index);
7223
7224   void SetValue(Object* value, bool is_value_nan);
7225
7226
7227   // Dispatched behavior.
7228   DECLARE_PRINTER(JSDate)
7229   DECLARE_VERIFIER(JSDate)
7230
7231   // The order is important. It must be kept in sync with date macros
7232   // in macros.py.
7233   enum FieldIndex {
7234     kDateValue,
7235     kYear,
7236     kMonth,
7237     kDay,
7238     kWeekday,
7239     kHour,
7240     kMinute,
7241     kSecond,
7242     kFirstUncachedField,
7243     kMillisecond = kFirstUncachedField,
7244     kDays,
7245     kTimeInDay,
7246     kFirstUTCField,
7247     kYearUTC = kFirstUTCField,
7248     kMonthUTC,
7249     kDayUTC,
7250     kWeekdayUTC,
7251     kHourUTC,
7252     kMinuteUTC,
7253     kSecondUTC,
7254     kMillisecondUTC,
7255     kDaysUTC,
7256     kTimeInDayUTC,
7257     kTimezoneOffset
7258   };
7259
7260   // Layout description.
7261   static const int kValueOffset = JSObject::kHeaderSize;
7262   static const int kYearOffset = kValueOffset + kPointerSize;
7263   static const int kMonthOffset = kYearOffset + kPointerSize;
7264   static const int kDayOffset = kMonthOffset + kPointerSize;
7265   static const int kWeekdayOffset = kDayOffset + kPointerSize;
7266   static const int kHourOffset = kWeekdayOffset  + kPointerSize;
7267   static const int kMinOffset = kHourOffset + kPointerSize;
7268   static const int kSecOffset = kMinOffset + kPointerSize;
7269   static const int kCacheStampOffset = kSecOffset + kPointerSize;
7270   static const int kSize = kCacheStampOffset + kPointerSize;
7271
7272  private:
7273   inline Object* DoGetField(FieldIndex index);
7274
7275   Object* GetUTCField(FieldIndex index, double value, DateCache* date_cache);
7276
7277   // Computes and caches the cacheable fields of the date.
7278   inline void SetCachedFields(int64_t local_time_ms, DateCache* date_cache);
7279
7280
7281   DISALLOW_IMPLICIT_CONSTRUCTORS(JSDate);
7282 };
7283
7284
7285 // Representation of message objects used for error reporting through
7286 // the API. The messages are formatted in JavaScript so this object is
7287 // a real JavaScript object. The information used for formatting the
7288 // error messages are not directly accessible from JavaScript to
7289 // prevent leaking information to user code called during error
7290 // formatting.
7291 class JSMessageObject: public JSObject {
7292  public:
7293   // [type]: the type of error message.
7294   inline int type() const;
7295   inline void set_type(int value);
7296
7297   // [arguments]: the arguments for formatting the error message.
7298   DECL_ACCESSORS(argument, Object)
7299
7300   // [script]: the script from which the error message originated.
7301   DECL_ACCESSORS(script, Object)
7302
7303   // [stack_frames]: an array of stack frames for this error object.
7304   DECL_ACCESSORS(stack_frames, Object)
7305
7306   // [start_position]: the start position in the script for the error message.
7307   inline int start_position() const;
7308   inline void set_start_position(int value);
7309
7310   // [end_position]: the end position in the script for the error message.
7311   inline int end_position() const;
7312   inline void set_end_position(int value);
7313
7314   DECLARE_CAST(JSMessageObject)
7315
7316   // Dispatched behavior.
7317   DECLARE_PRINTER(JSMessageObject)
7318   DECLARE_VERIFIER(JSMessageObject)
7319
7320   // Layout description.
7321   static const int kTypeOffset = JSObject::kHeaderSize;
7322   static const int kArgumentsOffset = kTypeOffset + kPointerSize;
7323   static const int kScriptOffset = kArgumentsOffset + kPointerSize;
7324   static const int kStackFramesOffset = kScriptOffset + kPointerSize;
7325   static const int kStartPositionOffset = kStackFramesOffset + kPointerSize;
7326   static const int kEndPositionOffset = kStartPositionOffset + kPointerSize;
7327   static const int kSize = kEndPositionOffset + kPointerSize;
7328
7329   typedef FixedBodyDescriptor<HeapObject::kMapOffset,
7330                               kStackFramesOffset + kPointerSize,
7331                               kSize> BodyDescriptor;
7332 };
7333
7334
7335 // Regular expressions
7336 // The regular expression holds a single reference to a FixedArray in
7337 // the kDataOffset field.
7338 // The FixedArray contains the following data:
7339 // - tag : type of regexp implementation (not compiled yet, atom or irregexp)
7340 // - reference to the original source string
7341 // - reference to the original flag string
7342 // If it is an atom regexp
7343 // - a reference to a literal string to search for
7344 // If it is an irregexp regexp:
7345 // - a reference to code for Latin1 inputs (bytecode or compiled), or a smi
7346 // used for tracking the last usage (used for code flushing).
7347 // - a reference to code for UC16 inputs (bytecode or compiled), or a smi
7348 // used for tracking the last usage (used for code flushing)..
7349 // - max number of registers used by irregexp implementations.
7350 // - number of capture registers (output values) of the regexp.
7351 class JSRegExp: public JSObject {
7352  public:
7353   // Meaning of Type:
7354   // NOT_COMPILED: Initial value. No data has been stored in the JSRegExp yet.
7355   // ATOM: A simple string to match against using an indexOf operation.
7356   // IRREGEXP: Compiled with Irregexp.
7357   // IRREGEXP_NATIVE: Compiled to native code with Irregexp.
7358   enum Type { NOT_COMPILED, ATOM, IRREGEXP };
7359   enum Flag {
7360     NONE = 0,
7361     GLOBAL = 1,
7362     IGNORE_CASE = 2,
7363     MULTILINE = 4,
7364     STICKY = 8,
7365     UNICODE_ESCAPES = 16
7366   };
7367
7368   class Flags {
7369    public:
7370     explicit Flags(uint32_t value) : value_(value) { }
7371     bool is_global() { return (value_ & GLOBAL) != 0; }
7372     bool is_ignore_case() { return (value_ & IGNORE_CASE) != 0; }
7373     bool is_multiline() { return (value_ & MULTILINE) != 0; }
7374     bool is_sticky() { return (value_ & STICKY) != 0; }
7375     bool is_unicode() { return (value_ & UNICODE_ESCAPES) != 0; }
7376     uint32_t value() { return value_; }
7377    private:
7378     uint32_t value_;
7379   };
7380
7381   DECL_ACCESSORS(data, Object)
7382
7383   inline Type TypeTag();
7384   inline int CaptureCount();
7385   inline Flags GetFlags();
7386   inline String* Pattern();
7387   inline Object* DataAt(int index);
7388   // Set implementation data after the object has been prepared.
7389   inline void SetDataAt(int index, Object* value);
7390
7391   static int code_index(bool is_latin1) {
7392     if (is_latin1) {
7393       return kIrregexpLatin1CodeIndex;
7394     } else {
7395       return kIrregexpUC16CodeIndex;
7396     }
7397   }
7398
7399   static int saved_code_index(bool is_latin1) {
7400     if (is_latin1) {
7401       return kIrregexpLatin1CodeSavedIndex;
7402     } else {
7403       return kIrregexpUC16CodeSavedIndex;
7404     }
7405   }
7406
7407   DECLARE_CAST(JSRegExp)
7408
7409   // Dispatched behavior.
7410   DECLARE_VERIFIER(JSRegExp)
7411
7412   static const int kDataOffset = JSObject::kHeaderSize;
7413   static const int kSize = kDataOffset + kPointerSize;
7414
7415   // Indices in the data array.
7416   static const int kTagIndex = 0;
7417   static const int kSourceIndex = kTagIndex + 1;
7418   static const int kFlagsIndex = kSourceIndex + 1;
7419   static const int kDataIndex = kFlagsIndex + 1;
7420   // The data fields are used in different ways depending on the
7421   // value of the tag.
7422   // Atom regexps (literal strings).
7423   static const int kAtomPatternIndex = kDataIndex;
7424
7425   static const int kAtomDataSize = kAtomPatternIndex + 1;
7426
7427   // Irregexp compiled code or bytecode for Latin1. If compilation
7428   // fails, this fields hold an exception object that should be
7429   // thrown if the regexp is used again.
7430   static const int kIrregexpLatin1CodeIndex = kDataIndex;
7431   // Irregexp compiled code or bytecode for UC16.  If compilation
7432   // fails, this fields hold an exception object that should be
7433   // thrown if the regexp is used again.
7434   static const int kIrregexpUC16CodeIndex = kDataIndex + 1;
7435
7436   // Saved instance of Irregexp compiled code or bytecode for Latin1 that
7437   // is a potential candidate for flushing.
7438   static const int kIrregexpLatin1CodeSavedIndex = kDataIndex + 2;
7439   // Saved instance of Irregexp compiled code or bytecode for UC16 that is
7440   // a potential candidate for flushing.
7441   static const int kIrregexpUC16CodeSavedIndex = kDataIndex + 3;
7442
7443   // Maximal number of registers used by either Latin1 or UC16.
7444   // Only used to check that there is enough stack space
7445   static const int kIrregexpMaxRegisterCountIndex = kDataIndex + 4;
7446   // Number of captures in the compiled regexp.
7447   static const int kIrregexpCaptureCountIndex = kDataIndex + 5;
7448
7449   static const int kIrregexpDataSize = kIrregexpCaptureCountIndex + 1;
7450
7451   // Offsets directly into the data fixed array.
7452   static const int kDataTagOffset =
7453       FixedArray::kHeaderSize + kTagIndex * kPointerSize;
7454   static const int kDataOneByteCodeOffset =
7455       FixedArray::kHeaderSize + kIrregexpLatin1CodeIndex * kPointerSize;
7456   static const int kDataUC16CodeOffset =
7457       FixedArray::kHeaderSize + kIrregexpUC16CodeIndex * kPointerSize;
7458   static const int kIrregexpCaptureCountOffset =
7459       FixedArray::kHeaderSize + kIrregexpCaptureCountIndex * kPointerSize;
7460
7461   // In-object fields.
7462   static const int kSourceFieldIndex = 0;
7463   static const int kGlobalFieldIndex = 1;
7464   static const int kIgnoreCaseFieldIndex = 2;
7465   static const int kMultilineFieldIndex = 3;
7466   static const int kLastIndexFieldIndex = 4;
7467   static const int kInObjectFieldCount = 5;
7468
7469   // The uninitialized value for a regexp code object.
7470   static const int kUninitializedValue = -1;
7471
7472   // The compilation error value for the regexp code object. The real error
7473   // object is in the saved code field.
7474   static const int kCompilationErrorValue = -2;
7475
7476   // When we store the sweep generation at which we moved the code from the
7477   // code index to the saved code index we mask it of to be in the [0:255]
7478   // range.
7479   static const int kCodeAgeMask = 0xff;
7480 };
7481
7482
7483 class CompilationCacheShape : public BaseShape<HashTableKey*> {
7484  public:
7485   static inline bool IsMatch(HashTableKey* key, Object* value) {
7486     return key->IsMatch(value);
7487   }
7488
7489   static inline uint32_t Hash(HashTableKey* key) {
7490     return key->Hash();
7491   }
7492
7493   static inline uint32_t HashForObject(HashTableKey* key, Object* object) {
7494     return key->HashForObject(object);
7495   }
7496
7497   static inline Handle<Object> AsHandle(Isolate* isolate, HashTableKey* key);
7498
7499   static const int kPrefixSize = 0;
7500   static const int kEntrySize = 2;
7501 };
7502
7503
7504 // This cache is used in two different variants. For regexp caching, it simply
7505 // maps identifying info of the regexp to the cached regexp object. Scripts and
7506 // eval code only gets cached after a second probe for the code object. To do
7507 // so, on first "put" only a hash identifying the source is entered into the
7508 // cache, mapping it to a lifetime count of the hash. On each call to Age all
7509 // such lifetimes get reduced, and removed once they reach zero. If a second put
7510 // is called while such a hash is live in the cache, the hash gets replaced by
7511 // an actual cache entry. Age also removes stale live entries from the cache.
7512 // Such entries are identified by SharedFunctionInfos pointing to either the
7513 // recompilation stub, or to "old" code. This avoids memory leaks due to
7514 // premature caching of scripts and eval strings that are never needed later.
7515 class CompilationCacheTable: public HashTable<CompilationCacheTable,
7516                                               CompilationCacheShape,
7517                                               HashTableKey*> {
7518  public:
7519   // Find cached value for a string key, otherwise return null.
7520   Handle<Object> Lookup(
7521       Handle<String> src, Handle<Context> context, LanguageMode language_mode);
7522   Handle<Object> LookupEval(
7523       Handle<String> src, Handle<SharedFunctionInfo> shared,
7524       LanguageMode language_mode, int scope_position);
7525   Handle<Object> LookupRegExp(Handle<String> source, JSRegExp::Flags flags);
7526   static Handle<CompilationCacheTable> Put(
7527       Handle<CompilationCacheTable> cache, Handle<String> src,
7528       Handle<Context> context, LanguageMode language_mode,
7529       Handle<Object> value);
7530   static Handle<CompilationCacheTable> PutEval(
7531       Handle<CompilationCacheTable> cache, Handle<String> src,
7532       Handle<SharedFunctionInfo> context, Handle<SharedFunctionInfo> value,
7533       int scope_position);
7534   static Handle<CompilationCacheTable> PutRegExp(
7535       Handle<CompilationCacheTable> cache, Handle<String> src,
7536       JSRegExp::Flags flags, Handle<FixedArray> value);
7537   void Remove(Object* value);
7538   void Age();
7539   static const int kHashGenerations = 10;
7540
7541   DECLARE_CAST(CompilationCacheTable)
7542
7543  private:
7544   DISALLOW_IMPLICIT_CONSTRUCTORS(CompilationCacheTable);
7545 };
7546
7547
7548 class CodeCache: public Struct {
7549  public:
7550   DECL_ACCESSORS(default_cache, FixedArray)
7551   DECL_ACCESSORS(normal_type_cache, Object)
7552
7553   // Add the code object to the cache.
7554   static void Update(
7555       Handle<CodeCache> cache, Handle<Name> name, Handle<Code> code);
7556
7557   // Lookup code object in the cache. Returns code object if found and undefined
7558   // if not.
7559   Object* Lookup(Name* name, Code::Flags flags);
7560
7561   // Get the internal index of a code object in the cache. Returns -1 if the
7562   // code object is not in that cache. This index can be used to later call
7563   // RemoveByIndex. The cache cannot be modified between a call to GetIndex and
7564   // RemoveByIndex.
7565   int GetIndex(Object* name, Code* code);
7566
7567   // Remove an object from the cache with the provided internal index.
7568   void RemoveByIndex(Object* name, Code* code, int index);
7569
7570   DECLARE_CAST(CodeCache)
7571
7572   // Dispatched behavior.
7573   DECLARE_PRINTER(CodeCache)
7574   DECLARE_VERIFIER(CodeCache)
7575
7576   static const int kDefaultCacheOffset = HeapObject::kHeaderSize;
7577   static const int kNormalTypeCacheOffset =
7578       kDefaultCacheOffset + kPointerSize;
7579   static const int kSize = kNormalTypeCacheOffset + kPointerSize;
7580
7581  private:
7582   static void UpdateDefaultCache(
7583       Handle<CodeCache> code_cache, Handle<Name> name, Handle<Code> code);
7584   static void UpdateNormalTypeCache(
7585       Handle<CodeCache> code_cache, Handle<Name> name, Handle<Code> code);
7586   Object* LookupDefaultCache(Name* name, Code::Flags flags);
7587   Object* LookupNormalTypeCache(Name* name, Code::Flags flags);
7588
7589   // Code cache layout of the default cache. Elements are alternating name and
7590   // code objects for non normal load/store/call IC's.
7591   static const int kCodeCacheEntrySize = 2;
7592   static const int kCodeCacheEntryNameOffset = 0;
7593   static const int kCodeCacheEntryCodeOffset = 1;
7594
7595   DISALLOW_IMPLICIT_CONSTRUCTORS(CodeCache);
7596 };
7597
7598
7599 class CodeCacheHashTableShape : public BaseShape<HashTableKey*> {
7600  public:
7601   static inline bool IsMatch(HashTableKey* key, Object* value) {
7602     return key->IsMatch(value);
7603   }
7604
7605   static inline uint32_t Hash(HashTableKey* key) {
7606     return key->Hash();
7607   }
7608
7609   static inline uint32_t HashForObject(HashTableKey* key, Object* object) {
7610     return key->HashForObject(object);
7611   }
7612
7613   static inline Handle<Object> AsHandle(Isolate* isolate, HashTableKey* key);
7614
7615   static const int kPrefixSize = 0;
7616   static const int kEntrySize = 2;
7617 };
7618
7619
7620 class CodeCacheHashTable: public HashTable<CodeCacheHashTable,
7621                                            CodeCacheHashTableShape,
7622                                            HashTableKey*> {
7623  public:
7624   Object* Lookup(Name* name, Code::Flags flags);
7625   static Handle<CodeCacheHashTable> Put(
7626       Handle<CodeCacheHashTable> table,
7627       Handle<Name> name,
7628       Handle<Code> code);
7629
7630   int GetIndex(Name* name, Code::Flags flags);
7631   void RemoveByIndex(int index);
7632
7633   DECLARE_CAST(CodeCacheHashTable)
7634
7635   // Initial size of the fixed array backing the hash table.
7636   static const int kInitialSize = 64;
7637
7638  private:
7639   DISALLOW_IMPLICIT_CONSTRUCTORS(CodeCacheHashTable);
7640 };
7641
7642
7643 class PolymorphicCodeCache: public Struct {
7644  public:
7645   DECL_ACCESSORS(cache, Object)
7646
7647   static void Update(Handle<PolymorphicCodeCache> cache,
7648                      MapHandleList* maps,
7649                      Code::Flags flags,
7650                      Handle<Code> code);
7651
7652
7653   // Returns an undefined value if the entry is not found.
7654   Handle<Object> Lookup(MapHandleList* maps, Code::Flags flags);
7655
7656   DECLARE_CAST(PolymorphicCodeCache)
7657
7658   // Dispatched behavior.
7659   DECLARE_PRINTER(PolymorphicCodeCache)
7660   DECLARE_VERIFIER(PolymorphicCodeCache)
7661
7662   static const int kCacheOffset = HeapObject::kHeaderSize;
7663   static const int kSize = kCacheOffset + kPointerSize;
7664
7665  private:
7666   DISALLOW_IMPLICIT_CONSTRUCTORS(PolymorphicCodeCache);
7667 };
7668
7669
7670 class PolymorphicCodeCacheHashTable
7671     : public HashTable<PolymorphicCodeCacheHashTable,
7672                        CodeCacheHashTableShape,
7673                        HashTableKey*> {
7674  public:
7675   Object* Lookup(MapHandleList* maps, int code_kind);
7676
7677   static Handle<PolymorphicCodeCacheHashTable> Put(
7678       Handle<PolymorphicCodeCacheHashTable> hash_table,
7679       MapHandleList* maps,
7680       int code_kind,
7681       Handle<Code> code);
7682
7683   DECLARE_CAST(PolymorphicCodeCacheHashTable)
7684
7685   static const int kInitialSize = 64;
7686  private:
7687   DISALLOW_IMPLICIT_CONSTRUCTORS(PolymorphicCodeCacheHashTable);
7688 };
7689
7690
7691 class TypeFeedbackInfo: public Struct {
7692  public:
7693   inline int ic_total_count();
7694   inline void set_ic_total_count(int count);
7695
7696   inline int ic_with_type_info_count();
7697   inline void change_ic_with_type_info_count(int delta);
7698
7699   inline int ic_generic_count();
7700   inline void change_ic_generic_count(int delta);
7701
7702   inline void initialize_storage();
7703
7704   inline void change_own_type_change_checksum();
7705   inline int own_type_change_checksum();
7706
7707   inline void set_inlined_type_change_checksum(int checksum);
7708   inline bool matches_inlined_type_change_checksum(int checksum);
7709
7710   DECLARE_CAST(TypeFeedbackInfo)
7711
7712   // Dispatched behavior.
7713   DECLARE_PRINTER(TypeFeedbackInfo)
7714   DECLARE_VERIFIER(TypeFeedbackInfo)
7715
7716   static const int kStorage1Offset = HeapObject::kHeaderSize;
7717   static const int kStorage2Offset = kStorage1Offset + kPointerSize;
7718   static const int kStorage3Offset = kStorage2Offset + kPointerSize;
7719   static const int kSize = kStorage3Offset + kPointerSize;
7720
7721  private:
7722   static const int kTypeChangeChecksumBits = 7;
7723
7724   class ICTotalCountField: public BitField<int, 0,
7725       kSmiValueSize - kTypeChangeChecksumBits> {};  // NOLINT
7726   class OwnTypeChangeChecksum: public BitField<int,
7727       kSmiValueSize - kTypeChangeChecksumBits,
7728       kTypeChangeChecksumBits> {};  // NOLINT
7729   class ICsWithTypeInfoCountField: public BitField<int, 0,
7730       kSmiValueSize - kTypeChangeChecksumBits> {};  // NOLINT
7731   class InlinedTypeChangeChecksum: public BitField<int,
7732       kSmiValueSize - kTypeChangeChecksumBits,
7733       kTypeChangeChecksumBits> {};  // NOLINT
7734
7735   DISALLOW_IMPLICIT_CONSTRUCTORS(TypeFeedbackInfo);
7736 };
7737
7738
7739 enum AllocationSiteMode {
7740   DONT_TRACK_ALLOCATION_SITE,
7741   TRACK_ALLOCATION_SITE,
7742   LAST_ALLOCATION_SITE_MODE = TRACK_ALLOCATION_SITE
7743 };
7744
7745
7746 class AllocationSite: public Struct {
7747  public:
7748   static const uint32_t kMaximumArrayBytesToPretransition = 8 * 1024;
7749   static const double kPretenureRatio;
7750   static const int kPretenureMinimumCreated = 100;
7751
7752   // Values for pretenure decision field.
7753   enum PretenureDecision {
7754     kUndecided = 0,
7755     kDontTenure = 1,
7756     kMaybeTenure = 2,
7757     kTenure = 3,
7758     kZombie = 4,
7759     kLastPretenureDecisionValue = kZombie
7760   };
7761
7762   const char* PretenureDecisionName(PretenureDecision decision);
7763
7764   DECL_ACCESSORS(transition_info, Object)
7765   // nested_site threads a list of sites that represent nested literals
7766   // walked in a particular order. So [[1, 2], 1, 2] will have one
7767   // nested_site, but [[1, 2], 3, [4]] will have a list of two.
7768   DECL_ACCESSORS(nested_site, Object)
7769   DECL_ACCESSORS(pretenure_data, Smi)
7770   DECL_ACCESSORS(pretenure_create_count, Smi)
7771   DECL_ACCESSORS(dependent_code, DependentCode)
7772   DECL_ACCESSORS(weak_next, Object)
7773
7774   inline void Initialize();
7775
7776   // This method is expensive, it should only be called for reporting.
7777   bool IsNestedSite();
7778
7779   // transition_info bitfields, for constructed array transition info.
7780   class ElementsKindBits:       public BitField<ElementsKind, 0,  15> {};
7781   class UnusedBits:             public BitField<int,          15, 14> {};
7782   class DoNotInlineBit:         public BitField<bool,         29,  1> {};
7783
7784   // Bitfields for pretenure_data
7785   class MementoFoundCountBits:  public BitField<int,               0, 26> {};
7786   class PretenureDecisionBits:  public BitField<PretenureDecision, 26, 3> {};
7787   class DeoptDependentCodeBit:  public BitField<bool,              29, 1> {};
7788   STATIC_ASSERT(PretenureDecisionBits::kMax >= kLastPretenureDecisionValue);
7789
7790   // Increments the mementos found counter and returns true when the first
7791   // memento was found for a given allocation site.
7792   inline bool IncrementMementoFoundCount();
7793
7794   inline void IncrementMementoCreateCount();
7795
7796   PretenureFlag GetPretenureMode();
7797
7798   void ResetPretenureDecision();
7799
7800   inline PretenureDecision pretenure_decision();
7801   inline void set_pretenure_decision(PretenureDecision decision);
7802
7803   inline bool deopt_dependent_code();
7804   inline void set_deopt_dependent_code(bool deopt);
7805
7806   inline int memento_found_count();
7807   inline void set_memento_found_count(int count);
7808
7809   inline int memento_create_count();
7810   inline void set_memento_create_count(int count);
7811
7812   // The pretenuring decision is made during gc, and the zombie state allows
7813   // us to recognize when an allocation site is just being kept alive because
7814   // a later traversal of new space may discover AllocationMementos that point
7815   // to this AllocationSite.
7816   inline bool IsZombie();
7817
7818   inline bool IsMaybeTenure();
7819
7820   inline void MarkZombie();
7821
7822   inline bool MakePretenureDecision(PretenureDecision current_decision,
7823                                     double ratio,
7824                                     bool maximum_size_scavenge);
7825
7826   inline bool DigestPretenuringFeedback(bool maximum_size_scavenge);
7827
7828   inline ElementsKind GetElementsKind();
7829   inline void SetElementsKind(ElementsKind kind);
7830
7831   inline bool CanInlineCall();
7832   inline void SetDoNotInlineCall();
7833
7834   inline bool SitePointsToLiteral();
7835
7836   static void DigestTransitionFeedback(Handle<AllocationSite> site,
7837                                        ElementsKind to_kind);
7838
7839   DECLARE_PRINTER(AllocationSite)
7840   DECLARE_VERIFIER(AllocationSite)
7841
7842   DECLARE_CAST(AllocationSite)
7843   static inline AllocationSiteMode GetMode(
7844       ElementsKind boilerplate_elements_kind);
7845   static inline AllocationSiteMode GetMode(ElementsKind from, ElementsKind to);
7846   static inline bool CanTrack(InstanceType type);
7847
7848   static const int kTransitionInfoOffset = HeapObject::kHeaderSize;
7849   static const int kNestedSiteOffset = kTransitionInfoOffset + kPointerSize;
7850   static const int kPretenureDataOffset = kNestedSiteOffset + kPointerSize;
7851   static const int kPretenureCreateCountOffset =
7852       kPretenureDataOffset + kPointerSize;
7853   static const int kDependentCodeOffset =
7854       kPretenureCreateCountOffset + kPointerSize;
7855   static const int kWeakNextOffset = kDependentCodeOffset + kPointerSize;
7856   static const int kSize = kWeakNextOffset + kPointerSize;
7857
7858   // During mark compact we need to take special care for the dependent code
7859   // field.
7860   static const int kPointerFieldsBeginOffset = kTransitionInfoOffset;
7861   static const int kPointerFieldsEndOffset = kWeakNextOffset;
7862
7863   // For other visitors, use the fixed body descriptor below.
7864   typedef FixedBodyDescriptor<HeapObject::kHeaderSize,
7865                               kDependentCodeOffset + kPointerSize,
7866                               kSize> BodyDescriptor;
7867
7868  private:
7869   inline bool PretenuringDecisionMade();
7870
7871   DISALLOW_IMPLICIT_CONSTRUCTORS(AllocationSite);
7872 };
7873
7874
7875 class AllocationMemento: public Struct {
7876  public:
7877   static const int kAllocationSiteOffset = HeapObject::kHeaderSize;
7878   static const int kSize = kAllocationSiteOffset + kPointerSize;
7879
7880   DECL_ACCESSORS(allocation_site, Object)
7881
7882   inline bool IsValid();
7883   inline AllocationSite* GetAllocationSite();
7884
7885   DECLARE_PRINTER(AllocationMemento)
7886   DECLARE_VERIFIER(AllocationMemento)
7887
7888   DECLARE_CAST(AllocationMemento)
7889
7890  private:
7891   DISALLOW_IMPLICIT_CONSTRUCTORS(AllocationMemento);
7892 };
7893
7894
7895 // Representation of a slow alias as part of a sloppy arguments objects.
7896 // For fast aliases (if HasSloppyArgumentsElements()):
7897 // - the parameter map contains an index into the context
7898 // - all attributes of the element have default values
7899 // For slow aliases (if HasDictionaryArgumentsElements()):
7900 // - the parameter map contains no fast alias mapping (i.e. the hole)
7901 // - this struct (in the slow backing store) contains an index into the context
7902 // - all attributes are available as part if the property details
7903 class AliasedArgumentsEntry: public Struct {
7904  public:
7905   inline int aliased_context_slot() const;
7906   inline void set_aliased_context_slot(int count);
7907
7908   DECLARE_CAST(AliasedArgumentsEntry)
7909
7910   // Dispatched behavior.
7911   DECLARE_PRINTER(AliasedArgumentsEntry)
7912   DECLARE_VERIFIER(AliasedArgumentsEntry)
7913
7914   static const int kAliasedContextSlot = HeapObject::kHeaderSize;
7915   static const int kSize = kAliasedContextSlot + kPointerSize;
7916
7917  private:
7918   DISALLOW_IMPLICIT_CONSTRUCTORS(AliasedArgumentsEntry);
7919 };
7920
7921
7922 enum AllowNullsFlag {ALLOW_NULLS, DISALLOW_NULLS};
7923 enum RobustnessFlag {ROBUST_STRING_TRAVERSAL, FAST_STRING_TRAVERSAL};
7924
7925
7926 class StringHasher {
7927  public:
7928   explicit inline StringHasher(int length, uint32_t seed);
7929
7930   template <typename schar>
7931   static inline uint32_t HashSequentialString(const schar* chars,
7932                                               int length,
7933                                               uint32_t seed);
7934
7935   // Reads all the data, even for long strings and computes the utf16 length.
7936   static uint32_t ComputeUtf8Hash(Vector<const char> chars,
7937                                   uint32_t seed,
7938                                   int* utf16_length_out);
7939
7940   // Calculated hash value for a string consisting of 1 to
7941   // String::kMaxArrayIndexSize digits with no leading zeros (except "0").
7942   // value is represented decimal value.
7943   static uint32_t MakeArrayIndexHash(uint32_t value, int length);
7944
7945   // No string is allowed to have a hash of zero.  That value is reserved
7946   // for internal properties.  If the hash calculation yields zero then we
7947   // use 27 instead.
7948   static const int kZeroHash = 27;
7949
7950   // Reusable parts of the hashing algorithm.
7951   INLINE(static uint32_t AddCharacterCore(uint32_t running_hash, uint16_t c));
7952   INLINE(static uint32_t GetHashCore(uint32_t running_hash));
7953   INLINE(static uint32_t ComputeRunningHash(uint32_t running_hash,
7954                                             const uc16* chars, int length));
7955   INLINE(static uint32_t ComputeRunningHashOneByte(uint32_t running_hash,
7956                                                    const char* chars,
7957                                                    int length));
7958
7959  protected:
7960   // Returns the value to store in the hash field of a string with
7961   // the given length and contents.
7962   uint32_t GetHashField();
7963   // Returns true if the hash of this string can be computed without
7964   // looking at the contents.
7965   inline bool has_trivial_hash();
7966   // Adds a block of characters to the hash.
7967   template<typename Char>
7968   inline void AddCharacters(const Char* chars, int len);
7969
7970  private:
7971   // Add a character to the hash.
7972   inline void AddCharacter(uint16_t c);
7973   // Update index. Returns true if string is still an index.
7974   inline bool UpdateIndex(uint16_t c);
7975
7976   int length_;
7977   uint32_t raw_running_hash_;
7978   uint32_t array_index_;
7979   bool is_array_index_;
7980   bool is_first_char_;
7981   DISALLOW_COPY_AND_ASSIGN(StringHasher);
7982 };
7983
7984
7985 class IteratingStringHasher : public StringHasher {
7986  public:
7987   static inline uint32_t Hash(String* string, uint32_t seed);
7988   inline void VisitOneByteString(const uint8_t* chars, int length);
7989   inline void VisitTwoByteString(const uint16_t* chars, int length);
7990
7991  private:
7992   inline IteratingStringHasher(int len, uint32_t seed);
7993   void VisitConsString(ConsString* cons_string);
7994   DISALLOW_COPY_AND_ASSIGN(IteratingStringHasher);
7995 };
7996
7997
7998 // The characteristics of a string are stored in its map.  Retrieving these
7999 // few bits of information is moderately expensive, involving two memory
8000 // loads where the second is dependent on the first.  To improve efficiency
8001 // the shape of the string is given its own class so that it can be retrieved
8002 // once and used for several string operations.  A StringShape is small enough
8003 // to be passed by value and is immutable, but be aware that flattening a
8004 // string can potentially alter its shape.  Also be aware that a GC caused by
8005 // something else can alter the shape of a string due to ConsString
8006 // shortcutting.  Keeping these restrictions in mind has proven to be error-
8007 // prone and so we no longer put StringShapes in variables unless there is a
8008 // concrete performance benefit at that particular point in the code.
8009 class StringShape BASE_EMBEDDED {
8010  public:
8011   inline explicit StringShape(const String* s);
8012   inline explicit StringShape(Map* s);
8013   inline explicit StringShape(InstanceType t);
8014   inline bool IsSequential();
8015   inline bool IsExternal();
8016   inline bool IsCons();
8017   inline bool IsSliced();
8018   inline bool IsIndirect();
8019   inline bool IsExternalOneByte();
8020   inline bool IsExternalTwoByte();
8021   inline bool IsSequentialOneByte();
8022   inline bool IsSequentialTwoByte();
8023   inline bool IsInternalized();
8024   inline StringRepresentationTag representation_tag();
8025   inline uint32_t encoding_tag();
8026   inline uint32_t full_representation_tag();
8027   inline uint32_t size_tag();
8028 #ifdef DEBUG
8029   inline uint32_t type() { return type_; }
8030   inline void invalidate() { valid_ = false; }
8031   inline bool valid() { return valid_; }
8032 #else
8033   inline void invalidate() { }
8034 #endif
8035
8036  private:
8037   uint32_t type_;
8038 #ifdef DEBUG
8039   inline void set_valid() { valid_ = true; }
8040   bool valid_;
8041 #else
8042   inline void set_valid() { }
8043 #endif
8044 };
8045
8046
8047 // The Name abstract class captures anything that can be used as a property
8048 // name, i.e., strings and symbols.  All names store a hash value.
8049 class Name: public HeapObject {
8050  public:
8051   // Get and set the hash field of the name.
8052   inline uint32_t hash_field();
8053   inline void set_hash_field(uint32_t value);
8054
8055   // Tells whether the hash code has been computed.
8056   inline bool HasHashCode();
8057
8058   // Returns a hash value used for the property table
8059   inline uint32_t Hash();
8060
8061   // Equality operations.
8062   inline bool Equals(Name* other);
8063   inline static bool Equals(Handle<Name> one, Handle<Name> two);
8064
8065   // Conversion.
8066   inline bool AsArrayIndex(uint32_t* index);
8067
8068   // If the name is private, it can only name own properties.
8069   inline bool IsPrivate();
8070
8071   // If the name is a non-flat string, this method returns a flat version of the
8072   // string. Otherwise it'll just return the input.
8073   static inline Handle<Name> Flatten(Handle<Name> name,
8074                                      PretenureFlag pretenure = NOT_TENURED);
8075
8076   DECLARE_CAST(Name)
8077
8078   DECLARE_PRINTER(Name)
8079 #if TRACE_MAPS
8080   void NameShortPrint();
8081   int NameShortPrint(Vector<char> str);
8082 #endif
8083
8084   // Layout description.
8085   static const int kHashFieldSlot = HeapObject::kHeaderSize;
8086 #if V8_TARGET_LITTLE_ENDIAN || !V8_HOST_ARCH_64_BIT
8087   static const int kHashFieldOffset = kHashFieldSlot;
8088 #else
8089   static const int kHashFieldOffset = kHashFieldSlot + kIntSize;
8090 #endif
8091   static const int kSize = kHashFieldSlot + kPointerSize;
8092
8093   // Mask constant for checking if a name has a computed hash code
8094   // and if it is a string that is an array index.  The least significant bit
8095   // indicates whether a hash code has been computed.  If the hash code has
8096   // been computed the 2nd bit tells whether the string can be used as an
8097   // array index.
8098   static const int kHashNotComputedMask = 1;
8099   static const int kIsNotArrayIndexMask = 1 << 1;
8100   static const int kNofHashBitFields = 2;
8101
8102   // Shift constant retrieving hash code from hash field.
8103   static const int kHashShift = kNofHashBitFields;
8104
8105   // Only these bits are relevant in the hash, since the top two are shifted
8106   // out.
8107   static const uint32_t kHashBitMask = 0xffffffffu >> kHashShift;
8108
8109   // Array index strings this short can keep their index in the hash field.
8110   static const int kMaxCachedArrayIndexLength = 7;
8111
8112   // For strings which are array indexes the hash value has the string length
8113   // mixed into the hash, mainly to avoid a hash value of zero which would be
8114   // the case for the string '0'. 24 bits are used for the array index value.
8115   static const int kArrayIndexValueBits = 24;
8116   static const int kArrayIndexLengthBits =
8117       kBitsPerInt - kArrayIndexValueBits - kNofHashBitFields;
8118
8119   STATIC_ASSERT((kArrayIndexLengthBits > 0));
8120
8121   class ArrayIndexValueBits : public BitField<unsigned int, kNofHashBitFields,
8122       kArrayIndexValueBits> {};  // NOLINT
8123   class ArrayIndexLengthBits : public BitField<unsigned int,
8124       kNofHashBitFields + kArrayIndexValueBits,
8125       kArrayIndexLengthBits> {};  // NOLINT
8126
8127   // Check that kMaxCachedArrayIndexLength + 1 is a power of two so we
8128   // could use a mask to test if the length of string is less than or equal to
8129   // kMaxCachedArrayIndexLength.
8130   STATIC_ASSERT(IS_POWER_OF_TWO(kMaxCachedArrayIndexLength + 1));
8131
8132   static const unsigned int kContainsCachedArrayIndexMask =
8133       (~static_cast<unsigned>(kMaxCachedArrayIndexLength)
8134        << ArrayIndexLengthBits::kShift) |
8135       kIsNotArrayIndexMask;
8136
8137   // Value of empty hash field indicating that the hash is not computed.
8138   static const int kEmptyHashField =
8139       kIsNotArrayIndexMask | kHashNotComputedMask;
8140
8141  protected:
8142   static inline bool IsHashFieldComputed(uint32_t field);
8143
8144  private:
8145   DISALLOW_IMPLICIT_CONSTRUCTORS(Name);
8146 };
8147
8148
8149 // ES6 symbols.
8150 class Symbol: public Name {
8151  public:
8152   // [name]: The print name of a symbol, or undefined if none.
8153   DECL_ACCESSORS(name, Object)
8154
8155   DECL_ACCESSORS(flags, Smi)
8156
8157   // [is_private]: Whether this is a private symbol.  Private symbols can only
8158   // be used to designate own properties of objects.
8159   DECL_BOOLEAN_ACCESSORS(is_private)
8160
8161   DECLARE_CAST(Symbol)
8162
8163   // Dispatched behavior.
8164   DECLARE_PRINTER(Symbol)
8165   DECLARE_VERIFIER(Symbol)
8166
8167   // Layout description.
8168   static const int kNameOffset = Name::kSize;
8169   static const int kFlagsOffset = kNameOffset + kPointerSize;
8170   static const int kSize = kFlagsOffset + kPointerSize;
8171
8172   typedef FixedBodyDescriptor<kNameOffset, kFlagsOffset, kSize> BodyDescriptor;
8173
8174   void SymbolShortPrint(std::ostream& os);
8175
8176  private:
8177   static const int kPrivateBit = 0;
8178
8179   const char* PrivateSymbolToName() const;
8180
8181 #if TRACE_MAPS
8182   friend class Name;  // For PrivateSymbolToName.
8183 #endif
8184
8185   DISALLOW_IMPLICIT_CONSTRUCTORS(Symbol);
8186 };
8187
8188
8189 class ConsString;
8190
8191 // The String abstract class captures JavaScript string values:
8192 //
8193 // Ecma-262:
8194 //  4.3.16 String Value
8195 //    A string value is a member of the type String and is a finite
8196 //    ordered sequence of zero or more 16-bit unsigned integer values.
8197 //
8198 // All string values have a length field.
8199 class String: public Name {
8200  public:
8201   enum Encoding { ONE_BYTE_ENCODING, TWO_BYTE_ENCODING };
8202
8203   // Array index strings this short can keep their index in the hash field.
8204   static const int kMaxCachedArrayIndexLength = 7;
8205
8206   // For strings which are array indexes the hash value has the string length
8207   // mixed into the hash, mainly to avoid a hash value of zero which would be
8208   // the case for the string '0'. 24 bits are used for the array index value.
8209   static const int kArrayIndexValueBits = 24;
8210   static const int kArrayIndexLengthBits =
8211       kBitsPerInt - kArrayIndexValueBits - kNofHashBitFields;
8212
8213   STATIC_ASSERT((kArrayIndexLengthBits > 0));
8214
8215   class ArrayIndexValueBits : public BitField<unsigned int, kNofHashBitFields,
8216       kArrayIndexValueBits> {};  // NOLINT
8217   class ArrayIndexLengthBits : public BitField<unsigned int,
8218       kNofHashBitFields + kArrayIndexValueBits,
8219       kArrayIndexLengthBits> {};  // NOLINT
8220
8221   // Check that kMaxCachedArrayIndexLength + 1 is a power of two so we
8222   // could use a mask to test if the length of string is less than or equal to
8223   // kMaxCachedArrayIndexLength.
8224   STATIC_ASSERT(IS_POWER_OF_TWO(kMaxCachedArrayIndexLength + 1));
8225
8226   static const unsigned int kContainsCachedArrayIndexMask =
8227       (~static_cast<unsigned>(kMaxCachedArrayIndexLength)
8228        << ArrayIndexLengthBits::kShift) |
8229       kIsNotArrayIndexMask;
8230
8231   class SubStringRange {
8232    public:
8233     explicit inline SubStringRange(String* string, int first = 0,
8234                                    int length = -1);
8235     class iterator;
8236     inline iterator begin();
8237     inline iterator end();
8238
8239    private:
8240     String* string_;
8241     int first_;
8242     int length_;
8243   };
8244
8245   // Representation of the flat content of a String.
8246   // A non-flat string doesn't have flat content.
8247   // A flat string has content that's encoded as a sequence of either
8248   // one-byte chars or two-byte UC16.
8249   // Returned by String::GetFlatContent().
8250   class FlatContent {
8251    public:
8252     // Returns true if the string is flat and this structure contains content.
8253     bool IsFlat() { return state_ != NON_FLAT; }
8254     // Returns true if the structure contains one-byte content.
8255     bool IsOneByte() { return state_ == ONE_BYTE; }
8256     // Returns true if the structure contains two-byte content.
8257     bool IsTwoByte() { return state_ == TWO_BYTE; }
8258
8259     // Return the one byte content of the string. Only use if IsOneByte()
8260     // returns true.
8261     Vector<const uint8_t> ToOneByteVector() {
8262       DCHECK_EQ(ONE_BYTE, state_);
8263       return Vector<const uint8_t>(onebyte_start, length_);
8264     }
8265     // Return the two-byte content of the string. Only use if IsTwoByte()
8266     // returns true.
8267     Vector<const uc16> ToUC16Vector() {
8268       DCHECK_EQ(TWO_BYTE, state_);
8269       return Vector<const uc16>(twobyte_start, length_);
8270     }
8271
8272     uc16 Get(int i) {
8273       DCHECK(i < length_);
8274       DCHECK(state_ != NON_FLAT);
8275       if (state_ == ONE_BYTE) return onebyte_start[i];
8276       return twobyte_start[i];
8277     }
8278
8279     bool UsesSameString(const FlatContent& other) const {
8280       return onebyte_start == other.onebyte_start;
8281     }
8282
8283    private:
8284     enum State { NON_FLAT, ONE_BYTE, TWO_BYTE };
8285
8286     // Constructors only used by String::GetFlatContent().
8287     explicit FlatContent(const uint8_t* start, int length)
8288         : onebyte_start(start), length_(length), state_(ONE_BYTE) {}
8289     explicit FlatContent(const uc16* start, int length)
8290         : twobyte_start(start), length_(length), state_(TWO_BYTE) { }
8291     FlatContent() : onebyte_start(NULL), length_(0), state_(NON_FLAT) { }
8292
8293     union {
8294       const uint8_t* onebyte_start;
8295       const uc16* twobyte_start;
8296     };
8297     int length_;
8298     State state_;
8299
8300     friend class String;
8301     friend class IterableSubString;
8302   };
8303
8304   template <typename Char>
8305   INLINE(Vector<const Char> GetCharVector());
8306
8307   // Get and set the length of the string.
8308   inline int length() const;
8309   inline void set_length(int value);
8310
8311   // Get and set the length of the string using acquire loads and release
8312   // stores.
8313   inline int synchronized_length() const;
8314   inline void synchronized_set_length(int value);
8315
8316   // Returns whether this string has only one-byte chars, i.e. all of them can
8317   // be one-byte encoded.  This might be the case even if the string is
8318   // two-byte.  Such strings may appear when the embedder prefers
8319   // two-byte external representations even for one-byte data.
8320   inline bool IsOneByteRepresentation() const;
8321   inline bool IsTwoByteRepresentation() const;
8322
8323   // Cons and slices have an encoding flag that may not represent the actual
8324   // encoding of the underlying string.  This is taken into account here.
8325   // Requires: this->IsFlat()
8326   inline bool IsOneByteRepresentationUnderneath();
8327   inline bool IsTwoByteRepresentationUnderneath();
8328
8329   // NOTE: this should be considered only a hint.  False negatives are
8330   // possible.
8331   inline bool HasOnlyOneByteChars();
8332
8333   // Get and set individual two byte chars in the string.
8334   inline void Set(int index, uint16_t value);
8335   // Get individual two byte char in the string.  Repeated calls
8336   // to this method are not efficient unless the string is flat.
8337   INLINE(uint16_t Get(int index));
8338
8339   // Flattens the string.  Checks first inline to see if it is
8340   // necessary.  Does nothing if the string is not a cons string.
8341   // Flattening allocates a sequential string with the same data as
8342   // the given string and mutates the cons string to a degenerate
8343   // form, where the first component is the new sequential string and
8344   // the second component is the empty string.  If allocation fails,
8345   // this function returns a failure.  If flattening succeeds, this
8346   // function returns the sequential string that is now the first
8347   // component of the cons string.
8348   //
8349   // Degenerate cons strings are handled specially by the garbage
8350   // collector (see IsShortcutCandidate).
8351
8352   static inline Handle<String> Flatten(Handle<String> string,
8353                                        PretenureFlag pretenure = NOT_TENURED);
8354
8355   // Tries to return the content of a flat string as a structure holding either
8356   // a flat vector of char or of uc16.
8357   // If the string isn't flat, and therefore doesn't have flat content, the
8358   // returned structure will report so, and can't provide a vector of either
8359   // kind.
8360   FlatContent GetFlatContent();
8361
8362   // Returns the parent of a sliced string or first part of a flat cons string.
8363   // Requires: StringShape(this).IsIndirect() && this->IsFlat()
8364   inline String* GetUnderlying();
8365
8366   // String equality operations.
8367   inline bool Equals(String* other);
8368   inline static bool Equals(Handle<String> one, Handle<String> two);
8369   bool IsUtf8EqualTo(Vector<const char> str, bool allow_prefix_match = false);
8370   bool IsOneByteEqualTo(Vector<const uint8_t> str);
8371   bool IsTwoByteEqualTo(Vector<const uc16> str);
8372
8373   // Return a UTF8 representation of the string.  The string is null
8374   // terminated but may optionally contain nulls.  Length is returned
8375   // in length_output if length_output is not a null pointer  The string
8376   // should be nearly flat, otherwise the performance of this method may
8377   // be very slow (quadratic in the length).  Setting robustness_flag to
8378   // ROBUST_STRING_TRAVERSAL invokes behaviour that is robust  This means it
8379   // handles unexpected data without causing assert failures and it does not
8380   // do any heap allocations.  This is useful when printing stack traces.
8381   base::SmartArrayPointer<char> ToCString(AllowNullsFlag allow_nulls,
8382                                           RobustnessFlag robustness_flag,
8383                                           int offset, int length,
8384                                           int* length_output = 0);
8385   base::SmartArrayPointer<char> ToCString(
8386       AllowNullsFlag allow_nulls = DISALLOW_NULLS,
8387       RobustnessFlag robustness_flag = FAST_STRING_TRAVERSAL,
8388       int* length_output = 0);
8389
8390   // Return a 16 bit Unicode representation of the string.
8391   // The string should be nearly flat, otherwise the performance of
8392   // of this method may be very bad.  Setting robustness_flag to
8393   // ROBUST_STRING_TRAVERSAL invokes behaviour that is robust  This means it
8394   // handles unexpected data without causing assert failures and it does not
8395   // do any heap allocations.  This is useful when printing stack traces.
8396   base::SmartArrayPointer<uc16> ToWideCString(
8397       RobustnessFlag robustness_flag = FAST_STRING_TRAVERSAL);
8398
8399   bool ComputeArrayIndex(uint32_t* index);
8400
8401   // Externalization.
8402   bool MakeExternal(v8::String::ExternalStringResource* resource);
8403   bool MakeExternal(v8::String::ExternalOneByteStringResource* resource);
8404
8405   // Conversion.
8406   inline bool AsArrayIndex(uint32_t* index);
8407
8408   DECLARE_CAST(String)
8409
8410   void PrintOn(FILE* out);
8411
8412   // For use during stack traces.  Performs rudimentary sanity check.
8413   bool LooksValid();
8414
8415   // Dispatched behavior.
8416   void StringShortPrint(StringStream* accumulator);
8417   void PrintUC16(std::ostream& os, int start = 0, int end = -1);  // NOLINT
8418 #if defined(DEBUG) || defined(OBJECT_PRINT)
8419   char* ToAsciiArray();
8420 #endif
8421   DECLARE_PRINTER(String)
8422   DECLARE_VERIFIER(String)
8423
8424   inline bool IsFlat();
8425
8426   // Layout description.
8427   static const int kLengthOffset = Name::kSize;
8428   static const int kSize = kLengthOffset + kPointerSize;
8429
8430   // Maximum number of characters to consider when trying to convert a string
8431   // value into an array index.
8432   static const int kMaxArrayIndexSize = 10;
8433   STATIC_ASSERT(kMaxArrayIndexSize < (1 << kArrayIndexLengthBits));
8434
8435   // Max char codes.
8436   static const int32_t kMaxOneByteCharCode = unibrow::Latin1::kMaxChar;
8437   static const uint32_t kMaxOneByteCharCodeU = unibrow::Latin1::kMaxChar;
8438   static const int kMaxUtf16CodeUnit = 0xffff;
8439   static const uint32_t kMaxUtf16CodeUnitU = kMaxUtf16CodeUnit;
8440
8441   // Value of hash field containing computed hash equal to zero.
8442   static const int kEmptyStringHash = kIsNotArrayIndexMask;
8443
8444   // Maximal string length.
8445   static const int kMaxLength = (1 << 28) - 16;
8446
8447   // Max length for computing hash. For strings longer than this limit the
8448   // string length is used as the hash value.
8449   static const int kMaxHashCalcLength = 16383;
8450
8451   // Limit for truncation in short printing.
8452   static const int kMaxShortPrintLength = 1024;
8453
8454   // Support for regular expressions.
8455   const uc16* GetTwoByteData(unsigned start);
8456
8457   // Helper function for flattening strings.
8458   template <typename sinkchar>
8459   static void WriteToFlat(String* source,
8460                           sinkchar* sink,
8461                           int from,
8462                           int to);
8463
8464   // The return value may point to the first aligned word containing the first
8465   // non-one-byte character, rather than directly to the non-one-byte character.
8466   // If the return value is >= the passed length, the entire string was
8467   // one-byte.
8468   static inline int NonAsciiStart(const char* chars, int length) {
8469     const char* start = chars;
8470     const char* limit = chars + length;
8471
8472     if (length >= kIntptrSize) {
8473       // Check unaligned bytes.
8474       while (!IsAligned(reinterpret_cast<intptr_t>(chars), sizeof(uintptr_t))) {
8475         if (static_cast<uint8_t>(*chars) > unibrow::Utf8::kMaxOneByteChar) {
8476           return static_cast<int>(chars - start);
8477         }
8478         ++chars;
8479       }
8480       // Check aligned words.
8481       DCHECK(unibrow::Utf8::kMaxOneByteChar == 0x7F);
8482       const uintptr_t non_one_byte_mask = kUintptrAllBitsSet / 0xFF * 0x80;
8483       while (chars + sizeof(uintptr_t) <= limit) {
8484         if (*reinterpret_cast<const uintptr_t*>(chars) & non_one_byte_mask) {
8485           return static_cast<int>(chars - start);
8486         }
8487         chars += sizeof(uintptr_t);
8488       }
8489     }
8490     // Check remaining unaligned bytes.
8491     while (chars < limit) {
8492       if (static_cast<uint8_t>(*chars) > unibrow::Utf8::kMaxOneByteChar) {
8493         return static_cast<int>(chars - start);
8494       }
8495       ++chars;
8496     }
8497
8498     return static_cast<int>(chars - start);
8499   }
8500
8501   static inline bool IsAscii(const char* chars, int length) {
8502     return NonAsciiStart(chars, length) >= length;
8503   }
8504
8505   static inline bool IsAscii(const uint8_t* chars, int length) {
8506     return
8507         NonAsciiStart(reinterpret_cast<const char*>(chars), length) >= length;
8508   }
8509
8510   static inline int NonOneByteStart(const uc16* chars, int length) {
8511     const uc16* limit = chars + length;
8512     const uc16* start = chars;
8513     while (chars < limit) {
8514       if (*chars > kMaxOneByteCharCodeU) return static_cast<int>(chars - start);
8515       ++chars;
8516     }
8517     return static_cast<int>(chars - start);
8518   }
8519
8520   static inline bool IsOneByte(const uc16* chars, int length) {
8521     return NonOneByteStart(chars, length) >= length;
8522   }
8523
8524   template<class Visitor>
8525   static inline ConsString* VisitFlat(Visitor* visitor,
8526                                       String* string,
8527                                       int offset = 0);
8528
8529   static Handle<FixedArray> CalculateLineEnds(Handle<String> string,
8530                                               bool include_ending_line);
8531
8532   // Use the hash field to forward to the canonical internalized string
8533   // when deserializing an internalized string.
8534   inline void SetForwardedInternalizedString(String* string);
8535   inline String* GetForwardedInternalizedString();
8536
8537  private:
8538   friend class Name;
8539   friend class StringTableInsertionKey;
8540
8541   static Handle<String> SlowFlatten(Handle<ConsString> cons,
8542                                     PretenureFlag tenure);
8543
8544   // Slow case of String::Equals.  This implementation works on any strings
8545   // but it is most efficient on strings that are almost flat.
8546   bool SlowEquals(String* other);
8547
8548   static bool SlowEquals(Handle<String> one, Handle<String> two);
8549
8550   // Slow case of AsArrayIndex.
8551   bool SlowAsArrayIndex(uint32_t* index);
8552
8553   // Compute and set the hash code.
8554   uint32_t ComputeAndSetHash();
8555
8556   DISALLOW_IMPLICIT_CONSTRUCTORS(String);
8557 };
8558
8559
8560 // The SeqString abstract class captures sequential string values.
8561 class SeqString: public String {
8562  public:
8563   DECLARE_CAST(SeqString)
8564
8565   // Layout description.
8566   static const int kHeaderSize = String::kSize;
8567
8568   // Truncate the string in-place if possible and return the result.
8569   // In case of new_length == 0, the empty string is returned without
8570   // truncating the original string.
8571   MUST_USE_RESULT static Handle<String> Truncate(Handle<SeqString> string,
8572                                                  int new_length);
8573  private:
8574   DISALLOW_IMPLICIT_CONSTRUCTORS(SeqString);
8575 };
8576
8577
8578 // The OneByteString class captures sequential one-byte string objects.
8579 // Each character in the OneByteString is an one-byte character.
8580 class SeqOneByteString: public SeqString {
8581  public:
8582   static const bool kHasOneByteEncoding = true;
8583
8584   // Dispatched behavior.
8585   inline uint16_t SeqOneByteStringGet(int index);
8586   inline void SeqOneByteStringSet(int index, uint16_t value);
8587
8588   // Get the address of the characters in this string.
8589   inline Address GetCharsAddress();
8590
8591   inline uint8_t* GetChars();
8592
8593   DECLARE_CAST(SeqOneByteString)
8594
8595   // Garbage collection support.  This method is called by the
8596   // garbage collector to compute the actual size of an OneByteString
8597   // instance.
8598   inline int SeqOneByteStringSize(InstanceType instance_type);
8599
8600   // Computes the size for an OneByteString instance of a given length.
8601   static int SizeFor(int length) {
8602     return OBJECT_POINTER_ALIGN(kHeaderSize + length * kCharSize);
8603   }
8604
8605   // Maximal memory usage for a single sequential one-byte string.
8606   static const int kMaxSize = 512 * MB - 1;
8607   STATIC_ASSERT((kMaxSize - kHeaderSize) >= String::kMaxLength);
8608
8609  private:
8610   DISALLOW_IMPLICIT_CONSTRUCTORS(SeqOneByteString);
8611 };
8612
8613
8614 // The TwoByteString class captures sequential unicode string objects.
8615 // Each character in the TwoByteString is a two-byte uint16_t.
8616 class SeqTwoByteString: public SeqString {
8617  public:
8618   static const bool kHasOneByteEncoding = false;
8619
8620   // Dispatched behavior.
8621   inline uint16_t SeqTwoByteStringGet(int index);
8622   inline void SeqTwoByteStringSet(int index, uint16_t value);
8623
8624   // Get the address of the characters in this string.
8625   inline Address GetCharsAddress();
8626
8627   inline uc16* GetChars();
8628
8629   // For regexp code.
8630   const uint16_t* SeqTwoByteStringGetData(unsigned start);
8631
8632   DECLARE_CAST(SeqTwoByteString)
8633
8634   // Garbage collection support.  This method is called by the
8635   // garbage collector to compute the actual size of a TwoByteString
8636   // instance.
8637   inline int SeqTwoByteStringSize(InstanceType instance_type);
8638
8639   // Computes the size for a TwoByteString instance of a given length.
8640   static int SizeFor(int length) {
8641     return OBJECT_POINTER_ALIGN(kHeaderSize + length * kShortSize);
8642   }
8643
8644   // Maximal memory usage for a single sequential two-byte string.
8645   static const int kMaxSize = 512 * MB - 1;
8646   STATIC_ASSERT(static_cast<int>((kMaxSize - kHeaderSize)/sizeof(uint16_t)) >=
8647                String::kMaxLength);
8648
8649  private:
8650   DISALLOW_IMPLICIT_CONSTRUCTORS(SeqTwoByteString);
8651 };
8652
8653
8654 // The ConsString class describes string values built by using the
8655 // addition operator on strings.  A ConsString is a pair where the
8656 // first and second components are pointers to other string values.
8657 // One or both components of a ConsString can be pointers to other
8658 // ConsStrings, creating a binary tree of ConsStrings where the leaves
8659 // are non-ConsString string values.  The string value represented by
8660 // a ConsString can be obtained by concatenating the leaf string
8661 // values in a left-to-right depth-first traversal of the tree.
8662 class ConsString: public String {
8663  public:
8664   // First string of the cons cell.
8665   inline String* first();
8666   // Doesn't check that the result is a string, even in debug mode.  This is
8667   // useful during GC where the mark bits confuse the checks.
8668   inline Object* unchecked_first();
8669   inline void set_first(String* first,
8670                         WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
8671
8672   // Second string of the cons cell.
8673   inline String* second();
8674   // Doesn't check that the result is a string, even in debug mode.  This is
8675   // useful during GC where the mark bits confuse the checks.
8676   inline Object* unchecked_second();
8677   inline void set_second(String* second,
8678                          WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
8679
8680   // Dispatched behavior.
8681   uint16_t ConsStringGet(int index);
8682
8683   DECLARE_CAST(ConsString)
8684
8685   // Layout description.
8686   static const int kFirstOffset = POINTER_SIZE_ALIGN(String::kSize);
8687   static const int kSecondOffset = kFirstOffset + kPointerSize;
8688   static const int kSize = kSecondOffset + kPointerSize;
8689
8690   // Minimum length for a cons string.
8691   static const int kMinLength = 13;
8692
8693   typedef FixedBodyDescriptor<kFirstOffset, kSecondOffset + kPointerSize, kSize>
8694           BodyDescriptor;
8695
8696   DECLARE_VERIFIER(ConsString)
8697
8698  private:
8699   DISALLOW_IMPLICIT_CONSTRUCTORS(ConsString);
8700 };
8701
8702
8703 // The Sliced String class describes strings that are substrings of another
8704 // sequential string.  The motivation is to save time and memory when creating
8705 // a substring.  A Sliced String is described as a pointer to the parent,
8706 // the offset from the start of the parent string and the length.  Using
8707 // a Sliced String therefore requires unpacking of the parent string and
8708 // adding the offset to the start address.  A substring of a Sliced String
8709 // are not nested since the double indirection is simplified when creating
8710 // such a substring.
8711 // Currently missing features are:
8712 //  - handling externalized parent strings
8713 //  - external strings as parent
8714 //  - truncating sliced string to enable otherwise unneeded parent to be GC'ed.
8715 class SlicedString: public String {
8716  public:
8717   inline String* parent();
8718   inline void set_parent(String* parent,
8719                          WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
8720   inline int offset() const;
8721   inline void set_offset(int offset);
8722
8723   // Dispatched behavior.
8724   uint16_t SlicedStringGet(int index);
8725
8726   DECLARE_CAST(SlicedString)
8727
8728   // Layout description.
8729   static const int kParentOffset = POINTER_SIZE_ALIGN(String::kSize);
8730   static const int kOffsetOffset = kParentOffset + kPointerSize;
8731   static const int kSize = kOffsetOffset + kPointerSize;
8732
8733   // Minimum length for a sliced string.
8734   static const int kMinLength = 13;
8735
8736   typedef FixedBodyDescriptor<kParentOffset,
8737                               kOffsetOffset + kPointerSize, kSize>
8738           BodyDescriptor;
8739
8740   DECLARE_VERIFIER(SlicedString)
8741
8742  private:
8743   DISALLOW_IMPLICIT_CONSTRUCTORS(SlicedString);
8744 };
8745
8746
8747 // The ExternalString class describes string values that are backed by
8748 // a string resource that lies outside the V8 heap.  ExternalStrings
8749 // consist of the length field common to all strings, a pointer to the
8750 // external resource.  It is important to ensure (externally) that the
8751 // resource is not deallocated while the ExternalString is live in the
8752 // V8 heap.
8753 //
8754 // The API expects that all ExternalStrings are created through the
8755 // API.  Therefore, ExternalStrings should not be used internally.
8756 class ExternalString: public String {
8757  public:
8758   DECLARE_CAST(ExternalString)
8759
8760   // Layout description.
8761   static const int kResourceOffset = POINTER_SIZE_ALIGN(String::kSize);
8762   static const int kShortSize = kResourceOffset + kPointerSize;
8763   static const int kResourceDataOffset = kResourceOffset + kPointerSize;
8764   static const int kSize = kResourceDataOffset + kPointerSize;
8765
8766   static const int kMaxShortLength =
8767       (kShortSize - SeqString::kHeaderSize) / kCharSize;
8768
8769   // Return whether external string is short (data pointer is not cached).
8770   inline bool is_short();
8771
8772   STATIC_ASSERT(kResourceOffset == Internals::kStringResourceOffset);
8773
8774  private:
8775   DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalString);
8776 };
8777
8778
8779 // The ExternalOneByteString class is an external string backed by an
8780 // one-byte string.
8781 class ExternalOneByteString : public ExternalString {
8782  public:
8783   static const bool kHasOneByteEncoding = true;
8784
8785   typedef v8::String::ExternalOneByteStringResource Resource;
8786
8787   // The underlying resource.
8788   inline const Resource* resource();
8789   inline void set_resource(const Resource* buffer);
8790
8791   // Update the pointer cache to the external character array.
8792   // The cached pointer is always valid, as the external character array does =
8793   // not move during lifetime.  Deserialization is the only exception, after
8794   // which the pointer cache has to be refreshed.
8795   inline void update_data_cache();
8796
8797   inline const uint8_t* GetChars();
8798
8799   // Dispatched behavior.
8800   inline uint16_t ExternalOneByteStringGet(int index);
8801
8802   DECLARE_CAST(ExternalOneByteString)
8803
8804   // Garbage collection support.
8805   inline void ExternalOneByteStringIterateBody(ObjectVisitor* v);
8806
8807   template <typename StaticVisitor>
8808   inline void ExternalOneByteStringIterateBody();
8809
8810  private:
8811   DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalOneByteString);
8812 };
8813
8814
8815 // The ExternalTwoByteString class is an external string backed by a UTF-16
8816 // encoded string.
8817 class ExternalTwoByteString: public ExternalString {
8818  public:
8819   static const bool kHasOneByteEncoding = false;
8820
8821   typedef v8::String::ExternalStringResource Resource;
8822
8823   // The underlying string resource.
8824   inline const Resource* resource();
8825   inline void set_resource(const Resource* buffer);
8826
8827   // Update the pointer cache to the external character array.
8828   // The cached pointer is always valid, as the external character array does =
8829   // not move during lifetime.  Deserialization is the only exception, after
8830   // which the pointer cache has to be refreshed.
8831   inline void update_data_cache();
8832
8833   inline const uint16_t* GetChars();
8834
8835   // Dispatched behavior.
8836   inline uint16_t ExternalTwoByteStringGet(int index);
8837
8838   // For regexp code.
8839   inline const uint16_t* ExternalTwoByteStringGetData(unsigned start);
8840
8841   DECLARE_CAST(ExternalTwoByteString)
8842
8843   // Garbage collection support.
8844   inline void ExternalTwoByteStringIterateBody(ObjectVisitor* v);
8845
8846   template<typename StaticVisitor>
8847   inline void ExternalTwoByteStringIterateBody();
8848
8849  private:
8850   DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalTwoByteString);
8851 };
8852
8853
8854 // Utility superclass for stack-allocated objects that must be updated
8855 // on gc.  It provides two ways for the gc to update instances, either
8856 // iterating or updating after gc.
8857 class Relocatable BASE_EMBEDDED {
8858  public:
8859   explicit inline Relocatable(Isolate* isolate);
8860   inline virtual ~Relocatable();
8861   virtual void IterateInstance(ObjectVisitor* v) { }
8862   virtual void PostGarbageCollection() { }
8863
8864   static void PostGarbageCollectionProcessing(Isolate* isolate);
8865   static int ArchiveSpacePerThread();
8866   static char* ArchiveState(Isolate* isolate, char* to);
8867   static char* RestoreState(Isolate* isolate, char* from);
8868   static void Iterate(Isolate* isolate, ObjectVisitor* v);
8869   static void Iterate(ObjectVisitor* v, Relocatable* top);
8870   static char* Iterate(ObjectVisitor* v, char* t);
8871
8872  private:
8873   Isolate* isolate_;
8874   Relocatable* prev_;
8875 };
8876
8877
8878 // A flat string reader provides random access to the contents of a
8879 // string independent of the character width of the string.  The handle
8880 // must be valid as long as the reader is being used.
8881 class FlatStringReader : public Relocatable {
8882  public:
8883   FlatStringReader(Isolate* isolate, Handle<String> str);
8884   FlatStringReader(Isolate* isolate, Vector<const char> input);
8885   void PostGarbageCollection();
8886   inline uc32 Get(int index);
8887   template <typename Char>
8888   inline Char Get(int index);
8889   int length() { return length_; }
8890  private:
8891   String** str_;
8892   bool is_one_byte_;
8893   int length_;
8894   const void* start_;
8895 };
8896
8897
8898 // This maintains an off-stack representation of the stack frames required
8899 // to traverse a ConsString, allowing an entirely iterative and restartable
8900 // traversal of the entire string
8901 class ConsStringIterator {
8902  public:
8903   inline ConsStringIterator() {}
8904   inline explicit ConsStringIterator(ConsString* cons_string, int offset = 0) {
8905     Reset(cons_string, offset);
8906   }
8907   inline void Reset(ConsString* cons_string, int offset = 0) {
8908     depth_ = 0;
8909     // Next will always return NULL.
8910     if (cons_string == NULL) return;
8911     Initialize(cons_string, offset);
8912   }
8913   // Returns NULL when complete.
8914   inline String* Next(int* offset_out) {
8915     *offset_out = 0;
8916     if (depth_ == 0) return NULL;
8917     return Continue(offset_out);
8918   }
8919
8920  private:
8921   static const int kStackSize = 32;
8922   // Use a mask instead of doing modulo operations for stack wrapping.
8923   static const int kDepthMask = kStackSize-1;
8924   STATIC_ASSERT(IS_POWER_OF_TWO(kStackSize));
8925   static inline int OffsetForDepth(int depth);
8926
8927   inline void PushLeft(ConsString* string);
8928   inline void PushRight(ConsString* string);
8929   inline void AdjustMaximumDepth();
8930   inline void Pop();
8931   inline bool StackBlown() { return maximum_depth_ - depth_ == kStackSize; }
8932   void Initialize(ConsString* cons_string, int offset);
8933   String* Continue(int* offset_out);
8934   String* NextLeaf(bool* blew_stack);
8935   String* Search(int* offset_out);
8936
8937   // Stack must always contain only frames for which right traversal
8938   // has not yet been performed.
8939   ConsString* frames_[kStackSize];
8940   ConsString* root_;
8941   int depth_;
8942   int maximum_depth_;
8943   int consumed_;
8944   DISALLOW_COPY_AND_ASSIGN(ConsStringIterator);
8945 };
8946
8947
8948 class StringCharacterStream {
8949  public:
8950   inline StringCharacterStream(String* string,
8951                                int offset = 0);
8952   inline uint16_t GetNext();
8953   inline bool HasMore();
8954   inline void Reset(String* string, int offset = 0);
8955   inline void VisitOneByteString(const uint8_t* chars, int length);
8956   inline void VisitTwoByteString(const uint16_t* chars, int length);
8957
8958  private:
8959   ConsStringIterator iter_;
8960   bool is_one_byte_;
8961   union {
8962     const uint8_t* buffer8_;
8963     const uint16_t* buffer16_;
8964   };
8965   const uint8_t* end_;
8966   DISALLOW_COPY_AND_ASSIGN(StringCharacterStream);
8967 };
8968
8969
8970 template <typename T>
8971 class VectorIterator {
8972  public:
8973   VectorIterator(T* d, int l) : data_(Vector<const T>(d, l)), index_(0) { }
8974   explicit VectorIterator(Vector<const T> data) : data_(data), index_(0) { }
8975   T GetNext() { return data_[index_++]; }
8976   bool has_more() { return index_ < data_.length(); }
8977  private:
8978   Vector<const T> data_;
8979   int index_;
8980 };
8981
8982
8983 // The Oddball describes objects null, undefined, true, and false.
8984 class Oddball: public HeapObject {
8985  public:
8986   // [to_string]: Cached to_string computed at startup.
8987   DECL_ACCESSORS(to_string, String)
8988
8989   // [to_number]: Cached to_number computed at startup.
8990   DECL_ACCESSORS(to_number, Object)
8991
8992   // [typeof]: Cached type_of computed at startup.
8993   DECL_ACCESSORS(type_of, String)
8994
8995   inline byte kind() const;
8996   inline void set_kind(byte kind);
8997
8998   DECLARE_CAST(Oddball)
8999
9000   // Dispatched behavior.
9001   DECLARE_VERIFIER(Oddball)
9002
9003   // Initialize the fields.
9004   static void Initialize(Isolate* isolate, Handle<Oddball> oddball,
9005                          const char* to_string, Handle<Object> to_number,
9006                          const char* type_of, byte kind);
9007
9008   // Layout description.
9009   static const int kToStringOffset = HeapObject::kHeaderSize;
9010   static const int kToNumberOffset = kToStringOffset + kPointerSize;
9011   static const int kTypeOfOffset = kToNumberOffset + kPointerSize;
9012   static const int kKindOffset = kTypeOfOffset + kPointerSize;
9013   static const int kSize = kKindOffset + kPointerSize;
9014
9015   static const byte kFalse = 0;
9016   static const byte kTrue = 1;
9017   static const byte kNotBooleanMask = ~1;
9018   static const byte kTheHole = 2;
9019   static const byte kNull = 3;
9020   static const byte kArgumentMarker = 4;
9021   static const byte kUndefined = 5;
9022   static const byte kUninitialized = 6;
9023   static const byte kOther = 7;
9024   static const byte kException = 8;
9025
9026   typedef FixedBodyDescriptor<kToStringOffset, kTypeOfOffset + kPointerSize,
9027                               kSize> BodyDescriptor;
9028
9029   STATIC_ASSERT(kKindOffset == Internals::kOddballKindOffset);
9030   STATIC_ASSERT(kNull == Internals::kNullOddballKind);
9031   STATIC_ASSERT(kUndefined == Internals::kUndefinedOddballKind);
9032
9033  private:
9034   DISALLOW_IMPLICIT_CONSTRUCTORS(Oddball);
9035 };
9036
9037
9038 class Cell: public HeapObject {
9039  public:
9040   // [value]: value of the cell.
9041   DECL_ACCESSORS(value, Object)
9042
9043   DECLARE_CAST(Cell)
9044
9045   static inline Cell* FromValueAddress(Address value) {
9046     Object* result = FromAddress(value - kValueOffset);
9047     return static_cast<Cell*>(result);
9048   }
9049
9050   inline Address ValueAddress() {
9051     return address() + kValueOffset;
9052   }
9053
9054   // Dispatched behavior.
9055   DECLARE_PRINTER(Cell)
9056   DECLARE_VERIFIER(Cell)
9057
9058   // Layout description.
9059   static const int kValueOffset = HeapObject::kHeaderSize;
9060   static const int kSize = kValueOffset + kPointerSize;
9061
9062   typedef FixedBodyDescriptor<kValueOffset,
9063                               kValueOffset + kPointerSize,
9064                               kSize> BodyDescriptor;
9065
9066  private:
9067   DISALLOW_IMPLICIT_CONSTRUCTORS(Cell);
9068 };
9069
9070
9071 class PropertyCell : public HeapObject {
9072  public:
9073   // [property_details]: details of the global property.
9074   DECL_ACCESSORS(property_details_raw, Object)
9075   // [value]: value of the global property.
9076   DECL_ACCESSORS(value, Object)
9077   // [dependent_code]: dependent code that depends on the type of the global
9078   // property.
9079   DECL_ACCESSORS(dependent_code, DependentCode)
9080
9081   inline PropertyDetails property_details();
9082   inline void set_property_details(PropertyDetails details);
9083
9084   PropertyCellConstantType GetConstantType();
9085
9086   // Computes the new type of the cell's contents for the given value, but
9087   // without actually modifying the details.
9088   static PropertyCellType UpdatedType(Handle<PropertyCell> cell,
9089                                       Handle<Object> value,
9090                                       PropertyDetails details);
9091   static void UpdateCell(Handle<GlobalDictionary> dictionary, int entry,
9092                          Handle<Object> value, PropertyDetails details);
9093
9094   static Handle<PropertyCell> InvalidateEntry(
9095       Handle<GlobalDictionary> dictionary, int entry);
9096
9097   static void SetValueWithInvalidation(Handle<PropertyCell> cell,
9098                                        Handle<Object> new_value);
9099
9100   DECLARE_CAST(PropertyCell)
9101
9102   // Dispatched behavior.
9103   DECLARE_PRINTER(PropertyCell)
9104   DECLARE_VERIFIER(PropertyCell)
9105
9106   // Layout description.
9107   static const int kDetailsOffset = HeapObject::kHeaderSize;
9108   static const int kValueOffset = kDetailsOffset + kPointerSize;
9109   static const int kDependentCodeOffset = kValueOffset + kPointerSize;
9110   static const int kSize = kDependentCodeOffset + kPointerSize;
9111
9112   static const int kPointerFieldsBeginOffset = kValueOffset;
9113   static const int kPointerFieldsEndOffset = kSize;
9114
9115   typedef FixedBodyDescriptor<kValueOffset,
9116                               kSize,
9117                               kSize> BodyDescriptor;
9118
9119  private:
9120   DISALLOW_IMPLICIT_CONSTRUCTORS(PropertyCell);
9121 };
9122
9123
9124 class WeakCell : public HeapObject {
9125  public:
9126   inline Object* value() const;
9127
9128   // This should not be called by anyone except GC.
9129   inline void clear();
9130
9131   // This should not be called by anyone except allocator.
9132   inline void initialize(HeapObject* value);
9133
9134   inline bool cleared() const;
9135
9136   DECL_ACCESSORS(next, Object)
9137
9138   inline void clear_next(Heap* heap);
9139
9140   inline bool next_cleared();
9141
9142   DECLARE_CAST(WeakCell)
9143
9144   DECLARE_PRINTER(WeakCell)
9145   DECLARE_VERIFIER(WeakCell)
9146
9147   // Layout description.
9148   static const int kValueOffset = HeapObject::kHeaderSize;
9149   static const int kNextOffset = kValueOffset + kPointerSize;
9150   static const int kSize = kNextOffset + kPointerSize;
9151
9152   typedef FixedBodyDescriptor<kValueOffset, kSize, kSize> BodyDescriptor;
9153
9154  private:
9155   DISALLOW_IMPLICIT_CONSTRUCTORS(WeakCell);
9156 };
9157
9158
9159 // The JSProxy describes EcmaScript Harmony proxies
9160 class JSProxy: public JSReceiver {
9161  public:
9162   // [handler]: The handler property.
9163   DECL_ACCESSORS(handler, Object)
9164
9165   // [hash]: The hash code property (undefined if not initialized yet).
9166   DECL_ACCESSORS(hash, Object)
9167
9168   DECLARE_CAST(JSProxy)
9169
9170   MUST_USE_RESULT static MaybeHandle<Object> GetPropertyWithHandler(
9171       Handle<JSProxy> proxy,
9172       Handle<Object> receiver,
9173       Handle<Name> name);
9174
9175   // If the handler defines an accessor property with a setter, invoke it.
9176   // If it defines an accessor property without a setter, or a data property
9177   // that is read-only, throw. In all these cases set '*done' to true,
9178   // otherwise set it to false.
9179   MUST_USE_RESULT
9180   static MaybeHandle<Object> SetPropertyViaPrototypesWithHandler(
9181       Handle<JSProxy> proxy, Handle<Object> receiver, Handle<Name> name,
9182       Handle<Object> value, LanguageMode language_mode, bool* done);
9183
9184   MUST_USE_RESULT static Maybe<PropertyAttributes>
9185       GetPropertyAttributesWithHandler(Handle<JSProxy> proxy,
9186                                        Handle<Object> receiver,
9187                                        Handle<Name> name);
9188   MUST_USE_RESULT static MaybeHandle<Object> SetPropertyWithHandler(
9189       Handle<JSProxy> proxy, Handle<Object> receiver, Handle<Name> name,
9190       Handle<Object> value, LanguageMode language_mode);
9191
9192   // Turn the proxy into an (empty) JSObject.
9193   static void Fix(Handle<JSProxy> proxy);
9194
9195   // Initializes the body after the handler slot.
9196   inline void InitializeBody(int object_size, Object* value);
9197
9198   // Invoke a trap by name. If the trap does not exist on this's handler,
9199   // but derived_trap is non-NULL, invoke that instead.  May cause GC.
9200   MUST_USE_RESULT static MaybeHandle<Object> CallTrap(
9201       Handle<JSProxy> proxy,
9202       const char* name,
9203       Handle<Object> derived_trap,
9204       int argc,
9205       Handle<Object> args[]);
9206
9207   // Dispatched behavior.
9208   DECLARE_PRINTER(JSProxy)
9209   DECLARE_VERIFIER(JSProxy)
9210
9211   // Layout description. We add padding so that a proxy has the same
9212   // size as a virgin JSObject. This is essential for becoming a JSObject
9213   // upon freeze.
9214   static const int kHandlerOffset = HeapObject::kHeaderSize;
9215   static const int kHashOffset = kHandlerOffset + kPointerSize;
9216   static const int kPaddingOffset = kHashOffset + kPointerSize;
9217   static const int kSize = JSObject::kHeaderSize;
9218   static const int kHeaderSize = kPaddingOffset;
9219   static const int kPaddingSize = kSize - kPaddingOffset;
9220
9221   STATIC_ASSERT(kPaddingSize >= 0);
9222
9223   typedef FixedBodyDescriptor<kHandlerOffset,
9224                               kPaddingOffset,
9225                               kSize> BodyDescriptor;
9226
9227  private:
9228   friend class JSReceiver;
9229
9230   MUST_USE_RESULT static Maybe<bool> HasPropertyWithHandler(
9231       Handle<JSProxy> proxy, Handle<Name> name);
9232
9233   MUST_USE_RESULT static MaybeHandle<Object> DeletePropertyWithHandler(
9234       Handle<JSProxy> proxy, Handle<Name> name, LanguageMode language_mode);
9235
9236   MUST_USE_RESULT Object* GetIdentityHash();
9237
9238   static Handle<Smi> GetOrCreateIdentityHash(Handle<JSProxy> proxy);
9239
9240   DISALLOW_IMPLICIT_CONSTRUCTORS(JSProxy);
9241 };
9242
9243
9244 class JSFunctionProxy: public JSProxy {
9245  public:
9246   // [call_trap]: The call trap.
9247   DECL_ACCESSORS(call_trap, Object)
9248
9249   // [construct_trap]: The construct trap.
9250   DECL_ACCESSORS(construct_trap, Object)
9251
9252   DECLARE_CAST(JSFunctionProxy)
9253
9254   // Dispatched behavior.
9255   DECLARE_PRINTER(JSFunctionProxy)
9256   DECLARE_VERIFIER(JSFunctionProxy)
9257
9258   // Layout description.
9259   static const int kCallTrapOffset = JSProxy::kPaddingOffset;
9260   static const int kConstructTrapOffset = kCallTrapOffset + kPointerSize;
9261   static const int kPaddingOffset = kConstructTrapOffset + kPointerSize;
9262   static const int kSize = JSFunction::kSize;
9263   static const int kPaddingSize = kSize - kPaddingOffset;
9264
9265   STATIC_ASSERT(kPaddingSize >= 0);
9266
9267   typedef FixedBodyDescriptor<kHandlerOffset,
9268                               kConstructTrapOffset + kPointerSize,
9269                               kSize> BodyDescriptor;
9270
9271  private:
9272   DISALLOW_IMPLICIT_CONSTRUCTORS(JSFunctionProxy);
9273 };
9274
9275
9276 class JSCollection : public JSObject {
9277  public:
9278   // [table]: the backing hash table
9279   DECL_ACCESSORS(table, Object)
9280
9281   static const int kTableOffset = JSObject::kHeaderSize;
9282   static const int kSize = kTableOffset + kPointerSize;
9283
9284  private:
9285   DISALLOW_IMPLICIT_CONSTRUCTORS(JSCollection);
9286 };
9287
9288
9289 // The JSSet describes EcmaScript Harmony sets
9290 class JSSet : public JSCollection {
9291  public:
9292   DECLARE_CAST(JSSet)
9293
9294   // Dispatched behavior.
9295   DECLARE_PRINTER(JSSet)
9296   DECLARE_VERIFIER(JSSet)
9297
9298  private:
9299   DISALLOW_IMPLICIT_CONSTRUCTORS(JSSet);
9300 };
9301
9302
9303 // The JSMap describes EcmaScript Harmony maps
9304 class JSMap : public JSCollection {
9305  public:
9306   DECLARE_CAST(JSMap)
9307
9308   // Dispatched behavior.
9309   DECLARE_PRINTER(JSMap)
9310   DECLARE_VERIFIER(JSMap)
9311
9312  private:
9313   DISALLOW_IMPLICIT_CONSTRUCTORS(JSMap);
9314 };
9315
9316
9317 // OrderedHashTableIterator is an iterator that iterates over the keys and
9318 // values of an OrderedHashTable.
9319 //
9320 // The iterator has a reference to the underlying OrderedHashTable data,
9321 // [table], as well as the current [index] the iterator is at.
9322 //
9323 // When the OrderedHashTable is rehashed it adds a reference from the old table
9324 // to the new table as well as storing enough data about the changes so that the
9325 // iterator [index] can be adjusted accordingly.
9326 //
9327 // When the [Next] result from the iterator is requested, the iterator checks if
9328 // there is a newer table that it needs to transition to.
9329 template<class Derived, class TableType>
9330 class OrderedHashTableIterator: public JSObject {
9331  public:
9332   // [table]: the backing hash table mapping keys to values.
9333   DECL_ACCESSORS(table, Object)
9334
9335   // [index]: The index into the data table.
9336   DECL_ACCESSORS(index, Object)
9337
9338   // [kind]: The kind of iteration this is. One of the [Kind] enum values.
9339   DECL_ACCESSORS(kind, Object)
9340
9341 #ifdef OBJECT_PRINT
9342   void OrderedHashTableIteratorPrint(std::ostream& os);  // NOLINT
9343 #endif
9344
9345   static const int kTableOffset = JSObject::kHeaderSize;
9346   static const int kIndexOffset = kTableOffset + kPointerSize;
9347   static const int kKindOffset = kIndexOffset + kPointerSize;
9348   static const int kSize = kKindOffset + kPointerSize;
9349
9350   enum Kind {
9351     kKindKeys = 1,
9352     kKindValues = 2,
9353     kKindEntries = 3
9354   };
9355
9356   // Whether the iterator has more elements. This needs to be called before
9357   // calling |CurrentKey| and/or |CurrentValue|.
9358   bool HasMore();
9359
9360   // Move the index forward one.
9361   void MoveNext() {
9362     set_index(Smi::FromInt(Smi::cast(index())->value() + 1));
9363   }
9364
9365   // Populates the array with the next key and value and then moves the iterator
9366   // forward.
9367   // This returns the |kind| or 0 if the iterator is already at the end.
9368   Smi* Next(JSArray* value_array);
9369
9370   // Returns the current key of the iterator. This should only be called when
9371   // |HasMore| returns true.
9372   inline Object* CurrentKey();
9373
9374  private:
9375   // Transitions the iterator to the non obsolete backing store. This is a NOP
9376   // if the [table] is not obsolete.
9377   void Transition();
9378
9379   DISALLOW_IMPLICIT_CONSTRUCTORS(OrderedHashTableIterator);
9380 };
9381
9382
9383 class JSSetIterator: public OrderedHashTableIterator<JSSetIterator,
9384                                                      OrderedHashSet> {
9385  public:
9386   // Dispatched behavior.
9387   DECLARE_PRINTER(JSSetIterator)
9388   DECLARE_VERIFIER(JSSetIterator)
9389
9390   DECLARE_CAST(JSSetIterator)
9391
9392   // Called by |Next| to populate the array. This allows the subclasses to
9393   // populate the array differently.
9394   inline void PopulateValueArray(FixedArray* array);
9395
9396  private:
9397   DISALLOW_IMPLICIT_CONSTRUCTORS(JSSetIterator);
9398 };
9399
9400
9401 class JSMapIterator: public OrderedHashTableIterator<JSMapIterator,
9402                                                      OrderedHashMap> {
9403  public:
9404   // Dispatched behavior.
9405   DECLARE_PRINTER(JSMapIterator)
9406   DECLARE_VERIFIER(JSMapIterator)
9407
9408   DECLARE_CAST(JSMapIterator)
9409
9410   // Called by |Next| to populate the array. This allows the subclasses to
9411   // populate the array differently.
9412   inline void PopulateValueArray(FixedArray* array);
9413
9414  private:
9415   // Returns the current value of the iterator. This should only be called when
9416   // |HasMore| returns true.
9417   inline Object* CurrentValue();
9418
9419   DISALLOW_IMPLICIT_CONSTRUCTORS(JSMapIterator);
9420 };
9421
9422
9423 // Base class for both JSWeakMap and JSWeakSet
9424 class JSWeakCollection: public JSObject {
9425  public:
9426   // [table]: the backing hash table mapping keys to values.
9427   DECL_ACCESSORS(table, Object)
9428
9429   // [next]: linked list of encountered weak maps during GC.
9430   DECL_ACCESSORS(next, Object)
9431
9432   static const int kTableOffset = JSObject::kHeaderSize;
9433   static const int kNextOffset = kTableOffset + kPointerSize;
9434   static const int kSize = kNextOffset + kPointerSize;
9435
9436  private:
9437   DISALLOW_IMPLICIT_CONSTRUCTORS(JSWeakCollection);
9438 };
9439
9440
9441 // The JSWeakMap describes EcmaScript Harmony weak maps
9442 class JSWeakMap: public JSWeakCollection {
9443  public:
9444   DECLARE_CAST(JSWeakMap)
9445
9446   // Dispatched behavior.
9447   DECLARE_PRINTER(JSWeakMap)
9448   DECLARE_VERIFIER(JSWeakMap)
9449
9450  private:
9451   DISALLOW_IMPLICIT_CONSTRUCTORS(JSWeakMap);
9452 };
9453
9454
9455 // The JSWeakSet describes EcmaScript Harmony weak sets
9456 class JSWeakSet: public JSWeakCollection {
9457  public:
9458   DECLARE_CAST(JSWeakSet)
9459
9460   // Dispatched behavior.
9461   DECLARE_PRINTER(JSWeakSet)
9462   DECLARE_VERIFIER(JSWeakSet)
9463
9464  private:
9465   DISALLOW_IMPLICIT_CONSTRUCTORS(JSWeakSet);
9466 };
9467
9468
9469 // Whether a JSArrayBuffer is a SharedArrayBuffer or not.
9470 enum class SharedFlag { kNotShared, kShared };
9471
9472
9473 class JSArrayBuffer: public JSObject {
9474  public:
9475   // [backing_store]: backing memory for this array
9476   DECL_ACCESSORS(backing_store, void)
9477
9478   // [byte_length]: length in bytes
9479   DECL_ACCESSORS(byte_length, Object)
9480
9481   inline uint32_t bit_field() const;
9482   inline void set_bit_field(uint32_t bits);
9483
9484   inline bool is_external();
9485   inline void set_is_external(bool value);
9486
9487   inline bool is_neuterable();
9488   inline void set_is_neuterable(bool value);
9489
9490   inline bool was_neutered();
9491   inline void set_was_neutered(bool value);
9492
9493   inline bool is_shared();
9494   inline void set_is_shared(bool value);
9495
9496   DECLARE_CAST(JSArrayBuffer)
9497
9498   void Neuter();
9499
9500   // Dispatched behavior.
9501   DECLARE_PRINTER(JSArrayBuffer)
9502   DECLARE_VERIFIER(JSArrayBuffer)
9503
9504   static const int kBackingStoreOffset = JSObject::kHeaderSize;
9505   static const int kByteLengthOffset = kBackingStoreOffset + kPointerSize;
9506   static const int kBitFieldSlot = kByteLengthOffset + kPointerSize;
9507 #if V8_TARGET_LITTLE_ENDIAN || !V8_HOST_ARCH_64_BIT
9508   static const int kBitFieldOffset = kBitFieldSlot;
9509 #else
9510   static const int kBitFieldOffset = kBitFieldSlot + kIntSize;
9511 #endif
9512   static const int kSize = kBitFieldSlot + kPointerSize;
9513
9514   static const int kSizeWithInternalFields =
9515       kSize + v8::ArrayBuffer::kInternalFieldCount * kPointerSize;
9516
9517   class IsExternal : public BitField<bool, 1, 1> {};
9518   class IsNeuterable : public BitField<bool, 2, 1> {};
9519   class WasNeutered : public BitField<bool, 3, 1> {};
9520   class IsShared : public BitField<bool, 4, 1> {};
9521
9522  private:
9523   DISALLOW_IMPLICIT_CONSTRUCTORS(JSArrayBuffer);
9524 };
9525
9526
9527 class JSArrayBufferView: public JSObject {
9528  public:
9529   // [buffer]: ArrayBuffer that this typed array views.
9530   DECL_ACCESSORS(buffer, Object)
9531
9532   // [byte_offset]: offset of typed array in bytes.
9533   DECL_ACCESSORS(byte_offset, Object)
9534
9535   // [byte_length]: length of typed array in bytes.
9536   DECL_ACCESSORS(byte_length, Object)
9537
9538   DECLARE_CAST(JSArrayBufferView)
9539
9540   DECLARE_VERIFIER(JSArrayBufferView)
9541
9542   inline bool WasNeutered() const;
9543
9544   static const int kBufferOffset = JSObject::kHeaderSize;
9545   static const int kByteOffsetOffset = kBufferOffset + kPointerSize;
9546   static const int kByteLengthOffset = kByteOffsetOffset + kPointerSize;
9547   static const int kViewSize = kByteLengthOffset + kPointerSize;
9548
9549  private:
9550 #ifdef VERIFY_HEAP
9551   DECL_ACCESSORS(raw_byte_offset, Object)
9552   DECL_ACCESSORS(raw_byte_length, Object)
9553 #endif
9554
9555   DISALLOW_IMPLICIT_CONSTRUCTORS(JSArrayBufferView);
9556 };
9557
9558
9559 class JSTypedArray: public JSArrayBufferView {
9560  public:
9561   // [length]: length of typed array in elements.
9562   DECL_ACCESSORS(length, Object)
9563   inline uint32_t length_value() const;
9564
9565   DECLARE_CAST(JSTypedArray)
9566
9567   ExternalArrayType type();
9568   size_t element_size();
9569
9570   Handle<JSArrayBuffer> GetBuffer();
9571
9572   // Dispatched behavior.
9573   DECLARE_PRINTER(JSTypedArray)
9574   DECLARE_VERIFIER(JSTypedArray)
9575
9576   static const int kLengthOffset = kViewSize + kPointerSize;
9577   static const int kSize = kLengthOffset + kPointerSize;
9578
9579   static const int kSizeWithInternalFields =
9580       kSize + v8::ArrayBufferView::kInternalFieldCount * kPointerSize;
9581
9582  private:
9583   static Handle<JSArrayBuffer> MaterializeArrayBuffer(
9584       Handle<JSTypedArray> typed_array);
9585 #ifdef VERIFY_HEAP
9586   DECL_ACCESSORS(raw_length, Object)
9587 #endif
9588
9589   DISALLOW_IMPLICIT_CONSTRUCTORS(JSTypedArray);
9590 };
9591
9592
9593 class JSDataView: public JSArrayBufferView {
9594  public:
9595   DECLARE_CAST(JSDataView)
9596
9597   // Dispatched behavior.
9598   DECLARE_PRINTER(JSDataView)
9599   DECLARE_VERIFIER(JSDataView)
9600
9601   static const int kSize = kViewSize;
9602
9603   static const int kSizeWithInternalFields =
9604       kSize + v8::ArrayBufferView::kInternalFieldCount * kPointerSize;
9605
9606  private:
9607   DISALLOW_IMPLICIT_CONSTRUCTORS(JSDataView);
9608 };
9609
9610
9611 // Foreign describes objects pointing from JavaScript to C structures.
9612 class Foreign: public HeapObject {
9613  public:
9614   // [address]: field containing the address.
9615   inline Address foreign_address();
9616   inline void set_foreign_address(Address value);
9617
9618   DECLARE_CAST(Foreign)
9619
9620   // Dispatched behavior.
9621   inline void ForeignIterateBody(ObjectVisitor* v);
9622
9623   template<typename StaticVisitor>
9624   inline void ForeignIterateBody();
9625
9626   // Dispatched behavior.
9627   DECLARE_PRINTER(Foreign)
9628   DECLARE_VERIFIER(Foreign)
9629
9630   // Layout description.
9631
9632   static const int kForeignAddressOffset = HeapObject::kHeaderSize;
9633   static const int kSize = kForeignAddressOffset + kPointerSize;
9634
9635   STATIC_ASSERT(kForeignAddressOffset == Internals::kForeignAddressOffset);
9636
9637  private:
9638   DISALLOW_IMPLICIT_CONSTRUCTORS(Foreign);
9639 };
9640
9641
9642 // The JSArray describes JavaScript Arrays
9643 //  Such an array can be in one of two modes:
9644 //    - fast, backing storage is a FixedArray and length <= elements.length();
9645 //       Please note: push and pop can be used to grow and shrink the array.
9646 //    - slow, backing storage is a HashTable with numbers as keys.
9647 class JSArray: public JSObject {
9648  public:
9649   // [length]: The length property.
9650   DECL_ACCESSORS(length, Object)
9651
9652   // Overload the length setter to skip write barrier when the length
9653   // is set to a smi. This matches the set function on FixedArray.
9654   inline void set_length(Smi* length);
9655
9656   static bool HasReadOnlyLength(Handle<JSArray> array);
9657   static bool WouldChangeReadOnlyLength(Handle<JSArray> array, uint32_t index);
9658   static MaybeHandle<Object> ReadOnlyLengthError(Handle<JSArray> array);
9659
9660   // Initialize the array with the given capacity. The function may
9661   // fail due to out-of-memory situations, but only if the requested
9662   // capacity is non-zero.
9663   static void Initialize(Handle<JSArray> array, int capacity, int length = 0);
9664
9665   // If the JSArray has fast elements, and new_length would result in
9666   // normalization, returns true.
9667   bool SetLengthWouldNormalize(uint32_t new_length);
9668   static inline bool SetLengthWouldNormalize(Heap* heap, uint32_t new_length);
9669
9670   // Initializes the array to a certain length.
9671   inline bool AllowsSetLength();
9672
9673   static void SetLength(Handle<JSArray> array, uint32_t length);
9674   // Same as above but will also queue splice records if |array| is observed.
9675   static MaybeHandle<Object> ObservableSetLength(Handle<JSArray> array,
9676                                                  uint32_t length);
9677
9678   // Set the content of the array to the content of storage.
9679   static inline void SetContent(Handle<JSArray> array,
9680                                 Handle<FixedArrayBase> storage);
9681
9682   DECLARE_CAST(JSArray)
9683
9684   // Dispatched behavior.
9685   DECLARE_PRINTER(JSArray)
9686   DECLARE_VERIFIER(JSArray)
9687
9688   // Number of element slots to pre-allocate for an empty array.
9689   static const int kPreallocatedArrayElements = 4;
9690
9691   // Layout description.
9692   static const int kLengthOffset = JSObject::kHeaderSize;
9693   static const int kSize = kLengthOffset + kPointerSize;
9694
9695  private:
9696   DISALLOW_IMPLICIT_CONSTRUCTORS(JSArray);
9697 };
9698
9699
9700 Handle<Object> CacheInitialJSArrayMaps(Handle<Context> native_context,
9701                                        Handle<Map> initial_map);
9702
9703
9704 // JSRegExpResult is just a JSArray with a specific initial map.
9705 // This initial map adds in-object properties for "index" and "input"
9706 // properties, as assigned by RegExp.prototype.exec, which allows
9707 // faster creation of RegExp exec results.
9708 // This class just holds constants used when creating the result.
9709 // After creation the result must be treated as a JSArray in all regards.
9710 class JSRegExpResult: public JSArray {
9711  public:
9712   // Offsets of object fields.
9713   static const int kIndexOffset = JSArray::kSize;
9714   static const int kInputOffset = kIndexOffset + kPointerSize;
9715   static const int kSize = kInputOffset + kPointerSize;
9716   // Indices of in-object properties.
9717   static const int kIndexIndex = 0;
9718   static const int kInputIndex = 1;
9719  private:
9720   DISALLOW_IMPLICIT_CONSTRUCTORS(JSRegExpResult);
9721 };
9722
9723
9724 class AccessorInfo: public Struct {
9725  public:
9726   DECL_ACCESSORS(name, Object)
9727   DECL_ACCESSORS(flag, Smi)
9728   DECL_ACCESSORS(expected_receiver_type, Object)
9729
9730   inline bool all_can_read();
9731   inline void set_all_can_read(bool value);
9732
9733   inline bool all_can_write();
9734   inline void set_all_can_write(bool value);
9735
9736   inline bool is_special_data_property();
9737   inline void set_is_special_data_property(bool value);
9738
9739   inline PropertyAttributes property_attributes();
9740   inline void set_property_attributes(PropertyAttributes attributes);
9741
9742   // Checks whether the given receiver is compatible with this accessor.
9743   static bool IsCompatibleReceiverMap(Isolate* isolate,
9744                                       Handle<AccessorInfo> info,
9745                                       Handle<Map> map);
9746   inline bool IsCompatibleReceiver(Object* receiver);
9747
9748   DECLARE_CAST(AccessorInfo)
9749
9750   // Dispatched behavior.
9751   DECLARE_VERIFIER(AccessorInfo)
9752
9753   // Append all descriptors to the array that are not already there.
9754   // Return number added.
9755   static int AppendUnique(Handle<Object> descriptors,
9756                           Handle<FixedArray> array,
9757                           int valid_descriptors);
9758
9759   static const int kNameOffset = HeapObject::kHeaderSize;
9760   static const int kFlagOffset = kNameOffset + kPointerSize;
9761   static const int kExpectedReceiverTypeOffset = kFlagOffset + kPointerSize;
9762   static const int kSize = kExpectedReceiverTypeOffset + kPointerSize;
9763
9764  private:
9765   inline bool HasExpectedReceiverType();
9766
9767   // Bit positions in flag.
9768   static const int kAllCanReadBit = 0;
9769   static const int kAllCanWriteBit = 1;
9770   static const int kSpecialDataProperty = 2;
9771   class AttributesField : public BitField<PropertyAttributes, 3, 3> {};
9772
9773   DISALLOW_IMPLICIT_CONSTRUCTORS(AccessorInfo);
9774 };
9775
9776
9777 // An accessor must have a getter, but can have no setter.
9778 //
9779 // When setting a property, V8 searches accessors in prototypes.
9780 // If an accessor was found and it does not have a setter,
9781 // the request is ignored.
9782 //
9783 // If the accessor in the prototype has the READ_ONLY property attribute, then
9784 // a new value is added to the derived object when the property is set.
9785 // This shadows the accessor in the prototype.
9786 class ExecutableAccessorInfo: public AccessorInfo {
9787  public:
9788   DECL_ACCESSORS(getter, Object)
9789   DECL_ACCESSORS(setter, Object)
9790   DECL_ACCESSORS(data, Object)
9791
9792   DECLARE_CAST(ExecutableAccessorInfo)
9793
9794   // Dispatched behavior.
9795   DECLARE_PRINTER(ExecutableAccessorInfo)
9796   DECLARE_VERIFIER(ExecutableAccessorInfo)
9797
9798   static const int kGetterOffset = AccessorInfo::kSize;
9799   static const int kSetterOffset = kGetterOffset + kPointerSize;
9800   static const int kDataOffset = kSetterOffset + kPointerSize;
9801   static const int kSize = kDataOffset + kPointerSize;
9802
9803   static void ClearSetter(Handle<ExecutableAccessorInfo> info);
9804
9805  private:
9806   DISALLOW_IMPLICIT_CONSTRUCTORS(ExecutableAccessorInfo);
9807 };
9808
9809
9810 // Support for JavaScript accessors: A pair of a getter and a setter. Each
9811 // accessor can either be
9812 //   * a pointer to a JavaScript function or proxy: a real accessor
9813 //   * undefined: considered an accessor by the spec, too, strangely enough
9814 //   * the hole: an accessor which has not been set
9815 //   * a pointer to a map: a transition used to ensure map sharing
9816 class AccessorPair: public Struct {
9817  public:
9818   DECL_ACCESSORS(getter, Object)
9819   DECL_ACCESSORS(setter, Object)
9820
9821   DECLARE_CAST(AccessorPair)
9822
9823   static Handle<AccessorPair> Copy(Handle<AccessorPair> pair);
9824
9825   inline Object* get(AccessorComponent component);
9826   inline void set(AccessorComponent component, Object* value);
9827
9828   // Note: Returns undefined instead in case of a hole.
9829   Object* GetComponent(AccessorComponent component);
9830
9831   // Set both components, skipping arguments which are a JavaScript null.
9832   inline void SetComponents(Object* getter, Object* setter);
9833
9834   inline bool Equals(AccessorPair* pair);
9835   inline bool Equals(Object* getter_value, Object* setter_value);
9836
9837   inline bool ContainsAccessor();
9838
9839   // Dispatched behavior.
9840   DECLARE_PRINTER(AccessorPair)
9841   DECLARE_VERIFIER(AccessorPair)
9842
9843   static const int kGetterOffset = HeapObject::kHeaderSize;
9844   static const int kSetterOffset = kGetterOffset + kPointerSize;
9845   static const int kSize = kSetterOffset + kPointerSize;
9846
9847  private:
9848   // Strangely enough, in addition to functions and harmony proxies, the spec
9849   // requires us to consider undefined as a kind of accessor, too:
9850   //    var obj = {};
9851   //    Object.defineProperty(obj, "foo", {get: undefined});
9852   //    assertTrue("foo" in obj);
9853   inline bool IsJSAccessor(Object* obj);
9854
9855   DISALLOW_IMPLICIT_CONSTRUCTORS(AccessorPair);
9856 };
9857
9858
9859 class AccessCheckInfo: public Struct {
9860  public:
9861   DECL_ACCESSORS(named_callback, Object)
9862   DECL_ACCESSORS(indexed_callback, Object)
9863   DECL_ACCESSORS(data, Object)
9864
9865   DECLARE_CAST(AccessCheckInfo)
9866
9867   // Dispatched behavior.
9868   DECLARE_PRINTER(AccessCheckInfo)
9869   DECLARE_VERIFIER(AccessCheckInfo)
9870
9871   static const int kNamedCallbackOffset   = HeapObject::kHeaderSize;
9872   static const int kIndexedCallbackOffset = kNamedCallbackOffset + kPointerSize;
9873   static const int kDataOffset = kIndexedCallbackOffset + kPointerSize;
9874   static const int kSize = kDataOffset + kPointerSize;
9875
9876  private:
9877   DISALLOW_IMPLICIT_CONSTRUCTORS(AccessCheckInfo);
9878 };
9879
9880
9881 class InterceptorInfo: public Struct {
9882  public:
9883   DECL_ACCESSORS(getter, Object)
9884   DECL_ACCESSORS(setter, Object)
9885   DECL_ACCESSORS(query, Object)
9886   DECL_ACCESSORS(deleter, Object)
9887   DECL_ACCESSORS(enumerator, Object)
9888   DECL_ACCESSORS(data, Object)
9889   DECL_BOOLEAN_ACCESSORS(can_intercept_symbols)
9890   DECL_BOOLEAN_ACCESSORS(all_can_read)
9891   DECL_BOOLEAN_ACCESSORS(non_masking)
9892
9893   inline int flags() const;
9894   inline void set_flags(int flags);
9895
9896   DECLARE_CAST(InterceptorInfo)
9897
9898   // Dispatched behavior.
9899   DECLARE_PRINTER(InterceptorInfo)
9900   DECLARE_VERIFIER(InterceptorInfo)
9901
9902   static const int kGetterOffset = HeapObject::kHeaderSize;
9903   static const int kSetterOffset = kGetterOffset + kPointerSize;
9904   static const int kQueryOffset = kSetterOffset + kPointerSize;
9905   static const int kDeleterOffset = kQueryOffset + kPointerSize;
9906   static const int kEnumeratorOffset = kDeleterOffset + kPointerSize;
9907   static const int kDataOffset = kEnumeratorOffset + kPointerSize;
9908   static const int kFlagsOffset = kDataOffset + kPointerSize;
9909   static const int kSize = kFlagsOffset + kPointerSize;
9910
9911   static const int kCanInterceptSymbolsBit = 0;
9912   static const int kAllCanReadBit = 1;
9913   static const int kNonMasking = 2;
9914
9915  private:
9916   DISALLOW_IMPLICIT_CONSTRUCTORS(InterceptorInfo);
9917 };
9918
9919
9920 class CallHandlerInfo: public Struct {
9921  public:
9922   DECL_ACCESSORS(callback, Object)
9923   DECL_ACCESSORS(data, Object)
9924
9925   DECLARE_CAST(CallHandlerInfo)
9926
9927   // Dispatched behavior.
9928   DECLARE_PRINTER(CallHandlerInfo)
9929   DECLARE_VERIFIER(CallHandlerInfo)
9930
9931   static const int kCallbackOffset = HeapObject::kHeaderSize;
9932   static const int kDataOffset = kCallbackOffset + kPointerSize;
9933   static const int kSize = kDataOffset + kPointerSize;
9934
9935  private:
9936   DISALLOW_IMPLICIT_CONSTRUCTORS(CallHandlerInfo);
9937 };
9938
9939
9940 class TemplateInfo: public Struct {
9941  public:
9942   DECL_ACCESSORS(tag, Object)
9943   inline int number_of_properties() const;
9944   inline void set_number_of_properties(int value);
9945   DECL_ACCESSORS(property_list, Object)
9946   DECL_ACCESSORS(property_accessors, Object)
9947
9948   DECLARE_VERIFIER(TemplateInfo)
9949
9950   static const int kTagOffset = HeapObject::kHeaderSize;
9951   static const int kNumberOfProperties = kTagOffset + kPointerSize;
9952   static const int kPropertyListOffset = kNumberOfProperties + kPointerSize;
9953   static const int kPropertyAccessorsOffset =
9954       kPropertyListOffset + kPointerSize;
9955   static const int kHeaderSize = kPropertyAccessorsOffset + kPointerSize;
9956
9957  private:
9958   DISALLOW_IMPLICIT_CONSTRUCTORS(TemplateInfo);
9959 };
9960
9961
9962 class FunctionTemplateInfo: public TemplateInfo {
9963  public:
9964   DECL_ACCESSORS(serial_number, Object)
9965   DECL_ACCESSORS(call_code, Object)
9966   DECL_ACCESSORS(prototype_template, Object)
9967   DECL_ACCESSORS(parent_template, Object)
9968   DECL_ACCESSORS(named_property_handler, Object)
9969   DECL_ACCESSORS(indexed_property_handler, Object)
9970   DECL_ACCESSORS(instance_template, Object)
9971   DECL_ACCESSORS(class_name, Object)
9972   DECL_ACCESSORS(signature, Object)
9973   DECL_ACCESSORS(instance_call_handler, Object)
9974   DECL_ACCESSORS(access_check_info, Object)
9975   DECL_ACCESSORS(flag, Smi)
9976
9977   inline int length() const;
9978   inline void set_length(int value);
9979
9980   // Following properties use flag bits.
9981   DECL_BOOLEAN_ACCESSORS(hidden_prototype)
9982   DECL_BOOLEAN_ACCESSORS(undetectable)
9983   // If the bit is set, object instances created by this function
9984   // requires access check.
9985   DECL_BOOLEAN_ACCESSORS(needs_access_check)
9986   DECL_BOOLEAN_ACCESSORS(read_only_prototype)
9987   DECL_BOOLEAN_ACCESSORS(remove_prototype)
9988   DECL_BOOLEAN_ACCESSORS(do_not_cache)
9989   DECL_BOOLEAN_ACCESSORS(instantiated)
9990   DECL_BOOLEAN_ACCESSORS(accept_any_receiver)
9991
9992   DECLARE_CAST(FunctionTemplateInfo)
9993
9994   // Dispatched behavior.
9995   DECLARE_PRINTER(FunctionTemplateInfo)
9996   DECLARE_VERIFIER(FunctionTemplateInfo)
9997
9998   static const int kSerialNumberOffset = TemplateInfo::kHeaderSize;
9999   static const int kCallCodeOffset = kSerialNumberOffset + kPointerSize;
10000   static const int kPrototypeTemplateOffset =
10001       kCallCodeOffset + kPointerSize;
10002   static const int kParentTemplateOffset =
10003       kPrototypeTemplateOffset + kPointerSize;
10004   static const int kNamedPropertyHandlerOffset =
10005       kParentTemplateOffset + kPointerSize;
10006   static const int kIndexedPropertyHandlerOffset =
10007       kNamedPropertyHandlerOffset + kPointerSize;
10008   static const int kInstanceTemplateOffset =
10009       kIndexedPropertyHandlerOffset + kPointerSize;
10010   static const int kClassNameOffset = kInstanceTemplateOffset + kPointerSize;
10011   static const int kSignatureOffset = kClassNameOffset + kPointerSize;
10012   static const int kInstanceCallHandlerOffset = kSignatureOffset + kPointerSize;
10013   static const int kAccessCheckInfoOffset =
10014       kInstanceCallHandlerOffset + kPointerSize;
10015   static const int kFlagOffset = kAccessCheckInfoOffset + kPointerSize;
10016   static const int kLengthOffset = kFlagOffset + kPointerSize;
10017   static const int kSize = kLengthOffset + kPointerSize;
10018
10019   // Returns true if |object| is an instance of this function template.
10020   bool IsTemplateFor(Object* object);
10021   bool IsTemplateFor(Map* map);
10022
10023   // Returns the holder JSObject if the function can legally be called with this
10024   // receiver.  Returns Heap::null_value() if the call is illegal.
10025   Object* GetCompatibleReceiver(Isolate* isolate, Object* receiver);
10026
10027  private:
10028   // Bit position in the flag, from least significant bit position.
10029   static const int kHiddenPrototypeBit   = 0;
10030   static const int kUndetectableBit      = 1;
10031   static const int kNeedsAccessCheckBit  = 2;
10032   static const int kReadOnlyPrototypeBit = 3;
10033   static const int kRemovePrototypeBit   = 4;
10034   static const int kDoNotCacheBit        = 5;
10035   static const int kInstantiatedBit      = 6;
10036   static const int kAcceptAnyReceiver = 7;
10037
10038   DISALLOW_IMPLICIT_CONSTRUCTORS(FunctionTemplateInfo);
10039 };
10040
10041
10042 class ObjectTemplateInfo: public TemplateInfo {
10043  public:
10044   DECL_ACCESSORS(constructor, Object)
10045   DECL_ACCESSORS(internal_field_count, Object)
10046
10047   DECLARE_CAST(ObjectTemplateInfo)
10048
10049   // Dispatched behavior.
10050   DECLARE_PRINTER(ObjectTemplateInfo)
10051   DECLARE_VERIFIER(ObjectTemplateInfo)
10052
10053   static const int kConstructorOffset = TemplateInfo::kHeaderSize;
10054   static const int kInternalFieldCountOffset =
10055       kConstructorOffset + kPointerSize;
10056   static const int kSize = kInternalFieldCountOffset + kPointerSize;
10057 };
10058
10059
10060 class TypeSwitchInfo: public Struct {
10061  public:
10062   DECL_ACCESSORS(types, Object)
10063
10064   DECLARE_CAST(TypeSwitchInfo)
10065
10066   // Dispatched behavior.
10067   DECLARE_PRINTER(TypeSwitchInfo)
10068   DECLARE_VERIFIER(TypeSwitchInfo)
10069
10070   static const int kTypesOffset = Struct::kHeaderSize;
10071   static const int kSize        = kTypesOffset + kPointerSize;
10072 };
10073
10074
10075 // The DebugInfo class holds additional information for a function being
10076 // debugged.
10077 class DebugInfo: public Struct {
10078  public:
10079   // The shared function info for the source being debugged.
10080   DECL_ACCESSORS(shared, SharedFunctionInfo)
10081   // Code object for the patched code. This code object is the code object
10082   // currently active for the function.
10083   DECL_ACCESSORS(code, Code)
10084   // Fixed array holding status information for each active break point.
10085   DECL_ACCESSORS(break_points, FixedArray)
10086
10087   // Check if there is a break point at a code position.
10088   bool HasBreakPoint(int code_position);
10089   // Get the break point info object for a code position.
10090   Object* GetBreakPointInfo(int code_position);
10091   // Clear a break point.
10092   static void ClearBreakPoint(Handle<DebugInfo> debug_info,
10093                               int code_position,
10094                               Handle<Object> break_point_object);
10095   // Set a break point.
10096   static void SetBreakPoint(Handle<DebugInfo> debug_info, int code_position,
10097                             int source_position, int statement_position,
10098                             Handle<Object> break_point_object);
10099   // Get the break point objects for a code position.
10100   Handle<Object> GetBreakPointObjects(int code_position);
10101   // Find the break point info holding this break point object.
10102   static Handle<Object> FindBreakPointInfo(Handle<DebugInfo> debug_info,
10103                                            Handle<Object> break_point_object);
10104   // Get the number of break points for this function.
10105   int GetBreakPointCount();
10106
10107   DECLARE_CAST(DebugInfo)
10108
10109   // Dispatched behavior.
10110   DECLARE_PRINTER(DebugInfo)
10111   DECLARE_VERIFIER(DebugInfo)
10112
10113   static const int kSharedFunctionInfoIndex = Struct::kHeaderSize;
10114   static const int kCodeIndex = kSharedFunctionInfoIndex + kPointerSize;
10115   static const int kBreakPointsStateIndex = kCodeIndex + kPointerSize;
10116   static const int kSize = kBreakPointsStateIndex + kPointerSize;
10117
10118   static const int kEstimatedNofBreakPointsInFunction = 16;
10119
10120  private:
10121   static const int kNoBreakPointInfo = -1;
10122
10123   // Lookup the index in the break_points array for a code position.
10124   int GetBreakPointInfoIndex(int code_position);
10125
10126   DISALLOW_IMPLICIT_CONSTRUCTORS(DebugInfo);
10127 };
10128
10129
10130 // The BreakPointInfo class holds information for break points set in a
10131 // function. The DebugInfo object holds a BreakPointInfo object for each code
10132 // position with one or more break points.
10133 class BreakPointInfo: public Struct {
10134  public:
10135   // The position in the code for the break point.
10136   DECL_ACCESSORS(code_position, Smi)
10137   // The position in the source for the break position.
10138   DECL_ACCESSORS(source_position, Smi)
10139   // The position in the source for the last statement before this break
10140   // position.
10141   DECL_ACCESSORS(statement_position, Smi)
10142   // List of related JavaScript break points.
10143   DECL_ACCESSORS(break_point_objects, Object)
10144
10145   // Removes a break point.
10146   static void ClearBreakPoint(Handle<BreakPointInfo> info,
10147                               Handle<Object> break_point_object);
10148   // Set a break point.
10149   static void SetBreakPoint(Handle<BreakPointInfo> info,
10150                             Handle<Object> break_point_object);
10151   // Check if break point info has this break point object.
10152   static bool HasBreakPointObject(Handle<BreakPointInfo> info,
10153                                   Handle<Object> break_point_object);
10154   // Get the number of break points for this code position.
10155   int GetBreakPointCount();
10156
10157   DECLARE_CAST(BreakPointInfo)
10158
10159   // Dispatched behavior.
10160   DECLARE_PRINTER(BreakPointInfo)
10161   DECLARE_VERIFIER(BreakPointInfo)
10162
10163   static const int kCodePositionIndex = Struct::kHeaderSize;
10164   static const int kSourcePositionIndex = kCodePositionIndex + kPointerSize;
10165   static const int kStatementPositionIndex =
10166       kSourcePositionIndex + kPointerSize;
10167   static const int kBreakPointObjectsIndex =
10168       kStatementPositionIndex + kPointerSize;
10169   static const int kSize = kBreakPointObjectsIndex + kPointerSize;
10170
10171  private:
10172   DISALLOW_IMPLICIT_CONSTRUCTORS(BreakPointInfo);
10173 };
10174
10175
10176 #undef DECL_BOOLEAN_ACCESSORS
10177 #undef DECL_ACCESSORS
10178 #undef DECLARE_CAST
10179 #undef DECLARE_VERIFIER
10180
10181 #define VISITOR_SYNCHRONIZATION_TAGS_LIST(V)                               \
10182   V(kStringTable, "string_table", "(Internalized strings)")                \
10183   V(kExternalStringsTable, "external_strings_table", "(External strings)") \
10184   V(kStrongRootList, "strong_root_list", "(Strong roots)")                 \
10185   V(kSmiRootList, "smi_root_list", "(Smi roots)")                          \
10186   V(kBootstrapper, "bootstrapper", "(Bootstrapper)")                       \
10187   V(kTop, "top", "(Isolate)")                                              \
10188   V(kRelocatable, "relocatable", "(Relocatable)")                          \
10189   V(kDebug, "debug", "(Debugger)")                                         \
10190   V(kCompilationCache, "compilationcache", "(Compilation cache)")          \
10191   V(kHandleScope, "handlescope", "(Handle scope)")                         \
10192   V(kBuiltins, "builtins", "(Builtins)")                                   \
10193   V(kGlobalHandles, "globalhandles", "(Global handles)")                   \
10194   V(kEternalHandles, "eternalhandles", "(Eternal handles)")                \
10195   V(kThreadManager, "threadmanager", "(Thread manager)")                   \
10196   V(kStrongRoots, "strong roots", "(Strong roots)")                        \
10197   V(kExtensions, "Extensions", "(Extensions)")
10198
10199 class VisitorSynchronization : public AllStatic {
10200  public:
10201 #define DECLARE_ENUM(enum_item, ignore1, ignore2) enum_item,
10202   enum SyncTag {
10203     VISITOR_SYNCHRONIZATION_TAGS_LIST(DECLARE_ENUM)
10204     kNumberOfSyncTags
10205   };
10206 #undef DECLARE_ENUM
10207
10208   static const char* const kTags[kNumberOfSyncTags];
10209   static const char* const kTagNames[kNumberOfSyncTags];
10210 };
10211
10212 // Abstract base class for visiting, and optionally modifying, the
10213 // pointers contained in Objects. Used in GC and serialization/deserialization.
10214 class ObjectVisitor BASE_EMBEDDED {
10215  public:
10216   virtual ~ObjectVisitor() {}
10217
10218   // Visits a contiguous arrays of pointers in the half-open range
10219   // [start, end). Any or all of the values may be modified on return.
10220   virtual void VisitPointers(Object** start, Object** end) = 0;
10221
10222   // Handy shorthand for visiting a single pointer.
10223   virtual void VisitPointer(Object** p) { VisitPointers(p, p + 1); }
10224
10225   // Visit weak next_code_link in Code object.
10226   virtual void VisitNextCodeLink(Object** p) { VisitPointers(p, p + 1); }
10227
10228   // To allow lazy clearing of inline caches the visitor has
10229   // a rich interface for iterating over Code objects..
10230
10231   // Visits a code target in the instruction stream.
10232   virtual void VisitCodeTarget(RelocInfo* rinfo);
10233
10234   // Visits a code entry in a JS function.
10235   virtual void VisitCodeEntry(Address entry_address);
10236
10237   // Visits a global property cell reference in the instruction stream.
10238   virtual void VisitCell(RelocInfo* rinfo);
10239
10240   // Visits a runtime entry in the instruction stream.
10241   virtual void VisitRuntimeEntry(RelocInfo* rinfo) {}
10242
10243   // Visits the resource of an one-byte or two-byte string.
10244   virtual void VisitExternalOneByteString(
10245       v8::String::ExternalOneByteStringResource** resource) {}
10246   virtual void VisitExternalTwoByteString(
10247       v8::String::ExternalStringResource** resource) {}
10248
10249   // Visits a debug call target in the instruction stream.
10250   virtual void VisitDebugTarget(RelocInfo* rinfo);
10251
10252   // Visits the byte sequence in a function's prologue that contains information
10253   // about the code's age.
10254   virtual void VisitCodeAgeSequence(RelocInfo* rinfo);
10255
10256   // Visit pointer embedded into a code object.
10257   virtual void VisitEmbeddedPointer(RelocInfo* rinfo);
10258
10259   // Visits an external reference embedded into a code object.
10260   virtual void VisitExternalReference(RelocInfo* rinfo);
10261
10262   // Visits an external reference.
10263   virtual void VisitExternalReference(Address* p) {}
10264
10265   // Visits an (encoded) internal reference.
10266   virtual void VisitInternalReference(RelocInfo* rinfo) {}
10267
10268   // Visits a handle that has an embedder-assigned class ID.
10269   virtual void VisitEmbedderReference(Object** p, uint16_t class_id) {}
10270
10271   // Intended for serialization/deserialization checking: insert, or
10272   // check for the presence of, a tag at this position in the stream.
10273   // Also used for marking up GC roots in heap snapshots.
10274   virtual void Synchronize(VisitorSynchronization::SyncTag tag) {}
10275 };
10276
10277
10278 class StructBodyDescriptor : public
10279   FlexibleBodyDescriptor<HeapObject::kHeaderSize> {
10280  public:
10281   static inline int SizeOf(Map* map, HeapObject* object);
10282 };
10283
10284
10285 // BooleanBit is a helper class for setting and getting a bit in an
10286 // integer or Smi.
10287 class BooleanBit : public AllStatic {
10288  public:
10289   static inline bool get(Smi* smi, int bit_position) {
10290     return get(smi->value(), bit_position);
10291   }
10292
10293   static inline bool get(int value, int bit_position) {
10294     return (value & (1 << bit_position)) != 0;
10295   }
10296
10297   static inline Smi* set(Smi* smi, int bit_position, bool v) {
10298     return Smi::FromInt(set(smi->value(), bit_position, v));
10299   }
10300
10301   static inline int set(int value, int bit_position, bool v) {
10302     if (v) {
10303       value |= (1 << bit_position);
10304     } else {
10305       value &= ~(1 << bit_position);
10306     }
10307     return value;
10308   }
10309 };
10310
10311 } }  // namespace v8::internal
10312
10313 #endif  // V8_OBJECTS_H_