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