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