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