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