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.
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"
21 #include "src/property-details.h"
22 #include "src/unicode.h"
23 #include "src/unicode-decoder.h"
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
40 // Most object types in the V8 JavaScript are described in this file.
42 // Inheritance hierarchy:
44 // - Smi (immediate small integer)
45 // - HeapObject (superclass for everything allocated in the heap)
46 // - JSReceiver (suitable for property access)
50 // - JSArrayBufferView
63 // - JSGeneratorObject
82 // - CompilationCacheTable
83 // - CodeCacheHashTable
89 // - TypeFeedbackVector
92 // - ScriptContextTable
103 // - ExternalOneByteString
104 // - ExternalTwoByteString
105 // - InternalizedString
106 // - SeqInternalizedString
107 // - SeqOneByteInternalizedString
108 // - SeqTwoByteInternalizedString
109 // - ConsInternalizedString
110 // - ExternalInternalizedString
111 // - ExternalOneByteInternalizedString
112 // - ExternalTwoByteInternalizedString
132 // - SharedFunctionInfo
136 // - ExecutableAccessorInfo
142 // - FunctionTemplateInfo
143 // - ObjectTemplateInfo
152 // Formats of Object*:
153 // Smi: [31 bit signed int] 0
154 // HeapObject: [32 bit direct pointer] (4 byte aligned) | 01
159 enum KeyedAccessStoreMode {
161 STORE_TRANSITION_TO_OBJECT,
162 STORE_TRANSITION_TO_DOUBLE,
163 STORE_AND_GROW_NO_TRANSITION,
164 STORE_AND_GROW_TRANSITION_TO_OBJECT,
165 STORE_AND_GROW_TRANSITION_TO_DOUBLE,
166 STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS,
167 STORE_NO_TRANSITION_HANDLE_COW
171 // Valid hints for the abstract operation ToPrimitive,
172 // implemented according to ES6, section 7.1.1.
173 enum class ToPrimitiveHint { kDefault, kNumber, kString };
176 // Valid hints for the abstract operation OrdinaryToPrimitive,
177 // implemented according to ES6, section 7.1.1.
178 enum class OrdinaryToPrimitiveHint { kNumber, kString };
181 enum TypeofMode { INSIDE_TYPEOF, NOT_INSIDE_TYPEOF };
190 enum ExternalArrayType {
191 kExternalInt8Array = 1,
194 kExternalUint16Array,
196 kExternalUint32Array,
197 kExternalFloat32Array,
198 kExternalFloat64Array,
199 kExternalUint8ClampedArray,
203 static inline bool IsTransitionStoreMode(KeyedAccessStoreMode store_mode) {
204 return store_mode == STORE_TRANSITION_TO_OBJECT ||
205 store_mode == STORE_TRANSITION_TO_DOUBLE ||
206 store_mode == STORE_AND_GROW_TRANSITION_TO_OBJECT ||
207 store_mode == STORE_AND_GROW_TRANSITION_TO_DOUBLE;
211 static inline KeyedAccessStoreMode GetNonTransitioningStoreMode(
212 KeyedAccessStoreMode store_mode) {
213 if (store_mode >= STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS) {
216 if (store_mode >= STORE_AND_GROW_NO_TRANSITION) {
217 return STORE_AND_GROW_NO_TRANSITION;
219 return STANDARD_STORE;
223 static inline bool IsGrowStoreMode(KeyedAccessStoreMode store_mode) {
224 return store_mode >= STORE_AND_GROW_NO_TRANSITION &&
225 store_mode <= STORE_AND_GROW_TRANSITION_TO_DOUBLE;
229 enum IcCheckType { ELEMENT, PROPERTY };
232 // SKIP_WRITE_BARRIER skips the write barrier.
233 // UPDATE_WEAK_WRITE_BARRIER skips the marking part of the write barrier and
234 // only performs the generational part.
235 // UPDATE_WRITE_BARRIER is doing the full barrier, marking and generational.
236 enum WriteBarrierMode {
238 UPDATE_WEAK_WRITE_BARRIER,
243 // Indicates whether a value can be loaded as a constant.
244 enum StoreMode { ALLOW_IN_DESCRIPTOR, FORCE_FIELD };
247 // PropertyNormalizationMode is used to specify whether to keep
248 // inobject properties when normalizing properties of a JSObject.
249 enum PropertyNormalizationMode {
250 CLEAR_INOBJECT_PROPERTIES,
251 KEEP_INOBJECT_PROPERTIES
255 // Indicates how aggressively the prototype should be optimized. FAST_PROTOTYPE
256 // will give the fastest result by tailoring the map to the prototype, but that
257 // will cause polymorphism with other objects. REGULAR_PROTOTYPE is to be used
258 // (at least for now) when dynamically modifying the prototype chain of an
259 // object using __proto__ or Object.setPrototypeOf.
260 enum PrototypeOptimizationMode { REGULAR_PROTOTYPE, FAST_PROTOTYPE };
263 // Indicates whether transitions can be added to a source map or not.
264 enum TransitionFlag {
270 // Indicates whether the transition is simple: the target map of the transition
271 // either extends the current map with a new property, or it modifies the
272 // property that was added last to the current map.
273 enum SimpleTransitionFlag {
274 SIMPLE_PROPERTY_TRANSITION,
280 // Indicates whether we are only interested in the descriptors of a particular
281 // map, or in all descriptors in the descriptor array.
282 enum DescriptorFlag {
287 // The GC maintains a bit of information, the MarkingParity, which toggles
288 // from odd to even and back every time marking is completed. Incremental
289 // marking can visit an object twice during a marking phase, so algorithms that
290 // that piggy-back on marking can use the parity to ensure that they only
291 // perform an operation on an object once per marking phase: they record the
292 // MarkingParity when they visit an object, and only re-visit the object when it
293 // is marked again and the MarkingParity changes.
300 // ICs store extra state in a Code object. The default extra state is
302 typedef int ExtraICState;
303 static const ExtraICState kNoExtraICState = 0;
305 // Instance size sentinel for objects of variable size.
306 const int kVariableSizeSentinel = 0;
308 // We may store the unsigned bit field as signed Smi value and do not
310 const int kStubMajorKeyBits = 7;
311 const int kStubMinorKeyBits = kSmiValueSize - kStubMajorKeyBits - 1;
313 // All Maps have a field instance_type containing a InstanceType.
314 // It describes the type of the instances.
316 // As an example, a JavaScript object is a heap object and its map
317 // instance_type is JS_OBJECT_TYPE.
319 // The names of the string instance types are intended to systematically
320 // mirror their encoding in the instance_type field of the map. The default
321 // encoding is considered TWO_BYTE. It is not mentioned in the name. ONE_BYTE
322 // encoding is mentioned explicitly in the name. Likewise, the default
323 // representation is considered sequential. It is not mentioned in the
324 // name. The other representations (e.g. CONS, EXTERNAL) are explicitly
325 // mentioned. Finally, the string is either a STRING_TYPE (if it is a normal
326 // string) or a INTERNALIZED_STRING_TYPE (if it is a internalized string).
328 // NOTE: The following things are some that depend on the string types having
329 // instance_types that are less than those of all other types:
330 // HeapObject::Size, HeapObject::IterateBody, the typeof operator, and
333 // NOTE: Everything following JS_VALUE_TYPE is considered a
334 // JSObject for GC purposes. The first four entries here have typeof
335 // 'object', whereas JS_FUNCTION_TYPE has typeof 'function'.
336 #define INSTANCE_TYPE_LIST(V) \
338 V(ONE_BYTE_STRING_TYPE) \
339 V(CONS_STRING_TYPE) \
340 V(CONS_ONE_BYTE_STRING_TYPE) \
341 V(SLICED_STRING_TYPE) \
342 V(SLICED_ONE_BYTE_STRING_TYPE) \
343 V(EXTERNAL_STRING_TYPE) \
344 V(EXTERNAL_ONE_BYTE_STRING_TYPE) \
345 V(EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE) \
346 V(SHORT_EXTERNAL_STRING_TYPE) \
347 V(SHORT_EXTERNAL_ONE_BYTE_STRING_TYPE) \
348 V(SHORT_EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE) \
350 V(INTERNALIZED_STRING_TYPE) \
351 V(ONE_BYTE_INTERNALIZED_STRING_TYPE) \
352 V(EXTERNAL_INTERNALIZED_STRING_TYPE) \
353 V(EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE) \
354 V(EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE) \
355 V(SHORT_EXTERNAL_INTERNALIZED_STRING_TYPE) \
356 V(SHORT_EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE) \
357 V(SHORT_EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE) \
360 V(SIMD128_VALUE_TYPE) \
366 V(PROPERTY_CELL_TYPE) \
368 V(HEAP_NUMBER_TYPE) \
369 V(MUTABLE_HEAP_NUMBER_TYPE) \
372 V(BYTECODE_ARRAY_TYPE) \
375 V(FIXED_INT8_ARRAY_TYPE) \
376 V(FIXED_UINT8_ARRAY_TYPE) \
377 V(FIXED_INT16_ARRAY_TYPE) \
378 V(FIXED_UINT16_ARRAY_TYPE) \
379 V(FIXED_INT32_ARRAY_TYPE) \
380 V(FIXED_UINT32_ARRAY_TYPE) \
381 V(FIXED_FLOAT32_ARRAY_TYPE) \
382 V(FIXED_FLOAT64_ARRAY_TYPE) \
383 V(FIXED_UINT8_CLAMPED_ARRAY_TYPE) \
387 V(DECLARED_ACCESSOR_DESCRIPTOR_TYPE) \
388 V(DECLARED_ACCESSOR_INFO_TYPE) \
389 V(EXECUTABLE_ACCESSOR_INFO_TYPE) \
390 V(ACCESSOR_PAIR_TYPE) \
391 V(ACCESS_CHECK_INFO_TYPE) \
392 V(INTERCEPTOR_INFO_TYPE) \
393 V(CALL_HANDLER_INFO_TYPE) \
394 V(FUNCTION_TEMPLATE_INFO_TYPE) \
395 V(OBJECT_TEMPLATE_INFO_TYPE) \
396 V(SIGNATURE_INFO_TYPE) \
397 V(TYPE_SWITCH_INFO_TYPE) \
398 V(ALLOCATION_MEMENTO_TYPE) \
399 V(ALLOCATION_SITE_TYPE) \
402 V(POLYMORPHIC_CODE_CACHE_TYPE) \
403 V(TYPE_FEEDBACK_INFO_TYPE) \
404 V(ALIASED_ARGUMENTS_ENTRY_TYPE) \
406 V(PROTOTYPE_INFO_TYPE) \
407 V(SLOPPY_BLOCK_WITH_EVAL_CONTEXT_EXTENSION_TYPE) \
409 V(FIXED_ARRAY_TYPE) \
410 V(FIXED_DOUBLE_ARRAY_TYPE) \
411 V(SHARED_FUNCTION_INFO_TYPE) \
414 V(JS_MESSAGE_OBJECT_TYPE) \
419 V(JS_CONTEXT_EXTENSION_OBJECT_TYPE) \
420 V(JS_GENERATOR_OBJECT_TYPE) \
422 V(JS_GLOBAL_OBJECT_TYPE) \
423 V(JS_BUILTINS_OBJECT_TYPE) \
424 V(JS_GLOBAL_PROXY_TYPE) \
426 V(JS_ARRAY_BUFFER_TYPE) \
427 V(JS_TYPED_ARRAY_TYPE) \
428 V(JS_DATA_VIEW_TYPE) \
432 V(JS_SET_ITERATOR_TYPE) \
433 V(JS_MAP_ITERATOR_TYPE) \
434 V(JS_ITERATOR_RESULT_TYPE) \
435 V(JS_WEAK_MAP_TYPE) \
436 V(JS_WEAK_SET_TYPE) \
439 V(JS_FUNCTION_TYPE) \
440 V(JS_FUNCTION_PROXY_TYPE) \
442 V(BREAK_POINT_INFO_TYPE)
445 // Since string types are not consecutive, this macro is used to
446 // iterate over them.
447 #define STRING_TYPE_LIST(V) \
448 V(STRING_TYPE, kVariableSizeSentinel, string, String) \
449 V(ONE_BYTE_STRING_TYPE, kVariableSizeSentinel, one_byte_string, \
451 V(CONS_STRING_TYPE, ConsString::kSize, cons_string, ConsString) \
452 V(CONS_ONE_BYTE_STRING_TYPE, ConsString::kSize, cons_one_byte_string, \
454 V(SLICED_STRING_TYPE, SlicedString::kSize, sliced_string, SlicedString) \
455 V(SLICED_ONE_BYTE_STRING_TYPE, SlicedString::kSize, sliced_one_byte_string, \
456 SlicedOneByteString) \
457 V(EXTERNAL_STRING_TYPE, ExternalTwoByteString::kSize, external_string, \
459 V(EXTERNAL_ONE_BYTE_STRING_TYPE, ExternalOneByteString::kSize, \
460 external_one_byte_string, ExternalOneByteString) \
461 V(EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE, ExternalTwoByteString::kSize, \
462 external_string_with_one_byte_data, ExternalStringWithOneByteData) \
463 V(SHORT_EXTERNAL_STRING_TYPE, ExternalTwoByteString::kShortSize, \
464 short_external_string, ShortExternalString) \
465 V(SHORT_EXTERNAL_ONE_BYTE_STRING_TYPE, ExternalOneByteString::kShortSize, \
466 short_external_one_byte_string, ShortExternalOneByteString) \
467 V(SHORT_EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE, \
468 ExternalTwoByteString::kShortSize, \
469 short_external_string_with_one_byte_data, \
470 ShortExternalStringWithOneByteData) \
472 V(INTERNALIZED_STRING_TYPE, kVariableSizeSentinel, internalized_string, \
473 InternalizedString) \
474 V(ONE_BYTE_INTERNALIZED_STRING_TYPE, kVariableSizeSentinel, \
475 one_byte_internalized_string, OneByteInternalizedString) \
476 V(EXTERNAL_INTERNALIZED_STRING_TYPE, ExternalTwoByteString::kSize, \
477 external_internalized_string, ExternalInternalizedString) \
478 V(EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE, ExternalOneByteString::kSize, \
479 external_one_byte_internalized_string, ExternalOneByteInternalizedString) \
480 V(EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE, \
481 ExternalTwoByteString::kSize, \
482 external_internalized_string_with_one_byte_data, \
483 ExternalInternalizedStringWithOneByteData) \
484 V(SHORT_EXTERNAL_INTERNALIZED_STRING_TYPE, \
485 ExternalTwoByteString::kShortSize, short_external_internalized_string, \
486 ShortExternalInternalizedString) \
487 V(SHORT_EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE, \
488 ExternalOneByteString::kShortSize, \
489 short_external_one_byte_internalized_string, \
490 ShortExternalOneByteInternalizedString) \
491 V(SHORT_EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE, \
492 ExternalTwoByteString::kShortSize, \
493 short_external_internalized_string_with_one_byte_data, \
494 ShortExternalInternalizedStringWithOneByteData)
496 // A struct is a simple object a set of object-valued fields. Including an
497 // object type in this causes the compiler to generate most of the boilerplate
498 // code for the class including allocation and garbage collection routines,
499 // casts and predicates. All you need to define is the class, methods and
500 // object verification routines. Easy, no?
502 // Note that for subtle reasons related to the ordering or numerical values of
503 // type tags, elements in this list have to be added to the INSTANCE_TYPE_LIST
505 #define STRUCT_LIST(V) \
507 V(EXECUTABLE_ACCESSOR_INFO, ExecutableAccessorInfo, \
508 executable_accessor_info) \
509 V(ACCESSOR_PAIR, AccessorPair, accessor_pair) \
510 V(ACCESS_CHECK_INFO, AccessCheckInfo, access_check_info) \
511 V(INTERCEPTOR_INFO, InterceptorInfo, interceptor_info) \
512 V(CALL_HANDLER_INFO, CallHandlerInfo, call_handler_info) \
513 V(FUNCTION_TEMPLATE_INFO, FunctionTemplateInfo, function_template_info) \
514 V(OBJECT_TEMPLATE_INFO, ObjectTemplateInfo, object_template_info) \
515 V(TYPE_SWITCH_INFO, TypeSwitchInfo, type_switch_info) \
516 V(SCRIPT, Script, script) \
517 V(ALLOCATION_SITE, AllocationSite, allocation_site) \
518 V(ALLOCATION_MEMENTO, AllocationMemento, allocation_memento) \
519 V(CODE_CACHE, CodeCache, code_cache) \
520 V(POLYMORPHIC_CODE_CACHE, PolymorphicCodeCache, polymorphic_code_cache) \
521 V(TYPE_FEEDBACK_INFO, TypeFeedbackInfo, type_feedback_info) \
522 V(ALIASED_ARGUMENTS_ENTRY, AliasedArgumentsEntry, aliased_arguments_entry) \
523 V(DEBUG_INFO, DebugInfo, debug_info) \
524 V(BREAK_POINT_INFO, BreakPointInfo, break_point_info) \
525 V(PROTOTYPE_INFO, PrototypeInfo, prototype_info) \
526 V(SLOPPY_BLOCK_WITH_EVAL_CONTEXT_EXTENSION, \
527 SloppyBlockWithEvalContextExtension, \
528 sloppy_block_with_eval_context_extension)
530 // We use the full 8 bits of the instance_type field to encode heap object
531 // instance types. The high-order bit (bit 7) is set if the object is not a
532 // string, and cleared if it is a string.
533 const uint32_t kIsNotStringMask = 0x80;
534 const uint32_t kStringTag = 0x0;
535 const uint32_t kNotStringTag = 0x80;
537 // Bit 6 indicates that the object is an internalized string (if set) or not.
538 // Bit 7 has to be clear as well.
539 const uint32_t kIsNotInternalizedMask = 0x40;
540 const uint32_t kNotInternalizedTag = 0x40;
541 const uint32_t kInternalizedTag = 0x0;
543 // If bit 7 is clear then bit 2 indicates whether the string consists of
544 // two-byte characters or one-byte characters.
545 const uint32_t kStringEncodingMask = 0x4;
546 const uint32_t kTwoByteStringTag = 0x0;
547 const uint32_t kOneByteStringTag = 0x4;
549 // If bit 7 is clear, the low-order 2 bits indicate the representation
551 const uint32_t kStringRepresentationMask = 0x03;
552 enum StringRepresentationTag {
554 kConsStringTag = 0x1,
555 kExternalStringTag = 0x2,
556 kSlicedStringTag = 0x3
558 const uint32_t kIsIndirectStringMask = 0x1;
559 const uint32_t kIsIndirectStringTag = 0x1;
560 STATIC_ASSERT((kSeqStringTag & kIsIndirectStringMask) == 0); // NOLINT
561 STATIC_ASSERT((kExternalStringTag & kIsIndirectStringMask) == 0); // NOLINT
562 STATIC_ASSERT((kConsStringTag &
563 kIsIndirectStringMask) == kIsIndirectStringTag); // NOLINT
564 STATIC_ASSERT((kSlicedStringTag &
565 kIsIndirectStringMask) == kIsIndirectStringTag); // NOLINT
567 // Use this mask to distinguish between cons and slice only after making
568 // sure that the string is one of the two (an indirect string).
569 const uint32_t kSlicedNotConsMask = kSlicedStringTag & ~kConsStringTag;
570 STATIC_ASSERT(IS_POWER_OF_TWO(kSlicedNotConsMask));
572 // If bit 7 is clear, then bit 3 indicates whether this two-byte
573 // string actually contains one byte data.
574 const uint32_t kOneByteDataHintMask = 0x08;
575 const uint32_t kOneByteDataHintTag = 0x08;
577 // If bit 7 is clear and string representation indicates an external string,
578 // then bit 4 indicates whether the data pointer is cached.
579 const uint32_t kShortExternalStringMask = 0x10;
580 const uint32_t kShortExternalStringTag = 0x10;
583 // A ConsString with an empty string as the right side is a candidate
584 // for being shortcut by the garbage collector. We don't allocate any
585 // non-flat internalized strings, so we do not shortcut them thereby
586 // avoiding turning internalized strings into strings. The bit-masks
587 // below contain the internalized bit as additional safety.
588 // See heap.cc, mark-compact.cc and objects-visiting.cc.
589 const uint32_t kShortcutTypeMask =
591 kIsNotInternalizedMask |
592 kStringRepresentationMask;
593 const uint32_t kShortcutTypeTag = kConsStringTag | kNotInternalizedTag;
595 static inline bool IsShortcutCandidate(int type) {
596 return ((type & kShortcutTypeMask) == kShortcutTypeTag);
602 INTERNALIZED_STRING_TYPE = kTwoByteStringTag | kSeqStringTag |
603 kInternalizedTag, // FIRST_PRIMITIVE_TYPE
604 ONE_BYTE_INTERNALIZED_STRING_TYPE =
605 kOneByteStringTag | kSeqStringTag | kInternalizedTag,
606 EXTERNAL_INTERNALIZED_STRING_TYPE =
607 kTwoByteStringTag | kExternalStringTag | kInternalizedTag,
608 EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE =
609 kOneByteStringTag | kExternalStringTag | kInternalizedTag,
610 EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE =
611 EXTERNAL_INTERNALIZED_STRING_TYPE | kOneByteDataHintTag |
613 SHORT_EXTERNAL_INTERNALIZED_STRING_TYPE = EXTERNAL_INTERNALIZED_STRING_TYPE |
614 kShortExternalStringTag |
616 SHORT_EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE =
617 EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE | kShortExternalStringTag |
619 SHORT_EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE =
620 EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE |
621 kShortExternalStringTag | kInternalizedTag,
622 STRING_TYPE = INTERNALIZED_STRING_TYPE | kNotInternalizedTag,
623 ONE_BYTE_STRING_TYPE =
624 ONE_BYTE_INTERNALIZED_STRING_TYPE | kNotInternalizedTag,
625 CONS_STRING_TYPE = kTwoByteStringTag | kConsStringTag | kNotInternalizedTag,
626 CONS_ONE_BYTE_STRING_TYPE =
627 kOneByteStringTag | kConsStringTag | kNotInternalizedTag,
629 kTwoByteStringTag | kSlicedStringTag | kNotInternalizedTag,
630 SLICED_ONE_BYTE_STRING_TYPE =
631 kOneByteStringTag | kSlicedStringTag | kNotInternalizedTag,
632 EXTERNAL_STRING_TYPE =
633 EXTERNAL_INTERNALIZED_STRING_TYPE | kNotInternalizedTag,
634 EXTERNAL_ONE_BYTE_STRING_TYPE =
635 EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE | kNotInternalizedTag,
636 EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE =
637 EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE |
639 SHORT_EXTERNAL_STRING_TYPE =
640 SHORT_EXTERNAL_INTERNALIZED_STRING_TYPE | kNotInternalizedTag,
641 SHORT_EXTERNAL_ONE_BYTE_STRING_TYPE =
642 SHORT_EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE | kNotInternalizedTag,
643 SHORT_EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE =
644 SHORT_EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE |
648 SYMBOL_TYPE = kNotStringTag, // FIRST_NONSTRING_TYPE, LAST_NAME_TYPE
650 // Other primitives (cannot contain non-map-word pointers to heap objects).
653 ODDBALL_TYPE, // LAST_PRIMITIVE_TYPE
655 // Objects allocated in their own spaces (never in new space).
659 // "Data", objects that cannot contain non-map-word pointers to heap
661 MUTABLE_HEAP_NUMBER_TYPE,
666 FIXED_INT8_ARRAY_TYPE, // FIRST_FIXED_TYPED_ARRAY_TYPE
667 FIXED_UINT8_ARRAY_TYPE,
668 FIXED_INT16_ARRAY_TYPE,
669 FIXED_UINT16_ARRAY_TYPE,
670 FIXED_INT32_ARRAY_TYPE,
671 FIXED_UINT32_ARRAY_TYPE,
672 FIXED_FLOAT32_ARRAY_TYPE,
673 FIXED_FLOAT64_ARRAY_TYPE,
674 FIXED_UINT8_CLAMPED_ARRAY_TYPE, // LAST_FIXED_TYPED_ARRAY_TYPE
675 FIXED_DOUBLE_ARRAY_TYPE,
676 FILLER_TYPE, // LAST_DATA_TYPE
679 DECLARED_ACCESSOR_DESCRIPTOR_TYPE,
680 DECLARED_ACCESSOR_INFO_TYPE,
681 EXECUTABLE_ACCESSOR_INFO_TYPE,
683 ACCESS_CHECK_INFO_TYPE,
684 INTERCEPTOR_INFO_TYPE,
685 CALL_HANDLER_INFO_TYPE,
686 FUNCTION_TEMPLATE_INFO_TYPE,
687 OBJECT_TEMPLATE_INFO_TYPE,
689 TYPE_SWITCH_INFO_TYPE,
690 ALLOCATION_SITE_TYPE,
691 ALLOCATION_MEMENTO_TYPE,
694 POLYMORPHIC_CODE_CACHE_TYPE,
695 TYPE_FEEDBACK_INFO_TYPE,
696 ALIASED_ARGUMENTS_ENTRY_TYPE,
699 BREAK_POINT_INFO_TYPE,
701 SHARED_FUNCTION_INFO_TYPE,
706 SLOPPY_BLOCK_WITH_EVAL_CONTEXT_EXTENSION_TYPE,
708 // All the following types are subtypes of JSReceiver, which corresponds to
709 // objects in the JS sense. The first and the last type in this range are
710 // the two forms of function. This organization enables using the same
711 // compares for checking the JS_RECEIVER/SPEC_OBJECT range and the
712 // NONCALLABLE_JS_OBJECT range.
713 JS_FUNCTION_PROXY_TYPE, // FIRST_JS_RECEIVER_TYPE, FIRST_JS_PROXY_TYPE
714 JS_PROXY_TYPE, // LAST_JS_PROXY_TYPE
715 JS_VALUE_TYPE, // FIRST_JS_OBJECT_TYPE
716 JS_MESSAGE_OBJECT_TYPE,
719 JS_CONTEXT_EXTENSION_OBJECT_TYPE,
720 JS_GENERATOR_OBJECT_TYPE,
722 JS_GLOBAL_OBJECT_TYPE,
723 JS_BUILTINS_OBJECT_TYPE,
724 JS_GLOBAL_PROXY_TYPE,
726 JS_ARRAY_BUFFER_TYPE,
731 JS_SET_ITERATOR_TYPE,
732 JS_MAP_ITERATOR_TYPE,
733 JS_ITERATOR_RESULT_TYPE,
737 JS_FUNCTION_TYPE, // LAST_JS_OBJECT_TYPE, LAST_JS_RECEIVER_TYPE
741 LAST_TYPE = JS_FUNCTION_TYPE,
742 FIRST_NAME_TYPE = FIRST_TYPE,
743 LAST_NAME_TYPE = SYMBOL_TYPE,
744 FIRST_UNIQUE_NAME_TYPE = INTERNALIZED_STRING_TYPE,
745 LAST_UNIQUE_NAME_TYPE = SYMBOL_TYPE,
746 FIRST_NONSTRING_TYPE = SYMBOL_TYPE,
747 FIRST_PRIMITIVE_TYPE = FIRST_NAME_TYPE,
748 LAST_PRIMITIVE_TYPE = ODDBALL_TYPE,
749 // Boundaries for testing for a fixed typed array.
750 FIRST_FIXED_TYPED_ARRAY_TYPE = FIXED_INT8_ARRAY_TYPE,
751 LAST_FIXED_TYPED_ARRAY_TYPE = FIXED_UINT8_CLAMPED_ARRAY_TYPE,
752 // Boundary for promotion to old space.
753 LAST_DATA_TYPE = FILLER_TYPE,
754 // Boundary for objects represented as JSReceiver (i.e. JSObject or JSProxy).
755 // Note that there is no range for JSObject or JSProxy, since their subtypes
756 // are not continuous in this enum! The enum ranges instead reflect the
757 // external class names, where proxies are treated as either ordinary objects,
759 FIRST_JS_RECEIVER_TYPE = JS_FUNCTION_PROXY_TYPE,
760 LAST_JS_RECEIVER_TYPE = LAST_TYPE,
761 // Boundaries for testing the types represented as JSObject
762 FIRST_JS_OBJECT_TYPE = JS_VALUE_TYPE,
763 LAST_JS_OBJECT_TYPE = LAST_TYPE,
764 // Boundaries for testing the types represented as JSProxy
765 FIRST_JS_PROXY_TYPE = JS_FUNCTION_PROXY_TYPE,
766 LAST_JS_PROXY_TYPE = JS_PROXY_TYPE,
767 // Boundaries for testing whether the type is a JavaScript object.
768 FIRST_SPEC_OBJECT_TYPE = FIRST_JS_RECEIVER_TYPE,
769 LAST_SPEC_OBJECT_TYPE = LAST_JS_RECEIVER_TYPE,
770 // Boundaries for testing the types for which typeof is "object".
771 FIRST_NONCALLABLE_SPEC_OBJECT_TYPE = JS_PROXY_TYPE,
772 LAST_NONCALLABLE_SPEC_OBJECT_TYPE = JS_REGEXP_TYPE,
773 // Note that the types for which typeof is "function" are not continuous.
774 // Define this so that we can put assertions on discrete checks.
775 NUM_OF_CALLABLE_SPEC_OBJECT_TYPES = 2
778 STATIC_ASSERT(JS_OBJECT_TYPE == Internals::kJSObjectType);
779 STATIC_ASSERT(FIRST_NONSTRING_TYPE == Internals::kFirstNonstringType);
780 STATIC_ASSERT(ODDBALL_TYPE == Internals::kOddballType);
781 STATIC_ASSERT(FOREIGN_TYPE == Internals::kForeignType);
784 #define FIXED_ARRAY_SUB_INSTANCE_TYPE_LIST(V) \
785 V(FAST_ELEMENTS_SUB_TYPE) \
786 V(DICTIONARY_ELEMENTS_SUB_TYPE) \
787 V(FAST_PROPERTIES_SUB_TYPE) \
788 V(DICTIONARY_PROPERTIES_SUB_TYPE) \
789 V(MAP_CODE_CACHE_SUB_TYPE) \
790 V(SCOPE_INFO_SUB_TYPE) \
791 V(STRING_TABLE_SUB_TYPE) \
792 V(DESCRIPTOR_ARRAY_SUB_TYPE) \
793 V(TRANSITION_ARRAY_SUB_TYPE)
795 enum FixedArraySubInstanceType {
796 #define DEFINE_FIXED_ARRAY_SUB_INSTANCE_TYPE(name) name,
797 FIXED_ARRAY_SUB_INSTANCE_TYPE_LIST(DEFINE_FIXED_ARRAY_SUB_INSTANCE_TYPE)
798 #undef DEFINE_FIXED_ARRAY_SUB_INSTANCE_TYPE
799 LAST_FIXED_ARRAY_SUB_TYPE = TRANSITION_ARRAY_SUB_TYPE
812 #define DECL_BOOLEAN_ACCESSORS(name) \
813 inline bool name() const; \
814 inline void set_##name(bool value); \
817 #define DECL_ACCESSORS(name, type) \
818 inline type* name() const; \
819 inline void set_##name(type* value, \
820 WriteBarrierMode mode = UPDATE_WRITE_BARRIER); \
823 #define DECLARE_CAST(type) \
824 INLINE(static type* cast(Object* object)); \
825 INLINE(static const type* cast(const Object* object));
829 class AllocationSite;
830 class AllocationSiteCreationContext;
831 class AllocationSiteUsageContext;
834 class ElementsAccessor;
835 class FixedArrayBase;
836 class FunctionLiteral;
838 class JSBuiltinsObject;
839 class LayoutDescriptor;
840 class LookupIterator;
841 class ObjectHashTable;
844 class SafepointEntry;
845 class SharedFunctionInfo;
847 class TypeFeedbackInfo;
848 class TypeFeedbackVector;
851 // We cannot just say "class HeapType;" if it is created from a template... =8-?
852 template<class> class TypeImpl;
853 struct HeapTypeConfig;
854 typedef TypeImpl<HeapTypeConfig> HeapType;
857 // A template-ized version of the IsXXX functions.
858 template <class C> inline bool Is(Object* obj);
861 #define DECLARE_VERIFIER(Name) void Name##Verify();
863 #define DECLARE_VERIFIER(Name)
867 #define DECLARE_PRINTER(Name) void Name##Print(std::ostream& os); // NOLINT
869 #define DECLARE_PRINTER(Name)
873 #define OBJECT_TYPE_LIST(V) \
878 #define HEAP_OBJECT_TYPE_LIST(V) \
880 V(MutableHeapNumber) \
899 V(ExternalTwoByteString) \
900 V(ExternalOneByteString) \
901 V(SeqTwoByteString) \
902 V(SeqOneByteString) \
903 V(InternalizedString) \
906 V(FixedTypedArrayBase) \
909 V(FixedUint16Array) \
911 V(FixedUint32Array) \
913 V(FixedFloat32Array) \
914 V(FixedFloat64Array) \
915 V(FixedUint8ClampedArray) \
921 V(JSContextExtensionObject) \
922 V(JSGeneratorObject) \
924 V(LayoutDescriptor) \
928 V(TypeFeedbackVector) \
929 V(DeoptimizationInputData) \
930 V(DeoptimizationOutputData) \
934 V(FixedDoubleArray) \
938 V(ScriptContextTable) \
944 V(SharedFunctionInfo) \
953 V(JSArrayBufferView) \
962 V(JSIteratorResult) \
963 V(JSWeakCollection) \
970 V(NormalizedMapCache) \
971 V(CompilationCacheTable) \
972 V(CodeCacheHashTable) \
973 V(PolymorphicCodeCacheHashTable) \
978 V(JSBuiltinsObject) \
980 V(UndetectableObject) \
981 V(AccessCheckNeeded) \
989 // Object is the abstract superclass for all classes in the
991 // Object does not use any virtual functions to avoid the
992 // allocation of the C++ vtable.
993 // Since both Smi and HeapObject are subclasses of Object no
994 // data members can be present in Object.
998 bool IsObject() const { return true; }
1000 #define IS_TYPE_FUNCTION_DECL(type_) INLINE(bool Is##type_() const);
1001 OBJECT_TYPE_LIST(IS_TYPE_FUNCTION_DECL)
1002 HEAP_OBJECT_TYPE_LIST(IS_TYPE_FUNCTION_DECL)
1003 #undef IS_TYPE_FUNCTION_DECL
1005 // A non-keyed store is of the form a.x = foo or a["x"] = foo whereas
1006 // a keyed store is of the form a[expression] = foo.
1007 enum StoreFromKeyed {
1008 MAY_BE_STORE_FROM_KEYED,
1009 CERTAINLY_NOT_STORE_FROM_KEYED
1012 INLINE(bool IsFixedArrayBase() const);
1013 INLINE(bool IsExternal() const);
1014 INLINE(bool IsAccessorInfo() const);
1016 INLINE(bool IsStruct() const);
1017 #define DECLARE_STRUCT_PREDICATE(NAME, Name, name) \
1018 INLINE(bool Is##Name() const);
1019 STRUCT_LIST(DECLARE_STRUCT_PREDICATE)
1020 #undef DECLARE_STRUCT_PREDICATE
1022 // ES6, section 7.2.3 IsCallable.
1023 INLINE(bool IsCallable() const);
1025 INLINE(bool IsSpecObject()) const;
1026 // TODO(rossberg): IsSpecFunction should be removed in favor of IsCallable.
1027 INLINE(bool IsSpecFunction()) const;
1028 INLINE(bool IsTemplateInfo()) const;
1029 INLINE(bool IsNameDictionary() const);
1030 INLINE(bool IsGlobalDictionary() const);
1031 INLINE(bool IsSeededNumberDictionary() const);
1032 INLINE(bool IsUnseededNumberDictionary() const);
1033 INLINE(bool IsOrderedHashSet() const);
1034 INLINE(bool IsOrderedHashMap() const);
1035 static bool IsPromise(Handle<Object> object);
1038 INLINE(bool IsUndefined() const);
1039 INLINE(bool IsNull() const);
1040 INLINE(bool IsTheHole() const);
1041 INLINE(bool IsException() const);
1042 INLINE(bool IsUninitialized() const);
1043 INLINE(bool IsTrue() const);
1044 INLINE(bool IsFalse() const);
1045 INLINE(bool IsArgumentsMarker() const);
1047 // Filler objects (fillers and free space objects).
1048 INLINE(bool IsFiller() const);
1050 // Extract the number.
1051 inline double Number();
1052 INLINE(bool IsNaN() const);
1053 INLINE(bool IsMinusZero() const);
1054 bool ToInt32(int32_t* value);
1055 bool ToUint32(uint32_t* value);
1057 inline Representation OptimalRepresentation();
1059 inline ElementsKind OptimalElementsKind();
1061 inline bool FitsRepresentation(Representation representation);
1063 // Checks whether two valid primitive encodings of a property name resolve to
1064 // the same logical property. E.g., the smi 1, the string "1" and the double
1065 // 1 all refer to the same property, so this helper will return true.
1066 inline bool KeyEquals(Object* other);
1068 Handle<HeapType> OptimalType(Isolate* isolate, Representation representation);
1070 inline static Handle<Object> NewStorageFor(Isolate* isolate,
1071 Handle<Object> object,
1072 Representation representation);
1074 inline static Handle<Object> WrapForRead(Isolate* isolate,
1075 Handle<Object> object,
1076 Representation representation);
1078 // Returns true if the object is of the correct type to be used as a
1079 // implementation of a JSObject's elements.
1080 inline bool HasValidElements();
1082 inline bool HasSpecificClassOf(String* name);
1084 bool BooleanValue(); // ECMA-262 9.2.
1086 // ES6 section 7.2.13 Strict Equality Comparison
1087 bool StrictEquals(Object* that);
1089 // Convert to a JSObject if needed.
1090 // native_context is used when creating wrapper object.
1091 static inline MaybeHandle<JSReceiver> ToObject(Isolate* isolate,
1092 Handle<Object> object);
1093 MUST_USE_RESULT static MaybeHandle<JSReceiver> ToObject(
1094 Isolate* isolate, Handle<Object> object, Handle<Context> context);
1096 // ES6 section 7.1.14 ToPropertyKey
1097 MUST_USE_RESULT static inline MaybeHandle<Name> ToName(Isolate* isolate,
1098 Handle<Object> input);
1100 // ES6 section 7.1.1 ToPrimitive
1101 MUST_USE_RESULT static inline MaybeHandle<Object> ToPrimitive(
1102 Handle<Object> input, ToPrimitiveHint hint = ToPrimitiveHint::kDefault);
1104 // ES6 section 7.1.3 ToNumber
1105 MUST_USE_RESULT static MaybeHandle<Object> ToNumber(Isolate* isolate,
1106 Handle<Object> input);
1108 // ES6 section 7.1.12 ToString
1109 MUST_USE_RESULT static MaybeHandle<String> ToString(Isolate* isolate,
1110 Handle<Object> input);
1112 // ES6 section 7.3.9 GetMethod
1113 MUST_USE_RESULT static MaybeHandle<Object> GetMethod(
1114 Handle<JSReceiver> receiver, Handle<Name> name);
1116 // ES6 section 12.5.6 The typeof Operator
1117 static Handle<String> TypeOf(Isolate* isolate, Handle<Object> object);
1119 MUST_USE_RESULT static MaybeHandle<Object> GetProperty(
1120 LookupIterator* it, LanguageMode language_mode = SLOPPY);
1122 // Implementation of [[Put]], ECMA-262 5th edition, section 8.12.5.
1123 MUST_USE_RESULT static MaybeHandle<Object> SetProperty(
1124 Handle<Object> object, Handle<Name> name, Handle<Object> value,
1125 LanguageMode language_mode,
1126 StoreFromKeyed store_mode = MAY_BE_STORE_FROM_KEYED);
1128 MUST_USE_RESULT static MaybeHandle<Object> SetProperty(
1129 LookupIterator* it, Handle<Object> value, LanguageMode language_mode,
1130 StoreFromKeyed store_mode);
1132 MUST_USE_RESULT static MaybeHandle<Object> SetSuperProperty(
1133 LookupIterator* it, Handle<Object> value, LanguageMode language_mode,
1134 StoreFromKeyed store_mode);
1136 MUST_USE_RESULT static MaybeHandle<Object> ReadAbsentProperty(
1137 LookupIterator* it, LanguageMode language_mode);
1138 MUST_USE_RESULT static MaybeHandle<Object> ReadAbsentProperty(
1139 Isolate* isolate, Handle<Object> receiver, Handle<Object> name,
1140 LanguageMode language_mode);
1141 MUST_USE_RESULT static MaybeHandle<Object> WriteToReadOnlyProperty(
1142 LookupIterator* it, Handle<Object> value, LanguageMode language_mode);
1143 MUST_USE_RESULT static MaybeHandle<Object> WriteToReadOnlyProperty(
1144 Isolate* isolate, Handle<Object> receiver, Handle<Object> name,
1145 Handle<Object> value, LanguageMode language_mode);
1146 MUST_USE_RESULT static MaybeHandle<Object> RedefineNonconfigurableProperty(
1147 Isolate* isolate, Handle<Object> name, Handle<Object> value,
1148 LanguageMode language_mode);
1149 MUST_USE_RESULT static MaybeHandle<Object> SetDataProperty(
1150 LookupIterator* it, Handle<Object> value);
1151 MUST_USE_RESULT static MaybeHandle<Object> AddDataProperty(
1152 LookupIterator* it, Handle<Object> value, PropertyAttributes attributes,
1153 LanguageMode language_mode, StoreFromKeyed store_mode);
1154 MUST_USE_RESULT static inline MaybeHandle<Object> GetPropertyOrElement(
1155 Handle<Object> object, Handle<Name> name,
1156 LanguageMode language_mode = SLOPPY);
1157 MUST_USE_RESULT static inline MaybeHandle<Object> GetProperty(
1158 Isolate* isolate, Handle<Object> object, const char* key,
1159 LanguageMode language_mode = SLOPPY);
1160 MUST_USE_RESULT static inline MaybeHandle<Object> GetProperty(
1161 Handle<Object> object, Handle<Name> name,
1162 LanguageMode language_mode = SLOPPY);
1164 MUST_USE_RESULT static MaybeHandle<Object> GetPropertyWithAccessor(
1165 LookupIterator* it, LanguageMode language_mode);
1166 MUST_USE_RESULT static MaybeHandle<Object> SetPropertyWithAccessor(
1167 LookupIterator* it, Handle<Object> value, LanguageMode language_mode);
1169 MUST_USE_RESULT static MaybeHandle<Object> GetPropertyWithDefinedGetter(
1170 Handle<Object> receiver,
1171 Handle<JSReceiver> getter);
1172 MUST_USE_RESULT static MaybeHandle<Object> SetPropertyWithDefinedSetter(
1173 Handle<Object> receiver,
1174 Handle<JSReceiver> setter,
1175 Handle<Object> value);
1177 MUST_USE_RESULT static inline MaybeHandle<Object> GetElement(
1178 Isolate* isolate, Handle<Object> object, uint32_t index,
1179 LanguageMode language_mode = SLOPPY);
1181 MUST_USE_RESULT static inline MaybeHandle<Object> SetElement(
1182 Isolate* isolate, Handle<Object> object, uint32_t index,
1183 Handle<Object> value, LanguageMode language_mode);
1185 static inline Handle<Object> GetPrototypeSkipHiddenPrototypes(
1186 Isolate* isolate, Handle<Object> receiver);
1188 bool HasInPrototypeChain(Isolate* isolate, Object* object);
1190 // Returns the permanent hash code associated with this object. May return
1191 // undefined if not yet created.
1194 // Returns undefined for JSObjects, but returns the hash code for simple
1195 // objects. This avoids a double lookup in the cases where we know we will
1196 // add the hash to the JSObject if it does not already exist.
1197 Object* GetSimpleHash();
1199 // Returns the permanent hash code associated with this object depending on
1200 // the actual object type. May create and store a hash code if needed and none
1202 static Handle<Smi> GetOrCreateHash(Isolate* isolate, Handle<Object> object);
1204 // Checks whether this object has the same value as the given one. This
1205 // function is implemented according to ES5, section 9.12 and can be used
1206 // to implement the Harmony "egal" function.
1207 bool SameValue(Object* other);
1209 // Checks whether this object has the same value as the given one.
1210 // +0 and -0 are treated equal. Everything else is the same as SameValue.
1211 // This function is implemented according to ES6, section 7.2.4 and is used
1212 // by ES6 Map and Set.
1213 bool SameValueZero(Object* other);
1215 // Tries to convert an object to an array length. Returns true and sets the
1216 // output parameter if it succeeds.
1217 inline bool ToArrayLength(uint32_t* index);
1219 // Tries to convert an object to an array index. Returns true and sets the
1220 // output parameter if it succeeds. Equivalent to ToArrayLength, but does not
1221 // allow kMaxUInt32.
1222 inline bool ToArrayIndex(uint32_t* index);
1224 // Returns true if this is a JSValue containing a string and the index is
1225 // < the length of the string. Used to implement [] on strings.
1226 inline bool IsStringObjectWithCharacterAt(uint32_t index);
1228 DECLARE_VERIFIER(Object)
1230 // Verify a pointer is a valid object pointer.
1231 static void VerifyPointer(Object* p);
1234 inline void VerifyApiCallResultType();
1236 // Prints this object without details.
1237 void ShortPrint(FILE* out = stdout);
1239 // Prints this object without details to a message accumulator.
1240 void ShortPrint(StringStream* accumulator);
1242 void ShortPrint(std::ostream& os); // NOLINT
1244 DECLARE_CAST(Object)
1246 // Layout description.
1247 static const int kHeaderSize = 0; // Object does not take up any space.
1250 // For our gdb macros, we should perhaps change these in the future.
1253 // Prints this object with details.
1254 void Print(std::ostream& os); // NOLINT
1256 void Print() { ShortPrint(); }
1257 void Print(std::ostream& os) { ShortPrint(os); } // NOLINT
1261 friend class LookupIterator;
1262 friend class PrototypeIterator;
1264 // Return the map of the root of object's prototype chain.
1265 Map* GetRootMap(Isolate* isolate);
1267 // Helper for SetProperty and SetSuperProperty.
1268 MUST_USE_RESULT static MaybeHandle<Object> SetPropertyInternal(
1269 LookupIterator* it, Handle<Object> value, LanguageMode language_mode,
1270 StoreFromKeyed store_mode, bool* found);
1272 DISALLOW_IMPLICIT_CONSTRUCTORS(Object);
1276 // In objects.h to be usable without objects-inl.h inclusion.
1277 bool Object::IsSmi() const { return HAS_SMI_TAG(this); }
1278 bool Object::IsHeapObject() const { return Internals::HasHeapObjectTag(this); }
1282 explicit Brief(const Object* const v) : value(v) {}
1283 const Object* value;
1287 std::ostream& operator<<(std::ostream& os, const Brief& v);
1290 // Smi represents integer Numbers that can be stored in 31 bits.
1291 // Smis are immediate which means they are NOT allocated in the heap.
1292 // The this pointer has the following format: [31 bit signed int] 0
1293 // For long smis it has the following format:
1294 // [32 bit signed int] [31 bits zero padding] 0
1295 // Smi stands for small integer.
1296 class Smi: public Object {
1298 // Returns the integer value.
1299 inline int value() const { return Internals::SmiValue(this); }
1301 // Convert a value to a Smi object.
1302 static inline Smi* FromInt(int value) {
1303 DCHECK(Smi::IsValid(value));
1304 return reinterpret_cast<Smi*>(Internals::IntToSmi(value));
1307 static inline Smi* FromIntptr(intptr_t value) {
1308 DCHECK(Smi::IsValid(value));
1309 int smi_shift_bits = kSmiTagSize + kSmiShiftSize;
1310 return reinterpret_cast<Smi*>((value << smi_shift_bits) | kSmiTag);
1313 // Returns whether value can be represented in a Smi.
1314 static inline bool IsValid(intptr_t value) {
1315 bool result = Internals::IsValidSmi(value);
1316 DCHECK_EQ(result, value >= kMinValue && value <= kMaxValue);
1322 // Dispatched behavior.
1323 void SmiPrint(std::ostream& os) const; // NOLINT
1324 DECLARE_VERIFIER(Smi)
1326 static const int kMinValue =
1327 (static_cast<unsigned int>(-1)) << (kSmiValueSize - 1);
1328 static const int kMaxValue = -(kMinValue + 1);
1331 DISALLOW_IMPLICIT_CONSTRUCTORS(Smi);
1335 // Heap objects typically have a map pointer in their first word. However,
1336 // during GC other data (e.g. mark bits, forwarding addresses) is sometimes
1337 // encoded in the first word. The class MapWord is an abstraction of the
1338 // value in a heap object's first word.
1339 class MapWord BASE_EMBEDDED {
1341 // Normal state: the map word contains a map pointer.
1343 // Create a map word from a map pointer.
1344 static inline MapWord FromMap(const Map* map);
1346 // View this map word as a map pointer.
1347 inline Map* ToMap();
1350 // Scavenge collection: the map word of live objects in the from space
1351 // contains a forwarding address (a heap object pointer in the to space).
1353 // True if this map word is a forwarding address for a scavenge
1354 // collection. Only valid during a scavenge collection (specifically,
1355 // when all map words are heap object pointers, i.e. not during a full GC).
1356 inline bool IsForwardingAddress();
1358 // Create a map word from a forwarding address.
1359 static inline MapWord FromForwardingAddress(HeapObject* object);
1361 // View this map word as a forwarding address.
1362 inline HeapObject* ToForwardingAddress();
1364 static inline MapWord FromRawValue(uintptr_t value) {
1365 return MapWord(value);
1368 inline uintptr_t ToRawValue() {
1373 // HeapObject calls the private constructor and directly reads the value.
1374 friend class HeapObject;
1376 explicit MapWord(uintptr_t value) : value_(value) {}
1382 // The content of an heap object (except for the map pointer). kTaggedValues
1383 // objects can contain both heap pointers and Smis, kMixedValues can contain
1384 // heap pointers, Smis, and raw values (e.g. doubles or strings), and kRawValues
1385 // objects can contain raw values and Smis.
1386 enum class HeapObjectContents { kTaggedValues, kMixedValues, kRawValues };
1389 // HeapObject is the superclass for all classes describing heap allocated
1391 class HeapObject: public Object {
1393 // [map]: Contains a map which contains the object's reflective
1395 inline Map* map() const;
1396 inline void set_map(Map* value);
1397 // The no-write-barrier version. This is OK if the object is white and in
1398 // new space, or if the value is an immortal immutable object, like the maps
1399 // of primitive (non-JS) objects like strings, heap numbers etc.
1400 inline void set_map_no_write_barrier(Map* value);
1402 // Get the map using acquire load.
1403 inline Map* synchronized_map();
1404 inline MapWord synchronized_map_word() const;
1406 // Set the map using release store
1407 inline void synchronized_set_map(Map* value);
1408 inline void synchronized_set_map_no_write_barrier(Map* value);
1409 inline void synchronized_set_map_word(MapWord map_word);
1411 // During garbage collection, the map word of a heap object does not
1412 // necessarily contain a map pointer.
1413 inline MapWord map_word() const;
1414 inline void set_map_word(MapWord map_word);
1416 // The Heap the object was allocated in. Used also to access Isolate.
1417 inline Heap* GetHeap() const;
1419 // Convenience method to get current isolate.
1420 inline Isolate* GetIsolate() const;
1422 // Converts an address to a HeapObject pointer.
1423 static inline HeapObject* FromAddress(Address address) {
1424 DCHECK_TAG_ALIGNED(address);
1425 return reinterpret_cast<HeapObject*>(address + kHeapObjectTag);
1428 // Returns the address of this HeapObject.
1429 inline Address address() {
1430 return reinterpret_cast<Address>(this) - kHeapObjectTag;
1433 // Iterates over pointers contained in the object (including the Map)
1434 void Iterate(ObjectVisitor* v);
1436 // Iterates over all pointers contained in the object except the
1437 // first map pointer. The object type is given in the first
1438 // parameter. This function does not access the map pointer in the
1439 // object, and so is safe to call while the map pointer is modified.
1440 void IterateBody(InstanceType type, int object_size, ObjectVisitor* v);
1442 // Returns the heap object's size in bytes
1445 // Indicates what type of values this heap object may contain.
1446 inline HeapObjectContents ContentType();
1448 // Given a heap object's map pointer, returns the heap size in bytes
1449 // Useful when the map pointer field is used for other purposes.
1451 inline int SizeFromMap(Map* map);
1453 // Returns the field at offset in obj, as a read/write Object* reference.
1454 // Does no checking, and is safe to use during GC, while maps are invalid.
1455 // Does not invoke write barrier, so should only be assigned to
1456 // during marking GC.
1457 static inline Object** RawField(HeapObject* obj, int offset);
1459 // Adds the |code| object related to |name| to the code cache of this map. If
1460 // this map is a dictionary map that is shared, the map copied and installed
1462 static void UpdateMapCodeCache(Handle<HeapObject> object,
1466 DECLARE_CAST(HeapObject)
1468 // Return the write barrier mode for this. Callers of this function
1469 // must be able to present a reference to an DisallowHeapAllocation
1470 // object as a sign that they are not going to use this function
1471 // from code that allocates and thus invalidates the returned write
1473 inline WriteBarrierMode GetWriteBarrierMode(
1474 const DisallowHeapAllocation& promise);
1476 // Dispatched behavior.
1477 void HeapObjectShortPrint(std::ostream& os); // NOLINT
1479 void PrintHeader(std::ostream& os, const char* id); // NOLINT
1481 DECLARE_PRINTER(HeapObject)
1482 DECLARE_VERIFIER(HeapObject)
1484 inline void VerifyObjectField(int offset);
1485 inline void VerifySmiField(int offset);
1487 // Verify a pointer is a valid HeapObject pointer that points to object
1488 // areas in the heap.
1489 static void VerifyHeapPointer(Object* p);
1492 inline AllocationAlignment RequiredAlignment();
1494 // Layout description.
1495 // First field in a heap object is map.
1496 static const int kMapOffset = Object::kHeaderSize;
1497 static const int kHeaderSize = kMapOffset + kPointerSize;
1499 STATIC_ASSERT(kMapOffset == Internals::kHeapObjectMapOffset);
1502 // helpers for calling an ObjectVisitor to iterate over pointers in the
1503 // half-open range [start, end) specified as integer offsets
1504 inline void IteratePointers(ObjectVisitor* v, int start, int end);
1505 // as above, for the single element at "offset"
1506 inline void IteratePointer(ObjectVisitor* v, int offset);
1507 // as above, for the next code link of a code object.
1508 inline void IterateNextCodeLink(ObjectVisitor* v, int offset);
1511 DISALLOW_IMPLICIT_CONSTRUCTORS(HeapObject);
1515 // This class describes a body of an object of a fixed size
1516 // in which all pointer fields are located in the [start_offset, end_offset)
1518 template<int start_offset, int end_offset, int size>
1519 class FixedBodyDescriptor {
1521 static const int kStartOffset = start_offset;
1522 static const int kEndOffset = end_offset;
1523 static const int kSize = size;
1525 static inline void IterateBody(HeapObject* obj, ObjectVisitor* v);
1527 template<typename StaticVisitor>
1528 static inline void IterateBody(HeapObject* obj) {
1529 StaticVisitor::VisitPointers(HeapObject::RawField(obj, start_offset),
1530 HeapObject::RawField(obj, end_offset));
1535 // This class describes a body of an object of a variable size
1536 // in which all pointer fields are located in the [start_offset, object_size)
1538 template<int start_offset>
1539 class FlexibleBodyDescriptor {
1541 static const int kStartOffset = start_offset;
1543 static inline void IterateBody(HeapObject* obj,
1547 template<typename StaticVisitor>
1548 static inline void IterateBody(HeapObject* obj, int object_size) {
1549 StaticVisitor::VisitPointers(HeapObject::RawField(obj, start_offset),
1550 HeapObject::RawField(obj, object_size));
1555 // The HeapNumber class describes heap allocated numbers that cannot be
1556 // represented in a Smi (small integer)
1557 class HeapNumber: public HeapObject {
1559 // [value]: number value.
1560 inline double value() const;
1561 inline void set_value(double value);
1563 DECLARE_CAST(HeapNumber)
1565 // Dispatched behavior.
1566 bool HeapNumberBooleanValue();
1568 void HeapNumberPrint(std::ostream& os); // NOLINT
1569 DECLARE_VERIFIER(HeapNumber)
1571 inline int get_exponent();
1572 inline int get_sign();
1574 // Layout description.
1575 static const int kValueOffset = HeapObject::kHeaderSize;
1576 // IEEE doubles are two 32 bit words. The first is just mantissa, the second
1577 // is a mixture of sign, exponent and mantissa. The offsets of two 32 bit
1578 // words within double numbers are endian dependent and they are set
1580 #if defined(V8_TARGET_LITTLE_ENDIAN)
1581 static const int kMantissaOffset = kValueOffset;
1582 static const int kExponentOffset = kValueOffset + 4;
1583 #elif defined(V8_TARGET_BIG_ENDIAN)
1584 static const int kMantissaOffset = kValueOffset + 4;
1585 static const int kExponentOffset = kValueOffset;
1587 #error Unknown byte ordering
1590 static const int kSize = kValueOffset + kDoubleSize;
1591 static const uint32_t kSignMask = 0x80000000u;
1592 static const uint32_t kExponentMask = 0x7ff00000u;
1593 static const uint32_t kMantissaMask = 0xfffffu;
1594 static const int kMantissaBits = 52;
1595 static const int kExponentBits = 11;
1596 static const int kExponentBias = 1023;
1597 static const int kExponentShift = 20;
1598 static const int kInfinityOrNanExponent =
1599 (kExponentMask >> kExponentShift) - kExponentBias;
1600 static const int kMantissaBitsInTopWord = 20;
1601 static const int kNonMantissaBitsInTopWord = 12;
1604 DISALLOW_IMPLICIT_CONSTRUCTORS(HeapNumber);
1608 // The Simd128Value class describes heap allocated 128 bit SIMD values.
1609 class Simd128Value : public HeapObject {
1611 DECLARE_CAST(Simd128Value)
1613 DECLARE_PRINTER(Simd128Value)
1614 DECLARE_VERIFIER(Simd128Value)
1616 static Handle<String> ToString(Handle<Simd128Value> input);
1618 // Equality operations.
1619 inline bool Equals(Simd128Value* that);
1621 // Checks that another instance is bit-wise equal.
1622 bool BitwiseEquals(const Simd128Value* other) const;
1623 // Computes a hash from the 128 bit value, viewed as 4 32-bit integers.
1624 uint32_t Hash() const;
1625 // Copies the 16 bytes of SIMD data to the destination address.
1626 void CopyBits(void* destination) const;
1628 // Layout description.
1629 static const int kValueOffset = HeapObject::kHeaderSize;
1630 static const int kSize = kValueOffset + kSimd128Size;
1633 DISALLOW_IMPLICIT_CONSTRUCTORS(Simd128Value);
1637 // V has parameters (TYPE, Type, type, lane count, lane type)
1638 #define SIMD128_TYPES(V) \
1639 V(FLOAT32X4, Float32x4, float32x4, 4, float) \
1640 V(INT32X4, Int32x4, int32x4, 4, int32_t) \
1641 V(UINT32X4, Uint32x4, uint32x4, 4, uint32_t) \
1642 V(BOOL32X4, Bool32x4, bool32x4, 4, bool) \
1643 V(INT16X8, Int16x8, int16x8, 8, int16_t) \
1644 V(UINT16X8, Uint16x8, uint16x8, 8, uint16_t) \
1645 V(BOOL16X8, Bool16x8, bool16x8, 8, bool) \
1646 V(INT8X16, Int8x16, int8x16, 16, int8_t) \
1647 V(UINT8X16, Uint8x16, uint8x16, 16, uint8_t) \
1648 V(BOOL8X16, Bool8x16, bool8x16, 16, bool)
1650 #define SIMD128_VALUE_CLASS(TYPE, Type, type, lane_count, lane_type) \
1651 class Type final : public Simd128Value { \
1653 inline lane_type get_lane(int lane) const; \
1654 inline void set_lane(int lane, lane_type value); \
1656 DECLARE_CAST(Type) \
1658 DECLARE_PRINTER(Type) \
1660 static Handle<String> ToString(Handle<Type> input); \
1662 inline bool Equals(Type* that); \
1665 DISALLOW_IMPLICIT_CONSTRUCTORS(Type); \
1667 SIMD128_TYPES(SIMD128_VALUE_CLASS)
1668 #undef SIMD128_VALUE_CLASS
1671 enum EnsureElementsMode {
1672 DONT_ALLOW_DOUBLE_ELEMENTS,
1673 ALLOW_COPIED_DOUBLE_ELEMENTS,
1674 ALLOW_CONVERTED_DOUBLE_ELEMENTS
1678 // Indicator for one component of an AccessorPair.
1679 enum AccessorComponent {
1685 // JSReceiver includes types on which properties can be defined, i.e.,
1686 // JSObject and JSProxy.
1687 class JSReceiver: public HeapObject {
1689 DECLARE_CAST(JSReceiver)
1691 // ES6 section 7.1.1 ToPrimitive
1692 MUST_USE_RESULT static MaybeHandle<Object> ToPrimitive(
1693 Handle<JSReceiver> receiver,
1694 ToPrimitiveHint hint = ToPrimitiveHint::kDefault);
1695 MUST_USE_RESULT static MaybeHandle<Object> OrdinaryToPrimitive(
1696 Handle<JSReceiver> receiver, OrdinaryToPrimitiveHint hint);
1698 // Implementation of [[HasProperty]], ECMA-262 5th edition, section 8.12.6.
1699 MUST_USE_RESULT static inline Maybe<bool> HasProperty(
1700 Handle<JSReceiver> object, Handle<Name> name);
1701 MUST_USE_RESULT static inline Maybe<bool> HasOwnProperty(Handle<JSReceiver>,
1703 MUST_USE_RESULT static inline Maybe<bool> HasElement(
1704 Handle<JSReceiver> object, uint32_t index);
1705 MUST_USE_RESULT static inline Maybe<bool> HasOwnElement(
1706 Handle<JSReceiver> object, uint32_t index);
1708 // Implementation of [[Delete]], ECMA-262 5th edition, section 8.12.7.
1709 MUST_USE_RESULT static MaybeHandle<Object> DeletePropertyOrElement(
1710 Handle<JSReceiver> object, Handle<Name> name,
1711 LanguageMode language_mode = SLOPPY);
1712 MUST_USE_RESULT static MaybeHandle<Object> DeleteProperty(
1713 Handle<JSReceiver> object, Handle<Name> name,
1714 LanguageMode language_mode = SLOPPY);
1715 MUST_USE_RESULT static MaybeHandle<Object> DeleteProperty(
1716 LookupIterator* it, LanguageMode language_mode);
1717 MUST_USE_RESULT static MaybeHandle<Object> DeleteElement(
1718 Handle<JSReceiver> object, uint32_t index,
1719 LanguageMode language_mode = SLOPPY);
1721 // Tests for the fast common case for property enumeration.
1722 bool IsSimpleEnum();
1724 // Returns the class name ([[Class]] property in the specification).
1725 String* class_name();
1727 // Returns the constructor name (the name (possibly, inferred name) of the
1728 // function that was used to instantiate the object).
1729 String* constructor_name();
1731 MUST_USE_RESULT static inline Maybe<PropertyAttributes> GetPropertyAttributes(
1732 Handle<JSReceiver> object, Handle<Name> name);
1733 MUST_USE_RESULT static inline Maybe<PropertyAttributes>
1734 GetOwnPropertyAttributes(Handle<JSReceiver> object, Handle<Name> name);
1736 MUST_USE_RESULT static inline Maybe<PropertyAttributes> GetElementAttributes(
1737 Handle<JSReceiver> object, uint32_t index);
1738 MUST_USE_RESULT static inline Maybe<PropertyAttributes>
1739 GetOwnElementAttributes(Handle<JSReceiver> object, uint32_t index);
1741 MUST_USE_RESULT static Maybe<PropertyAttributes> GetPropertyAttributes(
1742 LookupIterator* it);
1745 static Handle<Object> GetDataProperty(Handle<JSReceiver> object,
1747 static Handle<Object> GetDataProperty(LookupIterator* it);
1750 // Retrieves a permanent object identity hash code. The undefined value might
1751 // be returned in case no hash was created yet.
1752 inline Object* GetIdentityHash();
1754 // Retrieves a permanent object identity hash code. May create and store a
1755 // hash code if needed and none exists.
1756 inline static Handle<Smi> GetOrCreateIdentityHash(
1757 Handle<JSReceiver> object);
1759 enum KeyCollectionType { OWN_ONLY, INCLUDE_PROTOS };
1761 // Computes the enumerable keys for a JSObject. Used for implementing
1762 // "for (n in object) { }".
1763 MUST_USE_RESULT static MaybeHandle<FixedArray> GetKeys(
1764 Handle<JSReceiver> object,
1765 KeyCollectionType type);
1768 DISALLOW_IMPLICIT_CONSTRUCTORS(JSReceiver);
1772 // The JSObject describes real heap allocated JavaScript objects with
1774 // Note that the map of JSObject changes during execution to enable inline
1776 class JSObject: public JSReceiver {
1778 // [properties]: Backing storage for properties.
1779 // properties is a FixedArray in the fast case and a Dictionary in the
1781 DECL_ACCESSORS(properties, FixedArray) // Get and set fast properties.
1782 inline void initialize_properties();
1783 inline bool HasFastProperties();
1784 // Gets slow properties for non-global objects.
1785 inline NameDictionary* property_dictionary();
1786 // Gets global object properties.
1787 inline GlobalDictionary* global_dictionary();
1789 // [elements]: The elements (properties with names that are integers).
1791 // Elements can be in two general modes: fast and slow. Each mode
1792 // corrensponds to a set of object representations of elements that
1793 // have something in common.
1795 // In the fast mode elements is a FixedArray and so each element can
1796 // be quickly accessed. This fact is used in the generated code. The
1797 // elements array can have one of three maps in this mode:
1798 // fixed_array_map, sloppy_arguments_elements_map or
1799 // fixed_cow_array_map (for copy-on-write arrays). In the latter case
1800 // the elements array may be shared by a few objects and so before
1801 // writing to any element the array must be copied. Use
1802 // EnsureWritableFastElements in this case.
1804 // In the slow mode the elements is either a NumberDictionary, a
1805 // FixedArray parameter map for a (sloppy) arguments object.
1806 DECL_ACCESSORS(elements, FixedArrayBase)
1807 inline void initialize_elements();
1808 static void ResetElements(Handle<JSObject> object);
1809 static inline void SetMapAndElements(Handle<JSObject> object,
1811 Handle<FixedArrayBase> elements);
1812 inline ElementsKind GetElementsKind();
1813 ElementsAccessor* GetElementsAccessor();
1814 // Returns true if an object has elements of FAST_SMI_ELEMENTS ElementsKind.
1815 inline bool HasFastSmiElements();
1816 // Returns true if an object has elements of FAST_ELEMENTS ElementsKind.
1817 inline bool HasFastObjectElements();
1818 // Returns true if an object has elements of FAST_ELEMENTS or
1819 // FAST_SMI_ONLY_ELEMENTS.
1820 inline bool HasFastSmiOrObjectElements();
1821 // Returns true if an object has any of the fast elements kinds.
1822 inline bool HasFastElements();
1823 // Returns true if an object has elements of FAST_DOUBLE_ELEMENTS
1825 inline bool HasFastDoubleElements();
1826 // Returns true if an object has elements of FAST_HOLEY_*_ELEMENTS
1828 inline bool HasFastHoleyElements();
1829 inline bool HasSloppyArgumentsElements();
1830 inline bool HasDictionaryElements();
1832 inline bool HasFixedTypedArrayElements();
1834 inline bool HasFixedUint8ClampedElements();
1835 inline bool HasFixedArrayElements();
1836 inline bool HasFixedInt8Elements();
1837 inline bool HasFixedUint8Elements();
1838 inline bool HasFixedInt16Elements();
1839 inline bool HasFixedUint16Elements();
1840 inline bool HasFixedInt32Elements();
1841 inline bool HasFixedUint32Elements();
1842 inline bool HasFixedFloat32Elements();
1843 inline bool HasFixedFloat64Elements();
1845 inline bool HasFastArgumentsElements();
1846 inline bool HasSlowArgumentsElements();
1847 inline SeededNumberDictionary* element_dictionary(); // Gets slow elements.
1849 // Requires: HasFastElements().
1850 static Handle<FixedArray> EnsureWritableFastElements(
1851 Handle<JSObject> object);
1853 // Collects elements starting at index 0.
1854 // Undefined values are placed after non-undefined values.
1855 // Returns the number of non-undefined values.
1856 static Handle<Object> PrepareElementsForSort(Handle<JSObject> object,
1858 // As PrepareElementsForSort, but only on objects where elements is
1859 // a dictionary, and it will stay a dictionary. Collates undefined and
1860 // unexisting elements below limit from position zero of the elements.
1861 static Handle<Object> PrepareSlowElementsForSort(Handle<JSObject> object,
1864 MUST_USE_RESULT static MaybeHandle<Object> SetPropertyWithInterceptor(
1865 LookupIterator* it, Handle<Object> value);
1867 // SetLocalPropertyIgnoreAttributes converts callbacks to fields. We need to
1868 // grant an exemption to ExecutableAccessor callbacks in some cases.
1869 enum ExecutableAccessorInfoHandling { DEFAULT_HANDLING, DONT_FORCE_FIELD };
1871 MUST_USE_RESULT static MaybeHandle<Object> DefineOwnPropertyIgnoreAttributes(
1872 LookupIterator* it, Handle<Object> value, PropertyAttributes attributes,
1873 ExecutableAccessorInfoHandling handling = DEFAULT_HANDLING);
1875 MUST_USE_RESULT static MaybeHandle<Object> SetOwnPropertyIgnoreAttributes(
1876 Handle<JSObject> object, Handle<Name> name, Handle<Object> value,
1877 PropertyAttributes attributes,
1878 ExecutableAccessorInfoHandling handling = DEFAULT_HANDLING);
1880 MUST_USE_RESULT static MaybeHandle<Object> SetOwnElementIgnoreAttributes(
1881 Handle<JSObject> object, uint32_t index, Handle<Object> value,
1882 PropertyAttributes attributes,
1883 ExecutableAccessorInfoHandling handling = DEFAULT_HANDLING);
1885 // Equivalent to one of the above depending on whether |name| can be converted
1886 // to an array index.
1887 MUST_USE_RESULT static MaybeHandle<Object>
1888 DefinePropertyOrElementIgnoreAttributes(
1889 Handle<JSObject> object, Handle<Name> name, Handle<Object> value,
1890 PropertyAttributes attributes = NONE,
1891 ExecutableAccessorInfoHandling handling = DEFAULT_HANDLING);
1893 // Adds or reconfigures a property to attributes NONE. It will fail when it
1895 MUST_USE_RESULT static Maybe<bool> CreateDataProperty(LookupIterator* it,
1896 Handle<Object> value);
1898 static void AddProperty(Handle<JSObject> object, Handle<Name> name,
1899 Handle<Object> value, PropertyAttributes attributes);
1901 MUST_USE_RESULT static MaybeHandle<Object> AddDataElement(
1902 Handle<JSObject> receiver, uint32_t index, Handle<Object> value,
1903 PropertyAttributes attributes);
1905 // Extend the receiver with a single fast property appeared first in the
1906 // passed map. This also extends the property backing store if necessary.
1907 static void AllocateStorageForMap(Handle<JSObject> object, Handle<Map> map);
1909 // Migrates the given object to a map whose field representations are the
1910 // lowest upper bound of all known representations for that field.
1911 static void MigrateInstance(Handle<JSObject> instance);
1913 // Migrates the given object only if the target map is already available,
1914 // or returns false if such a map is not yet available.
1915 static bool TryMigrateInstance(Handle<JSObject> instance);
1917 // Sets the property value in a normalized object given (key, value, details).
1918 // Handles the special representation of JS global objects.
1919 static void SetNormalizedProperty(Handle<JSObject> object, Handle<Name> name,
1920 Handle<Object> value,
1921 PropertyDetails details);
1922 static void SetDictionaryElement(Handle<JSObject> object, uint32_t index,
1923 Handle<Object> value,
1924 PropertyAttributes attributes);
1925 static void SetDictionaryArgumentsElement(Handle<JSObject> object,
1927 Handle<Object> value,
1928 PropertyAttributes attributes);
1930 static void OptimizeAsPrototype(Handle<JSObject> object,
1931 PrototypeOptimizationMode mode);
1932 static void ReoptimizeIfPrototype(Handle<JSObject> object);
1933 static void LazyRegisterPrototypeUser(Handle<Map> user, Isolate* isolate);
1934 static bool UnregisterPrototypeUser(Handle<Map> user, Isolate* isolate);
1935 static void InvalidatePrototypeChains(Map* map);
1937 // Alternative implementation of WeakFixedArray::NullCallback.
1938 class PrototypeRegistryCompactionCallback {
1940 static void Callback(Object* value, int old_index, int new_index);
1943 // Retrieve interceptors.
1944 InterceptorInfo* GetNamedInterceptor();
1945 InterceptorInfo* GetIndexedInterceptor();
1947 // Used from JSReceiver.
1948 MUST_USE_RESULT static Maybe<PropertyAttributes>
1949 GetPropertyAttributesWithInterceptor(LookupIterator* it);
1950 MUST_USE_RESULT static Maybe<PropertyAttributes>
1951 GetPropertyAttributesWithFailedAccessCheck(LookupIterator* it);
1953 // Retrieves an AccessorPair property from the given object. Might return
1954 // undefined if the property doesn't exist or is of a different kind.
1955 MUST_USE_RESULT static MaybeHandle<Object> GetAccessor(
1956 Handle<JSObject> object,
1958 AccessorComponent component);
1960 // Defines an AccessorPair property on the given object.
1961 // TODO(mstarzinger): Rename to SetAccessor().
1962 static MaybeHandle<Object> DefineAccessor(Handle<JSObject> object,
1964 Handle<Object> getter,
1965 Handle<Object> setter,
1966 PropertyAttributes attributes);
1968 // Defines an AccessorInfo property on the given object.
1969 MUST_USE_RESULT static MaybeHandle<Object> SetAccessor(
1970 Handle<JSObject> object,
1971 Handle<AccessorInfo> info);
1973 // The result must be checked first for exceptions. If there's no exception,
1974 // the output parameter |done| indicates whether the interceptor has a result
1976 MUST_USE_RESULT static MaybeHandle<Object> GetPropertyWithInterceptor(
1977 LookupIterator* it, bool* done);
1979 // Accessors for hidden properties object.
1981 // Hidden properties are not own properties of the object itself.
1982 // Instead they are stored in an auxiliary structure kept as an own
1983 // property with a special name Heap::hidden_string(). But if the
1984 // receiver is a JSGlobalProxy then the auxiliary object is a property
1985 // of its prototype, and if it's a detached proxy, then you can't have
1986 // hidden properties.
1988 // Sets a hidden property on this object. Returns this object if successful,
1989 // undefined if called on a detached proxy.
1990 static Handle<Object> SetHiddenProperty(Handle<JSObject> object,
1992 Handle<Object> value);
1993 // Gets the value of a hidden property with the given key. Returns the hole
1994 // if the property doesn't exist (or if called on a detached proxy),
1995 // otherwise returns the value set for the key.
1996 Object* GetHiddenProperty(Handle<Name> key);
1997 // Deletes a hidden property. Deleting a non-existing property is
1998 // considered successful.
1999 static void DeleteHiddenProperty(Handle<JSObject> object,
2001 // Returns true if the object has a property with the hidden string as name.
2002 static bool HasHiddenProperties(Handle<JSObject> object);
2004 static void SetIdentityHash(Handle<JSObject> object, Handle<Smi> hash);
2006 static void ValidateElements(Handle<JSObject> object);
2008 // Makes sure that this object can contain HeapObject as elements.
2009 static inline void EnsureCanContainHeapObjectElements(Handle<JSObject> obj);
2011 // Makes sure that this object can contain the specified elements.
2012 static inline void EnsureCanContainElements(
2013 Handle<JSObject> object,
2016 EnsureElementsMode mode);
2017 static inline void EnsureCanContainElements(
2018 Handle<JSObject> object,
2019 Handle<FixedArrayBase> elements,
2021 EnsureElementsMode mode);
2022 static void EnsureCanContainElements(
2023 Handle<JSObject> object,
2024 Arguments* arguments,
2027 EnsureElementsMode mode);
2029 // Would we convert a fast elements array to dictionary mode given
2030 // an access at key?
2031 bool WouldConvertToSlowElements(uint32_t index);
2033 // Computes the new capacity when expanding the elements of a JSObject.
2034 static uint32_t NewElementsCapacity(uint32_t old_capacity) {
2035 // (old_capacity + 50%) + 16
2036 return old_capacity + (old_capacity >> 1) + 16;
2039 // These methods do not perform access checks!
2040 static void UpdateAllocationSite(Handle<JSObject> object,
2041 ElementsKind to_kind);
2043 // Lookup interceptors are used for handling properties controlled by host
2045 inline bool HasNamedInterceptor();
2046 inline bool HasIndexedInterceptor();
2048 // Computes the enumerable keys from interceptors. Used for debug mirrors and
2049 // by JSReceiver::GetKeys.
2050 MUST_USE_RESULT static MaybeHandle<JSObject> GetKeysForNamedInterceptor(
2051 Handle<JSObject> object,
2052 Handle<JSReceiver> receiver);
2053 MUST_USE_RESULT static MaybeHandle<JSObject> GetKeysForIndexedInterceptor(
2054 Handle<JSObject> object,
2055 Handle<JSReceiver> receiver);
2057 // Support functions for v8 api (needed for correct interceptor behavior).
2058 MUST_USE_RESULT static Maybe<bool> HasRealNamedProperty(
2059 Handle<JSObject> object, Handle<Name> name);
2060 MUST_USE_RESULT static Maybe<bool> HasRealElementProperty(
2061 Handle<JSObject> object, uint32_t index);
2062 MUST_USE_RESULT static Maybe<bool> HasRealNamedCallbackProperty(
2063 Handle<JSObject> object, Handle<Name> name);
2065 // Get the header size for a JSObject. Used to compute the index of
2066 // internal fields as well as the number of internal fields.
2067 inline int GetHeaderSize();
2069 inline int GetInternalFieldCount();
2070 inline int GetInternalFieldOffset(int index);
2071 inline Object* GetInternalField(int index);
2072 inline void SetInternalField(int index, Object* value);
2073 inline void SetInternalField(int index, Smi* value);
2075 // Returns the number of properties on this object filtering out properties
2076 // with the specified attributes (ignoring interceptors).
2077 int NumberOfOwnProperties(PropertyAttributes filter = NONE);
2078 // Fill in details for properties into storage starting at the specified
2079 // index. Returns the number of properties added.
2080 int GetOwnPropertyNames(FixedArray* storage, int index,
2081 PropertyAttributes filter = NONE);
2083 // Returns the number of properties on this object filtering out properties
2084 // with the specified attributes (ignoring interceptors).
2085 int NumberOfOwnElements(PropertyAttributes filter);
2086 // Returns the number of enumerable elements (ignoring interceptors).
2087 int NumberOfEnumElements();
2088 // Returns the number of elements on this object filtering out elements
2089 // with the specified attributes (ignoring interceptors).
2090 int GetOwnElementKeys(FixedArray* storage, PropertyAttributes filter);
2091 // Count and fill in the enumerable elements into storage.
2092 // (storage->length() == NumberOfEnumElements()).
2093 // If storage is NULL, will count the elements without adding
2094 // them to any storage.
2095 // Returns the number of enumerable elements.
2096 int GetEnumElementKeys(FixedArray* storage);
2098 static Handle<FixedArray> GetEnumPropertyKeys(Handle<JSObject> object,
2101 // Returns a new map with all transitions dropped from the object's current
2102 // map and the ElementsKind set.
2103 static Handle<Map> GetElementsTransitionMap(Handle<JSObject> object,
2104 ElementsKind to_kind);
2105 static void TransitionElementsKind(Handle<JSObject> object,
2106 ElementsKind to_kind);
2108 // Always use this to migrate an object to a new map.
2109 // |expected_additional_properties| is only used for fast-to-slow transitions
2110 // and ignored otherwise.
2111 static void MigrateToMap(Handle<JSObject> object, Handle<Map> new_map,
2112 int expected_additional_properties = 0);
2114 // Convert the object to use the canonical dictionary
2115 // representation. If the object is expected to have additional properties
2116 // added this number can be indicated to have the backing store allocated to
2117 // an initial capacity for holding these properties.
2118 static void NormalizeProperties(Handle<JSObject> object,
2119 PropertyNormalizationMode mode,
2120 int expected_additional_properties,
2121 const char* reason);
2123 // Convert and update the elements backing store to be a
2124 // SeededNumberDictionary dictionary. Returns the backing after conversion.
2125 static Handle<SeededNumberDictionary> NormalizeElements(
2126 Handle<JSObject> object);
2128 void RequireSlowElements(SeededNumberDictionary* dictionary);
2130 // Transform slow named properties to fast variants.
2131 static void MigrateSlowToFast(Handle<JSObject> object,
2132 int unused_property_fields, const char* reason);
2134 inline bool IsUnboxedDoubleField(FieldIndex index);
2136 // Access fast-case object properties at index.
2137 static Handle<Object> FastPropertyAt(Handle<JSObject> object,
2138 Representation representation,
2140 inline Object* RawFastPropertyAt(FieldIndex index);
2141 inline double RawFastDoublePropertyAt(FieldIndex index);
2143 inline void FastPropertyAtPut(FieldIndex index, Object* value);
2144 inline void RawFastPropertyAtPut(FieldIndex index, Object* value);
2145 inline void RawFastDoublePropertyAtPut(FieldIndex index, double value);
2146 inline void WriteToField(int descriptor, Object* value);
2148 // Access to in object properties.
2149 inline int GetInObjectPropertyOffset(int index);
2150 inline Object* InObjectPropertyAt(int index);
2151 inline Object* InObjectPropertyAtPut(int index,
2153 WriteBarrierMode mode
2154 = UPDATE_WRITE_BARRIER);
2156 // Set the object's prototype (only JSReceiver and null are allowed values).
2157 MUST_USE_RESULT static MaybeHandle<Object> SetPrototype(
2158 Handle<JSObject> object, Handle<Object> value, bool from_javascript);
2160 // Initializes the body after properties slot, properties slot is
2161 // initialized by set_properties. Fill the pre-allocated fields with
2162 // pre_allocated_value and the rest with filler_value.
2163 // Note: this call does not update write barrier, the caller is responsible
2164 // to ensure that |filler_value| can be collected without WB here.
2165 inline void InitializeBody(Map* map,
2166 Object* pre_allocated_value,
2167 Object* filler_value);
2169 // Check whether this object references another object
2170 bool ReferencesObject(Object* obj);
2172 // Disalow further properties to be added to the oject.
2173 MUST_USE_RESULT static MaybeHandle<Object> PreventExtensions(
2174 Handle<JSObject> object);
2176 bool IsExtensible();
2179 MUST_USE_RESULT static MaybeHandle<Object> Seal(Handle<JSObject> object);
2181 // ES5 Object.freeze
2182 MUST_USE_RESULT static MaybeHandle<Object> Freeze(Handle<JSObject> object);
2184 // Called the first time an object is observed with ES7 Object.observe.
2185 static void SetObserved(Handle<JSObject> object);
2188 enum DeepCopyHints { kNoHints = 0, kObjectIsShallow = 1 };
2190 MUST_USE_RESULT static MaybeHandle<JSObject> DeepCopy(
2191 Handle<JSObject> object,
2192 AllocationSiteUsageContext* site_context,
2193 DeepCopyHints hints = kNoHints);
2194 MUST_USE_RESULT static MaybeHandle<JSObject> DeepWalk(
2195 Handle<JSObject> object,
2196 AllocationSiteCreationContext* site_context);
2198 DECLARE_CAST(JSObject)
2200 // Dispatched behavior.
2201 void JSObjectShortPrint(StringStream* accumulator);
2202 DECLARE_PRINTER(JSObject)
2203 DECLARE_VERIFIER(JSObject)
2205 void PrintProperties(std::ostream& os); // NOLINT
2206 void PrintElements(std::ostream& os); // NOLINT
2208 #if defined(DEBUG) || defined(OBJECT_PRINT)
2209 void PrintTransitions(std::ostream& os); // NOLINT
2212 static void PrintElementsTransition(
2213 FILE* file, Handle<JSObject> object,
2214 ElementsKind from_kind, Handle<FixedArrayBase> from_elements,
2215 ElementsKind to_kind, Handle<FixedArrayBase> to_elements);
2217 void PrintInstanceMigration(FILE* file, Map* original_map, Map* new_map);
2220 // Structure for collecting spill information about JSObjects.
2221 class SpillInformation {
2225 int number_of_objects_;
2226 int number_of_objects_with_fast_properties_;
2227 int number_of_objects_with_fast_elements_;
2228 int number_of_fast_used_fields_;
2229 int number_of_fast_unused_fields_;
2230 int number_of_slow_used_properties_;
2231 int number_of_slow_unused_properties_;
2232 int number_of_fast_used_elements_;
2233 int number_of_fast_unused_elements_;
2234 int number_of_slow_used_elements_;
2235 int number_of_slow_unused_elements_;
2238 void IncrementSpillStatistics(SpillInformation* info);
2242 // If a GC was caused while constructing this object, the elements pointer
2243 // may point to a one pointer filler map. The object won't be rooted, but
2244 // our heap verification code could stumble across it.
2245 bool ElementsAreSafeToExamine();
2248 Object* SlowReverseLookup(Object* value);
2250 // Maximal number of elements (numbered 0 .. kMaxElementCount - 1).
2251 // Also maximal value of JSArray's length property.
2252 static const uint32_t kMaxElementCount = 0xffffffffu;
2254 // Constants for heuristics controlling conversion of fast elements
2255 // to slow elements.
2257 // Maximal gap that can be introduced by adding an element beyond
2258 // the current elements length.
2259 static const uint32_t kMaxGap = 1024;
2261 // Maximal length of fast elements array that won't be checked for
2262 // being dense enough on expansion.
2263 static const int kMaxUncheckedFastElementsLength = 5000;
2265 // Same as above but for old arrays. This limit is more strict. We
2266 // don't want to be wasteful with long lived objects.
2267 static const int kMaxUncheckedOldFastElementsLength = 500;
2269 // Note that Page::kMaxRegularHeapObjectSize puts a limit on
2270 // permissible values (see the DCHECK in heap.cc).
2271 static const int kInitialMaxFastElementArray = 100000;
2273 // This constant applies only to the initial map of "global.Object" and
2274 // not to arbitrary other JSObject maps.
2275 static const int kInitialGlobalObjectUnusedPropertiesCount = 4;
2277 static const int kMaxInstanceSize = 255 * kPointerSize;
2278 // When extending the backing storage for property values, we increase
2279 // its size by more than the 1 entry necessary, so sequentially adding fields
2280 // to the same object requires fewer allocations and copies.
2281 static const int kFieldsAdded = 3;
2283 // Layout description.
2284 static const int kPropertiesOffset = HeapObject::kHeaderSize;
2285 static const int kElementsOffset = kPropertiesOffset + kPointerSize;
2286 static const int kHeaderSize = kElementsOffset + kPointerSize;
2288 STATIC_ASSERT(kHeaderSize == Internals::kJSObjectHeaderSize);
2290 class BodyDescriptor : public FlexibleBodyDescriptor<kPropertiesOffset> {
2292 static inline int SizeOf(Map* map, HeapObject* object);
2295 Context* GetCreationContext();
2297 // Enqueue change record for Object.observe. May cause GC.
2298 MUST_USE_RESULT static MaybeHandle<Object> EnqueueChangeRecord(
2299 Handle<JSObject> object, const char* type, Handle<Name> name,
2300 Handle<Object> old_value);
2302 // Gets the number of currently used elements.
2303 int GetFastElementsUsage();
2305 // Deletes an existing named property in a normalized object.
2306 static void DeleteNormalizedProperty(Handle<JSObject> object,
2307 Handle<Name> name, int entry);
2309 static bool AllCanRead(LookupIterator* it);
2310 static bool AllCanWrite(LookupIterator* it);
2313 friend class JSReceiver;
2314 friend class Object;
2316 static void MigrateFastToFast(Handle<JSObject> object, Handle<Map> new_map);
2317 static void MigrateFastToSlow(Handle<JSObject> object,
2318 Handle<Map> new_map,
2319 int expected_additional_properties);
2321 // Used from Object::GetProperty().
2322 MUST_USE_RESULT static MaybeHandle<Object> GetPropertyWithFailedAccessCheck(
2323 LookupIterator* it);
2325 MUST_USE_RESULT static MaybeHandle<Object> SetPropertyWithFailedAccessCheck(
2326 LookupIterator* it, Handle<Object> value);
2328 // Add a property to a slow-case object.
2329 static void AddSlowProperty(Handle<JSObject> object,
2331 Handle<Object> value,
2332 PropertyAttributes attributes);
2334 MUST_USE_RESULT static MaybeHandle<Object> DeletePropertyWithInterceptor(
2335 LookupIterator* it);
2337 bool ReferencesObjectFromElements(FixedArray* elements,
2341 // Return the hash table backing store or the inline stored identity hash,
2342 // whatever is found.
2343 MUST_USE_RESULT Object* GetHiddenPropertiesHashTable();
2345 // Return the hash table backing store for hidden properties. If there is no
2346 // backing store, allocate one.
2347 static Handle<ObjectHashTable> GetOrCreateHiddenPropertiesHashtable(
2348 Handle<JSObject> object);
2350 // Set the hidden property backing store to either a hash table or
2351 // the inline-stored identity hash.
2352 static Handle<Object> SetHiddenPropertiesHashTable(
2353 Handle<JSObject> object,
2354 Handle<Object> value);
2356 MUST_USE_RESULT Object* GetIdentityHash();
2358 static Handle<Smi> GetOrCreateIdentityHash(Handle<JSObject> object);
2360 static Handle<SeededNumberDictionary> GetNormalizedElementDictionary(
2361 Handle<JSObject> object, Handle<FixedArrayBase> elements);
2363 // Helper for fast versions of preventExtensions, seal, and freeze.
2364 // attrs is one of NONE, SEALED, or FROZEN (depending on the operation).
2365 template <PropertyAttributes attrs>
2366 MUST_USE_RESULT static MaybeHandle<Object> PreventExtensionsWithTransition(
2367 Handle<JSObject> object);
2369 DISALLOW_IMPLICIT_CONSTRUCTORS(JSObject);
2373 // Common superclass for FixedArrays that allow implementations to share
2374 // common accessors and some code paths.
2375 class FixedArrayBase: public HeapObject {
2377 // [length]: length of the array.
2378 inline int length() const;
2379 inline void set_length(int value);
2381 // Get and set the length using acquire loads and release stores.
2382 inline int synchronized_length() const;
2383 inline void synchronized_set_length(int value);
2385 DECLARE_CAST(FixedArrayBase)
2387 // Layout description.
2388 // Length is smi tagged when it is stored.
2389 static const int kLengthOffset = HeapObject::kHeaderSize;
2390 static const int kHeaderSize = kLengthOffset + kPointerSize;
2394 class FixedDoubleArray;
2395 class IncrementalMarking;
2398 // FixedArray describes fixed-sized arrays with element type Object*.
2399 class FixedArray: public FixedArrayBase {
2401 // Setter and getter for elements.
2402 inline Object* get(int index) const;
2403 static inline Handle<Object> get(Handle<FixedArray> array, int index);
2404 // Setter that uses write barrier.
2405 inline void set(int index, Object* value);
2406 inline bool is_the_hole(int index);
2408 // Setter that doesn't need write barrier.
2409 inline void set(int index, Smi* value);
2410 // Setter with explicit barrier mode.
2411 inline void set(int index, Object* value, WriteBarrierMode mode);
2413 // Setters for frequently used oddballs located in old space.
2414 inline void set_undefined(int index);
2415 inline void set_null(int index);
2416 inline void set_the_hole(int index);
2418 inline Object** GetFirstElementAddress();
2419 inline bool ContainsOnlySmisOrHoles();
2421 // Gives access to raw memory which stores the array's data.
2422 inline Object** data_start();
2424 inline void FillWithHoles(int from, int to);
2426 // Shrink length and insert filler objects.
2427 void Shrink(int length);
2429 enum KeyFilter { ALL_KEYS, NON_SYMBOL_KEYS };
2431 // Add the elements of a JSArray to this FixedArray.
2432 MUST_USE_RESULT static MaybeHandle<FixedArray> AddKeysFromArrayLike(
2433 Handle<FixedArray> content, Handle<JSObject> array,
2434 KeyFilter filter = ALL_KEYS);
2436 // Computes the union of keys and return the result.
2437 // Used for implementing "for (n in object) { }"
2438 MUST_USE_RESULT static MaybeHandle<FixedArray> UnionOfKeys(
2439 Handle<FixedArray> first,
2440 Handle<FixedArray> second);
2442 // Copy a sub array from the receiver to dest.
2443 void CopyTo(int pos, FixedArray* dest, int dest_pos, int len);
2445 // Garbage collection support.
2446 static int SizeFor(int length) { return kHeaderSize + length * kPointerSize; }
2448 // Code Generation support.
2449 static int OffsetOfElementAt(int index) { return SizeFor(index); }
2451 // Garbage collection support.
2452 inline Object** RawFieldOfElementAt(int index);
2454 DECLARE_CAST(FixedArray)
2456 // Maximal allowed size, in bytes, of a single FixedArray.
2457 // Prevents overflowing size computations, as well as extreme memory
2459 static const int kMaxSize = 128 * MB * kPointerSize;
2460 // Maximally allowed length of a FixedArray.
2461 static const int kMaxLength = (kMaxSize - kHeaderSize) / kPointerSize;
2463 // Dispatched behavior.
2464 DECLARE_PRINTER(FixedArray)
2465 DECLARE_VERIFIER(FixedArray)
2467 // Checks if two FixedArrays have identical contents.
2468 bool IsEqualTo(FixedArray* other);
2471 // Swap two elements in a pair of arrays. If this array and the
2472 // numbers array are the same object, the elements are only swapped
2474 void SwapPairs(FixedArray* numbers, int i, int j);
2476 // Sort prefix of this array and the numbers array as pairs wrt. the
2477 // numbers. If the numbers array and the this array are the same
2478 // object, the prefix of this array is sorted.
2479 void SortPairs(FixedArray* numbers, uint32_t len);
2481 class BodyDescriptor : public FlexibleBodyDescriptor<kHeaderSize> {
2483 static inline int SizeOf(Map* map, HeapObject* object);
2487 // Set operation on FixedArray without using write barriers. Can
2488 // only be used for storing old space objects or smis.
2489 static inline void NoWriteBarrierSet(FixedArray* array,
2493 // Set operation on FixedArray without incremental write barrier. Can
2494 // only be used if the object is guaranteed to be white (whiteness witness
2496 static inline void NoIncrementalWriteBarrierSet(FixedArray* array,
2501 STATIC_ASSERT(kHeaderSize == Internals::kFixedArrayHeaderSize);
2503 DISALLOW_IMPLICIT_CONSTRUCTORS(FixedArray);
2507 // FixedDoubleArray describes fixed-sized arrays with element type double.
2508 class FixedDoubleArray: public FixedArrayBase {
2510 // Setter and getter for elements.
2511 inline double get_scalar(int index);
2512 inline uint64_t get_representation(int index);
2513 static inline Handle<Object> get(Handle<FixedDoubleArray> array, int index);
2514 inline void set(int index, double value);
2515 inline void set_the_hole(int index);
2517 // Checking for the hole.
2518 inline bool is_the_hole(int index);
2520 // Garbage collection support.
2521 inline static int SizeFor(int length) {
2522 return kHeaderSize + length * kDoubleSize;
2525 // Gives access to raw memory which stores the array's data.
2526 inline double* data_start();
2528 inline void FillWithHoles(int from, int to);
2530 // Code Generation support.
2531 static int OffsetOfElementAt(int index) { return SizeFor(index); }
2533 DECLARE_CAST(FixedDoubleArray)
2535 // Maximal allowed size, in bytes, of a single FixedDoubleArray.
2536 // Prevents overflowing size computations, as well as extreme memory
2538 static const int kMaxSize = 512 * MB;
2539 // Maximally allowed length of a FixedArray.
2540 static const int kMaxLength = (kMaxSize - kHeaderSize) / kDoubleSize;
2542 // Dispatched behavior.
2543 DECLARE_PRINTER(FixedDoubleArray)
2544 DECLARE_VERIFIER(FixedDoubleArray)
2547 DISALLOW_IMPLICIT_CONSTRUCTORS(FixedDoubleArray);
2551 class WeakFixedArray : public FixedArray {
2553 // If |maybe_array| is not a WeakFixedArray, a fresh one will be allocated.
2554 // This function does not check if the value exists already, callers must
2555 // ensure this themselves if necessary.
2556 static Handle<WeakFixedArray> Add(Handle<Object> maybe_array,
2557 Handle<HeapObject> value,
2558 int* assigned_index = NULL);
2560 // Returns true if an entry was found and removed.
2561 bool Remove(Handle<HeapObject> value);
2563 class NullCallback {
2565 static void Callback(Object* value, int old_index, int new_index) {}
2568 template <class CompactionCallback>
2571 inline Object* Get(int index) const;
2572 inline void Clear(int index);
2573 inline int Length() const;
2575 inline bool IsEmptySlot(int index) const;
2576 static Object* Empty() { return Smi::FromInt(0); }
2580 explicit Iterator(Object* maybe_array) : list_(NULL) { Reset(maybe_array); }
2581 void Reset(Object* maybe_array);
2588 WeakFixedArray* list_;
2590 int last_used_index_;
2591 DisallowHeapAllocation no_gc_;
2593 DISALLOW_COPY_AND_ASSIGN(Iterator);
2596 DECLARE_CAST(WeakFixedArray)
2599 static const int kLastUsedIndexIndex = 0;
2600 static const int kFirstIndex = 1;
2602 static Handle<WeakFixedArray> Allocate(
2603 Isolate* isolate, int size, Handle<WeakFixedArray> initialize_from);
2605 static void Set(Handle<WeakFixedArray> array, int index,
2606 Handle<HeapObject> value);
2607 inline void clear(int index);
2609 inline int last_used_index() const;
2610 inline void set_last_used_index(int index);
2612 // Disallow inherited setters.
2613 void set(int index, Smi* value);
2614 void set(int index, Object* value);
2615 void set(int index, Object* value, WriteBarrierMode mode);
2616 DISALLOW_IMPLICIT_CONSTRUCTORS(WeakFixedArray);
2620 // Generic array grows dynamically with O(1) amortized insertion.
2621 class ArrayList : public FixedArray {
2625 // Use this if GC can delete elements from the array.
2626 kReloadLengthAfterAllocation,
2628 static Handle<ArrayList> Add(Handle<ArrayList> array, Handle<Object> obj,
2629 AddMode mode = kNone);
2630 static Handle<ArrayList> Add(Handle<ArrayList> array, Handle<Object> obj1,
2631 Handle<Object> obj2, AddMode = kNone);
2632 inline int Length();
2633 inline void SetLength(int length);
2634 inline Object* Get(int index);
2635 inline Object** Slot(int index);
2636 inline void Set(int index, Object* obj);
2637 inline void Clear(int index, Object* undefined);
2638 DECLARE_CAST(ArrayList)
2641 static Handle<ArrayList> EnsureSpace(Handle<ArrayList> array, int length);
2642 static const int kLengthIndex = 0;
2643 static const int kFirstIndex = 1;
2644 DISALLOW_IMPLICIT_CONSTRUCTORS(ArrayList);
2648 // DescriptorArrays are fixed arrays used to hold instance descriptors.
2649 // The format of the these objects is:
2650 // [0]: Number of descriptors
2651 // [1]: Either Smi(0) if uninitialized, or a pointer to small fixed array:
2652 // [0]: pointer to fixed array with enum cache
2653 // [1]: either Smi(0) or pointer to fixed array with indices
2655 // [2 + number of descriptors * kDescriptorSize]: start of slack
2656 class DescriptorArray: public FixedArray {
2658 // Returns true for both shared empty_descriptor_array and for smis, which the
2659 // map uses to encode additional bit fields when the descriptor array is not
2661 inline bool IsEmpty();
2663 // Returns the number of descriptors in the array.
2664 inline int number_of_descriptors();
2666 inline int number_of_descriptors_storage();
2668 inline int NumberOfSlackDescriptors();
2670 inline void SetNumberOfDescriptors(int number_of_descriptors);
2671 inline int number_of_entries();
2673 inline bool HasEnumCache();
2675 inline void CopyEnumCacheFrom(DescriptorArray* array);
2677 inline FixedArray* GetEnumCache();
2679 inline bool HasEnumIndicesCache();
2681 inline FixedArray* GetEnumIndicesCache();
2683 inline Object** GetEnumCacheSlot();
2685 void ClearEnumCache();
2687 // Initialize or change the enum cache,
2688 // using the supplied storage for the small "bridge".
2689 void SetEnumCache(FixedArray* bridge_storage,
2690 FixedArray* new_cache,
2691 Object* new_index_cache);
2693 bool CanHoldValue(int descriptor, Object* value);
2695 // Accessors for fetching instance descriptor at descriptor number.
2696 inline Name* GetKey(int descriptor_number);
2697 inline Object** GetKeySlot(int descriptor_number);
2698 inline Object* GetValue(int descriptor_number);
2699 inline void SetValue(int descriptor_number, Object* value);
2700 inline Object** GetValueSlot(int descriptor_number);
2701 static inline int GetValueOffset(int descriptor_number);
2702 inline Object** GetDescriptorStartSlot(int descriptor_number);
2703 inline Object** GetDescriptorEndSlot(int descriptor_number);
2704 inline PropertyDetails GetDetails(int descriptor_number);
2705 inline PropertyType GetType(int descriptor_number);
2706 inline int GetFieldIndex(int descriptor_number);
2707 inline HeapType* GetFieldType(int descriptor_number);
2708 inline Object* GetConstant(int descriptor_number);
2709 inline Object* GetCallbacksObject(int descriptor_number);
2710 inline AccessorDescriptor* GetCallbacks(int descriptor_number);
2712 inline Name* GetSortedKey(int descriptor_number);
2713 inline int GetSortedKeyIndex(int descriptor_number);
2714 inline void SetSortedKey(int pointer, int descriptor_number);
2715 inline void SetRepresentation(int descriptor_number,
2716 Representation representation);
2718 // Accessor for complete descriptor.
2719 inline void Get(int descriptor_number, Descriptor* desc);
2720 inline void Set(int descriptor_number, Descriptor* desc);
2721 void Replace(int descriptor_number, Descriptor* descriptor);
2723 // Append automatically sets the enumeration index. This should only be used
2724 // to add descriptors in bulk at the end, followed by sorting the descriptor
2726 inline void Append(Descriptor* desc);
2728 static Handle<DescriptorArray> CopyUpTo(Handle<DescriptorArray> desc,
2729 int enumeration_index,
2732 static Handle<DescriptorArray> CopyUpToAddAttributes(
2733 Handle<DescriptorArray> desc,
2734 int enumeration_index,
2735 PropertyAttributes attributes,
2738 // Sort the instance descriptors by the hash codes of their keys.
2741 // Search the instance descriptors for given name.
2742 INLINE(int Search(Name* name, int number_of_own_descriptors));
2744 // As the above, but uses DescriptorLookupCache and updates it when
2746 INLINE(int SearchWithCache(Name* name, Map* map));
2748 // Allocates a DescriptorArray, but returns the singleton
2749 // empty descriptor array object if number_of_descriptors is 0.
2750 static Handle<DescriptorArray> Allocate(Isolate* isolate,
2751 int number_of_descriptors,
2754 DECLARE_CAST(DescriptorArray)
2756 // Constant for denoting key was not found.
2757 static const int kNotFound = -1;
2759 static const int kDescriptorLengthIndex = 0;
2760 static const int kEnumCacheIndex = 1;
2761 static const int kFirstIndex = 2;
2763 // The length of the "bridge" to the enum cache.
2764 static const int kEnumCacheBridgeLength = 2;
2765 static const int kEnumCacheBridgeCacheIndex = 0;
2766 static const int kEnumCacheBridgeIndicesCacheIndex = 1;
2768 // Layout description.
2769 static const int kDescriptorLengthOffset = FixedArray::kHeaderSize;
2770 static const int kEnumCacheOffset = kDescriptorLengthOffset + kPointerSize;
2771 static const int kFirstOffset = kEnumCacheOffset + kPointerSize;
2773 // Layout description for the bridge array.
2774 static const int kEnumCacheBridgeCacheOffset = FixedArray::kHeaderSize;
2776 // Layout of descriptor.
2777 static const int kDescriptorKey = 0;
2778 static const int kDescriptorDetails = 1;
2779 static const int kDescriptorValue = 2;
2780 static const int kDescriptorSize = 3;
2782 #if defined(DEBUG) || defined(OBJECT_PRINT)
2783 // For our gdb macros, we should perhaps change these in the future.
2786 // Print all the descriptors.
2787 void PrintDescriptors(std::ostream& os); // NOLINT
2791 // Is the descriptor array sorted and without duplicates?
2792 bool IsSortedNoDuplicates(int valid_descriptors = -1);
2794 // Is the descriptor array consistent with the back pointers in targets?
2795 bool IsConsistentWithBackPointers(Map* current_map);
2797 // Are two DescriptorArrays equal?
2798 bool IsEqualTo(DescriptorArray* other);
2801 // Returns the fixed array length required to hold number_of_descriptors
2803 static int LengthFor(int number_of_descriptors) {
2804 return ToKeyIndex(number_of_descriptors);
2808 // WhitenessWitness is used to prove that a descriptor array is white
2809 // (unmarked), so incremental write barriers can be skipped because the
2810 // marking invariant cannot be broken and slots pointing into evacuation
2811 // candidates will be discovered when the object is scanned. A witness is
2812 // always stack-allocated right after creating an array. By allocating a
2813 // witness, incremental marking is globally disabled. The witness is then
2814 // passed along wherever needed to statically prove that the array is known to
2816 class WhitenessWitness {
2818 inline explicit WhitenessWitness(DescriptorArray* array);
2819 inline ~WhitenessWitness();
2822 IncrementalMarking* marking_;
2825 // An entry in a DescriptorArray, represented as an (array, index) pair.
2828 inline explicit Entry(DescriptorArray* descs, int index) :
2829 descs_(descs), index_(index) { }
2831 inline PropertyType type();
2832 inline Object* GetCallbackObject();
2835 DescriptorArray* descs_;
2839 // Conversion from descriptor number to array indices.
2840 static int ToKeyIndex(int descriptor_number) {
2841 return kFirstIndex +
2842 (descriptor_number * kDescriptorSize) +
2846 static int ToDetailsIndex(int descriptor_number) {
2847 return kFirstIndex +
2848 (descriptor_number * kDescriptorSize) +
2852 static int ToValueIndex(int descriptor_number) {
2853 return kFirstIndex +
2854 (descriptor_number * kDescriptorSize) +
2858 // Transfer a complete descriptor from the src descriptor array to this
2859 // descriptor array.
2860 void CopyFrom(int index, DescriptorArray* src, const WhitenessWitness&);
2862 inline void Set(int descriptor_number,
2864 const WhitenessWitness&);
2866 // Swap first and second descriptor.
2867 inline void SwapSortedKeys(int first, int second);
2869 DISALLOW_IMPLICIT_CONSTRUCTORS(DescriptorArray);
2873 enum SearchMode { ALL_ENTRIES, VALID_ENTRIES };
2875 template <SearchMode search_mode, typename T>
2876 inline int Search(T* array, Name* name, int valid_entries = 0,
2877 int* out_insertion_index = NULL);
2880 // HashTable is a subclass of FixedArray that implements a hash table
2881 // that uses open addressing and quadratic probing.
2883 // In order for the quadratic probing to work, elements that have not
2884 // yet been used and elements that have been deleted are
2885 // distinguished. Probing continues when deleted elements are
2886 // encountered and stops when unused elements are encountered.
2888 // - Elements with key == undefined have not been used yet.
2889 // - Elements with key == the_hole have been deleted.
2891 // The hash table class is parameterized with a Shape and a Key.
2892 // Shape must be a class with the following interface:
2893 // class ExampleShape {
2895 // // Tells whether key matches other.
2896 // static bool IsMatch(Key key, Object* other);
2897 // // Returns the hash value for key.
2898 // static uint32_t Hash(Key key);
2899 // // Returns the hash value for object.
2900 // static uint32_t HashForObject(Key key, Object* object);
2901 // // Convert key to an object.
2902 // static inline Handle<Object> AsHandle(Isolate* isolate, Key key);
2903 // // The prefix size indicates number of elements in the beginning
2904 // // of the backing storage.
2905 // static const int kPrefixSize = ..;
2906 // // The Element size indicates number of elements per entry.
2907 // static const int kEntrySize = ..;
2909 // The prefix size indicates an amount of memory in the
2910 // beginning of the backing storage that can be used for non-element
2911 // information by subclasses.
2913 template<typename Key>
2916 static const bool UsesSeed = false;
2917 static uint32_t Hash(Key key) { return 0; }
2918 static uint32_t SeededHash(Key key, uint32_t seed) {
2922 static uint32_t HashForObject(Key key, Object* object) { return 0; }
2923 static uint32_t SeededHashForObject(Key key, uint32_t seed, Object* object) {
2925 return HashForObject(key, object);
2930 class HashTableBase : public FixedArray {
2932 // Returns the number of elements in the hash table.
2933 inline int NumberOfElements();
2935 // Returns the number of deleted elements in the hash table.
2936 inline int NumberOfDeletedElements();
2938 // Returns the capacity of the hash table.
2939 inline int Capacity();
2941 // ElementAdded should be called whenever an element is added to a
2943 inline void ElementAdded();
2945 // ElementRemoved should be called whenever an element is removed from
2947 inline void ElementRemoved();
2948 inline void ElementsRemoved(int n);
2950 // Computes the required capacity for a table holding the given
2951 // number of elements. May be more than HashTable::kMaxCapacity.
2952 static inline int ComputeCapacity(int at_least_space_for);
2954 // Tells whether k is a real key. The hole and undefined are not allowed
2955 // as keys and can be used to indicate missing or deleted elements.
2956 inline bool IsKey(Object* k);
2958 // Compute the probe offset (quadratic probing).
2959 INLINE(static uint32_t GetProbeOffset(uint32_t n)) {
2960 return (n + n * n) >> 1;
2963 static const int kNumberOfElementsIndex = 0;
2964 static const int kNumberOfDeletedElementsIndex = 1;
2965 static const int kCapacityIndex = 2;
2966 static const int kPrefixStartIndex = 3;
2968 // Constant used for denoting a absent entry.
2969 static const int kNotFound = -1;
2972 // Update the number of elements in the hash table.
2973 inline void SetNumberOfElements(int nof);
2975 // Update the number of deleted elements in the hash table.
2976 inline void SetNumberOfDeletedElements(int nod);
2978 // Returns probe entry.
2979 static uint32_t GetProbe(uint32_t hash, uint32_t number, uint32_t size) {
2980 DCHECK(base::bits::IsPowerOfTwo32(size));
2981 return (hash + GetProbeOffset(number)) & (size - 1);
2984 inline static uint32_t FirstProbe(uint32_t hash, uint32_t size) {
2985 return hash & (size - 1);
2988 inline static uint32_t NextProbe(
2989 uint32_t last, uint32_t number, uint32_t size) {
2990 return (last + number) & (size - 1);
2995 template <typename Derived, typename Shape, typename Key>
2996 class HashTable : public HashTableBase {
2999 inline uint32_t Hash(Key key) {
3000 if (Shape::UsesSeed) {
3001 return Shape::SeededHash(key, GetHeap()->HashSeed());
3003 return Shape::Hash(key);
3007 inline uint32_t HashForObject(Key key, Object* object) {
3008 if (Shape::UsesSeed) {
3009 return Shape::SeededHashForObject(key, GetHeap()->HashSeed(), object);
3011 return Shape::HashForObject(key, object);
3015 // Returns a new HashTable object.
3016 MUST_USE_RESULT static Handle<Derived> New(
3017 Isolate* isolate, int at_least_space_for,
3018 MinimumCapacity capacity_option = USE_DEFAULT_MINIMUM_CAPACITY,
3019 PretenureFlag pretenure = NOT_TENURED);
3021 DECLARE_CAST(HashTable)
3023 // Garbage collection support.
3024 void IteratePrefix(ObjectVisitor* visitor);
3025 void IterateElements(ObjectVisitor* visitor);
3027 // Find entry for key otherwise return kNotFound.
3028 inline int FindEntry(Key key);
3029 inline int FindEntry(Isolate* isolate, Key key, int32_t hash);
3030 int FindEntry(Isolate* isolate, Key key);
3032 // Rehashes the table in-place.
3033 void Rehash(Key key);
3035 // Returns the key at entry.
3036 Object* KeyAt(int entry) { return get(EntryToIndex(entry)); }
3038 static const int kElementsStartIndex = kPrefixStartIndex + Shape::kPrefixSize;
3039 static const int kEntrySize = Shape::kEntrySize;
3040 static const int kElementsStartOffset =
3041 kHeaderSize + kElementsStartIndex * kPointerSize;
3042 static const int kCapacityOffset =
3043 kHeaderSize + kCapacityIndex * kPointerSize;
3045 // Returns the index for an entry (of the key)
3046 static inline int EntryToIndex(int entry) {
3047 return (entry * kEntrySize) + kElementsStartIndex;
3051 friend class ObjectHashTable;
3053 // Find the entry at which to insert element with the given key that
3054 // has the given hash value.
3055 uint32_t FindInsertionEntry(uint32_t hash);
3057 // Attempt to shrink hash table after removal of key.
3058 MUST_USE_RESULT static Handle<Derived> Shrink(Handle<Derived> table, Key key);
3060 // Ensure enough space for n additional elements.
3061 MUST_USE_RESULT static Handle<Derived> EnsureCapacity(
3062 Handle<Derived> table,
3065 PretenureFlag pretenure = NOT_TENURED);
3067 // Sets the capacity of the hash table.
3068 void SetCapacity(int capacity) {
3069 // To scale a computed hash code to fit within the hash table, we
3070 // use bit-wise AND with a mask, so the capacity must be positive
3072 DCHECK(capacity > 0);
3073 DCHECK(capacity <= kMaxCapacity);
3074 set(kCapacityIndex, Smi::FromInt(capacity));
3077 // Maximal capacity of HashTable. Based on maximal length of underlying
3078 // FixedArray. Staying below kMaxCapacity also ensures that EntryToIndex
3080 static const int kMaxCapacity =
3081 (FixedArray::kMaxLength - kElementsStartOffset) / kEntrySize;
3084 // Returns _expected_ if one of entries given by the first _probe_ probes is
3085 // equal to _expected_. Otherwise, returns the entry given by the probe
3087 uint32_t EntryForProbe(Key key, Object* k, int probe, uint32_t expected);
3089 void Swap(uint32_t entry1, uint32_t entry2, WriteBarrierMode mode);
3091 // Rehashes this hash-table into the new table.
3092 void Rehash(Handle<Derived> new_table, Key key);
3096 // HashTableKey is an abstract superclass for virtual key behavior.
3097 class HashTableKey {
3099 // Returns whether the other object matches this key.
3100 virtual bool IsMatch(Object* other) = 0;
3101 // Returns the hash value for this key.
3102 virtual uint32_t Hash() = 0;
3103 // Returns the hash value for object.
3104 virtual uint32_t HashForObject(Object* key) = 0;
3105 // Returns the key object for storing into the hash table.
3106 MUST_USE_RESULT virtual Handle<Object> AsHandle(Isolate* isolate) = 0;
3108 virtual ~HashTableKey() {}
3112 class StringTableShape : public BaseShape<HashTableKey*> {
3114 static inline bool IsMatch(HashTableKey* key, Object* value) {
3115 return key->IsMatch(value);
3118 static inline uint32_t Hash(HashTableKey* key) {
3122 static inline uint32_t HashForObject(HashTableKey* key, Object* object) {
3123 return key->HashForObject(object);
3126 static inline Handle<Object> AsHandle(Isolate* isolate, HashTableKey* key);
3128 static const int kPrefixSize = 0;
3129 static const int kEntrySize = 1;
3132 class SeqOneByteString;
3136 // No special elements in the prefix and the element size is 1
3137 // because only the string itself (the key) needs to be stored.
3138 class StringTable: public HashTable<StringTable,
3142 // Find string in the string table. If it is not there yet, it is
3143 // added. The return value is the string found.
3144 static Handle<String> LookupString(Isolate* isolate, Handle<String> key);
3145 static Handle<String> LookupKey(Isolate* isolate, HashTableKey* key);
3146 static String* LookupKeyIfExists(Isolate* isolate, HashTableKey* key);
3148 // Tries to internalize given string and returns string handle on success
3149 // or an empty handle otherwise.
3150 MUST_USE_RESULT static MaybeHandle<String> InternalizeStringIfExists(
3152 Handle<String> string);
3154 // Looks up a string that is equal to the given string and returns
3155 // string handle if it is found, or an empty handle otherwise.
3156 MUST_USE_RESULT static MaybeHandle<String> LookupStringIfExists(
3158 Handle<String> str);
3159 MUST_USE_RESULT static MaybeHandle<String> LookupTwoCharsStringIfExists(
3164 static void EnsureCapacityForDeserialization(Isolate* isolate, int expected);
3166 DECLARE_CAST(StringTable)
3169 template <bool seq_one_byte>
3170 friend class JsonParser;
3172 DISALLOW_IMPLICIT_CONSTRUCTORS(StringTable);
3176 template <typename Derived, typename Shape, typename Key>
3177 class Dictionary: public HashTable<Derived, Shape, Key> {
3178 typedef HashTable<Derived, Shape, Key> DerivedHashTable;
3181 // Returns the value at entry.
3182 Object* ValueAt(int entry) {
3183 return this->get(Derived::EntryToIndex(entry) + 1);
3186 // Set the value for entry.
3187 void ValueAtPut(int entry, Object* value) {
3188 this->set(Derived::EntryToIndex(entry) + 1, value);
3191 // Returns the property details for the property at entry.
3192 PropertyDetails DetailsAt(int entry) {
3193 return Shape::DetailsAt(static_cast<Derived*>(this), entry);
3196 // Set the details for entry.
3197 void DetailsAtPut(int entry, PropertyDetails value) {
3198 Shape::DetailsAtPut(static_cast<Derived*>(this), entry, value);
3201 // Returns true if property at given entry is deleted.
3202 bool IsDeleted(int entry) {
3203 return Shape::IsDeleted(static_cast<Derived*>(this), entry);
3206 // Delete a property from the dictionary.
3207 static Handle<Object> DeleteProperty(Handle<Derived> dictionary, int entry);
3209 // Attempt to shrink the dictionary after deletion of key.
3210 MUST_USE_RESULT static inline Handle<Derived> Shrink(
3211 Handle<Derived> dictionary,
3213 return DerivedHashTable::Shrink(dictionary, key);
3217 // TODO(dcarney): templatize or move to SeededNumberDictionary
3218 void CopyValuesTo(FixedArray* elements);
3220 // Returns the number of elements in the dictionary filtering out properties
3221 // with the specified attributes.
3222 int NumberOfElementsFilterAttributes(PropertyAttributes filter);
3224 // Returns the number of enumerable elements in the dictionary.
3225 int NumberOfEnumElements() {
3226 return NumberOfElementsFilterAttributes(
3227 static_cast<PropertyAttributes>(DONT_ENUM | SYMBOLIC));
3230 // Returns true if the dictionary contains any elements that are non-writable,
3231 // non-configurable, non-enumerable, or have getters/setters.
3232 bool HasComplexElements();
3234 enum SortMode { UNSORTED, SORTED };
3236 // Fill in details for properties into storage.
3237 // Returns the number of properties added.
3238 int CopyKeysTo(FixedArray* storage, int index, PropertyAttributes filter,
3239 SortMode sort_mode);
3241 // Copies enumerable keys to preallocated fixed array.
3242 void CopyEnumKeysTo(FixedArray* storage);
3244 // Accessors for next enumeration index.
3245 void SetNextEnumerationIndex(int index) {
3247 this->set(kNextEnumerationIndexIndex, Smi::FromInt(index));
3250 int NextEnumerationIndex() {
3251 return Smi::cast(this->get(kNextEnumerationIndexIndex))->value();
3254 // Creates a new dictionary.
3255 MUST_USE_RESULT static Handle<Derived> New(
3257 int at_least_space_for,
3258 PretenureFlag pretenure = NOT_TENURED);
3260 // Ensure enough space for n additional elements.
3261 static Handle<Derived> EnsureCapacity(Handle<Derived> obj, int n, Key key);
3264 void Print(std::ostream& os); // NOLINT
3266 // Returns the key (slow).
3267 Object* SlowReverseLookup(Object* value);
3269 // Sets the entry to (key, value) pair.
3270 inline void SetEntry(int entry,
3272 Handle<Object> value);
3273 inline void SetEntry(int entry,
3275 Handle<Object> value,
3276 PropertyDetails details);
3278 MUST_USE_RESULT static Handle<Derived> Add(
3279 Handle<Derived> dictionary,
3281 Handle<Object> value,
3282 PropertyDetails details);
3284 // Returns iteration indices array for the |dictionary|.
3285 // Values are direct indices in the |HashTable| array.
3286 static Handle<FixedArray> BuildIterationIndicesArray(
3287 Handle<Derived> dictionary);
3290 // Generic at put operation.
3291 MUST_USE_RESULT static Handle<Derived> AtPut(
3292 Handle<Derived> dictionary,
3294 Handle<Object> value);
3296 // Add entry to dictionary.
3297 static void AddEntry(
3298 Handle<Derived> dictionary,
3300 Handle<Object> value,
3301 PropertyDetails details,
3304 // Generate new enumeration indices to avoid enumeration index overflow.
3305 // Returns iteration indices array for the |dictionary|.
3306 static Handle<FixedArray> GenerateNewEnumerationIndices(
3307 Handle<Derived> dictionary);
3308 static const int kMaxNumberKeyIndex = DerivedHashTable::kPrefixStartIndex;
3309 static const int kNextEnumerationIndexIndex = kMaxNumberKeyIndex + 1;
3313 template <typename Derived, typename Shape>
3314 class NameDictionaryBase : public Dictionary<Derived, Shape, Handle<Name> > {
3315 typedef Dictionary<Derived, Shape, Handle<Name> > DerivedDictionary;
3318 // Find entry for key, otherwise return kNotFound. Optimized version of
3319 // HashTable::FindEntry.
3320 int FindEntry(Handle<Name> key);
3324 template <typename Key>
3325 class BaseDictionaryShape : public BaseShape<Key> {
3327 template <typename Dictionary>
3328 static inline PropertyDetails DetailsAt(Dictionary* dict, int entry) {
3329 STATIC_ASSERT(Dictionary::kEntrySize == 3);
3330 DCHECK(entry >= 0); // Not found is -1, which is not caught by get().
3331 return PropertyDetails(
3332 Smi::cast(dict->get(Dictionary::EntryToIndex(entry) + 2)));
3335 template <typename Dictionary>
3336 static inline void DetailsAtPut(Dictionary* dict, int entry,
3337 PropertyDetails value) {
3338 STATIC_ASSERT(Dictionary::kEntrySize == 3);
3339 dict->set(Dictionary::EntryToIndex(entry) + 2, value.AsSmi());
3342 template <typename Dictionary>
3343 static bool IsDeleted(Dictionary* dict, int entry) {
3347 template <typename Dictionary>
3348 static inline void SetEntry(Dictionary* dict, int entry, Handle<Object> key,
3349 Handle<Object> value, PropertyDetails details);
3353 class NameDictionaryShape : public BaseDictionaryShape<Handle<Name> > {
3355 static inline bool IsMatch(Handle<Name> key, Object* other);
3356 static inline uint32_t Hash(Handle<Name> key);
3357 static inline uint32_t HashForObject(Handle<Name> key, Object* object);
3358 static inline Handle<Object> AsHandle(Isolate* isolate, Handle<Name> key);
3359 static const int kPrefixSize = 2;
3360 static const int kEntrySize = 3;
3361 static const bool kIsEnumerable = true;
3365 class NameDictionary
3366 : public NameDictionaryBase<NameDictionary, NameDictionaryShape> {
3367 typedef NameDictionaryBase<NameDictionary, NameDictionaryShape>
3371 DECLARE_CAST(NameDictionary)
3373 inline static Handle<FixedArray> DoGenerateNewEnumerationIndices(
3374 Handle<NameDictionary> dictionary);
3378 class GlobalDictionaryShape : public NameDictionaryShape {
3380 static const int kEntrySize = 2; // Overrides NameDictionaryShape::kEntrySize
3382 template <typename Dictionary>
3383 static inline PropertyDetails DetailsAt(Dictionary* dict, int entry);
3385 template <typename Dictionary>
3386 static inline void DetailsAtPut(Dictionary* dict, int entry,
3387 PropertyDetails value);
3389 template <typename Dictionary>
3390 static bool IsDeleted(Dictionary* dict, int entry);
3392 template <typename Dictionary>
3393 static inline void SetEntry(Dictionary* dict, int entry, Handle<Object> key,
3394 Handle<Object> value, PropertyDetails details);
3398 class GlobalDictionary
3399 : public NameDictionaryBase<GlobalDictionary, GlobalDictionaryShape> {
3401 DECLARE_CAST(GlobalDictionary)
3405 class NumberDictionaryShape : public BaseDictionaryShape<uint32_t> {
3407 static inline bool IsMatch(uint32_t key, Object* other);
3408 static inline Handle<Object> AsHandle(Isolate* isolate, uint32_t key);
3409 static const int kEntrySize = 3;
3410 static const bool kIsEnumerable = false;
3414 class SeededNumberDictionaryShape : public NumberDictionaryShape {
3416 static const bool UsesSeed = true;
3417 static const int kPrefixSize = 2;
3419 static inline uint32_t SeededHash(uint32_t key, uint32_t seed);
3420 static inline uint32_t SeededHashForObject(uint32_t key,
3426 class UnseededNumberDictionaryShape : public NumberDictionaryShape {
3428 static const int kPrefixSize = 0;
3430 static inline uint32_t Hash(uint32_t key);
3431 static inline uint32_t HashForObject(uint32_t key, Object* object);
3435 class SeededNumberDictionary
3436 : public Dictionary<SeededNumberDictionary,
3437 SeededNumberDictionaryShape,
3440 DECLARE_CAST(SeededNumberDictionary)
3442 // Type specific at put (default NONE attributes is used when adding).
3443 MUST_USE_RESULT static Handle<SeededNumberDictionary> AtNumberPut(
3444 Handle<SeededNumberDictionary> dictionary, uint32_t key,
3445 Handle<Object> value, bool used_as_prototype);
3446 MUST_USE_RESULT static Handle<SeededNumberDictionary> AddNumberEntry(
3447 Handle<SeededNumberDictionary> dictionary, uint32_t key,
3448 Handle<Object> value, PropertyDetails details, bool used_as_prototype);
3450 // Set an existing entry or add a new one if needed.
3451 // Return the updated dictionary.
3452 MUST_USE_RESULT static Handle<SeededNumberDictionary> Set(
3453 Handle<SeededNumberDictionary> dictionary, uint32_t key,
3454 Handle<Object> value, PropertyDetails details, bool used_as_prototype);
3456 void UpdateMaxNumberKey(uint32_t key, bool used_as_prototype);
3458 // If slow elements are required we will never go back to fast-case
3459 // for the elements kept in this dictionary. We require slow
3460 // elements if an element has been added at an index larger than
3461 // kRequiresSlowElementsLimit or set_requires_slow_elements() has been called
3462 // when defining a getter or setter with a number key.
3463 inline bool requires_slow_elements();
3464 inline void set_requires_slow_elements();
3466 // Get the value of the max number key that has been added to this
3467 // dictionary. max_number_key can only be called if
3468 // requires_slow_elements returns false.
3469 inline uint32_t max_number_key();
3472 static const int kRequiresSlowElementsMask = 1;
3473 static const int kRequiresSlowElementsTagSize = 1;
3474 static const uint32_t kRequiresSlowElementsLimit = (1 << 29) - 1;
3478 class UnseededNumberDictionary
3479 : public Dictionary<UnseededNumberDictionary,
3480 UnseededNumberDictionaryShape,
3483 DECLARE_CAST(UnseededNumberDictionary)
3485 // Type specific at put (default NONE attributes is used when adding).
3486 MUST_USE_RESULT static Handle<UnseededNumberDictionary> AtNumberPut(
3487 Handle<UnseededNumberDictionary> dictionary,
3489 Handle<Object> value);
3490 MUST_USE_RESULT static Handle<UnseededNumberDictionary> AddNumberEntry(
3491 Handle<UnseededNumberDictionary> dictionary,
3493 Handle<Object> value);
3495 // Set an existing entry or add a new one if needed.
3496 // Return the updated dictionary.
3497 MUST_USE_RESULT static Handle<UnseededNumberDictionary> Set(
3498 Handle<UnseededNumberDictionary> dictionary,
3500 Handle<Object> value);
3504 class ObjectHashTableShape : public BaseShape<Handle<Object> > {
3506 static inline bool IsMatch(Handle<Object> key, Object* other);
3507 static inline uint32_t Hash(Handle<Object> key);
3508 static inline uint32_t HashForObject(Handle<Object> key, Object* object);
3509 static inline Handle<Object> AsHandle(Isolate* isolate, Handle<Object> key);
3510 static const int kPrefixSize = 0;
3511 static const int kEntrySize = 2;
3515 // ObjectHashTable maps keys that are arbitrary objects to object values by
3516 // using the identity hash of the key for hashing purposes.
3517 class ObjectHashTable: public HashTable<ObjectHashTable,
3518 ObjectHashTableShape,
3521 ObjectHashTable, ObjectHashTableShape, Handle<Object> > DerivedHashTable;
3523 DECLARE_CAST(ObjectHashTable)
3525 // Attempt to shrink hash table after removal of key.
3526 MUST_USE_RESULT static inline Handle<ObjectHashTable> Shrink(
3527 Handle<ObjectHashTable> table,
3528 Handle<Object> key);
3530 // Looks up the value associated with the given key. The hole value is
3531 // returned in case the key is not present.
3532 Object* Lookup(Handle<Object> key);
3533 Object* Lookup(Handle<Object> key, int32_t hash);
3534 Object* Lookup(Isolate* isolate, Handle<Object> key, int32_t hash);
3536 // Adds (or overwrites) the value associated with the given key.
3537 static Handle<ObjectHashTable> Put(Handle<ObjectHashTable> table,
3539 Handle<Object> value);
3540 static Handle<ObjectHashTable> Put(Handle<ObjectHashTable> table,
3541 Handle<Object> key, Handle<Object> value,
3544 // Returns an ObjectHashTable (possibly |table|) where |key| has been removed.
3545 static Handle<ObjectHashTable> Remove(Handle<ObjectHashTable> table,
3548 static Handle<ObjectHashTable> Remove(Handle<ObjectHashTable> table,
3549 Handle<Object> key, bool* was_present,
3553 friend class MarkCompactCollector;
3555 void AddEntry(int entry, Object* key, Object* value);
3556 void RemoveEntry(int entry);
3558 // Returns the index to the value of an entry.
3559 static inline int EntryToValueIndex(int entry) {
3560 return EntryToIndex(entry) + 1;
3565 // OrderedHashTable is a HashTable with Object keys that preserves
3566 // insertion order. There are Map and Set interfaces (OrderedHashMap
3567 // and OrderedHashTable, below). It is meant to be used by JSMap/JSSet.
3569 // Only Object* keys are supported, with Object::SameValueZero() used as the
3570 // equality operator and Object::GetHash() for the hash function.
3572 // Based on the "Deterministic Hash Table" as described by Jason Orendorff at
3573 // https://wiki.mozilla.org/User:Jorend/Deterministic_hash_tables
3574 // Originally attributed to Tyler Close.
3577 // [0]: bucket count
3578 // [1]: element count
3579 // [2]: deleted element count
3580 // [3..(3 + NumberOfBuckets() - 1)]: "hash table", where each item is an
3581 // offset into the data table (see below) where the
3582 // first item in this bucket is stored.
3583 // [3 + NumberOfBuckets()..length]: "data table", an array of length
3584 // Capacity() * kEntrySize, where the first entrysize
3585 // items are handled by the derived class and the
3586 // item at kChainOffset is another entry into the
3587 // data table indicating the next entry in this hash
3590 // When we transition the table to a new version we obsolete it and reuse parts
3591 // of the memory to store information how to transition an iterator to the new
3594 // Memory layout for obsolete table:
3595 // [0]: bucket count
3596 // [1]: Next newer table
3597 // [2]: Number of removed holes or -1 when the table was cleared.
3598 // [3..(3 + NumberOfRemovedHoles() - 1)]: The indexes of the removed holes.
3599 // [3 + NumberOfRemovedHoles()..length]: Not used
3601 template<class Derived, class Iterator, int entrysize>
3602 class OrderedHashTable: public FixedArray {
3604 // Returns an OrderedHashTable with a capacity of at least |capacity|.
3605 static Handle<Derived> Allocate(
3606 Isolate* isolate, int capacity, PretenureFlag pretenure = NOT_TENURED);
3608 // Returns an OrderedHashTable (possibly |table|) with enough space
3609 // to add at least one new element.
3610 static Handle<Derived> EnsureGrowable(Handle<Derived> table);
3612 // Returns an OrderedHashTable (possibly |table|) that's shrunken
3614 static Handle<Derived> Shrink(Handle<Derived> table);
3616 // Returns a new empty OrderedHashTable and records the clearing so that
3617 // exisiting iterators can be updated.
3618 static Handle<Derived> Clear(Handle<Derived> table);
3620 int NumberOfElements() {
3621 return Smi::cast(get(kNumberOfElementsIndex))->value();
3624 int NumberOfDeletedElements() {
3625 return Smi::cast(get(kNumberOfDeletedElementsIndex))->value();
3628 int UsedCapacity() { return NumberOfElements() + NumberOfDeletedElements(); }
3630 int NumberOfBuckets() {
3631 return Smi::cast(get(kNumberOfBucketsIndex))->value();
3634 // Returns an index into |this| for the given entry.
3635 int EntryToIndex(int entry) {
3636 return kHashTableStartIndex + NumberOfBuckets() + (entry * kEntrySize);
3639 Object* KeyAt(int entry) { return get(EntryToIndex(entry)); }
3642 return !get(kNextTableIndex)->IsSmi();
3645 // The next newer table. This is only valid if the table is obsolete.
3646 Derived* NextTable() {
3647 return Derived::cast(get(kNextTableIndex));
3650 // When the table is obsolete we store the indexes of the removed holes.
3651 int RemovedIndexAt(int index) {
3652 return Smi::cast(get(kRemovedHolesIndex + index))->value();
3655 static const int kNotFound = -1;
3656 static const int kMinCapacity = 4;
3658 static const int kNumberOfBucketsIndex = 0;
3659 static const int kNumberOfElementsIndex = kNumberOfBucketsIndex + 1;
3660 static const int kNumberOfDeletedElementsIndex = kNumberOfElementsIndex + 1;
3661 static const int kHashTableStartIndex = kNumberOfDeletedElementsIndex + 1;
3662 static const int kNextTableIndex = kNumberOfElementsIndex;
3664 static const int kNumberOfBucketsOffset =
3665 kHeaderSize + kNumberOfBucketsIndex * kPointerSize;
3666 static const int kNumberOfElementsOffset =
3667 kHeaderSize + kNumberOfElementsIndex * kPointerSize;
3668 static const int kNumberOfDeletedElementsOffset =
3669 kHeaderSize + kNumberOfDeletedElementsIndex * kPointerSize;
3670 static const int kHashTableStartOffset =
3671 kHeaderSize + kHashTableStartIndex * kPointerSize;
3672 static const int kNextTableOffset =
3673 kHeaderSize + kNextTableIndex * kPointerSize;
3675 static const int kEntrySize = entrysize + 1;
3676 static const int kChainOffset = entrysize;
3678 static const int kLoadFactor = 2;
3680 // NumberOfDeletedElements is set to kClearedTableSentinel when
3681 // the table is cleared, which allows iterator transitions to
3682 // optimize that case.
3683 static const int kClearedTableSentinel = -1;
3686 static Handle<Derived> Rehash(Handle<Derived> table, int new_capacity);
3688 void SetNumberOfBuckets(int num) {
3689 set(kNumberOfBucketsIndex, Smi::FromInt(num));
3692 void SetNumberOfElements(int num) {
3693 set(kNumberOfElementsIndex, Smi::FromInt(num));
3696 void SetNumberOfDeletedElements(int num) {
3697 set(kNumberOfDeletedElementsIndex, Smi::FromInt(num));
3701 return NumberOfBuckets() * kLoadFactor;
3704 void SetNextTable(Derived* next_table) {
3705 set(kNextTableIndex, next_table);
3708 void SetRemovedIndexAt(int index, int removed_index) {
3709 return set(kRemovedHolesIndex + index, Smi::FromInt(removed_index));
3712 static const int kRemovedHolesIndex = kHashTableStartIndex;
3714 static const int kMaxCapacity =
3715 (FixedArray::kMaxLength - kHashTableStartIndex)
3716 / (1 + (kEntrySize * kLoadFactor));
3720 class JSSetIterator;
3723 class OrderedHashSet: public OrderedHashTable<
3724 OrderedHashSet, JSSetIterator, 1> {
3726 DECLARE_CAST(OrderedHashSet)
3730 class JSMapIterator;
3733 class OrderedHashMap
3734 : public OrderedHashTable<OrderedHashMap, JSMapIterator, 2> {
3736 DECLARE_CAST(OrderedHashMap)
3738 inline Object* ValueAt(int entry);
3740 static const int kValueOffset = 1;
3744 template <int entrysize>
3745 class WeakHashTableShape : public BaseShape<Handle<Object> > {
3747 static inline bool IsMatch(Handle<Object> key, Object* other);
3748 static inline uint32_t Hash(Handle<Object> key);
3749 static inline uint32_t HashForObject(Handle<Object> key, Object* object);
3750 static inline Handle<Object> AsHandle(Isolate* isolate, Handle<Object> key);
3751 static const int kPrefixSize = 0;
3752 static const int kEntrySize = entrysize;
3756 // WeakHashTable maps keys that are arbitrary heap objects to heap object
3757 // values. The table wraps the keys in weak cells and store values directly.
3758 // Thus it references keys weakly and values strongly.
3759 class WeakHashTable: public HashTable<WeakHashTable,
3760 WeakHashTableShape<2>,
3763 WeakHashTable, WeakHashTableShape<2>, Handle<Object> > DerivedHashTable;
3765 DECLARE_CAST(WeakHashTable)
3767 // Looks up the value associated with the given key. The hole value is
3768 // returned in case the key is not present.
3769 Object* Lookup(Handle<HeapObject> key);
3771 // Adds (or overwrites) the value associated with the given key. Mapping a
3772 // key to the hole value causes removal of the whole entry.
3773 MUST_USE_RESULT static Handle<WeakHashTable> Put(Handle<WeakHashTable> table,
3774 Handle<HeapObject> key,
3775 Handle<HeapObject> value);
3777 static Handle<FixedArray> GetValues(Handle<WeakHashTable> table);
3780 friend class MarkCompactCollector;
3782 void AddEntry(int entry, Handle<WeakCell> key, Handle<HeapObject> value);
3784 // Returns the index to the value of an entry.
3785 static inline int EntryToValueIndex(int entry) {
3786 return EntryToIndex(entry) + 1;
3791 // ScopeInfo represents information about different scopes of a source
3792 // program and the allocation of the scope's variables. Scope information
3793 // is stored in a compressed form in ScopeInfo objects and is used
3794 // at runtime (stack dumps, deoptimization, etc.).
3796 // This object provides quick access to scope info details for runtime
3798 class ScopeInfo : public FixedArray {
3800 DECLARE_CAST(ScopeInfo)
3802 // Return the type of this scope.
3803 ScopeType scope_type();
3805 // Does this scope call eval?
3808 // Return the language mode of this scope.
3809 LanguageMode language_mode();
3811 // True if this scope is a (var) declaration scope.
3812 bool is_declaration_scope();
3814 // Does this scope make a sloppy eval call?
3815 bool CallsSloppyEval() { return CallsEval() && is_sloppy(language_mode()); }
3817 // Return the total number of locals allocated on the stack and in the
3818 // context. This includes the parameters that are allocated in the context.
3821 // Return the number of stack slots for code. This number consists of two
3823 // 1. One stack slot per stack allocated local.
3824 // 2. One stack slot for the function name if it is stack allocated.
3825 int StackSlotCount();
3827 // Return the number of context slots for code if a context is allocated. This
3828 // number consists of three parts:
3829 // 1. Size of fixed header for every context: Context::MIN_CONTEXT_SLOTS
3830 // 2. One context slot per context allocated local.
3831 // 3. One context slot for the function name if it is context allocated.
3832 // Parameters allocated in the context count as context allocated locals. If
3833 // no contexts are allocated for this scope ContextLength returns 0.
3834 int ContextLength();
3836 // Does this scope declare a "this" binding?
3839 // Does this scope declare a "this" binding, and the "this" binding is stack-
3840 // or context-allocated?
3841 bool HasAllocatedReceiver();
3843 // Is this scope the scope of a named function expression?
3844 bool HasFunctionName();
3846 // Return if this has context allocated locals.
3847 bool HasHeapAllocatedLocals();
3849 // Return if contexts are allocated for this scope.
3852 // Return if this is a function scope with "use asm".
3853 inline bool IsAsmModule();
3855 // Return if this is a nested function within an asm module scope.
3856 inline bool IsAsmFunction();
3858 inline bool HasSimpleParameters();
3860 // Return the function_name if present.
3861 String* FunctionName();
3863 // Return the name of the given parameter.
3864 String* ParameterName(int var);
3866 // Return the name of the given local.
3867 String* LocalName(int var);
3869 // Return the name of the given stack local.
3870 String* StackLocalName(int var);
3872 // Return the name of the given stack local.
3873 int StackLocalIndex(int var);
3875 // Return the name of the given context local.
3876 String* ContextLocalName(int var);
3878 // Return the mode of the given context local.
3879 VariableMode ContextLocalMode(int var);
3881 // Return the initialization flag of the given context local.
3882 InitializationFlag ContextLocalInitFlag(int var);
3884 // Return the initialization flag of the given context local.
3885 MaybeAssignedFlag ContextLocalMaybeAssignedFlag(int var);
3887 // Return true if this local was introduced by the compiler, and should not be
3888 // exposed to the user in a debugger.
3889 bool LocalIsSynthetic(int var);
3891 String* StrongModeFreeVariableName(int var);
3892 int StrongModeFreeVariableStartPosition(int var);
3893 int StrongModeFreeVariableEndPosition(int var);
3895 // Lookup support for serialized scope info. Returns the
3896 // the stack slot index for a given slot name if the slot is
3897 // present; otherwise returns a value < 0. The name must be an internalized
3899 int StackSlotIndex(String* name);
3901 // Lookup support for serialized scope info. Returns the
3902 // context slot index for a given slot name if the slot is present; otherwise
3903 // returns a value < 0. The name must be an internalized string.
3904 // If the slot is present and mode != NULL, sets *mode to the corresponding
3905 // mode for that variable.
3906 static int ContextSlotIndex(Handle<ScopeInfo> scope_info, Handle<String> name,
3907 VariableMode* mode, VariableLocation* location,
3908 InitializationFlag* init_flag,
3909 MaybeAssignedFlag* maybe_assigned_flag);
3911 // Lookup the name of a certain context slot by its index.
3912 String* ContextSlotName(int slot_index);
3914 // Lookup support for serialized scope info. Returns the
3915 // parameter index for a given parameter name if the parameter is present;
3916 // otherwise returns a value < 0. The name must be an internalized string.
3917 int ParameterIndex(String* name);
3919 // Lookup support for serialized scope info. Returns the function context
3920 // slot index if the function name is present and context-allocated (named
3921 // function expressions, only), otherwise returns a value < 0. The name
3922 // must be an internalized string.
3923 int FunctionContextSlotIndex(String* name, VariableMode* mode);
3925 // Lookup support for serialized scope info. Returns the receiver context
3926 // slot index if scope has a "this" binding, and the binding is
3927 // context-allocated. Otherwise returns a value < 0.
3928 int ReceiverContextSlotIndex();
3930 FunctionKind function_kind();
3932 static Handle<ScopeInfo> Create(Isolate* isolate, Zone* zone, Scope* scope);
3933 static Handle<ScopeInfo> CreateGlobalThisBinding(Isolate* isolate);
3935 // Serializes empty scope info.
3936 static ScopeInfo* Empty(Isolate* isolate);
3942 // The layout of the static part of a ScopeInfo is as follows. Each entry is
3943 // numeric and occupies one array slot.
3944 // 1. A set of properties of the scope
3945 // 2. The number of parameters. This only applies to function scopes. For
3946 // non-function scopes this is 0.
3947 // 3. The number of non-parameter variables allocated on the stack.
3948 // 4. The number of non-parameter and parameter variables allocated in the
3950 #define FOR_EACH_SCOPE_INFO_NUMERIC_FIELD(V) \
3953 V(StackLocalCount) \
3954 V(ContextLocalCount) \
3955 V(ContextGlobalCount) \
3956 V(StrongModeFreeVariableCount)
3958 #define FIELD_ACCESSORS(name) \
3959 inline void Set##name(int value); \
3961 FOR_EACH_SCOPE_INFO_NUMERIC_FIELD(FIELD_ACCESSORS)
3962 #undef FIELD_ACCESSORS
3966 #define DECL_INDEX(name) k##name,
3967 FOR_EACH_SCOPE_INFO_NUMERIC_FIELD(DECL_INDEX)
3972 // The layout of the variable part of a ScopeInfo is as follows:
3973 // 1. ParameterEntries:
3974 // This part stores the names of the parameters for function scopes. One
3975 // slot is used per parameter, so in total this part occupies
3976 // ParameterCount() slots in the array. For other scopes than function
3977 // scopes ParameterCount() is 0.
3978 // 2. StackLocalFirstSlot:
3979 // Index of a first stack slot for stack local. Stack locals belonging to
3980 // this scope are located on a stack at slots starting from this index.
3981 // 3. StackLocalEntries:
3982 // Contains the names of local variables that are allocated on the stack,
3983 // in increasing order of the stack slot index. First local variable has
3984 // a stack slot index defined in StackLocalFirstSlot (point 2 above).
3985 // One slot is used per stack local, so in total this part occupies
3986 // StackLocalCount() slots in the array.
3987 // 4. ContextLocalNameEntries:
3988 // Contains the names of local variables and parameters that are allocated
3989 // in the context. They are stored in increasing order of the context slot
3990 // index starting with Context::MIN_CONTEXT_SLOTS. One slot is used per
3991 // context local, so in total this part occupies ContextLocalCount() slots
3993 // 5. ContextLocalInfoEntries:
3994 // Contains the variable modes and initialization flags corresponding to
3995 // the context locals in ContextLocalNameEntries. One slot is used per
3996 // context local, so in total this part occupies ContextLocalCount()
3997 // slots in the array.
3998 // 6. StrongModeFreeVariableNameEntries:
3999 // Stores the names of strong mode free variables.
4000 // 7. StrongModeFreeVariablePositionEntries:
4001 // Stores the locations (start and end position) of strong mode free
4003 // 8. RecieverEntryIndex:
4004 // If the scope binds a "this" value, one slot is reserved to hold the
4005 // context or stack slot index for the variable.
4006 // 9. FunctionNameEntryIndex:
4007 // If the scope belongs to a named function expression this part contains
4008 // information about the function variable. It always occupies two array
4009 // slots: a. The name of the function variable.
4010 // b. The context or stack slot index for the variable.
4011 int ParameterEntriesIndex();
4012 int StackLocalFirstSlotIndex();
4013 int StackLocalEntriesIndex();
4014 int ContextLocalNameEntriesIndex();
4015 int ContextGlobalNameEntriesIndex();
4016 int ContextLocalInfoEntriesIndex();
4017 int ContextGlobalInfoEntriesIndex();
4018 int StrongModeFreeVariableNameEntriesIndex();
4019 int StrongModeFreeVariablePositionEntriesIndex();
4020 int ReceiverEntryIndex();
4021 int FunctionNameEntryIndex();
4023 int Lookup(Handle<String> name, int start, int end, VariableMode* mode,
4024 VariableLocation* location, InitializationFlag* init_flag,
4025 MaybeAssignedFlag* maybe_assigned_flag);
4027 // Used for the function name variable for named function expressions, and for
4029 enum VariableAllocationInfo { NONE, STACK, CONTEXT, UNUSED };
4031 // Properties of scopes.
4032 class ScopeTypeField : public BitField<ScopeType, 0, 4> {};
4033 class CallsEvalField : public BitField<bool, ScopeTypeField::kNext, 1> {};
4034 STATIC_ASSERT(LANGUAGE_END == 3);
4035 class LanguageModeField
4036 : public BitField<LanguageMode, CallsEvalField::kNext, 2> {};
4037 class DeclarationScopeField
4038 : public BitField<bool, LanguageModeField::kNext, 1> {};
4039 class ReceiverVariableField
4040 : public BitField<VariableAllocationInfo, DeclarationScopeField::kNext,
4042 class FunctionVariableField
4043 : public BitField<VariableAllocationInfo, ReceiverVariableField::kNext,
4045 class FunctionVariableMode
4046 : public BitField<VariableMode, FunctionVariableField::kNext, 3> {};
4047 class AsmModuleField : public BitField<bool, FunctionVariableMode::kNext, 1> {
4049 class AsmFunctionField : public BitField<bool, AsmModuleField::kNext, 1> {};
4050 class HasSimpleParametersField
4051 : public BitField<bool, AsmFunctionField::kNext, 1> {};
4052 class FunctionKindField
4053 : public BitField<FunctionKind, HasSimpleParametersField::kNext, 8> {};
4055 // BitFields representing the encoded information for context locals in the
4056 // ContextLocalInfoEntries part.
4057 class ContextLocalMode: public BitField<VariableMode, 0, 3> {};
4058 class ContextLocalInitFlag: public BitField<InitializationFlag, 3, 1> {};
4059 class ContextLocalMaybeAssignedFlag
4060 : public BitField<MaybeAssignedFlag, 4, 1> {};
4062 friend class ScopeIterator;
4066 // The cache for maps used by normalized (dictionary mode) objects.
4067 // Such maps do not have property descriptors, so a typical program
4068 // needs very limited number of distinct normalized maps.
4069 class NormalizedMapCache: public FixedArray {
4071 static Handle<NormalizedMapCache> New(Isolate* isolate);
4073 MUST_USE_RESULT MaybeHandle<Map> Get(Handle<Map> fast_map,
4074 PropertyNormalizationMode mode);
4075 void Set(Handle<Map> fast_map, Handle<Map> normalized_map);
4079 DECLARE_CAST(NormalizedMapCache)
4081 static inline bool IsNormalizedMapCache(const Object* obj);
4083 DECLARE_VERIFIER(NormalizedMapCache)
4085 static const int kEntries = 64;
4087 static inline int GetIndex(Handle<Map> map);
4089 // The following declarations hide base class methods.
4090 Object* get(int index);
4091 void set(int index, Object* value);
4095 // ByteArray represents fixed sized byte arrays. Used for the relocation info
4096 // that is attached to code objects.
4097 class ByteArray: public FixedArrayBase {
4101 // Setter and getter.
4102 inline byte get(int index);
4103 inline void set(int index, byte value);
4105 // Treat contents as an int array.
4106 inline int get_int(int index);
4108 static int SizeFor(int length) {
4109 return OBJECT_POINTER_ALIGN(kHeaderSize + length);
4111 // We use byte arrays for free blocks in the heap. Given a desired size in
4112 // bytes that is a multiple of the word size and big enough to hold a byte
4113 // array, this function returns the number of elements a byte array should
4115 static int LengthFor(int size_in_bytes) {
4116 DCHECK(IsAligned(size_in_bytes, kPointerSize));
4117 DCHECK(size_in_bytes >= kHeaderSize);
4118 return size_in_bytes - kHeaderSize;
4121 // Returns data start address.
4122 inline Address GetDataStartAddress();
4124 // Returns a pointer to the ByteArray object for a given data start address.
4125 static inline ByteArray* FromDataStartAddress(Address address);
4127 DECLARE_CAST(ByteArray)
4129 // Dispatched behavior.
4130 inline int ByteArraySize();
4131 DECLARE_PRINTER(ByteArray)
4132 DECLARE_VERIFIER(ByteArray)
4134 // Layout description.
4135 static const int kAlignedSize = OBJECT_POINTER_ALIGN(kHeaderSize);
4137 // Maximal memory consumption for a single ByteArray.
4138 static const int kMaxSize = 512 * MB;
4139 // Maximal length of a single ByteArray.
4140 static const int kMaxLength = kMaxSize - kHeaderSize;
4143 DISALLOW_IMPLICIT_CONSTRUCTORS(ByteArray);
4147 // BytecodeArray represents a sequence of interpreter bytecodes.
4148 class BytecodeArray : public FixedArrayBase {
4150 static int SizeFor(int length) {
4151 return OBJECT_POINTER_ALIGN(kHeaderSize + length);
4154 // Setter and getter
4155 inline byte get(int index);
4156 inline void set(int index, byte value);
4158 // Returns data start address.
4159 inline Address GetFirstBytecodeAddress();
4161 // Accessors for frame size.
4162 inline int frame_size() const;
4163 inline void set_frame_size(int frame_size);
4165 // Accessors for parameter count (including implicit 'this' receiver).
4166 inline int parameter_count() const;
4167 inline void set_parameter_count(int number_of_parameters);
4169 // Accessors for the constant pool.
4170 DECL_ACCESSORS(constant_pool, FixedArray)
4172 DECLARE_CAST(BytecodeArray)
4174 // Dispatched behavior.
4175 inline int BytecodeArraySize();
4176 inline void BytecodeArrayIterateBody(ObjectVisitor* v);
4178 DECLARE_PRINTER(BytecodeArray)
4179 DECLARE_VERIFIER(BytecodeArray)
4181 void Disassemble(std::ostream& os);
4183 // Layout description.
4184 static const int kFrameSizeOffset = FixedArrayBase::kHeaderSize;
4185 static const int kParameterSizeOffset = kFrameSizeOffset + kIntSize;
4186 static const int kConstantPoolOffset = kParameterSizeOffset + kIntSize;
4187 static const int kHeaderSize = kConstantPoolOffset + kPointerSize;
4189 static const int kAlignedSize = OBJECT_POINTER_ALIGN(kHeaderSize);
4191 // Maximal memory consumption for a single BytecodeArray.
4192 static const int kMaxSize = 512 * MB;
4193 // Maximal length of a single BytecodeArray.
4194 static const int kMaxLength = kMaxSize - kHeaderSize;
4197 DISALLOW_IMPLICIT_CONSTRUCTORS(BytecodeArray);
4201 // FreeSpace are fixed-size free memory blocks used by the heap and GC.
4202 // They look like heap objects (are heap object tagged and have a map) so that
4203 // the heap remains iterable. They have a size and a next pointer.
4204 // The next pointer is the raw address of the next FreeSpace object (or NULL)
4205 // in the free list.
4206 class FreeSpace: public HeapObject {
4208 // [size]: size of the free space including the header.
4209 inline int size() const;
4210 inline void set_size(int value);
4212 inline int nobarrier_size() const;
4213 inline void nobarrier_set_size(int value);
4217 // Accessors for the next field.
4218 inline FreeSpace* next();
4219 inline FreeSpace** next_address();
4220 inline void set_next(FreeSpace* next);
4222 inline static FreeSpace* cast(HeapObject* obj);
4224 // Dispatched behavior.
4225 DECLARE_PRINTER(FreeSpace)
4226 DECLARE_VERIFIER(FreeSpace)
4228 // Layout description.
4229 // Size is smi tagged when it is stored.
4230 static const int kSizeOffset = HeapObject::kHeaderSize;
4231 static const int kNextOffset = POINTER_SIZE_ALIGN(kSizeOffset + kPointerSize);
4234 DISALLOW_IMPLICIT_CONSTRUCTORS(FreeSpace);
4238 // V has parameters (Type, type, TYPE, C type, element_size)
4239 #define TYPED_ARRAYS(V) \
4240 V(Uint8, uint8, UINT8, uint8_t, 1) \
4241 V(Int8, int8, INT8, int8_t, 1) \
4242 V(Uint16, uint16, UINT16, uint16_t, 2) \
4243 V(Int16, int16, INT16, int16_t, 2) \
4244 V(Uint32, uint32, UINT32, uint32_t, 4) \
4245 V(Int32, int32, INT32, int32_t, 4) \
4246 V(Float32, float32, FLOAT32, float, 4) \
4247 V(Float64, float64, FLOAT64, double, 8) \
4248 V(Uint8Clamped, uint8_clamped, UINT8_CLAMPED, uint8_t, 1)
4251 class FixedTypedArrayBase: public FixedArrayBase {
4253 // [base_pointer]: Either points to the FixedTypedArrayBase itself or nullptr.
4254 DECL_ACCESSORS(base_pointer, Object)
4256 // [external_pointer]: Contains the offset between base_pointer and the start
4257 // of the data. If the base_pointer is a nullptr, the external_pointer
4258 // therefore points to the actual backing store.
4259 DECL_ACCESSORS(external_pointer, void)
4261 // Dispatched behavior.
4262 inline void FixedTypedArrayBaseIterateBody(ObjectVisitor* v);
4264 template <typename StaticVisitor>
4265 inline void FixedTypedArrayBaseIterateBody();
4267 DECLARE_CAST(FixedTypedArrayBase)
4269 static const int kBasePointerOffset = FixedArrayBase::kHeaderSize;
4270 static const int kExternalPointerOffset = kBasePointerOffset + kPointerSize;
4271 static const int kHeaderSize =
4272 DOUBLE_POINTER_ALIGN(kExternalPointerOffset + kPointerSize);
4274 static const int kDataOffset = kHeaderSize;
4278 static inline int TypedArraySize(InstanceType type, int length);
4279 inline int TypedArraySize(InstanceType type);
4281 // Use with care: returns raw pointer into heap.
4282 inline void* DataPtr();
4284 inline int DataSize();
4287 static inline int ElementSize(InstanceType type);
4289 inline int DataSize(InstanceType type);
4291 DISALLOW_IMPLICIT_CONSTRUCTORS(FixedTypedArrayBase);
4295 template <class Traits>
4296 class FixedTypedArray: public FixedTypedArrayBase {
4298 typedef typename Traits::ElementType ElementType;
4299 static const InstanceType kInstanceType = Traits::kInstanceType;
4301 DECLARE_CAST(FixedTypedArray<Traits>)
4303 inline ElementType get_scalar(int index);
4304 static inline Handle<Object> get(Handle<FixedTypedArray> array, int index);
4305 inline void set(int index, ElementType value);
4307 static inline ElementType from_int(int value);
4308 static inline ElementType from_double(double value);
4310 // This accessor applies the correct conversion from Smi, HeapNumber
4312 inline void SetValue(uint32_t index, Object* value);
4314 DECLARE_PRINTER(FixedTypedArray)
4315 DECLARE_VERIFIER(FixedTypedArray)
4318 DISALLOW_IMPLICIT_CONSTRUCTORS(FixedTypedArray);
4321 #define FIXED_TYPED_ARRAY_TRAITS(Type, type, TYPE, elementType, size) \
4322 class Type##ArrayTraits { \
4323 public: /* NOLINT */ \
4324 typedef elementType ElementType; \
4325 static const InstanceType kInstanceType = FIXED_##TYPE##_ARRAY_TYPE; \
4326 static const char* Designator() { return #type " array"; } \
4327 static inline Handle<Object> ToHandle(Isolate* isolate, \
4328 elementType scalar); \
4329 static inline elementType defaultValue(); \
4332 typedef FixedTypedArray<Type##ArrayTraits> Fixed##Type##Array;
4334 TYPED_ARRAYS(FIXED_TYPED_ARRAY_TRAITS)
4336 #undef FIXED_TYPED_ARRAY_TRAITS
4339 // DeoptimizationInputData is a fixed array used to hold the deoptimization
4340 // data for code generated by the Hydrogen/Lithium compiler. It also
4341 // contains information about functions that were inlined. If N different
4342 // functions were inlined then first N elements of the literal array will
4343 // contain these functions.
4346 class DeoptimizationInputData: public FixedArray {
4348 // Layout description. Indices in the array.
4349 static const int kTranslationByteArrayIndex = 0;
4350 static const int kInlinedFunctionCountIndex = 1;
4351 static const int kLiteralArrayIndex = 2;
4352 static const int kOsrAstIdIndex = 3;
4353 static const int kOsrPcOffsetIndex = 4;
4354 static const int kOptimizationIdIndex = 5;
4355 static const int kSharedFunctionInfoIndex = 6;
4356 static const int kWeakCellCacheIndex = 7;
4357 static const int kFirstDeoptEntryIndex = 8;
4359 // Offsets of deopt entry elements relative to the start of the entry.
4360 static const int kAstIdRawOffset = 0;
4361 static const int kTranslationIndexOffset = 1;
4362 static const int kArgumentsStackHeightOffset = 2;
4363 static const int kPcOffset = 3;
4364 static const int kDeoptEntrySize = 4;
4366 // Simple element accessors.
4367 #define DECLARE_ELEMENT_ACCESSORS(name, type) \
4368 inline type* name(); \
4369 inline void Set##name(type* value);
4371 DECLARE_ELEMENT_ACCESSORS(TranslationByteArray, ByteArray)
4372 DECLARE_ELEMENT_ACCESSORS(InlinedFunctionCount, Smi)
4373 DECLARE_ELEMENT_ACCESSORS(LiteralArray, FixedArray)
4374 DECLARE_ELEMENT_ACCESSORS(OsrAstId, Smi)
4375 DECLARE_ELEMENT_ACCESSORS(OsrPcOffset, Smi)
4376 DECLARE_ELEMENT_ACCESSORS(OptimizationId, Smi)
4377 DECLARE_ELEMENT_ACCESSORS(SharedFunctionInfo, Object)
4378 DECLARE_ELEMENT_ACCESSORS(WeakCellCache, Object)
4380 #undef DECLARE_ELEMENT_ACCESSORS
4382 // Accessors for elements of the ith deoptimization entry.
4383 #define DECLARE_ENTRY_ACCESSORS(name, type) \
4384 inline type* name(int i); \
4385 inline void Set##name(int i, type* value);
4387 DECLARE_ENTRY_ACCESSORS(AstIdRaw, Smi)
4388 DECLARE_ENTRY_ACCESSORS(TranslationIndex, Smi)
4389 DECLARE_ENTRY_ACCESSORS(ArgumentsStackHeight, Smi)
4390 DECLARE_ENTRY_ACCESSORS(Pc, Smi)
4392 #undef DECLARE_ENTRY_ACCESSORS
4394 inline BailoutId AstId(int i);
4396 inline void SetAstId(int i, BailoutId value);
4398 inline int DeoptCount();
4400 // Allocates a DeoptimizationInputData.
4401 static Handle<DeoptimizationInputData> New(Isolate* isolate,
4402 int deopt_entry_count,
4403 PretenureFlag pretenure);
4405 DECLARE_CAST(DeoptimizationInputData)
4407 #ifdef ENABLE_DISASSEMBLER
4408 void DeoptimizationInputDataPrint(std::ostream& os); // NOLINT
4412 static int IndexForEntry(int i) {
4413 return kFirstDeoptEntryIndex + (i * kDeoptEntrySize);
4417 static int LengthFor(int entry_count) { return IndexForEntry(entry_count); }
4421 // DeoptimizationOutputData is a fixed array used to hold the deoptimization
4422 // data for code generated by the full compiler.
4423 // The format of the these objects is
4424 // [i * 2]: Ast ID for ith deoptimization.
4425 // [i * 2 + 1]: PC and state of ith deoptimization
4426 class DeoptimizationOutputData: public FixedArray {
4428 inline int DeoptPoints();
4430 inline BailoutId AstId(int index);
4432 inline void SetAstId(int index, BailoutId id);
4434 inline Smi* PcAndState(int index);
4435 inline void SetPcAndState(int index, Smi* offset);
4437 static int LengthOfFixedArray(int deopt_points) {
4438 return deopt_points * 2;
4441 // Allocates a DeoptimizationOutputData.
4442 static Handle<DeoptimizationOutputData> New(Isolate* isolate,
4443 int number_of_deopt_points,
4444 PretenureFlag pretenure);
4446 DECLARE_CAST(DeoptimizationOutputData)
4448 #if defined(OBJECT_PRINT) || defined(ENABLE_DISASSEMBLER)
4449 void DeoptimizationOutputDataPrint(std::ostream& os); // NOLINT
4454 // HandlerTable is a fixed array containing entries for exception handlers in
4455 // the code object it is associated with. The tables comes in two flavors:
4456 // 1) Based on ranges: Used for unoptimized code. Contains one entry per
4457 // exception handler and a range representing the try-block covered by that
4458 // handler. Layout looks as follows:
4459 // [ range-start , range-end , handler-offset , stack-depth ]
4460 // 2) Based on return addresses: Used for turbofanned code. Contains one entry
4461 // per call-site that could throw an exception. Layout looks as follows:
4462 // [ return-address-offset , handler-offset ]
4463 class HandlerTable : public FixedArray {
4465 // Conservative prediction whether a given handler will locally catch an
4466 // exception or cause a re-throw to outside the code boundary. Since this is
4467 // undecidable it is merely an approximation (e.g. useful for debugger).
4468 enum CatchPrediction { UNCAUGHT, CAUGHT };
4470 // Accessors for handler table based on ranges.
4471 inline void SetRangeStart(int index, int value);
4472 inline void SetRangeEnd(int index, int value);
4473 inline void SetRangeHandler(int index, int offset, CatchPrediction pred);
4474 inline void SetRangeDepth(int index, int value);
4476 // Accessors for handler table based on return addresses.
4477 inline void SetReturnOffset(int index, int value);
4478 inline void SetReturnHandler(int index, int offset, CatchPrediction pred);
4480 // Lookup handler in a table based on ranges.
4481 int LookupRange(int pc_offset, int* stack_depth, CatchPrediction* prediction);
4483 // Lookup handler in a table based on return addresses.
4484 int LookupReturn(int pc_offset, CatchPrediction* prediction);
4486 // Returns the required length of the underlying fixed array.
4487 static int LengthForRange(int entries) { return entries * kRangeEntrySize; }
4488 static int LengthForReturn(int entries) { return entries * kReturnEntrySize; }
4490 DECLARE_CAST(HandlerTable)
4492 #if defined(OBJECT_PRINT) || defined(ENABLE_DISASSEMBLER)
4493 void HandlerTableRangePrint(std::ostream& os); // NOLINT
4494 void HandlerTableReturnPrint(std::ostream& os); // NOLINT
4498 // Layout description for handler table based on ranges.
4499 static const int kRangeStartIndex = 0;
4500 static const int kRangeEndIndex = 1;
4501 static const int kRangeHandlerIndex = 2;
4502 static const int kRangeDepthIndex = 3;
4503 static const int kRangeEntrySize = 4;
4505 // Layout description for handler table based on return addresses.
4506 static const int kReturnOffsetIndex = 0;
4507 static const int kReturnHandlerIndex = 1;
4508 static const int kReturnEntrySize = 2;
4510 // Encoding of the {handler} field.
4511 class HandlerPredictionField : public BitField<CatchPrediction, 0, 1> {};
4512 class HandlerOffsetField : public BitField<int, 1, 30> {};
4516 // Code describes objects with on-the-fly generated machine code.
4517 class Code: public HeapObject {
4519 // Opaque data type for encapsulating code flags like kind, inline
4520 // cache state, and arguments count.
4521 typedef uint32_t Flags;
4523 #define NON_IC_KIND_LIST(V) \
4525 V(OPTIMIZED_FUNCTION) \
4532 #define IC_KIND_LIST(V) \
4543 #define CODE_KIND_LIST(V) \
4544 NON_IC_KIND_LIST(V) \
4548 #define DEFINE_CODE_KIND_ENUM(name) name,
4549 CODE_KIND_LIST(DEFINE_CODE_KIND_ENUM)
4550 #undef DEFINE_CODE_KIND_ENUM
4554 // No more than 16 kinds. The value is currently encoded in four bits in
4556 STATIC_ASSERT(NUMBER_OF_KINDS <= 16);
4558 static const char* Kind2String(Kind kind);
4566 static const int kPrologueOffsetNotSet = -1;
4568 #ifdef ENABLE_DISASSEMBLER
4570 static const char* ICState2String(InlineCacheState state);
4571 static const char* StubType2String(StubType type);
4572 static void PrintExtraICState(std::ostream& os, // NOLINT
4573 Kind kind, ExtraICState extra);
4574 void Disassemble(const char* name, std::ostream& os); // NOLINT
4575 #endif // ENABLE_DISASSEMBLER
4577 // [instruction_size]: Size of the native instructions
4578 inline int instruction_size() const;
4579 inline void set_instruction_size(int value);
4581 // [relocation_info]: Code relocation information
4582 DECL_ACCESSORS(relocation_info, ByteArray)
4583 void InvalidateRelocation();
4584 void InvalidateEmbeddedObjects();
4586 // [handler_table]: Fixed array containing offsets of exception handlers.
4587 DECL_ACCESSORS(handler_table, FixedArray)
4589 // [deoptimization_data]: Array containing data for deopt.
4590 DECL_ACCESSORS(deoptimization_data, FixedArray)
4592 // [raw_type_feedback_info]: This field stores various things, depending on
4593 // the kind of the code object.
4594 // FUNCTION => type feedback information.
4595 // STUB and ICs => major/minor key as Smi.
4596 DECL_ACCESSORS(raw_type_feedback_info, Object)
4597 inline Object* type_feedback_info();
4598 inline void set_type_feedback_info(
4599 Object* value, WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
4600 inline uint32_t stub_key();
4601 inline void set_stub_key(uint32_t key);
4603 // [next_code_link]: Link for lists of optimized or deoptimized code.
4604 // Note that storage for this field is overlapped with typefeedback_info.
4605 DECL_ACCESSORS(next_code_link, Object)
4607 // [gc_metadata]: Field used to hold GC related metadata. The contents of this
4608 // field does not have to be traced during garbage collection since
4609 // it is only used by the garbage collector itself.
4610 DECL_ACCESSORS(gc_metadata, Object)
4612 // [ic_age]: Inline caching age: the value of the Heap::global_ic_age
4613 // at the moment when this object was created.
4614 inline void set_ic_age(int count);
4615 inline int ic_age() const;
4617 // [prologue_offset]: Offset of the function prologue, used for aging
4618 // FUNCTIONs and OPTIMIZED_FUNCTIONs.
4619 inline int prologue_offset() const;
4620 inline void set_prologue_offset(int offset);
4622 // [constant_pool offset]: Offset of the constant pool.
4623 // Valid for FLAG_enable_embedded_constant_pool only
4624 inline int constant_pool_offset() const;
4625 inline void set_constant_pool_offset(int offset);
4627 // Unchecked accessors to be used during GC.
4628 inline ByteArray* unchecked_relocation_info();
4630 inline int relocation_size();
4632 // [flags]: Various code flags.
4633 inline Flags flags();
4634 inline void set_flags(Flags flags);
4636 // [flags]: Access to specific code flags.
4638 inline InlineCacheState ic_state(); // Only valid for IC stubs.
4639 inline ExtraICState extra_ic_state(); // Only valid for IC stubs.
4641 inline StubType type(); // Only valid for monomorphic IC stubs.
4643 // Testers for IC stub kinds.
4644 inline bool is_inline_cache_stub();
4645 inline bool is_debug_stub();
4646 inline bool is_handler();
4647 inline bool is_load_stub();
4648 inline bool is_keyed_load_stub();
4649 inline bool is_store_stub();
4650 inline bool is_keyed_store_stub();
4651 inline bool is_call_stub();
4652 inline bool is_binary_op_stub();
4653 inline bool is_compare_ic_stub();
4654 inline bool is_compare_nil_ic_stub();
4655 inline bool is_to_boolean_ic_stub();
4656 inline bool is_keyed_stub();
4657 inline bool is_optimized_code();
4658 inline bool embeds_maps_weakly();
4660 inline bool IsCodeStubOrIC();
4661 inline bool IsJavaScriptCode();
4663 inline void set_raw_kind_specific_flags1(int value);
4664 inline void set_raw_kind_specific_flags2(int value);
4666 // [is_crankshafted]: For kind STUB or ICs, tells whether or not a code
4667 // object was generated by either the hydrogen or the TurboFan optimizing
4668 // compiler (but it may not be an optimized function).
4669 inline bool is_crankshafted();
4670 inline bool is_hydrogen_stub(); // Crankshafted, but not a function.
4671 inline void set_is_crankshafted(bool value);
4673 // [is_turbofanned]: For kind STUB or OPTIMIZED_FUNCTION, tells whether the
4674 // code object was generated by the TurboFan optimizing compiler.
4675 inline bool is_turbofanned();
4676 inline void set_is_turbofanned(bool value);
4678 // [can_have_weak_objects]: For kind OPTIMIZED_FUNCTION, tells whether the
4679 // embedded objects in code should be treated weakly.
4680 inline bool can_have_weak_objects();
4681 inline void set_can_have_weak_objects(bool value);
4683 // [has_deoptimization_support]: For FUNCTION kind, tells if it has
4684 // deoptimization support.
4685 inline bool has_deoptimization_support();
4686 inline void set_has_deoptimization_support(bool value);
4688 // [has_debug_break_slots]: For FUNCTION kind, tells if it has
4689 // been compiled with debug break slots.
4690 inline bool has_debug_break_slots();
4691 inline void set_has_debug_break_slots(bool value);
4693 // [has_reloc_info_for_serialization]: For FUNCTION kind, tells if its
4694 // reloc info includes runtime and external references to support
4695 // serialization/deserialization.
4696 inline bool has_reloc_info_for_serialization();
4697 inline void set_has_reloc_info_for_serialization(bool value);
4699 // [allow_osr_at_loop_nesting_level]: For FUNCTION kind, tells for
4700 // how long the function has been marked for OSR and therefore which
4701 // level of loop nesting we are willing to do on-stack replacement
4703 inline void set_allow_osr_at_loop_nesting_level(int level);
4704 inline int allow_osr_at_loop_nesting_level();
4706 // [profiler_ticks]: For FUNCTION kind, tells for how many profiler ticks
4707 // the code object was seen on the stack with no IC patching going on.
4708 inline int profiler_ticks();
4709 inline void set_profiler_ticks(int ticks);
4711 // [builtin_index]: For BUILTIN kind, tells which builtin index it has.
4712 // For builtins, tells which builtin index it has.
4713 // Note that builtins can have a code kind other than BUILTIN, which means
4714 // that for arbitrary code objects, this index value may be random garbage.
4715 // To verify in that case, compare the code object to the indexed builtin.
4716 inline int builtin_index();
4717 inline void set_builtin_index(int id);
4719 // [stack_slots]: For kind OPTIMIZED_FUNCTION, the number of stack slots
4720 // reserved in the code prologue.
4721 inline unsigned stack_slots();
4722 inline void set_stack_slots(unsigned slots);
4724 // [safepoint_table_start]: For kind OPTIMIZED_FUNCTION, the offset in
4725 // the instruction stream where the safepoint table starts.
4726 inline unsigned safepoint_table_offset();
4727 inline void set_safepoint_table_offset(unsigned offset);
4729 // [back_edge_table_start]: For kind FUNCTION, the offset in the
4730 // instruction stream where the back edge table starts.
4731 inline unsigned back_edge_table_offset();
4732 inline void set_back_edge_table_offset(unsigned offset);
4734 inline bool back_edges_patched_for_osr();
4736 // [to_boolean_foo]: For kind TO_BOOLEAN_IC tells what state the stub is in.
4737 inline uint16_t to_boolean_state();
4739 // [has_function_cache]: For kind STUB tells whether there is a function
4740 // cache is passed to the stub.
4741 inline bool has_function_cache();
4742 inline void set_has_function_cache(bool flag);
4745 // [marked_for_deoptimization]: For kind OPTIMIZED_FUNCTION tells whether
4746 // the code is going to be deoptimized because of dead embedded maps.
4747 inline bool marked_for_deoptimization();
4748 inline void set_marked_for_deoptimization(bool flag);
4750 // [constant_pool]: The constant pool for this function.
4751 inline Address constant_pool();
4753 // Get the safepoint entry for the given pc.
4754 SafepointEntry GetSafepointEntry(Address pc);
4756 // Find an object in a stub with a specified map
4757 Object* FindNthObject(int n, Map* match_map);
4759 // Find the first allocation site in an IC stub.
4760 AllocationSite* FindFirstAllocationSite();
4762 // Find the first map in an IC stub.
4763 Map* FindFirstMap();
4764 void FindAllMaps(MapHandleList* maps);
4766 // Find the first handler in an IC stub.
4767 Code* FindFirstHandler();
4769 // Find |length| handlers and put them into |code_list|. Returns false if not
4770 // enough handlers can be found.
4771 bool FindHandlers(CodeHandleList* code_list, int length = -1);
4773 // Find the handler for |map|.
4774 MaybeHandle<Code> FindHandlerForMap(Map* map);
4776 // Find the first name in an IC stub.
4777 Name* FindFirstName();
4779 class FindAndReplacePattern;
4780 // For each (map-to-find, object-to-replace) pair in the pattern, this
4781 // function replaces the corresponding placeholder in the code with the
4782 // object-to-replace. The function assumes that pairs in the pattern come in
4783 // the same order as the placeholders in the code.
4784 // If the placeholder is a weak cell, then the value of weak cell is matched
4785 // against the map-to-find.
4786 void FindAndReplace(const FindAndReplacePattern& pattern);
4788 // The entire code object including its header is copied verbatim to the
4789 // snapshot so that it can be written in one, fast, memcpy during
4790 // deserialization. The deserializer will overwrite some pointers, rather
4791 // like a runtime linker, but the random allocation addresses used in the
4792 // mksnapshot process would still be present in the unlinked snapshot data,
4793 // which would make snapshot production non-reproducible. This method wipes
4794 // out the to-be-overwritten header data for reproducible snapshots.
4795 inline void WipeOutHeader();
4797 // Flags operations.
4798 static inline Flags ComputeFlags(
4799 Kind kind, InlineCacheState ic_state = UNINITIALIZED,
4800 ExtraICState extra_ic_state = kNoExtraICState, StubType type = NORMAL,
4801 CacheHolderFlag holder = kCacheOnReceiver);
4803 static inline Flags ComputeMonomorphicFlags(
4804 Kind kind, ExtraICState extra_ic_state = kNoExtraICState,
4805 CacheHolderFlag holder = kCacheOnReceiver, StubType type = NORMAL);
4807 static inline Flags ComputeHandlerFlags(
4808 Kind handler_kind, StubType type = NORMAL,
4809 CacheHolderFlag holder = kCacheOnReceiver);
4811 static inline InlineCacheState ExtractICStateFromFlags(Flags flags);
4812 static inline StubType ExtractTypeFromFlags(Flags flags);
4813 static inline CacheHolderFlag ExtractCacheHolderFromFlags(Flags flags);
4814 static inline Kind ExtractKindFromFlags(Flags flags);
4815 static inline ExtraICState ExtractExtraICStateFromFlags(Flags flags);
4817 static inline Flags RemoveTypeFromFlags(Flags flags);
4818 static inline Flags RemoveTypeAndHolderFromFlags(Flags flags);
4820 // Convert a target address into a code object.
4821 static inline Code* GetCodeFromTargetAddress(Address address);
4823 // Convert an entry address into an object.
4824 static inline Object* GetObjectFromEntryAddress(Address location_of_address);
4826 // Returns the address of the first instruction.
4827 inline byte* instruction_start();
4829 // Returns the address right after the last instruction.
4830 inline byte* instruction_end();
4832 // Returns the size of the instructions, padding, and relocation information.
4833 inline int body_size();
4835 // Returns the address of the first relocation info (read backwards!).
4836 inline byte* relocation_start();
4838 // Code entry point.
4839 inline byte* entry();
4841 // Returns true if pc is inside this object's instructions.
4842 inline bool contains(byte* pc);
4844 // Relocate the code by delta bytes. Called to signal that this code
4845 // object has been moved by delta bytes.
4846 void Relocate(intptr_t delta);
4848 // Migrate code described by desc.
4849 void CopyFrom(const CodeDesc& desc);
4851 // Returns the object size for a given body (used for allocation).
4852 static int SizeFor(int body_size) {
4853 DCHECK_SIZE_TAG_ALIGNED(body_size);
4854 return RoundUp(kHeaderSize + body_size, kCodeAlignment);
4857 // Calculate the size of the code object to report for log events. This takes
4858 // the layout of the code object into account.
4859 inline int ExecutableSize();
4861 // Locating source position.
4862 int SourcePosition(Address pc);
4863 int SourceStatementPosition(Address pc);
4867 // Dispatched behavior.
4868 inline int CodeSize();
4869 inline void CodeIterateBody(ObjectVisitor* v);
4871 template<typename StaticVisitor>
4872 inline void CodeIterateBody(Heap* heap);
4874 DECLARE_PRINTER(Code)
4875 DECLARE_VERIFIER(Code)
4877 void ClearInlineCaches();
4878 void ClearInlineCaches(Kind kind);
4880 BailoutId TranslatePcOffsetToAstId(uint32_t pc_offset);
4881 uint32_t TranslateAstIdToPcOffset(BailoutId ast_id);
4883 #define DECLARE_CODE_AGE_ENUM(X) k##X##CodeAge,
4885 kToBeExecutedOnceCodeAge = -3,
4886 kNotExecutedCodeAge = -2,
4887 kExecutedOnceCodeAge = -1,
4889 CODE_AGE_LIST(DECLARE_CODE_AGE_ENUM)
4891 kFirstCodeAge = kToBeExecutedOnceCodeAge,
4892 kLastCodeAge = kAfterLastCodeAge - 1,
4893 kCodeAgeCount = kAfterLastCodeAge - kFirstCodeAge - 1,
4894 kIsOldCodeAge = kSexagenarianCodeAge,
4895 kPreAgedCodeAge = kIsOldCodeAge - 1
4897 #undef DECLARE_CODE_AGE_ENUM
4899 // Code aging. Indicates how many full GCs this code has survived without
4900 // being entered through the prologue. Used to determine when it is
4901 // relatively safe to flush this code object and replace it with the lazy
4902 // compilation stub.
4903 static void MakeCodeAgeSequenceYoung(byte* sequence, Isolate* isolate);
4904 static void MarkCodeAsExecuted(byte* sequence, Isolate* isolate);
4905 void MakeYoung(Isolate* isolate);
4906 void MarkToBeExecutedOnce(Isolate* isolate);
4907 void MakeOlder(MarkingParity);
4908 static bool IsYoungSequence(Isolate* isolate, byte* sequence);
4911 static inline Code* GetPreAgedCodeAgeStub(Isolate* isolate) {
4912 return GetCodeAgeStub(isolate, kNotExecutedCodeAge, NO_MARKING_PARITY);
4915 void PrintDeoptLocation(FILE* out, Address pc);
4916 bool CanDeoptAt(Address pc);
4919 void VerifyEmbeddedObjectsDependency();
4923 enum VerifyMode { kNoContextSpecificPointers, kNoContextRetainingPointers };
4924 void VerifyEmbeddedObjects(VerifyMode mode = kNoContextRetainingPointers);
4925 static void VerifyRecompiledCode(Code* old_code, Code* new_code);
4928 inline bool CanContainWeakObjects();
4930 inline bool IsWeakObject(Object* object);
4932 static inline bool IsWeakObjectInOptimizedCode(Object* object);
4934 static Handle<WeakCell> WeakCellFor(Handle<Code> code);
4935 WeakCell* CachedWeakCell();
4937 // Max loop nesting marker used to postpose OSR. We don't take loop
4938 // nesting that is deeper than 5 levels into account.
4939 static const int kMaxLoopNestingMarker = 6;
4941 static const int kConstantPoolSize =
4942 FLAG_enable_embedded_constant_pool ? kIntSize : 0;
4944 // Layout description.
4945 static const int kRelocationInfoOffset = HeapObject::kHeaderSize;
4946 static const int kHandlerTableOffset = kRelocationInfoOffset + kPointerSize;
4947 static const int kDeoptimizationDataOffset =
4948 kHandlerTableOffset + kPointerSize;
4949 // For FUNCTION kind, we store the type feedback info here.
4950 static const int kTypeFeedbackInfoOffset =
4951 kDeoptimizationDataOffset + kPointerSize;
4952 static const int kNextCodeLinkOffset = kTypeFeedbackInfoOffset + kPointerSize;
4953 static const int kGCMetadataOffset = kNextCodeLinkOffset + kPointerSize;
4954 static const int kInstructionSizeOffset = kGCMetadataOffset + kPointerSize;
4955 static const int kICAgeOffset = kInstructionSizeOffset + kIntSize;
4956 static const int kFlagsOffset = kICAgeOffset + kIntSize;
4957 static const int kKindSpecificFlags1Offset = kFlagsOffset + kIntSize;
4958 static const int kKindSpecificFlags2Offset =
4959 kKindSpecificFlags1Offset + kIntSize;
4960 // Note: We might be able to squeeze this into the flags above.
4961 static const int kPrologueOffset = kKindSpecificFlags2Offset + kIntSize;
4962 static const int kConstantPoolOffset = kPrologueOffset + kIntSize;
4963 static const int kHeaderPaddingStart =
4964 kConstantPoolOffset + kConstantPoolSize;
4966 // Add padding to align the instruction start following right after
4967 // the Code object header.
4968 static const int kHeaderSize =
4969 (kHeaderPaddingStart + kCodeAlignmentMask) & ~kCodeAlignmentMask;
4971 // Byte offsets within kKindSpecificFlags1Offset.
4972 static const int kFullCodeFlags = kKindSpecificFlags1Offset;
4973 class FullCodeFlagsHasDeoptimizationSupportField:
4974 public BitField<bool, 0, 1> {}; // NOLINT
4975 class FullCodeFlagsHasDebugBreakSlotsField: public BitField<bool, 1, 1> {};
4976 class FullCodeFlagsHasRelocInfoForSerialization
4977 : public BitField<bool, 2, 1> {};
4978 // Bit 3 in this bitfield is unused.
4979 class ProfilerTicksField : public BitField<int, 4, 28> {};
4981 // Flags layout. BitField<type, shift, size>.
4982 class ICStateField : public BitField<InlineCacheState, 0, 4> {};
4983 class TypeField : public BitField<StubType, 4, 1> {};
4984 class CacheHolderField : public BitField<CacheHolderFlag, 5, 2> {};
4985 class KindField : public BitField<Kind, 7, 4> {};
4986 class ExtraICStateField: public BitField<ExtraICState, 11,
4987 PlatformSmiTagging::kSmiValueSize - 11 + 1> {}; // NOLINT
4989 // KindSpecificFlags1 layout (STUB and OPTIMIZED_FUNCTION)
4990 static const int kStackSlotsFirstBit = 0;
4991 static const int kStackSlotsBitCount = 24;
4992 static const int kHasFunctionCacheBit =
4993 kStackSlotsFirstBit + kStackSlotsBitCount;
4994 static const int kMarkedForDeoptimizationBit = kHasFunctionCacheBit + 1;
4995 static const int kIsTurbofannedBit = kMarkedForDeoptimizationBit + 1;
4996 static const int kCanHaveWeakObjects = kIsTurbofannedBit + 1;
4998 STATIC_ASSERT(kStackSlotsFirstBit + kStackSlotsBitCount <= 32);
4999 STATIC_ASSERT(kCanHaveWeakObjects + 1 <= 32);
5001 class StackSlotsField: public BitField<int,
5002 kStackSlotsFirstBit, kStackSlotsBitCount> {}; // NOLINT
5003 class HasFunctionCacheField : public BitField<bool, kHasFunctionCacheBit, 1> {
5005 class MarkedForDeoptimizationField
5006 : public BitField<bool, kMarkedForDeoptimizationBit, 1> {}; // NOLINT
5007 class IsTurbofannedField : public BitField<bool, kIsTurbofannedBit, 1> {
5009 class CanHaveWeakObjectsField
5010 : public BitField<bool, kCanHaveWeakObjects, 1> {}; // NOLINT
5012 // KindSpecificFlags2 layout (ALL)
5013 static const int kIsCrankshaftedBit = 0;
5014 class IsCrankshaftedField: public BitField<bool,
5015 kIsCrankshaftedBit, 1> {}; // NOLINT
5017 // KindSpecificFlags2 layout (STUB and OPTIMIZED_FUNCTION)
5018 static const int kSafepointTableOffsetFirstBit = kIsCrankshaftedBit + 1;
5019 static const int kSafepointTableOffsetBitCount = 30;
5021 STATIC_ASSERT(kSafepointTableOffsetFirstBit +
5022 kSafepointTableOffsetBitCount <= 32);
5023 STATIC_ASSERT(1 + kSafepointTableOffsetBitCount <= 32);
5025 class SafepointTableOffsetField: public BitField<int,
5026 kSafepointTableOffsetFirstBit,
5027 kSafepointTableOffsetBitCount> {}; // NOLINT
5029 // KindSpecificFlags2 layout (FUNCTION)
5030 class BackEdgeTableOffsetField: public BitField<int,
5031 kIsCrankshaftedBit + 1, 27> {}; // NOLINT
5032 class AllowOSRAtLoopNestingLevelField: public BitField<int,
5033 kIsCrankshaftedBit + 1 + 27, 4> {}; // NOLINT
5034 STATIC_ASSERT(AllowOSRAtLoopNestingLevelField::kMax >= kMaxLoopNestingMarker);
5036 static const int kArgumentsBits = 16;
5037 static const int kMaxArguments = (1 << kArgumentsBits) - 1;
5039 // This constant should be encodable in an ARM instruction.
5040 static const int kFlagsNotUsedInLookup =
5041 TypeField::kMask | CacheHolderField::kMask;
5044 friend class RelocIterator;
5045 friend class Deoptimizer; // For FindCodeAgeSequence.
5047 void ClearInlineCaches(Kind* kind);
5050 byte* FindCodeAgeSequence();
5051 static void GetCodeAgeAndParity(Code* code, Age* age,
5052 MarkingParity* parity);
5053 static void GetCodeAgeAndParity(Isolate* isolate, byte* sequence, Age* age,
5054 MarkingParity* parity);
5055 static Code* GetCodeAgeStub(Isolate* isolate, Age age, MarkingParity parity);
5057 // Code aging -- platform-specific
5058 static void PatchPlatformCodeAge(Isolate* isolate,
5059 byte* sequence, Age age,
5060 MarkingParity parity);
5062 DISALLOW_IMPLICIT_CONSTRUCTORS(Code);
5066 // This class describes the layout of dependent codes array of a map. The
5067 // array is partitioned into several groups of dependent codes. Each group
5068 // contains codes with the same dependency on the map. The array has the
5069 // following layout for n dependency groups:
5071 // +----+----+-----+----+---------+----------+-----+---------+-----------+
5072 // | C1 | C2 | ... | Cn | group 1 | group 2 | ... | group n | undefined |
5073 // +----+----+-----+----+---------+----------+-----+---------+-----------+
5075 // The first n elements are Smis, each of them specifies the number of codes
5076 // in the corresponding group. The subsequent elements contain grouped code
5077 // objects in weak cells. The suffix of the array can be filled with the
5078 // undefined value if the number of codes is less than the length of the
5079 // array. The order of the code objects within a group is not preserved.
5081 // All code indexes used in the class are counted starting from the first
5082 // code object of the first group. In other words, code index 0 corresponds
5083 // to array index n = kCodesStartIndex.
5085 class DependentCode: public FixedArray {
5087 enum DependencyGroup {
5088 // Group of code that weakly embed this map and depend on being
5089 // deoptimized when the map is garbage collected.
5091 // Group of code that embed a transition to this map, and depend on being
5092 // deoptimized when the transition is replaced by a new version.
5094 // Group of code that omit run-time prototype checks for prototypes
5095 // described by this map. The group is deoptimized whenever an object
5096 // described by this map changes shape (and transitions to a new map),
5097 // possibly invalidating the assumptions embedded in the code.
5098 kPrototypeCheckGroup,
5099 // Group of code that depends on global property values in property cells
5100 // not being changed.
5101 kPropertyCellChangedGroup,
5102 // Group of code that omit run-time type checks for the field(s) introduced
5105 // Group of code that omit run-time type checks for initial maps of
5107 kInitialMapChangedGroup,
5108 // Group of code that depends on tenuring information in AllocationSites
5109 // not being changed.
5110 kAllocationSiteTenuringChangedGroup,
5111 // Group of code that depends on element transition information in
5112 // AllocationSites not being changed.
5113 kAllocationSiteTransitionChangedGroup
5116 static const int kGroupCount = kAllocationSiteTransitionChangedGroup + 1;
5118 // Array for holding the index of the first code object of each group.
5119 // The last element stores the total number of code objects.
5120 class GroupStartIndexes {
5122 explicit GroupStartIndexes(DependentCode* entries);
5123 void Recompute(DependentCode* entries);
5124 int at(int i) { return start_indexes_[i]; }
5125 int number_of_entries() { return start_indexes_[kGroupCount]; }
5127 int start_indexes_[kGroupCount + 1];
5130 bool Contains(DependencyGroup group, WeakCell* code_cell);
5132 static Handle<DependentCode> InsertCompilationDependencies(
5133 Handle<DependentCode> entries, DependencyGroup group,
5134 Handle<Foreign> info);
5136 static Handle<DependentCode> InsertWeakCode(Handle<DependentCode> entries,
5137 DependencyGroup group,
5138 Handle<WeakCell> code_cell);
5140 void UpdateToFinishedCode(DependencyGroup group, Foreign* info,
5141 WeakCell* code_cell);
5143 void RemoveCompilationDependencies(DependentCode::DependencyGroup group,
5146 void DeoptimizeDependentCodeGroup(Isolate* isolate,
5147 DependentCode::DependencyGroup group);
5149 bool MarkCodeForDeoptimization(Isolate* isolate,
5150 DependentCode::DependencyGroup group);
5152 // The following low-level accessors should only be used by this class
5153 // and the mark compact collector.
5154 inline int number_of_entries(DependencyGroup group);
5155 inline void set_number_of_entries(DependencyGroup group, int value);
5156 inline Object* object_at(int i);
5157 inline void set_object_at(int i, Object* object);
5158 inline void clear_at(int i);
5159 inline void copy(int from, int to);
5160 DECLARE_CAST(DependentCode)
5162 static const char* DependencyGroupName(DependencyGroup group);
5163 static void SetMarkedForDeoptimization(Code* code, DependencyGroup group);
5166 static Handle<DependentCode> Insert(Handle<DependentCode> entries,
5167 DependencyGroup group,
5168 Handle<Object> object);
5169 static Handle<DependentCode> EnsureSpace(Handle<DependentCode> entries);
5170 // Make a room at the end of the given group by moving out the first
5171 // code objects of the subsequent groups.
5172 inline void ExtendGroup(DependencyGroup group);
5173 // Compact by removing cleared weak cells and return true if there was
5174 // any cleared weak cell.
5176 static int Grow(int number_of_entries) {
5177 if (number_of_entries < 5) return number_of_entries + 1;
5178 return number_of_entries * 5 / 4;
5180 static const int kCodesStartIndex = kGroupCount;
5184 class PrototypeInfo;
5187 // All heap objects have a Map that describes their structure.
5188 // A Map contains information about:
5189 // - Size information about the object
5190 // - How to iterate over an object (for garbage collection)
5191 class Map: public HeapObject {
5194 // Size in bytes or kVariableSizeSentinel if instances do not have
5196 inline int instance_size();
5197 inline void set_instance_size(int value);
5199 // Only to clear an unused byte, remove once byte is used.
5200 inline void clear_unused();
5202 // [inobject_properties_or_constructor_function_index]: Provides access
5203 // to the inobject properties in case of JSObject maps, or the constructor
5204 // function index in case of primitive maps.
5205 inline int inobject_properties_or_constructor_function_index();
5206 inline void set_inobject_properties_or_constructor_function_index(int value);
5207 // Count of properties allocated in the object (JSObject only).
5208 inline int GetInObjectProperties();
5209 inline void SetInObjectProperties(int value);
5210 // Index of the constructor function in the native context (primitives only),
5211 // or the special sentinel value to indicate that there is no object wrapper
5212 // for the primitive (i.e. in case of null or undefined).
5213 static const int kNoConstructorFunctionIndex = 0;
5214 inline int GetConstructorFunctionIndex();
5215 inline void SetConstructorFunctionIndex(int value);
5218 inline InstanceType instance_type();
5219 inline void set_instance_type(InstanceType value);
5221 // Tells how many unused property fields are available in the
5222 // instance (only used for JSObject in fast mode).
5223 inline int unused_property_fields();
5224 inline void set_unused_property_fields(int value);
5227 inline byte bit_field() const;
5228 inline void set_bit_field(byte value);
5231 inline byte bit_field2() const;
5232 inline void set_bit_field2(byte value);
5235 inline uint32_t bit_field3() const;
5236 inline void set_bit_field3(uint32_t bits);
5238 class EnumLengthBits: public BitField<int,
5239 0, kDescriptorIndexBitCount> {}; // NOLINT
5240 class NumberOfOwnDescriptorsBits: public BitField<int,
5241 kDescriptorIndexBitCount, kDescriptorIndexBitCount> {}; // NOLINT
5242 STATIC_ASSERT(kDescriptorIndexBitCount + kDescriptorIndexBitCount == 20);
5243 class DictionaryMap : public BitField<bool, 20, 1> {};
5244 class OwnsDescriptors : public BitField<bool, 21, 1> {};
5245 class IsHiddenPrototype : public BitField<bool, 22, 1> {};
5246 class Deprecated : public BitField<bool, 23, 1> {};
5247 class IsUnstable : public BitField<bool, 24, 1> {};
5248 class IsMigrationTarget : public BitField<bool, 25, 1> {};
5249 class IsStrong : public BitField<bool, 26, 1> {};
5252 // Keep this bit field at the very end for better code in
5253 // Builtins::kJSConstructStubGeneric stub.
5254 // This counter is used for in-object slack tracking and for map aging.
5255 // The in-object slack tracking is considered enabled when the counter is
5256 // in the range [kSlackTrackingCounterStart, kSlackTrackingCounterEnd].
5257 class Counter : public BitField<int, 28, 4> {};
5258 static const int kSlackTrackingCounterStart = 14;
5259 static const int kSlackTrackingCounterEnd = 8;
5260 static const int kRetainingCounterStart = kSlackTrackingCounterEnd - 1;
5261 static const int kRetainingCounterEnd = 0;
5263 // Tells whether the object in the prototype property will be used
5264 // for instances created from this function. If the prototype
5265 // property is set to a value that is not a JSObject, the prototype
5266 // property will not be used to create instances of the function.
5267 // See ECMA-262, 13.2.2.
5268 inline void set_non_instance_prototype(bool value);
5269 inline bool has_non_instance_prototype();
5271 // Tells whether function has special prototype property. If not, prototype
5272 // property will not be created when accessed (will return undefined),
5273 // and construction from this function will not be allowed.
5274 inline void set_function_with_prototype(bool value);
5275 inline bool function_with_prototype();
5277 // Tells whether the instance with this map should be ignored by the
5278 // Object.getPrototypeOf() function and the __proto__ accessor.
5279 inline void set_is_hidden_prototype();
5280 inline bool is_hidden_prototype() const;
5282 // Records and queries whether the instance has a named interceptor.
5283 inline void set_has_named_interceptor();
5284 inline bool has_named_interceptor();
5286 // Records and queries whether the instance has an indexed interceptor.
5287 inline void set_has_indexed_interceptor();
5288 inline bool has_indexed_interceptor();
5290 // Tells whether the instance is undetectable.
5291 // An undetectable object is a special class of JSObject: 'typeof' operator
5292 // returns undefined, ToBoolean returns false. Otherwise it behaves like
5293 // a normal JS object. It is useful for implementing undetectable
5294 // document.all in Firefox & Safari.
5295 // See https://bugzilla.mozilla.org/show_bug.cgi?id=248549.
5296 inline void set_is_undetectable();
5297 inline bool is_undetectable();
5299 // Tells whether the instance has a call-as-function handler.
5300 inline void set_is_observed();
5301 inline bool is_observed();
5303 // Tells whether the instance has a [[Call]] internal field.
5304 // This property is implemented according to ES6, section 7.2.3.
5305 inline void set_is_callable();
5306 inline bool is_callable() const;
5308 inline void set_is_strong();
5309 inline bool is_strong();
5310 inline void set_is_extensible(bool value);
5311 inline bool is_extensible();
5312 inline void set_is_prototype_map(bool value);
5313 inline bool is_prototype_map() const;
5315 inline void set_elements_kind(ElementsKind elements_kind);
5316 inline ElementsKind elements_kind();
5318 // Tells whether the instance has fast elements that are only Smis.
5319 inline bool has_fast_smi_elements();
5321 // Tells whether the instance has fast elements.
5322 inline bool has_fast_object_elements();
5323 inline bool has_fast_smi_or_object_elements();
5324 inline bool has_fast_double_elements();
5325 inline bool has_fast_elements();
5326 inline bool has_sloppy_arguments_elements();
5327 inline bool has_fixed_typed_array_elements();
5328 inline bool has_dictionary_elements();
5330 static bool IsValidElementsTransition(ElementsKind from_kind,
5331 ElementsKind to_kind);
5333 // Returns true if the current map doesn't have DICTIONARY_ELEMENTS but if a
5334 // map with DICTIONARY_ELEMENTS was found in the prototype chain.
5335 bool DictionaryElementsInPrototypeChainOnly();
5337 inline Map* ElementsTransitionMap();
5339 inline FixedArrayBase* GetInitialElements();
5341 // [raw_transitions]: Provides access to the transitions storage field.
5342 // Don't call set_raw_transitions() directly to overwrite transitions, use
5343 // the TransitionArray::ReplaceTransitions() wrapper instead!
5344 DECL_ACCESSORS(raw_transitions, Object)
5345 // [prototype_info]: Per-prototype metadata. Aliased with transitions
5346 // (which prototype maps don't have).
5347 DECL_ACCESSORS(prototype_info, Object)
5348 // PrototypeInfo is created lazily using this helper (which installs it on
5349 // the given prototype's map).
5350 static Handle<PrototypeInfo> GetOrCreatePrototypeInfo(
5351 Handle<JSObject> prototype, Isolate* isolate);
5352 static Handle<PrototypeInfo> GetOrCreatePrototypeInfo(
5353 Handle<Map> prototype_map, Isolate* isolate);
5355 // [prototype chain validity cell]: Associated with a prototype object,
5356 // stored in that object's map's PrototypeInfo, indicates that prototype
5357 // chains through this object are currently valid. The cell will be
5358 // invalidated and replaced when the prototype chain changes.
5359 static Handle<Cell> GetOrCreatePrototypeChainValidityCell(Handle<Map> map,
5361 static const int kPrototypeChainValid = 0;
5362 static const int kPrototypeChainInvalid = 1;
5365 Map* FindFieldOwner(int descriptor);
5367 inline int GetInObjectPropertyOffset(int index);
5369 int NumberOfFields();
5371 // TODO(ishell): candidate with JSObject::MigrateToMap().
5372 bool InstancesNeedRewriting(Map* target, int target_number_of_fields,
5373 int target_inobject, int target_unused,
5374 int* old_number_of_fields);
5375 // TODO(ishell): moveit!
5376 static Handle<Map> GeneralizeAllFieldRepresentations(Handle<Map> map);
5377 MUST_USE_RESULT static Handle<HeapType> GeneralizeFieldType(
5378 Handle<HeapType> type1,
5379 Handle<HeapType> type2,
5381 static void GeneralizeFieldType(Handle<Map> map, int modify_index,
5382 Representation new_representation,
5383 Handle<HeapType> new_field_type);
5384 static Handle<Map> ReconfigureProperty(Handle<Map> map, int modify_index,
5385 PropertyKind new_kind,
5386 PropertyAttributes new_attributes,
5387 Representation new_representation,
5388 Handle<HeapType> new_field_type,
5389 StoreMode store_mode);
5390 static Handle<Map> CopyGeneralizeAllRepresentations(
5391 Handle<Map> map, int modify_index, StoreMode store_mode,
5392 PropertyKind kind, PropertyAttributes attributes, const char* reason);
5394 static Handle<Map> PrepareForDataProperty(Handle<Map> old_map,
5395 int descriptor_number,
5396 Handle<Object> value);
5398 static Handle<Map> Normalize(Handle<Map> map, PropertyNormalizationMode mode,
5399 const char* reason);
5401 // Returns the constructor name (the name (possibly, inferred name) of the
5402 // function that was used to instantiate the object).
5403 String* constructor_name();
5405 // Tells whether the map is used for JSObjects in dictionary mode (ie
5406 // normalized objects, ie objects for which HasFastProperties returns false).
5407 // A map can never be used for both dictionary mode and fast mode JSObjects.
5408 // False by default and for HeapObjects that are not JSObjects.
5409 inline void set_dictionary_map(bool value);
5410 inline bool is_dictionary_map();
5412 // Tells whether the instance needs security checks when accessing its
5414 inline void set_is_access_check_needed(bool access_check_needed);
5415 inline bool is_access_check_needed();
5417 // Returns true if map has a non-empty stub code cache.
5418 inline bool has_code_cache();
5420 // [prototype]: implicit prototype object.
5421 DECL_ACCESSORS(prototype, Object)
5422 // TODO(jkummerow): make set_prototype private.
5423 static void SetPrototype(
5424 Handle<Map> map, Handle<Object> prototype,
5425 PrototypeOptimizationMode proto_mode = FAST_PROTOTYPE);
5427 // [constructor]: points back to the function responsible for this map.
5428 // The field overlaps with the back pointer. All maps in a transition tree
5429 // have the same constructor, so maps with back pointers can walk the
5430 // back pointer chain until they find the map holding their constructor.
5431 DECL_ACCESSORS(constructor_or_backpointer, Object)
5432 inline Object* GetConstructor() const;
5433 inline void SetConstructor(Object* constructor,
5434 WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
5435 // [back pointer]: points back to the parent map from which a transition
5436 // leads to this map. The field overlaps with the constructor (see above).
5437 inline Object* GetBackPointer();
5438 inline void SetBackPointer(Object* value,
5439 WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
5441 // [instance descriptors]: describes the object.
5442 DECL_ACCESSORS(instance_descriptors, DescriptorArray)
5444 // [layout descriptor]: describes the object layout.
5445 DECL_ACCESSORS(layout_descriptor, LayoutDescriptor)
5446 // |layout descriptor| accessor which can be used from GC.
5447 inline LayoutDescriptor* layout_descriptor_gc_safe();
5448 inline bool HasFastPointerLayout() const;
5450 // |layout descriptor| accessor that is safe to call even when
5451 // FLAG_unbox_double_fields is disabled (in this case Map does not contain
5452 // |layout_descriptor| field at all).
5453 inline LayoutDescriptor* GetLayoutDescriptor();
5455 inline void UpdateDescriptors(DescriptorArray* descriptors,
5456 LayoutDescriptor* layout_descriptor);
5457 inline void InitializeDescriptors(DescriptorArray* descriptors,
5458 LayoutDescriptor* layout_descriptor);
5460 // [stub cache]: contains stubs compiled for this map.
5461 DECL_ACCESSORS(code_cache, Object)
5463 // [dependent code]: list of optimized codes that weakly embed this map.
5464 DECL_ACCESSORS(dependent_code, DependentCode)
5466 // [weak cell cache]: cache that stores a weak cell pointing to this map.
5467 DECL_ACCESSORS(weak_cell_cache, Object)
5469 inline PropertyDetails GetLastDescriptorDetails();
5471 inline int LastAdded();
5473 inline int NumberOfOwnDescriptors();
5474 inline void SetNumberOfOwnDescriptors(int number);
5476 inline Cell* RetrieveDescriptorsPointer();
5478 inline int EnumLength();
5479 inline void SetEnumLength(int length);
5481 inline bool owns_descriptors();
5482 inline void set_owns_descriptors(bool owns_descriptors);
5483 inline void mark_unstable();
5484 inline bool is_stable();
5485 inline void set_migration_target(bool value);
5486 inline bool is_migration_target();
5487 inline void set_counter(int value);
5488 inline int counter();
5489 inline void deprecate();
5490 inline bool is_deprecated();
5491 inline bool CanBeDeprecated();
5492 // Returns a non-deprecated version of the input. If the input was not
5493 // deprecated, it is directly returned. Otherwise, the non-deprecated version
5494 // is found by re-transitioning from the root of the transition tree using the
5495 // descriptor array of the map. Returns MaybeHandle<Map>() if no updated map
5497 static MaybeHandle<Map> TryUpdate(Handle<Map> map) WARN_UNUSED_RESULT;
5499 // Returns a non-deprecated version of the input. This method may deprecate
5500 // existing maps along the way if encodings conflict. Not for use while
5501 // gathering type feedback. Use TryUpdate in those cases instead.
5502 static Handle<Map> Update(Handle<Map> map);
5504 static Handle<Map> CopyDropDescriptors(Handle<Map> map);
5505 static Handle<Map> CopyInsertDescriptor(Handle<Map> map,
5506 Descriptor* descriptor,
5507 TransitionFlag flag);
5509 MUST_USE_RESULT static MaybeHandle<Map> CopyWithField(
5512 Handle<HeapType> type,
5513 PropertyAttributes attributes,
5514 Representation representation,
5515 TransitionFlag flag);
5517 MUST_USE_RESULT static MaybeHandle<Map> CopyWithConstant(
5520 Handle<Object> constant,
5521 PropertyAttributes attributes,
5522 TransitionFlag flag);
5524 // Returns a new map with all transitions dropped from the given map and
5525 // the ElementsKind set.
5526 static Handle<Map> TransitionElementsTo(Handle<Map> map,
5527 ElementsKind to_kind);
5529 static Handle<Map> AsElementsKind(Handle<Map> map, ElementsKind kind);
5531 static Handle<Map> CopyAsElementsKind(Handle<Map> map,
5533 TransitionFlag flag);
5535 static Handle<Map> CopyForObserved(Handle<Map> map);
5537 static Handle<Map> CopyForPreventExtensions(Handle<Map> map,
5538 PropertyAttributes attrs_to_add,
5539 Handle<Symbol> transition_marker,
5540 const char* reason);
5542 static Handle<Map> FixProxy(Handle<Map> map, InstanceType type, int size);
5545 // Maximal number of fast properties. Used to restrict the number of map
5546 // transitions to avoid an explosion in the number of maps for objects used as
5548 inline bool TooManyFastProperties(StoreFromKeyed store_mode);
5549 static Handle<Map> TransitionToDataProperty(Handle<Map> map,
5551 Handle<Object> value,
5552 PropertyAttributes attributes,
5553 StoreFromKeyed store_mode);
5554 static Handle<Map> TransitionToAccessorProperty(
5555 Handle<Map> map, Handle<Name> name, AccessorComponent component,
5556 Handle<Object> accessor, PropertyAttributes attributes);
5557 static Handle<Map> ReconfigureExistingProperty(Handle<Map> map,
5560 PropertyAttributes attributes);
5562 inline void AppendDescriptor(Descriptor* desc);
5564 // Returns a copy of the map, prepared for inserting into the transition
5565 // tree (if the |map| owns descriptors then the new one will share
5566 // descriptors with |map|).
5567 static Handle<Map> CopyForTransition(Handle<Map> map, const char* reason);
5569 // Returns a copy of the map, with all transitions dropped from the
5570 // instance descriptors.
5571 static Handle<Map> Copy(Handle<Map> map, const char* reason);
5572 static Handle<Map> Create(Isolate* isolate, int inobject_properties);
5574 // Returns the next free property index (only valid for FAST MODE).
5575 int NextFreePropertyIndex();
5577 // Returns the number of properties described in instance_descriptors
5578 // filtering out properties with the specified attributes.
5579 int NumberOfDescribedProperties(DescriptorFlag which = OWN_DESCRIPTORS,
5580 PropertyAttributes filter = NONE);
5584 // Code cache operations.
5586 // Clears the code cache.
5587 inline void ClearCodeCache(Heap* heap);
5589 // Update code cache.
5590 static void UpdateCodeCache(Handle<Map> map,
5594 // Extend the descriptor array of the map with the list of descriptors.
5595 // In case of duplicates, the latest descriptor is used.
5596 static void AppendCallbackDescriptors(Handle<Map> map,
5597 Handle<Object> descriptors);
5599 static inline int SlackForArraySize(int old_size, int size_limit);
5601 static void EnsureDescriptorSlack(Handle<Map> map, int slack);
5603 // Returns the found code or undefined if absent.
5604 Object* FindInCodeCache(Name* name, Code::Flags flags);
5606 // Returns the non-negative index of the code object if it is in the
5607 // cache and -1 otherwise.
5608 int IndexInCodeCache(Object* name, Code* code);
5610 // Removes a code object from the code cache at the given index.
5611 void RemoveFromCodeCache(Name* name, Code* code, int index);
5613 // Computes a hash value for this map, to be used in HashTables and such.
5616 // Returns the map that this map transitions to if its elements_kind
5617 // is changed to |elements_kind|, or NULL if no such map is cached yet.
5618 // |safe_to_add_transitions| is set to false if adding transitions is not
5620 Map* LookupElementsTransitionMap(ElementsKind elements_kind);
5622 // Returns the transitioned map for this map with the most generic
5623 // elements_kind that's found in |candidates|, or null handle if no match is
5625 static Handle<Map> FindTransitionedMap(Handle<Map> map,
5626 MapHandleList* candidates);
5628 inline bool CanTransition();
5630 inline bool IsPrimitiveMap();
5631 inline bool IsJSObjectMap();
5632 inline bool IsJSArrayMap();
5633 inline bool IsStringMap();
5634 inline bool IsJSProxyMap();
5635 inline bool IsJSGlobalProxyMap();
5636 inline bool IsJSGlobalObjectMap();
5637 inline bool IsGlobalObjectMap();
5639 inline bool CanOmitMapChecks();
5641 static void AddDependentCode(Handle<Map> map,
5642 DependentCode::DependencyGroup group,
5645 bool IsMapInArrayPrototypeChain();
5647 static Handle<WeakCell> WeakCellForMap(Handle<Map> map);
5649 // Dispatched behavior.
5650 DECLARE_PRINTER(Map)
5651 DECLARE_VERIFIER(Map)
5654 void DictionaryMapVerify();
5655 void VerifyOmittedMapChecks();
5658 inline int visitor_id();
5659 inline void set_visitor_id(int visitor_id);
5661 static Handle<Map> TransitionToPrototype(Handle<Map> map,
5662 Handle<Object> prototype,
5663 PrototypeOptimizationMode mode);
5665 static const int kMaxPreAllocatedPropertyFields = 255;
5667 // Layout description.
5668 static const int kInstanceSizesOffset = HeapObject::kHeaderSize;
5669 static const int kInstanceAttributesOffset = kInstanceSizesOffset + kIntSize;
5670 static const int kBitField3Offset = kInstanceAttributesOffset + kIntSize;
5671 static const int kPrototypeOffset = kBitField3Offset + kPointerSize;
5672 static const int kConstructorOrBackPointerOffset =
5673 kPrototypeOffset + kPointerSize;
5674 // When there is only one transition, it is stored directly in this field;
5675 // otherwise a transition array is used.
5676 // For prototype maps, this slot is used to store this map's PrototypeInfo
5678 static const int kTransitionsOrPrototypeInfoOffset =
5679 kConstructorOrBackPointerOffset + kPointerSize;
5680 static const int kDescriptorsOffset =
5681 kTransitionsOrPrototypeInfoOffset + kPointerSize;
5682 #if V8_DOUBLE_FIELDS_UNBOXING
5683 static const int kLayoutDecriptorOffset = kDescriptorsOffset + kPointerSize;
5684 static const int kCodeCacheOffset = kLayoutDecriptorOffset + kPointerSize;
5686 static const int kLayoutDecriptorOffset = 1; // Must not be ever accessed.
5687 static const int kCodeCacheOffset = kDescriptorsOffset + kPointerSize;
5689 static const int kDependentCodeOffset = kCodeCacheOffset + kPointerSize;
5690 static const int kWeakCellCacheOffset = kDependentCodeOffset + kPointerSize;
5691 static const int kSize = kWeakCellCacheOffset + kPointerSize;
5693 // Layout of pointer fields. Heap iteration code relies on them
5694 // being continuously allocated.
5695 static const int kPointerFieldsBeginOffset = Map::kPrototypeOffset;
5696 static const int kPointerFieldsEndOffset = kSize;
5698 // Byte offsets within kInstanceSizesOffset.
5699 static const int kInstanceSizeOffset = kInstanceSizesOffset + 0;
5700 static const int kInObjectPropertiesOrConstructorFunctionIndexByte = 1;
5701 static const int kInObjectPropertiesOrConstructorFunctionIndexOffset =
5702 kInstanceSizesOffset + kInObjectPropertiesOrConstructorFunctionIndexByte;
5703 // Note there is one byte available for use here.
5704 static const int kUnusedByte = 2;
5705 static const int kUnusedOffset = kInstanceSizesOffset + kUnusedByte;
5706 static const int kVisitorIdByte = 3;
5707 static const int kVisitorIdOffset = kInstanceSizesOffset + kVisitorIdByte;
5709 // Byte offsets within kInstanceAttributesOffset attributes.
5710 #if V8_TARGET_LITTLE_ENDIAN
5711 // Order instance type and bit field together such that they can be loaded
5712 // together as a 16-bit word with instance type in the lower 8 bits regardless
5713 // of endianess. Also provide endian-independent offset to that 16-bit word.
5714 static const int kInstanceTypeOffset = kInstanceAttributesOffset + 0;
5715 static const int kBitFieldOffset = kInstanceAttributesOffset + 1;
5717 static const int kBitFieldOffset = kInstanceAttributesOffset + 0;
5718 static const int kInstanceTypeOffset = kInstanceAttributesOffset + 1;
5720 static const int kInstanceTypeAndBitFieldOffset =
5721 kInstanceAttributesOffset + 0;
5722 static const int kBitField2Offset = kInstanceAttributesOffset + 2;
5723 static const int kUnusedPropertyFieldsByte = 3;
5724 static const int kUnusedPropertyFieldsOffset = kInstanceAttributesOffset + 3;
5726 STATIC_ASSERT(kInstanceTypeAndBitFieldOffset ==
5727 Internals::kMapInstanceTypeAndBitFieldOffset);
5729 // Bit positions for bit field.
5730 static const int kHasNonInstancePrototype = 0;
5731 static const int kIsCallable = 1;
5732 static const int kHasNamedInterceptor = 2;
5733 static const int kHasIndexedInterceptor = 3;
5734 static const int kIsUndetectable = 4;
5735 static const int kIsObserved = 5;
5736 static const int kIsAccessCheckNeeded = 6;
5737 class FunctionWithPrototype: public BitField<bool, 7, 1> {};
5739 // Bit positions for bit field 2
5740 static const int kIsExtensible = 0;
5741 static const int kStringWrapperSafeForDefaultValueOf = 1;
5742 class IsPrototypeMapBits : public BitField<bool, 2, 1> {};
5743 class ElementsKindBits: public BitField<ElementsKind, 3, 5> {};
5745 // Derived values from bit field 2
5746 static const int8_t kMaximumBitField2FastElementValue = static_cast<int8_t>(
5747 (FAST_ELEMENTS + 1) << Map::ElementsKindBits::kShift) - 1;
5748 static const int8_t kMaximumBitField2FastSmiElementValue =
5749 static_cast<int8_t>((FAST_SMI_ELEMENTS + 1) <<
5750 Map::ElementsKindBits::kShift) - 1;
5751 static const int8_t kMaximumBitField2FastHoleyElementValue =
5752 static_cast<int8_t>((FAST_HOLEY_ELEMENTS + 1) <<
5753 Map::ElementsKindBits::kShift) - 1;
5754 static const int8_t kMaximumBitField2FastHoleySmiElementValue =
5755 static_cast<int8_t>((FAST_HOLEY_SMI_ELEMENTS + 1) <<
5756 Map::ElementsKindBits::kShift) - 1;
5758 typedef FixedBodyDescriptor<kPointerFieldsBeginOffset,
5759 kPointerFieldsEndOffset,
5760 kSize> BodyDescriptor;
5762 // Compares this map to another to see if they describe equivalent objects.
5763 // If |mode| is set to CLEAR_INOBJECT_PROPERTIES, |other| is treated as if
5764 // it had exactly zero inobject properties.
5765 // The "shared" flags of both this map and |other| are ignored.
5766 bool EquivalentToForNormalization(Map* other, PropertyNormalizationMode mode);
5768 // Returns true if given field is unboxed double.
5769 inline bool IsUnboxedDoubleField(FieldIndex index);
5772 static void TraceTransition(const char* what, Map* from, Map* to, Name* name);
5773 static void TraceAllTransitions(Map* map);
5776 static inline Handle<Map> CopyInstallDescriptorsForTesting(
5777 Handle<Map> map, int new_descriptor, Handle<DescriptorArray> descriptors,
5778 Handle<LayoutDescriptor> layout_descriptor);
5781 static void ConnectTransition(Handle<Map> parent, Handle<Map> child,
5782 Handle<Name> name, SimpleTransitionFlag flag);
5784 bool EquivalentToForTransition(Map* other);
5785 static Handle<Map> RawCopy(Handle<Map> map, int instance_size);
5786 static Handle<Map> ShareDescriptor(Handle<Map> map,
5787 Handle<DescriptorArray> descriptors,
5788 Descriptor* descriptor);
5789 static Handle<Map> CopyInstallDescriptors(
5790 Handle<Map> map, int new_descriptor, Handle<DescriptorArray> descriptors,
5791 Handle<LayoutDescriptor> layout_descriptor);
5792 static Handle<Map> CopyAddDescriptor(Handle<Map> map,
5793 Descriptor* descriptor,
5794 TransitionFlag flag);
5795 static Handle<Map> CopyReplaceDescriptors(
5796 Handle<Map> map, Handle<DescriptorArray> descriptors,
5797 Handle<LayoutDescriptor> layout_descriptor, TransitionFlag flag,
5798 MaybeHandle<Name> maybe_name, const char* reason,
5799 SimpleTransitionFlag simple_flag);
5801 static Handle<Map> CopyReplaceDescriptor(Handle<Map> map,
5802 Handle<DescriptorArray> descriptors,
5803 Descriptor* descriptor,
5805 TransitionFlag flag);
5806 static MUST_USE_RESULT MaybeHandle<Map> TryReconfigureExistingProperty(
5807 Handle<Map> map, int descriptor, PropertyKind kind,
5808 PropertyAttributes attributes, const char** reason);
5810 static Handle<Map> CopyNormalized(Handle<Map> map,
5811 PropertyNormalizationMode mode);
5813 // Fires when the layout of an object with a leaf map changes.
5814 // This includes adding transitions to the leaf map or changing
5815 // the descriptor array.
5816 inline void NotifyLeafMapLayoutChange();
5818 void DeprecateTransitionTree();
5819 bool DeprecateTarget(PropertyKind kind, Name* key,
5820 PropertyAttributes attributes,
5821 DescriptorArray* new_descriptors,
5822 LayoutDescriptor* new_layout_descriptor);
5824 Map* FindLastMatchMap(int verbatim, int length, DescriptorArray* descriptors);
5826 // Update field type of the given descriptor to new representation and new
5827 // type. The type must be prepared for storing in descriptor array:
5828 // it must be either a simple type or a map wrapped in a weak cell.
5829 void UpdateFieldType(int descriptor_number, Handle<Name> name,
5830 Representation new_representation,
5831 Handle<Object> new_wrapped_type);
5833 void PrintReconfiguration(FILE* file, int modify_index, PropertyKind kind,
5834 PropertyAttributes attributes);
5835 void PrintGeneralization(FILE* file,
5840 bool constant_to_field,
5841 Representation old_representation,
5842 Representation new_representation,
5843 HeapType* old_field_type,
5844 HeapType* new_field_type);
5846 static const int kFastPropertiesSoftLimit = 12;
5847 static const int kMaxFastProperties = 128;
5849 DISALLOW_IMPLICIT_CONSTRUCTORS(Map);
5853 // An abstract superclass, a marker class really, for simple structure classes.
5854 // It doesn't carry much functionality but allows struct classes to be
5855 // identified in the type system.
5856 class Struct: public HeapObject {
5858 inline void InitializeBody(int object_size);
5859 DECLARE_CAST(Struct)
5863 // A simple one-element struct, useful where smis need to be boxed.
5864 class Box : public Struct {
5866 // [value]: the boxed contents.
5867 DECL_ACCESSORS(value, Object)
5871 // Dispatched behavior.
5872 DECLARE_PRINTER(Box)
5873 DECLARE_VERIFIER(Box)
5875 static const int kValueOffset = HeapObject::kHeaderSize;
5876 static const int kSize = kValueOffset + kPointerSize;
5879 DISALLOW_IMPLICIT_CONSTRUCTORS(Box);
5883 // Container for metadata stored on each prototype map.
5884 class PrototypeInfo : public Struct {
5886 static const int UNREGISTERED = -1;
5888 // [prototype_users]: WeakFixedArray containing maps using this prototype,
5889 // or Smi(0) if uninitialized.
5890 DECL_ACCESSORS(prototype_users, Object)
5891 // [registry_slot]: Slot in prototype's user registry where this user
5892 // is stored. Returns UNREGISTERED if this prototype has not been registered.
5893 inline int registry_slot() const;
5894 inline void set_registry_slot(int slot);
5895 // [validity_cell]: Cell containing the validity bit for prototype chains
5896 // going through this object, or Smi(0) if uninitialized.
5897 DECL_ACCESSORS(validity_cell, Object)
5898 // [constructor_name]: User-friendly name of the original constructor.
5899 DECL_ACCESSORS(constructor_name, Object)
5901 DECLARE_CAST(PrototypeInfo)
5903 // Dispatched behavior.
5904 DECLARE_PRINTER(PrototypeInfo)
5905 DECLARE_VERIFIER(PrototypeInfo)
5907 static const int kPrototypeUsersOffset = HeapObject::kHeaderSize;
5908 static const int kRegistrySlotOffset = kPrototypeUsersOffset + kPointerSize;
5909 static const int kValidityCellOffset = kRegistrySlotOffset + kPointerSize;
5910 static const int kConstructorNameOffset = kValidityCellOffset + kPointerSize;
5911 static const int kSize = kConstructorNameOffset + kPointerSize;
5914 DISALLOW_IMPLICIT_CONSTRUCTORS(PrototypeInfo);
5918 // Pair used to store both a ScopeInfo and an extension object in the extension
5919 // slot of a block context. Needed in the rare case where a declaration block
5920 // scope (a "varblock" as used to desugar parameter destructuring) also contains
5921 // a sloppy direct eval. (In no other case both are needed at the same time.)
5922 class SloppyBlockWithEvalContextExtension : public Struct {
5924 // [scope_info]: Scope info.
5925 DECL_ACCESSORS(scope_info, ScopeInfo)
5926 // [extension]: Extension object.
5927 DECL_ACCESSORS(extension, JSObject)
5929 DECLARE_CAST(SloppyBlockWithEvalContextExtension)
5931 // Dispatched behavior.
5932 DECLARE_PRINTER(SloppyBlockWithEvalContextExtension)
5933 DECLARE_VERIFIER(SloppyBlockWithEvalContextExtension)
5935 static const int kScopeInfoOffset = HeapObject::kHeaderSize;
5936 static const int kExtensionOffset = kScopeInfoOffset + kPointerSize;
5937 static const int kSize = kExtensionOffset + kPointerSize;
5940 DISALLOW_IMPLICIT_CONSTRUCTORS(SloppyBlockWithEvalContextExtension);
5944 // Script describes a script which has been added to the VM.
5945 class Script: public Struct {
5954 // Script compilation types.
5955 enum CompilationType {
5956 COMPILATION_TYPE_HOST = 0,
5957 COMPILATION_TYPE_EVAL = 1
5960 // Script compilation state.
5961 enum CompilationState {
5962 COMPILATION_STATE_INITIAL = 0,
5963 COMPILATION_STATE_COMPILED = 1
5966 // [source]: the script source.
5967 DECL_ACCESSORS(source, Object)
5969 // [name]: the script name.
5970 DECL_ACCESSORS(name, Object)
5972 // [id]: the script id.
5973 DECL_ACCESSORS(id, Smi)
5975 // [line_offset]: script line offset in resource from where it was extracted.
5976 DECL_ACCESSORS(line_offset, Smi)
5978 // [column_offset]: script column offset in resource from where it was
5980 DECL_ACCESSORS(column_offset, Smi)
5982 // [context_data]: context data for the context this script was compiled in.
5983 DECL_ACCESSORS(context_data, Object)
5985 // [wrapper]: the wrapper cache. This is either undefined or a WeakCell.
5986 DECL_ACCESSORS(wrapper, HeapObject)
5988 // [type]: the script type.
5989 DECL_ACCESSORS(type, Smi)
5991 // [line_ends]: FixedArray of line ends positions.
5992 DECL_ACCESSORS(line_ends, Object)
5994 // [eval_from_shared]: for eval scripts the shared funcion info for the
5995 // function from which eval was called.
5996 DECL_ACCESSORS(eval_from_shared, Object)
5998 // [eval_from_instructions_offset]: the instruction offset in the code for the
5999 // function from which eval was called where eval was called.
6000 DECL_ACCESSORS(eval_from_instructions_offset, Smi)
6002 // [shared_function_infos]: weak fixed array containing all shared
6003 // function infos created from this script.
6004 DECL_ACCESSORS(shared_function_infos, Object)
6006 // [flags]: Holds an exciting bitfield.
6007 DECL_ACCESSORS(flags, Smi)
6009 // [source_url]: sourceURL from magic comment
6010 DECL_ACCESSORS(source_url, Object)
6012 // [source_url]: sourceMappingURL magic comment
6013 DECL_ACCESSORS(source_mapping_url, Object)
6015 // [compilation_type]: how the the script was compiled. Encoded in the
6017 inline CompilationType compilation_type();
6018 inline void set_compilation_type(CompilationType type);
6020 // [compilation_state]: determines whether the script has already been
6021 // compiled. Encoded in the 'flags' field.
6022 inline CompilationState compilation_state();
6023 inline void set_compilation_state(CompilationState state);
6025 // [hide_source]: determines whether the script source can be exposed as
6026 // function source. Encoded in the 'flags' field.
6027 inline bool hide_source();
6028 inline void set_hide_source(bool value);
6030 // [origin_options]: optional attributes set by the embedder via ScriptOrigin,
6031 // and used by the embedder to make decisions about the script. V8 just passes
6032 // this through. Encoded in the 'flags' field.
6033 inline v8::ScriptOriginOptions origin_options();
6034 inline void set_origin_options(ScriptOriginOptions origin_options);
6036 DECLARE_CAST(Script)
6038 // If script source is an external string, check that the underlying
6039 // resource is accessible. Otherwise, always return true.
6040 inline bool HasValidSource();
6042 // Convert code position into column number.
6043 static int GetColumnNumber(Handle<Script> script, int code_pos);
6045 // Convert code position into (zero-based) line number.
6046 // The non-handlified version does not allocate, but may be much slower.
6047 static int GetLineNumber(Handle<Script> script, int code_pos);
6048 int GetLineNumber(int code_pos);
6050 static Handle<Object> GetNameOrSourceURL(Handle<Script> script);
6052 // Init line_ends array with code positions of line ends inside script source.
6053 static void InitLineEnds(Handle<Script> script);
6055 // Get the JS object wrapping the given script; create it if none exists.
6056 static Handle<JSObject> GetWrapper(Handle<Script> script);
6058 // Look through the list of existing shared function infos to find one
6059 // that matches the function literal. Return empty handle if not found.
6060 MaybeHandle<SharedFunctionInfo> FindSharedFunctionInfo(FunctionLiteral* fun);
6062 // Iterate over all script objects on the heap.
6065 explicit Iterator(Isolate* isolate);
6069 WeakFixedArray::Iterator iterator_;
6070 DISALLOW_COPY_AND_ASSIGN(Iterator);
6073 // Dispatched behavior.
6074 DECLARE_PRINTER(Script)
6075 DECLARE_VERIFIER(Script)
6077 static const int kSourceOffset = HeapObject::kHeaderSize;
6078 static const int kNameOffset = kSourceOffset + kPointerSize;
6079 static const int kLineOffsetOffset = kNameOffset + kPointerSize;
6080 static const int kColumnOffsetOffset = kLineOffsetOffset + kPointerSize;
6081 static const int kContextOffset = kColumnOffsetOffset + kPointerSize;
6082 static const int kWrapperOffset = kContextOffset + kPointerSize;
6083 static const int kTypeOffset = kWrapperOffset + kPointerSize;
6084 static const int kLineEndsOffset = kTypeOffset + kPointerSize;
6085 static const int kIdOffset = kLineEndsOffset + kPointerSize;
6086 static const int kEvalFromSharedOffset = kIdOffset + kPointerSize;
6087 static const int kEvalFrominstructionsOffsetOffset =
6088 kEvalFromSharedOffset + kPointerSize;
6089 static const int kSharedFunctionInfosOffset =
6090 kEvalFrominstructionsOffsetOffset + kPointerSize;
6091 static const int kFlagsOffset = kSharedFunctionInfosOffset + kPointerSize;
6092 static const int kSourceUrlOffset = kFlagsOffset + kPointerSize;
6093 static const int kSourceMappingUrlOffset = kSourceUrlOffset + kPointerSize;
6094 static const int kSize = kSourceMappingUrlOffset + kPointerSize;
6097 int GetLineNumberWithArray(int code_pos);
6099 // Bit positions in the flags field.
6100 static const int kCompilationTypeBit = 0;
6101 static const int kCompilationStateBit = 1;
6102 static const int kHideSourceBit = 2;
6103 static const int kOriginOptionsShift = 3;
6104 static const int kOriginOptionsSize = 3;
6105 static const int kOriginOptionsMask = ((1 << kOriginOptionsSize) - 1)
6106 << kOriginOptionsShift;
6108 DISALLOW_IMPLICIT_CONSTRUCTORS(Script);
6112 // List of builtin functions we want to identify to improve code
6115 // Each entry has a name of a global object property holding an object
6116 // optionally followed by ".prototype", a name of a builtin function
6117 // on the object (the one the id is set for), and a label.
6119 // Installation of ids for the selected builtin functions is handled
6120 // by the bootstrapper.
6121 #define FUNCTIONS_WITH_ID_LIST(V) \
6122 V(Array.prototype, indexOf, ArrayIndexOf) \
6123 V(Array.prototype, lastIndexOf, ArrayLastIndexOf) \
6124 V(Array.prototype, push, ArrayPush) \
6125 V(Array.prototype, pop, ArrayPop) \
6126 V(Array.prototype, shift, ArrayShift) \
6127 V(Function.prototype, apply, FunctionApply) \
6128 V(Function.prototype, call, FunctionCall) \
6129 V(String.prototype, charCodeAt, StringCharCodeAt) \
6130 V(String.prototype, charAt, StringCharAt) \
6131 V(String, fromCharCode, StringFromCharCode) \
6132 V(Math, random, MathRandom) \
6133 V(Math, floor, MathFloor) \
6134 V(Math, round, MathRound) \
6135 V(Math, ceil, MathCeil) \
6136 V(Math, abs, MathAbs) \
6137 V(Math, log, MathLog) \
6138 V(Math, exp, MathExp) \
6139 V(Math, sqrt, MathSqrt) \
6140 V(Math, pow, MathPow) \
6141 V(Math, max, MathMax) \
6142 V(Math, min, MathMin) \
6143 V(Math, cos, MathCos) \
6144 V(Math, sin, MathSin) \
6145 V(Math, tan, MathTan) \
6146 V(Math, acos, MathAcos) \
6147 V(Math, asin, MathAsin) \
6148 V(Math, atan, MathAtan) \
6149 V(Math, atan2, MathAtan2) \
6150 V(Math, imul, MathImul) \
6151 V(Math, clz32, MathClz32) \
6152 V(Math, fround, MathFround)
6154 #define ATOMIC_FUNCTIONS_WITH_ID_LIST(V) \
6155 V(Atomics, load, AtomicsLoad) \
6156 V(Atomics, store, AtomicsStore)
6158 enum BuiltinFunctionId {
6160 #define DECLARE_FUNCTION_ID(ignored1, ignore2, name) \
6162 FUNCTIONS_WITH_ID_LIST(DECLARE_FUNCTION_ID)
6163 ATOMIC_FUNCTIONS_WITH_ID_LIST(DECLARE_FUNCTION_ID)
6164 #undef DECLARE_FUNCTION_ID
6165 // Fake id for a special case of Math.pow. Note, it continues the
6166 // list of math functions.
6171 // Result of searching in an optimized code map of a SharedFunctionInfo. Note
6172 // that both {code} and {literals} can be NULL to pass search result status.
6173 struct CodeAndLiterals {
6174 Code* code; // Cached optimized code.
6175 FixedArray* literals; // Cached literals array.
6179 // SharedFunctionInfo describes the JSFunction information that can be
6180 // shared by multiple instances of the function.
6181 class SharedFunctionInfo: public HeapObject {
6183 // [name]: Function name.
6184 DECL_ACCESSORS(name, Object)
6186 // [code]: Function code.
6187 DECL_ACCESSORS(code, Code)
6188 inline void ReplaceCode(Code* code);
6190 // [optimized_code_map]: Map from native context to optimized code
6191 // and a shared literals array or Smi(0) if none.
6192 DECL_ACCESSORS(optimized_code_map, Object)
6194 // Returns entry from optimized code map for specified context and OSR entry.
6195 // Note that {code == nullptr} indicates no matching entry has been found,
6196 // whereas {literals == nullptr} indicates the code is context-independent.
6197 CodeAndLiterals SearchOptimizedCodeMap(Context* native_context,
6198 BailoutId osr_ast_id);
6200 // Clear optimized code map.
6201 void ClearOptimizedCodeMap();
6203 // Removed a specific optimized code object from the optimized code map.
6204 void EvictFromOptimizedCodeMap(Code* optimized_code, const char* reason);
6206 // Trims the optimized code map after entries have been removed.
6207 void TrimOptimizedCodeMap(int shrink_by);
6209 // Add a new entry to the optimized code map for context-independent code.
6210 static void AddSharedCodeToOptimizedCodeMap(Handle<SharedFunctionInfo> shared,
6213 // Add a new entry to the optimized code map for context-dependent code.
6214 static void AddToOptimizedCodeMap(Handle<SharedFunctionInfo> shared,
6215 Handle<Context> native_context,
6217 Handle<FixedArray> literals,
6218 BailoutId osr_ast_id);
6220 // Set up the link between shared function info and the script. The shared
6221 // function info is added to the list on the script.
6222 static void SetScript(Handle<SharedFunctionInfo> shared,
6223 Handle<Object> script_object);
6225 // Layout description of the optimized code map.
6226 static const int kNextMapIndex = 0;
6227 static const int kSharedCodeIndex = 1;
6228 static const int kEntriesStart = 2;
6229 static const int kContextOffset = 0;
6230 static const int kCachedCodeOffset = 1;
6231 static const int kLiteralsOffset = 2;
6232 static const int kOsrAstIdOffset = 3;
6233 static const int kEntryLength = 4;
6234 static const int kInitialLength = kEntriesStart + kEntryLength;
6236 // [scope_info]: Scope info.
6237 DECL_ACCESSORS(scope_info, ScopeInfo)
6239 // [construct stub]: Code stub for constructing instances of this function.
6240 DECL_ACCESSORS(construct_stub, Code)
6242 // Returns if this function has been compiled to native code yet.
6243 inline bool is_compiled();
6245 // [length]: The function length - usually the number of declared parameters.
6246 // Use up to 2^30 parameters.
6247 inline int length() const;
6248 inline void set_length(int value);
6250 // [internal formal parameter count]: The declared number of parameters.
6251 // For subclass constructors, also includes new.target.
6252 // The size of function's frame is internal_formal_parameter_count + 1.
6253 inline int internal_formal_parameter_count() const;
6254 inline void set_internal_formal_parameter_count(int value);
6256 // Set the formal parameter count so the function code will be
6257 // called without using argument adaptor frames.
6258 inline void DontAdaptArguments();
6260 // [expected_nof_properties]: Expected number of properties for the function.
6261 inline int expected_nof_properties() const;
6262 inline void set_expected_nof_properties(int value);
6264 // [feedback_vector] - accumulates ast node feedback from full-codegen and
6265 // (increasingly) from crankshafted code where sufficient feedback isn't
6267 DECL_ACCESSORS(feedback_vector, TypeFeedbackVector)
6269 // Unconditionally clear the type feedback vector (including vector ICs).
6270 void ClearTypeFeedbackInfo();
6272 // Clear the type feedback vector with a more subtle policy at GC time.
6273 void ClearTypeFeedbackInfoAtGCTime();
6276 // [unique_id] - For --trace-maps purposes, an identifier that's persistent
6277 // even if the GC moves this SharedFunctionInfo.
6278 inline int unique_id() const;
6279 inline void set_unique_id(int value);
6282 // [instance class name]: class name for instances.
6283 DECL_ACCESSORS(instance_class_name, Object)
6285 // [function data]: This field holds some additional data for function.
6286 // Currently it has one of:
6287 // - a FunctionTemplateInfo to make benefit the API [IsApiFunction()].
6288 // - a Smi identifying a builtin function [HasBuiltinFunctionId()].
6289 // - a BytecodeArray for the interpreter [HasBytecodeArray()].
6290 // In the long run we don't want all functions to have this field but
6291 // we can fix that when we have a better model for storing hidden data
6293 DECL_ACCESSORS(function_data, Object)
6295 inline bool IsApiFunction();
6296 inline FunctionTemplateInfo* get_api_func_data();
6297 inline bool HasBuiltinFunctionId();
6298 inline BuiltinFunctionId builtin_function_id();
6299 inline bool HasBytecodeArray();
6300 inline BytecodeArray* bytecode_array();
6302 // [script info]: Script from which the function originates.
6303 DECL_ACCESSORS(script, Object)
6305 // [num_literals]: Number of literals used by this function.
6306 inline int num_literals() const;
6307 inline void set_num_literals(int value);
6309 // [start_position_and_type]: Field used to store both the source code
6310 // position, whether or not the function is a function expression,
6311 // and whether or not the function is a toplevel function. The two
6312 // least significants bit indicates whether the function is an
6313 // expression and the rest contains the source code position.
6314 inline int start_position_and_type() const;
6315 inline void set_start_position_and_type(int value);
6317 // The function is subject to debugging if a debug info is attached.
6318 inline bool HasDebugInfo();
6319 inline DebugInfo* GetDebugInfo();
6321 // A function has debug code if the compiled code has debug break slots.
6322 inline bool HasDebugCode();
6324 // [debug info]: Debug information.
6325 DECL_ACCESSORS(debug_info, Object)
6327 // [inferred name]: Name inferred from variable or property
6328 // assignment of this function. Used to facilitate debugging and
6329 // profiling of JavaScript code written in OO style, where almost
6330 // all functions are anonymous but are assigned to object
6332 DECL_ACCESSORS(inferred_name, String)
6334 // The function's name if it is non-empty, otherwise the inferred name.
6335 String* DebugName();
6337 // Position of the 'function' token in the script source.
6338 inline int function_token_position() const;
6339 inline void set_function_token_position(int function_token_position);
6341 // Position of this function in the script source.
6342 inline int start_position() const;
6343 inline void set_start_position(int start_position);
6345 // End position of this function in the script source.
6346 inline int end_position() const;
6347 inline void set_end_position(int end_position);
6349 // Is this function a function expression in the source code.
6350 DECL_BOOLEAN_ACCESSORS(is_expression)
6352 // Is this function a top-level function (scripts, evals).
6353 DECL_BOOLEAN_ACCESSORS(is_toplevel)
6355 // Bit field containing various information collected by the compiler to
6356 // drive optimization.
6357 inline int compiler_hints() const;
6358 inline void set_compiler_hints(int value);
6360 inline int ast_node_count() const;
6361 inline void set_ast_node_count(int count);
6363 inline int profiler_ticks() const;
6364 inline void set_profiler_ticks(int ticks);
6366 // Inline cache age is used to infer whether the function survived a context
6367 // disposal or not. In the former case we reset the opt_count.
6368 inline int ic_age();
6369 inline void set_ic_age(int age);
6371 // Indicates if this function can be lazy compiled.
6372 // This is used to determine if we can safely flush code from a function
6373 // when doing GC if we expect that the function will no longer be used.
6374 DECL_BOOLEAN_ACCESSORS(allows_lazy_compilation)
6376 // Indicates if this function can be lazy compiled without a context.
6377 // This is used to determine if we can force compilation without reaching
6378 // the function through program execution but through other means (e.g. heap
6379 // iteration by the debugger).
6380 DECL_BOOLEAN_ACCESSORS(allows_lazy_compilation_without_context)
6382 // Indicates whether optimizations have been disabled for this
6383 // shared function info. If a function is repeatedly optimized or if
6384 // we cannot optimize the function we disable optimization to avoid
6385 // spending time attempting to optimize it again.
6386 DECL_BOOLEAN_ACCESSORS(optimization_disabled)
6388 // Indicates the language mode.
6389 inline LanguageMode language_mode();
6390 inline void set_language_mode(LanguageMode language_mode);
6392 // False if the function definitely does not allocate an arguments object.
6393 DECL_BOOLEAN_ACCESSORS(uses_arguments)
6395 // Indicates that this function uses a super property (or an eval that may
6396 // use a super property).
6397 // This is needed to set up the [[HomeObject]] on the function instance.
6398 DECL_BOOLEAN_ACCESSORS(needs_home_object)
6400 // True if the function has any duplicated parameter names.
6401 DECL_BOOLEAN_ACCESSORS(has_duplicate_parameters)
6403 // Indicates whether the function is a native function.
6404 // These needs special treatment in .call and .apply since
6405 // null passed as the receiver should not be translated to the
6407 DECL_BOOLEAN_ACCESSORS(native)
6409 // Indicate that this function should always be inlined in optimized code.
6410 DECL_BOOLEAN_ACCESSORS(force_inline)
6412 // Indicates that the function was created by the Function function.
6413 // Though it's anonymous, toString should treat it as if it had the name
6414 // "anonymous". We don't set the name itself so that the system does not
6415 // see a binding for it.
6416 DECL_BOOLEAN_ACCESSORS(name_should_print_as_anonymous)
6418 // Indicates whether the function is a bound function created using
6419 // the bind function.
6420 DECL_BOOLEAN_ACCESSORS(bound)
6422 // Indicates that the function is anonymous (the name field can be set
6423 // through the API, which does not change this flag).
6424 DECL_BOOLEAN_ACCESSORS(is_anonymous)
6426 // Is this a function or top-level/eval code.
6427 DECL_BOOLEAN_ACCESSORS(is_function)
6429 // Indicates that code for this function cannot be compiled with Crankshaft.
6430 DECL_BOOLEAN_ACCESSORS(dont_crankshaft)
6432 // Indicates that code for this function cannot be flushed.
6433 DECL_BOOLEAN_ACCESSORS(dont_flush)
6435 // Indicates that this function is a generator.
6436 DECL_BOOLEAN_ACCESSORS(is_generator)
6438 // Indicates that this function is an arrow function.
6439 DECL_BOOLEAN_ACCESSORS(is_arrow)
6441 // Indicates that this function is a concise method.
6442 DECL_BOOLEAN_ACCESSORS(is_concise_method)
6444 // Indicates that this function is an accessor (getter or setter).
6445 DECL_BOOLEAN_ACCESSORS(is_accessor_function)
6447 // Indicates that this function is a default constructor.
6448 DECL_BOOLEAN_ACCESSORS(is_default_constructor)
6450 // Indicates that this function is an asm function.
6451 DECL_BOOLEAN_ACCESSORS(asm_function)
6453 // Indicates that the the shared function info is deserialized from cache.
6454 DECL_BOOLEAN_ACCESSORS(deserialized)
6456 // Indicates that the the shared function info has never been compiled before.
6457 DECL_BOOLEAN_ACCESSORS(never_compiled)
6459 inline FunctionKind kind();
6460 inline void set_kind(FunctionKind kind);
6462 // Indicates whether or not the code in the shared function support
6464 inline bool has_deoptimization_support();
6466 // Enable deoptimization support through recompiled code.
6467 void EnableDeoptimizationSupport(Code* recompiled);
6469 // Disable (further) attempted optimization of all functions sharing this
6470 // shared function info.
6471 void DisableOptimization(BailoutReason reason);
6473 inline BailoutReason disable_optimization_reason();
6475 // Lookup the bailout ID and DCHECK that it exists in the non-optimized
6476 // code, returns whether it asserted (i.e., always true if assertions are
6478 bool VerifyBailoutId(BailoutId id);
6480 // [source code]: Source code for the function.
6481 bool HasSourceCode() const;
6482 Handle<Object> GetSourceCode();
6484 // Number of times the function was optimized.
6485 inline int opt_count();
6486 inline void set_opt_count(int opt_count);
6488 // Number of times the function was deoptimized.
6489 inline void set_deopt_count(int value);
6490 inline int deopt_count();
6491 inline void increment_deopt_count();
6493 // Number of time we tried to re-enable optimization after it
6494 // was disabled due to high number of deoptimizations.
6495 inline void set_opt_reenable_tries(int value);
6496 inline int opt_reenable_tries();
6498 inline void TryReenableOptimization();
6500 // Stores deopt_count, opt_reenable_tries and ic_age as bit-fields.
6501 inline void set_counters(int value);
6502 inline int counters() const;
6504 // Stores opt_count and bailout_reason as bit-fields.
6505 inline void set_opt_count_and_bailout_reason(int value);
6506 inline int opt_count_and_bailout_reason() const;
6508 inline void set_disable_optimization_reason(BailoutReason reason);
6510 // Tells whether this function should be subject to debugging.
6511 inline bool IsSubjectToDebugging();
6513 // Whether this function is defined in native code or extensions.
6514 inline bool IsBuiltin();
6516 // Check whether or not this function is inlineable.
6517 bool IsInlineable();
6519 // Source size of this function.
6522 // Calculate the instance size.
6523 int CalculateInstanceSize();
6525 // Calculate the number of in-object properties.
6526 int CalculateInObjectProperties();
6528 inline bool has_simple_parameters();
6530 // Initialize a SharedFunctionInfo from a parsed function literal.
6531 static void InitFromFunctionLiteral(Handle<SharedFunctionInfo> shared_info,
6532 FunctionLiteral* lit);
6534 // Dispatched behavior.
6535 DECLARE_PRINTER(SharedFunctionInfo)
6536 DECLARE_VERIFIER(SharedFunctionInfo)
6538 void ResetForNewContext(int new_ic_age);
6540 // Iterate over all shared function infos that are created from a script.
6541 // That excludes shared function infos created for API functions and C++
6545 explicit Iterator(Isolate* isolate);
6546 SharedFunctionInfo* Next();
6551 Script::Iterator script_iterator_;
6552 WeakFixedArray::Iterator sfi_iterator_;
6553 DisallowHeapAllocation no_gc_;
6554 DISALLOW_COPY_AND_ASSIGN(Iterator);
6557 DECLARE_CAST(SharedFunctionInfo)
6560 static const int kDontAdaptArgumentsSentinel = -1;
6562 // Layout description.
6564 static const int kNameOffset = HeapObject::kHeaderSize;
6565 static const int kCodeOffset = kNameOffset + kPointerSize;
6566 static const int kOptimizedCodeMapOffset = kCodeOffset + kPointerSize;
6567 static const int kScopeInfoOffset = kOptimizedCodeMapOffset + kPointerSize;
6568 static const int kConstructStubOffset = kScopeInfoOffset + kPointerSize;
6569 static const int kInstanceClassNameOffset =
6570 kConstructStubOffset + kPointerSize;
6571 static const int kFunctionDataOffset =
6572 kInstanceClassNameOffset + kPointerSize;
6573 static const int kScriptOffset = kFunctionDataOffset + kPointerSize;
6574 static const int kDebugInfoOffset = kScriptOffset + kPointerSize;
6575 static const int kInferredNameOffset = kDebugInfoOffset + kPointerSize;
6576 static const int kFeedbackVectorOffset =
6577 kInferredNameOffset + kPointerSize;
6579 static const int kUniqueIdOffset = kFeedbackVectorOffset + kPointerSize;
6580 static const int kLastPointerFieldOffset = kUniqueIdOffset;
6582 // Just to not break the postmortrem support with conditional offsets
6583 static const int kUniqueIdOffset = kFeedbackVectorOffset;
6584 static const int kLastPointerFieldOffset = kFeedbackVectorOffset;
6587 #if V8_HOST_ARCH_32_BIT
6589 static const int kLengthOffset = kLastPointerFieldOffset + kPointerSize;
6590 static const int kFormalParameterCountOffset = kLengthOffset + kPointerSize;
6591 static const int kExpectedNofPropertiesOffset =
6592 kFormalParameterCountOffset + kPointerSize;
6593 static const int kNumLiteralsOffset =
6594 kExpectedNofPropertiesOffset + kPointerSize;
6595 static const int kStartPositionAndTypeOffset =
6596 kNumLiteralsOffset + kPointerSize;
6597 static const int kEndPositionOffset =
6598 kStartPositionAndTypeOffset + kPointerSize;
6599 static const int kFunctionTokenPositionOffset =
6600 kEndPositionOffset + kPointerSize;
6601 static const int kCompilerHintsOffset =
6602 kFunctionTokenPositionOffset + kPointerSize;
6603 static const int kOptCountAndBailoutReasonOffset =
6604 kCompilerHintsOffset + kPointerSize;
6605 static const int kCountersOffset =
6606 kOptCountAndBailoutReasonOffset + kPointerSize;
6607 static const int kAstNodeCountOffset =
6608 kCountersOffset + kPointerSize;
6609 static const int kProfilerTicksOffset =
6610 kAstNodeCountOffset + kPointerSize;
6613 static const int kSize = kProfilerTicksOffset + kPointerSize;
6615 // The only reason to use smi fields instead of int fields
6616 // is to allow iteration without maps decoding during
6617 // garbage collections.
6618 // To avoid wasting space on 64-bit architectures we use
6619 // the following trick: we group integer fields into pairs
6620 // The least significant integer in each pair is shifted left by 1.
6621 // By doing this we guarantee that LSB of each kPointerSize aligned
6622 // word is not set and thus this word cannot be treated as pointer
6623 // to HeapObject during old space traversal.
6624 #if V8_TARGET_LITTLE_ENDIAN
6625 static const int kLengthOffset = kLastPointerFieldOffset + kPointerSize;
6626 static const int kFormalParameterCountOffset =
6627 kLengthOffset + kIntSize;
6629 static const int kExpectedNofPropertiesOffset =
6630 kFormalParameterCountOffset + kIntSize;
6631 static const int kNumLiteralsOffset =
6632 kExpectedNofPropertiesOffset + kIntSize;
6634 static const int kEndPositionOffset =
6635 kNumLiteralsOffset + kIntSize;
6636 static const int kStartPositionAndTypeOffset =
6637 kEndPositionOffset + kIntSize;
6639 static const int kFunctionTokenPositionOffset =
6640 kStartPositionAndTypeOffset + kIntSize;
6641 static const int kCompilerHintsOffset =
6642 kFunctionTokenPositionOffset + kIntSize;
6644 static const int kOptCountAndBailoutReasonOffset =
6645 kCompilerHintsOffset + kIntSize;
6646 static const int kCountersOffset =
6647 kOptCountAndBailoutReasonOffset + kIntSize;
6649 static const int kAstNodeCountOffset =
6650 kCountersOffset + kIntSize;
6651 static const int kProfilerTicksOffset =
6652 kAstNodeCountOffset + kIntSize;
6655 static const int kSize = kProfilerTicksOffset + kIntSize;
6657 #elif V8_TARGET_BIG_ENDIAN
6658 static const int kFormalParameterCountOffset =
6659 kLastPointerFieldOffset + kPointerSize;
6660 static const int kLengthOffset = kFormalParameterCountOffset + kIntSize;
6662 static const int kNumLiteralsOffset = kLengthOffset + kIntSize;
6663 static const int kExpectedNofPropertiesOffset = kNumLiteralsOffset + kIntSize;
6665 static const int kStartPositionAndTypeOffset =
6666 kExpectedNofPropertiesOffset + kIntSize;
6667 static const int kEndPositionOffset = kStartPositionAndTypeOffset + kIntSize;
6669 static const int kCompilerHintsOffset = kEndPositionOffset + kIntSize;
6670 static const int kFunctionTokenPositionOffset =
6671 kCompilerHintsOffset + kIntSize;
6673 static const int kCountersOffset = kFunctionTokenPositionOffset + kIntSize;
6674 static const int kOptCountAndBailoutReasonOffset = kCountersOffset + kIntSize;
6676 static const int kProfilerTicksOffset =
6677 kOptCountAndBailoutReasonOffset + kIntSize;
6678 static const int kAstNodeCountOffset = kProfilerTicksOffset + kIntSize;
6681 static const int kSize = kAstNodeCountOffset + kIntSize;
6684 #error Unknown byte ordering
6685 #endif // Big endian
6689 static const int kAlignedSize = POINTER_SIZE_ALIGN(kSize);
6691 typedef FixedBodyDescriptor<kNameOffset,
6692 kLastPointerFieldOffset + kPointerSize,
6693 kSize> BodyDescriptor;
6695 // Bit positions in start_position_and_type.
6696 // The source code start position is in the 30 most significant bits of
6697 // the start_position_and_type field.
6698 static const int kIsExpressionBit = 0;
6699 static const int kIsTopLevelBit = 1;
6700 static const int kStartPositionShift = 2;
6701 static const int kStartPositionMask = ~((1 << kStartPositionShift) - 1);
6703 // Bit positions in compiler_hints.
6704 enum CompilerHints {
6705 kAllowLazyCompilation,
6706 kAllowLazyCompilationWithoutContext,
6707 kOptimizationDisabled,
6708 kStrictModeFunction,
6709 kStrongModeFunction,
6712 kHasDuplicateParameters,
6717 kNameShouldPrintAsAnonymous,
6724 kIsAccessorFunction,
6725 kIsDefaultConstructor,
6726 kIsSubclassConstructor,
6732 kCompilerHintsCount // Pseudo entry
6734 // Add hints for other modes when they're added.
6735 STATIC_ASSERT(LANGUAGE_END == 3);
6737 class FunctionKindBits : public BitField<FunctionKind, kIsArrow, 8> {};
6739 class DeoptCountBits : public BitField<int, 0, 4> {};
6740 class OptReenableTriesBits : public BitField<int, 4, 18> {};
6741 class ICAgeBits : public BitField<int, 22, 8> {};
6743 class OptCountBits : public BitField<int, 0, 22> {};
6744 class DisabledOptimizationReasonBits : public BitField<int, 22, 8> {};
6747 #if V8_HOST_ARCH_32_BIT
6748 // On 32 bit platforms, compiler hints is a smi.
6749 static const int kCompilerHintsSmiTagSize = kSmiTagSize;
6750 static const int kCompilerHintsSize = kPointerSize;
6752 // On 64 bit platforms, compiler hints is not a smi, see comment above.
6753 static const int kCompilerHintsSmiTagSize = 0;
6754 static const int kCompilerHintsSize = kIntSize;
6757 STATIC_ASSERT(SharedFunctionInfo::kCompilerHintsCount <=
6758 SharedFunctionInfo::kCompilerHintsSize * kBitsPerByte);
6761 // Constants for optimizing codegen for strict mode function and
6763 // Allows to use byte-width instructions.
6764 static const int kStrictModeBitWithinByte =
6765 (kStrictModeFunction + kCompilerHintsSmiTagSize) % kBitsPerByte;
6766 static const int kStrongModeBitWithinByte =
6767 (kStrongModeFunction + kCompilerHintsSmiTagSize) % kBitsPerByte;
6769 static const int kNativeBitWithinByte =
6770 (kNative + kCompilerHintsSmiTagSize) % kBitsPerByte;
6772 static const int kBoundBitWithinByte =
6773 (kBoundFunction + kCompilerHintsSmiTagSize) % kBitsPerByte;
6775 #if defined(V8_TARGET_LITTLE_ENDIAN)
6776 static const int kStrictModeByteOffset = kCompilerHintsOffset +
6777 (kStrictModeFunction + kCompilerHintsSmiTagSize) / kBitsPerByte;
6778 static const int kStrongModeByteOffset =
6779 kCompilerHintsOffset +
6780 (kStrongModeFunction + kCompilerHintsSmiTagSize) / kBitsPerByte;
6781 static const int kNativeByteOffset = kCompilerHintsOffset +
6782 (kNative + kCompilerHintsSmiTagSize) / kBitsPerByte;
6783 static const int kBoundByteOffset =
6784 kCompilerHintsOffset +
6785 (kBoundFunction + kCompilerHintsSmiTagSize) / kBitsPerByte;
6786 #elif defined(V8_TARGET_BIG_ENDIAN)
6787 static const int kStrictModeByteOffset = kCompilerHintsOffset +
6788 (kCompilerHintsSize - 1) -
6789 ((kStrictModeFunction + kCompilerHintsSmiTagSize) / kBitsPerByte);
6790 static const int kStrongModeByteOffset =
6791 kCompilerHintsOffset + (kCompilerHintsSize - 1) -
6792 ((kStrongModeFunction + kCompilerHintsSmiTagSize) / kBitsPerByte);
6793 static const int kNativeByteOffset = kCompilerHintsOffset +
6794 (kCompilerHintsSize - 1) -
6795 ((kNative + kCompilerHintsSmiTagSize) / kBitsPerByte);
6796 static const int kBoundByteOffset =
6797 kCompilerHintsOffset + (kCompilerHintsSize - 1) -
6798 ((kBoundFunction + kCompilerHintsSmiTagSize) / kBitsPerByte);
6800 #error Unknown byte ordering
6804 DISALLOW_IMPLICIT_CONSTRUCTORS(SharedFunctionInfo);
6808 // Printing support.
6809 struct SourceCodeOf {
6810 explicit SourceCodeOf(SharedFunctionInfo* v, int max = -1)
6811 : value(v), max_length(max) {}
6812 const SharedFunctionInfo* value;
6817 std::ostream& operator<<(std::ostream& os, const SourceCodeOf& v);
6820 class JSGeneratorObject: public JSObject {
6822 // [function]: The function corresponding to this generator object.
6823 DECL_ACCESSORS(function, JSFunction)
6825 // [context]: The context of the suspended computation.
6826 DECL_ACCESSORS(context, Context)
6828 // [receiver]: The receiver of the suspended computation.
6829 DECL_ACCESSORS(receiver, Object)
6831 // [continuation]: Offset into code of continuation.
6833 // A positive offset indicates a suspended generator. The special
6834 // kGeneratorExecuting and kGeneratorClosed values indicate that a generator
6835 // cannot be resumed.
6836 inline int continuation() const;
6837 inline void set_continuation(int continuation);
6838 inline bool is_closed();
6839 inline bool is_executing();
6840 inline bool is_suspended();
6842 // [operand_stack]: Saved operand stack.
6843 DECL_ACCESSORS(operand_stack, FixedArray)
6845 DECLARE_CAST(JSGeneratorObject)
6847 // Dispatched behavior.
6848 DECLARE_PRINTER(JSGeneratorObject)
6849 DECLARE_VERIFIER(JSGeneratorObject)
6851 // Magic sentinel values for the continuation.
6852 static const int kGeneratorExecuting = -1;
6853 static const int kGeneratorClosed = 0;
6855 // Layout description.
6856 static const int kFunctionOffset = JSObject::kHeaderSize;
6857 static const int kContextOffset = kFunctionOffset + kPointerSize;
6858 static const int kReceiverOffset = kContextOffset + kPointerSize;
6859 static const int kContinuationOffset = kReceiverOffset + kPointerSize;
6860 static const int kOperandStackOffset = kContinuationOffset + kPointerSize;
6861 static const int kSize = kOperandStackOffset + kPointerSize;
6863 // Resume mode, for use by runtime functions.
6864 enum ResumeMode { NEXT, THROW };
6867 DISALLOW_IMPLICIT_CONSTRUCTORS(JSGeneratorObject);
6871 // Representation for module instance objects.
6872 class JSModule: public JSObject {
6874 // [context]: the context holding the module's locals, or undefined if none.
6875 DECL_ACCESSORS(context, Object)
6877 // [scope_info]: Scope info.
6878 DECL_ACCESSORS(scope_info, ScopeInfo)
6880 DECLARE_CAST(JSModule)
6882 // Dispatched behavior.
6883 DECLARE_PRINTER(JSModule)
6884 DECLARE_VERIFIER(JSModule)
6886 // Layout description.
6887 static const int kContextOffset = JSObject::kHeaderSize;
6888 static const int kScopeInfoOffset = kContextOffset + kPointerSize;
6889 static const int kSize = kScopeInfoOffset + kPointerSize;
6892 DISALLOW_IMPLICIT_CONSTRUCTORS(JSModule);
6896 // JSFunction describes JavaScript functions.
6897 class JSFunction: public JSObject {
6899 // [prototype_or_initial_map]:
6900 DECL_ACCESSORS(prototype_or_initial_map, Object)
6902 // [shared]: The information about the function that
6903 // can be shared by instances.
6904 DECL_ACCESSORS(shared, SharedFunctionInfo)
6906 // [context]: The context for this function.
6907 inline Context* context();
6908 inline void set_context(Object* context);
6909 inline JSObject* global_proxy();
6911 // [code]: The generated code object for this function. Executed
6912 // when the function is invoked, e.g. foo() or new foo(). See
6913 // [[Call]] and [[Construct]] description in ECMA-262, section
6915 inline Code* code();
6916 inline void set_code(Code* code);
6917 inline void set_code_no_write_barrier(Code* code);
6918 inline void ReplaceCode(Code* code);
6920 // Tells whether this function is builtin.
6921 inline bool IsBuiltin();
6923 // Tells whether this function inlines the given shared function info.
6924 bool Inlines(SharedFunctionInfo* candidate);
6926 // Tells whether this function should be subject to debugging.
6927 inline bool IsSubjectToDebugging();
6929 // Tells whether or not the function needs arguments adaption.
6930 inline bool NeedsArgumentsAdaption();
6932 // Tells whether or not this function has been optimized.
6933 inline bool IsOptimized();
6935 // Mark this function for lazy recompilation. The function will be
6936 // recompiled the next time it is executed.
6937 void MarkForOptimization();
6938 void AttemptConcurrentOptimization();
6940 // Tells whether or not the function is already marked for lazy
6942 inline bool IsMarkedForOptimization();
6943 inline bool IsMarkedForConcurrentOptimization();
6945 // Tells whether or not the function is on the concurrent recompilation queue.
6946 inline bool IsInOptimizationQueue();
6948 // Inobject slack tracking is the way to reclaim unused inobject space.
6950 // The instance size is initially determined by adding some slack to
6951 // expected_nof_properties (to allow for a few extra properties added
6952 // after the constructor). There is no guarantee that the extra space
6953 // will not be wasted.
6955 // Here is the algorithm to reclaim the unused inobject space:
6956 // - Detect the first constructor call for this JSFunction.
6957 // When it happens enter the "in progress" state: initialize construction
6958 // counter in the initial_map.
6959 // - While the tracking is in progress create objects filled with
6960 // one_pointer_filler_map instead of undefined_value. This way they can be
6961 // resized quickly and safely.
6962 // - Once enough objects have been created compute the 'slack'
6963 // (traverse the map transition tree starting from the
6964 // initial_map and find the lowest value of unused_property_fields).
6965 // - Traverse the transition tree again and decrease the instance size
6966 // of every map. Existing objects will resize automatically (they are
6967 // filled with one_pointer_filler_map). All further allocations will
6968 // use the adjusted instance size.
6969 // - SharedFunctionInfo's expected_nof_properties left unmodified since
6970 // allocations made using different closures could actually create different
6971 // kind of objects (see prototype inheritance pattern).
6973 // Important: inobject slack tracking is not attempted during the snapshot
6976 // True if the initial_map is set and the object constructions countdown
6977 // counter is not zero.
6978 static const int kGenerousAllocationCount =
6979 Map::kSlackTrackingCounterStart - Map::kSlackTrackingCounterEnd + 1;
6980 inline bool IsInobjectSlackTrackingInProgress();
6982 // Starts the tracking.
6983 // Initializes object constructions countdown counter in the initial map.
6984 void StartInobjectSlackTracking();
6986 // Completes the tracking.
6987 void CompleteInobjectSlackTracking();
6989 // [literals_or_bindings]: Fixed array holding either
6990 // the materialized literals or the bindings of a bound function.
6992 // If the function contains object, regexp or array literals, the
6993 // literals array prefix contains the object, regexp, and array
6994 // function to be used when creating these literals. This is
6995 // necessary so that we do not dynamically lookup the object, regexp
6996 // or array functions. Performing a dynamic lookup, we might end up
6997 // using the functions from a new context that we should not have
7000 // On bound functions, the array is a (copy-on-write) fixed-array containing
7001 // the function that was bound, bound this-value and any bound
7002 // arguments. Bound functions never contain literals.
7003 DECL_ACCESSORS(literals_or_bindings, FixedArray)
7005 inline FixedArray* literals();
7006 inline void set_literals(FixedArray* literals);
7008 inline FixedArray* function_bindings();
7009 inline void set_function_bindings(FixedArray* bindings);
7011 // The initial map for an object created by this constructor.
7012 inline Map* initial_map();
7013 static void SetInitialMap(Handle<JSFunction> function, Handle<Map> map,
7014 Handle<Object> prototype);
7015 inline bool has_initial_map();
7016 static void EnsureHasInitialMap(Handle<JSFunction> function);
7018 // Get and set the prototype property on a JSFunction. If the
7019 // function has an initial map the prototype is set on the initial
7020 // map. Otherwise, the prototype is put in the initial map field
7021 // until an initial map is needed.
7022 inline bool has_prototype();
7023 inline bool has_instance_prototype();
7024 inline Object* prototype();
7025 inline Object* instance_prototype();
7026 static void SetPrototype(Handle<JSFunction> function,
7027 Handle<Object> value);
7028 static void SetInstancePrototype(Handle<JSFunction> function,
7029 Handle<Object> value);
7031 // Creates a new closure for the fucntion with the same bindings,
7032 // bound values, and prototype. An equivalent of spec operations
7033 // ``CloneMethod`` and ``CloneBoundFunction``.
7034 static Handle<JSFunction> CloneClosure(Handle<JSFunction> function);
7036 // After prototype is removed, it will not be created when accessed, and
7037 // [[Construct]] from this function will not be allowed.
7038 bool RemovePrototype();
7039 inline bool should_have_prototype();
7041 // Accessor for this function's initial map's [[class]]
7042 // property. This is primarily used by ECMA native functions. This
7043 // method sets the class_name field of this function's initial map
7044 // to a given value. It creates an initial map if this function does
7045 // not have one. Note that this method does not copy the initial map
7046 // if it has one already, but simply replaces it with the new value.
7047 // Instances created afterwards will have a map whose [[class]] is
7048 // set to 'value', but there is no guarantees on instances created
7050 void SetInstanceClassName(String* name);
7052 // Returns if this function has been compiled to native code yet.
7053 inline bool is_compiled();
7055 // Returns `false` if formal parameters include rest parameters, optional
7056 // parameters, or destructuring parameters.
7057 // TODO(caitp): make this a flag set during parsing
7058 inline bool has_simple_parameters();
7060 // [next_function_link]: Links functions into various lists, e.g. the list
7061 // of optimized functions hanging off the native_context. The CodeFlusher
7062 // uses this link to chain together flushing candidates. Treated weakly
7063 // by the garbage collector.
7064 DECL_ACCESSORS(next_function_link, Object)
7066 // Prints the name of the function using PrintF.
7067 void PrintName(FILE* out = stdout);
7069 DECLARE_CAST(JSFunction)
7071 // Iterates the objects, including code objects indirectly referenced
7072 // through pointers to the first instruction in the code object.
7073 void JSFunctionIterateBody(int object_size, ObjectVisitor* v);
7075 // Dispatched behavior.
7076 DECLARE_PRINTER(JSFunction)
7077 DECLARE_VERIFIER(JSFunction)
7079 // Returns the number of allocated literals.
7080 inline int NumberOfLiterals();
7082 // Used for flags such as --hydrogen-filter.
7083 bool PassesFilter(const char* raw_filter);
7085 // The function's name if it is configured, otherwise shared function info
7087 static Handle<String> GetDebugName(Handle<JSFunction> function);
7089 // Layout descriptors. The last property (from kNonWeakFieldsEndOffset to
7090 // kSize) is weak and has special handling during garbage collection.
7091 static const int kCodeEntryOffset = JSObject::kHeaderSize;
7092 static const int kPrototypeOrInitialMapOffset =
7093 kCodeEntryOffset + kPointerSize;
7094 static const int kSharedFunctionInfoOffset =
7095 kPrototypeOrInitialMapOffset + kPointerSize;
7096 static const int kContextOffset = kSharedFunctionInfoOffset + kPointerSize;
7097 static const int kLiteralsOffset = kContextOffset + kPointerSize;
7098 static const int kNonWeakFieldsEndOffset = kLiteralsOffset + kPointerSize;
7099 static const int kNextFunctionLinkOffset = kNonWeakFieldsEndOffset;
7100 static const int kSize = kNextFunctionLinkOffset + kPointerSize;
7102 // Layout of the bound-function binding array.
7103 static const int kBoundFunctionIndex = 0;
7104 static const int kBoundThisIndex = 1;
7105 static const int kBoundArgumentsStartIndex = 2;
7108 DISALLOW_IMPLICIT_CONSTRUCTORS(JSFunction);
7112 // JSGlobalProxy's prototype must be a JSGlobalObject or null,
7113 // and the prototype is hidden. JSGlobalProxy always delegates
7114 // property accesses to its prototype if the prototype is not null.
7116 // A JSGlobalProxy can be reinitialized which will preserve its identity.
7118 // Accessing a JSGlobalProxy requires security check.
7120 class JSGlobalProxy : public JSObject {
7122 // [native_context]: the owner native context of this global proxy object.
7123 // It is null value if this object is not used by any context.
7124 DECL_ACCESSORS(native_context, Object)
7126 // [hash]: The hash code property (undefined if not initialized yet).
7127 DECL_ACCESSORS(hash, Object)
7129 DECLARE_CAST(JSGlobalProxy)
7131 inline bool IsDetachedFrom(GlobalObject* global) const;
7133 // Dispatched behavior.
7134 DECLARE_PRINTER(JSGlobalProxy)
7135 DECLARE_VERIFIER(JSGlobalProxy)
7137 // Layout description.
7138 static const int kNativeContextOffset = JSObject::kHeaderSize;
7139 static const int kHashOffset = kNativeContextOffset + kPointerSize;
7140 static const int kSize = kHashOffset + kPointerSize;
7143 DISALLOW_IMPLICIT_CONSTRUCTORS(JSGlobalProxy);
7147 // Common super class for JavaScript global objects and the special
7148 // builtins global objects.
7149 class GlobalObject: public JSObject {
7151 // [builtins]: the object holding the runtime routines written in JS.
7152 DECL_ACCESSORS(builtins, JSBuiltinsObject)
7154 // [native context]: the natives corresponding to this global object.
7155 DECL_ACCESSORS(native_context, Context)
7157 // [global proxy]: the global proxy object of the context
7158 DECL_ACCESSORS(global_proxy, JSObject)
7160 DECLARE_CAST(GlobalObject)
7162 static void InvalidatePropertyCell(Handle<GlobalObject> object,
7164 // Ensure that the global object has a cell for the given property name.
7165 static Handle<PropertyCell> EnsurePropertyCell(Handle<GlobalObject> global,
7168 // Layout description.
7169 static const int kBuiltinsOffset = JSObject::kHeaderSize;
7170 static const int kNativeContextOffset = kBuiltinsOffset + kPointerSize;
7171 static const int kGlobalProxyOffset = kNativeContextOffset + kPointerSize;
7172 static const int kHeaderSize = kGlobalProxyOffset + kPointerSize;
7175 DISALLOW_IMPLICIT_CONSTRUCTORS(GlobalObject);
7179 // JavaScript global object.
7180 class JSGlobalObject: public GlobalObject {
7182 DECLARE_CAST(JSGlobalObject)
7184 inline bool IsDetached();
7186 // Dispatched behavior.
7187 DECLARE_PRINTER(JSGlobalObject)
7188 DECLARE_VERIFIER(JSGlobalObject)
7190 // Layout description.
7191 static const int kSize = GlobalObject::kHeaderSize;
7194 DISALLOW_IMPLICIT_CONSTRUCTORS(JSGlobalObject);
7198 // Builtins global object which holds the runtime routines written in
7200 class JSBuiltinsObject: public GlobalObject {
7202 DECLARE_CAST(JSBuiltinsObject)
7204 // Dispatched behavior.
7205 DECLARE_PRINTER(JSBuiltinsObject)
7206 DECLARE_VERIFIER(JSBuiltinsObject)
7208 // Layout description.
7209 static const int kSize = GlobalObject::kHeaderSize;
7212 DISALLOW_IMPLICIT_CONSTRUCTORS(JSBuiltinsObject);
7216 // Representation for JS Wrapper objects, String, Number, Boolean, etc.
7217 class JSValue: public JSObject {
7219 // [value]: the object being wrapped.
7220 DECL_ACCESSORS(value, Object)
7222 DECLARE_CAST(JSValue)
7224 // Dispatched behavior.
7225 DECLARE_PRINTER(JSValue)
7226 DECLARE_VERIFIER(JSValue)
7228 // Layout description.
7229 static const int kValueOffset = JSObject::kHeaderSize;
7230 static const int kSize = kValueOffset + kPointerSize;
7233 DISALLOW_IMPLICIT_CONSTRUCTORS(JSValue);
7239 // Representation for JS date objects.
7240 class JSDate: public JSObject {
7242 // If one component is NaN, all of them are, indicating a NaN time value.
7243 // [value]: the time value.
7244 DECL_ACCESSORS(value, Object)
7245 // [year]: caches year. Either undefined, smi, or NaN.
7246 DECL_ACCESSORS(year, Object)
7247 // [month]: caches month. Either undefined, smi, or NaN.
7248 DECL_ACCESSORS(month, Object)
7249 // [day]: caches day. Either undefined, smi, or NaN.
7250 DECL_ACCESSORS(day, Object)
7251 // [weekday]: caches day of week. Either undefined, smi, or NaN.
7252 DECL_ACCESSORS(weekday, Object)
7253 // [hour]: caches hours. Either undefined, smi, or NaN.
7254 DECL_ACCESSORS(hour, Object)
7255 // [min]: caches minutes. Either undefined, smi, or NaN.
7256 DECL_ACCESSORS(min, Object)
7257 // [sec]: caches seconds. Either undefined, smi, or NaN.
7258 DECL_ACCESSORS(sec, Object)
7259 // [cache stamp]: sample of the date cache stamp at the
7260 // moment when chached fields were cached.
7261 DECL_ACCESSORS(cache_stamp, Object)
7263 DECLARE_CAST(JSDate)
7265 // Returns the date field with the specified index.
7266 // See FieldIndex for the list of date fields.
7267 static Object* GetField(Object* date, Smi* index);
7269 void SetValue(Object* value, bool is_value_nan);
7271 // ES6 section 20.3.4.45 Date.prototype [ @@toPrimitive ]
7272 static MUST_USE_RESULT MaybeHandle<Object> ToPrimitive(
7273 Handle<JSReceiver> receiver, Handle<Object> hint);
7275 // Dispatched behavior.
7276 DECLARE_PRINTER(JSDate)
7277 DECLARE_VERIFIER(JSDate)
7279 // The order is important. It must be kept in sync with date macros
7290 kFirstUncachedField,
7291 kMillisecond = kFirstUncachedField,
7295 kYearUTC = kFirstUTCField,
7308 // Layout description.
7309 static const int kValueOffset = JSObject::kHeaderSize;
7310 static const int kYearOffset = kValueOffset + kPointerSize;
7311 static const int kMonthOffset = kYearOffset + kPointerSize;
7312 static const int kDayOffset = kMonthOffset + kPointerSize;
7313 static const int kWeekdayOffset = kDayOffset + kPointerSize;
7314 static const int kHourOffset = kWeekdayOffset + kPointerSize;
7315 static const int kMinOffset = kHourOffset + kPointerSize;
7316 static const int kSecOffset = kMinOffset + kPointerSize;
7317 static const int kCacheStampOffset = kSecOffset + kPointerSize;
7318 static const int kSize = kCacheStampOffset + kPointerSize;
7321 inline Object* DoGetField(FieldIndex index);
7323 Object* GetUTCField(FieldIndex index, double value, DateCache* date_cache);
7325 // Computes and caches the cacheable fields of the date.
7326 inline void SetCachedFields(int64_t local_time_ms, DateCache* date_cache);
7329 DISALLOW_IMPLICIT_CONSTRUCTORS(JSDate);
7333 // Representation of message objects used for error reporting through
7334 // the API. The messages are formatted in JavaScript so this object is
7335 // a real JavaScript object. The information used for formatting the
7336 // error messages are not directly accessible from JavaScript to
7337 // prevent leaking information to user code called during error
7339 class JSMessageObject: public JSObject {
7341 // [type]: the type of error message.
7342 inline int type() const;
7343 inline void set_type(int value);
7345 // [arguments]: the arguments for formatting the error message.
7346 DECL_ACCESSORS(argument, Object)
7348 // [script]: the script from which the error message originated.
7349 DECL_ACCESSORS(script, Object)
7351 // [stack_frames]: an array of stack frames for this error object.
7352 DECL_ACCESSORS(stack_frames, Object)
7354 // [start_position]: the start position in the script for the error message.
7355 inline int start_position() const;
7356 inline void set_start_position(int value);
7358 // [end_position]: the end position in the script for the error message.
7359 inline int end_position() const;
7360 inline void set_end_position(int value);
7362 DECLARE_CAST(JSMessageObject)
7364 // Dispatched behavior.
7365 DECLARE_PRINTER(JSMessageObject)
7366 DECLARE_VERIFIER(JSMessageObject)
7368 // Layout description.
7369 static const int kTypeOffset = JSObject::kHeaderSize;
7370 static const int kArgumentsOffset = kTypeOffset + kPointerSize;
7371 static const int kScriptOffset = kArgumentsOffset + kPointerSize;
7372 static const int kStackFramesOffset = kScriptOffset + kPointerSize;
7373 static const int kStartPositionOffset = kStackFramesOffset + kPointerSize;
7374 static const int kEndPositionOffset = kStartPositionOffset + kPointerSize;
7375 static const int kSize = kEndPositionOffset + kPointerSize;
7377 typedef FixedBodyDescriptor<HeapObject::kMapOffset,
7378 kStackFramesOffset + kPointerSize,
7379 kSize> BodyDescriptor;
7383 // Regular expressions
7384 // The regular expression holds a single reference to a FixedArray in
7385 // the kDataOffset field.
7386 // The FixedArray contains the following data:
7387 // - tag : type of regexp implementation (not compiled yet, atom or irregexp)
7388 // - reference to the original source string
7389 // - reference to the original flag string
7390 // If it is an atom regexp
7391 // - a reference to a literal string to search for
7392 // If it is an irregexp regexp:
7393 // - a reference to code for Latin1 inputs (bytecode or compiled), or a smi
7394 // used for tracking the last usage (used for code flushing).
7395 // - a reference to code for UC16 inputs (bytecode or compiled), or a smi
7396 // used for tracking the last usage (used for code flushing)..
7397 // - max number of registers used by irregexp implementations.
7398 // - number of capture registers (output values) of the regexp.
7399 class JSRegExp: public JSObject {
7402 // NOT_COMPILED: Initial value. No data has been stored in the JSRegExp yet.
7403 // ATOM: A simple string to match against using an indexOf operation.
7404 // IRREGEXP: Compiled with Irregexp.
7405 // IRREGEXP_NATIVE: Compiled to native code with Irregexp.
7406 enum Type { NOT_COMPILED, ATOM, IRREGEXP };
7413 UNICODE_ESCAPES = 16
7418 explicit Flags(uint32_t value) : value_(value) { }
7419 bool is_global() { return (value_ & GLOBAL) != 0; }
7420 bool is_ignore_case() { return (value_ & IGNORE_CASE) != 0; }
7421 bool is_multiline() { return (value_ & MULTILINE) != 0; }
7422 bool is_sticky() { return (value_ & STICKY) != 0; }
7423 bool is_unicode() { return (value_ & UNICODE_ESCAPES) != 0; }
7424 uint32_t value() { return value_; }
7429 DECL_ACCESSORS(data, Object)
7431 inline Type TypeTag();
7432 inline int CaptureCount();
7433 inline Flags GetFlags();
7434 inline String* Pattern();
7435 inline Object* DataAt(int index);
7436 // Set implementation data after the object has been prepared.
7437 inline void SetDataAt(int index, Object* value);
7439 static int code_index(bool is_latin1) {
7441 return kIrregexpLatin1CodeIndex;
7443 return kIrregexpUC16CodeIndex;
7447 static int saved_code_index(bool is_latin1) {
7449 return kIrregexpLatin1CodeSavedIndex;
7451 return kIrregexpUC16CodeSavedIndex;
7455 DECLARE_CAST(JSRegExp)
7457 // Dispatched behavior.
7458 DECLARE_VERIFIER(JSRegExp)
7460 static const int kDataOffset = JSObject::kHeaderSize;
7461 static const int kSize = kDataOffset + kPointerSize;
7463 // Indices in the data array.
7464 static const int kTagIndex = 0;
7465 static const int kSourceIndex = kTagIndex + 1;
7466 static const int kFlagsIndex = kSourceIndex + 1;
7467 static const int kDataIndex = kFlagsIndex + 1;
7468 // The data fields are used in different ways depending on the
7469 // value of the tag.
7470 // Atom regexps (literal strings).
7471 static const int kAtomPatternIndex = kDataIndex;
7473 static const int kAtomDataSize = kAtomPatternIndex + 1;
7475 // Irregexp compiled code or bytecode for Latin1. If compilation
7476 // fails, this fields hold an exception object that should be
7477 // thrown if the regexp is used again.
7478 static const int kIrregexpLatin1CodeIndex = kDataIndex;
7479 // Irregexp compiled code or bytecode for UC16. If compilation
7480 // fails, this fields hold an exception object that should be
7481 // thrown if the regexp is used again.
7482 static const int kIrregexpUC16CodeIndex = kDataIndex + 1;
7484 // Saved instance of Irregexp compiled code or bytecode for Latin1 that
7485 // is a potential candidate for flushing.
7486 static const int kIrregexpLatin1CodeSavedIndex = kDataIndex + 2;
7487 // Saved instance of Irregexp compiled code or bytecode for UC16 that is
7488 // a potential candidate for flushing.
7489 static const int kIrregexpUC16CodeSavedIndex = kDataIndex + 3;
7491 // Maximal number of registers used by either Latin1 or UC16.
7492 // Only used to check that there is enough stack space
7493 static const int kIrregexpMaxRegisterCountIndex = kDataIndex + 4;
7494 // Number of captures in the compiled regexp.
7495 static const int kIrregexpCaptureCountIndex = kDataIndex + 5;
7497 static const int kIrregexpDataSize = kIrregexpCaptureCountIndex + 1;
7499 // Offsets directly into the data fixed array.
7500 static const int kDataTagOffset =
7501 FixedArray::kHeaderSize + kTagIndex * kPointerSize;
7502 static const int kDataOneByteCodeOffset =
7503 FixedArray::kHeaderSize + kIrregexpLatin1CodeIndex * kPointerSize;
7504 static const int kDataUC16CodeOffset =
7505 FixedArray::kHeaderSize + kIrregexpUC16CodeIndex * kPointerSize;
7506 static const int kIrregexpCaptureCountOffset =
7507 FixedArray::kHeaderSize + kIrregexpCaptureCountIndex * kPointerSize;
7509 // In-object fields.
7510 static const int kSourceFieldIndex = 0;
7511 static const int kGlobalFieldIndex = 1;
7512 static const int kIgnoreCaseFieldIndex = 2;
7513 static const int kMultilineFieldIndex = 3;
7514 static const int kLastIndexFieldIndex = 4;
7515 static const int kInObjectFieldCount = 5;
7517 // The uninitialized value for a regexp code object.
7518 static const int kUninitializedValue = -1;
7520 // The compilation error value for the regexp code object. The real error
7521 // object is in the saved code field.
7522 static const int kCompilationErrorValue = -2;
7524 // When we store the sweep generation at which we moved the code from the
7525 // code index to the saved code index we mask it of to be in the [0:255]
7527 static const int kCodeAgeMask = 0xff;
7531 class CompilationCacheShape : public BaseShape<HashTableKey*> {
7533 static inline bool IsMatch(HashTableKey* key, Object* value) {
7534 return key->IsMatch(value);
7537 static inline uint32_t Hash(HashTableKey* key) {
7541 static inline uint32_t HashForObject(HashTableKey* key, Object* object) {
7542 return key->HashForObject(object);
7545 static inline Handle<Object> AsHandle(Isolate* isolate, HashTableKey* key);
7547 static const int kPrefixSize = 0;
7548 static const int kEntrySize = 2;
7552 // This cache is used in two different variants. For regexp caching, it simply
7553 // maps identifying info of the regexp to the cached regexp object. Scripts and
7554 // eval code only gets cached after a second probe for the code object. To do
7555 // so, on first "put" only a hash identifying the source is entered into the
7556 // cache, mapping it to a lifetime count of the hash. On each call to Age all
7557 // such lifetimes get reduced, and removed once they reach zero. If a second put
7558 // is called while such a hash is live in the cache, the hash gets replaced by
7559 // an actual cache entry. Age also removes stale live entries from the cache.
7560 // Such entries are identified by SharedFunctionInfos pointing to either the
7561 // recompilation stub, or to "old" code. This avoids memory leaks due to
7562 // premature caching of scripts and eval strings that are never needed later.
7563 class CompilationCacheTable: public HashTable<CompilationCacheTable,
7564 CompilationCacheShape,
7567 // Find cached value for a string key, otherwise return null.
7568 Handle<Object> Lookup(
7569 Handle<String> src, Handle<Context> context, LanguageMode language_mode);
7570 Handle<Object> LookupEval(
7571 Handle<String> src, Handle<SharedFunctionInfo> shared,
7572 LanguageMode language_mode, int scope_position);
7573 Handle<Object> LookupRegExp(Handle<String> source, JSRegExp::Flags flags);
7574 static Handle<CompilationCacheTable> Put(
7575 Handle<CompilationCacheTable> cache, Handle<String> src,
7576 Handle<Context> context, LanguageMode language_mode,
7577 Handle<Object> value);
7578 static Handle<CompilationCacheTable> PutEval(
7579 Handle<CompilationCacheTable> cache, Handle<String> src,
7580 Handle<SharedFunctionInfo> context, Handle<SharedFunctionInfo> value,
7581 int scope_position);
7582 static Handle<CompilationCacheTable> PutRegExp(
7583 Handle<CompilationCacheTable> cache, Handle<String> src,
7584 JSRegExp::Flags flags, Handle<FixedArray> value);
7585 void Remove(Object* value);
7587 static const int kHashGenerations = 10;
7589 DECLARE_CAST(CompilationCacheTable)
7592 DISALLOW_IMPLICIT_CONSTRUCTORS(CompilationCacheTable);
7596 class CodeCache: public Struct {
7598 DECL_ACCESSORS(default_cache, FixedArray)
7599 DECL_ACCESSORS(normal_type_cache, Object)
7601 // Add the code object to the cache.
7603 Handle<CodeCache> cache, Handle<Name> name, Handle<Code> code);
7605 // Lookup code object in the cache. Returns code object if found and undefined
7607 Object* Lookup(Name* name, Code::Flags flags);
7609 // Get the internal index of a code object in the cache. Returns -1 if the
7610 // code object is not in that cache. This index can be used to later call
7611 // RemoveByIndex. The cache cannot be modified between a call to GetIndex and
7613 int GetIndex(Object* name, Code* code);
7615 // Remove an object from the cache with the provided internal index.
7616 void RemoveByIndex(Object* name, Code* code, int index);
7618 DECLARE_CAST(CodeCache)
7620 // Dispatched behavior.
7621 DECLARE_PRINTER(CodeCache)
7622 DECLARE_VERIFIER(CodeCache)
7624 static const int kDefaultCacheOffset = HeapObject::kHeaderSize;
7625 static const int kNormalTypeCacheOffset =
7626 kDefaultCacheOffset + kPointerSize;
7627 static const int kSize = kNormalTypeCacheOffset + kPointerSize;
7630 static void UpdateDefaultCache(
7631 Handle<CodeCache> code_cache, Handle<Name> name, Handle<Code> code);
7632 static void UpdateNormalTypeCache(
7633 Handle<CodeCache> code_cache, Handle<Name> name, Handle<Code> code);
7634 Object* LookupDefaultCache(Name* name, Code::Flags flags);
7635 Object* LookupNormalTypeCache(Name* name, Code::Flags flags);
7637 // Code cache layout of the default cache. Elements are alternating name and
7638 // code objects for non normal load/store/call IC's.
7639 static const int kCodeCacheEntrySize = 2;
7640 static const int kCodeCacheEntryNameOffset = 0;
7641 static const int kCodeCacheEntryCodeOffset = 1;
7643 DISALLOW_IMPLICIT_CONSTRUCTORS(CodeCache);
7647 class CodeCacheHashTableShape : public BaseShape<HashTableKey*> {
7649 static inline bool IsMatch(HashTableKey* key, Object* value) {
7650 return key->IsMatch(value);
7653 static inline uint32_t Hash(HashTableKey* key) {
7657 static inline uint32_t HashForObject(HashTableKey* key, Object* object) {
7658 return key->HashForObject(object);
7661 static inline Handle<Object> AsHandle(Isolate* isolate, HashTableKey* key);
7663 static const int kPrefixSize = 0;
7664 static const int kEntrySize = 2;
7668 class CodeCacheHashTable: public HashTable<CodeCacheHashTable,
7669 CodeCacheHashTableShape,
7672 Object* Lookup(Name* name, Code::Flags flags);
7673 static Handle<CodeCacheHashTable> Put(
7674 Handle<CodeCacheHashTable> table,
7678 int GetIndex(Name* name, Code::Flags flags);
7679 void RemoveByIndex(int index);
7681 DECLARE_CAST(CodeCacheHashTable)
7683 // Initial size of the fixed array backing the hash table.
7684 static const int kInitialSize = 64;
7687 DISALLOW_IMPLICIT_CONSTRUCTORS(CodeCacheHashTable);
7691 class PolymorphicCodeCache: public Struct {
7693 DECL_ACCESSORS(cache, Object)
7695 static void Update(Handle<PolymorphicCodeCache> cache,
7696 MapHandleList* maps,
7701 // Returns an undefined value if the entry is not found.
7702 Handle<Object> Lookup(MapHandleList* maps, Code::Flags flags);
7704 DECLARE_CAST(PolymorphicCodeCache)
7706 // Dispatched behavior.
7707 DECLARE_PRINTER(PolymorphicCodeCache)
7708 DECLARE_VERIFIER(PolymorphicCodeCache)
7710 static const int kCacheOffset = HeapObject::kHeaderSize;
7711 static const int kSize = kCacheOffset + kPointerSize;
7714 DISALLOW_IMPLICIT_CONSTRUCTORS(PolymorphicCodeCache);
7718 class PolymorphicCodeCacheHashTable
7719 : public HashTable<PolymorphicCodeCacheHashTable,
7720 CodeCacheHashTableShape,
7723 Object* Lookup(MapHandleList* maps, int code_kind);
7725 static Handle<PolymorphicCodeCacheHashTable> Put(
7726 Handle<PolymorphicCodeCacheHashTable> hash_table,
7727 MapHandleList* maps,
7731 DECLARE_CAST(PolymorphicCodeCacheHashTable)
7733 static const int kInitialSize = 64;
7735 DISALLOW_IMPLICIT_CONSTRUCTORS(PolymorphicCodeCacheHashTable);
7739 class TypeFeedbackInfo: public Struct {
7741 inline int ic_total_count();
7742 inline void set_ic_total_count(int count);
7744 inline int ic_with_type_info_count();
7745 inline void change_ic_with_type_info_count(int delta);
7747 inline int ic_generic_count();
7748 inline void change_ic_generic_count(int delta);
7750 inline void initialize_storage();
7752 inline void change_own_type_change_checksum();
7753 inline int own_type_change_checksum();
7755 inline void set_inlined_type_change_checksum(int checksum);
7756 inline bool matches_inlined_type_change_checksum(int checksum);
7758 DECLARE_CAST(TypeFeedbackInfo)
7760 // Dispatched behavior.
7761 DECLARE_PRINTER(TypeFeedbackInfo)
7762 DECLARE_VERIFIER(TypeFeedbackInfo)
7764 static const int kStorage1Offset = HeapObject::kHeaderSize;
7765 static const int kStorage2Offset = kStorage1Offset + kPointerSize;
7766 static const int kStorage3Offset = kStorage2Offset + kPointerSize;
7767 static const int kSize = kStorage3Offset + kPointerSize;
7770 static const int kTypeChangeChecksumBits = 7;
7772 class ICTotalCountField: public BitField<int, 0,
7773 kSmiValueSize - kTypeChangeChecksumBits> {}; // NOLINT
7774 class OwnTypeChangeChecksum: public BitField<int,
7775 kSmiValueSize - kTypeChangeChecksumBits,
7776 kTypeChangeChecksumBits> {}; // NOLINT
7777 class ICsWithTypeInfoCountField: public BitField<int, 0,
7778 kSmiValueSize - kTypeChangeChecksumBits> {}; // NOLINT
7779 class InlinedTypeChangeChecksum: public BitField<int,
7780 kSmiValueSize - kTypeChangeChecksumBits,
7781 kTypeChangeChecksumBits> {}; // NOLINT
7783 DISALLOW_IMPLICIT_CONSTRUCTORS(TypeFeedbackInfo);
7787 enum AllocationSiteMode {
7788 DONT_TRACK_ALLOCATION_SITE,
7789 TRACK_ALLOCATION_SITE,
7790 LAST_ALLOCATION_SITE_MODE = TRACK_ALLOCATION_SITE
7794 class AllocationSite: public Struct {
7796 static const uint32_t kMaximumArrayBytesToPretransition = 8 * 1024;
7797 static const double kPretenureRatio;
7798 static const int kPretenureMinimumCreated = 100;
7800 // Values for pretenure decision field.
7801 enum PretenureDecision {
7807 kLastPretenureDecisionValue = kZombie
7810 const char* PretenureDecisionName(PretenureDecision decision);
7812 DECL_ACCESSORS(transition_info, Object)
7813 // nested_site threads a list of sites that represent nested literals
7814 // walked in a particular order. So [[1, 2], 1, 2] will have one
7815 // nested_site, but [[1, 2], 3, [4]] will have a list of two.
7816 DECL_ACCESSORS(nested_site, Object)
7817 DECL_ACCESSORS(pretenure_data, Smi)
7818 DECL_ACCESSORS(pretenure_create_count, Smi)
7819 DECL_ACCESSORS(dependent_code, DependentCode)
7820 DECL_ACCESSORS(weak_next, Object)
7822 inline void Initialize();
7824 // This method is expensive, it should only be called for reporting.
7825 bool IsNestedSite();
7827 // transition_info bitfields, for constructed array transition info.
7828 class ElementsKindBits: public BitField<ElementsKind, 0, 15> {};
7829 class UnusedBits: public BitField<int, 15, 14> {};
7830 class DoNotInlineBit: public BitField<bool, 29, 1> {};
7832 // Bitfields for pretenure_data
7833 class MementoFoundCountBits: public BitField<int, 0, 26> {};
7834 class PretenureDecisionBits: public BitField<PretenureDecision, 26, 3> {};
7835 class DeoptDependentCodeBit: public BitField<bool, 29, 1> {};
7836 STATIC_ASSERT(PretenureDecisionBits::kMax >= kLastPretenureDecisionValue);
7838 // Increments the mementos found counter and returns true when the first
7839 // memento was found for a given allocation site.
7840 inline bool IncrementMementoFoundCount();
7842 inline void IncrementMementoCreateCount();
7844 PretenureFlag GetPretenureMode();
7846 void ResetPretenureDecision();
7848 inline PretenureDecision pretenure_decision();
7849 inline void set_pretenure_decision(PretenureDecision decision);
7851 inline bool deopt_dependent_code();
7852 inline void set_deopt_dependent_code(bool deopt);
7854 inline int memento_found_count();
7855 inline void set_memento_found_count(int count);
7857 inline int memento_create_count();
7858 inline void set_memento_create_count(int count);
7860 // The pretenuring decision is made during gc, and the zombie state allows
7861 // us to recognize when an allocation site is just being kept alive because
7862 // a later traversal of new space may discover AllocationMementos that point
7863 // to this AllocationSite.
7864 inline bool IsZombie();
7866 inline bool IsMaybeTenure();
7868 inline void MarkZombie();
7870 inline bool MakePretenureDecision(PretenureDecision current_decision,
7872 bool maximum_size_scavenge);
7874 inline bool DigestPretenuringFeedback(bool maximum_size_scavenge);
7876 inline ElementsKind GetElementsKind();
7877 inline void SetElementsKind(ElementsKind kind);
7879 inline bool CanInlineCall();
7880 inline void SetDoNotInlineCall();
7882 inline bool SitePointsToLiteral();
7884 static void DigestTransitionFeedback(Handle<AllocationSite> site,
7885 ElementsKind to_kind);
7887 DECLARE_PRINTER(AllocationSite)
7888 DECLARE_VERIFIER(AllocationSite)
7890 DECLARE_CAST(AllocationSite)
7891 static inline AllocationSiteMode GetMode(
7892 ElementsKind boilerplate_elements_kind);
7893 static inline AllocationSiteMode GetMode(ElementsKind from, ElementsKind to);
7894 static inline bool CanTrack(InstanceType type);
7896 static const int kTransitionInfoOffset = HeapObject::kHeaderSize;
7897 static const int kNestedSiteOffset = kTransitionInfoOffset + kPointerSize;
7898 static const int kPretenureDataOffset = kNestedSiteOffset + kPointerSize;
7899 static const int kPretenureCreateCountOffset =
7900 kPretenureDataOffset + kPointerSize;
7901 static const int kDependentCodeOffset =
7902 kPretenureCreateCountOffset + kPointerSize;
7903 static const int kWeakNextOffset = kDependentCodeOffset + kPointerSize;
7904 static const int kSize = kWeakNextOffset + kPointerSize;
7906 // During mark compact we need to take special care for the dependent code
7908 static const int kPointerFieldsBeginOffset = kTransitionInfoOffset;
7909 static const int kPointerFieldsEndOffset = kWeakNextOffset;
7911 // For other visitors, use the fixed body descriptor below.
7912 typedef FixedBodyDescriptor<HeapObject::kHeaderSize,
7913 kDependentCodeOffset + kPointerSize,
7914 kSize> BodyDescriptor;
7917 inline bool PretenuringDecisionMade();
7919 DISALLOW_IMPLICIT_CONSTRUCTORS(AllocationSite);
7923 class AllocationMemento: public Struct {
7925 static const int kAllocationSiteOffset = HeapObject::kHeaderSize;
7926 static const int kSize = kAllocationSiteOffset + kPointerSize;
7928 DECL_ACCESSORS(allocation_site, Object)
7930 inline bool IsValid();
7931 inline AllocationSite* GetAllocationSite();
7933 DECLARE_PRINTER(AllocationMemento)
7934 DECLARE_VERIFIER(AllocationMemento)
7936 DECLARE_CAST(AllocationMemento)
7939 DISALLOW_IMPLICIT_CONSTRUCTORS(AllocationMemento);
7943 // Representation of a slow alias as part of a sloppy arguments objects.
7944 // For fast aliases (if HasSloppyArgumentsElements()):
7945 // - the parameter map contains an index into the context
7946 // - all attributes of the element have default values
7947 // For slow aliases (if HasDictionaryArgumentsElements()):
7948 // - the parameter map contains no fast alias mapping (i.e. the hole)
7949 // - this struct (in the slow backing store) contains an index into the context
7950 // - all attributes are available as part if the property details
7951 class AliasedArgumentsEntry: public Struct {
7953 inline int aliased_context_slot() const;
7954 inline void set_aliased_context_slot(int count);
7956 DECLARE_CAST(AliasedArgumentsEntry)
7958 // Dispatched behavior.
7959 DECLARE_PRINTER(AliasedArgumentsEntry)
7960 DECLARE_VERIFIER(AliasedArgumentsEntry)
7962 static const int kAliasedContextSlot = HeapObject::kHeaderSize;
7963 static const int kSize = kAliasedContextSlot + kPointerSize;
7966 DISALLOW_IMPLICIT_CONSTRUCTORS(AliasedArgumentsEntry);
7970 enum AllowNullsFlag {ALLOW_NULLS, DISALLOW_NULLS};
7971 enum RobustnessFlag {ROBUST_STRING_TRAVERSAL, FAST_STRING_TRAVERSAL};
7974 class StringHasher {
7976 explicit inline StringHasher(int length, uint32_t seed);
7978 template <typename schar>
7979 static inline uint32_t HashSequentialString(const schar* chars,
7983 // Reads all the data, even for long strings and computes the utf16 length.
7984 static uint32_t ComputeUtf8Hash(Vector<const char> chars,
7986 int* utf16_length_out);
7988 // Calculated hash value for a string consisting of 1 to
7989 // String::kMaxArrayIndexSize digits with no leading zeros (except "0").
7990 // value is represented decimal value.
7991 static uint32_t MakeArrayIndexHash(uint32_t value, int length);
7993 // No string is allowed to have a hash of zero. That value is reserved
7994 // for internal properties. If the hash calculation yields zero then we
7996 static const int kZeroHash = 27;
7998 // Reusable parts of the hashing algorithm.
7999 INLINE(static uint32_t AddCharacterCore(uint32_t running_hash, uint16_t c));
8000 INLINE(static uint32_t GetHashCore(uint32_t running_hash));
8001 INLINE(static uint32_t ComputeRunningHash(uint32_t running_hash,
8002 const uc16* chars, int length));
8003 INLINE(static uint32_t ComputeRunningHashOneByte(uint32_t running_hash,
8008 // Returns the value to store in the hash field of a string with
8009 // the given length and contents.
8010 uint32_t GetHashField();
8011 // Returns true if the hash of this string can be computed without
8012 // looking at the contents.
8013 inline bool has_trivial_hash();
8014 // Adds a block of characters to the hash.
8015 template<typename Char>
8016 inline void AddCharacters(const Char* chars, int len);
8019 // Add a character to the hash.
8020 inline void AddCharacter(uint16_t c);
8021 // Update index. Returns true if string is still an index.
8022 inline bool UpdateIndex(uint16_t c);
8025 uint32_t raw_running_hash_;
8026 uint32_t array_index_;
8027 bool is_array_index_;
8028 bool is_first_char_;
8029 DISALLOW_COPY_AND_ASSIGN(StringHasher);
8033 class IteratingStringHasher : public StringHasher {
8035 static inline uint32_t Hash(String* string, uint32_t seed);
8036 inline void VisitOneByteString(const uint8_t* chars, int length);
8037 inline void VisitTwoByteString(const uint16_t* chars, int length);
8040 inline IteratingStringHasher(int len, uint32_t seed);
8041 void VisitConsString(ConsString* cons_string);
8042 DISALLOW_COPY_AND_ASSIGN(IteratingStringHasher);
8046 // The characteristics of a string are stored in its map. Retrieving these
8047 // few bits of information is moderately expensive, involving two memory
8048 // loads where the second is dependent on the first. To improve efficiency
8049 // the shape of the string is given its own class so that it can be retrieved
8050 // once and used for several string operations. A StringShape is small enough
8051 // to be passed by value and is immutable, but be aware that flattening a
8052 // string can potentially alter its shape. Also be aware that a GC caused by
8053 // something else can alter the shape of a string due to ConsString
8054 // shortcutting. Keeping these restrictions in mind has proven to be error-
8055 // prone and so we no longer put StringShapes in variables unless there is a
8056 // concrete performance benefit at that particular point in the code.
8057 class StringShape BASE_EMBEDDED {
8059 inline explicit StringShape(const String* s);
8060 inline explicit StringShape(Map* s);
8061 inline explicit StringShape(InstanceType t);
8062 inline bool IsSequential();
8063 inline bool IsExternal();
8064 inline bool IsCons();
8065 inline bool IsSliced();
8066 inline bool IsIndirect();
8067 inline bool IsExternalOneByte();
8068 inline bool IsExternalTwoByte();
8069 inline bool IsSequentialOneByte();
8070 inline bool IsSequentialTwoByte();
8071 inline bool IsInternalized();
8072 inline StringRepresentationTag representation_tag();
8073 inline uint32_t encoding_tag();
8074 inline uint32_t full_representation_tag();
8075 inline uint32_t size_tag();
8077 inline uint32_t type() { return type_; }
8078 inline void invalidate() { valid_ = false; }
8079 inline bool valid() { return valid_; }
8081 inline void invalidate() { }
8087 inline void set_valid() { valid_ = true; }
8090 inline void set_valid() { }
8095 // The Name abstract class captures anything that can be used as a property
8096 // name, i.e., strings and symbols. All names store a hash value.
8097 class Name: public HeapObject {
8099 // Get and set the hash field of the name.
8100 inline uint32_t hash_field();
8101 inline void set_hash_field(uint32_t value);
8103 // Tells whether the hash code has been computed.
8104 inline bool HasHashCode();
8106 // Returns a hash value used for the property table
8107 inline uint32_t Hash();
8109 // Equality operations.
8110 inline bool Equals(Name* other);
8111 inline static bool Equals(Handle<Name> one, Handle<Name> two);
8114 inline bool AsArrayIndex(uint32_t* index);
8116 // If the name is private, it can only name own properties.
8117 inline bool IsPrivate();
8119 // If the name is a non-flat string, this method returns a flat version of the
8120 // string. Otherwise it'll just return the input.
8121 static inline Handle<Name> Flatten(Handle<Name> name,
8122 PretenureFlag pretenure = NOT_TENURED);
8124 // Return a string version of this name that is converted according to the
8125 // rules described in ES6 section 9.2.11.
8126 MUST_USE_RESULT static MaybeHandle<String> ToFunctionName(Handle<Name> name);
8130 DECLARE_PRINTER(Name)
8132 void NameShortPrint();
8133 int NameShortPrint(Vector<char> str);
8136 // Layout description.
8137 static const int kHashFieldSlot = HeapObject::kHeaderSize;
8138 #if V8_TARGET_LITTLE_ENDIAN || !V8_HOST_ARCH_64_BIT
8139 static const int kHashFieldOffset = kHashFieldSlot;
8141 static const int kHashFieldOffset = kHashFieldSlot + kIntSize;
8143 static const int kSize = kHashFieldSlot + kPointerSize;
8145 // Mask constant for checking if a name has a computed hash code
8146 // and if it is a string that is an array index. The least significant bit
8147 // indicates whether a hash code has been computed. If the hash code has
8148 // been computed the 2nd bit tells whether the string can be used as an
8150 static const int kHashNotComputedMask = 1;
8151 static const int kIsNotArrayIndexMask = 1 << 1;
8152 static const int kNofHashBitFields = 2;
8154 // Shift constant retrieving hash code from hash field.
8155 static const int kHashShift = kNofHashBitFields;
8157 // Only these bits are relevant in the hash, since the top two are shifted
8159 static const uint32_t kHashBitMask = 0xffffffffu >> kHashShift;
8161 // Array index strings this short can keep their index in the hash field.
8162 static const int kMaxCachedArrayIndexLength = 7;
8164 // For strings which are array indexes the hash value has the string length
8165 // mixed into the hash, mainly to avoid a hash value of zero which would be
8166 // the case for the string '0'. 24 bits are used for the array index value.
8167 static const int kArrayIndexValueBits = 24;
8168 static const int kArrayIndexLengthBits =
8169 kBitsPerInt - kArrayIndexValueBits - kNofHashBitFields;
8171 STATIC_ASSERT((kArrayIndexLengthBits > 0));
8173 class ArrayIndexValueBits : public BitField<unsigned int, kNofHashBitFields,
8174 kArrayIndexValueBits> {}; // NOLINT
8175 class ArrayIndexLengthBits : public BitField<unsigned int,
8176 kNofHashBitFields + kArrayIndexValueBits,
8177 kArrayIndexLengthBits> {}; // NOLINT
8179 // Check that kMaxCachedArrayIndexLength + 1 is a power of two so we
8180 // could use a mask to test if the length of string is less than or equal to
8181 // kMaxCachedArrayIndexLength.
8182 STATIC_ASSERT(IS_POWER_OF_TWO(kMaxCachedArrayIndexLength + 1));
8184 static const unsigned int kContainsCachedArrayIndexMask =
8185 (~static_cast<unsigned>(kMaxCachedArrayIndexLength)
8186 << ArrayIndexLengthBits::kShift) |
8187 kIsNotArrayIndexMask;
8189 // Value of empty hash field indicating that the hash is not computed.
8190 static const int kEmptyHashField =
8191 kIsNotArrayIndexMask | kHashNotComputedMask;
8194 static inline bool IsHashFieldComputed(uint32_t field);
8197 DISALLOW_IMPLICIT_CONSTRUCTORS(Name);
8202 class Symbol: public Name {
8204 // [name]: The print name of a symbol, or undefined if none.
8205 DECL_ACCESSORS(name, Object)
8207 DECL_ACCESSORS(flags, Smi)
8209 // [is_private]: Whether this is a private symbol. Private symbols can only
8210 // be used to designate own properties of objects.
8211 DECL_BOOLEAN_ACCESSORS(is_private)
8213 DECLARE_CAST(Symbol)
8215 // Dispatched behavior.
8216 DECLARE_PRINTER(Symbol)
8217 DECLARE_VERIFIER(Symbol)
8219 // Layout description.
8220 static const int kNameOffset = Name::kSize;
8221 static const int kFlagsOffset = kNameOffset + kPointerSize;
8222 static const int kSize = kFlagsOffset + kPointerSize;
8224 typedef FixedBodyDescriptor<kNameOffset, kFlagsOffset, kSize> BodyDescriptor;
8226 void SymbolShortPrint(std::ostream& os);
8229 static const int kPrivateBit = 0;
8231 const char* PrivateSymbolToName() const;
8234 friend class Name; // For PrivateSymbolToName.
8237 DISALLOW_IMPLICIT_CONSTRUCTORS(Symbol);
8243 // The String abstract class captures JavaScript string values:
8246 // 4.3.16 String Value
8247 // A string value is a member of the type String and is a finite
8248 // ordered sequence of zero or more 16-bit unsigned integer values.
8250 // All string values have a length field.
8251 class String: public Name {
8253 enum Encoding { ONE_BYTE_ENCODING, TWO_BYTE_ENCODING };
8255 // Array index strings this short can keep their index in the hash field.
8256 static const int kMaxCachedArrayIndexLength = 7;
8258 // For strings which are array indexes the hash value has the string length
8259 // mixed into the hash, mainly to avoid a hash value of zero which would be
8260 // the case for the string '0'. 24 bits are used for the array index value.
8261 static const int kArrayIndexValueBits = 24;
8262 static const int kArrayIndexLengthBits =
8263 kBitsPerInt - kArrayIndexValueBits - kNofHashBitFields;
8265 STATIC_ASSERT((kArrayIndexLengthBits > 0));
8267 class ArrayIndexValueBits : public BitField<unsigned int, kNofHashBitFields,
8268 kArrayIndexValueBits> {}; // NOLINT
8269 class ArrayIndexLengthBits : public BitField<unsigned int,
8270 kNofHashBitFields + kArrayIndexValueBits,
8271 kArrayIndexLengthBits> {}; // NOLINT
8273 // Check that kMaxCachedArrayIndexLength + 1 is a power of two so we
8274 // could use a mask to test if the length of string is less than or equal to
8275 // kMaxCachedArrayIndexLength.
8276 STATIC_ASSERT(IS_POWER_OF_TWO(kMaxCachedArrayIndexLength + 1));
8278 static const unsigned int kContainsCachedArrayIndexMask =
8279 (~static_cast<unsigned>(kMaxCachedArrayIndexLength)
8280 << ArrayIndexLengthBits::kShift) |
8281 kIsNotArrayIndexMask;
8283 class SubStringRange {
8285 explicit inline SubStringRange(String* string, int first = 0,
8288 inline iterator begin();
8289 inline iterator end();
8297 // Representation of the flat content of a String.
8298 // A non-flat string doesn't have flat content.
8299 // A flat string has content that's encoded as a sequence of either
8300 // one-byte chars or two-byte UC16.
8301 // Returned by String::GetFlatContent().
8304 // Returns true if the string is flat and this structure contains content.
8305 bool IsFlat() { return state_ != NON_FLAT; }
8306 // Returns true if the structure contains one-byte content.
8307 bool IsOneByte() { return state_ == ONE_BYTE; }
8308 // Returns true if the structure contains two-byte content.
8309 bool IsTwoByte() { return state_ == TWO_BYTE; }
8311 // Return the one byte content of the string. Only use if IsOneByte()
8313 Vector<const uint8_t> ToOneByteVector() {
8314 DCHECK_EQ(ONE_BYTE, state_);
8315 return Vector<const uint8_t>(onebyte_start, length_);
8317 // Return the two-byte content of the string. Only use if IsTwoByte()
8319 Vector<const uc16> ToUC16Vector() {
8320 DCHECK_EQ(TWO_BYTE, state_);
8321 return Vector<const uc16>(twobyte_start, length_);
8325 DCHECK(i < length_);
8326 DCHECK(state_ != NON_FLAT);
8327 if (state_ == ONE_BYTE) return onebyte_start[i];
8328 return twobyte_start[i];
8331 bool UsesSameString(const FlatContent& other) const {
8332 return onebyte_start == other.onebyte_start;
8336 enum State { NON_FLAT, ONE_BYTE, TWO_BYTE };
8338 // Constructors only used by String::GetFlatContent().
8339 explicit FlatContent(const uint8_t* start, int length)
8340 : onebyte_start(start), length_(length), state_(ONE_BYTE) {}
8341 explicit FlatContent(const uc16* start, int length)
8342 : twobyte_start(start), length_(length), state_(TWO_BYTE) { }
8343 FlatContent() : onebyte_start(NULL), length_(0), state_(NON_FLAT) { }
8346 const uint8_t* onebyte_start;
8347 const uc16* twobyte_start;
8352 friend class String;
8353 friend class IterableSubString;
8356 template <typename Char>
8357 INLINE(Vector<const Char> GetCharVector());
8359 // Get and set the length of the string.
8360 inline int length() const;
8361 inline void set_length(int value);
8363 // Get and set the length of the string using acquire loads and release
8365 inline int synchronized_length() const;
8366 inline void synchronized_set_length(int value);
8368 // Returns whether this string has only one-byte chars, i.e. all of them can
8369 // be one-byte encoded. This might be the case even if the string is
8370 // two-byte. Such strings may appear when the embedder prefers
8371 // two-byte external representations even for one-byte data.
8372 inline bool IsOneByteRepresentation() const;
8373 inline bool IsTwoByteRepresentation() const;
8375 // Cons and slices have an encoding flag that may not represent the actual
8376 // encoding of the underlying string. This is taken into account here.
8377 // Requires: this->IsFlat()
8378 inline bool IsOneByteRepresentationUnderneath();
8379 inline bool IsTwoByteRepresentationUnderneath();
8381 // NOTE: this should be considered only a hint. False negatives are
8383 inline bool HasOnlyOneByteChars();
8385 // Get and set individual two byte chars in the string.
8386 inline void Set(int index, uint16_t value);
8387 // Get individual two byte char in the string. Repeated calls
8388 // to this method are not efficient unless the string is flat.
8389 INLINE(uint16_t Get(int index));
8391 // ES6 section 7.1.3.1 ToNumber Applied to the String Type
8392 static Handle<Object> ToNumber(Handle<String> subject);
8394 // Flattens the string. Checks first inline to see if it is
8395 // necessary. Does nothing if the string is not a cons string.
8396 // Flattening allocates a sequential string with the same data as
8397 // the given string and mutates the cons string to a degenerate
8398 // form, where the first component is the new sequential string and
8399 // the second component is the empty string. If allocation fails,
8400 // this function returns a failure. If flattening succeeds, this
8401 // function returns the sequential string that is now the first
8402 // component of the cons string.
8404 // Degenerate cons strings are handled specially by the garbage
8405 // collector (see IsShortcutCandidate).
8407 static inline Handle<String> Flatten(Handle<String> string,
8408 PretenureFlag pretenure = NOT_TENURED);
8410 // Tries to return the content of a flat string as a structure holding either
8411 // a flat vector of char or of uc16.
8412 // If the string isn't flat, and therefore doesn't have flat content, the
8413 // returned structure will report so, and can't provide a vector of either
8415 FlatContent GetFlatContent();
8417 // Returns the parent of a sliced string or first part of a flat cons string.
8418 // Requires: StringShape(this).IsIndirect() && this->IsFlat()
8419 inline String* GetUnderlying();
8421 // String equality operations.
8422 inline bool Equals(String* other);
8423 inline static bool Equals(Handle<String> one, Handle<String> two);
8424 bool IsUtf8EqualTo(Vector<const char> str, bool allow_prefix_match = false);
8425 bool IsOneByteEqualTo(Vector<const uint8_t> str);
8426 bool IsTwoByteEqualTo(Vector<const uc16> str);
8428 // Return a UTF8 representation of the string. The string is null
8429 // terminated but may optionally contain nulls. Length is returned
8430 // in length_output if length_output is not a null pointer The string
8431 // should be nearly flat, otherwise the performance of this method may
8432 // be very slow (quadratic in the length). Setting robustness_flag to
8433 // ROBUST_STRING_TRAVERSAL invokes behaviour that is robust This means it
8434 // handles unexpected data without causing assert failures and it does not
8435 // do any heap allocations. This is useful when printing stack traces.
8436 base::SmartArrayPointer<char> ToCString(AllowNullsFlag allow_nulls,
8437 RobustnessFlag robustness_flag,
8438 int offset, int length,
8439 int* length_output = 0);
8440 base::SmartArrayPointer<char> ToCString(
8441 AllowNullsFlag allow_nulls = DISALLOW_NULLS,
8442 RobustnessFlag robustness_flag = FAST_STRING_TRAVERSAL,
8443 int* length_output = 0);
8445 // Return a 16 bit Unicode representation of the string.
8446 // The string should be nearly flat, otherwise the performance of
8447 // of this method may be very bad. Setting robustness_flag to
8448 // ROBUST_STRING_TRAVERSAL invokes behaviour that is robust This means it
8449 // handles unexpected data without causing assert failures and it does not
8450 // do any heap allocations. This is useful when printing stack traces.
8451 base::SmartArrayPointer<uc16> ToWideCString(
8452 RobustnessFlag robustness_flag = FAST_STRING_TRAVERSAL);
8454 bool ComputeArrayIndex(uint32_t* index);
8457 bool MakeExternal(v8::String::ExternalStringResource* resource);
8458 bool MakeExternal(v8::String::ExternalOneByteStringResource* resource);
8461 inline bool AsArrayIndex(uint32_t* index);
8463 DECLARE_CAST(String)
8465 void PrintOn(FILE* out);
8467 // For use during stack traces. Performs rudimentary sanity check.
8470 // Dispatched behavior.
8471 void StringShortPrint(StringStream* accumulator);
8472 void PrintUC16(std::ostream& os, int start = 0, int end = -1); // NOLINT
8473 #if defined(DEBUG) || defined(OBJECT_PRINT)
8474 char* ToAsciiArray();
8476 DECLARE_PRINTER(String)
8477 DECLARE_VERIFIER(String)
8479 inline bool IsFlat();
8481 // Layout description.
8482 static const int kLengthOffset = Name::kSize;
8483 static const int kSize = kLengthOffset + kPointerSize;
8485 // Maximum number of characters to consider when trying to convert a string
8486 // value into an array index.
8487 static const int kMaxArrayIndexSize = 10;
8488 STATIC_ASSERT(kMaxArrayIndexSize < (1 << kArrayIndexLengthBits));
8491 static const int32_t kMaxOneByteCharCode = unibrow::Latin1::kMaxChar;
8492 static const uint32_t kMaxOneByteCharCodeU = unibrow::Latin1::kMaxChar;
8493 static const int kMaxUtf16CodeUnit = 0xffff;
8494 static const uint32_t kMaxUtf16CodeUnitU = kMaxUtf16CodeUnit;
8496 // Value of hash field containing computed hash equal to zero.
8497 static const int kEmptyStringHash = kIsNotArrayIndexMask;
8499 // Maximal string length.
8500 static const int kMaxLength = (1 << 28) - 16;
8502 // Max length for computing hash. For strings longer than this limit the
8503 // string length is used as the hash value.
8504 static const int kMaxHashCalcLength = 16383;
8506 // Limit for truncation in short printing.
8507 static const int kMaxShortPrintLength = 1024;
8509 // Support for regular expressions.
8510 const uc16* GetTwoByteData(unsigned start);
8512 // Helper function for flattening strings.
8513 template <typename sinkchar>
8514 static void WriteToFlat(String* source,
8519 // The return value may point to the first aligned word containing the first
8520 // non-one-byte character, rather than directly to the non-one-byte character.
8521 // If the return value is >= the passed length, the entire string was
8523 static inline int NonAsciiStart(const char* chars, int length) {
8524 const char* start = chars;
8525 const char* limit = chars + length;
8527 if (length >= kIntptrSize) {
8528 // Check unaligned bytes.
8529 while (!IsAligned(reinterpret_cast<intptr_t>(chars), sizeof(uintptr_t))) {
8530 if (static_cast<uint8_t>(*chars) > unibrow::Utf8::kMaxOneByteChar) {
8531 return static_cast<int>(chars - start);
8535 // Check aligned words.
8536 DCHECK(unibrow::Utf8::kMaxOneByteChar == 0x7F);
8537 const uintptr_t non_one_byte_mask = kUintptrAllBitsSet / 0xFF * 0x80;
8538 while (chars + sizeof(uintptr_t) <= limit) {
8539 if (*reinterpret_cast<const uintptr_t*>(chars) & non_one_byte_mask) {
8540 return static_cast<int>(chars - start);
8542 chars += sizeof(uintptr_t);
8545 // Check remaining unaligned bytes.
8546 while (chars < limit) {
8547 if (static_cast<uint8_t>(*chars) > unibrow::Utf8::kMaxOneByteChar) {
8548 return static_cast<int>(chars - start);
8553 return static_cast<int>(chars - start);
8556 static inline bool IsAscii(const char* chars, int length) {
8557 return NonAsciiStart(chars, length) >= length;
8560 static inline bool IsAscii(const uint8_t* chars, int length) {
8562 NonAsciiStart(reinterpret_cast<const char*>(chars), length) >= length;
8565 static inline int NonOneByteStart(const uc16* chars, int length) {
8566 const uc16* limit = chars + length;
8567 const uc16* start = chars;
8568 while (chars < limit) {
8569 if (*chars > kMaxOneByteCharCodeU) return static_cast<int>(chars - start);
8572 return static_cast<int>(chars - start);
8575 static inline bool IsOneByte(const uc16* chars, int length) {
8576 return NonOneByteStart(chars, length) >= length;
8579 template<class Visitor>
8580 static inline ConsString* VisitFlat(Visitor* visitor,
8584 static Handle<FixedArray> CalculateLineEnds(Handle<String> string,
8585 bool include_ending_line);
8587 // Use the hash field to forward to the canonical internalized string
8588 // when deserializing an internalized string.
8589 inline void SetForwardedInternalizedString(String* string);
8590 inline String* GetForwardedInternalizedString();
8594 friend class StringTableInsertionKey;
8596 static Handle<String> SlowFlatten(Handle<ConsString> cons,
8597 PretenureFlag tenure);
8599 // Slow case of String::Equals. This implementation works on any strings
8600 // but it is most efficient on strings that are almost flat.
8601 bool SlowEquals(String* other);
8603 static bool SlowEquals(Handle<String> one, Handle<String> two);
8605 // Slow case of AsArrayIndex.
8606 bool SlowAsArrayIndex(uint32_t* index);
8608 // Compute and set the hash code.
8609 uint32_t ComputeAndSetHash();
8611 DISALLOW_IMPLICIT_CONSTRUCTORS(String);
8615 // The SeqString abstract class captures sequential string values.
8616 class SeqString: public String {
8618 DECLARE_CAST(SeqString)
8620 // Layout description.
8621 static const int kHeaderSize = String::kSize;
8623 // Truncate the string in-place if possible and return the result.
8624 // In case of new_length == 0, the empty string is returned without
8625 // truncating the original string.
8626 MUST_USE_RESULT static Handle<String> Truncate(Handle<SeqString> string,
8629 DISALLOW_IMPLICIT_CONSTRUCTORS(SeqString);
8633 // The OneByteString class captures sequential one-byte string objects.
8634 // Each character in the OneByteString is an one-byte character.
8635 class SeqOneByteString: public SeqString {
8637 static const bool kHasOneByteEncoding = true;
8639 // Dispatched behavior.
8640 inline uint16_t SeqOneByteStringGet(int index);
8641 inline void SeqOneByteStringSet(int index, uint16_t value);
8643 // Get the address of the characters in this string.
8644 inline Address GetCharsAddress();
8646 inline uint8_t* GetChars();
8648 DECLARE_CAST(SeqOneByteString)
8650 // Garbage collection support. This method is called by the
8651 // garbage collector to compute the actual size of an OneByteString
8653 inline int SeqOneByteStringSize(InstanceType instance_type);
8655 // Computes the size for an OneByteString instance of a given length.
8656 static int SizeFor(int length) {
8657 return OBJECT_POINTER_ALIGN(kHeaderSize + length * kCharSize);
8660 // Maximal memory usage for a single sequential one-byte string.
8661 static const int kMaxSize = 512 * MB - 1;
8662 STATIC_ASSERT((kMaxSize - kHeaderSize) >= String::kMaxLength);
8665 DISALLOW_IMPLICIT_CONSTRUCTORS(SeqOneByteString);
8669 // The TwoByteString class captures sequential unicode string objects.
8670 // Each character in the TwoByteString is a two-byte uint16_t.
8671 class SeqTwoByteString: public SeqString {
8673 static const bool kHasOneByteEncoding = false;
8675 // Dispatched behavior.
8676 inline uint16_t SeqTwoByteStringGet(int index);
8677 inline void SeqTwoByteStringSet(int index, uint16_t value);
8679 // Get the address of the characters in this string.
8680 inline Address GetCharsAddress();
8682 inline uc16* GetChars();
8685 const uint16_t* SeqTwoByteStringGetData(unsigned start);
8687 DECLARE_CAST(SeqTwoByteString)
8689 // Garbage collection support. This method is called by the
8690 // garbage collector to compute the actual size of a TwoByteString
8692 inline int SeqTwoByteStringSize(InstanceType instance_type);
8694 // Computes the size for a TwoByteString instance of a given length.
8695 static int SizeFor(int length) {
8696 return OBJECT_POINTER_ALIGN(kHeaderSize + length * kShortSize);
8699 // Maximal memory usage for a single sequential two-byte string.
8700 static const int kMaxSize = 512 * MB - 1;
8701 STATIC_ASSERT(static_cast<int>((kMaxSize - kHeaderSize)/sizeof(uint16_t)) >=
8702 String::kMaxLength);
8705 DISALLOW_IMPLICIT_CONSTRUCTORS(SeqTwoByteString);
8709 // The ConsString class describes string values built by using the
8710 // addition operator on strings. A ConsString is a pair where the
8711 // first and second components are pointers to other string values.
8712 // One or both components of a ConsString can be pointers to other
8713 // ConsStrings, creating a binary tree of ConsStrings where the leaves
8714 // are non-ConsString string values. The string value represented by
8715 // a ConsString can be obtained by concatenating the leaf string
8716 // values in a left-to-right depth-first traversal of the tree.
8717 class ConsString: public String {
8719 // First string of the cons cell.
8720 inline String* first();
8721 // Doesn't check that the result is a string, even in debug mode. This is
8722 // useful during GC where the mark bits confuse the checks.
8723 inline Object* unchecked_first();
8724 inline void set_first(String* first,
8725 WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
8727 // Second string of the cons cell.
8728 inline String* second();
8729 // Doesn't check that the result is a string, even in debug mode. This is
8730 // useful during GC where the mark bits confuse the checks.
8731 inline Object* unchecked_second();
8732 inline void set_second(String* second,
8733 WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
8735 // Dispatched behavior.
8736 uint16_t ConsStringGet(int index);
8738 DECLARE_CAST(ConsString)
8740 // Layout description.
8741 static const int kFirstOffset = POINTER_SIZE_ALIGN(String::kSize);
8742 static const int kSecondOffset = kFirstOffset + kPointerSize;
8743 static const int kSize = kSecondOffset + kPointerSize;
8745 // Minimum length for a cons string.
8746 static const int kMinLength = 13;
8748 typedef FixedBodyDescriptor<kFirstOffset, kSecondOffset + kPointerSize, kSize>
8751 DECLARE_VERIFIER(ConsString)
8754 DISALLOW_IMPLICIT_CONSTRUCTORS(ConsString);
8758 // The Sliced String class describes strings that are substrings of another
8759 // sequential string. The motivation is to save time and memory when creating
8760 // a substring. A Sliced String is described as a pointer to the parent,
8761 // the offset from the start of the parent string and the length. Using
8762 // a Sliced String therefore requires unpacking of the parent string and
8763 // adding the offset to the start address. A substring of a Sliced String
8764 // are not nested since the double indirection is simplified when creating
8765 // such a substring.
8766 // Currently missing features are:
8767 // - handling externalized parent strings
8768 // - external strings as parent
8769 // - truncating sliced string to enable otherwise unneeded parent to be GC'ed.
8770 class SlicedString: public String {
8772 inline String* parent();
8773 inline void set_parent(String* parent,
8774 WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
8775 inline int offset() const;
8776 inline void set_offset(int offset);
8778 // Dispatched behavior.
8779 uint16_t SlicedStringGet(int index);
8781 DECLARE_CAST(SlicedString)
8783 // Layout description.
8784 static const int kParentOffset = POINTER_SIZE_ALIGN(String::kSize);
8785 static const int kOffsetOffset = kParentOffset + kPointerSize;
8786 static const int kSize = kOffsetOffset + kPointerSize;
8788 // Minimum length for a sliced string.
8789 static const int kMinLength = 13;
8791 typedef FixedBodyDescriptor<kParentOffset,
8792 kOffsetOffset + kPointerSize, kSize>
8795 DECLARE_VERIFIER(SlicedString)
8798 DISALLOW_IMPLICIT_CONSTRUCTORS(SlicedString);
8802 // The ExternalString class describes string values that are backed by
8803 // a string resource that lies outside the V8 heap. ExternalStrings
8804 // consist of the length field common to all strings, a pointer to the
8805 // external resource. It is important to ensure (externally) that the
8806 // resource is not deallocated while the ExternalString is live in the
8809 // The API expects that all ExternalStrings are created through the
8810 // API. Therefore, ExternalStrings should not be used internally.
8811 class ExternalString: public String {
8813 DECLARE_CAST(ExternalString)
8815 // Layout description.
8816 static const int kResourceOffset = POINTER_SIZE_ALIGN(String::kSize);
8817 static const int kShortSize = kResourceOffset + kPointerSize;
8818 static const int kResourceDataOffset = kResourceOffset + kPointerSize;
8819 static const int kSize = kResourceDataOffset + kPointerSize;
8821 static const int kMaxShortLength =
8822 (kShortSize - SeqString::kHeaderSize) / kCharSize;
8824 // Return whether external string is short (data pointer is not cached).
8825 inline bool is_short();
8827 STATIC_ASSERT(kResourceOffset == Internals::kStringResourceOffset);
8830 DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalString);
8834 // The ExternalOneByteString class is an external string backed by an
8836 class ExternalOneByteString : public ExternalString {
8838 static const bool kHasOneByteEncoding = true;
8840 typedef v8::String::ExternalOneByteStringResource Resource;
8842 // The underlying resource.
8843 inline const Resource* resource();
8844 inline void set_resource(const Resource* buffer);
8846 // Update the pointer cache to the external character array.
8847 // The cached pointer is always valid, as the external character array does =
8848 // not move during lifetime. Deserialization is the only exception, after
8849 // which the pointer cache has to be refreshed.
8850 inline void update_data_cache();
8852 inline const uint8_t* GetChars();
8854 // Dispatched behavior.
8855 inline uint16_t ExternalOneByteStringGet(int index);
8857 DECLARE_CAST(ExternalOneByteString)
8859 // Garbage collection support.
8860 inline void ExternalOneByteStringIterateBody(ObjectVisitor* v);
8862 template <typename StaticVisitor>
8863 inline void ExternalOneByteStringIterateBody();
8866 DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalOneByteString);
8870 // The ExternalTwoByteString class is an external string backed by a UTF-16
8872 class ExternalTwoByteString: public ExternalString {
8874 static const bool kHasOneByteEncoding = false;
8876 typedef v8::String::ExternalStringResource Resource;
8878 // The underlying string resource.
8879 inline const Resource* resource();
8880 inline void set_resource(const Resource* buffer);
8882 // Update the pointer cache to the external character array.
8883 // The cached pointer is always valid, as the external character array does =
8884 // not move during lifetime. Deserialization is the only exception, after
8885 // which the pointer cache has to be refreshed.
8886 inline void update_data_cache();
8888 inline const uint16_t* GetChars();
8890 // Dispatched behavior.
8891 inline uint16_t ExternalTwoByteStringGet(int index);
8894 inline const uint16_t* ExternalTwoByteStringGetData(unsigned start);
8896 DECLARE_CAST(ExternalTwoByteString)
8898 // Garbage collection support.
8899 inline void ExternalTwoByteStringIterateBody(ObjectVisitor* v);
8901 template<typename StaticVisitor>
8902 inline void ExternalTwoByteStringIterateBody();
8905 DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalTwoByteString);
8909 // Utility superclass for stack-allocated objects that must be updated
8910 // on gc. It provides two ways for the gc to update instances, either
8911 // iterating or updating after gc.
8912 class Relocatable BASE_EMBEDDED {
8914 explicit inline Relocatable(Isolate* isolate);
8915 inline virtual ~Relocatable();
8916 virtual void IterateInstance(ObjectVisitor* v) { }
8917 virtual void PostGarbageCollection() { }
8919 static void PostGarbageCollectionProcessing(Isolate* isolate);
8920 static int ArchiveSpacePerThread();
8921 static char* ArchiveState(Isolate* isolate, char* to);
8922 static char* RestoreState(Isolate* isolate, char* from);
8923 static void Iterate(Isolate* isolate, ObjectVisitor* v);
8924 static void Iterate(ObjectVisitor* v, Relocatable* top);
8925 static char* Iterate(ObjectVisitor* v, char* t);
8933 // A flat string reader provides random access to the contents of a
8934 // string independent of the character width of the string. The handle
8935 // must be valid as long as the reader is being used.
8936 class FlatStringReader : public Relocatable {
8938 FlatStringReader(Isolate* isolate, Handle<String> str);
8939 FlatStringReader(Isolate* isolate, Vector<const char> input);
8940 void PostGarbageCollection();
8941 inline uc32 Get(int index);
8942 template <typename Char>
8943 inline Char Get(int index);
8944 int length() { return length_; }
8953 // This maintains an off-stack representation of the stack frames required
8954 // to traverse a ConsString, allowing an entirely iterative and restartable
8955 // traversal of the entire string
8956 class ConsStringIterator {
8958 inline ConsStringIterator() {}
8959 inline explicit ConsStringIterator(ConsString* cons_string, int offset = 0) {
8960 Reset(cons_string, offset);
8962 inline void Reset(ConsString* cons_string, int offset = 0) {
8964 // Next will always return NULL.
8965 if (cons_string == NULL) return;
8966 Initialize(cons_string, offset);
8968 // Returns NULL when complete.
8969 inline String* Next(int* offset_out) {
8971 if (depth_ == 0) return NULL;
8972 return Continue(offset_out);
8976 static const int kStackSize = 32;
8977 // Use a mask instead of doing modulo operations for stack wrapping.
8978 static const int kDepthMask = kStackSize-1;
8979 STATIC_ASSERT(IS_POWER_OF_TWO(kStackSize));
8980 static inline int OffsetForDepth(int depth);
8982 inline void PushLeft(ConsString* string);
8983 inline void PushRight(ConsString* string);
8984 inline void AdjustMaximumDepth();
8986 inline bool StackBlown() { return maximum_depth_ - depth_ == kStackSize; }
8987 void Initialize(ConsString* cons_string, int offset);
8988 String* Continue(int* offset_out);
8989 String* NextLeaf(bool* blew_stack);
8990 String* Search(int* offset_out);
8992 // Stack must always contain only frames for which right traversal
8993 // has not yet been performed.
8994 ConsString* frames_[kStackSize];
8999 DISALLOW_COPY_AND_ASSIGN(ConsStringIterator);
9003 class StringCharacterStream {
9005 inline StringCharacterStream(String* string,
9007 inline uint16_t GetNext();
9008 inline bool HasMore();
9009 inline void Reset(String* string, int offset = 0);
9010 inline void VisitOneByteString(const uint8_t* chars, int length);
9011 inline void VisitTwoByteString(const uint16_t* chars, int length);
9014 ConsStringIterator iter_;
9017 const uint8_t* buffer8_;
9018 const uint16_t* buffer16_;
9020 const uint8_t* end_;
9021 DISALLOW_COPY_AND_ASSIGN(StringCharacterStream);
9025 template <typename T>
9026 class VectorIterator {
9028 VectorIterator(T* d, int l) : data_(Vector<const T>(d, l)), index_(0) { }
9029 explicit VectorIterator(Vector<const T> data) : data_(data), index_(0) { }
9030 T GetNext() { return data_[index_++]; }
9031 bool has_more() { return index_ < data_.length(); }
9033 Vector<const T> data_;
9038 // The Oddball describes objects null, undefined, true, and false.
9039 class Oddball: public HeapObject {
9041 // [to_string]: Cached to_string computed at startup.
9042 DECL_ACCESSORS(to_string, String)
9044 // [to_number]: Cached to_number computed at startup.
9045 DECL_ACCESSORS(to_number, Object)
9047 // [typeof]: Cached type_of computed at startup.
9048 DECL_ACCESSORS(type_of, String)
9050 inline byte kind() const;
9051 inline void set_kind(byte kind);
9053 DECLARE_CAST(Oddball)
9055 // Dispatched behavior.
9056 DECLARE_VERIFIER(Oddball)
9058 // Initialize the fields.
9059 static void Initialize(Isolate* isolate, Handle<Oddball> oddball,
9060 const char* to_string, Handle<Object> to_number,
9061 const char* type_of, byte kind);
9063 // Layout description.
9064 static const int kToStringOffset = HeapObject::kHeaderSize;
9065 static const int kToNumberOffset = kToStringOffset + kPointerSize;
9066 static const int kTypeOfOffset = kToNumberOffset + kPointerSize;
9067 static const int kKindOffset = kTypeOfOffset + kPointerSize;
9068 static const int kSize = kKindOffset + kPointerSize;
9070 static const byte kFalse = 0;
9071 static const byte kTrue = 1;
9072 static const byte kNotBooleanMask = ~1;
9073 static const byte kTheHole = 2;
9074 static const byte kNull = 3;
9075 static const byte kArgumentMarker = 4;
9076 static const byte kUndefined = 5;
9077 static const byte kUninitialized = 6;
9078 static const byte kOther = 7;
9079 static const byte kException = 8;
9081 typedef FixedBodyDescriptor<kToStringOffset, kTypeOfOffset + kPointerSize,
9082 kSize> BodyDescriptor;
9084 STATIC_ASSERT(kKindOffset == Internals::kOddballKindOffset);
9085 STATIC_ASSERT(kNull == Internals::kNullOddballKind);
9086 STATIC_ASSERT(kUndefined == Internals::kUndefinedOddballKind);
9089 DISALLOW_IMPLICIT_CONSTRUCTORS(Oddball);
9093 class Cell: public HeapObject {
9095 // [value]: value of the cell.
9096 DECL_ACCESSORS(value, Object)
9100 static inline Cell* FromValueAddress(Address value) {
9101 Object* result = FromAddress(value - kValueOffset);
9102 return static_cast<Cell*>(result);
9105 inline Address ValueAddress() {
9106 return address() + kValueOffset;
9109 // Dispatched behavior.
9110 DECLARE_PRINTER(Cell)
9111 DECLARE_VERIFIER(Cell)
9113 // Layout description.
9114 static const int kValueOffset = HeapObject::kHeaderSize;
9115 static const int kSize = kValueOffset + kPointerSize;
9117 typedef FixedBodyDescriptor<kValueOffset,
9118 kValueOffset + kPointerSize,
9119 kSize> BodyDescriptor;
9122 DISALLOW_IMPLICIT_CONSTRUCTORS(Cell);
9126 class PropertyCell : public HeapObject {
9128 // [property_details]: details of the global property.
9129 DECL_ACCESSORS(property_details_raw, Object)
9130 // [value]: value of the global property.
9131 DECL_ACCESSORS(value, Object)
9132 // [dependent_code]: dependent code that depends on the type of the global
9134 DECL_ACCESSORS(dependent_code, DependentCode)
9136 inline PropertyDetails property_details();
9137 inline void set_property_details(PropertyDetails details);
9139 PropertyCellConstantType GetConstantType();
9141 // Computes the new type of the cell's contents for the given value, but
9142 // without actually modifying the details.
9143 static PropertyCellType UpdatedType(Handle<PropertyCell> cell,
9144 Handle<Object> value,
9145 PropertyDetails details);
9146 static void UpdateCell(Handle<GlobalDictionary> dictionary, int entry,
9147 Handle<Object> value, PropertyDetails details);
9149 static Handle<PropertyCell> InvalidateEntry(
9150 Handle<GlobalDictionary> dictionary, int entry);
9152 static void SetValueWithInvalidation(Handle<PropertyCell> cell,
9153 Handle<Object> new_value);
9155 DECLARE_CAST(PropertyCell)
9157 // Dispatched behavior.
9158 DECLARE_PRINTER(PropertyCell)
9159 DECLARE_VERIFIER(PropertyCell)
9161 // Layout description.
9162 static const int kDetailsOffset = HeapObject::kHeaderSize;
9163 static const int kValueOffset = kDetailsOffset + kPointerSize;
9164 static const int kDependentCodeOffset = kValueOffset + kPointerSize;
9165 static const int kSize = kDependentCodeOffset + kPointerSize;
9167 static const int kPointerFieldsBeginOffset = kValueOffset;
9168 static const int kPointerFieldsEndOffset = kSize;
9170 typedef FixedBodyDescriptor<kValueOffset,
9172 kSize> BodyDescriptor;
9175 DISALLOW_IMPLICIT_CONSTRUCTORS(PropertyCell);
9179 class WeakCell : public HeapObject {
9181 inline Object* value() const;
9183 // This should not be called by anyone except GC.
9184 inline void clear();
9186 // This should not be called by anyone except allocator.
9187 inline void initialize(HeapObject* value);
9189 inline bool cleared() const;
9191 DECL_ACCESSORS(next, Object)
9193 inline void clear_next(Heap* heap);
9195 inline bool next_cleared();
9197 DECLARE_CAST(WeakCell)
9199 DECLARE_PRINTER(WeakCell)
9200 DECLARE_VERIFIER(WeakCell)
9202 // Layout description.
9203 static const int kValueOffset = HeapObject::kHeaderSize;
9204 static const int kNextOffset = kValueOffset + kPointerSize;
9205 static const int kSize = kNextOffset + kPointerSize;
9207 typedef FixedBodyDescriptor<kValueOffset, kSize, kSize> BodyDescriptor;
9210 DISALLOW_IMPLICIT_CONSTRUCTORS(WeakCell);
9214 // The JSProxy describes EcmaScript Harmony proxies
9215 class JSProxy: public JSReceiver {
9217 // [handler]: The handler property.
9218 DECL_ACCESSORS(handler, Object)
9220 // [hash]: The hash code property (undefined if not initialized yet).
9221 DECL_ACCESSORS(hash, Object)
9223 DECLARE_CAST(JSProxy)
9225 MUST_USE_RESULT static MaybeHandle<Object> GetPropertyWithHandler(
9226 Handle<JSProxy> proxy,
9227 Handle<Object> receiver,
9230 // If the handler defines an accessor property with a setter, invoke it.
9231 // If it defines an accessor property without a setter, or a data property
9232 // that is read-only, throw. In all these cases set '*done' to true,
9233 // otherwise set it to false.
9235 static MaybeHandle<Object> SetPropertyViaPrototypesWithHandler(
9236 Handle<JSProxy> proxy, Handle<Object> receiver, Handle<Name> name,
9237 Handle<Object> value, LanguageMode language_mode, bool* done);
9239 MUST_USE_RESULT static Maybe<PropertyAttributes>
9240 GetPropertyAttributesWithHandler(Handle<JSProxy> proxy,
9241 Handle<Object> receiver,
9243 MUST_USE_RESULT static MaybeHandle<Object> SetPropertyWithHandler(
9244 Handle<JSProxy> proxy, Handle<Object> receiver, Handle<Name> name,
9245 Handle<Object> value, LanguageMode language_mode);
9247 // Turn the proxy into an (empty) JSObject.
9248 static void Fix(Handle<JSProxy> proxy);
9250 // Initializes the body after the handler slot.
9251 inline void InitializeBody(int object_size, Object* value);
9253 // Invoke a trap by name. If the trap does not exist on this's handler,
9254 // but derived_trap is non-NULL, invoke that instead. May cause GC.
9255 MUST_USE_RESULT static MaybeHandle<Object> CallTrap(
9256 Handle<JSProxy> proxy,
9258 Handle<Object> derived_trap,
9260 Handle<Object> args[]);
9262 // Dispatched behavior.
9263 DECLARE_PRINTER(JSProxy)
9264 DECLARE_VERIFIER(JSProxy)
9266 // Layout description. We add padding so that a proxy has the same
9267 // size as a virgin JSObject. This is essential for becoming a JSObject
9269 static const int kHandlerOffset = HeapObject::kHeaderSize;
9270 static const int kHashOffset = kHandlerOffset + kPointerSize;
9271 static const int kPaddingOffset = kHashOffset + kPointerSize;
9272 static const int kSize = JSObject::kHeaderSize;
9273 static const int kHeaderSize = kPaddingOffset;
9274 static const int kPaddingSize = kSize - kPaddingOffset;
9276 STATIC_ASSERT(kPaddingSize >= 0);
9278 typedef FixedBodyDescriptor<kHandlerOffset,
9280 kSize> BodyDescriptor;
9283 friend class JSReceiver;
9285 MUST_USE_RESULT static Maybe<bool> HasPropertyWithHandler(
9286 Handle<JSProxy> proxy, Handle<Name> name);
9288 MUST_USE_RESULT static MaybeHandle<Object> DeletePropertyWithHandler(
9289 Handle<JSProxy> proxy, Handle<Name> name, LanguageMode language_mode);
9291 MUST_USE_RESULT Object* GetIdentityHash();
9293 static Handle<Smi> GetOrCreateIdentityHash(Handle<JSProxy> proxy);
9295 DISALLOW_IMPLICIT_CONSTRUCTORS(JSProxy);
9299 class JSFunctionProxy: public JSProxy {
9301 // [call_trap]: The call trap.
9302 DECL_ACCESSORS(call_trap, JSReceiver)
9304 // [construct_trap]: The construct trap.
9305 DECL_ACCESSORS(construct_trap, Object)
9307 DECLARE_CAST(JSFunctionProxy)
9309 // Dispatched behavior.
9310 DECLARE_PRINTER(JSFunctionProxy)
9311 DECLARE_VERIFIER(JSFunctionProxy)
9313 // Layout description.
9314 static const int kCallTrapOffset = JSProxy::kPaddingOffset;
9315 static const int kConstructTrapOffset = kCallTrapOffset + kPointerSize;
9316 static const int kPaddingOffset = kConstructTrapOffset + kPointerSize;
9317 static const int kSize = JSFunction::kSize;
9318 static const int kPaddingSize = kSize - kPaddingOffset;
9320 STATIC_ASSERT(kPaddingSize >= 0);
9322 typedef FixedBodyDescriptor<kHandlerOffset,
9323 kConstructTrapOffset + kPointerSize,
9324 kSize> BodyDescriptor;
9327 DISALLOW_IMPLICIT_CONSTRUCTORS(JSFunctionProxy);
9331 class JSCollection : public JSObject {
9333 // [table]: the backing hash table
9334 DECL_ACCESSORS(table, Object)
9336 static const int kTableOffset = JSObject::kHeaderSize;
9337 static const int kSize = kTableOffset + kPointerSize;
9340 DISALLOW_IMPLICIT_CONSTRUCTORS(JSCollection);
9344 // The JSSet describes EcmaScript Harmony sets
9345 class JSSet : public JSCollection {
9349 static void Initialize(Handle<JSSet> set, Isolate* isolate);
9350 static void Clear(Handle<JSSet> set);
9352 // Dispatched behavior.
9353 DECLARE_PRINTER(JSSet)
9354 DECLARE_VERIFIER(JSSet)
9357 DISALLOW_IMPLICIT_CONSTRUCTORS(JSSet);
9361 // The JSMap describes EcmaScript Harmony maps
9362 class JSMap : public JSCollection {
9366 static void Initialize(Handle<JSMap> map, Isolate* isolate);
9367 static void Clear(Handle<JSMap> map);
9369 // Dispatched behavior.
9370 DECLARE_PRINTER(JSMap)
9371 DECLARE_VERIFIER(JSMap)
9374 DISALLOW_IMPLICIT_CONSTRUCTORS(JSMap);
9378 // OrderedHashTableIterator is an iterator that iterates over the keys and
9379 // values of an OrderedHashTable.
9381 // The iterator has a reference to the underlying OrderedHashTable data,
9382 // [table], as well as the current [index] the iterator is at.
9384 // When the OrderedHashTable is rehashed it adds a reference from the old table
9385 // to the new table as well as storing enough data about the changes so that the
9386 // iterator [index] can be adjusted accordingly.
9388 // When the [Next] result from the iterator is requested, the iterator checks if
9389 // there is a newer table that it needs to transition to.
9390 template<class Derived, class TableType>
9391 class OrderedHashTableIterator: public JSObject {
9393 // [table]: the backing hash table mapping keys to values.
9394 DECL_ACCESSORS(table, Object)
9396 // [index]: The index into the data table.
9397 DECL_ACCESSORS(index, Object)
9399 // [kind]: The kind of iteration this is. One of the [Kind] enum values.
9400 DECL_ACCESSORS(kind, Object)
9403 void OrderedHashTableIteratorPrint(std::ostream& os); // NOLINT
9406 static const int kTableOffset = JSObject::kHeaderSize;
9407 static const int kIndexOffset = kTableOffset + kPointerSize;
9408 static const int kKindOffset = kIndexOffset + kPointerSize;
9409 static const int kSize = kKindOffset + kPointerSize;
9417 // Whether the iterator has more elements. This needs to be called before
9418 // calling |CurrentKey| and/or |CurrentValue|.
9421 // Move the index forward one.
9423 set_index(Smi::FromInt(Smi::cast(index())->value() + 1));
9426 // Populates the array with the next key and value and then moves the iterator
9428 // This returns the |kind| or 0 if the iterator is already at the end.
9429 Smi* Next(JSArray* value_array);
9431 // Returns the current key of the iterator. This should only be called when
9432 // |HasMore| returns true.
9433 inline Object* CurrentKey();
9436 // Transitions the iterator to the non obsolete backing store. This is a NOP
9437 // if the [table] is not obsolete.
9440 DISALLOW_IMPLICIT_CONSTRUCTORS(OrderedHashTableIterator);
9444 class JSSetIterator: public OrderedHashTableIterator<JSSetIterator,
9447 // Dispatched behavior.
9448 DECLARE_PRINTER(JSSetIterator)
9449 DECLARE_VERIFIER(JSSetIterator)
9451 DECLARE_CAST(JSSetIterator)
9453 // Called by |Next| to populate the array. This allows the subclasses to
9454 // populate the array differently.
9455 inline void PopulateValueArray(FixedArray* array);
9458 DISALLOW_IMPLICIT_CONSTRUCTORS(JSSetIterator);
9462 class JSMapIterator: public OrderedHashTableIterator<JSMapIterator,
9465 // Dispatched behavior.
9466 DECLARE_PRINTER(JSMapIterator)
9467 DECLARE_VERIFIER(JSMapIterator)
9469 DECLARE_CAST(JSMapIterator)
9471 // Called by |Next| to populate the array. This allows the subclasses to
9472 // populate the array differently.
9473 inline void PopulateValueArray(FixedArray* array);
9476 // Returns the current value of the iterator. This should only be called when
9477 // |HasMore| returns true.
9478 inline Object* CurrentValue();
9480 DISALLOW_IMPLICIT_CONSTRUCTORS(JSMapIterator);
9484 // ES6 section 25.1.1.3 The IteratorResult Interface
9485 class JSIteratorResult final : public JSObject {
9487 // [done]: This is the result status of an iterator next method call. If the
9488 // end of the iterator was reached done is true. If the end was not reached
9489 // done is false and a [value] is available.
9490 DECL_ACCESSORS(done, Object)
9492 // [value]: If [done] is false, this is the current iteration element value.
9493 // If [done] is true, this is the return value of the iterator, if it supplied
9494 // one. If the iterator does not have a return value, value is undefined.
9495 // In that case, the value property may be absent from the conforming object
9496 // if it does not inherit an explicit value property.
9497 DECL_ACCESSORS(value, Object)
9499 // Dispatched behavior.
9500 DECLARE_PRINTER(JSIteratorResult)
9501 DECLARE_VERIFIER(JSIteratorResult)
9503 DECLARE_CAST(JSIteratorResult)
9505 static const int kValueOffset = JSObject::kHeaderSize;
9506 static const int kDoneOffset = kValueOffset + kPointerSize;
9507 static const int kSize = kDoneOffset + kPointerSize;
9509 // Indices of in-object properties.
9510 static const int kValueIndex = 0;
9511 static const int kDoneIndex = 1;
9514 DISALLOW_IMPLICIT_CONSTRUCTORS(JSIteratorResult);
9518 // Base class for both JSWeakMap and JSWeakSet
9519 class JSWeakCollection: public JSObject {
9521 // [table]: the backing hash table mapping keys to values.
9522 DECL_ACCESSORS(table, Object)
9524 // [next]: linked list of encountered weak maps during GC.
9525 DECL_ACCESSORS(next, Object)
9527 static void Initialize(Handle<JSWeakCollection> collection, Isolate* isolate);
9528 static void Set(Handle<JSWeakCollection> collection, Handle<Object> key,
9529 Handle<Object> value, int32_t hash);
9530 static bool Delete(Handle<JSWeakCollection> collection, Handle<Object> key,
9533 static const int kTableOffset = JSObject::kHeaderSize;
9534 static const int kNextOffset = kTableOffset + kPointerSize;
9535 static const int kSize = kNextOffset + kPointerSize;
9538 DISALLOW_IMPLICIT_CONSTRUCTORS(JSWeakCollection);
9542 // The JSWeakMap describes EcmaScript Harmony weak maps
9543 class JSWeakMap: public JSWeakCollection {
9545 DECLARE_CAST(JSWeakMap)
9547 // Dispatched behavior.
9548 DECLARE_PRINTER(JSWeakMap)
9549 DECLARE_VERIFIER(JSWeakMap)
9552 DISALLOW_IMPLICIT_CONSTRUCTORS(JSWeakMap);
9556 // The JSWeakSet describes EcmaScript Harmony weak sets
9557 class JSWeakSet: public JSWeakCollection {
9559 DECLARE_CAST(JSWeakSet)
9561 // Dispatched behavior.
9562 DECLARE_PRINTER(JSWeakSet)
9563 DECLARE_VERIFIER(JSWeakSet)
9566 DISALLOW_IMPLICIT_CONSTRUCTORS(JSWeakSet);
9570 // Whether a JSArrayBuffer is a SharedArrayBuffer or not.
9571 enum class SharedFlag { kNotShared, kShared };
9574 class JSArrayBuffer: public JSObject {
9576 // [backing_store]: backing memory for this array
9577 DECL_ACCESSORS(backing_store, void)
9579 // [byte_length]: length in bytes
9580 DECL_ACCESSORS(byte_length, Object)
9582 inline uint32_t bit_field() const;
9583 inline void set_bit_field(uint32_t bits);
9585 inline bool is_external();
9586 inline void set_is_external(bool value);
9588 inline bool is_neuterable();
9589 inline void set_is_neuterable(bool value);
9591 inline bool was_neutered();
9592 inline void set_was_neutered(bool value);
9594 inline bool is_shared();
9595 inline void set_is_shared(bool value);
9597 DECLARE_CAST(JSArrayBuffer)
9601 static void Setup(Handle<JSArrayBuffer> array_buffer, Isolate* isolate,
9602 bool is_external, void* data, size_t allocated_length,
9603 SharedFlag shared = SharedFlag::kNotShared);
9605 static bool SetupAllocatingData(Handle<JSArrayBuffer> array_buffer,
9606 Isolate* isolate, size_t allocated_length,
9607 bool initialize = true,
9608 SharedFlag shared = SharedFlag::kNotShared);
9610 // Dispatched behavior.
9611 DECLARE_PRINTER(JSArrayBuffer)
9612 DECLARE_VERIFIER(JSArrayBuffer)
9614 static const int kBackingStoreOffset = JSObject::kHeaderSize;
9615 static const int kByteLengthOffset = kBackingStoreOffset + kPointerSize;
9616 static const int kBitFieldSlot = kByteLengthOffset + kPointerSize;
9617 #if V8_TARGET_LITTLE_ENDIAN || !V8_HOST_ARCH_64_BIT
9618 static const int kBitFieldOffset = kBitFieldSlot;
9620 static const int kBitFieldOffset = kBitFieldSlot + kIntSize;
9622 static const int kSize = kBitFieldSlot + kPointerSize;
9624 static const int kSizeWithInternalFields =
9625 kSize + v8::ArrayBuffer::kInternalFieldCount * kPointerSize;
9627 class IsExternal : public BitField<bool, 1, 1> {};
9628 class IsNeuterable : public BitField<bool, 2, 1> {};
9629 class WasNeutered : public BitField<bool, 3, 1> {};
9630 class IsShared : public BitField<bool, 4, 1> {};
9633 DISALLOW_IMPLICIT_CONSTRUCTORS(JSArrayBuffer);
9637 class JSArrayBufferView: public JSObject {
9639 // [buffer]: ArrayBuffer that this typed array views.
9640 DECL_ACCESSORS(buffer, Object)
9642 // [byte_offset]: offset of typed array in bytes.
9643 DECL_ACCESSORS(byte_offset, Object)
9645 // [byte_length]: length of typed array in bytes.
9646 DECL_ACCESSORS(byte_length, Object)
9648 DECLARE_CAST(JSArrayBufferView)
9650 DECLARE_VERIFIER(JSArrayBufferView)
9652 inline bool WasNeutered() const;
9654 static const int kBufferOffset = JSObject::kHeaderSize;
9655 static const int kByteOffsetOffset = kBufferOffset + kPointerSize;
9656 static const int kByteLengthOffset = kByteOffsetOffset + kPointerSize;
9657 static const int kViewSize = kByteLengthOffset + kPointerSize;
9661 DECL_ACCESSORS(raw_byte_offset, Object)
9662 DECL_ACCESSORS(raw_byte_length, Object)
9665 DISALLOW_IMPLICIT_CONSTRUCTORS(JSArrayBufferView);
9669 class JSTypedArray: public JSArrayBufferView {
9671 // [length]: length of typed array in elements.
9672 DECL_ACCESSORS(length, Object)
9673 inline uint32_t length_value() const;
9675 DECLARE_CAST(JSTypedArray)
9677 ExternalArrayType type();
9678 size_t element_size();
9680 Handle<JSArrayBuffer> GetBuffer();
9682 // Dispatched behavior.
9683 DECLARE_PRINTER(JSTypedArray)
9684 DECLARE_VERIFIER(JSTypedArray)
9686 static const int kLengthOffset = kViewSize + kPointerSize;
9687 static const int kSize = kLengthOffset + kPointerSize;
9689 static const int kSizeWithInternalFields =
9690 kSize + v8::ArrayBufferView::kInternalFieldCount * kPointerSize;
9693 static Handle<JSArrayBuffer> MaterializeArrayBuffer(
9694 Handle<JSTypedArray> typed_array);
9696 DECL_ACCESSORS(raw_length, Object)
9699 DISALLOW_IMPLICIT_CONSTRUCTORS(JSTypedArray);
9703 class JSDataView: public JSArrayBufferView {
9705 DECLARE_CAST(JSDataView)
9707 // Dispatched behavior.
9708 DECLARE_PRINTER(JSDataView)
9709 DECLARE_VERIFIER(JSDataView)
9711 static const int kSize = kViewSize;
9713 static const int kSizeWithInternalFields =
9714 kSize + v8::ArrayBufferView::kInternalFieldCount * kPointerSize;
9717 DISALLOW_IMPLICIT_CONSTRUCTORS(JSDataView);
9721 // Foreign describes objects pointing from JavaScript to C structures.
9722 class Foreign: public HeapObject {
9724 // [address]: field containing the address.
9725 inline Address foreign_address();
9726 inline void set_foreign_address(Address value);
9728 DECLARE_CAST(Foreign)
9730 // Dispatched behavior.
9731 inline void ForeignIterateBody(ObjectVisitor* v);
9733 template<typename StaticVisitor>
9734 inline void ForeignIterateBody();
9736 // Dispatched behavior.
9737 DECLARE_PRINTER(Foreign)
9738 DECLARE_VERIFIER(Foreign)
9740 // Layout description.
9742 static const int kForeignAddressOffset = HeapObject::kHeaderSize;
9743 static const int kSize = kForeignAddressOffset + kPointerSize;
9745 STATIC_ASSERT(kForeignAddressOffset == Internals::kForeignAddressOffset);
9748 DISALLOW_IMPLICIT_CONSTRUCTORS(Foreign);
9752 // The JSArray describes JavaScript Arrays
9753 // Such an array can be in one of two modes:
9754 // - fast, backing storage is a FixedArray and length <= elements.length();
9755 // Please note: push and pop can be used to grow and shrink the array.
9756 // - slow, backing storage is a HashTable with numbers as keys.
9757 class JSArray: public JSObject {
9759 // [length]: The length property.
9760 DECL_ACCESSORS(length, Object)
9762 // Overload the length setter to skip write barrier when the length
9763 // is set to a smi. This matches the set function on FixedArray.
9764 inline void set_length(Smi* length);
9766 static bool HasReadOnlyLength(Handle<JSArray> array);
9767 static bool WouldChangeReadOnlyLength(Handle<JSArray> array, uint32_t index);
9768 static MaybeHandle<Object> ReadOnlyLengthError(Handle<JSArray> array);
9770 // Initialize the array with the given capacity. The function may
9771 // fail due to out-of-memory situations, but only if the requested
9772 // capacity is non-zero.
9773 static void Initialize(Handle<JSArray> array, int capacity, int length = 0);
9775 // If the JSArray has fast elements, and new_length would result in
9776 // normalization, returns true.
9777 bool SetLengthWouldNormalize(uint32_t new_length);
9778 static inline bool SetLengthWouldNormalize(Heap* heap, uint32_t new_length);
9780 // Initializes the array to a certain length.
9781 inline bool AllowsSetLength();
9783 static void SetLength(Handle<JSArray> array, uint32_t length);
9784 // Same as above but will also queue splice records if |array| is observed.
9785 static MaybeHandle<Object> ObservableSetLength(Handle<JSArray> array,
9788 // Set the content of the array to the content of storage.
9789 static inline void SetContent(Handle<JSArray> array,
9790 Handle<FixedArrayBase> storage);
9792 DECLARE_CAST(JSArray)
9794 // Dispatched behavior.
9795 DECLARE_PRINTER(JSArray)
9796 DECLARE_VERIFIER(JSArray)
9798 // Number of element slots to pre-allocate for an empty array.
9799 static const int kPreallocatedArrayElements = 4;
9801 // Layout description.
9802 static const int kLengthOffset = JSObject::kHeaderSize;
9803 static const int kSize = kLengthOffset + kPointerSize;
9806 DISALLOW_IMPLICIT_CONSTRUCTORS(JSArray);
9810 Handle<Object> CacheInitialJSArrayMaps(Handle<Context> native_context,
9811 Handle<Map> initial_map);
9814 // JSRegExpResult is just a JSArray with a specific initial map.
9815 // This initial map adds in-object properties for "index" and "input"
9816 // properties, as assigned by RegExp.prototype.exec, which allows
9817 // faster creation of RegExp exec results.
9818 // This class just holds constants used when creating the result.
9819 // After creation the result must be treated as a JSArray in all regards.
9820 class JSRegExpResult: public JSArray {
9822 // Offsets of object fields.
9823 static const int kIndexOffset = JSArray::kSize;
9824 static const int kInputOffset = kIndexOffset + kPointerSize;
9825 static const int kSize = kInputOffset + kPointerSize;
9826 // Indices of in-object properties.
9827 static const int kIndexIndex = 0;
9828 static const int kInputIndex = 1;
9830 DISALLOW_IMPLICIT_CONSTRUCTORS(JSRegExpResult);
9834 class AccessorInfo: public Struct {
9836 DECL_ACCESSORS(name, Object)
9837 DECL_ACCESSORS(flag, Smi)
9838 DECL_ACCESSORS(expected_receiver_type, Object)
9840 inline bool all_can_read();
9841 inline void set_all_can_read(bool value);
9843 inline bool all_can_write();
9844 inline void set_all_can_write(bool value);
9846 inline bool is_special_data_property();
9847 inline void set_is_special_data_property(bool value);
9849 inline PropertyAttributes property_attributes();
9850 inline void set_property_attributes(PropertyAttributes attributes);
9852 // Checks whether the given receiver is compatible with this accessor.
9853 static bool IsCompatibleReceiverMap(Isolate* isolate,
9854 Handle<AccessorInfo> info,
9856 inline bool IsCompatibleReceiver(Object* receiver);
9858 DECLARE_CAST(AccessorInfo)
9860 // Dispatched behavior.
9861 DECLARE_VERIFIER(AccessorInfo)
9863 // Append all descriptors to the array that are not already there.
9864 // Return number added.
9865 static int AppendUnique(Handle<Object> descriptors,
9866 Handle<FixedArray> array,
9867 int valid_descriptors);
9869 static const int kNameOffset = HeapObject::kHeaderSize;
9870 static const int kFlagOffset = kNameOffset + kPointerSize;
9871 static const int kExpectedReceiverTypeOffset = kFlagOffset + kPointerSize;
9872 static const int kSize = kExpectedReceiverTypeOffset + kPointerSize;
9875 inline bool HasExpectedReceiverType();
9877 // Bit positions in flag.
9878 static const int kAllCanReadBit = 0;
9879 static const int kAllCanWriteBit = 1;
9880 static const int kSpecialDataProperty = 2;
9881 class AttributesField : public BitField<PropertyAttributes, 3, 3> {};
9883 DISALLOW_IMPLICIT_CONSTRUCTORS(AccessorInfo);
9887 // An accessor must have a getter, but can have no setter.
9889 // When setting a property, V8 searches accessors in prototypes.
9890 // If an accessor was found and it does not have a setter,
9891 // the request is ignored.
9893 // If the accessor in the prototype has the READ_ONLY property attribute, then
9894 // a new value is added to the derived object when the property is set.
9895 // This shadows the accessor in the prototype.
9896 class ExecutableAccessorInfo: public AccessorInfo {
9898 DECL_ACCESSORS(getter, Object)
9899 DECL_ACCESSORS(setter, Object)
9900 DECL_ACCESSORS(data, Object)
9902 DECLARE_CAST(ExecutableAccessorInfo)
9904 // Dispatched behavior.
9905 DECLARE_PRINTER(ExecutableAccessorInfo)
9906 DECLARE_VERIFIER(ExecutableAccessorInfo)
9908 static const int kGetterOffset = AccessorInfo::kSize;
9909 static const int kSetterOffset = kGetterOffset + kPointerSize;
9910 static const int kDataOffset = kSetterOffset + kPointerSize;
9911 static const int kSize = kDataOffset + kPointerSize;
9913 static void ClearSetter(Handle<ExecutableAccessorInfo> info);
9916 DISALLOW_IMPLICIT_CONSTRUCTORS(ExecutableAccessorInfo);
9920 // Support for JavaScript accessors: A pair of a getter and a setter. Each
9921 // accessor can either be
9922 // * a pointer to a JavaScript function or proxy: a real accessor
9923 // * undefined: considered an accessor by the spec, too, strangely enough
9924 // * the hole: an accessor which has not been set
9925 // * a pointer to a map: a transition used to ensure map sharing
9926 class AccessorPair: public Struct {
9928 DECL_ACCESSORS(getter, Object)
9929 DECL_ACCESSORS(setter, Object)
9931 DECLARE_CAST(AccessorPair)
9933 static Handle<AccessorPair> Copy(Handle<AccessorPair> pair);
9935 inline Object* get(AccessorComponent component);
9936 inline void set(AccessorComponent component, Object* value);
9938 // Note: Returns undefined instead in case of a hole.
9939 Object* GetComponent(AccessorComponent component);
9941 // Set both components, skipping arguments which are a JavaScript null.
9942 inline void SetComponents(Object* getter, Object* setter);
9944 inline bool Equals(AccessorPair* pair);
9945 inline bool Equals(Object* getter_value, Object* setter_value);
9947 inline bool ContainsAccessor();
9949 // Dispatched behavior.
9950 DECLARE_PRINTER(AccessorPair)
9951 DECLARE_VERIFIER(AccessorPair)
9953 static const int kGetterOffset = HeapObject::kHeaderSize;
9954 static const int kSetterOffset = kGetterOffset + kPointerSize;
9955 static const int kSize = kSetterOffset + kPointerSize;
9958 // Strangely enough, in addition to functions and harmony proxies, the spec
9959 // requires us to consider undefined as a kind of accessor, too:
9961 // Object.defineProperty(obj, "foo", {get: undefined});
9962 // assertTrue("foo" in obj);
9963 inline bool IsJSAccessor(Object* obj);
9965 DISALLOW_IMPLICIT_CONSTRUCTORS(AccessorPair);
9969 class AccessCheckInfo: public Struct {
9971 DECL_ACCESSORS(named_callback, Object)
9972 DECL_ACCESSORS(indexed_callback, Object)
9973 DECL_ACCESSORS(data, Object)
9975 DECLARE_CAST(AccessCheckInfo)
9977 // Dispatched behavior.
9978 DECLARE_PRINTER(AccessCheckInfo)
9979 DECLARE_VERIFIER(AccessCheckInfo)
9981 static const int kNamedCallbackOffset = HeapObject::kHeaderSize;
9982 static const int kIndexedCallbackOffset = kNamedCallbackOffset + kPointerSize;
9983 static const int kDataOffset = kIndexedCallbackOffset + kPointerSize;
9984 static const int kSize = kDataOffset + kPointerSize;
9987 DISALLOW_IMPLICIT_CONSTRUCTORS(AccessCheckInfo);
9991 class InterceptorInfo: public Struct {
9993 DECL_ACCESSORS(getter, Object)
9994 DECL_ACCESSORS(setter, Object)
9995 DECL_ACCESSORS(query, Object)
9996 DECL_ACCESSORS(deleter, Object)
9997 DECL_ACCESSORS(enumerator, Object)
9998 DECL_ACCESSORS(data, Object)
9999 DECL_BOOLEAN_ACCESSORS(can_intercept_symbols)
10000 DECL_BOOLEAN_ACCESSORS(all_can_read)
10001 DECL_BOOLEAN_ACCESSORS(non_masking)
10003 inline int flags() const;
10004 inline void set_flags(int flags);
10006 DECLARE_CAST(InterceptorInfo)
10008 // Dispatched behavior.
10009 DECLARE_PRINTER(InterceptorInfo)
10010 DECLARE_VERIFIER(InterceptorInfo)
10012 static const int kGetterOffset = HeapObject::kHeaderSize;
10013 static const int kSetterOffset = kGetterOffset + kPointerSize;
10014 static const int kQueryOffset = kSetterOffset + kPointerSize;
10015 static const int kDeleterOffset = kQueryOffset + kPointerSize;
10016 static const int kEnumeratorOffset = kDeleterOffset + kPointerSize;
10017 static const int kDataOffset = kEnumeratorOffset + kPointerSize;
10018 static const int kFlagsOffset = kDataOffset + kPointerSize;
10019 static const int kSize = kFlagsOffset + kPointerSize;
10021 static const int kCanInterceptSymbolsBit = 0;
10022 static const int kAllCanReadBit = 1;
10023 static const int kNonMasking = 2;
10026 DISALLOW_IMPLICIT_CONSTRUCTORS(InterceptorInfo);
10030 class CallHandlerInfo: public Struct {
10032 DECL_ACCESSORS(callback, Object)
10033 DECL_ACCESSORS(data, Object)
10035 DECLARE_CAST(CallHandlerInfo)
10037 // Dispatched behavior.
10038 DECLARE_PRINTER(CallHandlerInfo)
10039 DECLARE_VERIFIER(CallHandlerInfo)
10041 static const int kCallbackOffset = HeapObject::kHeaderSize;
10042 static const int kDataOffset = kCallbackOffset + kPointerSize;
10043 static const int kSize = kDataOffset + kPointerSize;
10046 DISALLOW_IMPLICIT_CONSTRUCTORS(CallHandlerInfo);
10050 class TemplateInfo: public Struct {
10052 DECL_ACCESSORS(tag, Object)
10053 inline int number_of_properties() const;
10054 inline void set_number_of_properties(int value);
10055 DECL_ACCESSORS(property_list, Object)
10056 DECL_ACCESSORS(property_accessors, Object)
10058 DECLARE_VERIFIER(TemplateInfo)
10060 static const int kTagOffset = HeapObject::kHeaderSize;
10061 static const int kNumberOfProperties = kTagOffset + kPointerSize;
10062 static const int kPropertyListOffset = kNumberOfProperties + kPointerSize;
10063 static const int kPropertyAccessorsOffset =
10064 kPropertyListOffset + kPointerSize;
10065 static const int kHeaderSize = kPropertyAccessorsOffset + kPointerSize;
10068 DISALLOW_IMPLICIT_CONSTRUCTORS(TemplateInfo);
10072 class FunctionTemplateInfo: public TemplateInfo {
10074 DECL_ACCESSORS(serial_number, Object)
10075 DECL_ACCESSORS(call_code, Object)
10076 DECL_ACCESSORS(prototype_template, Object)
10077 DECL_ACCESSORS(parent_template, Object)
10078 DECL_ACCESSORS(named_property_handler, Object)
10079 DECL_ACCESSORS(indexed_property_handler, Object)
10080 DECL_ACCESSORS(instance_template, Object)
10081 DECL_ACCESSORS(class_name, Object)
10082 DECL_ACCESSORS(signature, Object)
10083 DECL_ACCESSORS(instance_call_handler, Object)
10084 DECL_ACCESSORS(access_check_info, Object)
10085 DECL_ACCESSORS(flag, Smi)
10087 inline int length() const;
10088 inline void set_length(int value);
10090 // Following properties use flag bits.
10091 DECL_BOOLEAN_ACCESSORS(hidden_prototype)
10092 DECL_BOOLEAN_ACCESSORS(undetectable)
10093 // If the bit is set, object instances created by this function
10094 // requires access check.
10095 DECL_BOOLEAN_ACCESSORS(needs_access_check)
10096 DECL_BOOLEAN_ACCESSORS(read_only_prototype)
10097 DECL_BOOLEAN_ACCESSORS(remove_prototype)
10098 DECL_BOOLEAN_ACCESSORS(do_not_cache)
10099 DECL_BOOLEAN_ACCESSORS(instantiated)
10100 DECL_BOOLEAN_ACCESSORS(accept_any_receiver)
10102 DECLARE_CAST(FunctionTemplateInfo)
10104 // Dispatched behavior.
10105 DECLARE_PRINTER(FunctionTemplateInfo)
10106 DECLARE_VERIFIER(FunctionTemplateInfo)
10108 static const int kSerialNumberOffset = TemplateInfo::kHeaderSize;
10109 static const int kCallCodeOffset = kSerialNumberOffset + kPointerSize;
10110 static const int kPrototypeTemplateOffset =
10111 kCallCodeOffset + kPointerSize;
10112 static const int kParentTemplateOffset =
10113 kPrototypeTemplateOffset + kPointerSize;
10114 static const int kNamedPropertyHandlerOffset =
10115 kParentTemplateOffset + kPointerSize;
10116 static const int kIndexedPropertyHandlerOffset =
10117 kNamedPropertyHandlerOffset + kPointerSize;
10118 static const int kInstanceTemplateOffset =
10119 kIndexedPropertyHandlerOffset + kPointerSize;
10120 static const int kClassNameOffset = kInstanceTemplateOffset + kPointerSize;
10121 static const int kSignatureOffset = kClassNameOffset + kPointerSize;
10122 static const int kInstanceCallHandlerOffset = kSignatureOffset + kPointerSize;
10123 static const int kAccessCheckInfoOffset =
10124 kInstanceCallHandlerOffset + kPointerSize;
10125 static const int kFlagOffset = kAccessCheckInfoOffset + kPointerSize;
10126 static const int kLengthOffset = kFlagOffset + kPointerSize;
10127 static const int kSize = kLengthOffset + kPointerSize;
10129 // Returns true if |object| is an instance of this function template.
10130 bool IsTemplateFor(Object* object);
10131 bool IsTemplateFor(Map* map);
10133 // Returns the holder JSObject if the function can legally be called with this
10134 // receiver. Returns Heap::null_value() if the call is illegal.
10135 Object* GetCompatibleReceiver(Isolate* isolate, Object* receiver);
10138 // Bit position in the flag, from least significant bit position.
10139 static const int kHiddenPrototypeBit = 0;
10140 static const int kUndetectableBit = 1;
10141 static const int kNeedsAccessCheckBit = 2;
10142 static const int kReadOnlyPrototypeBit = 3;
10143 static const int kRemovePrototypeBit = 4;
10144 static const int kDoNotCacheBit = 5;
10145 static const int kInstantiatedBit = 6;
10146 static const int kAcceptAnyReceiver = 7;
10148 DISALLOW_IMPLICIT_CONSTRUCTORS(FunctionTemplateInfo);
10152 class ObjectTemplateInfo: public TemplateInfo {
10154 DECL_ACCESSORS(constructor, Object)
10155 DECL_ACCESSORS(internal_field_count, Object)
10157 DECLARE_CAST(ObjectTemplateInfo)
10159 // Dispatched behavior.
10160 DECLARE_PRINTER(ObjectTemplateInfo)
10161 DECLARE_VERIFIER(ObjectTemplateInfo)
10163 static const int kConstructorOffset = TemplateInfo::kHeaderSize;
10164 static const int kInternalFieldCountOffset =
10165 kConstructorOffset + kPointerSize;
10166 static const int kSize = kInternalFieldCountOffset + kPointerSize;
10170 class TypeSwitchInfo: public Struct {
10172 DECL_ACCESSORS(types, Object)
10174 DECLARE_CAST(TypeSwitchInfo)
10176 // Dispatched behavior.
10177 DECLARE_PRINTER(TypeSwitchInfo)
10178 DECLARE_VERIFIER(TypeSwitchInfo)
10180 static const int kTypesOffset = Struct::kHeaderSize;
10181 static const int kSize = kTypesOffset + kPointerSize;
10185 // The DebugInfo class holds additional information for a function being
10187 class DebugInfo: public Struct {
10189 // The shared function info for the source being debugged.
10190 DECL_ACCESSORS(shared, SharedFunctionInfo)
10191 // Code object for the patched code. This code object is the code object
10192 // currently active for the function.
10193 DECL_ACCESSORS(code, Code)
10194 // Fixed array holding status information for each active break point.
10195 DECL_ACCESSORS(break_points, FixedArray)
10197 // Check if there is a break point at a code position.
10198 bool HasBreakPoint(int code_position);
10199 // Get the break point info object for a code position.
10200 Object* GetBreakPointInfo(int code_position);
10201 // Clear a break point.
10202 static void ClearBreakPoint(Handle<DebugInfo> debug_info,
10204 Handle<Object> break_point_object);
10205 // Set a break point.
10206 static void SetBreakPoint(Handle<DebugInfo> debug_info, int code_position,
10207 int source_position, int statement_position,
10208 Handle<Object> break_point_object);
10209 // Get the break point objects for a code position.
10210 Handle<Object> GetBreakPointObjects(int code_position);
10211 // Find the break point info holding this break point object.
10212 static Handle<Object> FindBreakPointInfo(Handle<DebugInfo> debug_info,
10213 Handle<Object> break_point_object);
10214 // Get the number of break points for this function.
10215 int GetBreakPointCount();
10217 DECLARE_CAST(DebugInfo)
10219 // Dispatched behavior.
10220 DECLARE_PRINTER(DebugInfo)
10221 DECLARE_VERIFIER(DebugInfo)
10223 static const int kSharedFunctionInfoIndex = Struct::kHeaderSize;
10224 static const int kCodeIndex = kSharedFunctionInfoIndex + kPointerSize;
10225 static const int kBreakPointsStateIndex = kCodeIndex + kPointerSize;
10226 static const int kSize = kBreakPointsStateIndex + kPointerSize;
10228 static const int kEstimatedNofBreakPointsInFunction = 16;
10231 static const int kNoBreakPointInfo = -1;
10233 // Lookup the index in the break_points array for a code position.
10234 int GetBreakPointInfoIndex(int code_position);
10236 DISALLOW_IMPLICIT_CONSTRUCTORS(DebugInfo);
10240 // The BreakPointInfo class holds information for break points set in a
10241 // function. The DebugInfo object holds a BreakPointInfo object for each code
10242 // position with one or more break points.
10243 class BreakPointInfo: public Struct {
10245 // The position in the code for the break point.
10246 DECL_ACCESSORS(code_position, Smi)
10247 // The position in the source for the break position.
10248 DECL_ACCESSORS(source_position, Smi)
10249 // The position in the source for the last statement before this break
10251 DECL_ACCESSORS(statement_position, Smi)
10252 // List of related JavaScript break points.
10253 DECL_ACCESSORS(break_point_objects, Object)
10255 // Removes a break point.
10256 static void ClearBreakPoint(Handle<BreakPointInfo> info,
10257 Handle<Object> break_point_object);
10258 // Set a break point.
10259 static void SetBreakPoint(Handle<BreakPointInfo> info,
10260 Handle<Object> break_point_object);
10261 // Check if break point info has this break point object.
10262 static bool HasBreakPointObject(Handle<BreakPointInfo> info,
10263 Handle<Object> break_point_object);
10264 // Get the number of break points for this code position.
10265 int GetBreakPointCount();
10267 DECLARE_CAST(BreakPointInfo)
10269 // Dispatched behavior.
10270 DECLARE_PRINTER(BreakPointInfo)
10271 DECLARE_VERIFIER(BreakPointInfo)
10273 static const int kCodePositionIndex = Struct::kHeaderSize;
10274 static const int kSourcePositionIndex = kCodePositionIndex + kPointerSize;
10275 static const int kStatementPositionIndex =
10276 kSourcePositionIndex + kPointerSize;
10277 static const int kBreakPointObjectsIndex =
10278 kStatementPositionIndex + kPointerSize;
10279 static const int kSize = kBreakPointObjectsIndex + kPointerSize;
10282 DISALLOW_IMPLICIT_CONSTRUCTORS(BreakPointInfo);
10286 #undef DECL_BOOLEAN_ACCESSORS
10287 #undef DECL_ACCESSORS
10288 #undef DECLARE_CAST
10289 #undef DECLARE_VERIFIER
10291 #define VISITOR_SYNCHRONIZATION_TAGS_LIST(V) \
10292 V(kStringTable, "string_table", "(Internalized strings)") \
10293 V(kExternalStringsTable, "external_strings_table", "(External strings)") \
10294 V(kStrongRootList, "strong_root_list", "(Strong roots)") \
10295 V(kSmiRootList, "smi_root_list", "(Smi roots)") \
10296 V(kBootstrapper, "bootstrapper", "(Bootstrapper)") \
10297 V(kTop, "top", "(Isolate)") \
10298 V(kRelocatable, "relocatable", "(Relocatable)") \
10299 V(kDebug, "debug", "(Debugger)") \
10300 V(kCompilationCache, "compilationcache", "(Compilation cache)") \
10301 V(kHandleScope, "handlescope", "(Handle scope)") \
10302 V(kBuiltins, "builtins", "(Builtins)") \
10303 V(kGlobalHandles, "globalhandles", "(Global handles)") \
10304 V(kEternalHandles, "eternalhandles", "(Eternal handles)") \
10305 V(kThreadManager, "threadmanager", "(Thread manager)") \
10306 V(kStrongRoots, "strong roots", "(Strong roots)") \
10307 V(kExtensions, "Extensions", "(Extensions)")
10309 class VisitorSynchronization : public AllStatic {
10311 #define DECLARE_ENUM(enum_item, ignore1, ignore2) enum_item,
10313 VISITOR_SYNCHRONIZATION_TAGS_LIST(DECLARE_ENUM)
10316 #undef DECLARE_ENUM
10318 static const char* const kTags[kNumberOfSyncTags];
10319 static const char* const kTagNames[kNumberOfSyncTags];
10322 // Abstract base class for visiting, and optionally modifying, the
10323 // pointers contained in Objects. Used in GC and serialization/deserialization.
10324 class ObjectVisitor BASE_EMBEDDED {
10326 virtual ~ObjectVisitor() {}
10328 // Visits a contiguous arrays of pointers in the half-open range
10329 // [start, end). Any or all of the values may be modified on return.
10330 virtual void VisitPointers(Object** start, Object** end) = 0;
10332 // Handy shorthand for visiting a single pointer.
10333 virtual void VisitPointer(Object** p) { VisitPointers(p, p + 1); }
10335 // Visit weak next_code_link in Code object.
10336 virtual void VisitNextCodeLink(Object** p) { VisitPointers(p, p + 1); }
10338 // To allow lazy clearing of inline caches the visitor has
10339 // a rich interface for iterating over Code objects..
10341 // Visits a code target in the instruction stream.
10342 virtual void VisitCodeTarget(RelocInfo* rinfo);
10344 // Visits a code entry in a JS function.
10345 virtual void VisitCodeEntry(Address entry_address);
10347 // Visits a global property cell reference in the instruction stream.
10348 virtual void VisitCell(RelocInfo* rinfo);
10350 // Visits a runtime entry in the instruction stream.
10351 virtual void VisitRuntimeEntry(RelocInfo* rinfo) {}
10353 // Visits the resource of an one-byte or two-byte string.
10354 virtual void VisitExternalOneByteString(
10355 v8::String::ExternalOneByteStringResource** resource) {}
10356 virtual void VisitExternalTwoByteString(
10357 v8::String::ExternalStringResource** resource) {}
10359 // Visits a debug call target in the instruction stream.
10360 virtual void VisitDebugTarget(RelocInfo* rinfo);
10362 // Visits the byte sequence in a function's prologue that contains information
10363 // about the code's age.
10364 virtual void VisitCodeAgeSequence(RelocInfo* rinfo);
10366 // Visit pointer embedded into a code object.
10367 virtual void VisitEmbeddedPointer(RelocInfo* rinfo);
10369 // Visits an external reference embedded into a code object.
10370 virtual void VisitExternalReference(RelocInfo* rinfo);
10372 // Visits an external reference.
10373 virtual void VisitExternalReference(Address* p) {}
10375 // Visits an (encoded) internal reference.
10376 virtual void VisitInternalReference(RelocInfo* rinfo) {}
10378 // Visits a handle that has an embedder-assigned class ID.
10379 virtual void VisitEmbedderReference(Object** p, uint16_t class_id) {}
10381 // Intended for serialization/deserialization checking: insert, or
10382 // check for the presence of, a tag at this position in the stream.
10383 // Also used for marking up GC roots in heap snapshots.
10384 virtual void Synchronize(VisitorSynchronization::SyncTag tag) {}
10388 class StructBodyDescriptor : public
10389 FlexibleBodyDescriptor<HeapObject::kHeaderSize> {
10391 static inline int SizeOf(Map* map, HeapObject* object);
10395 // BooleanBit is a helper class for setting and getting a bit in an
10397 class BooleanBit : public AllStatic {
10399 static inline bool get(Smi* smi, int bit_position) {
10400 return get(smi->value(), bit_position);
10403 static inline bool get(int value, int bit_position) {
10404 return (value & (1 << bit_position)) != 0;
10407 static inline Smi* set(Smi* smi, int bit_position, bool v) {
10408 return Smi::FromInt(set(smi->value(), bit_position, v));
10411 static inline int set(int value, int bit_position, bool v) {
10413 value |= (1 << bit_position);
10415 value &= ~(1 << bit_position);
10421 } } // namespace v8::internal
10423 #endif // V8_OBJECTS_H_