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