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