src/objects.h

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