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