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