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