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