src/objects.h

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