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