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