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