diff options
Diffstat (limited to 'deps/v8/src/objects')
101 files changed, 1393 insertions, 1569 deletions
diff --git a/deps/v8/src/objects/OWNERS b/deps/v8/src/objects/OWNERS index 450423f878..f52e1c9ca8 100644 --- a/deps/v8/src/objects/OWNERS +++ b/deps/v8/src/objects/OWNERS @@ -1,3 +1,3 @@ -file://COMMON_OWNERS +file:../../COMMON_OWNERS # COMPONENT: Blink>JavaScript>Runtime diff --git a/deps/v8/src/objects/allocation-site.h b/deps/v8/src/objects/allocation-site.h index 9289a83f70..c1b6417ae1 100644 --- a/deps/v8/src/objects/allocation-site.h +++ b/deps/v8/src/objects/allocation-site.h @@ -66,14 +66,14 @@ class AllocationSite : public Struct { bool IsNested(); // transition_info bitfields, for constructed array transition info. - class ElementsKindBits : public BitField<ElementsKind, 0, 5> {}; - class DoNotInlineBit : public BitField<bool, 5, 1> {}; + using ElementsKindBits = BitField<ElementsKind, 0, 5>; + using DoNotInlineBit = BitField<bool, 5, 1>; // Unused bits 6-30. // Bitfields for pretenure_data - class MementoFoundCountBits : public BitField<int, 0, 26> {}; - class PretenureDecisionBits : public BitField<PretenureDecision, 26, 3> {}; - class DeoptDependentCodeBit : public BitField<bool, 29, 1> {}; + using MementoFoundCountBits = BitField<int, 0, 26>; + using PretenureDecisionBits = BitField<PretenureDecision, 26, 3>; + using DeoptDependentCodeBit = BitField<bool, 29, 1>; STATIC_ASSERT(PretenureDecisionBits::kMax >= kLastPretenureDecisionValue); // Increments the mementos found counter and returns true when the first diff --git a/deps/v8/src/objects/api-callbacks-inl.h b/deps/v8/src/objects/api-callbacks-inl.h index c327a35746..d0698d13a1 100644 --- a/deps/v8/src/objects/api-callbacks-inl.h +++ b/deps/v8/src/objects/api-callbacks-inl.h @@ -21,15 +21,13 @@ namespace v8 { namespace internal { -OBJECT_CONSTRUCTORS_IMPL(AccessCheckInfo, Struct) +TQ_OBJECT_CONSTRUCTORS_IMPL(AccessCheckInfo) OBJECT_CONSTRUCTORS_IMPL(AccessorInfo, Struct) -OBJECT_CONSTRUCTORS_IMPL(InterceptorInfo, Struct) +TQ_OBJECT_CONSTRUCTORS_IMPL(InterceptorInfo) TQ_OBJECT_CONSTRUCTORS_IMPL(CallHandlerInfo) CAST_ACCESSOR(AccessorInfo) -CAST_ACCESSOR(AccessCheckInfo) -CAST_ACCESSOR(InterceptorInfo) ACCESSORS(AccessorInfo, name, Name, kNameOffset) SMI_ACCESSORS(AccessorInfo, flags, kFlagsOffset) @@ -98,21 +96,7 @@ bool AccessorInfo::HasExpectedReceiverType() { return expected_receiver_type().IsFunctionTemplateInfo(); } -ACCESSORS(AccessCheckInfo, callback, Object, kCallbackOffset) -ACCESSORS(AccessCheckInfo, named_interceptor, Object, kNamedInterceptorOffset) -ACCESSORS(AccessCheckInfo, indexed_interceptor, Object, - kIndexedInterceptorOffset) -ACCESSORS(AccessCheckInfo, data, Object, kDataOffset) - -ACCESSORS(InterceptorInfo, getter, Object, kGetterOffset) -ACCESSORS(InterceptorInfo, setter, Object, kSetterOffset) -ACCESSORS(InterceptorInfo, query, Object, kQueryOffset) -ACCESSORS(InterceptorInfo, descriptor, Object, kDescriptorOffset) -ACCESSORS(InterceptorInfo, deleter, Object, kDeleterOffset) -ACCESSORS(InterceptorInfo, enumerator, Object, kEnumeratorOffset) -ACCESSORS(InterceptorInfo, definer, Object, kDefinerOffset) -ACCESSORS(InterceptorInfo, data, Object, kDataOffset) -SMI_ACCESSORS(InterceptorInfo, flags, kFlagsOffset) +TQ_SMI_ACCESSORS(InterceptorInfo, flags) BOOL_ACCESSORS(InterceptorInfo, flags, can_intercept_symbols, kCanInterceptSymbolsBit) BOOL_ACCESSORS(InterceptorInfo, flags, all_can_read, kAllCanReadBit) diff --git a/deps/v8/src/objects/api-callbacks.h b/deps/v8/src/objects/api-callbacks.h index 518339f7d4..72be5deb8f 100644 --- a/deps/v8/src/objects/api-callbacks.h +++ b/deps/v8/src/objects/api-callbacks.h @@ -102,37 +102,20 @@ class AccessorInfo : public Struct { OBJECT_CONSTRUCTORS(AccessorInfo, Struct); }; -class AccessCheckInfo : public Struct { +class AccessCheckInfo + : public TorqueGeneratedAccessCheckInfo<AccessCheckInfo, Struct> { public: - DECL_ACCESSORS(callback, Object) - DECL_ACCESSORS(named_interceptor, Object) - DECL_ACCESSORS(indexed_interceptor, Object) - DECL_ACCESSORS(data, Object) - - DECL_CAST(AccessCheckInfo) - // Dispatched behavior. DECL_PRINTER(AccessCheckInfo) - DECL_VERIFIER(AccessCheckInfo) static AccessCheckInfo Get(Isolate* isolate, Handle<JSObject> receiver); - DEFINE_FIELD_OFFSET_CONSTANTS(HeapObject::kHeaderSize, - TORQUE_GENERATED_ACCESS_CHECK_INFO_FIELDS) - - OBJECT_CONSTRUCTORS(AccessCheckInfo, Struct); + TQ_OBJECT_CONSTRUCTORS(AccessCheckInfo) }; -class InterceptorInfo : public Struct { +class InterceptorInfo + : public TorqueGeneratedInterceptorInfo<InterceptorInfo, Struct> { public: - DECL_ACCESSORS(getter, Object) - DECL_ACCESSORS(setter, Object) - DECL_ACCESSORS(query, Object) - DECL_ACCESSORS(descriptor, Object) - DECL_ACCESSORS(deleter, Object) - DECL_ACCESSORS(enumerator, Object) - DECL_ACCESSORS(definer, Object) - DECL_ACCESSORS(data, Object) DECL_BOOLEAN_ACCESSORS(can_intercept_symbols) DECL_BOOLEAN_ACCESSORS(all_can_read) DECL_BOOLEAN_ACCESSORS(non_masking) @@ -142,14 +125,8 @@ class InterceptorInfo : public Struct { inline int flags() const; inline void set_flags(int flags); - DECL_CAST(InterceptorInfo) - // Dispatched behavior. DECL_PRINTER(InterceptorInfo) - DECL_VERIFIER(InterceptorInfo) - - DEFINE_FIELD_OFFSET_CONSTANTS(HeapObject::kHeaderSize, - TORQUE_GENERATED_INTERCEPTOR_INFO_FIELDS) static const int kCanInterceptSymbolsBit = 0; static const int kAllCanReadBit = 1; @@ -157,7 +134,7 @@ class InterceptorInfo : public Struct { static const int kNamed = 3; static const int kHasNoSideEffect = 4; - OBJECT_CONSTRUCTORS(InterceptorInfo, Struct); + TQ_OBJECT_CONSTRUCTORS(InterceptorInfo) }; class CallHandlerInfo diff --git a/deps/v8/src/objects/arguments-inl.h b/deps/v8/src/objects/arguments-inl.h index 2931c5b0a0..3de88d6a9b 100644 --- a/deps/v8/src/objects/arguments-inl.h +++ b/deps/v8/src/objects/arguments-inl.h @@ -19,15 +19,12 @@ namespace v8 { namespace internal { OBJECT_CONSTRUCTORS_IMPL(SloppyArgumentsElements, FixedArray) -OBJECT_CONSTRUCTORS_IMPL(JSArgumentsObject, JSObject) -OBJECT_CONSTRUCTORS_IMPL(AliasedArgumentsEntry, Struct) +TQ_OBJECT_CONSTRUCTORS_IMPL(JSArgumentsObject) +TQ_OBJECT_CONSTRUCTORS_IMPL(AliasedArgumentsEntry) -CAST_ACCESSOR(AliasedArgumentsEntry) CAST_ACCESSOR(SloppyArgumentsElements) -CAST_ACCESSOR(JSArgumentsObject) -SMI_ACCESSORS(AliasedArgumentsEntry, aliased_context_slot, - kAliasedContextSlotOffset) +TQ_SMI_ACCESSORS(AliasedArgumentsEntry, aliased_context_slot) DEF_GETTER(SloppyArgumentsElements, context, Context) { return TaggedField<Context>::load(isolate, *this, diff --git a/deps/v8/src/objects/arguments.h b/deps/v8/src/objects/arguments.h index 79d2e604bd..a306ef592a 100644 --- a/deps/v8/src/objects/arguments.h +++ b/deps/v8/src/objects/arguments.h @@ -17,11 +17,11 @@ namespace v8 { namespace internal { // Superclass for all objects with instance type {JS_ARGUMENTS_TYPE} -class JSArgumentsObject : public JSObject { +class JSArgumentsObject + : public TorqueGeneratedJSArgumentsObject<JSArgumentsObject, JSObject> { public: DECL_VERIFIER(JSArgumentsObject) - DECL_CAST(JSArgumentsObject) - OBJECT_CONSTRUCTORS(JSArgumentsObject, JSObject); + TQ_OBJECT_CONSTRUCTORS(JSArgumentsObject) }; // Common superclass for JSSloppyArgumentsObject and JSStrictArgumentsObject. @@ -125,21 +125,17 @@ class SloppyArgumentsElements : public FixedArray { // - the parameter map contains no fast alias mapping (i.e. the hole) // - this struct (in the slow backing store) contains an index into the context // - all attributes are available as part if the property details -class AliasedArgumentsEntry : public Struct { +class AliasedArgumentsEntry + : public TorqueGeneratedAliasedArgumentsEntry<AliasedArgumentsEntry, + Struct> { public: inline int aliased_context_slot() const; inline void set_aliased_context_slot(int count); - DECL_CAST(AliasedArgumentsEntry) - // Dispatched behavior. DECL_PRINTER(AliasedArgumentsEntry) - DECL_VERIFIER(AliasedArgumentsEntry) - - DEFINE_FIELD_OFFSET_CONSTANTS(HeapObject::kHeaderSize, - TORQUE_GENERATED_ALIASED_ARGUMENTS_ENTRY_FIELDS) - OBJECT_CONSTRUCTORS(AliasedArgumentsEntry, Struct); + TQ_OBJECT_CONSTRUCTORS(AliasedArgumentsEntry) }; } // namespace internal diff --git a/deps/v8/src/objects/bigint.cc b/deps/v8/src/objects/bigint.cc index b02c0f29d6..2905bb44c6 100644 --- a/deps/v8/src/objects/bigint.cc +++ b/deps/v8/src/objects/bigint.cc @@ -992,7 +992,7 @@ ComparisonResult BigInt::CompareToDouble(Handle<BigInt> x, double y) { MaybeHandle<String> BigInt::ToString(Isolate* isolate, Handle<BigInt> bigint, int radix, ShouldThrow should_throw) { if (bigint->is_zero()) { - return isolate->factory()->NewStringFromStaticChars("0"); + return isolate->factory()->zero_string(); } if (base::bits::IsPowerOfTwo(radix)) { return MutableBigInt::ToStringBasePowerOfTwo(isolate, bigint, radix, diff --git a/deps/v8/src/objects/bigint.h b/deps/v8/src/objects/bigint.h index a5ca514867..ca80547230 100644 --- a/deps/v8/src/objects/bigint.h +++ b/deps/v8/src/objects/bigint.h @@ -57,9 +57,9 @@ class BigIntBase : public HeapObject { // able to read the length concurrently, the getters and setters are atomic. static const int kLengthFieldBits = 30; STATIC_ASSERT(kMaxLength <= ((1 << kLengthFieldBits) - 1)); - class SignBits : public BitField<bool, 0, 1> {}; - class LengthBits : public BitField<int, SignBits::kNext, kLengthFieldBits> {}; - STATIC_ASSERT(LengthBits::kNext <= 32); + using SignBits = BitField<bool, 0, 1>; + using LengthBits = SignBits::Next<int, kLengthFieldBits>; + STATIC_ASSERT(LengthBits::kLastUsedBit < 32); // Layout description. #define BIGINT_FIELDS(V) \ diff --git a/deps/v8/src/objects/cell-inl.h b/deps/v8/src/objects/cell-inl.h index 90266b7599..0bd6808fbc 100644 --- a/deps/v8/src/objects/cell-inl.h +++ b/deps/v8/src/objects/cell-inl.h @@ -16,11 +16,7 @@ namespace v8 { namespace internal { -OBJECT_CONSTRUCTORS_IMPL(Cell, HeapObject) - -CAST_ACCESSOR(Cell) - -ACCESSORS(Cell, value, Object, kValueOffset) +TQ_OBJECT_CONSTRUCTORS_IMPL(Cell) Cell Cell::FromValueAddress(Address value) { return Cell::cast(HeapObject::FromAddress(value - kValueOffset)); diff --git a/deps/v8/src/objects/cell.h b/deps/v8/src/objects/cell.h index 9c77f5d332..fc49f164b2 100644 --- a/deps/v8/src/objects/cell.h +++ b/deps/v8/src/objects/cell.h @@ -6,7 +6,7 @@ #define V8_OBJECTS_CELL_H_ #include "src/objects/heap-object.h" -#include "torque-generated/field-offsets-tq.h" +#include "torque-generated/class-definitions-tq.h" // Has to be the last include (doesn't have include guards): #include "src/objects/object-macros.h" @@ -14,27 +14,18 @@ namespace v8 { namespace internal { -class Cell : public HeapObject { +class Cell : public TorqueGeneratedCell<Cell, HeapObject> { public: - // [value]: value of the cell. - DECL_ACCESSORS(value, Object) - - DECL_CAST(Cell) - static inline Cell FromValueAddress(Address value); inline Address ValueAddress() { return address() + kValueOffset; } // Dispatched behavior. DECL_PRINTER(Cell) - DECL_VERIFIER(Cell) - - DEFINE_FIELD_OFFSET_CONSTANTS(HeapObject::kHeaderSize, - TORQUE_GENERATED_CELL_FIELDS) using BodyDescriptor = FixedBodyDescriptor<kValueOffset, kSize, kSize>; - OBJECT_CONSTRUCTORS(Cell, HeapObject); + TQ_OBJECT_CONSTRUCTORS(Cell) }; } // namespace internal diff --git a/deps/v8/src/objects/code-inl.h b/deps/v8/src/objects/code-inl.h index e6f00b0fb2..6e00a3363c 100644 --- a/deps/v8/src/objects/code-inl.h +++ b/deps/v8/src/objects/code-inl.h @@ -768,6 +768,7 @@ DEFINE_DEOPT_ELEMENT_ACCESSORS(OsrBytecodeOffset, Smi) DEFINE_DEOPT_ELEMENT_ACCESSORS(OsrPcOffset, Smi) DEFINE_DEOPT_ELEMENT_ACCESSORS(OptimizationId, Smi) DEFINE_DEOPT_ELEMENT_ACCESSORS(InliningPositions, PodArray<InliningPosition>) +DEFINE_DEOPT_ELEMENT_ACCESSORS(DeoptExitStart, Smi) DEFINE_DEOPT_ENTRY_ACCESSORS(BytecodeOffsetRaw, Smi) DEFINE_DEOPT_ENTRY_ACCESSORS(TranslationIndex, Smi) diff --git a/deps/v8/src/objects/code.cc b/deps/v8/src/objects/code.cc index a51a8c5b79..b416df8878 100644 --- a/deps/v8/src/objects/code.cc +++ b/deps/v8/src/objects/code.cc @@ -193,7 +193,10 @@ namespace { template <typename Code> void DropStackFrameCacheCommon(Code code) { i::Object maybe_table = code.source_position_table(); - if (maybe_table.IsUndefined() || maybe_table.IsByteArray()) return; + if (maybe_table.IsUndefined() || maybe_table.IsByteArray() || + maybe_table.IsException()) { + return; + } DCHECK(maybe_table.IsSourcePositionTableWithFrameCache()); code.set_source_position_table( i::SourcePositionTableWithFrameCache::cast(maybe_table) @@ -1086,15 +1089,5 @@ const char* DependentCode::DependencyGroupName(DependencyGroup group) { UNREACHABLE(); } -bool BytecodeArray::IsBytecodeEqual(const BytecodeArray other) const { - if (length() != other.length()) return false; - - for (int i = 0; i < length(); ++i) { - if (get(i) != other.get(i)) return false; - } - - return true; -} - } // namespace internal } // namespace v8 diff --git a/deps/v8/src/objects/code.h b/deps/v8/src/objects/code.h index 2f85d4ac7b..6a5ac9f31a 100644 --- a/deps/v8/src/objects/code.h +++ b/deps/v8/src/objects/code.h @@ -45,6 +45,7 @@ class Code : public HeapObject { V(WASM_TO_CAPI_FUNCTION) \ V(WASM_TO_JS_FUNCTION) \ V(JS_TO_WASM_FUNCTION) \ + V(JS_TO_JS_FUNCTION) \ V(WASM_INTERPRETER_ENTRY) \ V(C_WASM_ENTRY) @@ -438,7 +439,7 @@ class Code : public HeapObject { DEFINE_BIT_FIELDS(CODE_FLAGS_BIT_FIELDS) #undef CODE_FLAGS_BIT_FIELDS static_assert(NUMBER_OF_KINDS <= KindField::kMax, "Code::KindField size"); - static_assert(IsOffHeapTrampoline::kNext <= 32, + static_assert(IsOffHeapTrampoline::kLastUsedBit < 32, "Code::flags field exhausted"); // KindSpecificFlags layout (STUB, BUILTIN and OPTIMIZED_FUNCTION) @@ -451,7 +452,8 @@ class Code : public HeapObject { V(IsExceptionCaughtField, bool, 1, _) DEFINE_BIT_FIELDS(CODE_KIND_SPECIFIC_FLAGS_BIT_FIELDS) #undef CODE_KIND_SPECIFIC_FLAGS_BIT_FIELDS - static_assert(IsExceptionCaughtField::kNext <= 32, "KindSpecificFlags full"); + static_assert(IsExceptionCaughtField::kLastUsedBit < 32, + "KindSpecificFlags full"); // The {marked_for_deoptimization} field is accessed from generated code. static const int kMarkedForDeoptimizationBit = @@ -705,8 +707,8 @@ class DependentCode : public WeakFixedArray { inline int flags(); inline void set_flags(int flags); - class GroupField : public BitField<int, 0, 3> {}; - class CountField : public BitField<int, 3, 27> {}; + using GroupField = BitField<int, 0, 3>; + using CountField = BitField<int, 3, 27>; STATIC_ASSERT(kGroupCount <= GroupField::kMax + 1); OBJECT_CONSTRUCTORS(DependentCode, WeakFixedArray); @@ -825,9 +827,6 @@ class BytecodeArray : public FixedArrayBase { // is deterministic. inline void clear_padding(); - // Compares only the bytecode array but not any of the header fields. - bool IsBytecodeEqual(const BytecodeArray other) const; - // Layout description. DEFINE_FIELD_OFFSET_CONSTANTS(FixedArrayBase::kHeaderSize, TORQUE_GENERATED_BYTECODE_ARRAY_FIELDS) @@ -865,7 +864,8 @@ class DeoptimizationData : public FixedArray { static const int kOptimizationIdIndex = 5; static const int kSharedFunctionInfoIndex = 6; static const int kInliningPositionsIndex = 7; - static const int kFirstDeoptEntryIndex = 8; + static const int kDeoptExitStartIndex = 8; + static const int kFirstDeoptEntryIndex = 9; // Offsets of deopt entry elements relative to the start of the entry. static const int kBytecodeOffsetRawOffset = 0; @@ -886,6 +886,7 @@ class DeoptimizationData : public FixedArray { DECL_ELEMENT_ACCESSORS(OptimizationId, Smi) DECL_ELEMENT_ACCESSORS(SharedFunctionInfo, Object) DECL_ELEMENT_ACCESSORS(InliningPositions, PodArray<InliningPosition>) + DECL_ELEMENT_ACCESSORS(DeoptExitStart, Smi) #undef DECL_ELEMENT_ACCESSORS diff --git a/deps/v8/src/objects/contexts.cc b/deps/v8/src/objects/contexts.cc index 861e06d87f..74fb4477b1 100644 --- a/deps/v8/src/objects/contexts.cc +++ b/deps/v8/src/objects/contexts.cc @@ -44,7 +44,7 @@ bool ScriptContextTable::Lookup(Isolate* isolate, ScriptContextTable table, DCHECK(context.IsScriptContext()); int slot_index = ScopeInfo::ContextSlotIndex( context.scope_info(), name, &result->mode, &result->init_flag, - &result->maybe_assigned_flag, &result->requires_brand_check); + &result->maybe_assigned_flag); if (slot_index >= 0) { result->context_index = i; @@ -161,8 +161,8 @@ static Maybe<bool> UnscopableLookup(LookupIterator* it) { } static PropertyAttributes GetAttributesForMode(VariableMode mode) { - DCHECK(IsDeclaredVariableMode(mode)); - return mode == VariableMode::kConst ? READ_ONLY : NONE; + DCHECK(IsSerializableVariableMode(mode)); + return IsConstVariableMode(mode) ? READ_ONLY : NONE; } // static @@ -287,10 +287,8 @@ Handle<Object> Context::Lookup(Handle<Context> context, Handle<String> name, VariableMode mode; InitializationFlag flag; MaybeAssignedFlag maybe_assigned_flag; - RequiresBrandCheckFlag requires_brand_check; int slot_index = ScopeInfo::ContextSlotIndex(scope_info, *name, &mode, - &flag, &maybe_assigned_flag, - &requires_brand_check); + &flag, &maybe_assigned_flag); DCHECK(slot_index < 0 || slot_index >= MIN_CONTEXT_SLOTS); if (slot_index >= 0) { if (FLAG_trace_contexts) { diff --git a/deps/v8/src/objects/contexts.h b/deps/v8/src/objects/contexts.h index 0c00aba08e..a7b60ff7b9 100644 --- a/deps/v8/src/objects/contexts.h +++ b/deps/v8/src/objects/contexts.h @@ -227,10 +227,14 @@ enum ContextLookupFlags { V(REGEXP_EXEC_FUNCTION_INDEX, JSFunction, regexp_exec_function) \ V(REGEXP_FUNCTION_INDEX, JSFunction, regexp_function) \ V(REGEXP_LAST_MATCH_INFO_INDEX, RegExpMatchInfo, regexp_last_match_info) \ + V(REGEXP_MATCH_ALL_FUNCTION_INDEX, JSFunction, regexp_match_all_function) \ + V(REGEXP_MATCH_FUNCTION_INDEX, JSFunction, regexp_match_function) \ V(REGEXP_PROTOTYPE_INDEX, JSObject, regexp_prototype) \ V(REGEXP_PROTOTYPE_MAP_INDEX, Map, regexp_prototype_map) \ + V(REGEXP_REPLACE_FUNCTION_INDEX, JSFunction, regexp_replace_function) \ V(REGEXP_RESULT_MAP_INDEX, Map, regexp_result_map) \ - V(REGEXP_SPECIES_PROTECTOR_INDEX, PropertyCell, regexp_species_protector) \ + V(REGEXP_SEARCH_FUNCTION_INDEX, JSFunction, regexp_search_function) \ + V(REGEXP_SPLIT_FUNCTION_INDEX, JSFunction, regexp_split_function) \ V(INITIAL_REGEXP_STRING_ITERATOR_PROTOTYPE_MAP_INDEX, Map, \ initial_regexp_string_iterator_prototype_map) \ V(SCRIPT_CONTEXT_TABLE_INDEX, ScriptContextTable, script_context_table) \ @@ -249,6 +253,8 @@ enum ContextLookupFlags { slow_object_with_object_prototype_map) \ V(SLOW_TEMPLATE_INSTANTIATIONS_CACHE_INDEX, SimpleNumberDictionary, \ slow_template_instantiations_cache) \ + /* Fast Path Protectors */ \ + V(REGEXP_SPECIES_PROTECTOR_INDEX, PropertyCell, regexp_species_protector) \ /* All *_FUNCTION_MAP_INDEX definitions used by Context::FunctionMapIndex */ \ /* must remain together. */ \ V(SLOPPY_FUNCTION_MAP_INDEX, Map, sloppy_function_map) \ @@ -356,7 +362,6 @@ class ScriptContextTable : public FixedArray { VariableMode mode; InitializationFlag init_flag; MaybeAssignedFlag maybe_assigned_flag; - RequiresBrandCheckFlag requires_brand_check; }; inline int used() const; diff --git a/deps/v8/src/objects/dictionary.h b/deps/v8/src/objects/dictionary.h index fe6001f58c..957c06d8ec 100644 --- a/deps/v8/src/objects/dictionary.h +++ b/deps/v8/src/objects/dictionary.h @@ -170,7 +170,8 @@ class EXPORT_TEMPLATE_DECLARE(V8_EXPORT_PRIVATE) BaseNameDictionary // Collect the keys into the given KeyAccumulator, in ascending chronological // order of property creation. - static void CollectKeysTo(Handle<Derived> dictionary, KeyAccumulator* keys); + V8_WARN_UNUSED_RESULT static ExceptionStatus CollectKeysTo( + Handle<Derived> dictionary, KeyAccumulator* keys); // Return the key indices sorted by its enumeration index. static Handle<FixedArray> IterationIndices(Isolate* isolate, diff --git a/deps/v8/src/objects/elements-inl.h b/deps/v8/src/objects/elements-inl.h index c4f2e2bf78..dfec2e35f4 100644 --- a/deps/v8/src/objects/elements-inl.h +++ b/deps/v8/src/objects/elements-inl.h @@ -5,6 +5,7 @@ #ifndef V8_OBJECTS_ELEMENTS_INL_H_ #define V8_OBJECTS_ELEMENTS_INL_H_ +#include "src/common/globals.h" #include "src/objects/elements.h" #include "src/handles/handles-inl.h" @@ -13,10 +14,11 @@ namespace v8 { namespace internal { -inline void ElementsAccessor::CollectElementIndices(Handle<JSObject> object, - KeyAccumulator* keys) { - CollectElementIndices(object, handle(object->elements(), keys->isolate()), - keys); +V8_WARN_UNUSED_RESULT inline ExceptionStatus +ElementsAccessor::CollectElementIndices(Handle<JSObject> object, + KeyAccumulator* keys) { + return CollectElementIndices( + object, handle(object->elements(), keys->isolate()), keys); } inline MaybeHandle<FixedArray> ElementsAccessor::PrependElementIndices( diff --git a/deps/v8/src/objects/elements-kind.cc b/deps/v8/src/objects/elements-kind.cc index a819caf459..ec2b79d10b 100644 --- a/deps/v8/src/objects/elements-kind.cc +++ b/deps/v8/src/objects/elements-kind.cc @@ -35,10 +35,12 @@ int ElementsKindToShiftSize(ElementsKind elements_kind) { case PACKED_ELEMENTS: case PACKED_FROZEN_ELEMENTS: case PACKED_SEALED_ELEMENTS: + case PACKED_NONEXTENSIBLE_ELEMENTS: case HOLEY_SMI_ELEMENTS: case HOLEY_ELEMENTS: case HOLEY_FROZEN_ELEMENTS: case HOLEY_SEALED_ELEMENTS: + case HOLEY_NONEXTENSIBLE_ELEMENTS: case DICTIONARY_ELEMENTS: case FAST_SLOPPY_ARGUMENTS_ELEMENTS: case SLOW_SLOPPY_ARGUMENTS_ELEMENTS: @@ -79,6 +81,10 @@ const char* ElementsKindToString(ElementsKind kind) { return "PACKED_DOUBLE_ELEMENTS"; case HOLEY_DOUBLE_ELEMENTS: return "HOLEY_DOUBLE_ELEMENTS"; + case PACKED_NONEXTENSIBLE_ELEMENTS: + return "PACKED_NONEXTENSIBLE_ELEMENTS"; + case HOLEY_NONEXTENSIBLE_ELEMENTS: + return "HOLEY_NONEXTENSIBLE_ELEMENTS"; case PACKED_SEALED_ELEMENTS: return "PACKED_SEALED_ELEMENTS"; case HOLEY_SEALED_ELEMENTS: diff --git a/deps/v8/src/objects/elements-kind.h b/deps/v8/src/objects/elements-kind.h index 3ed6ea66ec..e1335fa3c0 100644 --- a/deps/v8/src/objects/elements-kind.h +++ b/deps/v8/src/objects/elements-kind.h @@ -43,6 +43,10 @@ enum ElementsKind : uint8_t { PACKED_DOUBLE_ELEMENTS, HOLEY_DOUBLE_ELEMENTS, + // The nonextensible kind for elements. + PACKED_NONEXTENSIBLE_ELEMENTS, + HOLEY_NONEXTENSIBLE_ELEMENTS, + // The sealed kind for elements. PACKED_SEALED_ELEMENTS, HOLEY_SEALED_ELEMENTS, @@ -79,7 +83,8 @@ enum ElementsKind : uint8_t { FIRST_FIXED_TYPED_ARRAY_ELEMENTS_KIND = UINT8_ELEMENTS, LAST_FIXED_TYPED_ARRAY_ELEMENTS_KIND = BIGINT64_ELEMENTS, TERMINAL_FAST_ELEMENTS_KIND = HOLEY_ELEMENTS, - LAST_FROZEN_ELEMENTS_KIND = HOLEY_FROZEN_ELEMENTS, + FIRST_ANY_NONEXTENSIBLE_ELEMENTS_KIND = PACKED_NONEXTENSIBLE_ELEMENTS, + LAST_ANY_NONEXTENSIBLE_ELEMENTS_KIND = HOLEY_FROZEN_ELEMENTS, // Alias for kSystemPointerSize-sized elements #ifdef V8_COMPRESS_POINTERS @@ -156,14 +161,23 @@ inline bool IsDoubleOrFloatElementsKind(ElementsKind kind) { } // This predicate is used for disabling respective functionality in builtins. -inline bool IsFrozenOrSealedElementsKindUnchecked(ElementsKind kind) { - return IsInRange(kind, PACKED_SEALED_ELEMENTS, HOLEY_FROZEN_ELEMENTS); +inline bool IsAnyNonextensibleElementsKindUnchecked(ElementsKind kind) { + return IsInRange(kind, FIRST_ANY_NONEXTENSIBLE_ELEMENTS_KIND, + LAST_ANY_NONEXTENSIBLE_ELEMENTS_KIND); } -inline bool IsFrozenOrSealedElementsKind(ElementsKind kind) { - DCHECK_IMPLIES(IsFrozenOrSealedElementsKindUnchecked(kind), +inline bool IsAnyNonextensibleElementsKind(ElementsKind kind) { + DCHECK_IMPLIES(IsAnyNonextensibleElementsKindUnchecked(kind), FLAG_enable_sealed_frozen_elements_kind); - return IsFrozenOrSealedElementsKindUnchecked(kind); + return IsAnyNonextensibleElementsKindUnchecked(kind); +} + +inline bool IsNonextensibleElementsKind(ElementsKind kind) { + DCHECK_IMPLIES(IsInRange(kind, PACKED_NONEXTENSIBLE_ELEMENTS, + HOLEY_NONEXTENSIBLE_ELEMENTS), + FLAG_enable_sealed_frozen_elements_kind); + return IsInRange(kind, PACKED_NONEXTENSIBLE_ELEMENTS, + HOLEY_NONEXTENSIBLE_ELEMENTS); } inline bool IsSealedElementsKind(ElementsKind kind) { @@ -194,10 +208,13 @@ inline bool IsObjectElementsKind(ElementsKind kind) { return IsInRange(kind, PACKED_ELEMENTS, HOLEY_ELEMENTS); } -inline bool IsHoleyFrozenOrSealedElementsKind(ElementsKind kind) { - DCHECK_IMPLIES(kind == HOLEY_SEALED_ELEMENTS || kind == HOLEY_FROZEN_ELEMENTS, +inline bool IsAnyHoleyNonextensibleElementsKind(ElementsKind kind) { + DCHECK_IMPLIES(kind == HOLEY_NONEXTENSIBLE_ELEMENTS || + kind == HOLEY_SEALED_ELEMENTS || + kind == HOLEY_FROZEN_ELEMENTS, FLAG_enable_sealed_frozen_elements_kind); - return kind == HOLEY_SEALED_ELEMENTS || kind == HOLEY_FROZEN_ELEMENTS; + return kind == HOLEY_NONEXTENSIBLE_ELEMENTS || + kind == HOLEY_SEALED_ELEMENTS || kind == HOLEY_FROZEN_ELEMENTS; } inline bool IsHoleyElementsKind(ElementsKind kind) { @@ -239,6 +256,9 @@ inline ElementsKind GetHoleyElementsKind(ElementsKind packed_kind) { if (packed_kind == PACKED_ELEMENTS) { return HOLEY_ELEMENTS; } + if (packed_kind == PACKED_NONEXTENSIBLE_ELEMENTS) { + return HOLEY_NONEXTENSIBLE_ELEMENTS; + } return packed_kind; } diff --git a/deps/v8/src/objects/elements.cc b/deps/v8/src/objects/elements.cc index 4bdfba052d..6e5648d2f4 100644 --- a/deps/v8/src/objects/elements.cc +++ b/deps/v8/src/objects/elements.cc @@ -33,6 +33,9 @@ // - FastPackedSmiElementsAccessor // - FastHoleySmiElementsAccessor // - FastPackedObjectElementsAccessor +// - FastNonextensibleObjectElementsAccessor: template +// - FastPackedNonextensibleObjectElementsAccessor +// - FastHoleyNonextensibleObjectElementsAccessor // - FastSealedObjectElementsAccessor: template // - FastPackedSealedObjectElementsAccessor // - FastHoleySealedObjectElementsAccessor @@ -68,6 +71,17 @@ namespace internal { namespace { +#define RETURN_NOTHING_IF_NOT_SUCCESSFUL(call) \ + do { \ + if (!(call)) return Nothing<bool>(); \ + } while (false) + +#define RETURN_FAILURE_IF_NOT_SUCCESSFUL(call) \ + do { \ + ExceptionStatus status_enum_result = (call); \ + if (!status_enum_result) return status_enum_result; \ + } while (false) + static const int kPackedSizeNotKnown = -1; enum Where { AT_START, AT_END }; @@ -85,6 +99,10 @@ enum Where { AT_START, AT_END }; V(FastPackedDoubleElementsAccessor, PACKED_DOUBLE_ELEMENTS, \ FixedDoubleArray) \ V(FastHoleyDoubleElementsAccessor, HOLEY_DOUBLE_ELEMENTS, FixedDoubleArray) \ + V(FastPackedNonextensibleObjectElementsAccessor, \ + PACKED_NONEXTENSIBLE_ELEMENTS, FixedArray) \ + V(FastHoleyNonextensibleObjectElementsAccessor, \ + HOLEY_NONEXTENSIBLE_ELEMENTS, FixedArray) \ V(FastPackedSealedObjectElementsAccessor, PACKED_SEALED_ELEMENTS, \ FixedArray) \ V(FastHoleySealedObjectElementsAccessor, HOLEY_SEALED_ELEMENTS, FixedArray) \ @@ -992,8 +1010,8 @@ class ElementsAccessorBase : public InternalElementsAccessor { DCHECK_EQ(*nof_items, 0); KeyAccumulator accumulator(isolate, KeyCollectionMode::kOwnOnly, ALL_PROPERTIES); - Subclass::CollectElementIndicesImpl( - object, handle(object->elements(), isolate), &accumulator); + RETURN_NOTHING_IF_NOT_SUCCESSFUL(Subclass::CollectElementIndicesImpl( + object, handle(object->elements(), isolate), &accumulator)); Handle<FixedArray> keys = accumulator.GetKeys(); int count = 0; @@ -1055,16 +1073,16 @@ class ElementsAccessorBase : public InternalElementsAccessor { return Just(true); } - void CollectElementIndices(Handle<JSObject> object, - Handle<FixedArrayBase> backing_store, - KeyAccumulator* keys) final { - if (keys->filter() & ONLY_ALL_CAN_READ) return; - Subclass::CollectElementIndicesImpl(object, backing_store, keys); + V8_WARN_UNUSED_RESULT ExceptionStatus CollectElementIndices( + Handle<JSObject> object, Handle<FixedArrayBase> backing_store, + KeyAccumulator* keys) final { + if (keys->filter() & ONLY_ALL_CAN_READ) return ExceptionStatus::kSuccess; + return Subclass::CollectElementIndicesImpl(object, backing_store, keys); } - static void CollectElementIndicesImpl(Handle<JSObject> object, - Handle<FixedArrayBase> backing_store, - KeyAccumulator* keys) { + V8_WARN_UNUSED_RESULT static ExceptionStatus CollectElementIndicesImpl( + Handle<JSObject> object, Handle<FixedArrayBase> backing_store, + KeyAccumulator* keys) { DCHECK_NE(DICTIONARY_ELEMENTS, kind()); // Non-dictionary elements can't have all-can-read accessors. uint32_t length = Subclass::GetMaxIndex(*object, *backing_store); @@ -1074,9 +1092,11 @@ class ElementsAccessorBase : public InternalElementsAccessor { for (uint32_t i = 0; i < length; i++) { if (Subclass::HasElementImpl(isolate, *object, i, *backing_store, filter)) { - keys->AddKey(factory->NewNumberFromUint(i)); + RETURN_FAILURE_IF_NOT_SUCCESSFUL( + keys->AddKey(factory->NewNumberFromUint(i))); } } + return ExceptionStatus::kSuccess; } static Handle<FixedArray> DirectCollectElementIndicesImpl( @@ -1189,10 +1209,11 @@ class ElementsAccessorBase : public InternalElementsAccessor { return combined_keys; } - void AddElementsToKeyAccumulator(Handle<JSObject> receiver, - KeyAccumulator* accumulator, - AddKeyConversion convert) final { - Subclass::AddElementsToKeyAccumulatorImpl(receiver, accumulator, convert); + V8_WARN_UNUSED_RESULT ExceptionStatus AddElementsToKeyAccumulator( + Handle<JSObject> receiver, KeyAccumulator* accumulator, + AddKeyConversion convert) final { + return Subclass::AddElementsToKeyAccumulatorImpl(receiver, accumulator, + convert); } static uint32_t GetCapacityImpl(JSObject holder, @@ -1266,7 +1287,8 @@ class ElementsAccessorBase : public InternalElementsAccessor { static uint32_t GetEntryForIndexImpl(Isolate* isolate, JSObject holder, FixedArrayBase backing_store, uint32_t index, PropertyFilter filter) { - DCHECK(IsFastElementsKind(kind()) || IsFrozenOrSealedElementsKind(kind())); + DCHECK(IsFastElementsKind(kind()) || + IsAnyNonextensibleElementsKind(kind())); uint32_t length = Subclass::GetMaxIndex(holder, backing_store); if (IsHoleyElementsKindForRead(kind())) { return index < length && !BackingStore::cast(backing_store) @@ -1529,10 +1551,10 @@ class DictionaryElementsAccessor return FilterKey(dictionary, entry, raw_key, filter); } - static void CollectElementIndicesImpl(Handle<JSObject> object, - Handle<FixedArrayBase> backing_store, - KeyAccumulator* keys) { - if (keys->filter() & SKIP_STRINGS) return; + V8_WARN_UNUSED_RESULT static ExceptionStatus CollectElementIndicesImpl( + Handle<JSObject> object, Handle<FixedArrayBase> backing_store, + KeyAccumulator* keys) { + if (keys->filter() & SKIP_STRINGS) return ExceptionStatus::kSuccess; Isolate* isolate = keys->isolate(); Handle<NumberDictionary> dictionary = Handle<NumberDictionary>::cast(backing_store); @@ -1555,8 +1577,9 @@ class DictionaryElementsAccessor } SortIndices(isolate, elements, insertion_index); for (int i = 0; i < insertion_index; i++) { - keys->AddKey(elements->get(i)); + RETURN_FAILURE_IF_NOT_SUCCESSFUL(keys->AddKey(elements->get(i))); } + return ExceptionStatus::kSuccess; } static Handle<FixedArray> DirectCollectElementIndicesImpl( @@ -1581,9 +1604,9 @@ class DictionaryElementsAccessor return list; } - static void AddElementsToKeyAccumulatorImpl(Handle<JSObject> receiver, - KeyAccumulator* accumulator, - AddKeyConversion convert) { + V8_WARN_UNUSED_RESULT static ExceptionStatus AddElementsToKeyAccumulatorImpl( + Handle<JSObject> receiver, KeyAccumulator* accumulator, + AddKeyConversion convert) { Isolate* isolate = accumulator->isolate(); Handle<NumberDictionary> dictionary( NumberDictionary::cast(receiver->elements()), isolate); @@ -1596,8 +1619,9 @@ class DictionaryElementsAccessor DCHECK(!value.IsTheHole(isolate)); DCHECK(!value.IsAccessorPair()); DCHECK(!value.IsAccessorInfo()); - accumulator->AddKey(value, convert); + RETURN_FAILURE_IF_NOT_SUCCESSFUL(accumulator->AddKey(value, convert)); } + return ExceptionStatus::kSuccess; } static bool IncludesValueFastPath(Isolate* isolate, Handle<JSObject> receiver, @@ -1877,7 +1901,7 @@ class FastElementsAccessor : public ElementsAccessorBase<Subclass, KindTraits> { static void DeleteCommon(Handle<JSObject> obj, uint32_t entry, Handle<FixedArrayBase> store) { DCHECK(obj->HasSmiOrObjectElements() || obj->HasDoubleElements() || - obj->HasFastArgumentsElements() || + obj->HasNonextensibleElements() || obj->HasFastArgumentsElements() || obj->HasFastStringWrapperElements()); Handle<BackingStore> backing_store = Handle<BackingStore>::cast(store); if (!obj->IsJSArray() && @@ -1981,10 +2005,12 @@ class FastElementsAccessor : public ElementsAccessorBase<Subclass, KindTraits> { static void DeleteImpl(Handle<JSObject> obj, uint32_t entry) { ElementsKind kind = KindTraits::Kind; - if (IsFastPackedElementsKind(kind)) { + if (IsFastPackedElementsKind(kind) || + kind == PACKED_NONEXTENSIBLE_ELEMENTS) { JSObject::TransitionElementsKind(obj, GetHoleyElementsKind(kind)); } - if (IsSmiOrObjectElementsKind(KindTraits::Kind)) { + if (IsSmiOrObjectElementsKind(KindTraits::Kind) || + IsNonextensibleElementsKind(kind)) { JSObject::EnsureWritableFastElements(obj); } DeleteCommon(obj, entry, handle(obj->elements(), obj->GetIsolate())); @@ -2007,18 +2033,20 @@ class FastElementsAccessor : public ElementsAccessorBase<Subclass, KindTraits> { return count; } - static void AddElementsToKeyAccumulatorImpl(Handle<JSObject> receiver, - KeyAccumulator* accumulator, - AddKeyConversion convert) { + V8_WARN_UNUSED_RESULT static ExceptionStatus AddElementsToKeyAccumulatorImpl( + Handle<JSObject> receiver, KeyAccumulator* accumulator, + AddKeyConversion convert) { Isolate* isolate = accumulator->isolate(); Handle<FixedArrayBase> elements(receiver->elements(), isolate); uint32_t length = Subclass::GetMaxNumberOfEntries(*receiver, *elements); for (uint32_t i = 0; i < length; i++) { if (IsFastPackedElementsKind(KindTraits::Kind) || HasEntryImpl(isolate, *elements, i)) { - accumulator->AddKey(Subclass::GetImpl(isolate, *elements, i), convert); + RETURN_FAILURE_IF_NOT_SUCCESSFUL(accumulator->AddKey( + Subclass::GetImpl(isolate, *elements, i), convert)); } } + return ExceptionStatus::kSuccess; } static void ValidateContents(JSObject holder, int length) { @@ -2164,7 +2192,7 @@ class FastElementsAccessor : public ElementsAccessorBase<Subclass, KindTraits> { // Hole here, since the {length} used here can be larger than // JSArray::length. if (IsSmiOrObjectElementsKind(Subclass::kind()) || - IsFrozenOrSealedElementsKind(Subclass::kind())) { + IsAnyNonextensibleElementsKind(Subclass::kind())) { auto elements = FixedArray::cast(receiver->elements()); for (uint32_t k = start_from; k < length; ++k) { @@ -2189,7 +2217,7 @@ class FastElementsAccessor : public ElementsAccessorBase<Subclass, KindTraits> { return Just(false); } } else if (!IsObjectElementsKind(Subclass::kind()) && - !IsFrozenOrSealedElementsKind(Subclass::kind())) { + !IsAnyNonextensibleElementsKind(Subclass::kind())) { // Search for non-number, non-Undefined value, with either // PACKED_SMI_ELEMENTS, PACKED_DOUBLE_ELEMENTS, HOLEY_SMI_ELEMENTS or // HOLEY_DOUBLE_ELEMENTS. Guaranteed to return false, since these @@ -2199,7 +2227,7 @@ class FastElementsAccessor : public ElementsAccessorBase<Subclass, KindTraits> { // Search for non-number, non-Undefined value with either // PACKED_ELEMENTS or HOLEY_ELEMENTS. DCHECK(IsObjectElementsKind(Subclass::kind()) || - IsFrozenOrSealedElementsKind(Subclass::kind())); + IsAnyNonextensibleElementsKind(Subclass::kind())); auto elements = FixedArray::cast(receiver->elements()); for (uint32_t k = start_from; k < length; ++k) { @@ -2265,7 +2293,7 @@ class FastElementsAccessor : public ElementsAccessorBase<Subclass, KindTraits> { // PACKED_SMI_ELEMENTS or HOLEY_SMI_ELEMENTS. Return true if // elementK->IsHeapNumber() && std::isnan(elementK->Number()) DCHECK(IsSmiOrObjectElementsKind(Subclass::kind()) || - IsFrozenOrSealedElementsKind(Subclass::kind())); + IsAnyNonextensibleElementsKind(Subclass::kind())); auto elements = FixedArray::cast(receiver->elements()); for (uint32_t k = start_from; k < length; ++k) { @@ -2414,9 +2442,11 @@ class FastSmiOrObjectElementsAccessor case PACKED_ELEMENTS: case PACKED_FROZEN_ELEMENTS: case PACKED_SEALED_ELEMENTS: + case PACKED_NONEXTENSIBLE_ELEMENTS: case HOLEY_ELEMENTS: case HOLEY_FROZEN_ELEMENTS: case HOLEY_SEALED_ELEMENTS: + case HOLEY_NONEXTENSIBLE_ELEMENTS: CopyObjectToObjectElements(isolate, from, from_kind, from_start, to, to_kind, to_start, copy_size); break; @@ -2493,7 +2523,7 @@ class FastSmiOrObjectElementsAccessor // Only FAST_{,HOLEY_}ELEMENTS can store non-numbers. if (!value.IsNumber() && !IsObjectElementsKind(Subclass::kind()) && - !IsFrozenOrSealedElementsKind(Subclass::kind())) { + !IsAnyNonextensibleElementsKind(Subclass::kind())) { return Just<int64_t>(-1); } // NaN can never be found by strict equality. @@ -2527,6 +2557,80 @@ class FastPackedObjectElementsAccessor ElementsKindTraits<PACKED_ELEMENTS>> {}; template <typename Subclass, typename KindTraits> +class FastNonextensibleObjectElementsAccessor + : public FastSmiOrObjectElementsAccessor<Subclass, KindTraits> { + public: + using BackingStore = typename KindTraits::BackingStore; + + static uint32_t PushImpl(Handle<JSArray> receiver, Arguments* args, + uint32_t push_size) { + UNREACHABLE(); + } + + static void AddImpl(Handle<JSObject> object, uint32_t index, + Handle<Object> value, PropertyAttributes attributes, + uint32_t new_capacity) { + UNREACHABLE(); + } + + // TODO(duongn): refactor this due to code duplication of sealed version. + // Consider using JSObject::NormalizeElements(). Also consider follow the fast + // element logic instead of changing to dictionary mode. + static void SetLengthImpl(Isolate* isolate, Handle<JSArray> array, + uint32_t length, + Handle<FixedArrayBase> backing_store) { + uint32_t old_length = 0; + CHECK(array->length().ToArrayIndex(&old_length)); + if (length == old_length) { + // Do nothing. + return; + } + + // Transition to DICTIONARY_ELEMENTS. + // Convert to dictionary mode. + Handle<NumberDictionary> new_element_dictionary = + old_length == 0 ? isolate->factory()->empty_slow_element_dictionary() + : array->GetElementsAccessor()->Normalize(array); + + // Migrate map. + Handle<Map> new_map = Map::Copy(isolate, handle(array->map(), isolate), + "SlowCopyForSetLengthImpl"); + new_map->set_is_extensible(false); + new_map->set_elements_kind(DICTIONARY_ELEMENTS); + JSObject::MigrateToMap(isolate, array, new_map); + + if (!new_element_dictionary.is_null()) { + array->set_elements(*new_element_dictionary); + } + + if (array->elements() != + ReadOnlyRoots(isolate).empty_slow_element_dictionary()) { + Handle<NumberDictionary> dictionary(array->element_dictionary(), isolate); + // Make sure we never go back to the fast case + array->RequireSlowElements(*dictionary); + JSObject::ApplyAttributesToDictionary(isolate, ReadOnlyRoots(isolate), + dictionary, + PropertyAttributes::NONE); + } + + // Set length. + Handle<FixedArrayBase> new_backing_store(array->elements(), isolate); + DictionaryElementsAccessor::SetLengthImpl(isolate, array, length, + new_backing_store); + } +}; + +class FastPackedNonextensibleObjectElementsAccessor + : public FastNonextensibleObjectElementsAccessor< + FastPackedNonextensibleObjectElementsAccessor, + ElementsKindTraits<PACKED_NONEXTENSIBLE_ELEMENTS>> {}; + +class FastHoleyNonextensibleObjectElementsAccessor + : public FastNonextensibleObjectElementsAccessor< + FastHoleyNonextensibleObjectElementsAccessor, + ElementsKindTraits<HOLEY_NONEXTENSIBLE_ELEMENTS>> {}; + +template <typename Subclass, typename KindTraits> class FastSealedObjectElementsAccessor : public FastSmiOrObjectElementsAccessor<Subclass, KindTraits> { public: @@ -2564,6 +2668,9 @@ class FastSealedObjectElementsAccessor UNREACHABLE(); } + // TODO(duongn): refactor this due to code duplication of nonextensible + // version. Consider using JSObject::NormalizeElements(). Also consider follow + // the fast element logic instead of changing to dictionary mode. static void SetLengthImpl(Isolate* isolate, Handle<JSArray> array, uint32_t length, Handle<FixedArrayBase> backing_store) { @@ -2749,9 +2856,11 @@ class FastDoubleElementsAccessor case PACKED_ELEMENTS: case PACKED_FROZEN_ELEMENTS: case PACKED_SEALED_ELEMENTS: + case PACKED_NONEXTENSIBLE_ELEMENTS: case HOLEY_ELEMENTS: case HOLEY_FROZEN_ELEMENTS: case HOLEY_SEALED_ELEMENTS: + case HOLEY_NONEXTENSIBLE_ELEMENTS: CopyObjectToDoubleElements(from, from_start, to, to_start, copy_size); break; case DICTIONARY_ELEMENTS: @@ -3006,16 +3115,17 @@ class TypedElementsAccessor return AccessorClass::GetCapacityImpl(receiver, backing_store); } - static void AddElementsToKeyAccumulatorImpl(Handle<JSObject> receiver, - KeyAccumulator* accumulator, - AddKeyConversion convert) { + V8_WARN_UNUSED_RESULT static ExceptionStatus AddElementsToKeyAccumulatorImpl( + Handle<JSObject> receiver, KeyAccumulator* accumulator, + AddKeyConversion convert) { Isolate* isolate = receiver->GetIsolate(); Handle<FixedArrayBase> elements(receiver->elements(), isolate); uint32_t length = AccessorClass::GetCapacityImpl(*receiver, *elements); for (uint32_t i = 0; i < length; i++) { Handle<Object> value = AccessorClass::GetInternalImpl(receiver, i); - accumulator->AddKey(value, convert); + RETURN_FAILURE_IF_NOT_SUCCESSFUL(accumulator->AddKey(value, convert)); } + return ExceptionStatus::kSuccess; } static Maybe<bool> CollectValuesOrEntriesImpl( @@ -3886,17 +3996,18 @@ class SloppyArgumentsElementsAccessor ArgumentsAccessor::NumberOfElementsImpl(receiver, arguments); } - static void AddElementsToKeyAccumulatorImpl(Handle<JSObject> receiver, - KeyAccumulator* accumulator, - AddKeyConversion convert) { + V8_WARN_UNUSED_RESULT static ExceptionStatus AddElementsToKeyAccumulatorImpl( + Handle<JSObject> receiver, KeyAccumulator* accumulator, + AddKeyConversion convert) { Isolate* isolate = accumulator->isolate(); Handle<FixedArrayBase> elements(receiver->elements(), isolate); uint32_t length = GetCapacityImpl(*receiver, *elements); for (uint32_t entry = 0; entry < length; entry++) { if (!HasEntryImpl(isolate, *elements, entry)) continue; Handle<Object> value = GetImpl(isolate, *elements, entry); - accumulator->AddKey(value, convert); + RETURN_FAILURE_IF_NOT_SUCCESSFUL(accumulator->AddKey(value, convert)); } + return ExceptionStatus::kSuccess; } static bool HasEntryImpl(Isolate* isolate, FixedArrayBase parameters, @@ -3986,9 +4097,9 @@ class SloppyArgumentsElementsAccessor UNREACHABLE(); } - static void CollectElementIndicesImpl(Handle<JSObject> object, - Handle<FixedArrayBase> backing_store, - KeyAccumulator* keys) { + V8_WARN_UNUSED_RESULT static ExceptionStatus CollectElementIndicesImpl( + Handle<JSObject> object, Handle<FixedArrayBase> backing_store, + KeyAccumulator* keys) { Isolate* isolate = keys->isolate(); uint32_t nof_indices = 0; Handle<FixedArray> indices = isolate->factory()->NewFixedArray( @@ -3998,8 +4109,9 @@ class SloppyArgumentsElementsAccessor ENUMERABLE_STRINGS, indices, &nof_indices); SortIndices(isolate, indices, nof_indices); for (uint32_t i = 0; i < nof_indices; i++) { - keys->AddKey(indices->get(i)); + RETURN_FAILURE_IF_NOT_SUCCESSFUL(keys->AddKey(indices->get(i))); } + return ExceptionStatus::kSuccess; } static Handle<FixedArray> DirectCollectElementIndicesImpl( @@ -4418,33 +4530,34 @@ class StringWrapperElementsAccessor attributes); } - static void AddElementsToKeyAccumulatorImpl(Handle<JSObject> receiver, - KeyAccumulator* accumulator, - AddKeyConversion convert) { + V8_WARN_UNUSED_RESULT static ExceptionStatus AddElementsToKeyAccumulatorImpl( + Handle<JSObject> receiver, KeyAccumulator* accumulator, + AddKeyConversion convert) { Isolate* isolate = receiver->GetIsolate(); Handle<String> string(GetString(*receiver), isolate); string = String::Flatten(isolate, string); uint32_t length = static_cast<uint32_t>(string->length()); for (uint32_t i = 0; i < length; i++) { - accumulator->AddKey( + Handle<String> key = isolate->factory()->LookupSingleCharacterStringFromCode( - string->Get(i)), - convert); + string->Get(i)); + RETURN_FAILURE_IF_NOT_SUCCESSFUL(accumulator->AddKey(key, convert)); } - BackingStoreAccessor::AddElementsToKeyAccumulatorImpl(receiver, accumulator, - convert); + return BackingStoreAccessor::AddElementsToKeyAccumulatorImpl( + receiver, accumulator, convert); } - static void CollectElementIndicesImpl(Handle<JSObject> object, - Handle<FixedArrayBase> backing_store, - KeyAccumulator* keys) { + V8_WARN_UNUSED_RESULT static ExceptionStatus CollectElementIndicesImpl( + Handle<JSObject> object, Handle<FixedArrayBase> backing_store, + KeyAccumulator* keys) { uint32_t length = GetString(*object).length(); Factory* factory = keys->isolate()->factory(); for (uint32_t i = 0; i < length; i++) { - keys->AddKey(factory->NewNumberFromUint(i)); + RETURN_FAILURE_IF_NOT_SUCCESSFUL( + keys->AddKey(factory->NewNumberFromUint(i))); } - BackingStoreAccessor::CollectElementIndicesImpl(object, backing_store, - keys); + return BackingStoreAccessor::CollectElementIndicesImpl(object, + backing_store, keys); } static void GrowCapacityAndConvertImpl(Handle<JSObject> object, @@ -4737,5 +4850,7 @@ Handle<JSArray> ElementsAccessor::Concat(Isolate* isolate, Arguments* args, ElementsAccessor** ElementsAccessor::elements_accessors_ = nullptr; #undef ELEMENTS_LIST +#undef RETURN_NOTHING_IF_NOT_SUCCESSFUL +#undef RETURN_FAILURE_IF_NOT_SUCCESSFUL } // namespace internal } // namespace v8 diff --git a/deps/v8/src/objects/elements.h b/deps/v8/src/objects/elements.h index a72a6b068e..b7fcd907a3 100644 --- a/deps/v8/src/objects/elements.h +++ b/deps/v8/src/objects/elements.h @@ -69,12 +69,12 @@ class ElementsAccessor { // Copy all indices that have elements from |object| into the given // KeyAccumulator. For Dictionary-based element-kinds we filter out elements // whose PropertyAttribute match |filter|. - virtual void CollectElementIndices(Handle<JSObject> object, - Handle<FixedArrayBase> backing_store, - KeyAccumulator* keys) = 0; + V8_WARN_UNUSED_RESULT virtual ExceptionStatus CollectElementIndices( + Handle<JSObject> object, Handle<FixedArrayBase> backing_store, + KeyAccumulator* keys) = 0; - inline void CollectElementIndices(Handle<JSObject> object, - KeyAccumulator* keys); + V8_WARN_UNUSED_RESULT inline ExceptionStatus CollectElementIndices( + Handle<JSObject> object, KeyAccumulator* keys); virtual Maybe<bool> CollectValuesOrEntries( Isolate* isolate, Handle<JSObject> object, @@ -90,9 +90,9 @@ class ElementsAccessor { Handle<JSObject> object, Handle<FixedArray> keys, GetKeysConversion convert, PropertyFilter filter = ALL_PROPERTIES); - virtual void AddElementsToKeyAccumulator(Handle<JSObject> receiver, - KeyAccumulator* accumulator, - AddKeyConversion convert) = 0; + V8_WARN_UNUSED_RESULT virtual ExceptionStatus AddElementsToKeyAccumulator( + Handle<JSObject> receiver, KeyAccumulator* accumulator, + AddKeyConversion convert) = 0; virtual void TransitionElementsKind(Handle<JSObject> object, Handle<Map> map) = 0; diff --git a/deps/v8/src/objects/embedder-data-array-inl.h b/deps/v8/src/objects/embedder-data-array-inl.h index 34f22b1115..6775fa8075 100644 --- a/deps/v8/src/objects/embedder-data-array-inl.h +++ b/deps/v8/src/objects/embedder-data-array-inl.h @@ -16,11 +16,9 @@ namespace v8 { namespace internal { -CAST_ACCESSOR(EmbedderDataArray) +TQ_SMI_ACCESSORS(EmbedderDataArray, length) -SMI_ACCESSORS(EmbedderDataArray, length, kLengthOffset) - -OBJECT_CONSTRUCTORS_IMPL(EmbedderDataArray, HeapObject) +TQ_OBJECT_CONSTRUCTORS_IMPL(EmbedderDataArray) Address EmbedderDataArray::slots_start() { return FIELD_ADDR(*this, OffsetOfElementAt(0)); diff --git a/deps/v8/src/objects/embedder-data-array.h b/deps/v8/src/objects/embedder-data-array.h index ba4fe25465..668d890817 100644 --- a/deps/v8/src/objects/embedder-data-array.h +++ b/deps/v8/src/objects/embedder-data-array.h @@ -8,7 +8,7 @@ #include "src/common/globals.h" #include "src/handles/maybe-handles.h" #include "src/objects/heap-object.h" -#include "torque-generated/field-offsets-tq.h" +#include "torque-generated/class-definitions-tq.h" // Has to be the last include (doesn't have include guards): #include "src/objects/object-macros.h" @@ -20,16 +20,13 @@ namespace internal { // It's basically an "array of EmbedderDataSlots". // Note, if the pointer compression is enabled the embedder data slot also // contains a raw data part in addition to tagged part. -class EmbedderDataArray : public HeapObject { +class EmbedderDataArray + : public TorqueGeneratedEmbedderDataArray<EmbedderDataArray, HeapObject> { public: // [length]: length of the array in an embedder data slots. V8_INLINE int length() const; V8_INLINE void set_length(int value); - DECL_CAST(EmbedderDataArray) - - DEFINE_FIELD_OFFSET_CONSTANTS(HeapObject::kHeaderSize, - TORQUE_GENERATED_EMBEDDER_DATA_ARRAY_FIELDS) // TODO(v8:8989): [torque] Support marker constants. static const int kHeaderSize = kSize; @@ -64,7 +61,7 @@ class EmbedderDataArray : public HeapObject { private: STATIC_ASSERT(kHeaderSize == Internals::kFixedArrayHeaderSize); - OBJECT_CONSTRUCTORS(EmbedderDataArray, HeapObject); + TQ_OBJECT_CONSTRUCTORS(EmbedderDataArray) }; } // namespace internal diff --git a/deps/v8/src/objects/feedback-vector.cc b/deps/v8/src/objects/feedback-vector.cc index 4f4826eab3..2fbc48a95e 100644 --- a/deps/v8/src/objects/feedback-vector.cc +++ b/deps/v8/src/objects/feedback-vector.cc @@ -887,8 +887,7 @@ float FeedbackNexus::ComputeCallFrequency() { double const invocation_count = vector().invocation_count(); double const call_count = GetCallCount(); - if (invocation_count == 0) { - // Prevent division by 0. + if (invocation_count == 0.0) { // Prevent division by 0. return 0.0f; } return static_cast<float>(call_count / invocation_count); @@ -1094,6 +1093,12 @@ Name FeedbackNexus::GetName() const { return Name::cast(feedback->GetHeapObjectAssumeStrong()); } } + if (IsStoreDataPropertyInLiteralKind(kind())) { + MaybeObject extra = GetFeedbackExtra(); + if (IsPropertyNameFeedback(extra)) { + return Name::cast(extra->GetHeapObjectAssumeStrong()); + } + } return Name(); } @@ -1180,7 +1185,8 @@ KeyedAccessStoreMode KeyedAccessStoreModeForBuiltin(int builtin_index) { } // namespace KeyedAccessStoreMode FeedbackNexus::GetKeyedAccessStoreMode() const { - DCHECK(IsKeyedStoreICKind(kind()) || IsStoreInArrayLiteralICKind(kind())); + DCHECK(IsKeyedStoreICKind(kind()) || IsStoreInArrayLiteralICKind(kind()) || + IsStoreDataPropertyInLiteralKind(kind())); KeyedAccessStoreMode mode = STANDARD_STORE; MapHandles maps; MaybeObjectHandles handlers; @@ -1220,14 +1226,17 @@ KeyedAccessStoreMode FeedbackNexus::GetKeyedAccessStoreMode() const { IcCheckType FeedbackNexus::GetKeyType() const { DCHECK(IsKeyedStoreICKind(kind()) || IsKeyedLoadICKind(kind()) || - IsStoreInArrayLiteralICKind(kind()) || IsKeyedHasICKind(kind())); + IsStoreInArrayLiteralICKind(kind()) || IsKeyedHasICKind(kind()) || + IsStoreDataPropertyInLiteralKind(kind())); MaybeObject feedback = GetFeedback(); if (feedback == MaybeObject::FromObject( *FeedbackVector::MegamorphicSentinel(GetIsolate()))) { return static_cast<IcCheckType>( Smi::ToInt(GetFeedbackExtra()->cast<Object>())); } - return IsPropertyNameFeedback(feedback) ? PROPERTY : ELEMENT; + MaybeObject maybe_name = + IsStoreDataPropertyInLiteralKind(kind()) ? GetFeedbackExtra() : feedback; + return IsPropertyNameFeedback(maybe_name) ? PROPERTY : ELEMENT; } BinaryOperationHint FeedbackNexus::GetBinaryOperationFeedback() const { diff --git a/deps/v8/src/objects/field-index.h b/deps/v8/src/objects/field-index.h index a6657634c8..4fae87774d 100644 --- a/deps/v8/src/objects/field-index.h +++ b/deps/v8/src/objects/field-index.h @@ -107,18 +107,16 @@ class FieldIndex final { (kDescriptorIndexBitCount + 1 + kTaggedSizeLog2); // Index from beginning of object. - class OffsetBits : public BitField64<int, 0, kOffsetBitsSize> {}; - class IsInObjectBits : public BitField64<bool, OffsetBits::kNext, 1> {}; - class EncodingBits : public BitField64<Encoding, IsInObjectBits::kNext, 2> {}; + using OffsetBits = BitField64<int, 0, kOffsetBitsSize>; + using IsInObjectBits = OffsetBits::Next<bool, 1>; + using EncodingBits = IsInObjectBits::Next<Encoding, 2>; // Number of inobject properties. - class InObjectPropertyBits - : public BitField64<int, EncodingBits::kNext, kDescriptorIndexBitCount> { - }; + using InObjectPropertyBits = + EncodingBits::Next<int, kDescriptorIndexBitCount>; // Offset of first inobject property from beginning of object. - class FirstInobjectPropertyOffsetBits - : public BitField64<int, InObjectPropertyBits::kNext, - kFirstInobjectPropertyOffsetBitCount> {}; - STATIC_ASSERT(FirstInobjectPropertyOffsetBits::kNext <= 64); + using FirstInobjectPropertyOffsetBits = + InObjectPropertyBits::Next<int, kFirstInobjectPropertyOffsetBitCount>; + STATIC_ASSERT(FirstInobjectPropertyOffsetBits::kLastUsedBit < 64); uint64_t bit_field_; }; diff --git a/deps/v8/src/objects/fixed-array.h b/deps/v8/src/objects/fixed-array.h index ca6f06e83c..40290797f7 100644 --- a/deps/v8/src/objects/fixed-array.h +++ b/deps/v8/src/objects/fixed-array.h @@ -247,7 +247,10 @@ class FixedDoubleArray : public FixedArrayBase { DECL_CAST(FixedDoubleArray) - // Maximally allowed length of a FixedArray. + // Start offset of elements. + static constexpr int kFloatsOffset = kHeaderSize; + + // Maximally allowed length of a FixedDoubleArray. static const int kMaxLength = (kMaxSize - kHeaderSize) / kDoubleSize; static_assert(Internals::IsValidSmi(kMaxLength), "FixedDoubleArray maxLength not a Smi"); diff --git a/deps/v8/src/objects/function-kind.h b/deps/v8/src/objects/function-kind.h index 4a1819813c..8e9c68e426 100644 --- a/deps/v8/src/objects/function-kind.h +++ b/deps/v8/src/objects/function-kind.h @@ -1,4 +1,3 @@ - // Copyright 2019 the V8 project authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -21,12 +20,12 @@ enum FunctionKind : uint8_t { // BEGIN default constructors kDefaultBaseConstructor, // END base constructors - // BEGIN derived cosntructors + // BEGIN derived constructors kDefaultDerivedConstructor, // END default constructors kDerivedConstructor, - // END derived costructors - // END class cosntructors + // END derived constructors + // END class constructors // END constructable functions. // BEGIN accessors kGetterFunction, diff --git a/deps/v8/src/objects/function-syntax-kind.h b/deps/v8/src/objects/function-syntax-kind.h new file mode 100644 index 0000000000..074ccc4286 --- /dev/null +++ b/deps/v8/src/objects/function-syntax-kind.h @@ -0,0 +1,46 @@ +// Copyright 2019 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef V8_OBJECTS_FUNCTION_SYNTAX_KIND_H_ +#define V8_OBJECTS_FUNCTION_SYNTAX_KIND_H_ + +#include "src/utils/utils.h" + +namespace v8 { +namespace internal { + +enum class FunctionSyntaxKind : uint8_t { + kAnonymousExpression, + kNamedExpression, + kDeclaration, + kAccessorOrMethod, + kWrapped, + + kLastFunctionSyntaxKind = kWrapped, +}; + +inline const char* FunctionSyntaxKind2String(FunctionSyntaxKind kind) { + switch (kind) { + case FunctionSyntaxKind::kAnonymousExpression: + return "AnonymousExpression"; + case FunctionSyntaxKind::kNamedExpression: + return "NamedExpression"; + case FunctionSyntaxKind::kDeclaration: + return "Declaration"; + case FunctionSyntaxKind::kAccessorOrMethod: + return "AccessorOrMethod"; + case FunctionSyntaxKind::kWrapped: + return "Wrapped"; + } + UNREACHABLE(); +} + +inline std::ostream& operator<<(std::ostream& os, FunctionSyntaxKind kind) { + return os << FunctionSyntaxKind2String(kind); +} + +} // namespace internal +} // namespace v8 + +#endif // V8_OBJECTS_FUNCTION_SYNTAX_KIND_H_ diff --git a/deps/v8/src/objects/heap-number-inl.h b/deps/v8/src/objects/heap-number-inl.h index 3d70d71c89..78e65ca231 100644 --- a/deps/v8/src/objects/heap-number-inl.h +++ b/deps/v8/src/objects/heap-number-inl.h @@ -16,34 +16,31 @@ namespace v8 { namespace internal { -OBJECT_CONSTRUCTORS_IMPL(HeapNumberBase, HeapObject) -OBJECT_CONSTRUCTORS_IMPL(HeapNumber, HeapNumberBase) -OBJECT_CONSTRUCTORS_IMPL(MutableHeapNumber, HeapNumberBase) +OBJECT_CONSTRUCTORS_IMPL(HeapNumber, HeapObject) CAST_ACCESSOR(HeapNumber) -CAST_ACCESSOR(MutableHeapNumber) -double HeapNumberBase::value() const { return ReadField<double>(kValueOffset); } +double HeapNumber::value() const { return ReadField<double>(kValueOffset); } -void HeapNumberBase::set_value(double value) { +void HeapNumber::set_value(double value) { WriteField<double>(kValueOffset, value); } -uint64_t HeapNumberBase::value_as_bits() const { +uint64_t HeapNumber::value_as_bits() const { // Bug(v8:8875): HeapNumber's double may be unaligned. return base::ReadUnalignedValue<uint64_t>(field_address(kValueOffset)); } -void HeapNumberBase::set_value_as_bits(uint64_t bits) { +void HeapNumber::set_value_as_bits(uint64_t bits) { base::WriteUnalignedValue<uint64_t>(field_address(kValueOffset), bits); } -int HeapNumberBase::get_exponent() { +int HeapNumber::get_exponent() { return ((ReadField<int>(kExponentOffset) & kExponentMask) >> kExponentShift) - kExponentBias; } -int HeapNumberBase::get_sign() { +int HeapNumber::get_sign() { return ReadField<int>(kExponentOffset) & kSignMask; } diff --git a/deps/v8/src/objects/heap-number.h b/deps/v8/src/objects/heap-number.h index 15e821e966..9063f3d22c 100644 --- a/deps/v8/src/objects/heap-number.h +++ b/deps/v8/src/objects/heap-number.h @@ -14,10 +14,8 @@ namespace v8 { namespace internal { // The HeapNumber class describes heap allocated numbers that cannot be -// represented in a Smi (small integer). MutableHeapNumber is the same, but its -// number value can change over time (it is used only as property storage). -// HeapNumberBase merely exists to avoid code duplication. -class HeapNumberBase : public HeapObject { +// represented in a Smi (small integer). +class HeapNumber : public HeapObject { public: // [value]: number value. inline double value() const; @@ -58,27 +56,10 @@ class HeapNumberBase : public HeapObject { static const int kMantissaBitsInTopWord = 20; static const int kNonMantissaBitsInTopWord = 12; - // Just to make the macro-generated constructor happy. Subclasses should - // perform their own proper type checking. - inline bool IsHeapNumberBase() const { return true; } - - OBJECT_CONSTRUCTORS(HeapNumberBase, HeapObject); -}; - -class HeapNumber : public HeapNumberBase { - public: DECL_CAST(HeapNumber) V8_EXPORT_PRIVATE void HeapNumberPrint(std::ostream& os); - OBJECT_CONSTRUCTORS(HeapNumber, HeapNumberBase); -}; - -class MutableHeapNumber : public HeapNumberBase { - public: - DECL_CAST(MutableHeapNumber) - V8_EXPORT_PRIVATE void MutableHeapNumberPrint(std::ostream& os); - - OBJECT_CONSTRUCTORS(MutableHeapNumber, HeapNumberBase); + OBJECT_CONSTRUCTORS(HeapNumber, HeapObject); }; } // namespace internal diff --git a/deps/v8/src/objects/instance-type.h b/deps/v8/src/objects/instance-type.h index 79c953aa87..9a855de95b 100644 --- a/deps/v8/src/objects/instance-type.h +++ b/deps/v8/src/objects/instance-type.h @@ -133,7 +133,6 @@ enum InstanceType : uint16_t { // "Data", objects that cannot contain non-map-word pointers to heap // objects. - MUTABLE_HEAP_NUMBER_TYPE, FOREIGN_TYPE, BYTE_ARRAY_TYPE, BYTECODE_ARRAY_TYPE, @@ -181,8 +180,7 @@ enum InstanceType : uint16_t { CALLBACK_TASK_TYPE, PROMISE_FULFILL_REACTION_JOB_TASK_TYPE, PROMISE_REJECT_REACTION_JOB_TASK_TYPE, - PROMISE_RESOLVE_THENABLE_JOB_TASK_TYPE, - FINALIZATION_GROUP_CLEANUP_JOB_TASK_TYPE, // LAST_MICROTASK_TYPE + PROMISE_RESOLVE_THENABLE_JOB_TASK_TYPE, // LAST_MICROTASK_TYPE #define MAKE_TORQUE_INSTANCE_TYPE(V) V, TORQUE_DEFINED_INSTANCE_TYPES(MAKE_TORQUE_INSTANCE_TYPE) @@ -346,7 +344,7 @@ enum InstanceType : uint16_t { LAST_CONTEXT_TYPE = WITH_CONTEXT_TYPE, // Boundaries for testing if given HeapObject is a subclass of Microtask. FIRST_MICROTASK_TYPE = CALLABLE_TASK_TYPE, - LAST_MICROTASK_TYPE = FINALIZATION_GROUP_CLEANUP_JOB_TASK_TYPE, + LAST_MICROTASK_TYPE = PROMISE_RESOLVE_THENABLE_JOB_TASK_TYPE, // Boundaries of module record types FIRST_MODULE_TYPE = SOURCE_TEXT_MODULE_TYPE, LAST_MODULE_TYPE = SYNTHETIC_MODULE_TYPE, @@ -462,7 +460,6 @@ V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os, V(JSWeakSet, JS_WEAK_SET_TYPE) \ V(LoadHandler, LOAD_HANDLER_TYPE) \ V(Map, MAP_TYPE) \ - V(MutableHeapNumber, MUTABLE_HEAP_NUMBER_TYPE) \ V(NameDictionary, NAME_DICTIONARY_TYPE) \ V(NativeContext, NATIVE_CONTEXT_TYPE) \ V(NumberDictionary, NUMBER_DICTIONARY_TYPE) \ diff --git a/deps/v8/src/objects/js-collection-inl.h b/deps/v8/src/objects/js-collection-inl.h index fb0cf1652e..6bbaa9bc1f 100644 --- a/deps/v8/src/objects/js-collection-inl.h +++ b/deps/v8/src/objects/js-collection-inl.h @@ -19,17 +19,17 @@ namespace v8 { namespace internal { -OBJECT_CONSTRUCTORS_IMPL(JSCollection, JSObject) -OBJECT_CONSTRUCTORS_IMPL(JSMap, JSCollection) -OBJECT_CONSTRUCTORS_IMPL(JSSet, JSCollection) -OBJECT_CONSTRUCTORS_IMPL(JSWeakCollection, JSObject) -OBJECT_CONSTRUCTORS_IMPL(JSWeakMap, JSWeakCollection) -OBJECT_CONSTRUCTORS_IMPL(JSWeakSet, JSWeakCollection) +TQ_OBJECT_CONSTRUCTORS_IMPL(JSCollection) +TQ_OBJECT_CONSTRUCTORS_IMPL(JSMap) +TQ_OBJECT_CONSTRUCTORS_IMPL(JSSet) +TQ_OBJECT_CONSTRUCTORS_IMPL(JSWeakCollection) +TQ_OBJECT_CONSTRUCTORS_IMPL(JSWeakMap) +TQ_OBJECT_CONSTRUCTORS_IMPL(JSWeakSet) // TODO(jkummerow): Move JSCollectionIterator to js-collection.h? // TODO(jkummerow): Introduce IsJSCollectionIterator() check? Or unchecked // version of OBJECT_CONSTRUCTORS_IMPL macro? -JSCollectionIterator::JSCollectionIterator(Address ptr) : JSObject(ptr) {} +TQ_OBJECT_CONSTRUCTORS_IMPL(JSCollectionIterator) template <class Derived, class TableType> OrderedHashTableIterator<Derived, TableType>::OrderedHashTableIterator( Address ptr) @@ -45,20 +45,8 @@ JSSetIterator::JSSetIterator(Address ptr) SLOW_DCHECK(IsJSSetIterator()); } -ACCESSORS(JSCollection, table, Object, kTableOffset) -ACCESSORS(JSCollectionIterator, table, Object, kTableOffset) -ACCESSORS(JSCollectionIterator, index, Object, kIndexOffset) - -ACCESSORS(JSWeakCollection, table, Object, kTableOffset) - -CAST_ACCESSOR(JSCollection) -CAST_ACCESSOR(JSSet) CAST_ACCESSOR(JSSetIterator) -CAST_ACCESSOR(JSMap) CAST_ACCESSOR(JSMapIterator) -CAST_ACCESSOR(JSWeakCollection) -CAST_ACCESSOR(JSWeakMap) -CAST_ACCESSOR(JSWeakSet) Object JSMapIterator::CurrentValue() { OrderedHashMap table = OrderedHashMap::cast(this->table()); diff --git a/deps/v8/src/objects/js-collection-iterator.h b/deps/v8/src/objects/js-collection-iterator.h index c002294b01..b193aa84cd 100644 --- a/deps/v8/src/objects/js-collection-iterator.h +++ b/deps/v8/src/objects/js-collection-iterator.h @@ -16,21 +16,13 @@ namespace v8 { namespace internal { -class JSCollectionIterator : public JSObject { +class JSCollectionIterator + : public TorqueGeneratedJSCollectionIterator<JSCollectionIterator, + JSObject> { public: - // [table]: the backing hash table mapping keys to values. - DECL_ACCESSORS(table, Object) - - // [index]: The index into the data table. - DECL_ACCESSORS(index, Object) - void JSCollectionIteratorPrint(std::ostream& os, const char* name); - DECL_VERIFIER(JSCollectionIterator) - - DEFINE_FIELD_OFFSET_CONSTANTS(JSObject::kHeaderSize, - TORQUE_GENERATED_JSCOLLECTION_ITERATOR_FIELDS) - OBJECT_CONSTRUCTORS(JSCollectionIterator, JSObject); + TQ_OBJECT_CONSTRUCTORS(JSCollectionIterator) }; // OrderedHashTableIterator is an iterator that iterates over the keys and diff --git a/deps/v8/src/objects/js-collection.h b/deps/v8/src/objects/js-collection.h index 0a856ca062..d1b2ae862a 100644 --- a/deps/v8/src/objects/js-collection.h +++ b/deps/v8/src/objects/js-collection.h @@ -17,39 +17,25 @@ namespace internal { class OrderedHashSet; class OrderedHashMap; -class JSCollection : public JSObject { +class JSCollection + : public TorqueGeneratedJSCollection<JSCollection, JSObject> { public: - DECL_CAST(JSCollection) - - // [table]: the backing hash table - DECL_ACCESSORS(table, Object) - - // Layout description. - DEFINE_FIELD_OFFSET_CONSTANTS(JSObject::kHeaderSize, - TORQUE_GENERATED_JSCOLLECTION_FIELDS) - static const int kAddFunctionDescriptorIndex = 3; - DECL_VERIFIER(JSCollection) - - OBJECT_CONSTRUCTORS(JSCollection, JSObject); + TQ_OBJECT_CONSTRUCTORS(JSCollection) }; // The JSSet describes EcmaScript Harmony sets -class JSSet : public JSCollection { +class JSSet : public TorqueGeneratedJSSet<JSSet, JSCollection> { public: - DECL_CAST(JSSet) - static void Initialize(Handle<JSSet> set, Isolate* isolate); static void Clear(Isolate* isolate, Handle<JSSet> set); // Dispatched behavior. DECL_PRINTER(JSSet) DECL_VERIFIER(JSSet) - DEFINE_FIELD_OFFSET_CONSTANTS(JSCollection::kHeaderSize, - TORQUE_GENERATED_JSWEAK_SET_FIELDS) - OBJECT_CONSTRUCTORS(JSSet, JSCollection); + TQ_OBJECT_CONSTRUCTORS(JSSet) }; class JSSetIterator @@ -66,20 +52,16 @@ class JSSetIterator }; // The JSMap describes EcmaScript Harmony maps -class JSMap : public JSCollection { +class JSMap : public TorqueGeneratedJSMap<JSMap, JSCollection> { public: - DECL_CAST(JSMap) - static void Initialize(Handle<JSMap> map, Isolate* isolate); static void Clear(Isolate* isolate, Handle<JSMap> map); // Dispatched behavior. DECL_PRINTER(JSMap) DECL_VERIFIER(JSMap) - DEFINE_FIELD_OFFSET_CONSTANTS(JSCollection::kHeaderSize, - TORQUE_GENERATED_JSWEAK_MAP_FIELDS) - OBJECT_CONSTRUCTORS(JSMap, JSCollection); + TQ_OBJECT_CONSTRUCTORS(JSMap) }; class JSMapIterator @@ -100,13 +82,9 @@ class JSMapIterator }; // Base class for both JSWeakMap and JSWeakSet -class JSWeakCollection : public JSObject { +class JSWeakCollection + : public TorqueGeneratedJSWeakCollection<JSWeakCollection, JSObject> { public: - DECL_CAST(JSWeakCollection) - - // [table]: the backing hash table mapping keys to values. - DECL_ACCESSORS(table, Object) - static void Initialize(Handle<JSWeakCollection> collection, Isolate* isolate); V8_EXPORT_PRIVATE static void Set(Handle<JSWeakCollection> collection, Handle<Object> key, Handle<Object> value, @@ -116,11 +94,6 @@ class JSWeakCollection : public JSObject { static Handle<JSArray> GetEntries(Handle<JSWeakCollection> holder, int max_entries); - DECL_VERIFIER(JSWeakCollection) - - DEFINE_FIELD_OFFSET_CONSTANTS(JSObject::kHeaderSize, - TORQUE_GENERATED_JSWEAK_COLLECTION_FIELDS) - static const int kAddFunctionDescriptorIndex = 3; // Iterates the function object according to the visiting policy. @@ -131,37 +104,29 @@ class JSWeakCollection : public JSObject { static const int kSizeOfAllWeakCollections = kHeaderSize; - OBJECT_CONSTRUCTORS(JSWeakCollection, JSObject); + TQ_OBJECT_CONSTRUCTORS(JSWeakCollection) }; // The JSWeakMap describes EcmaScript Harmony weak maps -class JSWeakMap : public JSWeakCollection { +class JSWeakMap : public TorqueGeneratedJSWeakMap<JSWeakMap, JSWeakCollection> { public: - DECL_CAST(JSWeakMap) - // Dispatched behavior. DECL_PRINTER(JSWeakMap) DECL_VERIFIER(JSWeakMap) - DEFINE_FIELD_OFFSET_CONSTANTS(JSWeakCollection::kHeaderSize, - TORQUE_GENERATED_JSWEAK_MAP_FIELDS) STATIC_ASSERT(kSize == kSizeOfAllWeakCollections); - OBJECT_CONSTRUCTORS(JSWeakMap, JSWeakCollection); + TQ_OBJECT_CONSTRUCTORS(JSWeakMap) }; // The JSWeakSet describes EcmaScript Harmony weak sets -class JSWeakSet : public JSWeakCollection { +class JSWeakSet : public TorqueGeneratedJSWeakSet<JSWeakSet, JSWeakCollection> { public: - DECL_CAST(JSWeakSet) - // Dispatched behavior. DECL_PRINTER(JSWeakSet) DECL_VERIFIER(JSWeakSet) - DEFINE_FIELD_OFFSET_CONSTANTS(JSWeakCollection::kHeaderSize, - TORQUE_GENERATED_JSWEAK_SET_FIELDS) - STATIC_ASSERT(kSize == kSizeOfAllWeakCollections); - OBJECT_CONSTRUCTORS(JSWeakSet, JSWeakCollection); + STATIC_ASSERT(kSize == kSizeOfAllWeakCollections); + TQ_OBJECT_CONSTRUCTORS(JSWeakSet) }; } // namespace internal diff --git a/deps/v8/src/objects/js-date-time-format.cc b/deps/v8/src/objects/js-date-time-format.cc index db7ba27312..29fcfb0d7c 100644 --- a/deps/v8/src/objects/js-date-time-format.cc +++ b/deps/v8/src/objects/js-date-time-format.cc @@ -8,8 +8,11 @@ #include "src/objects/js-date-time-format.h" +#include <algorithm> +#include <map> #include <memory> #include <string> +#include <utility> #include <vector> #include "src/date/date.h" @@ -1191,6 +1194,12 @@ class DateTimePatternGeneratorCache { UErrorCode status = U_ZERO_ERROR; map_[key].reset(icu::DateTimePatternGenerator::createInstance( icu::Locale(key.c_str()), status)); + // Fallback to use "root". + if (U_FAILURE(status)) { + status = U_ZERO_ERROR; + map_[key].reset( + icu::DateTimePatternGenerator::createInstance("root", status)); + } CHECK(U_SUCCESS(status)); return map_[key]->clone(); } diff --git a/deps/v8/src/objects/js-generator-inl.h b/deps/v8/src/objects/js-generator-inl.h index d0fe2cd90e..e3c57198c4 100644 --- a/deps/v8/src/objects/js-generator-inl.h +++ b/deps/v8/src/objects/js-generator-inl.h @@ -16,29 +16,15 @@ namespace v8 { namespace internal { -OBJECT_CONSTRUCTORS_IMPL(JSGeneratorObject, JSObject) -OBJECT_CONSTRUCTORS_IMPL(JSAsyncFunctionObject, JSGeneratorObject) -OBJECT_CONSTRUCTORS_IMPL(JSAsyncGeneratorObject, JSGeneratorObject) -OBJECT_CONSTRUCTORS_IMPL(AsyncGeneratorRequest, Struct) +TQ_OBJECT_CONSTRUCTORS_IMPL(JSGeneratorObject) +TQ_OBJECT_CONSTRUCTORS_IMPL(JSAsyncFunctionObject) +TQ_OBJECT_CONSTRUCTORS_IMPL(JSAsyncGeneratorObject) +TQ_OBJECT_CONSTRUCTORS_IMPL(AsyncGeneratorRequest) -CAST_ACCESSOR(JSAsyncFunctionObject) -CAST_ACCESSOR(JSAsyncGeneratorObject) -CAST_ACCESSOR(JSGeneratorObject) -CAST_ACCESSOR(AsyncGeneratorRequest) +TQ_SMI_ACCESSORS(JSGeneratorObject, resume_mode) +TQ_SMI_ACCESSORS(JSGeneratorObject, continuation) -ACCESSORS(JSGeneratorObject, function, JSFunction, kFunctionOffset) -ACCESSORS(JSGeneratorObject, context, Context, kContextOffset) -ACCESSORS(JSGeneratorObject, receiver, Object, kReceiverOffset) -ACCESSORS(JSGeneratorObject, input_or_debug_pos, Object, kInputOrDebugPosOffset) -SMI_ACCESSORS(JSGeneratorObject, resume_mode, kResumeModeOffset) -SMI_ACCESSORS(JSGeneratorObject, continuation, kContinuationOffset) -ACCESSORS(JSGeneratorObject, parameters_and_registers, FixedArray, - kParametersAndRegistersOffset) - -ACCESSORS(AsyncGeneratorRequest, next, Object, kNextOffset) -SMI_ACCESSORS(AsyncGeneratorRequest, resume_mode, kResumeModeOffset) -ACCESSORS(AsyncGeneratorRequest, value, Object, kValueOffset) -ACCESSORS(AsyncGeneratorRequest, promise, Object, kPromiseOffset) +TQ_SMI_ACCESSORS(AsyncGeneratorRequest, resume_mode) bool JSGeneratorObject::is_suspended() const { DCHECK_LT(kGeneratorExecuting, 0); @@ -54,10 +40,7 @@ bool JSGeneratorObject::is_executing() const { return continuation() == kGeneratorExecuting; } -ACCESSORS(JSAsyncFunctionObject, promise, JSPromise, kPromiseOffset) - -ACCESSORS(JSAsyncGeneratorObject, queue, HeapObject, kQueueOffset) -SMI_ACCESSORS(JSAsyncGeneratorObject, is_awaiting, kIsAwaitingOffset) +TQ_SMI_ACCESSORS(JSAsyncGeneratorObject, is_awaiting) } // namespace internal } // namespace v8 diff --git a/deps/v8/src/objects/js-generator.h b/deps/v8/src/objects/js-generator.h index 0e99d824ab..a56ea917eb 100644 --- a/deps/v8/src/objects/js-generator.h +++ b/deps/v8/src/objects/js-generator.h @@ -17,24 +17,9 @@ namespace internal { // Forward declarations. class JSPromise; -class JSGeneratorObject : public JSObject { +class JSGeneratorObject + : public TorqueGeneratedJSGeneratorObject<JSGeneratorObject, JSObject> { public: - // [function]: The function corresponding to this generator object. - DECL_ACCESSORS(function, JSFunction) - - // [context]: The context of the suspended computation. - DECL_ACCESSORS(context, Context) - - // [receiver]: The receiver of the suspended computation. - DECL_ACCESSORS(receiver, Object) - - // [input_or_debug_pos] - // For executing generators: the most recent input value. - // For suspended generators: debug information (bytecode offset). - // There is currently no need to remember the most recent input value for a - // suspended generator. - DECL_ACCESSORS(input_or_debug_pos, Object) - // [resume_mode]: The most recent resume mode. enum ResumeMode { kNext, kReturn, kThrow }; DECL_INT_ACCESSORS(resume_mode) @@ -54,84 +39,50 @@ class JSGeneratorObject : public JSObject { // is suspended. int source_position() const; - // [parameters_and_registers]: Saved interpreter register file. - DECL_ACCESSORS(parameters_and_registers, FixedArray) - - DECL_CAST(JSGeneratorObject) - // Dispatched behavior. DECL_PRINTER(JSGeneratorObject) - DECL_VERIFIER(JSGeneratorObject) // Magic sentinel values for the continuation. static const int kGeneratorExecuting = -2; static const int kGeneratorClosed = -1; - // Layout description. - DEFINE_FIELD_OFFSET_CONSTANTS(JSObject::kHeaderSize, - TORQUE_GENERATED_JSGENERATOR_OBJECT_FIELDS) - - OBJECT_CONSTRUCTORS(JSGeneratorObject, JSObject); + TQ_OBJECT_CONSTRUCTORS(JSGeneratorObject) }; -class JSAsyncFunctionObject : public JSGeneratorObject { +class JSAsyncFunctionObject + : public TorqueGeneratedJSAsyncFunctionObject<JSAsyncFunctionObject, + JSGeneratorObject> { public: - DECL_CAST(JSAsyncFunctionObject) - // Dispatched behavior. DECL_VERIFIER(JSAsyncFunctionObject) - // [promise]: The promise of the async function. - DECL_ACCESSORS(promise, JSPromise) - - // Layout description. - DEFINE_FIELD_OFFSET_CONSTANTS(JSGeneratorObject::kSize, - TORQUE_GENERATED_JSASYNC_FUNCTION_OBJECT_FIELDS) - - OBJECT_CONSTRUCTORS(JSAsyncFunctionObject, JSGeneratorObject); + TQ_OBJECT_CONSTRUCTORS(JSAsyncFunctionObject) }; -class JSAsyncGeneratorObject : public JSGeneratorObject { +class JSAsyncGeneratorObject + : public TorqueGeneratedJSAsyncGeneratorObject<JSAsyncGeneratorObject, + JSGeneratorObject> { public: - DECL_CAST(JSAsyncGeneratorObject) - // Dispatched behavior. DECL_VERIFIER(JSAsyncGeneratorObject) - // [queue] - // Pointer to the head of a singly linked list of AsyncGeneratorRequest, or - // undefined. - DECL_ACCESSORS(queue, HeapObject) - // [is_awaiting] // Whether or not the generator is currently awaiting. DECL_INT_ACCESSORS(is_awaiting) - // Layout description. - DEFINE_FIELD_OFFSET_CONSTANTS( - JSGeneratorObject::kSize, - TORQUE_GENERATED_JSASYNC_GENERATOR_OBJECT_FIELDS) -#undef JS_ASYNC_GENERATOR_FIELDS - - OBJECT_CONSTRUCTORS(JSAsyncGeneratorObject, JSGeneratorObject); + TQ_OBJECT_CONSTRUCTORS(JSAsyncGeneratorObject) }; -class AsyncGeneratorRequest : public Struct { +class AsyncGeneratorRequest + : public TorqueGeneratedAsyncGeneratorRequest<AsyncGeneratorRequest, + Struct> { public: - // Holds an AsyncGeneratorRequest, or Undefined. - DECL_ACCESSORS(next, Object) DECL_INT_ACCESSORS(resume_mode) - DECL_ACCESSORS(value, Object) - DECL_ACCESSORS(promise, Object) - - DEFINE_FIELD_OFFSET_CONSTANTS(Struct::kHeaderSize, - TORQUE_GENERATED_ASYNC_GENERATOR_REQUEST_FIELDS) - DECL_CAST(AsyncGeneratorRequest) DECL_PRINTER(AsyncGeneratorRequest) DECL_VERIFIER(AsyncGeneratorRequest) - OBJECT_CONSTRUCTORS(AsyncGeneratorRequest, Struct); + TQ_OBJECT_CONSTRUCTORS(AsyncGeneratorRequest) }; } // namespace internal diff --git a/deps/v8/src/objects/js-number-format.cc b/deps/v8/src/objects/js-number-format.cc index d1e3ef4d0c..ff564975d6 100644 --- a/deps/v8/src/objects/js-number-format.cc +++ b/deps/v8/src/objects/js-number-format.cc @@ -172,16 +172,21 @@ std::map<const std::string, icu::MeasureUnit> CreateUnitMap() { status = U_ZERO_ERROR; // See the list in ecma402 #sec-issanctionedsimpleunitidentifier std::set<std::string> sanctioned( - {"acre", "bit", "byte", "celsius", - "centimeter", "day", "degree", "fahrenheit", - "foot", "gigabit", "gigabyte", "gram", - "hectare", "hour", "inch", "kilobit", - "kilobyte", "kilogram", "kilometer", "megabit", - "megabyte", "meter", "mile", "mile-scandinavian", - "millimeter", "millisecond", "minute", "month", - "ounce", "percent", "petabyte", "pound", - "second", "stone", "terabit", "terabyte", - "week", "yard", "year"}); + {"acre", "bit", "byte", + "celsius", "centimeter", "day", + "degree", "fahrenheit", "fluid-ounce", + "foot", "gallon", "gigabit", + "gigabyte", "gram", "hectare", + "hour", "inch", "kilobit", + "kilobyte", "kilogram", "kilometer", + "liter", "megabit", "megabyte", + "meter", "mile", "mile-scandinavian", + "millimeter", "milliliter", "millisecond", + "minute", "month", "ounce", + "percent", "petabyte", "pound", + "second", "stone", "terabit", + "terabyte", "week", "yard", + "year"}); std::vector<icu::MeasureUnit> units(total); total = icu::MeasureUnit::getAvailable(units.data(), total, status); CHECK(U_SUCCESS(status)); @@ -1031,7 +1036,7 @@ MaybeHandle<JSNumberFormat> JSNumberFormat::New(Isolate* isolate, isolate, NewTypeError(MessageTemplate::kInvalidUnit, factory->NewStringFromStaticChars("Intl.NumberFormat"), - factory->NewStringFromStaticChars("")), + factory->empty_string()), JSNumberFormat); } diff --git a/deps/v8/src/objects/js-objects-inl.h b/deps/v8/src/objects/js-objects-inl.h index 10672d4443..f8fe069d3d 100644 --- a/deps/v8/src/objects/js-objects-inl.h +++ b/deps/v8/src/objects/js-objects-inl.h @@ -31,9 +31,9 @@ namespace internal { OBJECT_CONSTRUCTORS_IMPL(JSReceiver, HeapObject) TQ_OBJECT_CONSTRUCTORS_IMPL(JSObject) -OBJECT_CONSTRUCTORS_IMPL(JSAsyncFromSyncIterator, JSObject) -OBJECT_CONSTRUCTORS_IMPL(JSBoundFunction, JSObject) -OBJECT_CONSTRUCTORS_IMPL(JSDate, JSObject) +TQ_OBJECT_CONSTRUCTORS_IMPL(JSAsyncFromSyncIterator) +TQ_OBJECT_CONSTRUCTORS_IMPL(JSBoundFunction) +TQ_OBJECT_CONSTRUCTORS_IMPL(JSDate) OBJECT_CONSTRUCTORS_IMPL(JSFunction, JSObject) OBJECT_CONSTRUCTORS_IMPL(JSGlobalObject, JSObject) TQ_OBJECT_CONSTRUCTORS_IMPL(JSGlobalProxy) @@ -44,9 +44,6 @@ OBJECT_CONSTRUCTORS_IMPL(JSStringIterator, JSObject) NEVER_READ_ONLY_SPACE_IMPL(JSReceiver) -CAST_ACCESSOR(JSAsyncFromSyncIterator) -CAST_ACCESSOR(JSBoundFunction) -CAST_ACCESSOR(JSDate) CAST_ACCESSOR(JSFunction) CAST_ACCESSOR(JSGlobalObject) CAST_ACCESSOR(JSIteratorResult) @@ -369,10 +366,10 @@ void JSObject::RawFastDoublePropertyAsBitsAtPut(FieldIndex index, void JSObject::FastPropertyAtPut(FieldIndex index, Object value) { if (IsUnboxedDoubleField(index)) { - DCHECK(value.IsMutableHeapNumber()); + DCHECK(value.IsHeapNumber()); // Ensure that all bits of the double value are preserved. - RawFastDoublePropertyAsBitsAtPut( - index, MutableHeapNumber::cast(value).value_as_bits()); + RawFastDoublePropertyAsBitsAtPut(index, + HeapNumber::cast(value).value_as_bits()); } else { RawFastPropertyAtPut(index, value); } @@ -401,7 +398,7 @@ void JSObject::WriteToField(int descriptor, PropertyDetails details, if (IsUnboxedDoubleField(index)) { RawFastDoublePropertyAsBitsAtPut(index, bits); } else { - auto box = MutableHeapNumber::cast(RawFastPropertyAt(index)); + auto box = HeapNumber::cast(RawFastPropertyAt(index)); box.set_value_as_bits(bits); } } else { @@ -450,11 +447,6 @@ void JSObject::InitializeBody(Map map, int start_offset, } } -ACCESSORS(JSBoundFunction, bound_target_function, JSReceiver, - kBoundTargetFunctionOffset) -ACCESSORS(JSBoundFunction, bound_this, Object, kBoundThisOffset) -ACCESSORS(JSBoundFunction, bound_arguments, FixedArray, kBoundArgumentsOffset) - ACCESSORS(JSFunction, raw_feedback_cell, FeedbackCell, kFeedbackCellOffset) ACCESSORS(JSGlobalObject, native_context, NativeContext, kNativeContextOffset) @@ -712,16 +704,6 @@ void JSFunction::ResetIfBytecodeFlushed() { } } -ACCESSORS(JSDate, value, Object, kValueOffset) -ACCESSORS(JSDate, cache_stamp, Object, kCacheStampOffset) -ACCESSORS(JSDate, year, Object, kYearOffset) -ACCESSORS(JSDate, month, Object, kMonthOffset) -ACCESSORS(JSDate, day, Object, kDayOffset) -ACCESSORS(JSDate, weekday, Object, kWeekdayOffset) -ACCESSORS(JSDate, hour, Object, kHourOffset) -ACCESSORS(JSDate, min, Object, kMinOffset) -ACCESSORS(JSDate, sec, Object, kSecOffset) - bool JSMessageObject::DidEnsureSourcePositionsAvailable() const { return shared_info().IsUndefined(); } @@ -774,7 +756,8 @@ DEF_GETTER(JSObject, GetElementsKind, ElementsKind) { DCHECK(fixed_array.IsFixedArray(isolate)); DCHECK(fixed_array.IsNumberDictionary(isolate)); } else { - DCHECK(kind > DICTIONARY_ELEMENTS || IsFrozenOrSealedElementsKind(kind)); + DCHECK(kind > DICTIONARY_ELEMENTS || + IsAnyNonextensibleElementsKind(kind)); } DCHECK( !IsSloppyArgumentsElementsKind(kind) || @@ -824,14 +807,18 @@ DEF_GETTER(JSObject, HasPackedElements, bool) { return GetElementsKind(isolate) == PACKED_ELEMENTS; } -DEF_GETTER(JSObject, HasFrozenOrSealedElements, bool) { - return IsFrozenOrSealedElementsKind(GetElementsKind(isolate)); +DEF_GETTER(JSObject, HasAnyNonextensibleElements, bool) { + return IsAnyNonextensibleElementsKind(GetElementsKind(isolate)); } DEF_GETTER(JSObject, HasSealedElements, bool) { return IsSealedElementsKind(GetElementsKind(isolate)); } +DEF_GETTER(JSObject, HasNonextensibleElements, bool) { + return IsNonextensibleElementsKind(GetElementsKind(isolate)); +} + DEF_GETTER(JSObject, HasFastArgumentsElements, bool) { return GetElementsKind(isolate) == FAST_SLOPPY_ARGUMENTS_ELEMENTS; } @@ -1020,10 +1007,6 @@ inline int JSGlobalProxy::SizeWithEmbedderFields(int embedder_field_count) { ACCESSORS(JSIteratorResult, value, Object, kValueOffset) ACCESSORS(JSIteratorResult, done, Object, kDoneOffset) -ACCESSORS(JSAsyncFromSyncIterator, sync_iterator, JSReceiver, - kSyncIteratorOffset) -ACCESSORS(JSAsyncFromSyncIterator, next, Object, kNextOffset) - ACCESSORS(JSStringIterator, string, String, kStringOffset) SMI_ACCESSORS(JSStringIterator, index, kNextIndexOffset) diff --git a/deps/v8/src/objects/js-objects.cc b/deps/v8/src/objects/js-objects.cc index 5c4db16206..3666f5afbe 100644 --- a/deps/v8/src/objects/js-objects.cc +++ b/deps/v8/src/objects/js-objects.cc @@ -1509,20 +1509,27 @@ namespace { Maybe<bool> GetPropertyDescriptorWithInterceptor(LookupIterator* it, PropertyDescriptor* desc) { + Handle<InterceptorInfo> interceptor; + if (it->state() == LookupIterator::ACCESS_CHECK) { if (it->HasAccess()) { it->Next(); - } else if (!JSObject::AllCanRead(it) || - it->state() != LookupIterator::INTERCEPTOR) { - it->Restart(); - return Just(false); + } else { + interceptor = it->GetInterceptorForFailedAccessCheck(); + if (interceptor.is_null() && + (!JSObject::AllCanRead(it) || + it->state() != LookupIterator::INTERCEPTOR)) { + it->Restart(); + return Just(false); + } } } - if (it->state() != LookupIterator::INTERCEPTOR) return Just(false); - + if (it->state() == LookupIterator::INTERCEPTOR) { + interceptor = it->GetInterceptor(); + } + if (interceptor.is_null()) return Just(false); Isolate* isolate = it->isolate(); - Handle<InterceptorInfo> interceptor = it->GetInterceptor(); if (interceptor->descriptor().IsUndefined(isolate)) return Just(false); Handle<Object> result; @@ -1607,12 +1614,14 @@ Maybe<bool> JSReceiver::GetOwnPropertyDescriptor(LookupIterator* it, // 6. Else X is an accessor property, so Handle<AccessorPair> accessors = Handle<AccessorPair>::cast(it->GetAccessors()); + Handle<NativeContext> native_context = + it->GetHolder<JSReceiver>()->GetCreationContext(); // 6a. Set D.[[Get]] to the value of X's [[Get]] attribute. - desc->set_get( - AccessorPair::GetComponent(isolate, accessors, ACCESSOR_GETTER)); + desc->set_get(AccessorPair::GetComponent(isolate, native_context, accessors, + ACCESSOR_GETTER)); // 6b. Set D.[[Set]] to the value of X's [[Set]] attribute. - desc->set_set( - AccessorPair::GetComponent(isolate, accessors, ACCESSOR_SETTER)); + desc->set_set(AccessorPair::GetComponent(isolate, native_context, accessors, + ACCESSOR_SETTER)); } // 7. Set D.[[Enumerable]] to the value of X's [[Enumerable]] attribute. @@ -2039,7 +2048,7 @@ MaybeHandle<JSObject> JSObject::ObjectCreate(Isolate* isolate, void JSObject::EnsureWritableFastElements(Handle<JSObject> object) { DCHECK(object->HasSmiOrObjectElements() || object->HasFastStringWrapperElements() || - object->HasFrozenOrSealedElements()); + object->HasAnyNonextensibleElements()); FixedArray raw_elems = FixedArray::cast(object->elements()); Isolate* isolate = object->GetIsolate(); if (raw_elems.map() != ReadOnlyRoots(isolate).fixed_cow_array_map()) return; @@ -2622,12 +2631,12 @@ void MigrateFastToFast(Isolate* isolate, Handle<JSObject> object, FieldIndex::ForDescriptor(isolate, *new_map, new_map->LastAdded()); if (index.is_inobject() || index.outobject_array_index() < object->property_array(isolate).length()) { - // We still need to allocate MutableHeapNumbers for double fields + // We still need to allocate HeapNumbers for double fields // if either double field unboxing is disabled or the double field // is in the PropertyArray backing store (where we don't support // double field unboxing). if (index.is_double() && !new_map->IsUnboxedDoubleField(isolate, index)) { - auto value = isolate->factory()->NewMutableHeapNumberWithHoleNaN(); + auto value = isolate->factory()->NewHeapNumberWithHoleNaN(); object->RawFastPropertyAtPut(index, *value); } object->synchronized_set_map(*new_map); @@ -2644,7 +2653,7 @@ void MigrateFastToFast(Isolate* isolate, Handle<JSObject> object, // Properly initialize newly added property. Handle<Object> value; if (details.representation().IsDouble()) { - value = isolate->factory()->NewMutableHeapNumberWithHoleNaN(); + value = isolate->factory()->NewHeapNumberWithHoleNaN(); } else { value = isolate->factory()->uninitialized_value(); } @@ -2708,7 +2717,7 @@ void MigrateFastToFast(Isolate* isolate, Handle<JSObject> object, // must already be prepared for data of certain type. DCHECK(!details.representation().IsNone()); if (details.representation().IsDouble()) { - value = isolate->factory()->NewMutableHeapNumberWithHoleNaN(); + value = isolate->factory()->NewHeapNumberWithHoleNaN(); } else { value = isolate->factory()->uninitialized_value(); } @@ -2722,11 +2731,7 @@ void MigrateFastToFast(Isolate* isolate, Handle<JSObject> object, FieldIndex index = FieldIndex::ForDescriptor(isolate, *old_map, i); if (object->IsUnboxedDoubleField(isolate, index)) { uint64_t old_bits = object->RawFastDoublePropertyAsBitsAt(index); - if (representation.IsDouble()) { - value = isolate->factory()->NewMutableHeapNumberFromBits(old_bits); - } else { - value = isolate->factory()->NewHeapNumberFromBits(old_bits); - } + value = isolate->factory()->NewHeapNumberFromBits(old_bits); } else { value = handle(object->RawFastPropertyAt(isolate, index), isolate); if (!old_representation.IsDouble() && representation.IsDouble()) { @@ -2754,7 +2759,7 @@ void MigrateFastToFast(Isolate* isolate, Handle<JSObject> object, DCHECK_EQ(kData, details.kind()); Handle<Object> value; if (details.representation().IsDouble()) { - value = isolate->factory()->NewMutableHeapNumberWithHoleNaN(); + value = isolate->factory()->NewHeapNumberWithHoleNaN(); } else { value = isolate->factory()->uninitialized_value(); } @@ -2784,10 +2789,10 @@ void MigrateFastToFast(Isolate* isolate, Handle<JSObject> object, // Can't use JSObject::FastPropertyAtPut() because proper map was not set // yet. if (new_map->IsUnboxedDoubleField(isolate, index)) { - DCHECK(value.IsMutableHeapNumber(isolate)); + DCHECK(value.IsHeapNumber(isolate)); // Ensure that all bits of the double value are preserved. object->RawFastDoublePropertyAsBitsAtPut( - index, MutableHeapNumber::cast(value).value_as_bits()); + index, HeapNumber::cast(value).value_as_bits()); if (i < old_number_of_fields && !old_map->IsUnboxedDoubleField(index)) { // Transition from tagged to untagged slot. heap->ClearRecordedSlot(*object, object->RawField(index.offset())); @@ -2859,8 +2864,8 @@ void MigrateFastToSlow(Isolate* isolate, Handle<JSObject> object, } else { value = handle(object->RawFastPropertyAt(isolate, index), isolate); if (details.representation().IsDouble()) { - DCHECK(value->IsMutableHeapNumber(isolate)); - double old_value = Handle<MutableHeapNumber>::cast(value)->value(); + DCHECK(value->IsHeapNumber(isolate)); + double old_value = Handle<HeapNumber>::cast(value)->value(); value = isolate->factory()->NewHeapNumber(old_value); } } @@ -3048,7 +3053,7 @@ void JSObject::AllocateStorageForMap(Handle<JSObject> object, Handle<Map> map) { if (!representation.IsDouble()) continue; FieldIndex index = FieldIndex::ForDescriptor(*map, i); if (map->IsUnboxedDoubleField(index)) continue; - auto box = isolate->factory()->NewMutableHeapNumberWithHoleNaN(); + auto box = isolate->factory()->NewHeapNumberWithHoleNaN(); if (index.is_inobject()) { storage->set(index.property_index(), *box); } else { @@ -3464,7 +3469,8 @@ Handle<NumberDictionary> JSObject::NormalizeElements(Handle<JSObject> object) { DCHECK(object->HasSmiOrObjectElements() || object->HasDoubleElements() || object->HasFastArgumentsElements() || - object->HasFastStringWrapperElements() || object->HasSealedElements()); + object->HasFastStringWrapperElements() || + object->HasSealedElements() || object->HasNonextensibleElements()); Handle<NumberDictionary> dictionary = object->GetElementsAccessor()->Normalize(object); @@ -3637,6 +3643,7 @@ bool TestElementsIntegrityLevel(JSObject object, PropertyAttributes level) { } if (IsFrozenElementsKind(kind)) return true; if (IsSealedElementsKind(kind) && level != FROZEN) return true; + if (IsNonextensibleElementsKind(kind) && level == NONE) return true; ElementsAccessor* accessor = ElementsAccessor::ForKind(kind); // Only DICTIONARY_ELEMENTS and SLOW_SLOPPY_ARGUMENTS_ELEMENTS have @@ -3795,9 +3802,9 @@ Maybe<bool> JSObject::PreventExtensionsWithTransition( if (attrs == NONE && !object->map().is_extensible()) return Just(true); { ElementsKind old_elements_kind = object->map().elements_kind(); + if (IsFrozenElementsKind(old_elements_kind)) return Just(true); if (attrs != FROZEN && IsSealedElementsKind(old_elements_kind)) return Just(true); - if (old_elements_kind == PACKED_FROZEN_ELEMENTS) return Just(true); } if (object->IsJSGlobalProxy()) { @@ -3842,8 +3849,7 @@ Maybe<bool> JSObject::PreventExtensionsWithTransition( // elements kind change in one go. If seal or freeze with Smi or Double // elements kind, we will transition to Object elements kind first to make // sure of valid element access. - if (FLAG_enable_sealed_frozen_elements_kind && - (attrs == SEALED || attrs == FROZEN)) { + if (FLAG_enable_sealed_frozen_elements_kind) { switch (object->map().elements_kind()) { case PACKED_SMI_ELEMENTS: case PACKED_DOUBLE_ELEMENTS: @@ -3871,9 +3877,9 @@ Maybe<bool> JSObject::PreventExtensionsWithTransition( DCHECK(transition_map->has_dictionary_elements() || transition_map->has_typed_array_elements() || transition_map->elements_kind() == SLOW_STRING_WRAPPER_ELEMENTS || - transition_map->has_frozen_or_sealed_elements()); + transition_map->has_any_nonextensible_elements()); DCHECK(!transition_map->is_extensible()); - if (!transition_map->has_frozen_or_sealed_elements()) { + if (!transition_map->has_any_nonextensible_elements()) { new_element_dictionary = CreateElementDictionary(isolate, object); } JSObject::MigrateToMap(isolate, object, transition_map); @@ -3881,7 +3887,7 @@ Maybe<bool> JSObject::PreventExtensionsWithTransition( // Create a new descriptor array with the appropriate property attributes Handle<Map> new_map = Map::CopyForPreventExtensions( isolate, old_map, attrs, transition_marker, "CopyForPreventExtensions"); - if (!new_map->has_frozen_or_sealed_elements()) { + if (!new_map->has_any_nonextensible_elements()) { new_element_dictionary = CreateElementDictionary(isolate, object); } JSObject::MigrateToMap(isolate, object, new_map); @@ -3922,7 +3928,7 @@ Maybe<bool> JSObject::PreventExtensionsWithTransition( } } - if (object->map().has_frozen_or_sealed_elements()) { + if (object->map().has_any_nonextensible_elements()) { DCHECK(new_element_dictionary.is_null()); return Just(true); } @@ -3980,6 +3986,7 @@ bool JSObject::HasEnumerableElements() { case PACKED_ELEMENTS: case PACKED_FROZEN_ELEMENTS: case PACKED_SEALED_ELEMENTS: + case PACKED_NONEXTENSIBLE_ELEMENTS: case PACKED_DOUBLE_ELEMENTS: { int length = object.IsJSArray() ? Smi::ToInt(JSArray::cast(object).length()) @@ -3989,6 +3996,7 @@ bool JSObject::HasEnumerableElements() { case HOLEY_SMI_ELEMENTS: case HOLEY_FROZEN_ELEMENTS: case HOLEY_SEALED_ELEMENTS: + case HOLEY_NONEXTENSIBLE_ELEMENTS: case HOLEY_ELEMENTS: { FixedArray elements = FixedArray::cast(object.elements()); int length = object.IsJSArray() @@ -4146,7 +4154,7 @@ Object JSObject::SlowReverseLookup(Object value) { } else { Object property = RawFastPropertyAt(field_index); if (field_index.is_double()) { - DCHECK(property.IsMutableHeapNumber()); + DCHECK(property.IsHeapNumber()); if (value_is_number && property.Number() == value.Number()) { return descs.GetKey(i); } @@ -4691,8 +4699,9 @@ void JSObject::TransitionElementsKind(Handle<JSObject> object, if (from_kind == to_kind) return; // This method should never be called for any other case. - DCHECK(IsFastElementsKind(from_kind)); - DCHECK(IsFastElementsKind(to_kind)); + DCHECK(IsFastElementsKind(from_kind) || + IsNonextensibleElementsKind(from_kind)); + DCHECK(IsFastElementsKind(to_kind) || IsNonextensibleElementsKind(to_kind)); DCHECK_NE(TERMINAL_FAST_ELEMENTS_KIND, from_kind); UpdateAllocationSite(object, to_kind); @@ -4735,6 +4744,7 @@ int JSObject::GetFastElementsUsage() { case PACKED_ELEMENTS: case PACKED_FROZEN_ELEMENTS: case PACKED_SEALED_ELEMENTS: + case PACKED_NONEXTENSIBLE_ELEMENTS: return IsJSArray() ? Smi::ToInt(JSArray::cast(*this).length()) : store.length(); case FAST_SLOPPY_ARGUMENTS_ELEMENTS: @@ -4744,6 +4754,7 @@ int JSObject::GetFastElementsUsage() { case HOLEY_ELEMENTS: case HOLEY_FROZEN_ELEMENTS: case HOLEY_SEALED_ELEMENTS: + case HOLEY_NONEXTENSIBLE_ELEMENTS: case FAST_STRING_WRAPPER_ELEMENTS: return HoleyElementsUsage(*this, FixedArray::cast(store)); case HOLEY_DOUBLE_ELEMENTS: @@ -4801,6 +4812,8 @@ bool JSObject::IsApiWrapper() { return instance_type == JS_API_OBJECT_TYPE || instance_type == JS_ARRAY_BUFFER_TYPE || instance_type == JS_DATA_VIEW_TYPE || + instance_type == JS_GLOBAL_OBJECT_TYPE || + instance_type == JS_GLOBAL_PROXY_TYPE || instance_type == JS_SPECIAL_API_OBJECT_TYPE || instance_type == JS_TYPED_ARRAY_TYPE; } @@ -4987,13 +5000,9 @@ void JSFunction::InitializeFeedbackCell(Handle<JSFunction> function) { Isolate* const isolate = function->GetIsolate(); if (function->has_feedback_vector()) { - // TODO(984344): Make this a CHECK that feedback vectors are identical to - // what we expect once we have removed all bytecode generation differences - // between eager and lazy compilation. For now just reset if they aren't - // identical - FeedbackVector vector = function->feedback_vector(); - if (vector.length() == vector.metadata().slot_count()) return; - function->raw_feedback_cell().reset(); + CHECK_EQ(function->feedback_vector().length(), + function->feedback_vector().metadata().slot_count()); + return; } bool needs_feedback_vector = !FLAG_lazy_feedback_allocation; @@ -5241,7 +5250,6 @@ bool CanSubclassHaveInobjectProperties(InstanceType instance_type) { case JS_GLOBAL_PROXY_TYPE: case JS_PROXY_TYPE: case MAP_TYPE: - case MUTABLE_HEAP_NUMBER_TYPE: case ODDBALL_TYPE: case PROPERTY_CELL_TYPE: case SHARED_FUNCTION_INFO_TYPE: diff --git a/deps/v8/src/objects/js-objects.h b/deps/v8/src/objects/js-objects.h index bcea3a28df..a9510642f1 100644 --- a/deps/v8/src/objects/js-objects.h +++ b/deps/v8/src/objects/js-objects.h @@ -323,8 +323,9 @@ class JSObject : public TorqueGeneratedJSObject<JSObject, JSReceiver> { // Returns true if an object has elements of PACKED_ELEMENTS DECL_GETTER(HasPackedElements, bool) - DECL_GETTER(HasFrozenOrSealedElements, bool) + DECL_GETTER(HasAnyNonextensibleElements, bool) DECL_GETTER(HasSealedElements, bool) + DECL_GETTER(HasNonextensibleElements, bool) DECL_GETTER(HasTypedArrayElements, bool) @@ -893,19 +894,9 @@ class JSIteratorResult : public JSObject { }; // JSBoundFunction describes a bound function exotic object. -class JSBoundFunction : public JSObject { +class JSBoundFunction + : public TorqueGeneratedJSBoundFunction<JSBoundFunction, JSObject> { public: - // [bound_target_function]: The wrapped function object. - DECL_ACCESSORS(bound_target_function, JSReceiver) - - // [bound_this]: The value that is always passed as the this value when - // calling the wrapped function. - DECL_ACCESSORS(bound_this, Object) - - // [bound_arguments]: A list of values whose elements are used as the first - // arguments to any call to the wrapped function. - DECL_ACCESSORS(bound_arguments, FixedArray) - static MaybeHandle<String> GetName(Isolate* isolate, Handle<JSBoundFunction> function); static Maybe<int> GetLength(Isolate* isolate, @@ -913,8 +904,6 @@ class JSBoundFunction : public JSObject { static MaybeHandle<NativeContext> GetFunctionRealm( Handle<JSBoundFunction> function); - DECL_CAST(JSBoundFunction) - // Dispatched behavior. DECL_PRINTER(JSBoundFunction) DECL_VERIFIER(JSBoundFunction) @@ -923,11 +912,7 @@ class JSBoundFunction : public JSObject { // to ES6 section 19.2.3.5 Function.prototype.toString ( ). static Handle<String> ToString(Handle<JSBoundFunction> function); - // Layout description. - DEFINE_FIELD_OFFSET_CONSTANTS(JSObject::kHeaderSize, - TORQUE_GENERATED_JSBOUND_FUNCTION_FIELDS) - - OBJECT_CONSTRUCTORS(JSBoundFunction, JSObject); + TQ_OBJECT_CONSTRUCTORS(JSBoundFunction) }; // JSFunction describes JavaScript functions. @@ -1213,34 +1198,11 @@ class JSPrimitiveWrapper class DateCache; // Representation for JS date objects. -class JSDate : public JSObject { +class JSDate : public TorqueGeneratedJSDate<JSDate, JSObject> { public: static V8_WARN_UNUSED_RESULT MaybeHandle<JSDate> New( Handle<JSFunction> constructor, Handle<JSReceiver> new_target, double tv); - // If one component is NaN, all of them are, indicating a NaN time value. - // [value]: the time value. - DECL_ACCESSORS(value, Object) - // [year]: caches year. Either undefined, smi, or NaN. - DECL_ACCESSORS(year, Object) - // [month]: caches month. Either undefined, smi, or NaN. - DECL_ACCESSORS(month, Object) - // [day]: caches day. Either undefined, smi, or NaN. - DECL_ACCESSORS(day, Object) - // [weekday]: caches day of week. Either undefined, smi, or NaN. - DECL_ACCESSORS(weekday, Object) - // [hour]: caches hours. Either undefined, smi, or NaN. - DECL_ACCESSORS(hour, Object) - // [min]: caches minutes. Either undefined, smi, or NaN. - DECL_ACCESSORS(min, Object) - // [sec]: caches seconds. Either undefined, smi, or NaN. - DECL_ACCESSORS(sec, Object) - // [cache stamp]: sample of the date cache stamp at the - // moment when chached fields were cached. - DECL_ACCESSORS(cache_stamp, Object) - - DECL_CAST(JSDate) - // Returns the time value (UTC) identifying the current time. static double CurrentTimeValue(Isolate* isolate); @@ -1290,9 +1252,6 @@ class JSDate : public JSObject { kTimezoneOffset }; - DEFINE_FIELD_OFFSET_CONSTANTS(JSObject::kHeaderSize, - TORQUE_GENERATED_JSDATE_FIELDS) - private: inline Object DoGetField(FieldIndex index); @@ -1301,7 +1260,7 @@ class JSDate : public JSObject { // Computes and caches the cacheable fields of the date. inline void SetCachedFields(int64_t local_time_ms, DateCache* date_cache); - OBJECT_CONSTRUCTORS(JSDate, JSObject); + TQ_OBJECT_CONSTRUCTORS(JSDate) }; // Representation of message objects used for error reporting through @@ -1396,27 +1355,19 @@ class JSMessageObject : public JSObject { // An object which wraps an ordinary Iterator and converts it to behave // according to the Async Iterator protocol. // (See https://tc39.github.io/proposal-async-iteration/#sec-iteration) -class JSAsyncFromSyncIterator : public JSObject { +class JSAsyncFromSyncIterator + : public TorqueGeneratedJSAsyncFromSyncIterator<JSAsyncFromSyncIterator, + JSObject> { public: - DECL_CAST(JSAsyncFromSyncIterator) DECL_PRINTER(JSAsyncFromSyncIterator) - DECL_VERIFIER(JSAsyncFromSyncIterator) // Async-from-Sync Iterator instances are ordinary objects that inherit // properties from the %AsyncFromSyncIteratorPrototype% intrinsic object. // Async-from-Sync Iterator instances are initially created with the internal // slots listed in Table 4. // (proposal-async-iteration/#table-async-from-sync-iterator-internal-slots) - DECL_ACCESSORS(sync_iterator, JSReceiver) - - // The "next" method is loaded during GetIterator, and is not reloaded for - // subsequent "next" invocations. - DECL_ACCESSORS(next, Object) - - DEFINE_FIELD_OFFSET_CONSTANTS( - JSObject::kHeaderSize, TORQUE_GENERATED_JSASYNC_FROM_SYNC_ITERATOR_FIELDS) - OBJECT_CONSTRUCTORS(JSAsyncFromSyncIterator, JSObject); + TQ_OBJECT_CONSTRUCTORS(JSAsyncFromSyncIterator) }; class JSStringIterator : public JSObject { diff --git a/deps/v8/src/objects/js-promise-inl.h b/deps/v8/src/objects/js-promise-inl.h index ecfeb53306..8b7a11a151 100644 --- a/deps/v8/src/objects/js-promise-inl.h +++ b/deps/v8/src/objects/js-promise-inl.h @@ -16,11 +16,9 @@ namespace v8 { namespace internal { -OBJECT_CONSTRUCTORS_IMPL(JSPromise, JSObject) -CAST_ACCESSOR(JSPromise) +TQ_OBJECT_CONSTRUCTORS_IMPL(JSPromise) -ACCESSORS(JSPromise, reactions_or_result, Object, kReactionsOrResultOffset) -SMI_ACCESSORS(JSPromise, flags, kFlagsOffset) +TQ_SMI_ACCESSORS(JSPromise, flags) BOOL_ACCESSORS(JSPromise, flags, has_handler, kHasHandlerBit) BOOL_ACCESSORS(JSPromise, flags, handled_hint, kHandledHintBit) diff --git a/deps/v8/src/objects/js-promise.h b/deps/v8/src/objects/js-promise.h index bbe6f724d1..06569a3fcd 100644 --- a/deps/v8/src/objects/js-promise.h +++ b/deps/v8/src/objects/js-promise.h @@ -24,12 +24,8 @@ namespace internal { // We also overlay the result and reactions fields on the JSPromise, since // the reactions are only necessary for pending promises, whereas the result // is only meaningful for settled promises. -class JSPromise : public JSObject { +class JSPromise : public TorqueGeneratedJSPromise<JSPromise, JSObject> { public: - // [reactions_or_result]: Smi 0 terminated list of PromiseReaction objects - // in case the JSPromise was not settled yet, otherwise the result. - DECL_ACCESSORS(reactions_or_result, Object) - // [result]: Checks that the promise is settled and returns the result. inline Object result() const; @@ -62,15 +58,10 @@ class JSPromise : public JSObject { V8_WARN_UNUSED_RESULT static MaybeHandle<Object> Resolve( Handle<JSPromise> promise, Handle<Object> resolution); - DECL_CAST(JSPromise) - // Dispatched behavior. DECL_PRINTER(JSPromise) DECL_VERIFIER(JSPromise) - DEFINE_FIELD_OFFSET_CONSTANTS(JSObject::kHeaderSize, - TORQUE_GENERATED_JSPROMISE_FIELDS) - static const int kSizeWithEmbedderFields = kSize + v8::Promise::kEmbedderFieldCount * kEmbedderDataSlotSize; @@ -79,7 +70,7 @@ class JSPromise : public JSObject { static const int kStatusBits = 2; static const int kHasHandlerBit = 2; static const int kHandledHintBit = 3; - class AsyncTaskIdField : public BitField<int, kHandledHintBit + 1, 22> {}; + using AsyncTaskIdField = BitField<int, kHandledHintBit + 1, 22>; static const int kStatusShift = 0; static const int kStatusMask = 0x3; @@ -94,7 +85,7 @@ class JSPromise : public JSObject { Handle<Object> argument, PromiseReaction::Type type); - OBJECT_CONSTRUCTORS(JSPromise, JSObject); + TQ_OBJECT_CONSTRUCTORS(JSPromise) }; } // namespace internal diff --git a/deps/v8/src/objects/js-regexp-inl.h b/deps/v8/src/objects/js-regexp-inl.h index 93e6ee008d..b69d1cca97 100644 --- a/deps/v8/src/objects/js-regexp-inl.h +++ b/deps/v8/src/objects/js-regexp-inl.h @@ -17,13 +17,8 @@ namespace v8 { namespace internal { -OBJECT_CONSTRUCTORS_IMPL(JSRegExp, JSObject) +TQ_OBJECT_CONSTRUCTORS_IMPL(JSRegExp) -CAST_ACCESSOR(JSRegExp) - -ACCESSORS(JSRegExp, data, Object, kDataOffset) -ACCESSORS(JSRegExp, flags, Object, kFlagsOffset) -ACCESSORS(JSRegExp, source, Object, kSourceOffset) ACCESSORS(JSRegExp, last_index, Object, kLastIndexOffset) JSRegExp::Type JSRegExp::TypeTag() const { @@ -80,23 +75,28 @@ void JSRegExp::SetDataAt(int index, Object value) { bool JSRegExp::HasCompiledCode() const { if (TypeTag() != IRREGEXP) return false; + Smi uninitialized = Smi::FromInt(kUninitializedValue); #ifdef DEBUG DCHECK(DataAt(kIrregexpLatin1CodeIndex).IsCode() || - DataAt(kIrregexpLatin1CodeIndex).IsByteArray() || - DataAt(kIrregexpLatin1CodeIndex) == Smi::FromInt(kUninitializedValue)); + DataAt(kIrregexpLatin1CodeIndex) == uninitialized); DCHECK(DataAt(kIrregexpUC16CodeIndex).IsCode() || - DataAt(kIrregexpUC16CodeIndex).IsByteArray() || - DataAt(kIrregexpUC16CodeIndex) == Smi::FromInt(kUninitializedValue)); + DataAt(kIrregexpUC16CodeIndex) == uninitialized); + DCHECK(DataAt(kIrregexpLatin1BytecodeIndex).IsByteArray() || + DataAt(kIrregexpLatin1BytecodeIndex) == uninitialized); + DCHECK(DataAt(kIrregexpUC16BytecodeIndex).IsByteArray() || + DataAt(kIrregexpUC16BytecodeIndex) == uninitialized); #endif // DEBUG - Smi uninitialized = Smi::FromInt(kUninitializedValue); return (DataAt(kIrregexpLatin1CodeIndex) != uninitialized || DataAt(kIrregexpUC16CodeIndex) != uninitialized); } void JSRegExp::DiscardCompiledCodeForSerialization() { DCHECK(HasCompiledCode()); - SetDataAt(kIrregexpLatin1CodeIndex, Smi::FromInt(kUninitializedValue)); - SetDataAt(kIrregexpUC16CodeIndex, Smi::FromInt(kUninitializedValue)); + Smi uninitialized = Smi::FromInt(kUninitializedValue); + SetDataAt(kIrregexpLatin1CodeIndex, uninitialized); + SetDataAt(kIrregexpUC16CodeIndex, uninitialized); + SetDataAt(kIrregexpLatin1BytecodeIndex, uninitialized); + SetDataAt(kIrregexpUC16BytecodeIndex, uninitialized); } } // namespace internal diff --git a/deps/v8/src/objects/js-regexp-string-iterator-inl.h b/deps/v8/src/objects/js-regexp-string-iterator-inl.h index 08e2f99d7e..b204619058 100644 --- a/deps/v8/src/objects/js-regexp-string-iterator-inl.h +++ b/deps/v8/src/objects/js-regexp-string-iterator-inl.h @@ -15,20 +15,13 @@ namespace v8 { namespace internal { -OBJECT_CONSTRUCTORS_IMPL(JSRegExpStringIterator, JSObject) +TQ_OBJECT_CONSTRUCTORS_IMPL(JSRegExpStringIterator) -ACCESSORS(JSRegExpStringIterator, iterating_regexp, Object, - kIteratingRegExpOffset) -ACCESSORS(JSRegExpStringIterator, iterating_string, String, - kIteratedStringOffset) - -SMI_ACCESSORS(JSRegExpStringIterator, flags, kFlagsOffset) +TQ_SMI_ACCESSORS(JSRegExpStringIterator, flags) BOOL_ACCESSORS(JSRegExpStringIterator, flags, done, kDoneBit) BOOL_ACCESSORS(JSRegExpStringIterator, flags, global, kGlobalBit) BOOL_ACCESSORS(JSRegExpStringIterator, flags, unicode, kUnicodeBit) -CAST_ACCESSOR(JSRegExpStringIterator) - } // namespace internal } // namespace v8 diff --git a/deps/v8/src/objects/js-regexp-string-iterator.h b/deps/v8/src/objects/js-regexp-string-iterator.h index 871b724966..ffd38fe211 100644 --- a/deps/v8/src/objects/js-regexp-string-iterator.h +++ b/deps/v8/src/objects/js-regexp-string-iterator.h @@ -13,14 +13,10 @@ namespace v8 { namespace internal { -class JSRegExpStringIterator : public JSObject { +class JSRegExpStringIterator + : public TorqueGeneratedJSRegExpStringIterator<JSRegExpStringIterator, + JSObject> { public: - // [regexp]: the [[IteratingRegExp]] internal property. - DECL_ACCESSORS(iterating_regexp, Object) - - // [string]: The [[IteratedString]] internal property. - DECL_ACCESSORS(iterating_string, String) - DECL_INT_ACCESSORS(flags) // [boolean]: The [[Done]] internal property. @@ -32,20 +28,13 @@ class JSRegExpStringIterator : public JSObject { // [boolean]: The [[Unicode]] internal property. DECL_BOOLEAN_ACCESSORS(unicode) - DECL_CAST(JSRegExpStringIterator) DECL_PRINTER(JSRegExpStringIterator) - DECL_VERIFIER(JSRegExpStringIterator) - - // Layout description. - DEFINE_FIELD_OFFSET_CONSTANTS( - JSObject::kHeaderSize, - TORQUE_GENERATED_JSREG_EXP_STRING_ITERATOR_FIELDS) static const int kDoneBit = 0; static const int kGlobalBit = 1; static const int kUnicodeBit = 2; - OBJECT_CONSTRUCTORS(JSRegExpStringIterator, JSObject); + TQ_OBJECT_CONSTRUCTORS(JSRegExpStringIterator) }; } // namespace internal diff --git a/deps/v8/src/objects/js-regexp.h b/deps/v8/src/objects/js-regexp.h index 18355079f8..b3ef06bd5c 100644 --- a/deps/v8/src/objects/js-regexp.h +++ b/deps/v8/src/objects/js-regexp.h @@ -29,7 +29,7 @@ namespace internal { // used for tracking the last usage (used for regexp code flushing). // - max number of registers used by irregexp implementations. // - number of capture registers (output values) of the regexp. -class JSRegExp : public JSObject { +class JSRegExp : public TorqueGeneratedJSRegExp<JSRegExp, JSObject> { public: // Meaning of Type: // NOT_COMPILED: Initial value. No data has been stored in the JSRegExp yet. @@ -82,10 +82,7 @@ class JSRegExp : public JSObject { STATIC_ASSERT(static_cast<int>(kDotAll) == v8::RegExp::kDotAll); STATIC_ASSERT(kFlagCount == v8::RegExp::kFlagCount); - DECL_ACCESSORS(data, Object) - DECL_ACCESSORS(flags, Object) DECL_ACCESSORS(last_index, Object) - DECL_ACCESSORS(source, Object) V8_EXPORT_PRIVATE static MaybeHandle<JSRegExp> New(Isolate* isolate, Handle<String> source, @@ -98,7 +95,15 @@ class JSRegExp : public JSObject { Handle<String> source, Handle<String> flags_string); + bool MarkedForTierUp(); + void ResetTierUp(); + void MarkTierUpForNextExec(); + inline Type TypeTag() const; + + // Maximum number of captures allowed. + static constexpr int kMaxCaptures = 1 << 16; + // Number of captures (without the match itself). inline int CaptureCount(); inline Flags GetFlags(); @@ -108,26 +113,27 @@ class JSRegExp : public JSObject { // Set implementation data after the object has been prepared. inline void SetDataAt(int index, Object value); - static int code_index(bool is_latin1) { - if (is_latin1) { - return kIrregexpLatin1CodeIndex; - } else { - return kIrregexpUC16CodeIndex; - } + static constexpr int code_index(bool is_latin1) { + return is_latin1 ? kIrregexpLatin1CodeIndex : kIrregexpUC16CodeIndex; } + static constexpr int bytecode_index(bool is_latin1) { + return is_latin1 ? kIrregexpLatin1BytecodeIndex + : kIrregexpUC16BytecodeIndex; + } + + // This could be a Smi kUninitializedValue or Code. + Object Code(bool is_latin1) const; + // This could be a Smi kUninitializedValue or ByteArray. + Object Bytecode(bool is_latin1) const; + bool ShouldProduceBytecode(); inline bool HasCompiledCode() const; inline void DiscardCompiledCodeForSerialization(); - DECL_CAST(JSRegExp) - // Dispatched behavior. DECL_PRINTER(JSRegExp) DECL_VERIFIER(JSRegExp) - // Layout description. - DEFINE_FIELD_OFFSET_CONSTANTS(JSObject::kHeaderSize, - TORQUE_GENERATED_JSREG_EXP_FIELDS) /* This is already an in-object field. */ // TODO(v8:8944): improve handling of in-object fields static constexpr int kLastIndexOffset = kSize; @@ -144,24 +150,35 @@ class JSRegExp : public JSObject { static const int kAtomDataSize = kAtomPatternIndex + 1; - // Irregexp compiled code or bytecode for Latin1. If compilation - // fails, this fields hold an exception object that should be + // Irregexp compiled code or trampoline to interpreter for Latin1. If + // compilation fails, this fields hold an exception object that should be // thrown if the regexp is used again. static const int kIrregexpLatin1CodeIndex = kDataIndex; - // Irregexp compiled code or bytecode for UC16. If compilation - // fails, this fields hold an exception object that should be + // Irregexp compiled code or trampoline to interpreter for UC16. If + // compilation fails, this fields hold an exception object that should be // thrown if the regexp is used again. static const int kIrregexpUC16CodeIndex = kDataIndex + 1; + // Bytecode to interpret the regexp for Latin1. Contains kUninitializedValue + // if we haven't compiled the regexp yet, regexp are always compiled or if + // tier-up has happened (i.e. when kIrregexpLatin1CodeIndex contains native + // irregexp code). + static const int kIrregexpLatin1BytecodeIndex = kDataIndex + 2; + // Bytecode to interpret the regexp for UC16. Contains kUninitializedValue if + // we haven't compiled the regxp yet, regexp are always compiled or if tier-up + // has happened (i.e. when kIrregexpUC16CodeIndex contains native irregexp + // code). + static const int kIrregexpUC16BytecodeIndex = kDataIndex + 3; // Maximal number of registers used by either Latin1 or UC16. // Only used to check that there is enough stack space - static const int kIrregexpMaxRegisterCountIndex = kDataIndex + 2; + static const int kIrregexpMaxRegisterCountIndex = kDataIndex + 4; // Number of captures in the compiled regexp. - static const int kIrregexpCaptureCountIndex = kDataIndex + 3; + static const int kIrregexpCaptureCountIndex = kDataIndex + 5; // Maps names of named capture groups (at indices 2i) to their corresponding // (1-based) capture group indices (at indices 2i + 1). - static const int kIrregexpCaptureNameMapIndex = kDataIndex + 4; + static const int kIrregexpCaptureNameMapIndex = kDataIndex + 6; + static const int kIrregexpTierUpTicksIndex = kDataIndex + 7; - static const int kIrregexpDataSize = kIrregexpCaptureNameMapIndex + 1; + static const int kIrregexpDataSize = kIrregexpTierUpTicksIndex + 1; // In-object fields. static const int kLastIndexFieldIndex = 0; @@ -178,7 +195,7 @@ class JSRegExp : public JSObject { // The uninitialized value for a regexp code object. static const int kUninitializedValue = -1; - OBJECT_CONSTRUCTORS(JSRegExp, JSObject); + TQ_OBJECT_CONSTRUCTORS(JSRegExp) }; DEFINE_OPERATORS_FOR_FLAGS(JSRegExp::Flags) diff --git a/deps/v8/src/objects/js-segment-iterator.cc b/deps/v8/src/objects/js-segment-iterator.cc index 509db37d44..d893f3705f 100644 --- a/deps/v8/src/objects/js-segment-iterator.cc +++ b/deps/v8/src/objects/js-segment-iterator.cc @@ -207,7 +207,7 @@ Maybe<bool> JSSegmentIterator::Following( THROW_NEW_ERROR_RETURN_VALUE( isolate, NewRangeError(MessageTemplate::kParameterOfFunctionOutOfRange, - factory->NewStringFromStaticChars("from"), + factory->from_string(), factory->NewStringFromStaticChars("following"), index), Nothing<bool>()); } @@ -220,7 +220,7 @@ Maybe<bool> JSSegmentIterator::Following( THROW_NEW_ERROR_RETURN_VALUE( isolate, NewRangeError(MessageTemplate::kParameterOfFunctionOutOfRange, - factory->NewStringFromStaticChars("from"), + factory->from_string(), factory->NewStringFromStaticChars("following"), from_obj), Nothing<bool>()); @@ -260,7 +260,7 @@ Maybe<bool> JSSegmentIterator::Preceding( THROW_NEW_ERROR_RETURN_VALUE( isolate, NewRangeError(MessageTemplate::kParameterOfFunctionOutOfRange, - factory->NewStringFromStaticChars("from"), + factory->from_string(), factory->NewStringFromStaticChars("preceding"), index), Nothing<bool>()); } @@ -272,7 +272,7 @@ Maybe<bool> JSSegmentIterator::Preceding( THROW_NEW_ERROR_RETURN_VALUE( isolate, NewRangeError(MessageTemplate::kParameterOfFunctionOutOfRange, - factory->NewStringFromStaticChars("from"), + factory->from_string(), factory->NewStringFromStaticChars("preceding"), from_obj), Nothing<bool>()); diff --git a/deps/v8/src/objects/js-weak-refs-inl.h b/deps/v8/src/objects/js-weak-refs-inl.h index 46f28e883e..004ffd6d79 100644 --- a/deps/v8/src/objects/js-weak-refs-inl.h +++ b/deps/v8/src/objects/js-weak-refs-inl.h @@ -9,7 +9,6 @@ #include "src/api/api-inl.h" #include "src/heap/heap-write-barrier-inl.h" -#include "src/objects/microtask-inl.h" #include "src/objects/smi-inl.h" // Has to be the last include (doesn't have include guards): @@ -22,7 +21,6 @@ OBJECT_CONSTRUCTORS_IMPL(WeakCell, HeapObject) OBJECT_CONSTRUCTORS_IMPL(JSWeakRef, JSObject) OBJECT_CONSTRUCTORS_IMPL(JSFinalizationGroup, JSObject) OBJECT_CONSTRUCTORS_IMPL(JSFinalizationGroupCleanupIterator, JSObject) -OBJECT_CONSTRUCTORS_IMPL(FinalizationGroupCleanupJobTask, Microtask) ACCESSORS(JSFinalizationGroup, native_context, NativeContext, kNativeContextOffset) @@ -51,10 +49,6 @@ ACCESSORS(JSFinalizationGroupCleanupIterator, finalization_group, JSFinalizationGroup, kFinalizationGroupOffset) CAST_ACCESSOR(JSFinalizationGroupCleanupIterator) -ACCESSORS(FinalizationGroupCleanupJobTask, finalization_group, - JSFinalizationGroup, kFinalizationGroupOffset) -CAST_ACCESSOR(FinalizationGroupCleanupJobTask) - void JSFinalizationGroup::Register( Handle<JSFinalizationGroup> finalization_group, Handle<JSReceiver> target, Handle<Object> holdings, Handle<Object> key, Isolate* isolate) { diff --git a/deps/v8/src/objects/js-weak-refs.h b/deps/v8/src/objects/js-weak-refs.h index 6a401fecee..723e0e3135 100644 --- a/deps/v8/src/objects/js-weak-refs.h +++ b/deps/v8/src/objects/js-weak-refs.h @@ -58,16 +58,18 @@ class JSFinalizationGroup : public JSObject { // Constructs an iterator for the WeakCells in the cleared_cells list and // calls the user's cleanup function. - static void Cleanup(Isolate* isolate, - Handle<JSFinalizationGroup> finalization_group, - Handle<Object> callback); + // + // Returns Nothing<bool> if exception occurs, otherwise returns Just(true). + static V8_WARN_UNUSED_RESULT Maybe<bool> Cleanup( + Isolate* isolate, Handle<JSFinalizationGroup> finalization_group, + Handle<Object> callback); // Layout description. DEFINE_FIELD_OFFSET_CONSTANTS(JSObject::kHeaderSize, TORQUE_GENERATED_JSFINALIZATION_GROUP_FIELDS) // Bitfields in flags. - class ScheduledForCleanupField : public BitField<bool, 0, 1> {}; + using ScheduledForCleanupField = BitField<bool, 0, 1>; OBJECT_CONSTRUCTORS(JSFinalizationGroup, JSObject); }; @@ -133,27 +135,6 @@ class JSWeakRef : public JSObject { OBJECT_CONSTRUCTORS(JSWeakRef, JSObject); }; -class FinalizationGroupCleanupJobTask : public Microtask { - public: - DECL_ACCESSORS(finalization_group, JSFinalizationGroup) - - DECL_CAST(FinalizationGroupCleanupJobTask) - DECL_VERIFIER(FinalizationGroupCleanupJobTask) - DECL_PRINTER(FinalizationGroupCleanupJobTask) - -// Layout description. -#define FINALIZATION_GROUP_CLEANUP_JOB_TASK_FIELDS(V) \ - V(kFinalizationGroupOffset, kTaggedSize) \ - /* Total size. */ \ - V(kSize, 0) - - DEFINE_FIELD_OFFSET_CONSTANTS(Microtask::kHeaderSize, - FINALIZATION_GROUP_CLEANUP_JOB_TASK_FIELDS) -#undef FINALIZATION_GROUP_CLEANUP_JOB_TASK_FIELDS - - OBJECT_CONSTRUCTORS(FinalizationGroupCleanupJobTask, Microtask); -}; - class JSFinalizationGroupCleanupIterator : public JSObject { public: DECL_PRINTER(JSFinalizationGroupCleanupIterator) diff --git a/deps/v8/src/objects/keys.cc b/deps/v8/src/objects/keys.cc index 18b38ed744..7496399cad 100644 --- a/deps/v8/src/objects/keys.cc +++ b/deps/v8/src/objects/keys.cc @@ -22,6 +22,17 @@ namespace v8 { namespace internal { +#define RETURN_NOTHING_IF_NOT_SUCCESSFUL(call) \ + do { \ + if (!(call)) return Nothing<bool>(); \ + } while (false) + +#define RETURN_FAILURE_IF_NOT_SUCCESSFUL(call) \ + do { \ + ExceptionStatus status_enum_result = (call); \ + if (!status_enum_result) return status_enum_result; \ + } while (false) + namespace { static bool ContainsOnlyValidKeys(Handle<FixedArray> array) { @@ -64,32 +75,39 @@ Handle<OrderedHashSet> KeyAccumulator::keys() { return Handle<OrderedHashSet>::cast(keys_); } -void KeyAccumulator::AddKey(Object key, AddKeyConversion convert) { - AddKey(handle(key, isolate_), convert); +ExceptionStatus KeyAccumulator::AddKey(Object key, AddKeyConversion convert) { + return AddKey(handle(key, isolate_), convert); } -void KeyAccumulator::AddKey(Handle<Object> key, AddKeyConversion convert) { +ExceptionStatus KeyAccumulator::AddKey(Handle<Object> key, + AddKeyConversion convert) { if (filter_ == PRIVATE_NAMES_ONLY) { - if (!key->IsSymbol()) return; - if (!Symbol::cast(*key).is_private_name()) return; + if (!key->IsSymbol()) return ExceptionStatus::kSuccess; + if (!Symbol::cast(*key).is_private_name()) return ExceptionStatus::kSuccess; } else if (key->IsSymbol()) { - if (filter_ & SKIP_SYMBOLS) return; - - if (Symbol::cast(*key).is_private()) return; + if (filter_ & SKIP_SYMBOLS) return ExceptionStatus::kSuccess; + if (Symbol::cast(*key).is_private()) return ExceptionStatus::kSuccess; } else if (filter_ & SKIP_STRINGS) { - return; + return ExceptionStatus::kSuccess; } - if (IsShadowed(key)) return; + if (IsShadowed(key)) return ExceptionStatus::kSuccess; if (keys_.is_null()) { - keys_ = OrderedHashSet::Allocate(isolate_, 16); + keys_ = OrderedHashSet::Allocate(isolate_, 16).ToHandleChecked(); } uint32_t index; if (convert == CONVERT_TO_ARRAY_INDEX && key->IsString() && Handle<String>::cast(key)->AsArrayIndex(&index)) { key = isolate_->factory()->NewNumberFromUint(index); } - Handle<OrderedHashSet> new_set = OrderedHashSet::Add(isolate(), keys(), key); + MaybeHandle<OrderedHashSet> new_set_candidate = + OrderedHashSet::Add(isolate(), keys(), key); + Handle<OrderedHashSet> new_set; + if (!new_set_candidate.ToHandle(&new_set)) { + THROW_NEW_ERROR_RETURN_VALUE( + isolate_, NewRangeError(MessageTemplate::kTooManyProperties), + ExceptionStatus::kException); + } if (*new_set != *keys_) { // The keys_ Set is converted directly to a FixedArray in GetKeys which can // be left-trimmer. Hence the previous Set should not keep a pointer to the @@ -97,22 +115,24 @@ void KeyAccumulator::AddKey(Handle<Object> key, AddKeyConversion convert) { keys_->set(OrderedHashSet::NextTableIndex(), Smi::kZero); keys_ = new_set; } + return ExceptionStatus::kSuccess; } -void KeyAccumulator::AddKeys(Handle<FixedArray> array, - AddKeyConversion convert) { +ExceptionStatus KeyAccumulator::AddKeys(Handle<FixedArray> array, + AddKeyConversion convert) { int add_length = array->length(); for (int i = 0; i < add_length; i++) { Handle<Object> current(array->get(i), isolate_); - AddKey(current, convert); + RETURN_FAILURE_IF_NOT_SUCCESSFUL(AddKey(current, convert)); } + return ExceptionStatus::kSuccess; } -void KeyAccumulator::AddKeys(Handle<JSObject> array_like, - AddKeyConversion convert) { +ExceptionStatus KeyAccumulator::AddKeys(Handle<JSObject> array_like, + AddKeyConversion convert) { DCHECK(array_like->IsJSArray() || array_like->HasSloppyArgumentsElements()); ElementsAccessor* accessor = array_like->GetElementsAccessor(); - accessor->AddElementsToKeyAccumulator(array_like, this, convert); + return accessor->AddElementsToKeyAccumulator(array_like, this, convert); } MaybeHandle<FixedArray> FilterProxyKeys(KeyAccumulator* accumulator, @@ -162,7 +182,8 @@ Maybe<bool> KeyAccumulator::AddKeysFromJSProxy(Handle<JSProxy> proxy, return Just(true); } } - AddKeys(keys, is_for_in_ ? CONVERT_TO_ARRAY_INDEX : DO_NOT_CONVERT); + RETURN_NOTHING_IF_NOT_SUCCESSFUL( + AddKeys(keys, is_for_in_ ? CONVERT_TO_ARRAY_INDEX : DO_NOT_CONVERT)); return Just(true); } @@ -488,12 +509,10 @@ namespace { enum IndexedOrNamed { kIndexed, kNamed }; -void FilterForEnumerableProperties(Handle<JSReceiver> receiver, - Handle<JSObject> object, - Handle<InterceptorInfo> interceptor, - KeyAccumulator* accumulator, - Handle<JSObject> result, - IndexedOrNamed type) { +V8_WARN_UNUSED_RESULT ExceptionStatus FilterForEnumerableProperties( + Handle<JSReceiver> receiver, Handle<JSObject> object, + Handle<InterceptorInfo> interceptor, KeyAccumulator* accumulator, + Handle<JSObject> result, IndexedOrNamed type) { DCHECK(result->IsJSArray() || result->HasSloppyArgumentsElements()); ElementsAccessor* accessor = result->GetElementsAccessor(); @@ -521,10 +540,12 @@ void FilterForEnumerableProperties(Handle<JSReceiver> receiver, int32_t value; CHECK(attributes->ToInt32(&value)); if ((value & DONT_ENUM) == 0) { - accumulator->AddKey(element, DO_NOT_CONVERT); + RETURN_FAILURE_IF_NOT_SUCCESSFUL( + accumulator->AddKey(element, DO_NOT_CONVERT)); } } } + return ExceptionStatus::kSuccess; } // Returns |true| on success, |nothing| on exception. @@ -551,11 +572,11 @@ Maybe<bool> CollectInterceptorKeysInternal(Handle<JSReceiver> receiver, if ((accumulator->filter() & ONLY_ENUMERABLE) && !interceptor->query().IsUndefined(isolate)) { - FilterForEnumerableProperties(receiver, object, interceptor, accumulator, - result, type); + RETURN_NOTHING_IF_NOT_SUCCESSFUL(FilterForEnumerableProperties( + receiver, object, interceptor, accumulator, result, type)); } else { - accumulator->AddKeys( - result, type == kIndexed ? CONVERT_TO_ARRAY_INDEX : DO_NOT_CONVERT); + RETURN_NOTHING_IF_NOT_SUCCESSFUL(accumulator->AddKeys( + result, type == kIndexed ? CONVERT_TO_ARRAY_INDEX : DO_NOT_CONVERT)); } return Just(true); } @@ -589,18 +610,17 @@ Maybe<bool> KeyAccumulator::CollectOwnElementIndices( if (filter_ & SKIP_STRINGS || skip_indices_) return Just(true); ElementsAccessor* accessor = object->GetElementsAccessor(); - accessor->CollectElementIndices(object, this); - + RETURN_NOTHING_IF_NOT_SUCCESSFUL( + accessor->CollectElementIndices(object, this)); return CollectInterceptorKeys(receiver, object, this, kIndexed); } namespace { template <bool skip_symbols> -int CollectOwnPropertyNamesInternal(Handle<JSObject> object, - KeyAccumulator* keys, - Handle<DescriptorArray> descs, - int start_index, int limit) { +base::Optional<int> CollectOwnPropertyNamesInternal( + Handle<JSObject> object, KeyAccumulator* keys, + Handle<DescriptorArray> descs, int start_index, int limit) { int first_skipped = -1; PropertyFilter filter = keys->filter(); KeyCollectionMode mode = keys->mode(); @@ -633,7 +653,9 @@ int CollectOwnPropertyNamesInternal(Handle<JSObject> object, if (is_shadowing_key) { keys->AddShadowingKey(key); } else { - keys->AddKey(key, DO_NOT_CONVERT); + if (keys->AddKey(key, DO_NOT_CONVERT) != ExceptionStatus::kSuccess) { + return base::Optional<int>(); + } } } return first_skipped; @@ -696,48 +718,50 @@ Maybe<bool> KeyAccumulator::CollectOwnPropertyNames(Handle<JSReceiver> receiver, } } } - AddKeys(enum_keys, DO_NOT_CONVERT); + RETURN_NOTHING_IF_NOT_SUCCESSFUL(AddKeys(enum_keys, DO_NOT_CONVERT)); } else { if (object->HasFastProperties()) { int limit = object->map().NumberOfOwnDescriptors(); Handle<DescriptorArray> descs(object->map().instance_descriptors(), isolate_); // First collect the strings, - int first_symbol = + base::Optional<int> first_symbol = CollectOwnPropertyNamesInternal<true>(object, this, descs, 0, limit); // then the symbols. - if (first_symbol != -1) { - CollectOwnPropertyNamesInternal<false>(object, this, descs, - first_symbol, limit); + RETURN_NOTHING_IF_NOT_SUCCESSFUL(first_symbol); + if (first_symbol.value() != -1) { + RETURN_NOTHING_IF_NOT_SUCCESSFUL(CollectOwnPropertyNamesInternal<false>( + object, this, descs, first_symbol.value(), limit)); } } else if (object->IsJSGlobalObject()) { - GlobalDictionary::CollectKeysTo( + RETURN_NOTHING_IF_NOT_SUCCESSFUL(GlobalDictionary::CollectKeysTo( handle(JSGlobalObject::cast(*object).global_dictionary(), isolate_), - this); + this)); } else { - NameDictionary::CollectKeysTo( - handle(object->property_dictionary(), isolate_), this); + RETURN_NOTHING_IF_NOT_SUCCESSFUL(NameDictionary::CollectKeysTo( + handle(object->property_dictionary(), isolate_), this)); } } // Add the property keys from the interceptor. return CollectInterceptorKeys(receiver, object, this, kNamed); } -void KeyAccumulator::CollectPrivateNames(Handle<JSReceiver> receiver, - Handle<JSObject> object) { +ExceptionStatus KeyAccumulator::CollectPrivateNames(Handle<JSReceiver> receiver, + Handle<JSObject> object) { if (object->HasFastProperties()) { int limit = object->map().NumberOfOwnDescriptors(); Handle<DescriptorArray> descs(object->map().instance_descriptors(), isolate_); CollectOwnPropertyNamesInternal<false>(object, this, descs, 0, limit); } else if (object->IsJSGlobalObject()) { - GlobalDictionary::CollectKeysTo( + RETURN_FAILURE_IF_NOT_SUCCESSFUL(GlobalDictionary::CollectKeysTo( handle(JSGlobalObject::cast(*object).global_dictionary(), isolate_), - this); + this)); } else { - NameDictionary::CollectKeysTo( - handle(object->property_dictionary(), isolate_), this); + RETURN_FAILURE_IF_NOT_SUCCESSFUL(NameDictionary::CollectKeysTo( + handle(object->property_dictionary(), isolate_), this)); } + return ExceptionStatus::kSuccess; } Maybe<bool> KeyAccumulator::CollectAccessCheckInterceptorKeys( @@ -795,7 +819,7 @@ Maybe<bool> KeyAccumulator::CollectOwnKeys(Handle<JSReceiver> receiver, filter_ = static_cast<PropertyFilter>(filter_ | ONLY_ALL_CAN_READ); } if (filter_ & PRIVATE_NAMES_ONLY) { - CollectPrivateNames(receiver, object); + RETURN_NOTHING_IF_NOT_SUCCESSFUL(CollectPrivateNames(receiver, object)); return Just(true); } @@ -843,8 +867,8 @@ Maybe<bool> KeyAccumulator::CollectOwnJSProxyKeys(Handle<JSReceiver> receiver, Handle<JSProxy> proxy) { STACK_CHECK(isolate_, Nothing<bool>()); if (filter_ == PRIVATE_NAMES_ONLY) { - NameDictionary::CollectKeysTo( - handle(proxy->property_dictionary(), isolate_), this); + RETURN_NOTHING_IF_NOT_SUCCESSFUL(NameDictionary::CollectKeysTo( + handle(proxy->property_dictionary(), isolate_), this)); return Just(true); } @@ -1018,5 +1042,7 @@ Maybe<bool> KeyAccumulator::CollectOwnJSProxyTargetKeys( return result; } +#undef RETURN_NOTHING_IF_NOT_SUCCESSFUL +#undef RETURN_FAILURE_IF_NOT_SUCCESSFUL } // namespace internal } // namespace v8 diff --git a/deps/v8/src/objects/keys.h b/deps/v8/src/objects/keys.h index 69f61a886e..5d8632e2a7 100644 --- a/deps/v8/src/objects/keys.h +++ b/deps/v8/src/objects/keys.h @@ -52,8 +52,8 @@ class KeyAccumulator final { Handle<JSObject> object); Maybe<bool> CollectOwnPropertyNames(Handle<JSReceiver> receiver, Handle<JSObject> object); - void CollectPrivateNames(Handle<JSReceiver> receiver, - Handle<JSObject> object); + V8_WARN_UNUSED_RESULT ExceptionStatus + CollectPrivateNames(Handle<JSReceiver> receiver, Handle<JSObject> object); Maybe<bool> CollectAccessCheckInterceptorKeys( Handle<AccessCheckInfo> access_check_info, Handle<JSReceiver> receiver, Handle<JSObject> object); @@ -65,10 +65,14 @@ class KeyAccumulator final { static Handle<FixedArray> GetOwnEnumPropertyKeys(Isolate* isolate, Handle<JSObject> object); - void AddKey(Object key, AddKeyConversion convert = DO_NOT_CONVERT); - void AddKey(Handle<Object> key, AddKeyConversion convert = DO_NOT_CONVERT); - void AddKeys(Handle<FixedArray> array, AddKeyConversion convert); - void AddKeys(Handle<JSObject> array_like, AddKeyConversion convert); + V8_WARN_UNUSED_RESULT ExceptionStatus + AddKey(Object key, AddKeyConversion convert = DO_NOT_CONVERT); + V8_WARN_UNUSED_RESULT ExceptionStatus + AddKey(Handle<Object> key, AddKeyConversion convert = DO_NOT_CONVERT); + V8_WARN_UNUSED_RESULT ExceptionStatus AddKeys(Handle<FixedArray> array, + AddKeyConversion convert); + V8_WARN_UNUSED_RESULT ExceptionStatus AddKeys(Handle<JSObject> array_like, + AddKeyConversion convert); // Jump to the next level, pushing the current |levelLength_| to // |levelLengths_| and adding a new list to |elements_|. diff --git a/deps/v8/src/objects/literal-objects-inl.h b/deps/v8/src/objects/literal-objects-inl.h index 32b43cd8f7..96aa8d8c8b 100644 --- a/deps/v8/src/objects/literal-objects-inl.h +++ b/deps/v8/src/objects/literal-objects-inl.h @@ -124,14 +124,9 @@ ACCESSORS(ClassBoilerplate, instance_computed_properties, FixedArray, // ArrayBoilerplateDescription // -OBJECT_CONSTRUCTORS_IMPL(ArrayBoilerplateDescription, Struct) +TQ_OBJECT_CONSTRUCTORS_IMPL(ArrayBoilerplateDescription) -CAST_ACCESSOR(ArrayBoilerplateDescription) - -SMI_ACCESSORS(ArrayBoilerplateDescription, flags, kFlagsOffset) - -ACCESSORS(ArrayBoilerplateDescription, constant_elements, FixedArrayBase, - kConstantElementsOffset) +TQ_SMI_ACCESSORS(ArrayBoilerplateDescription, flags) ElementsKind ArrayBoilerplateDescription::elements_kind() const { return static_cast<ElementsKind>(flags()); diff --git a/deps/v8/src/objects/literal-objects.cc b/deps/v8/src/objects/literal-objects.cc index 7328c11f31..95beb6cbdb 100644 --- a/deps/v8/src/objects/literal-objects.cc +++ b/deps/v8/src/objects/literal-objects.cc @@ -528,8 +528,7 @@ Handle<ClassBoilerplate> ClassBoilerplate::BuildClassBoilerplate( // Add name accessor to the class object if necessary. bool install_class_name_accessor = false; - if (!expr->has_name_static_property() && - expr->constructor()->has_shared_name()) { + if (!expr->has_name_static_property()) { if (static_desc.HasDictionaryProperties()) { // Install class name accessor if necessary during class literal // instantiation. diff --git a/deps/v8/src/objects/literal-objects.h b/deps/v8/src/objects/literal-objects.h index f009a54f8a..cf551ea576 100644 --- a/deps/v8/src/objects/literal-objects.h +++ b/deps/v8/src/objects/literal-objects.h @@ -55,29 +55,22 @@ class ObjectBoilerplateDescription : public FixedArray { OBJECT_CONSTRUCTORS(ObjectBoilerplateDescription, FixedArray); }; -class ArrayBoilerplateDescription : public Struct { +class ArrayBoilerplateDescription + : public TorqueGeneratedArrayBoilerplateDescription< + ArrayBoilerplateDescription, Struct> { public: - // store constant_elements of a fixed array - DECL_ACCESSORS(constant_elements, FixedArrayBase) - inline ElementsKind elements_kind() const; inline void set_elements_kind(ElementsKind kind); inline bool is_empty() const; - DECL_CAST(ArrayBoilerplateDescription) // Dispatched behavior. DECL_PRINTER(ArrayBoilerplateDescription) - DECL_VERIFIER(ArrayBoilerplateDescription) void BriefPrintDetails(std::ostream& os); - DEFINE_FIELD_OFFSET_CONSTANTS( - HeapObject::kHeaderSize, - TORQUE_GENERATED_ARRAY_BOILERPLATE_DESCRIPTION_FIELDS) - private: DECL_INT_ACCESSORS(flags) - OBJECT_CONSTRUCTORS(ArrayBoilerplateDescription, Struct); + TQ_OBJECT_CONSTRUCTORS(ArrayBoilerplateDescription) }; class ClassBoilerplate : public FixedArray { diff --git a/deps/v8/src/objects/lookup.cc b/deps/v8/src/objects/lookup.cc index 33130aafe5..445d0815f3 100644 --- a/deps/v8/src/objects/lookup.cc +++ b/deps/v8/src/objects/lookup.cc @@ -6,6 +6,7 @@ #include "src/deoptimizer/deoptimizer.h" #include "src/execution/isolate-inl.h" +#include "src/execution/protectors-inl.h" #include "src/init/bootstrapper.h" #include "src/logging/counters.h" #include "src/objects/elements.h" @@ -235,30 +236,42 @@ void LookupIterator::InternalUpdateProtector() { if (!receiver_->IsHeapObject()) return; Handle<HeapObject> receiver = Handle<HeapObject>::cast(receiver_); + // Getting the native_context from the isolate as a fallback. If possible, we + // use the receiver's creation context instead. Handle<NativeContext> native_context = isolate_->native_context(); ReadOnlyRoots roots(isolate_); if (*name_ == roots.constructor_string()) { - if (!isolate_->IsArraySpeciesLookupChainIntact() && + // Fetching the context in here since the operation is rather expensive. + if (receiver->IsJSReceiver()) { + native_context = Handle<JSReceiver>::cast(receiver)->GetCreationContext(); + } + + if (!Protectors::IsArraySpeciesLookupChainIntact(isolate_) && !isolate_->IsPromiseSpeciesLookupChainIntact() && - !isolate_->IsRegExpSpeciesLookupChainIntact(native_context) && + !Protectors::IsRegExpSpeciesLookupChainProtectorIntact( + native_context) && !isolate_->IsTypedArraySpeciesLookupChainIntact()) { return; } // Setting the constructor property could change an instance's @@species if (receiver->IsJSArray(isolate_)) { - if (!isolate_->IsArraySpeciesLookupChainIntact()) return; + if (!Protectors::IsArraySpeciesLookupChainIntact(isolate_)) return; isolate_->CountUsage( v8::Isolate::UseCounterFeature::kArrayInstanceConstructorModified); - isolate_->InvalidateArraySpeciesProtector(); + Protectors::InvalidateArraySpeciesLookupChain(isolate_); return; } else if (receiver->IsJSPromise(isolate_)) { if (!isolate_->IsPromiseSpeciesLookupChainIntact()) return; isolate_->InvalidatePromiseSpeciesProtector(); return; } else if (receiver->IsJSRegExp(isolate_)) { - if (!isolate_->IsRegExpSpeciesLookupChainIntact(native_context)) return; - isolate_->InvalidateRegExpSpeciesProtector(native_context); + if (!Protectors::IsRegExpSpeciesLookupChainProtectorIntact( + native_context)) { + return; + } + Protectors::InvalidateRegExpSpeciesLookupChainProtector(isolate_, + native_context); return; } else if (receiver->IsJSTypedArray(isolate_)) { if (!isolate_->IsTypedArraySpeciesLookupChainIntact()) return; @@ -274,18 +287,22 @@ void LookupIterator::InternalUpdateProtector() { // prototype is pointing the same TYPED_ARRAY_PROTOTYPE. if (isolate_->IsInAnyContext(*receiver, Context::INITIAL_ARRAY_PROTOTYPE_INDEX)) { - if (!isolate_->IsArraySpeciesLookupChainIntact()) return; + if (!Protectors::IsArraySpeciesLookupChainIntact(isolate_)) return; isolate_->CountUsage( v8::Isolate::UseCounterFeature::kArrayPrototypeConstructorModified); - isolate_->InvalidateArraySpeciesProtector(); + Protectors::InvalidateArraySpeciesLookupChain(isolate_); } else if (isolate_->IsInAnyContext(*receiver, Context::PROMISE_PROTOTYPE_INDEX)) { if (!isolate_->IsPromiseSpeciesLookupChainIntact()) return; isolate_->InvalidatePromiseSpeciesProtector(); } else if (isolate_->IsInAnyContext(*receiver, Context::REGEXP_PROTOTYPE_INDEX)) { - if (!isolate_->IsRegExpSpeciesLookupChainIntact(native_context)) return; - isolate_->InvalidateRegExpSpeciesProtector(native_context); + if (!Protectors::IsRegExpSpeciesLookupChainProtectorIntact( + native_context)) { + return; + } + Protectors::InvalidateRegExpSpeciesLookupChainProtector(isolate_, + native_context); } else if (isolate_->IsInAnyContext( receiver->map(isolate_).prototype(isolate_), Context::TYPED_ARRAY_PROTOTYPE_INDEX)) { @@ -321,27 +338,37 @@ void LookupIterator::InternalUpdateProtector() { isolate_->InvalidateStringIteratorProtector(); } } else if (*name_ == roots.species_symbol()) { - if (!isolate_->IsArraySpeciesLookupChainIntact() && + // Fetching the context in here since the operation is rather expensive. + if (receiver->IsJSReceiver()) { + native_context = Handle<JSReceiver>::cast(receiver)->GetCreationContext(); + } + + if (!Protectors::IsArraySpeciesLookupChainIntact(isolate_) && !isolate_->IsPromiseSpeciesLookupChainIntact() && - !isolate_->IsRegExpSpeciesLookupChainIntact(native_context) && + !Protectors::IsRegExpSpeciesLookupChainProtectorIntact( + native_context) && !isolate_->IsTypedArraySpeciesLookupChainIntact()) { return; } // Setting the Symbol.species property of any Array, Promise or TypedArray // constructor invalidates the @@species protector if (isolate_->IsInAnyContext(*receiver, Context::ARRAY_FUNCTION_INDEX)) { - if (!isolate_->IsArraySpeciesLookupChainIntact()) return; + if (!Protectors::IsArraySpeciesLookupChainIntact(isolate_)) return; isolate_->CountUsage( v8::Isolate::UseCounterFeature::kArraySpeciesModified); - isolate_->InvalidateArraySpeciesProtector(); + Protectors::InvalidateArraySpeciesLookupChain(isolate_); } else if (isolate_->IsInAnyContext(*receiver, Context::PROMISE_FUNCTION_INDEX)) { if (!isolate_->IsPromiseSpeciesLookupChainIntact()) return; isolate_->InvalidatePromiseSpeciesProtector(); } else if (isolate_->IsInAnyContext(*receiver, Context::REGEXP_FUNCTION_INDEX)) { - if (!isolate_->IsRegExpSpeciesLookupChainIntact(native_context)) return; - isolate_->InvalidateRegExpSpeciesProtector(native_context); + if (!Protectors::IsRegExpSpeciesLookupChainProtectorIntact( + native_context)) { + return; + } + Protectors::InvalidateRegExpSpeciesLookupChainProtector(isolate_, + native_context); } else if (IsTypedArrayFunctionInAnyContext(isolate_, *receiver)) { if (!isolate_->IsTypedArraySpeciesLookupChainIntact()) return; isolate_->InvalidateTypedArraySpeciesProtector(); @@ -433,7 +460,8 @@ void LookupIterator::PrepareForDataProperty(Handle<Object> value) { } // Copy the backing store if it is copy-on-write. - if (IsSmiOrObjectElementsKind(to) || IsSealedElementsKind(to)) { + if (IsSmiOrObjectElementsKind(to) || IsSealedElementsKind(to) || + IsNonextensibleElementsKind(to)) { JSObject::EnsureWritableFastElements(holder_obj); } return; @@ -901,8 +929,8 @@ bool LookupIterator::IsConstFieldValueEqualTo(Object value) const { bits = holder->RawFastDoublePropertyAsBitsAt(field_index); } else { Object current_value = holder->RawFastPropertyAt(isolate_, field_index); - DCHECK(current_value.IsMutableHeapNumber(isolate_)); - bits = MutableHeapNumber::cast(current_value).value_as_bits(); + DCHECK(current_value.IsHeapNumber(isolate_)); + bits = HeapNumber::cast(current_value).value_as_bits(); } // Use bit representation of double to to check for hole double, since // manipulating the signaling NaN used for the hole in C++, e.g. with @@ -1137,9 +1165,10 @@ LookupIterator::State LookupIterator::LookupInRegularHolder( : NOT_FOUND; } property_details_ = accessor->GetDetails(js_object, number_); - if (map.has_frozen_or_sealed_elements()) { - PropertyAttributes attrs = map.has_sealed_elements() ? SEALED : FROZEN; - property_details_ = property_details_.CopyAddAttributes(attrs); + if (map.has_frozen_elements()) { + property_details_ = property_details_.CopyAddAttributes(FROZEN); + } else if (map.has_sealed_elements()) { + property_details_ = property_details_.CopyAddAttributes(SEALED); } } else if (!map.is_dictionary_map()) { DescriptorArray descriptors = map.instance_descriptors(isolate_); diff --git a/deps/v8/src/objects/map-inl.h b/deps/v8/src/objects/map-inl.h index 6a9359e3a0..48bb86e2da 100644 --- a/deps/v8/src/objects/map-inl.h +++ b/deps/v8/src/objects/map-inl.h @@ -507,8 +507,12 @@ bool Map::has_dictionary_elements() const { return IsDictionaryElementsKind(elements_kind()); } -bool Map::has_frozen_or_sealed_elements() const { - return IsFrozenOrSealedElementsKind(elements_kind()); +bool Map::has_any_nonextensible_elements() const { + return IsAnyNonextensibleElementsKind(elements_kind()); +} + +bool Map::has_nonextensible_elements() const { + return IsNonextensibleElementsKind(elements_kind()); } bool Map::has_sealed_elements() const { diff --git a/deps/v8/src/objects/map-updater.cc b/deps/v8/src/objects/map-updater.cc index d21f0e1a12..49b9ccea91 100644 --- a/deps/v8/src/objects/map-updater.cc +++ b/deps/v8/src/objects/map-updater.cc @@ -324,7 +324,7 @@ MapUpdater::State MapUpdater::FindRootMap() { DCHECK(to_kind == DICTIONARY_ELEMENTS || to_kind == SLOW_STRING_WRAPPER_ELEMENTS || IsTypedArrayElementsKind(to_kind) || - IsFrozenOrSealedElementsKind(to_kind)); + IsAnyNonextensibleElementsKind(to_kind)); to_kind = integrity_source_map_->elements_kind(); } diff --git a/deps/v8/src/objects/map.cc b/deps/v8/src/objects/map.cc index 7b4f1abd05..a672d6580a 100644 --- a/deps/v8/src/objects/map.cc +++ b/deps/v8/src/objects/map.cc @@ -281,8 +281,6 @@ VisitorId Map::GetVisitorId(Map map) { case JS_DATE_TYPE: case JS_ARRAY_ITERATOR_TYPE: case JS_ARRAY_TYPE: - case JS_GLOBAL_PROXY_TYPE: - case JS_GLOBAL_OBJECT_TYPE: case JS_MESSAGE_OBJECT_TYPE: case JS_SET_TYPE: case JS_MAP_TYPE: @@ -321,6 +319,8 @@ VisitorId Map::GetVisitorId(Map map) { return has_raw_data_fields ? kVisitJSObject : kVisitJSObjectFast; } case JS_API_OBJECT_TYPE: + case JS_GLOBAL_PROXY_TYPE: + case JS_GLOBAL_OBJECT_TYPE: case JS_SPECIAL_API_OBJECT_TYPE: return kVisitJSApiObject; @@ -333,7 +333,6 @@ VisitorId Map::GetVisitorId(Map map) { case FILLER_TYPE: case FOREIGN_TYPE: case HEAP_NUMBER_TYPE: - case MUTABLE_HEAP_NUMBER_TYPE: case FEEDBACK_METADATA_TYPE: return kVisitDataObject; @@ -681,6 +680,10 @@ void Map::UpdateFieldType(Isolate* isolate, int descriptor, Handle<Name> name, if (details.location() != kField) return; DCHECK_EQ(kData, details.kind()); + if (new_constness != details.constness() && is_prototype_map()) { + JSObject::InvalidatePrototypeChains(*this); + } + Zone zone(isolate->allocator(), ZONE_NAME); ZoneQueue<Map> backlog(&zone); backlog.push(*this); @@ -966,7 +969,7 @@ Map Map::TryUpdateSlow(Isolate* isolate, Map old_map) { DCHECK(to_kind == DICTIONARY_ELEMENTS || to_kind == SLOW_STRING_WRAPPER_ELEMENTS || IsTypedArrayElementsKind(to_kind) || - IsHoleyFrozenOrSealedElementsKind(to_kind)); + IsAnyHoleyNonextensibleElementsKind(to_kind)); to_kind = info.integrity_level_source_map.elements_kind(); } if (from_kind != to_kind) { @@ -1730,6 +1733,12 @@ Handle<Map> Map::CopyReplaceDescriptors( descriptors->GeneralizeAllFields(); result->InitializeDescriptors(isolate, *descriptors, LayoutDescriptor::FastPointerLayout()); + // If we were trying to insert a transition but failed because there are + // too many transitions already, mark the object as a prototype to avoid + // tracking transitions from the detached map. + if (flag == INSERT_TRANSITION) { + result->set_is_prototype_map(true); + } } } else { result->InitializeDescriptors(isolate, *descriptors, *layout_descriptor); @@ -2006,6 +2015,15 @@ Handle<Map> Map::CopyForPreventExtensions( new_kind = PACKED_SEALED_ELEMENTS; } else if (attrs_to_add == FROZEN) { new_kind = PACKED_FROZEN_ELEMENTS; + } else { + new_kind = PACKED_NONEXTENSIBLE_ELEMENTS; + } + break; + case PACKED_NONEXTENSIBLE_ELEMENTS: + if (attrs_to_add == SEALED) { + new_kind = PACKED_SEALED_ELEMENTS; + } else if (attrs_to_add == FROZEN) { + new_kind = PACKED_FROZEN_ELEMENTS; } break; case PACKED_SEALED_ELEMENTS: @@ -2018,6 +2036,15 @@ Handle<Map> Map::CopyForPreventExtensions( new_kind = HOLEY_SEALED_ELEMENTS; } else if (attrs_to_add == FROZEN) { new_kind = HOLEY_FROZEN_ELEMENTS; + } else { + new_kind = HOLEY_NONEXTENSIBLE_ELEMENTS; + } + break; + case HOLEY_NONEXTENSIBLE_ELEMENTS: + if (attrs_to_add == SEALED) { + new_kind = HOLEY_SEALED_ELEMENTS; + } else if (attrs_to_add == FROZEN) { + new_kind = HOLEY_FROZEN_ELEMENTS; } break; case HOLEY_SEALED_ELEMENTS: diff --git a/deps/v8/src/objects/map.h b/deps/v8/src/objects/map.h index c9da19b3e3..ef16019685 100644 --- a/deps/v8/src/objects/map.h +++ b/deps/v8/src/objects/map.h @@ -423,7 +423,8 @@ class Map : public HeapObject { inline bool has_fast_string_wrapper_elements() const; inline bool has_typed_array_elements() const; inline bool has_dictionary_elements() const; - inline bool has_frozen_or_sealed_elements() const; + inline bool has_any_nonextensible_elements() const; + inline bool has_nonextensible_elements() const; inline bool has_sealed_elements() const; inline bool has_frozen_elements() const; diff --git a/deps/v8/src/objects/microtask-inl.h b/deps/v8/src/objects/microtask-inl.h index 91fa5890cb..613ee096c5 100644 --- a/deps/v8/src/objects/microtask-inl.h +++ b/deps/v8/src/objects/microtask-inl.h @@ -18,19 +18,9 @@ namespace v8 { namespace internal { -OBJECT_CONSTRUCTORS_IMPL(Microtask, Struct) -OBJECT_CONSTRUCTORS_IMPL(CallbackTask, Microtask) -OBJECT_CONSTRUCTORS_IMPL(CallableTask, Microtask) - -CAST_ACCESSOR(Microtask) -CAST_ACCESSOR(CallbackTask) -CAST_ACCESSOR(CallableTask) - -ACCESSORS(CallableTask, callable, JSReceiver, kCallableOffset) -ACCESSORS(CallableTask, context, Context, kContextOffset) - -ACCESSORS(CallbackTask, callback, Foreign, kCallbackOffset) -ACCESSORS(CallbackTask, data, Foreign, kDataOffset) +TQ_OBJECT_CONSTRUCTORS_IMPL(Microtask) +TQ_OBJECT_CONSTRUCTORS_IMPL(CallbackTask) +TQ_OBJECT_CONSTRUCTORS_IMPL(CallableTask) } // namespace internal } // namespace v8 diff --git a/deps/v8/src/objects/microtask.h b/deps/v8/src/objects/microtask.h index d631bf6903..cd8a71f58c 100644 --- a/deps/v8/src/objects/microtask.h +++ b/deps/v8/src/objects/microtask.h @@ -17,52 +17,35 @@ namespace internal { // Abstract base class for all microtasks that can be scheduled on the // microtask queue. This class merely serves the purpose of a marker // interface. -class Microtask : public Struct { +class Microtask : public TorqueGeneratedMicrotask<Microtask, Struct> { public: - // Dispatched behavior. - DECL_CAST(Microtask) - DECL_VERIFIER(Microtask) - - OBJECT_CONSTRUCTORS(Microtask, Struct); + TQ_OBJECT_CONSTRUCTORS(Microtask) }; // A CallbackTask is a special Microtask that allows us to schedule // C++ microtask callbacks on the microtask queue. This is heavily // used by Blink for example. -class CallbackTask : public Microtask { +class CallbackTask + : public TorqueGeneratedCallbackTask<CallbackTask, Microtask> { public: - DECL_ACCESSORS(callback, Foreign) - DECL_ACCESSORS(data, Foreign) - - DEFINE_FIELD_OFFSET_CONSTANTS(Microtask::kHeaderSize, - TORQUE_GENERATED_CALLBACK_TASK_FIELDS) - // Dispatched behavior. - DECL_CAST(CallbackTask) DECL_PRINTER(CallbackTask) - DECL_VERIFIER(CallbackTask) - OBJECT_CONSTRUCTORS(CallbackTask, Microtask); + TQ_OBJECT_CONSTRUCTORS(CallbackTask) }; // A CallableTask is a special (internal) Microtask that allows us to // schedule arbitrary callables on the microtask queue. We use this // for various tests of the microtask queue. -class CallableTask : public Microtask { +class CallableTask + : public TorqueGeneratedCallableTask<CallableTask, Microtask> { public: - DECL_ACCESSORS(callable, JSReceiver) - DECL_ACCESSORS(context, Context) - - DEFINE_FIELD_OFFSET_CONSTANTS(Microtask::kHeaderSize, - TORQUE_GENERATED_CALLABLE_TASK_FIELDS) - // Dispatched behavior. - DECL_CAST(CallableTask) DECL_PRINTER(CallableTask) DECL_VERIFIER(CallableTask) void BriefPrintDetails(std::ostream& os); - OBJECT_CONSTRUCTORS(CallableTask, Microtask); + TQ_OBJECT_CONSTRUCTORS(CallableTask) }; } // namespace internal diff --git a/deps/v8/src/objects/module-inl.h b/deps/v8/src/objects/module-inl.h index 1ab9b9fb04..ac54516376 100644 --- a/deps/v8/src/objects/module-inl.h +++ b/deps/v8/src/objects/module-inl.h @@ -20,37 +20,24 @@ namespace v8 { namespace internal { OBJECT_CONSTRUCTORS_IMPL(Module, HeapObject) -OBJECT_CONSTRUCTORS_IMPL(SourceTextModule, Module) -OBJECT_CONSTRUCTORS_IMPL(SourceTextModuleInfoEntry, Struct) -OBJECT_CONSTRUCTORS_IMPL(SyntheticModule, Module) -OBJECT_CONSTRUCTORS_IMPL(JSModuleNamespace, JSObject) +TQ_OBJECT_CONSTRUCTORS_IMPL(SourceTextModule) +TQ_OBJECT_CONSTRUCTORS_IMPL(SourceTextModuleInfoEntry) +TQ_OBJECT_CONSTRUCTORS_IMPL(SyntheticModule) +TQ_OBJECT_CONSTRUCTORS_IMPL(JSModuleNamespace) NEVER_READ_ONLY_SPACE_IMPL(Module) NEVER_READ_ONLY_SPACE_IMPL(SourceTextModule) NEVER_READ_ONLY_SPACE_IMPL(SyntheticModule) CAST_ACCESSOR(Module) -CAST_ACCESSOR(SourceTextModule) -CAST_ACCESSOR(SyntheticModule) ACCESSORS(Module, exports, ObjectHashTable, kExportsOffset) ACCESSORS(Module, module_namespace, HeapObject, kModuleNamespaceOffset) ACCESSORS(Module, exception, Object, kExceptionOffset) SMI_ACCESSORS(Module, status, kStatusOffset) SMI_ACCESSORS(Module, hash, kHashOffset) -ACCESSORS(SourceTextModule, code, Object, kCodeOffset) -ACCESSORS(SourceTextModule, regular_exports, FixedArray, kRegularExportsOffset) -ACCESSORS(SourceTextModule, regular_imports, FixedArray, kRegularImportsOffset) -ACCESSORS(SourceTextModule, requested_modules, FixedArray, - kRequestedModulesOffset) -ACCESSORS(SourceTextModule, script, Script, kScriptOffset) -ACCESSORS(SourceTextModule, import_meta, Object, kImportMetaOffset) -SMI_ACCESSORS(SourceTextModule, dfs_index, kDfsIndexOffset) -SMI_ACCESSORS(SourceTextModule, dfs_ancestor_index, kDfsAncestorIndexOffset) - -ACCESSORS(SyntheticModule, name, String, kNameOffset) -ACCESSORS(SyntheticModule, export_names, FixedArray, kExportNamesOffset) -ACCESSORS(SyntheticModule, evaluation_steps, Foreign, kEvaluationStepsOffset) +TQ_SMI_ACCESSORS(SourceTextModule, dfs_index) +TQ_SMI_ACCESSORS(SourceTextModule, dfs_ancestor_index) SourceTextModuleInfo SourceTextModule::info() const { return (status() >= kEvaluating) @@ -58,17 +45,10 @@ SourceTextModuleInfo SourceTextModule::info() const { : GetSharedFunctionInfo().scope_info().ModuleDescriptorInfo(); } -CAST_ACCESSOR(JSModuleNamespace) -ACCESSORS(JSModuleNamespace, module, Module, kModuleOffset) - -CAST_ACCESSOR(SourceTextModuleInfoEntry) -ACCESSORS(SourceTextModuleInfoEntry, export_name, Object, kExportNameOffset) -ACCESSORS(SourceTextModuleInfoEntry, local_name, Object, kLocalNameOffset) -ACCESSORS(SourceTextModuleInfoEntry, import_name, Object, kImportNameOffset) -SMI_ACCESSORS(SourceTextModuleInfoEntry, module_request, kModuleRequestOffset) -SMI_ACCESSORS(SourceTextModuleInfoEntry, cell_index, kCellIndexOffset) -SMI_ACCESSORS(SourceTextModuleInfoEntry, beg_pos, kBegPosOffset) -SMI_ACCESSORS(SourceTextModuleInfoEntry, end_pos, kEndPosOffset) +TQ_SMI_ACCESSORS(SourceTextModuleInfoEntry, module_request) +TQ_SMI_ACCESSORS(SourceTextModuleInfoEntry, cell_index) +TQ_SMI_ACCESSORS(SourceTextModuleInfoEntry, beg_pos) +TQ_SMI_ACCESSORS(SourceTextModuleInfoEntry, end_pos) OBJECT_CONSTRUCTORS_IMPL(SourceTextModuleInfo, FixedArray) CAST_ACCESSOR(SourceTextModuleInfo) diff --git a/deps/v8/src/objects/module.cc b/deps/v8/src/objects/module.cc index 4e89050360..60b9145d10 100644 --- a/deps/v8/src/objects/module.cc +++ b/deps/v8/src/objects/module.cc @@ -107,21 +107,18 @@ void Module::Reset(Isolate* isolate, Handle<Module> module) { module->PrintStatusTransition(kUninstantiated); #endif // DEBUG - int export_count; + const int export_count = + module->IsSourceTextModule() + ? Handle<SourceTextModule>::cast(module)->regular_exports().length() + : Handle<SyntheticModule>::cast(module)->export_names().length(); + Handle<ObjectHashTable> exports = ObjectHashTable::New(isolate, export_count); if (module->IsSourceTextModule()) { - Handle<SourceTextModule> source_text_module = - Handle<SourceTextModule>::cast(module); - export_count = source_text_module->regular_exports().length(); - SourceTextModule::Reset(isolate, source_text_module); + SourceTextModule::Reset(isolate, Handle<SourceTextModule>::cast(module)); } else { - export_count = - Handle<SyntheticModule>::cast(module)->export_names().length(); // Nothing to do here. } - Handle<ObjectHashTable> exports = ObjectHashTable::New(isolate, export_count); - module->set_exports(*exports); module->set_status(kUninstantiated); } diff --git a/deps/v8/src/objects/module.h b/deps/v8/src/objects/module.h index b776ddb0be..08badf0357 100644 --- a/deps/v8/src/objects/module.h +++ b/deps/v8/src/objects/module.h @@ -136,14 +136,10 @@ class Module : public HeapObject { // When importing a module namespace (import * as foo from "bar"), a // JSModuleNamespace object (representing module "bar") is created and bound to // the declared variable (foo). A module can have at most one namespace object. -class JSModuleNamespace : public JSObject { +class JSModuleNamespace + : public TorqueGeneratedJSModuleNamespace<JSModuleNamespace, JSObject> { public: - DECL_CAST(JSModuleNamespace) DECL_PRINTER(JSModuleNamespace) - DECL_VERIFIER(JSModuleNamespace) - - // The actual module whose namespace is being represented. - DECL_ACCESSORS(module, Module) // Retrieve the value exported by [module] under the given [name]. If there is // no such export, return Just(undefined). If the export is uninitialized, @@ -163,16 +159,12 @@ class JSModuleNamespace : public JSObject { kInObjectFieldCount, }; - // Layout description. - DEFINE_FIELD_OFFSET_CONSTANTS(JSObject::kHeaderSize, - TORQUE_GENERATED_JSMODULE_NAMESPACE_FIELDS) - // We need to include in-object fields // TODO(v8:8944): improve handling of in-object fields static constexpr int kSize = kHeaderSize + (kTaggedSize * kInObjectFieldCount); - OBJECT_CONSTRUCTORS(JSModuleNamespace, JSObject); + TQ_OBJECT_CONSTRUCTORS(JSModuleNamespace) }; } // namespace internal diff --git a/deps/v8/src/objects/name-inl.h b/deps/v8/src/objects/name-inl.h index 8aded12fb5..b76ae245a2 100644 --- a/deps/v8/src/objects/name-inl.h +++ b/deps/v8/src/objects/name-inl.h @@ -22,7 +22,8 @@ TQ_OBJECT_CONSTRUCTORS_IMPL(Symbol) BIT_FIELD_ACCESSORS(Symbol, flags, is_private, Symbol::IsPrivateBit) BIT_FIELD_ACCESSORS(Symbol, flags, is_well_known_symbol, Symbol::IsWellKnownSymbolBit) -BIT_FIELD_ACCESSORS(Symbol, flags, is_public, Symbol::IsPublicBit) +BIT_FIELD_ACCESSORS(Symbol, flags, is_in_public_symbol_table, + Symbol::IsInPublicSymbolTableBit) BIT_FIELD_ACCESSORS(Symbol, flags, is_interesting_symbol, Symbol::IsInterestingSymbolBit) diff --git a/deps/v8/src/objects/name.h b/deps/v8/src/objects/name.h index b13aa30fb0..a02bb3d794 100644 --- a/deps/v8/src/objects/name.h +++ b/deps/v8/src/objects/name.h @@ -99,12 +99,11 @@ class Name : public TorqueGeneratedName<Name, HeapObject> { STATIC_ASSERT(kArrayIndexLengthBits > 0); STATIC_ASSERT(kMaxArrayIndexSize < (1 << kArrayIndexLengthBits)); - class ArrayIndexValueBits - : public BitField<unsigned int, kNofHashBitFields, kArrayIndexValueBits> { - }; // NOLINT - class ArrayIndexLengthBits - : public BitField<unsigned int, kNofHashBitFields + kArrayIndexValueBits, - kArrayIndexLengthBits> {}; // NOLINT + using ArrayIndexValueBits = + BitField<unsigned int, kNofHashBitFields, kArrayIndexValueBits>; + using ArrayIndexLengthBits = + BitField<unsigned int, kNofHashBitFields + kArrayIndexValueBits, + kArrayIndexLengthBits>; // Check that kMaxCachedArrayIndexLength + 1 is a power of two so we // could use a mask to test if the length of string is less than or equal to @@ -147,9 +146,10 @@ class Symbol : public TorqueGeneratedSymbol<Symbol, Name> { // for a detailed description. DECL_BOOLEAN_ACCESSORS(is_interesting_symbol) - // [is_public]: Whether this is a symbol created by Symbol.for. Calling - // Symbol.keyFor on such a symbol simply needs to return the attached name. - DECL_BOOLEAN_ACCESSORS(is_public) + // [is_in_public_symbol_table]: Whether this is a symbol created by + // Symbol.for. Calling Symbol.keyFor on such a symbol simply needs + // to return the attached name. + DECL_BOOLEAN_ACCESSORS(is_in_public_symbol_table) // [is_private_name]: Whether this is a private name. Private names // are the same as private symbols except they throw on missing @@ -164,11 +164,11 @@ class Symbol : public TorqueGeneratedSymbol<Symbol, Name> { DECL_VERIFIER(Symbol) // Flags layout. -#define FLAGS_BIT_FIELDS(V, _) \ - V(IsPrivateBit, bool, 1, _) \ - V(IsWellKnownSymbolBit, bool, 1, _) \ - V(IsPublicBit, bool, 1, _) \ - V(IsInterestingSymbolBit, bool, 1, _) \ +#define FLAGS_BIT_FIELDS(V, _) \ + V(IsPrivateBit, bool, 1, _) \ + V(IsWellKnownSymbolBit, bool, 1, _) \ + V(IsInPublicSymbolTableBit, bool, 1, _) \ + V(IsInterestingSymbolBit, bool, 1, _) \ V(IsPrivateNameBit, bool, 1, _) DEFINE_BIT_FIELDS(FLAGS_BIT_FIELDS) diff --git a/deps/v8/src/objects/object-list-macros.h b/deps/v8/src/objects/object-list-macros.h index c15b212eec..d5bce62d43 100644 --- a/deps/v8/src/objects/object-list-macros.h +++ b/deps/v8/src/objects/object-list-macros.h @@ -37,7 +37,7 @@ class LookupIterator; class FieldType; class Module; class SourceTextModuleInfoEntry; -class MutableHeapNumber; +class HeapNumber; class ObjectHashTable; class ObjectTemplateInfo; class ObjectVisitor; @@ -173,7 +173,6 @@ class ZoneForwardList; V(MapCache) \ V(Module) \ V(Microtask) \ - V(MutableHeapNumber) \ V(Name) \ V(NameDictionary) \ V(NativeContext) \ diff --git a/deps/v8/src/objects/object-macros.h b/deps/v8/src/objects/object-macros.h index 8f9e51ca9e..da8c404c14 100644 --- a/deps/v8/src/objects/object-macros.h +++ b/deps/v8/src/objects/object-macros.h @@ -290,20 +290,31 @@ #define RELAXED_WRITE_WEAK_FIELD(p, offset, value) \ TaggedField<MaybeObject>::Relaxed_Store(p, offset, value) +#ifdef V8_DISABLE_WRITE_BARRIERS +#define WRITE_BARRIER(object, offset, value) +#else #define WRITE_BARRIER(object, offset, value) \ do { \ DCHECK_NOT_NULL(GetHeapFromWritableObject(object)); \ MarkingBarrier(object, (object).RawField(offset), value); \ GenerationalBarrier(object, (object).RawField(offset), value); \ } while (false) +#endif +#ifdef V8_DISABLE_WRITE_BARRIERS +#define WEAK_WRITE_BARRIER(object, offset, value) +#else #define WEAK_WRITE_BARRIER(object, offset, value) \ do { \ DCHECK_NOT_NULL(GetHeapFromWritableObject(object)); \ MarkingBarrier(object, (object).RawMaybeWeakField(offset), value); \ GenerationalBarrier(object, (object).RawMaybeWeakField(offset), value); \ } while (false) +#endif +#ifdef V8_DISABLE_WRITE_BARRIERS +#define EPHEMERON_KEY_WRITE_BARRIER(object, offset, value) +#else #define EPHEMERON_KEY_WRITE_BARRIER(object, offset, value) \ do { \ DCHECK_NOT_NULL(GetHeapFromWritableObject(object)); \ @@ -311,7 +322,11 @@ MarkingBarrier(object, (object).RawField(offset), value); \ GenerationalEphemeronKeyBarrier(table, (object).RawField(offset), value); \ } while (false) +#endif +#ifdef V8_DISABLE_WRITE_BARRIERS +#define CONDITIONAL_WRITE_BARRIER(object, offset, value, mode) +#else #define CONDITIONAL_WRITE_BARRIER(object, offset, value, mode) \ do { \ DCHECK_NOT_NULL(GetHeapFromWritableObject(object)); \ @@ -323,7 +338,11 @@ GenerationalBarrier(object, (object).RawField(offset), value); \ } \ } while (false) +#endif +#ifdef V8_DISABLE_WRITE_BARRIERS +#define CONDITIONAL_WEAK_WRITE_BARRIER(object, offset, value, mode) +#else #define CONDITIONAL_WEAK_WRITE_BARRIER(object, offset, value, mode) \ do { \ DCHECK_NOT_NULL(GetHeapFromWritableObject(object)); \ @@ -335,7 +354,11 @@ GenerationalBarrier(object, (object).RawMaybeWeakField(offset), value); \ } \ } while (false) +#endif +#ifdef V8_DISABLE_WRITE_BARRIERS +#define CONDITIONAL_EPHEMERON_KEY_WRITE_BARRIER(object, offset, value, mode) +#else #define CONDITIONAL_EPHEMERON_KEY_WRITE_BARRIER(object, offset, value, mode) \ do { \ DCHECK_NOT_NULL(GetHeapFromWritableObject(object)); \ @@ -349,6 +372,7 @@ value); \ } \ } while (false) +#endif #define ACQUIRE_READ_INT32_FIELD(p, offset) \ static_cast<int32_t>(base::Acquire_Load( \ diff --git a/deps/v8/src/objects/objects-body-descriptors-inl.h b/deps/v8/src/objects/objects-body-descriptors-inl.h index 51e380695e..4c980b2697 100644 --- a/deps/v8/src/objects/objects-body-descriptors-inl.h +++ b/deps/v8/src/objects/objects-body-descriptors-inl.h @@ -1022,7 +1022,6 @@ ReturnType BodyDescriptorApply(InstanceType type, T1 p1, T2 p2, T3 p3, T4 p4) { return Op::template apply<UncompiledDataWithPreparseData::BodyDescriptor>( p1, p2, p3, p4); case HEAP_NUMBER_TYPE: - case MUTABLE_HEAP_NUMBER_TYPE: case FILLER_TYPE: case BYTE_ARRAY_TYPE: case FREE_SPACE_TYPE: diff --git a/deps/v8/src/objects/objects-definitions.h b/deps/v8/src/objects/objects-definitions.h index b4c8591e5c..b346b5b7d1 100644 --- a/deps/v8/src/objects/objects-definitions.h +++ b/deps/v8/src/objects/objects-definitions.h @@ -67,7 +67,6 @@ namespace internal { \ V(MAP_TYPE) \ V(CODE_TYPE) \ - V(MUTABLE_HEAP_NUMBER_TYPE) \ V(FOREIGN_TYPE) \ V(BYTE_ARRAY_TYPE) \ V(BYTECODE_ARRAY_TYPE) \ @@ -116,7 +115,6 @@ namespace internal { V(PROMISE_FULFILL_REACTION_JOB_TASK_TYPE) \ V(PROMISE_REJECT_REACTION_JOB_TASK_TYPE) \ V(PROMISE_RESOLVE_THENABLE_JOB_TASK_TYPE) \ - V(FINALIZATION_GROUP_CLEANUP_JOB_TASK_TYPE) \ \ TORQUE_DEFINED_INSTANCE_TYPES(V) \ \ @@ -348,9 +346,7 @@ namespace internal { V(_, PROMISE_REJECT_REACTION_JOB_TASK_TYPE, PromiseRejectReactionJobTask, \ promise_reject_reaction_job_task) \ V(_, PROMISE_RESOLVE_THENABLE_JOB_TASK_TYPE, PromiseResolveThenableJobTask, \ - promise_resolve_thenable_job_task) \ - V(_, FINALIZATION_GROUP_CLEANUP_JOB_TASK_TYPE, \ - FinalizationGroupCleanupJobTask, finalization_group_cleanup_job_task) + promise_resolve_thenable_job_task) // Adapts one STRUCT_LIST_GENERATOR entry to the STRUCT_LIST entry #define STRUCT_LIST_ADAPTER(V, NAME, Name, name) V(NAME, Name, name) diff --git a/deps/v8/src/objects/objects-inl.h b/deps/v8/src/objects/objects-inl.h index b6748401c0..cf8c3ffad2 100644 --- a/deps/v8/src/objects/objects-inl.h +++ b/deps/v8/src/objects/objects-inl.h @@ -133,6 +133,13 @@ bool Object::IsNullOrUndefined() const { bool Object::IsZero() const { return *this == Smi::zero(); } +bool Object::IsPublicSymbol() const { + return IsSymbol() && !Symbol::cast(*this).is_private(); +} +bool Object::IsPrivateSymbol() const { + return IsSymbol() && Symbol::cast(*this).is_private(); +} + bool Object::IsNoSharedNameSentinel() const { return *this == SharedFunctionInfo::kNoSharedNameSentinel; } @@ -560,7 +567,7 @@ bool Object::FitsRepresentation(Representation representation) { if (FLAG_track_fields && representation.IsSmi()) { return IsSmi(); } else if (FLAG_track_double_fields && representation.IsDouble()) { - return IsMutableHeapNumber() || IsNumber(); + return IsNumber(); } else if (FLAG_track_heap_object_fields && representation.IsHeapObject()) { return IsHeapObject(); } else if (FLAG_track_fields && representation.IsNone()) { diff --git a/deps/v8/src/objects/objects.cc b/deps/v8/src/objects/objects.cc index 9963cba472..134cb3998a 100644 --- a/deps/v8/src/objects/objects.cc +++ b/deps/v8/src/objects/objects.cc @@ -33,6 +33,7 @@ #include "src/execution/frames-inl.h" #include "src/execution/isolate-inl.h" #include "src/execution/microtask-queue.h" +#include "src/execution/protectors-inl.h" #include "src/heap/heap-inl.h" #include "src/heap/read-only-heap.h" #include "src/ic/ic.h" @@ -193,12 +194,12 @@ Handle<FieldType> Object::OptimalType(Isolate* isolate, Handle<Object> Object::NewStorageFor(Isolate* isolate, Handle<Object> object, Representation representation) { if (!representation.IsDouble()) return object; - auto result = isolate->factory()->NewMutableHeapNumberWithHoleNaN(); + auto result = isolate->factory()->NewHeapNumberWithHoleNaN(); if (object->IsUninitialized(isolate)) { result->set_value_as_bits(kHoleNanInt64); - } else if (object->IsMutableHeapNumber()) { + } else if (object->IsHeapNumber()) { // Ensure that all bits of the double value are preserved. - result->set_value_as_bits(MutableHeapNumber::cast(*object).value_as_bits()); + result->set_value_as_bits(HeapNumber::cast(*object).value_as_bits()); } else { result->set_value(object->Number()); } @@ -213,7 +214,7 @@ Handle<Object> Object::WrapForRead(Isolate* isolate, Handle<Object> object, return object; } return isolate->factory()->NewHeapNumberFromBits( - MutableHeapNumber::cast(*object).value_as_bits()); + HeapNumber::cast(*object).value_as_bits()); } MaybeHandle<JSReceiver> Object::ToObjectImpl(Isolate* isolate, @@ -1667,7 +1668,7 @@ MaybeHandle<Object> Object::ArraySpeciesConstructor( Handle<Object> default_species = isolate->array_function(); if (original_array->IsJSArray() && Handle<JSArray>::cast(original_array)->HasArrayPrototype(isolate) && - isolate->IsArraySpeciesLookupChainIntact()) { + Protectors::IsArraySpeciesLookupChainIntact(isolate)) { return default_species; } Handle<Object> constructor = isolate->factory()->undefined_value(); @@ -2077,12 +2078,6 @@ void HeapObject::HeapObjectShortPrint(std::ostream& os) { // NOLINT os << ">"; break; } - case MUTABLE_HEAP_NUMBER_TYPE: { - os << "<MutableHeapNumber "; - MutableHeapNumber::cast(*this).MutableHeapNumberPrint(os); - os << '>'; - break; - } case BIGINT_TYPE: { os << "<BigInt "; BigInt::cast(*this).BigIntShortPrint(os); @@ -2192,8 +2187,7 @@ int HeapObject::SizeFromMap(Map map) const { FixedArray::unchecked_cast(*this).synchronized_length()); } if (IsInRange(instance_type, FIRST_CONTEXT_TYPE, LAST_CONTEXT_TYPE)) { - // Native context has fixed size. - DCHECK_NE(instance_type, NATIVE_CONTEXT_TYPE); + if (instance_type == NATIVE_CONTEXT_TYPE) return NativeContext::kSize; return Context::SizeFor(Context::unchecked_cast(*this).length()); } if (instance_type == ONE_BYTE_STRING_TYPE || @@ -4289,11 +4283,13 @@ Handle<AccessorPair> AccessorPair::Copy(Isolate* isolate, } Handle<Object> AccessorPair::GetComponent(Isolate* isolate, + Handle<NativeContext> native_context, Handle<AccessorPair> accessor_pair, AccessorComponent component) { Object accessor = accessor_pair->get(component); if (accessor.IsFunctionTemplateInfo()) { return ApiNatives::InstantiateFunction( + isolate, native_context, handle(FunctionTemplateInfo::cast(accessor), isolate)) .ToHandleChecked(); } @@ -5339,12 +5335,9 @@ void SharedFunctionInfo::InitFromFunctionLiteral( lit->end_position()); needs_position_info = false; } - shared_info->set_is_declaration(lit->is_declaration()); - shared_info->set_is_named_expression(lit->is_named_expression()); - shared_info->set_is_anonymous_expression(lit->is_anonymous_expression()); + shared_info->set_syntax_kind(lit->syntax_kind()); shared_info->set_allows_lazy_compilation(lit->AllowsLazyCompilation()); shared_info->set_language_mode(lit->language_mode()); - shared_info->set_is_wrapped(lit->is_wrapped()); shared_info->set_function_literal_id(lit->function_literal_id()); // shared_info->set_kind(lit->kind()); // FunctionKind must have already been set. @@ -5650,8 +5643,7 @@ bool AllocationSite::IsNested() { } bool AllocationSite::ShouldTrack(ElementsKind from, ElementsKind to) { - return IsSmiElementsKind(from) && - IsMoreGeneralElementsKindTransition(from, to); + return IsMoreGeneralElementsKindTransition(from, to); } const char* AllocationSite::PretenureDecisionName(PretenureDecision decision) { @@ -6145,6 +6137,43 @@ Handle<JSRegExp> JSRegExp::Copy(Handle<JSRegExp> regexp) { return Handle<JSRegExp>::cast(isolate->factory()->CopyJSObject(regexp)); } +Object JSRegExp::Code(bool is_latin1) const { + return DataAt(code_index(is_latin1)); +} + +Object JSRegExp::Bytecode(bool is_latin1) const { + return DataAt(bytecode_index(is_latin1)); +} + +bool JSRegExp::ShouldProduceBytecode() { + return FLAG_regexp_interpret_all || + (FLAG_regexp_tier_up && !MarkedForTierUp()); +} + +// An irregexp is considered to be marked for tier up if the tier-up ticks value +// is not zero. An atom is not subject to tier-up implementation, so the tier-up +// ticks value is not set. +bool JSRegExp::MarkedForTierUp() { + DCHECK(data().IsFixedArray()); + if (TypeTag() == JSRegExp::ATOM) { + return false; + } + return Smi::ToInt(DataAt(kIrregexpTierUpTicksIndex)) != 0; +} + +void JSRegExp::ResetTierUp() { + DCHECK(FLAG_regexp_tier_up); + DCHECK_EQ(TypeTag(), JSRegExp::IRREGEXP); + FixedArray::cast(data()).set(JSRegExp::kIrregexpTierUpTicksIndex, Smi::kZero); +} + +void JSRegExp::MarkTierUpForNextExec() { + DCHECK(FLAG_regexp_tier_up); + DCHECK_EQ(TypeTag(), JSRegExp::IRREGEXP); + FixedArray::cast(data()).set(JSRegExp::kIrregexpTierUpTicksIndex, + Smi::FromInt(1)); +} + namespace { template <typename Char> @@ -7405,7 +7434,7 @@ Handle<FixedArray> BaseNameDictionary<Derived, Shape>::IterationIndices( } template <typename Derived, typename Shape> -void BaseNameDictionary<Derived, Shape>::CollectKeysTo( +ExceptionStatus BaseNameDictionary<Derived, Shape>::CollectKeysTo( Handle<Derived> dictionary, KeyAccumulator* keys) { Isolate* isolate = keys->isolate(); ReadOnlyRoots roots(isolate); @@ -7450,16 +7479,19 @@ void BaseNameDictionary<Derived, Shape>::CollectKeysTo( has_seen_symbol = true; continue; } - keys->AddKey(key, DO_NOT_CONVERT); + ExceptionStatus status = keys->AddKey(key, DO_NOT_CONVERT); + if (!status) return status; } if (has_seen_symbol) { for (int i = 0; i < array_size; i++) { int index = Smi::ToInt(array->get(i)); Object key = dictionary->NameAt(index); if (!key.IsSymbol()) continue; - keys->AddKey(key, DO_NOT_CONVERT); + ExceptionStatus status = keys->AddKey(key, DO_NOT_CONVERT); + if (!status) return status; } } + return ExceptionStatus::kSuccess; } // Backwards lookup (slow). @@ -8067,7 +8099,10 @@ HashTable<NameDictionary, NameDictionaryShape>::Shrink(Isolate* isolate, Handle<NameDictionary>, int additionalCapacity); -void JSFinalizationGroup::Cleanup( +template void HashTable<GlobalDictionary, GlobalDictionaryShape>::Rehash( + ReadOnlyRoots roots); + +Maybe<bool> JSFinalizationGroup::Cleanup( Isolate* isolate, Handle<JSFinalizationGroup> finalization_group, Handle<Object> cleanup) { DCHECK(cleanup->IsCallable()); @@ -8088,23 +8123,17 @@ void JSFinalizationGroup::Cleanup( Handle<AllocationSite>::null())); iterator->set_finalization_group(*finalization_group); } - - v8::TryCatch try_catch(reinterpret_cast<v8::Isolate*>(isolate)); - v8::Local<v8::Value> result; - MaybeHandle<Object> exception; Handle<Object> args[] = {iterator}; - bool has_pending_exception = !ToLocal<Value>( - Execution::TryCall( + if (Execution::Call( isolate, cleanup, - handle(ReadOnlyRoots(isolate).undefined_value(), isolate), 1, args, - Execution::MessageHandling::kReport, &exception), - &result); - // TODO(marja): (spec): What if there's an exception? - USE(has_pending_exception); - + handle(ReadOnlyRoots(isolate).undefined_value(), isolate), 1, args) + .is_null()) { + return Nothing<bool>(); + } // TODO(marja): (spec): Should the iterator be invalidated after the // function returns? } + return Just(true); } MaybeHandle<FixedArray> JSReceiver::GetPrivateEntries( diff --git a/deps/v8/src/objects/objects.h b/deps/v8/src/objects/objects.h index d706b2dfb7..b4e78a1937 100644 --- a/deps/v8/src/objects/objects.h +++ b/deps/v8/src/objects/objects.h @@ -289,6 +289,8 @@ class Object : public TaggedImpl<HeapObjectReferenceType::STRONG, Address> { V8_INLINE bool IsZero() const; V8_INLINE bool IsNoSharedNameSentinel() const; + V8_INLINE bool IsPrivateSymbol() const; + V8_INLINE bool IsPublicSymbol() const; enum class Conversion { kToNumber, kToNumeric }; diff --git a/deps/v8/src/objects/ordered-hash-table.cc b/deps/v8/src/objects/ordered-hash-table.cc index 07536a4ccb..dda848f010 100644 --- a/deps/v8/src/objects/ordered-hash-table.cc +++ b/deps/v8/src/objects/ordered-hash-table.cc @@ -14,7 +14,7 @@ namespace v8 { namespace internal { template <class Derived, int entrysize> -Handle<Derived> OrderedHashTable<Derived, entrysize>::Allocate( +MaybeHandle<Derived> OrderedHashTable<Derived, entrysize>::Allocate( Isolate* isolate, int capacity, AllocationType allocation) { // Capacity must be a power of two, since we depend on being able // to divide and multiple by 2 (kLoadFactor) to derive capacity @@ -23,7 +23,7 @@ Handle<Derived> OrderedHashTable<Derived, entrysize>::Allocate( // field of this object. capacity = base::bits::RoundUpToPowerOfTwo32(Max(kMinCapacity, capacity)); if (capacity > MaxCapacity()) { - isolate->heap()->FatalProcessOutOfMemory("invalid table size"); + return MaybeHandle<Derived>(); } int num_buckets = capacity / kLoadFactor; Handle<FixedArray> backing_store = isolate->factory()->NewFixedArrayWithMap( @@ -41,7 +41,7 @@ Handle<Derived> OrderedHashTable<Derived, entrysize>::Allocate( } template <class Derived, int entrysize> -Handle<Derived> OrderedHashTable<Derived, entrysize>::EnsureGrowable( +MaybeHandle<Derived> OrderedHashTable<Derived, entrysize>::EnsureGrowable( Isolate* isolate, Handle<Derived> table) { DCHECK(!table->IsObsolete()); @@ -64,7 +64,7 @@ Handle<Derived> OrderedHashTable<Derived, entrysize>::Shrink( int nof = table->NumberOfElements(); int capacity = table->Capacity(); if (nof >= (capacity >> 2)) return table; - return Derived::Rehash(isolate, table, capacity / 2); + return Derived::Rehash(isolate, table, capacity / 2).ToHandleChecked(); } template <class Derived, int entrysize> @@ -72,10 +72,12 @@ Handle<Derived> OrderedHashTable<Derived, entrysize>::Clear( Isolate* isolate, Handle<Derived> table) { DCHECK(!table->IsObsolete()); + AllocationType allocation_type = Heap::InYoungGeneration(*table) + ? AllocationType::kYoung + : AllocationType::kOld; + Handle<Derived> new_table = - Allocate(isolate, kMinCapacity, - Heap::InYoungGeneration(*table) ? AllocationType::kYoung - : AllocationType::kOld); + Allocate(isolate, kMinCapacity, allocation_type).ToHandleChecked(); table->SetNextTable(*new_table); table->SetNumberOfDeletedElements(kClearedTableSentinel); @@ -120,9 +122,9 @@ int OrderedHashTable<Derived, entrysize>::FindEntry(Isolate* isolate, return entry; } -Handle<OrderedHashSet> OrderedHashSet::Add(Isolate* isolate, - Handle<OrderedHashSet> table, - Handle<Object> key) { +MaybeHandle<OrderedHashSet> OrderedHashSet::Add(Isolate* isolate, + Handle<OrderedHashSet> table, + Handle<Object> key) { int hash = key->GetOrCreateHash(isolate).value(); int entry = table->HashToEntry(hash); // Walk the chain of the bucket and try finding the key. @@ -133,7 +135,11 @@ Handle<OrderedHashSet> OrderedHashSet::Add(Isolate* isolate, entry = table->NextChainEntry(entry); } - table = OrderedHashSet::EnsureGrowable(isolate, table); + MaybeHandle<OrderedHashSet> table_candidate = + OrderedHashSet::EnsureGrowable(isolate, table); + if (!table_candidate.ToHandle(&table)) { + return table_candidate; + } // Read the existing bucket values. int bucket = table->HashToBucket(hash); int previous_entry = table->HashToEntry(hash); @@ -186,14 +192,18 @@ HeapObject OrderedHashMap::GetEmpty(ReadOnlyRoots ro_roots) { } template <class Derived, int entrysize> -Handle<Derived> OrderedHashTable<Derived, entrysize>::Rehash( +MaybeHandle<Derived> OrderedHashTable<Derived, entrysize>::Rehash( Isolate* isolate, Handle<Derived> table, int new_capacity) { DCHECK(!table->IsObsolete()); - Handle<Derived> new_table = + MaybeHandle<Derived> new_table_candidate = Derived::Allocate(isolate, new_capacity, Heap::InYoungGeneration(*table) ? AllocationType::kYoung : AllocationType::kOld); + Handle<Derived> new_table; + if (!new_table_candidate.ToHandle(&new_table)) { + return new_table_candidate; + } int nof = table->NumberOfElements(); int nod = table->NumberOfDeletedElements(); int new_buckets = new_table->NumberOfBuckets(); @@ -227,30 +237,33 @@ Handle<Derived> OrderedHashTable<Derived, entrysize>::Rehash( new_table->SetNumberOfElements(nof); table->SetNextTable(*new_table); - return new_table; + return new_table_candidate; } -Handle<OrderedHashSet> OrderedHashSet::Rehash(Isolate* isolate, - Handle<OrderedHashSet> table, - int new_capacity) { +MaybeHandle<OrderedHashSet> OrderedHashSet::Rehash(Isolate* isolate, + Handle<OrderedHashSet> table, + int new_capacity) { return OrderedHashTable<OrderedHashSet, 1>::Rehash(isolate, table, new_capacity); } -Handle<OrderedHashMap> OrderedHashMap::Rehash(Isolate* isolate, - Handle<OrderedHashMap> table, - int new_capacity) { +MaybeHandle<OrderedHashMap> OrderedHashMap::Rehash(Isolate* isolate, + Handle<OrderedHashMap> table, + int new_capacity) { return OrderedHashTable<OrderedHashMap, 2>::Rehash(isolate, table, new_capacity); } -Handle<OrderedNameDictionary> OrderedNameDictionary::Rehash( +MaybeHandle<OrderedNameDictionary> OrderedNameDictionary::Rehash( Isolate* isolate, Handle<OrderedNameDictionary> table, int new_capacity) { - Handle<OrderedNameDictionary> new_table = + MaybeHandle<OrderedNameDictionary> new_table_candidate = OrderedHashTable<OrderedNameDictionary, 3>::Rehash(isolate, table, new_capacity); - new_table->SetHash(table->Hash()); - return new_table; + Handle<OrderedNameDictionary> new_table; + if (new_table_candidate.ToHandle(&new_table)) { + new_table->SetHash(table->Hash()); + } + return new_table_candidate; } template <class Derived, int entrysize> @@ -286,10 +299,10 @@ Address OrderedHashMap::GetHash(Isolate* isolate, Address raw_key) { return hash.ptr(); } -Handle<OrderedHashMap> OrderedHashMap::Add(Isolate* isolate, - Handle<OrderedHashMap> table, - Handle<Object> key, - Handle<Object> value) { +MaybeHandle<OrderedHashMap> OrderedHashMap::Add(Isolate* isolate, + Handle<OrderedHashMap> table, + Handle<Object> key, + Handle<Object> value) { int hash = key->GetOrCreateHash(isolate).value(); int entry = table->HashToEntry(hash); // Walk the chain of the bucket and try finding the key. @@ -304,7 +317,11 @@ Handle<OrderedHashMap> OrderedHashMap::Add(Isolate* isolate, } } - table = OrderedHashMap::EnsureGrowable(isolate, table); + MaybeHandle<OrderedHashMap> table_candidate = + OrderedHashMap::EnsureGrowable(isolate, table); + if (!table_candidate.ToHandle(&table)) { + return table_candidate; + } // Read the existing bucket values. int bucket = table->HashToBucket(hash); int previous_entry = table->HashToEntry(hash); @@ -345,12 +362,16 @@ V8_EXPORT_PRIVATE int OrderedHashTable<OrderedNameDictionary, 3>::FindEntry( return kNotFound; } -Handle<OrderedNameDictionary> OrderedNameDictionary::Add( +MaybeHandle<OrderedNameDictionary> OrderedNameDictionary::Add( Isolate* isolate, Handle<OrderedNameDictionary> table, Handle<Name> key, Handle<Object> value, PropertyDetails details) { DCHECK_EQ(kNotFound, table->FindEntry(isolate, *key)); - table = OrderedNameDictionary::EnsureGrowable(isolate, table); + MaybeHandle<OrderedNameDictionary> table_candidate = + OrderedNameDictionary::EnsureGrowable(isolate, table); + if (!table_candidate.ToHandle(&table)) { + return table_candidate; + } // Read the existing bucket values. int hash = key->Hash(); int bucket = table->HashToBucket(hash); @@ -405,28 +426,31 @@ Handle<OrderedNameDictionary> OrderedNameDictionary::DeleteEntry( return Shrink(isolate, table); } -Handle<OrderedHashSet> OrderedHashSet::Allocate(Isolate* isolate, int capacity, - AllocationType allocation) { +MaybeHandle<OrderedHashSet> OrderedHashSet::Allocate( + Isolate* isolate, int capacity, AllocationType allocation) { return OrderedHashTable<OrderedHashSet, 1>::Allocate(isolate, capacity, allocation); } -Handle<OrderedHashMap> OrderedHashMap::Allocate(Isolate* isolate, int capacity, - AllocationType allocation) { +MaybeHandle<OrderedHashMap> OrderedHashMap::Allocate( + Isolate* isolate, int capacity, AllocationType allocation) { return OrderedHashTable<OrderedHashMap, 2>::Allocate(isolate, capacity, allocation); } -Handle<OrderedNameDictionary> OrderedNameDictionary::Allocate( +MaybeHandle<OrderedNameDictionary> OrderedNameDictionary::Allocate( Isolate* isolate, int capacity, AllocationType allocation) { - Handle<OrderedNameDictionary> table = + MaybeHandle<OrderedNameDictionary> table_candidate = OrderedHashTable<OrderedNameDictionary, 3>::Allocate(isolate, capacity, allocation); - table->SetHash(PropertyArray::kNoHashSentinel); - return table; + Handle<OrderedNameDictionary> table; + if (table_candidate.ToHandle(&table)) { + table->SetHash(PropertyArray::kNoHashSentinel); + } + return table_candidate; } -template V8_EXPORT_PRIVATE Handle<OrderedHashSet> +template V8_EXPORT_PRIVATE MaybeHandle<OrderedHashSet> OrderedHashTable<OrderedHashSet, 1>::EnsureGrowable( Isolate* isolate, Handle<OrderedHashSet> table); @@ -447,7 +471,7 @@ template V8_EXPORT_PRIVATE bool OrderedHashTable<OrderedHashSet, 1>::Delete( template V8_EXPORT_PRIVATE int OrderedHashTable<OrderedHashSet, 1>::FindEntry( Isolate* isolate, Object key); -template V8_EXPORT_PRIVATE Handle<OrderedHashMap> +template V8_EXPORT_PRIVATE MaybeHandle<OrderedHashMap> OrderedHashTable<OrderedHashMap, 2>::EnsureGrowable( Isolate* isolate, Handle<OrderedHashMap> table); @@ -472,7 +496,7 @@ template Handle<OrderedNameDictionary> OrderedHashTable<OrderedNameDictionary, 3>::Shrink( Isolate* isolate, Handle<OrderedNameDictionary> table); -template Handle<OrderedNameDictionary> +template MaybeHandle<OrderedNameDictionary> OrderedHashTable<OrderedNameDictionary, 3>::EnsureGrowable( Isolate* isolate, Handle<OrderedNameDictionary> table); @@ -912,8 +936,9 @@ SmallOrderedHashTable<SmallOrderedNameDictionary>::Shrink( Isolate* isolate, Handle<SmallOrderedNameDictionary> table); template <class SmallTable, class LargeTable> -Handle<HeapObject> OrderedHashTableHandler<SmallTable, LargeTable>::Allocate( - Isolate* isolate, int capacity) { +MaybeHandle<HeapObject> +OrderedHashTableHandler<SmallTable, LargeTable>::Allocate(Isolate* isolate, + int capacity) { if (capacity < SmallTable::kMaxCapacity) { return SmallTable::Allocate(isolate, capacity); } @@ -921,18 +946,17 @@ Handle<HeapObject> OrderedHashTableHandler<SmallTable, LargeTable>::Allocate( return LargeTable::Allocate(isolate, capacity); } -template V8_EXPORT_PRIVATE Handle<HeapObject> +template V8_EXPORT_PRIVATE MaybeHandle<HeapObject> OrderedHashTableHandler<SmallOrderedHashSet, OrderedHashSet>::Allocate( Isolate* isolate, int capacity); -template V8_EXPORT_PRIVATE Handle<HeapObject> +template V8_EXPORT_PRIVATE MaybeHandle<HeapObject> OrderedHashTableHandler<SmallOrderedHashMap, OrderedHashMap>::Allocate( Isolate* isolate, int capacity); -template V8_EXPORT_PRIVATE Handle<HeapObject> +template V8_EXPORT_PRIVATE MaybeHandle<HeapObject> OrderedHashTableHandler<SmallOrderedNameDictionary, OrderedNameDictionary>::Allocate(Isolate* isolate, int capacity); -#if !defined(V8_OS_WIN) template <class SmallTable, class LargeTable> bool OrderedHashTableHandler<SmallTable, LargeTable>::Delete( Handle<HeapObject> table, Handle<Object> key) { @@ -945,9 +969,7 @@ bool OrderedHashTableHandler<SmallTable, LargeTable>::Delete( // down to a smaller hash table. return LargeTable::Delete(Handle<LargeTable>::cast(table), key); } -#endif -#if !defined(V8_OS_WIN) template <class SmallTable, class LargeTable> bool OrderedHashTableHandler<SmallTable, LargeTable>::HasKey( Isolate* isolate, Handle<HeapObject> table, Handle<Object> key) { @@ -958,7 +980,6 @@ bool OrderedHashTableHandler<SmallTable, LargeTable>::HasKey( DCHECK(LargeTable::Is(table)); return LargeTable::HasKey(isolate, LargeTable::cast(*table), *key); } -#endif template bool OrderedHashTableHandler<SmallOrderedHashSet, OrderedHashSet>::HasKey( @@ -967,10 +988,14 @@ template bool OrderedHashTableHandler<SmallOrderedHashMap, OrderedHashMap>::HasKey( Isolate* isolate, Handle<HeapObject> table, Handle<Object> key); -Handle<OrderedHashMap> OrderedHashMapHandler::AdjustRepresentation( +MaybeHandle<OrderedHashMap> OrderedHashMapHandler::AdjustRepresentation( Isolate* isolate, Handle<SmallOrderedHashMap> table) { - Handle<OrderedHashMap> new_table = + MaybeHandle<OrderedHashMap> new_table_candidate = OrderedHashMap::Allocate(isolate, OrderedHashTableMinSize); + Handle<OrderedHashMap> new_table; + if (!new_table_candidate.ToHandle(&new_table)) { + return new_table_candidate; + } int nof = table->NumberOfElements(); int nod = table->NumberOfDeletedElements(); @@ -982,16 +1007,23 @@ Handle<OrderedHashMap> OrderedHashMapHandler::AdjustRepresentation( if (key->IsTheHole(isolate)) continue; Handle<Object> value = handle( table->GetDataEntry(entry, SmallOrderedHashMap::kValueIndex), isolate); - new_table = OrderedHashMap::Add(isolate, new_table, key, value); + new_table_candidate = OrderedHashMap::Add(isolate, new_table, key, value); + if (!new_table_candidate.ToHandle(&new_table)) { + return new_table_candidate; + } } - return new_table; + return new_table_candidate; } -Handle<OrderedHashSet> OrderedHashSetHandler::AdjustRepresentation( +MaybeHandle<OrderedHashSet> OrderedHashSetHandler::AdjustRepresentation( Isolate* isolate, Handle<SmallOrderedHashSet> table) { - Handle<OrderedHashSet> new_table = + MaybeHandle<OrderedHashSet> new_table_candidate = OrderedHashSet::Allocate(isolate, OrderedHashTableMinSize); + Handle<OrderedHashSet> new_table; + if (!new_table_candidate.ToHandle(&new_table)) { + return new_table_candidate; + } int nof = table->NumberOfElements(); int nod = table->NumberOfDeletedElements(); @@ -1001,17 +1033,24 @@ Handle<OrderedHashSet> OrderedHashSetHandler::AdjustRepresentation( for (int entry = 0; entry < (nof + nod); ++entry) { Handle<Object> key = handle(table->KeyAt(entry), isolate); if (key->IsTheHole(isolate)) continue; - new_table = OrderedHashSet::Add(isolate, new_table, key); + new_table_candidate = OrderedHashSet::Add(isolate, new_table, key); + if (!new_table_candidate.ToHandle(&new_table)) { + return new_table_candidate; + } } - return new_table; + return new_table_candidate; } -Handle<OrderedNameDictionary> +MaybeHandle<OrderedNameDictionary> OrderedNameDictionaryHandler::AdjustRepresentation( Isolate* isolate, Handle<SmallOrderedNameDictionary> table) { - Handle<OrderedNameDictionary> new_table = + MaybeHandle<OrderedNameDictionary> new_table_candidate = OrderedNameDictionary::Allocate(isolate, OrderedHashTableMinSize); + Handle<OrderedNameDictionary> new_table; + if (!new_table_candidate.ToHandle(&new_table)) { + return new_table_candidate; + } int nof = table->NumberOfElements(); int nod = table->NumberOfDeletedElements(); @@ -1023,17 +1062,20 @@ OrderedNameDictionaryHandler::AdjustRepresentation( if (key->IsTheHole(isolate)) continue; Handle<Object> value(table->ValueAt(entry), isolate); PropertyDetails details = table->DetailsAt(entry); - new_table = + new_table_candidate = OrderedNameDictionary::Add(isolate, new_table, key, value, details); + if (!new_table_candidate.ToHandle(&new_table)) { + return new_table_candidate; + } } - return new_table; + return new_table_candidate; } -Handle<HeapObject> OrderedHashMapHandler::Add(Isolate* isolate, - Handle<HeapObject> table, - Handle<Object> key, - Handle<Object> value) { +MaybeHandle<HeapObject> OrderedHashMapHandler::Add(Isolate* isolate, + Handle<HeapObject> table, + Handle<Object> key, + Handle<Object> value) { if (table->IsSmallOrderedHashMap()) { Handle<SmallOrderedHashMap> small_map = Handle<SmallOrderedHashMap>::cast(table); @@ -1043,7 +1085,11 @@ Handle<HeapObject> OrderedHashMapHandler::Add(Isolate* isolate, // We couldn't add to the small table, let's migrate to the // big table. - table = OrderedHashMapHandler::AdjustRepresentation(isolate, small_map); + MaybeHandle<OrderedHashMap> table_candidate = + OrderedHashMapHandler::AdjustRepresentation(isolate, small_map); + if (!table_candidate.ToHandle(&table)) { + return table_candidate; + } } DCHECK(table->IsOrderedHashMap()); @@ -1051,9 +1097,9 @@ Handle<HeapObject> OrderedHashMapHandler::Add(Isolate* isolate, value); } -Handle<HeapObject> OrderedHashSetHandler::Add(Isolate* isolate, - Handle<HeapObject> table, - Handle<Object> key) { +MaybeHandle<HeapObject> OrderedHashSetHandler::Add(Isolate* isolate, + Handle<HeapObject> table, + Handle<Object> key) { if (table->IsSmallOrderedHashSet()) { Handle<SmallOrderedHashSet> small_set = Handle<SmallOrderedHashSet>::cast(table); @@ -1063,18 +1109,20 @@ Handle<HeapObject> OrderedHashSetHandler::Add(Isolate* isolate, // We couldn't add to the small table, let's migrate to the // big table. - table = OrderedHashSetHandler::AdjustRepresentation(isolate, small_set); + MaybeHandle<OrderedHashSet> table_candidate = + OrderedHashSetHandler::AdjustRepresentation(isolate, small_set); + if (!table_candidate.ToHandle(&table)) { + return table_candidate; + } } DCHECK(table->IsOrderedHashSet()); return OrderedHashSet::Add(isolate, Handle<OrderedHashSet>::cast(table), key); } -Handle<HeapObject> OrderedNameDictionaryHandler::Add(Isolate* isolate, - Handle<HeapObject> table, - Handle<Name> key, - Handle<Object> value, - PropertyDetails details) { +MaybeHandle<HeapObject> OrderedNameDictionaryHandler::Add( + Isolate* isolate, Handle<HeapObject> table, Handle<Name> key, + Handle<Object> value, PropertyDetails details) { if (table->IsSmallOrderedNameDictionary()) { Handle<SmallOrderedNameDictionary> small_dict = Handle<SmallOrderedNameDictionary>::cast(table); @@ -1085,8 +1133,11 @@ Handle<HeapObject> OrderedNameDictionaryHandler::Add(Isolate* isolate, // We couldn't add to the small table, let's migrate to the // big table. - table = + MaybeHandle<OrderedNameDictionary> table_candidate = OrderedNameDictionaryHandler::AdjustRepresentation(isolate, small_dict); + if (!table_candidate.ToHandle(&table)) { + return table_candidate; + } } DCHECK(table->IsOrderedNameDictionary()); diff --git a/deps/v8/src/objects/ordered-hash-table.h b/deps/v8/src/objects/ordered-hash-table.h index 66dc36e81f..21decaeba7 100644 --- a/deps/v8/src/objects/ordered-hash-table.h +++ b/deps/v8/src/objects/ordered-hash-table.h @@ -64,8 +64,8 @@ class OrderedHashTable : public FixedArray { public: // Returns an OrderedHashTable (possibly |table|) with enough space // to add at least one new element. - static Handle<Derived> EnsureGrowable(Isolate* isolate, - Handle<Derived> table); + static MaybeHandle<Derived> EnsureGrowable(Isolate* isolate, + Handle<Derived> table); // Returns an OrderedHashTable (possibly |table|) that's shrunken // if possible. @@ -197,11 +197,11 @@ class OrderedHashTable : public FixedArray { protected: // Returns an OrderedHashTable with a capacity of at least |capacity|. - static Handle<Derived> Allocate( + static MaybeHandle<Derived> Allocate( Isolate* isolate, int capacity, AllocationType allocation = AllocationType::kYoung); - static Handle<Derived> Rehash(Isolate* isolate, Handle<Derived> table, - int new_capacity); + static MaybeHandle<Derived> Rehash(Isolate* isolate, Handle<Derived> table, + int new_capacity); void SetNumberOfBuckets(int num) { set(NumberOfBucketsIndex(), Smi::FromInt(num)); @@ -235,16 +235,16 @@ class V8_EXPORT_PRIVATE OrderedHashSet public: DECL_CAST(OrderedHashSet) - static Handle<OrderedHashSet> Add(Isolate* isolate, - Handle<OrderedHashSet> table, - Handle<Object> value); + static MaybeHandle<OrderedHashSet> Add(Isolate* isolate, + Handle<OrderedHashSet> table, + Handle<Object> value); static Handle<FixedArray> ConvertToKeysArray(Isolate* isolate, Handle<OrderedHashSet> table, GetKeysConversion convert); - static Handle<OrderedHashSet> Rehash(Isolate* isolate, - Handle<OrderedHashSet> table, - int new_capacity); - static Handle<OrderedHashSet> Allocate( + static MaybeHandle<OrderedHashSet> Rehash(Isolate* isolate, + Handle<OrderedHashSet> table, + int new_capacity); + static MaybeHandle<OrderedHashSet> Allocate( Isolate* isolate, int capacity, AllocationType allocation = AllocationType::kYoung); static HeapObject GetEmpty(ReadOnlyRoots ro_roots); @@ -262,16 +262,17 @@ class V8_EXPORT_PRIVATE OrderedHashMap // Returns a value if the OrderedHashMap contains the key, otherwise // returns undefined. - static Handle<OrderedHashMap> Add(Isolate* isolate, - Handle<OrderedHashMap> table, - Handle<Object> key, Handle<Object> value); + static MaybeHandle<OrderedHashMap> Add(Isolate* isolate, + Handle<OrderedHashMap> table, + Handle<Object> key, + Handle<Object> value); - static Handle<OrderedHashMap> Allocate( + static MaybeHandle<OrderedHashMap> Allocate( Isolate* isolate, int capacity, AllocationType allocation = AllocationType::kYoung); - static Handle<OrderedHashMap> Rehash(Isolate* isolate, - Handle<OrderedHashMap> table, - int new_capacity); + static MaybeHandle<OrderedHashMap> Rehash(Isolate* isolate, + Handle<OrderedHashMap> table, + int new_capacity); Object ValueAt(int entry); // This takes and returns raw Address values containing tagged Object @@ -656,7 +657,7 @@ class EXPORT_TEMPLATE_DECLARE(V8_EXPORT_PRIVATE) OrderedHashTableHandler { public: using Entry = int; - static Handle<HeapObject> Allocate(Isolate* isolate, int capacity); + static MaybeHandle<HeapObject> Allocate(Isolate* isolate, int capacity); static bool Delete(Handle<HeapObject> table, Handle<Object> key); static bool HasKey(Isolate* isolate, Handle<HeapObject> table, Handle<Object> key); @@ -672,9 +673,9 @@ extern template class EXPORT_TEMPLATE_DECLARE(V8_EXPORT_PRIVATE) class V8_EXPORT_PRIVATE OrderedHashMapHandler : public OrderedHashTableHandler<SmallOrderedHashMap, OrderedHashMap> { public: - static Handle<HeapObject> Add(Isolate* isolate, Handle<HeapObject> table, - Handle<Object> key, Handle<Object> value); - static Handle<OrderedHashMap> AdjustRepresentation( + static MaybeHandle<HeapObject> Add(Isolate* isolate, Handle<HeapObject> table, + Handle<Object> key, Handle<Object> value); + static MaybeHandle<OrderedHashMap> AdjustRepresentation( Isolate* isolate, Handle<SmallOrderedHashMap> table); }; @@ -684,9 +685,9 @@ extern template class EXPORT_TEMPLATE_DECLARE(V8_EXPORT_PRIVATE) class V8_EXPORT_PRIVATE OrderedHashSetHandler : public OrderedHashTableHandler<SmallOrderedHashSet, OrderedHashSet> { public: - static Handle<HeapObject> Add(Isolate* isolate, Handle<HeapObject> table, - Handle<Object> key); - static Handle<OrderedHashSet> AdjustRepresentation( + static MaybeHandle<HeapObject> Add(Isolate* isolate, Handle<HeapObject> table, + Handle<Object> key); + static MaybeHandle<OrderedHashSet> AdjustRepresentation( Isolate* isolate, Handle<SmallOrderedHashSet> table); }; @@ -695,7 +696,7 @@ class OrderedNameDictionary public: DECL_CAST(OrderedNameDictionary) - V8_EXPORT_PRIVATE static Handle<OrderedNameDictionary> Add( + V8_EXPORT_PRIVATE static MaybeHandle<OrderedNameDictionary> Add( Isolate* isolate, Handle<OrderedNameDictionary> table, Handle<Name> key, Handle<Object> value, PropertyDetails details); @@ -705,11 +706,11 @@ class OrderedNameDictionary V8_EXPORT_PRIVATE static Handle<OrderedNameDictionary> DeleteEntry( Isolate* isolate, Handle<OrderedNameDictionary> table, int entry); - static Handle<OrderedNameDictionary> Allocate( + static MaybeHandle<OrderedNameDictionary> Allocate( Isolate* isolate, int capacity, AllocationType allocation = AllocationType::kYoung); - static Handle<OrderedNameDictionary> Rehash( + static MaybeHandle<OrderedNameDictionary> Rehash( Isolate* isolate, Handle<OrderedNameDictionary> table, int new_capacity); // Returns the value for entry. @@ -745,9 +746,9 @@ class V8_EXPORT_PRIVATE OrderedNameDictionaryHandler : public OrderedHashTableHandler<SmallOrderedNameDictionary, OrderedNameDictionary> { public: - static Handle<HeapObject> Add(Isolate* isolate, Handle<HeapObject> table, - Handle<Name> key, Handle<Object> value, - PropertyDetails details); + static MaybeHandle<HeapObject> Add(Isolate* isolate, Handle<HeapObject> table, + Handle<Name> key, Handle<Object> value, + PropertyDetails details); static Handle<HeapObject> Shrink(Isolate* isolate, Handle<HeapObject> table); static Handle<HeapObject> DeleteEntry(Isolate* isolate, @@ -779,7 +780,7 @@ class V8_EXPORT_PRIVATE OrderedNameDictionaryHandler static const int kNotFound = -1; protected: - static Handle<OrderedNameDictionary> AdjustRepresentation( + static MaybeHandle<OrderedNameDictionary> AdjustRepresentation( Isolate* isolate, Handle<SmallOrderedNameDictionary> table); }; diff --git a/deps/v8/src/objects/promise-inl.h b/deps/v8/src/objects/promise-inl.h index 6807ac88f4..da11731e25 100644 --- a/deps/v8/src/objects/promise-inl.h +++ b/deps/v8/src/objects/promise-inl.h @@ -16,41 +16,12 @@ namespace v8 { namespace internal { -OBJECT_CONSTRUCTORS_IMPL(PromiseReactionJobTask, Microtask) -OBJECT_CONSTRUCTORS_IMPL(PromiseFulfillReactionJobTask, PromiseReactionJobTask) -OBJECT_CONSTRUCTORS_IMPL(PromiseRejectReactionJobTask, PromiseReactionJobTask) -OBJECT_CONSTRUCTORS_IMPL(PromiseResolveThenableJobTask, Microtask) -OBJECT_CONSTRUCTORS_IMPL(PromiseCapability, Struct) -OBJECT_CONSTRUCTORS_IMPL(PromiseReaction, Struct) - -CAST_ACCESSOR(PromiseCapability) -CAST_ACCESSOR(PromiseReaction) -CAST_ACCESSOR(PromiseReactionJobTask) -CAST_ACCESSOR(PromiseFulfillReactionJobTask) -CAST_ACCESSOR(PromiseRejectReactionJobTask) -CAST_ACCESSOR(PromiseResolveThenableJobTask) - -ACCESSORS(PromiseReaction, next, Object, kNextOffset) -ACCESSORS(PromiseReaction, reject_handler, HeapObject, kRejectHandlerOffset) -ACCESSORS(PromiseReaction, fulfill_handler, HeapObject, kFulfillHandlerOffset) -ACCESSORS(PromiseReaction, promise_or_capability, HeapObject, - kPromiseOrCapabilityOffset) - -ACCESSORS(PromiseResolveThenableJobTask, context, Context, kContextOffset) -ACCESSORS(PromiseResolveThenableJobTask, promise_to_resolve, JSPromise, - kPromiseToResolveOffset) -ACCESSORS(PromiseResolveThenableJobTask, then, JSReceiver, kThenOffset) -ACCESSORS(PromiseResolveThenableJobTask, thenable, JSReceiver, kThenableOffset) - -ACCESSORS(PromiseReactionJobTask, context, Context, kContextOffset) -ACCESSORS(PromiseReactionJobTask, argument, Object, kArgumentOffset) -ACCESSORS(PromiseReactionJobTask, handler, HeapObject, kHandlerOffset) -ACCESSORS(PromiseReactionJobTask, promise_or_capability, HeapObject, - kPromiseOrCapabilityOffset) - -ACCESSORS(PromiseCapability, promise, HeapObject, kPromiseOffset) -ACCESSORS(PromiseCapability, resolve, Object, kResolveOffset) -ACCESSORS(PromiseCapability, reject, Object, kRejectOffset) +TQ_OBJECT_CONSTRUCTORS_IMPL(PromiseReactionJobTask) +TQ_OBJECT_CONSTRUCTORS_IMPL(PromiseFulfillReactionJobTask) +TQ_OBJECT_CONSTRUCTORS_IMPL(PromiseRejectReactionJobTask) +TQ_OBJECT_CONSTRUCTORS_IMPL(PromiseResolveThenableJobTask) +TQ_OBJECT_CONSTRUCTORS_IMPL(PromiseCapability) +TQ_OBJECT_CONSTRUCTORS_IMPL(PromiseReaction) } // namespace internal } // namespace v8 diff --git a/deps/v8/src/objects/promise.h b/deps/v8/src/objects/promise.h index f7c60413d1..2582543f77 100644 --- a/deps/v8/src/objects/promise.h +++ b/deps/v8/src/objects/promise.h @@ -24,93 +24,59 @@ class JSPromise; // // classes, which are used to represent either reactions, and we distinguish // them by their instance types. -class PromiseReactionJobTask : public Microtask { +class PromiseReactionJobTask + : public TorqueGeneratedPromiseReactionJobTask<PromiseReactionJobTask, + Microtask> { public: - DECL_ACCESSORS(argument, Object) - DECL_ACCESSORS(context, Context) - DECL_ACCESSORS(handler, HeapObject) - // [promise_or_capability]: Either a JSPromise (in case of native promises), - // a PromiseCapability (general case), or undefined (in case of await). - DECL_ACCESSORS(promise_or_capability, HeapObject) - - DEFINE_FIELD_OFFSET_CONSTANTS( - Microtask::kHeaderSize, TORQUE_GENERATED_PROMISE_REACTION_JOB_TASK_FIELDS) - - // Dispatched behavior. - DECL_CAST(PromiseReactionJobTask) - DECL_VERIFIER(PromiseReactionJobTask) static const int kSizeOfAllPromiseReactionJobTasks = kHeaderSize; - OBJECT_CONSTRUCTORS(PromiseReactionJobTask, Microtask); + TQ_OBJECT_CONSTRUCTORS(PromiseReactionJobTask) }; // Struct to hold state required for a PromiseReactionJob of type "Fulfill". -class PromiseFulfillReactionJobTask : public PromiseReactionJobTask { +class PromiseFulfillReactionJobTask + : public TorqueGeneratedPromiseFulfillReactionJobTask< + PromiseFulfillReactionJobTask, PromiseReactionJobTask> { public: // Dispatched behavior. - DECL_CAST(PromiseFulfillReactionJobTask) DECL_PRINTER(PromiseFulfillReactionJobTask) - DECL_VERIFIER(PromiseFulfillReactionJobTask) - DEFINE_FIELD_OFFSET_CONSTANTS( - PromiseReactionJobTask::kHeaderSize, - TORQUE_GENERATED_PROMISE_FULFILL_REACTION_JOB_TASK_FIELDS) STATIC_ASSERT(kSize == kSizeOfAllPromiseReactionJobTasks); - OBJECT_CONSTRUCTORS(PromiseFulfillReactionJobTask, PromiseReactionJobTask); + TQ_OBJECT_CONSTRUCTORS(PromiseFulfillReactionJobTask) }; // Struct to hold state required for a PromiseReactionJob of type "Reject". -class PromiseRejectReactionJobTask : public PromiseReactionJobTask { +class PromiseRejectReactionJobTask + : public TorqueGeneratedPromiseRejectReactionJobTask< + PromiseRejectReactionJobTask, PromiseReactionJobTask> { public: // Dispatched behavior. - DECL_CAST(PromiseRejectReactionJobTask) DECL_PRINTER(PromiseRejectReactionJobTask) - DECL_VERIFIER(PromiseRejectReactionJobTask) - DEFINE_FIELD_OFFSET_CONSTANTS( - PromiseReactionJobTask::kHeaderSize, - TORQUE_GENERATED_PROMISE_REJECT_REACTION_JOB_TASK_FIELDS) STATIC_ASSERT(kSize == kSizeOfAllPromiseReactionJobTasks); - OBJECT_CONSTRUCTORS(PromiseRejectReactionJobTask, PromiseReactionJobTask); + TQ_OBJECT_CONSTRUCTORS(PromiseRejectReactionJobTask) }; // A container struct to hold state required for PromiseResolveThenableJob. -class PromiseResolveThenableJobTask : public Microtask { +class PromiseResolveThenableJobTask + : public TorqueGeneratedPromiseResolveThenableJobTask< + PromiseResolveThenableJobTask, Microtask> { public: - DECL_ACCESSORS(context, Context) - DECL_ACCESSORS(promise_to_resolve, JSPromise) - DECL_ACCESSORS(then, JSReceiver) - DECL_ACCESSORS(thenable, JSReceiver) - - DEFINE_FIELD_OFFSET_CONSTANTS( - Microtask::kHeaderSize, - TORQUE_GENERATED_PROMISE_RESOLVE_THENABLE_JOB_TASK_FIELDS) - // Dispatched behavior. - DECL_CAST(PromiseResolveThenableJobTask) DECL_PRINTER(PromiseResolveThenableJobTask) - DECL_VERIFIER(PromiseResolveThenableJobTask) - OBJECT_CONSTRUCTORS(PromiseResolveThenableJobTask, Microtask); + TQ_OBJECT_CONSTRUCTORS(PromiseResolveThenableJobTask) }; // Struct to hold the state of a PromiseCapability. -class PromiseCapability : public Struct { +class PromiseCapability + : public TorqueGeneratedPromiseCapability<PromiseCapability, Struct> { public: - DECL_ACCESSORS(promise, HeapObject) - DECL_ACCESSORS(resolve, Object) - DECL_ACCESSORS(reject, Object) - - DEFINE_FIELD_OFFSET_CONSTANTS(Struct::kHeaderSize, - TORQUE_GENERATED_PROMISE_CAPABILITY_FIELDS) - // Dispatched behavior. - DECL_CAST(PromiseCapability) DECL_PRINTER(PromiseCapability) - DECL_VERIFIER(PromiseCapability) - OBJECT_CONSTRUCTORS(PromiseCapability, Struct); + TQ_OBJECT_CONSTRUCTORS(PromiseCapability) }; // A representation of promise reaction. This differs from the specification @@ -130,26 +96,15 @@ class PromiseCapability : public Struct { // Smi 0. On the JSPromise instance they are linked in reverse order, // and are turned into the proper order again when scheduling them on // the microtask queue. -class PromiseReaction : public Struct { +class PromiseReaction + : public TorqueGeneratedPromiseReaction<PromiseReaction, Struct> { public: enum Type { kFulfill, kReject }; - DECL_ACCESSORS(next, Object) - DECL_ACCESSORS(reject_handler, HeapObject) - DECL_ACCESSORS(fulfill_handler, HeapObject) - // [promise_or_capability]: Either a JSPromise (in case of native promises), - // a PromiseCapability (general case), or undefined (in case of await). - DECL_ACCESSORS(promise_or_capability, HeapObject) - - DEFINE_FIELD_OFFSET_CONSTANTS(Struct::kHeaderSize, - TORQUE_GENERATED_PROMISE_REACTION_FIELDS) - // Dispatched behavior. - DECL_CAST(PromiseReaction) DECL_PRINTER(PromiseReaction) - DECL_VERIFIER(PromiseReaction) - OBJECT_CONSTRUCTORS(PromiseReaction, Struct); + TQ_OBJECT_CONSTRUCTORS(PromiseReaction) }; } // namespace internal diff --git a/deps/v8/src/objects/property-array.h b/deps/v8/src/objects/property-array.h index 5c71330280..62a472aa90 100644 --- a/deps/v8/src/objects/property-array.h +++ b/deps/v8/src/objects/property-array.h @@ -61,10 +61,10 @@ class PropertyArray : public HeapObject { using BodyDescriptor = FlexibleBodyDescriptor<kHeaderSize>; static const int kLengthFieldSize = 10; - class LengthField : public BitField<int, 0, kLengthFieldSize> {}; + using LengthField = BitField<int, 0, kLengthFieldSize>; static const int kMaxLength = LengthField::kMax; - class HashField : public BitField<int, kLengthFieldSize, - kSmiValueSize - kLengthFieldSize - 1> {}; + using HashField = + BitField<int, kLengthFieldSize, kSmiValueSize - kLengthFieldSize - 1>; static const int kNoHashSentinel = 0; diff --git a/deps/v8/src/objects/property-details.h b/deps/v8/src/objects/property-details.h index 7836575edf..e350fe2c27 100644 --- a/deps/v8/src/objects/property-details.h +++ b/deps/v8/src/objects/property-details.h @@ -310,13 +310,10 @@ class PropertyDetails { // Bit fields in value_ (type, shift, size). Must be public so the // constants can be embedded in generated code. - class KindField : public BitField<PropertyKind, 0, 1> {}; - class LocationField : public BitField<PropertyLocation, KindField::kNext, 1> { - }; - class ConstnessField - : public BitField<PropertyConstness, LocationField::kNext, 1> {}; - class AttributesField - : public BitField<PropertyAttributes, ConstnessField::kNext, 3> {}; + using KindField = BitField<PropertyKind, 0, 1>; + using LocationField = KindField::Next<PropertyLocation, 1>; + using ConstnessField = LocationField::Next<PropertyConstness, 1>; + using AttributesField = ConstnessField::Next<PropertyAttributes, 3>; static const int kAttributesReadOnlyMask = (READ_ONLY << AttributesField::kShift); static const int kAttributesDontDeleteMask = @@ -325,24 +322,19 @@ class PropertyDetails { (DONT_ENUM << AttributesField::kShift); // Bit fields for normalized objects. - class PropertyCellTypeField - : public BitField<PropertyCellType, AttributesField::kNext, 2> {}; - class DictionaryStorageField - : public BitField<uint32_t, PropertyCellTypeField::kNext, 23> {}; + using PropertyCellTypeField = AttributesField::Next<PropertyCellType, 2>; + using DictionaryStorageField = PropertyCellTypeField::Next<uint32_t, 23>; // Bit fields for fast objects. - class RepresentationField - : public BitField<uint32_t, AttributesField::kNext, 3> {}; - class DescriptorPointer - : public BitField<uint32_t, RepresentationField::kNext, - kDescriptorIndexBitCount> {}; // NOLINT - class FieldIndexField : public BitField<uint32_t, DescriptorPointer::kNext, - kDescriptorIndexBitCount> { - }; // NOLINT + using RepresentationField = AttributesField::Next<uint32_t, 3>; + using DescriptorPointer = + RepresentationField::Next<uint32_t, kDescriptorIndexBitCount>; + using FieldIndexField = + DescriptorPointer::Next<uint32_t, kDescriptorIndexBitCount>; // All bits for both fast and slow objects must fit in a smi. - STATIC_ASSERT(DictionaryStorageField::kNext <= 31); - STATIC_ASSERT(FieldIndexField::kNext <= 31); + STATIC_ASSERT(DictionaryStorageField::kLastUsedBit < 31); + STATIC_ASSERT(FieldIndexField::kLastUsedBit < 31); static const int kInitialIndex = 1; diff --git a/deps/v8/src/objects/scope-info.cc b/deps/v8/src/objects/scope-info.cc index eca8bc1ecd..c390298b5d 100644 --- a/deps/v8/src/objects/scope-info.cc +++ b/deps/v8/src/objects/scope-info.cc @@ -166,7 +166,7 @@ Handle<ScopeInfo> ScopeInfo::Create(Isolate* isolate, Zone* zone, Scope* scope, bool has_simple_parameters = false; bool is_asm_module = false; - bool calls_sloppy_eval = false; + bool sloppy_eval_can_extend_vars = false; if (scope->is_function_scope()) { DeclarationScope* function_scope = scope->AsDeclarationScope(); has_simple_parameters = function_scope->has_simple_parameters(); @@ -175,13 +175,14 @@ Handle<ScopeInfo> ScopeInfo::Create(Isolate* isolate, Zone* zone, Scope* scope, FunctionKind function_kind = kNormalFunction; if (scope->is_declaration_scope()) { function_kind = scope->AsDeclarationScope()->function_kind(); - calls_sloppy_eval = scope->AsDeclarationScope()->calls_sloppy_eval(); + sloppy_eval_can_extend_vars = + scope->AsDeclarationScope()->sloppy_eval_can_extend_vars(); } // Encode the flags. int flags = ScopeTypeField::encode(scope->scope_type()) | - CallsSloppyEvalField::encode(calls_sloppy_eval) | + SloppyEvalCanExtendVarsField::encode(sloppy_eval_can_extend_vars) | LanguageModeField::encode(scope->language_mode()) | DeclarationScopeField::encode(scope->is_declaration_scope()) | ReceiverVariableField::encode(receiver_info) | @@ -218,8 +219,6 @@ Handle<ScopeInfo> ScopeInfo::Create(Isolate* isolate, Zone* zone, Scope* scope, uint32_t info = VariableModeField::encode(var->mode()) | InitFlagField::encode(var->initialization_flag()) | - RequiresBrandCheckField::encode( - var->get_requires_brand_check_flag()) | MaybeAssignedFlagField::encode(var->maybe_assigned()) | ParameterNumberField::encode(ParameterNumberField::kMax); scope_info.set(context_local_base + local_index, *var->name(), mode); @@ -236,8 +235,6 @@ Handle<ScopeInfo> ScopeInfo::Create(Isolate* isolate, Zone* zone, Scope* scope, VariableModeField::encode(var->mode()) | InitFlagField::encode(var->initialization_flag()) | MaybeAssignedFlagField::encode(var->maybe_assigned()) | - RequiresBrandCheckField::encode( - var->get_requires_brand_check_flag()) | ParameterNumberField::encode(ParameterNumberField::kMax); scope_info.set(module_var_entry + kModuleVariablePropertiesOffset, Smi::FromInt(properties)); @@ -276,8 +273,6 @@ Handle<ScopeInfo> ScopeInfo::Create(Isolate* isolate, Zone* zone, Scope* scope, VariableModeField::encode(var->mode()) | InitFlagField::encode(var->initialization_flag()) | MaybeAssignedFlagField::encode(var->maybe_assigned()) | - RequiresBrandCheckField::encode( - var->get_requires_brand_check_flag()) | ParameterNumberField::encode(ParameterNumberField::kMax); scope_info.set(context_local_base + local_index, *var->name(), mode); scope_info.set(context_local_info_base + local_index, @@ -362,7 +357,8 @@ Handle<ScopeInfo> ScopeInfo::CreateForWithScope( // Encode the flags. int flags = - ScopeTypeField::encode(WITH_SCOPE) | CallsSloppyEvalField::encode(false) | + ScopeTypeField::encode(WITH_SCOPE) | + SloppyEvalCanExtendVarsField::encode(false) | LanguageModeField::encode(LanguageMode::kSloppy) | DeclarationScopeField::encode(false) | ReceiverVariableField::encode(NONE) | HasClassBrandField::encode(false) | @@ -419,11 +415,13 @@ Handle<ScopeInfo> ScopeInfo::CreateForBootstrapping(Isolate* isolate, (has_position_info ? kPositionInfoEntries : 0); Factory* factory = isolate->factory(); - Handle<ScopeInfo> scope_info = factory->NewScopeInfo(length); + Handle<ScopeInfo> scope_info = + factory->NewScopeInfo(length, AllocationType::kReadOnly); // Encode the flags. int flags = - ScopeTypeField::encode(type) | CallsSloppyEvalField::encode(false) | + ScopeTypeField::encode(type) | + SloppyEvalCanExtendVarsField::encode(false) | LanguageModeField::encode(LanguageMode::kSloppy) | DeclarationScopeField::encode(true) | ReceiverVariableField::encode(is_empty_function ? UNUSED : CONTEXT) | @@ -451,7 +449,6 @@ Handle<ScopeInfo> ScopeInfo::CreateForBootstrapping(Isolate* isolate, VariableModeField::encode(VariableMode::kConst) | InitFlagField::encode(kCreatedInitialized) | MaybeAssignedFlagField::encode(kNotAssigned) | - RequiresBrandCheckField::encode(kNoBrandCheck) | ParameterNumberField::encode(ParameterNumberField::kMax); scope_info->set(index++, Smi::FromInt(value)); } @@ -497,12 +494,12 @@ ScopeType ScopeInfo::scope_type() const { return ScopeTypeField::decode(Flags()); } -bool ScopeInfo::CallsSloppyEval() const { - bool calls_sloppy_eval = - length() > 0 && CallsSloppyEvalField::decode(Flags()); - DCHECK_IMPLIES(calls_sloppy_eval, is_sloppy(language_mode())); - DCHECK_IMPLIES(calls_sloppy_eval, is_declaration_scope()); - return calls_sloppy_eval; +bool ScopeInfo::SloppyEvalCanExtendVars() const { + bool sloppy_eval_can_extend_vars = + length() > 0 && SloppyEvalCanExtendVarsField::decode(Flags()); + DCHECK_IMPLIES(sloppy_eval_can_extend_vars, is_sloppy(language_mode())); + DCHECK_IMPLIES(sloppy_eval_can_extend_vars, is_declaration_scope()); + return sloppy_eval_can_extend_vars; } LanguageMode ScopeInfo::language_mode() const { @@ -523,9 +520,9 @@ int ScopeInfo::ContextLength() const { bool has_context = context_locals > 0 || force_context || function_name_context_slot || scope_type() == WITH_SCOPE || scope_type() == CLASS_SCOPE || - (scope_type() == BLOCK_SCOPE && CallsSloppyEval() && + (scope_type() == BLOCK_SCOPE && SloppyEvalCanExtendVars() && is_declaration_scope()) || - (scope_type() == FUNCTION_SCOPE && CallsSloppyEval()) || + (scope_type() == FUNCTION_SCOPE && SloppyEvalCanExtendVars()) || (scope_type() == FUNCTION_SCOPE && IsAsmModule()) || scope_type() == MODULE_SCOPE; @@ -708,21 +705,13 @@ MaybeAssignedFlag ScopeInfo::ContextLocalMaybeAssignedFlag(int var) const { return MaybeAssignedFlagField::decode(value); } -RequiresBrandCheckFlag ScopeInfo::RequiresBrandCheck(int var) const { - DCHECK_LE(0, var); - DCHECK_LT(var, ContextLocalCount()); - int info_index = ContextLocalInfosIndex() + var; - int value = Smi::ToInt(get(info_index)); - return RequiresBrandCheckField::decode(value); -} - // static bool ScopeInfo::VariableIsSynthetic(String name) { // There's currently no flag stored on the ScopeInfo to indicate that a // variable is a compiler-introduced temporary. However, to avoid conflict // with user declarations, the current temporaries like .generator_object and // .result start with a dot, so we can use that as a flag. It's a hack! - return name.length() == 0 || name.Get(0) == '.' || + return name.length() == 0 || name.Get(0) == '.' || name.Get(0) == '#' || name.Equals(name.GetReadOnlyRoots().this_string()); } @@ -755,8 +744,7 @@ int ScopeInfo::ModuleIndex(String name, VariableMode* mode, int ScopeInfo::ContextSlotIndex(ScopeInfo scope_info, String name, VariableMode* mode, InitializationFlag* init_flag, - MaybeAssignedFlag* maybe_assigned_flag, - RequiresBrandCheckFlag* requires_brand_check) { + MaybeAssignedFlag* maybe_assigned_flag) { DisallowHeapAllocation no_gc; DCHECK(name.IsInternalizedString()); DCHECK_NOT_NULL(mode); @@ -773,7 +761,6 @@ int ScopeInfo::ContextSlotIndex(ScopeInfo scope_info, String name, *mode = scope_info.ContextLocalMode(var); *init_flag = scope_info.ContextLocalInitFlag(var); *maybe_assigned_flag = scope_info.ContextLocalMaybeAssignedFlag(var); - *requires_brand_check = scope_info.RequiresBrandCheck(var); int result = Context::MIN_CONTEXT_SLOTS + var; DCHECK_LT(result, scope_info.ContextLength()); @@ -892,9 +879,9 @@ std::ostream& operator<<(std::ostream& os, } Handle<SourceTextModuleInfoEntry> SourceTextModuleInfoEntry::New( - Isolate* isolate, Handle<Object> export_name, Handle<Object> local_name, - Handle<Object> import_name, int module_request, int cell_index, int beg_pos, - int end_pos) { + Isolate* isolate, Handle<HeapObject> export_name, + Handle<HeapObject> local_name, Handle<HeapObject> import_name, + int module_request, int cell_index, int beg_pos, int end_pos) { Handle<SourceTextModuleInfoEntry> result = Handle<SourceTextModuleInfoEntry>::cast(isolate->factory()->NewStruct( SOURCE_TEXT_MODULE_INFO_ENTRY_TYPE, AllocationType::kOld)); diff --git a/deps/v8/src/objects/scope-info.h b/deps/v8/src/objects/scope-info.h index 0b8eb61b00..123b9b1797 100644 --- a/deps/v8/src/objects/scope-info.h +++ b/deps/v8/src/objects/scope-info.h @@ -51,7 +51,7 @@ class ScopeInfo : public FixedArray { bool is_class_scope() const; // Does this scope make a sloppy eval call? - bool CallsSloppyEval() const; + bool SloppyEvalCanExtendVars() const; // Return the number of context slots for code if a context is allocated. This // number consists of three parts: @@ -130,9 +130,6 @@ class ScopeInfo : public FixedArray { // Return the initialization flag of the given context local. MaybeAssignedFlag ContextLocalMaybeAssignedFlag(int var) const; - // Return whether access to the variable requries a brand check. - RequiresBrandCheckFlag RequiresBrandCheck(int var) const; - // Return true if this local was introduced by the compiler, and should not be // exposed to the user in a debugger. static bool VariableIsSynthetic(String name); @@ -144,8 +141,7 @@ class ScopeInfo : public FixedArray { // mode for that variable. static int ContextSlotIndex(ScopeInfo scope_info, String name, VariableMode* mode, InitializationFlag* init_flag, - MaybeAssignedFlag* maybe_assigned_flag, - RequiresBrandCheckFlag* requires_brand_check); + MaybeAssignedFlag* maybe_assigned_flag); // Lookup metadata of a MODULE-allocated variable. Return 0 if there is no // module variable with the given name (the index value of a MODULE variable @@ -224,39 +220,26 @@ class ScopeInfo : public FixedArray { enum VariableAllocationInfo { NONE, STACK, CONTEXT, UNUSED }; // Properties of scopes. - class ScopeTypeField : public BitField<ScopeType, 0, 4> {}; - class CallsSloppyEvalField : public BitField<bool, ScopeTypeField::kNext, 1> { - }; + using ScopeTypeField = BitField<ScopeType, 0, 4>; + using SloppyEvalCanExtendVarsField = ScopeTypeField::Next<bool, 1>; STATIC_ASSERT(LanguageModeSize == 2); - class LanguageModeField - : public BitField<LanguageMode, CallsSloppyEvalField::kNext, 1> {}; - class DeclarationScopeField - : public BitField<bool, LanguageModeField::kNext, 1> {}; - class ReceiverVariableField - : public BitField<VariableAllocationInfo, DeclarationScopeField::kNext, - 2> {}; - class HasClassBrandField - : public BitField<bool, ReceiverVariableField::kNext, 1> {}; - class HasNewTargetField - : public BitField<bool, HasClassBrandField::kNext, 1> {}; - class FunctionVariableField - : public BitField<VariableAllocationInfo, HasNewTargetField::kNext, 2> {}; + using LanguageModeField = SloppyEvalCanExtendVarsField::Next<LanguageMode, 1>; + using DeclarationScopeField = LanguageModeField::Next<bool, 1>; + using ReceiverVariableField = + DeclarationScopeField::Next<VariableAllocationInfo, 2>; + using HasClassBrandField = ReceiverVariableField::Next<bool, 1>; + using HasNewTargetField = HasClassBrandField::Next<bool, 1>; + using FunctionVariableField = + HasNewTargetField::Next<VariableAllocationInfo, 2>; // TODO(cbruni): Combine with function variable field when only storing the // function name. - class HasInferredFunctionNameField - : public BitField<bool, FunctionVariableField::kNext, 1> {}; - class IsAsmModuleField - : public BitField<bool, HasInferredFunctionNameField::kNext, 1> {}; - class HasSimpleParametersField - : public BitField<bool, IsAsmModuleField::kNext, 1> {}; - class FunctionKindField - : public BitField<FunctionKind, HasSimpleParametersField::kNext, 5> {}; - class HasOuterScopeInfoField - : public BitField<bool, FunctionKindField::kNext, 1> {}; - class IsDebugEvaluateScopeField - : public BitField<bool, HasOuterScopeInfoField::kNext, 1> {}; - class ForceContextAllocationField - : public BitField<bool, IsDebugEvaluateScopeField::kNext, 1> {}; + using HasInferredFunctionNameField = FunctionVariableField::Next<bool, 1>; + using IsAsmModuleField = HasInferredFunctionNameField::Next<bool, 1>; + using HasSimpleParametersField = IsAsmModuleField::Next<bool, 1>; + using FunctionKindField = HasSimpleParametersField::Next<FunctionKind, 5>; + using HasOuterScopeInfoField = FunctionKindField::Next<bool, 1>; + using IsDebugEvaluateScopeField = HasOuterScopeInfoField::Next<bool, 1>; + using ForceContextAllocationField = IsDebugEvaluateScopeField::Next<bool, 1>; STATIC_ASSERT(kLastFunctionKind <= FunctionKindField::kMax); @@ -323,14 +306,10 @@ class ScopeInfo : public FixedArray { static const int kPositionInfoEntries = 2; // Properties of variables. - class VariableModeField : public BitField<VariableMode, 0, 3> {}; - class InitFlagField : public BitField<InitializationFlag, 3, 1> {}; - class MaybeAssignedFlagField : public BitField<MaybeAssignedFlag, 4, 1> {}; - class RequiresBrandCheckField - : public BitField<RequiresBrandCheckFlag, MaybeAssignedFlagField::kNext, - 1> {}; - class ParameterNumberField - : public BitField<uint32_t, RequiresBrandCheckField::kNext, 16> {}; + using VariableModeField = BitField<VariableMode, 0, 4>; + using InitFlagField = VariableModeField::Next<InitializationFlag, 1>; + using MaybeAssignedFlagField = InitFlagField::Next<MaybeAssignedFlag, 1>; + using ParameterNumberField = MaybeAssignedFlagField::Next<uint32_t, 16>; friend class ScopeIterator; friend std::ostream& operator<<(std::ostream& os, diff --git a/deps/v8/src/objects/shared-function-info-inl.h b/deps/v8/src/objects/shared-function-info-inl.h index 9778db5d90..6023c3b828 100644 --- a/deps/v8/src/objects/shared-function-info-inl.h +++ b/deps/v8/src/objects/shared-function-info-inl.h @@ -200,14 +200,13 @@ int SharedFunctionInfo::function_token_position() const { } } -BIT_FIELD_ACCESSORS(SharedFunctionInfo, flags, is_wrapped, - SharedFunctionInfo::IsWrappedBit) +BIT_FIELD_ACCESSORS(SharedFunctionInfo, flags, syntax_kind, + SharedFunctionInfo::FunctionSyntaxKindBits) + BIT_FIELD_ACCESSORS(SharedFunctionInfo, flags, allows_lazy_compilation, SharedFunctionInfo::AllowLazyCompilationBit) BIT_FIELD_ACCESSORS(SharedFunctionInfo, flags, has_duplicate_parameters, SharedFunctionInfo::HasDuplicateParametersBit) -BIT_FIELD_ACCESSORS(SharedFunctionInfo, flags, is_declaration, - SharedFunctionInfo::IsDeclarationBit) BIT_FIELD_ACCESSORS(SharedFunctionInfo, flags, native, SharedFunctionInfo::IsNativeBit) @@ -219,13 +218,9 @@ BIT_FIELD_ACCESSORS(SharedFunctionInfo, flags, BIT_FIELD_ACCESSORS(SharedFunctionInfo, flags, name_should_print_as_anonymous, SharedFunctionInfo::NameShouldPrintAsAnonymousBit) -BIT_FIELD_ACCESSORS(SharedFunctionInfo, flags, is_anonymous_expression, - SharedFunctionInfo::IsAnonymousExpressionBit) BIT_FIELD_ACCESSORS(SharedFunctionInfo, flags, has_reported_binary_coverage, SharedFunctionInfo::HasReportedBinaryCoverageBit) -BIT_FIELD_ACCESSORS(SharedFunctionInfo, flags, is_named_expression, - SharedFunctionInfo::IsNamedExpressionBit) BIT_FIELD_ACCESSORS(SharedFunctionInfo, flags, is_toplevel, SharedFunctionInfo::IsTopLevelBit) BIT_FIELD_ACCESSORS(SharedFunctionInfo, flags, @@ -271,6 +266,10 @@ void SharedFunctionInfo::set_kind(FunctionKind kind) { UpdateFunctionMapIndex(); } +bool SharedFunctionInfo::is_wrapped() const { + return syntax_kind() == FunctionSyntaxKind::kWrapped; +} + bool SharedFunctionInfo::needs_home_object() const { return NeedsHomeObjectBit::decode(flags()); } @@ -359,6 +358,11 @@ void SharedFunctionInfo::set_scope_info(ScopeInfo scope_info, if (HasInferredName() && inferred_name().length() != 0) { scope_info.SetInferredFunctionName(inferred_name()); } + set_raw_scope_info(scope_info, mode); +} + +void SharedFunctionInfo::set_raw_scope_info(ScopeInfo scope_info, + WriteBarrierMode mode) { WRITE_FIELD(*this, kNameOrScopeInfoOffset, scope_info); CONDITIONAL_WRITE_BARRIER(*this, kNameOrScopeInfoOffset, scope_info, mode); } @@ -572,7 +576,8 @@ UncompiledData SharedFunctionInfo::uncompiled_data() const { } void SharedFunctionInfo::set_uncompiled_data(UncompiledData uncompiled_data) { - DCHECK(function_data() == Smi::FromEnum(Builtins::kCompileLazy)); + DCHECK(function_data() == Smi::FromEnum(Builtins::kCompileLazy) || + HasUncompiledData()); DCHECK(uncompiled_data.IsUncompiledData()); set_function_data(uncompiled_data); } @@ -622,7 +627,7 @@ void SharedFunctionInfo::ClearPreparseData() { data.address() + UncompiledDataWithoutPreparseData::kSize, UncompiledDataWithPreparseData::kSize - UncompiledDataWithoutPreparseData::kSize, - ClearRecordedSlots::kNo); + ClearRecordedSlots::kYes); // Ensure that the clear was successful. DCHECK(HasUncompiledDataWithoutPreparseData()); diff --git a/deps/v8/src/objects/shared-function-info.h b/deps/v8/src/objects/shared-function-info.h index f7a82964b1..dc84653ede 100644 --- a/deps/v8/src/objects/shared-function-info.h +++ b/deps/v8/src/objects/shared-function-info.h @@ -8,6 +8,7 @@ #include "src/codegen/bailout-reason.h" #include "src/objects/compressed-slots.h" #include "src/objects/function-kind.h" +#include "src/objects/function-syntax-kind.h" #include "src/objects/objects.h" #include "src/objects/script.h" #include "src/objects/slots.h" @@ -256,6 +257,10 @@ class SharedFunctionInfo : public HeapObject { // [scope_info]: Scope info. DECL_ACCESSORS(scope_info, ScopeInfo) + // Set scope_info without moving the existing name onto the ScopeInfo. + inline void set_raw_scope_info(ScopeInfo scope_info, + WriteBarrierMode mode = UPDATE_WRITE_BARRIER); + // End position of this function in the script source. V8_EXPORT_PRIVATE int EndPosition() const; @@ -429,9 +434,6 @@ class SharedFunctionInfo : public HeapObject { // [flags] Bit field containing various flags about the function. DECL_INT32_ACCESSORS(flags) - // Is this function a named function expression in the source code. - DECL_BOOLEAN_ACCESSORS(is_named_expression) - // Is this function a top-level function (scripts, evals). DECL_BOOLEAN_ACCESSORS(is_toplevel) @@ -442,8 +444,11 @@ class SharedFunctionInfo : public HeapObject { inline LanguageMode language_mode() const; inline void set_language_mode(LanguageMode language_mode); + // How the function appears in source text. + DECL_PRIMITIVE_ACCESSORS(syntax_kind, FunctionSyntaxKind) + // Indicates whether the source is implicitly wrapped in a function. - DECL_BOOLEAN_ACCESSORS(is_wrapped) + inline bool is_wrapped() const; // True if the function has any duplicated parameter names. DECL_BOOLEAN_ACCESSORS(has_duplicate_parameters) @@ -454,9 +459,6 @@ class SharedFunctionInfo : public HeapObject { // global object. DECL_BOOLEAN_ACCESSORS(native) - // Whether this function was created from a FunctionDeclaration. - DECL_BOOLEAN_ACCESSORS(is_declaration) - // Indicates that asm->wasm conversion failed and should not be re-attempted. DECL_BOOLEAN_ACCESSORS(is_asm_wasm_broken) @@ -466,11 +468,6 @@ class SharedFunctionInfo : public HeapObject { // see a binding for it. DECL_BOOLEAN_ACCESSORS(name_should_print_as_anonymous) - // Indicates that the function is either an anonymous expression - // or an arrow function (the name field can be set through the API, - // which does not change this flag). - DECL_BOOLEAN_ACCESSORS(is_anonymous_expression) - // Indicates that the function represented by the shared function info was // classed as an immediately invoked function execution (IIFE) function and // is only executed once. @@ -680,21 +677,18 @@ class SharedFunctionInfo : public HeapObject { V(FunctionKindBits, FunctionKind, 5, _) \ V(IsNativeBit, bool, 1, _) \ V(IsStrictBit, bool, 1, _) \ - V(IsWrappedBit, bool, 1, _) \ + V(FunctionSyntaxKindBits, FunctionSyntaxKind, 3, _) \ V(IsClassConstructorBit, bool, 1, _) \ V(HasDuplicateParametersBit, bool, 1, _) \ V(AllowLazyCompilationBit, bool, 1, _) \ V(NeedsHomeObjectBit, bool, 1, _) \ - V(IsDeclarationBit, bool, 1, _) \ V(IsAsmWasmBrokenBit, bool, 1, _) \ V(FunctionMapIndexBits, int, 5, _) \ V(DisabledOptimizationReasonBits, BailoutReason, 4, _) \ V(RequiresInstanceMembersInitializer, bool, 1, _) \ V(ConstructAsBuiltinBit, bool, 1, _) \ - V(IsAnonymousExpressionBit, bool, 1, _) \ V(NameShouldPrintAsAnonymousBit, bool, 1, _) \ V(HasReportedBinaryCoverageBit, bool, 1, _) \ - V(IsNamedExpressionBit, bool, 1, _) \ V(IsTopLevelBit, bool, 1, _) \ V(IsOneshotIIFEOrPropertiesAreFinalBit, bool, 1, _) \ V(IsSafeToSkipArgumentsAdaptorBit, bool, 1, _) @@ -706,6 +700,8 @@ class SharedFunctionInfo : public HeapObject { DisabledOptimizationReasonBits::kMax); STATIC_ASSERT(kLastFunctionKind <= FunctionKindBits::kMax); + STATIC_ASSERT(FunctionSyntaxKind::kLastFunctionSyntaxKind <= + FunctionSyntaxKindBits::kMax); // Indicates that this function uses a super property (or an eval that may // use a super property). diff --git a/deps/v8/src/objects/source-text-module.cc b/deps/v8/src/objects/source-text-module.cc index e6637415c1..f17c59de1a 100644 --- a/deps/v8/src/objects/source-text-module.cc +++ b/deps/v8/src/objects/source-text-module.cc @@ -380,7 +380,7 @@ bool SourceTextModule::RunInitializationCode(Isolate* isolate, return false; } DCHECK_EQ(*function, Handle<JSGeneratorObject>::cast(generator)->function()); - module->set_code(*generator); + module->set_code(JSGeneratorObject::cast(*generator)); return true; } diff --git a/deps/v8/src/objects/source-text-module.h b/deps/v8/src/objects/source-text-module.h index 5c20b7018b..e6cf260e10 100644 --- a/deps/v8/src/objects/source-text-module.h +++ b/deps/v8/src/objects/source-text-module.h @@ -17,43 +17,17 @@ class UnorderedModuleSet; // The runtime representation of an ECMAScript Source Text Module Record. // https://tc39.github.io/ecma262/#sec-source-text-module-records -class SourceTextModule : public Module { +class SourceTextModule + : public TorqueGeneratedSourceTextModule<SourceTextModule, Module> { public: NEVER_READ_ONLY_SPACE - DECL_CAST(SourceTextModule) DECL_VERIFIER(SourceTextModule) DECL_PRINTER(SourceTextModule) - // The code representing this module, or an abstraction thereof. - // This is either a SharedFunctionInfo, a JSFunction, a JSGeneratorObject, or - // a SourceTextModuleInfo, depending on the state (status) the module is in. - // See SourceTextModule::SourceTextModuleVerify() for the precise invariant. - DECL_ACCESSORS(code, Object) - - // Arrays of cells corresponding to regular exports and regular imports. - // A cell's position in the array is determined by the cell index of the - // associated module entry (which coincides with the variable index of the - // associated variable). - DECL_ACCESSORS(regular_exports, FixedArray) - DECL_ACCESSORS(regular_imports, FixedArray) - // The shared function info in case {status} is not kEvaluating, kEvaluated or // kErrored. SharedFunctionInfo GetSharedFunctionInfo() const; - // Modules imported or re-exported by this module. - // Corresponds 1-to-1 to the module specifier strings in - // SourceTextModuleInfo::module_requests. - DECL_ACCESSORS(requested_modules, FixedArray) - - // [script]: Script from which the module originates. - DECL_ACCESSORS(script, Script) - - // The value of import.meta inside of this module. - // Lazily initialized on first access. It's the hole before first access and - // a JSObject afterwards. - DECL_ACCESSORS(import_meta, Object) - // Get the SourceTextModuleInfo associated with the code. inline SourceTextModuleInfo info() const; @@ -72,10 +46,6 @@ class SourceTextModule : public Module { static Handle<JSModuleNamespace> GetModuleNamespace( Isolate* isolate, Handle<SourceTextModule> module, int module_request); - // Layout description. - DEFINE_FIELD_OFFSET_CONSTANTS(Module::kHeaderSize, - TORQUE_GENERATED_SOURCE_TEXT_MODULE_FIELDS) - using BodyDescriptor = SubclassBodyDescriptor<Module::BodyDescriptor, FixedBodyDescriptor<kCodeOffset, kSize, kSize>>; @@ -135,7 +105,7 @@ class SourceTextModule : public Module { static void Reset(Isolate* isolate, Handle<SourceTextModule> module); - OBJECT_CONSTRUCTORS(SourceTextModule, Module); + TQ_OBJECT_CONSTRUCTORS(SourceTextModule) }; // SourceTextModuleInfo is to SourceTextModuleDescriptor what ScopeInfo is to @@ -186,30 +156,24 @@ class SourceTextModuleInfo : public FixedArray { OBJECT_CONSTRUCTORS(SourceTextModuleInfo, FixedArray); }; -class SourceTextModuleInfoEntry : public Struct { +class SourceTextModuleInfoEntry + : public TorqueGeneratedSourceTextModuleInfoEntry<SourceTextModuleInfoEntry, + Struct> { public: - DECL_CAST(SourceTextModuleInfoEntry) DECL_PRINTER(SourceTextModuleInfoEntry) DECL_VERIFIER(SourceTextModuleInfoEntry) - DECL_ACCESSORS(export_name, Object) - DECL_ACCESSORS(local_name, Object) - DECL_ACCESSORS(import_name, Object) DECL_INT_ACCESSORS(module_request) DECL_INT_ACCESSORS(cell_index) DECL_INT_ACCESSORS(beg_pos) DECL_INT_ACCESSORS(end_pos) static Handle<SourceTextModuleInfoEntry> New( - Isolate* isolate, Handle<Object> export_name, Handle<Object> local_name, - Handle<Object> import_name, int module_request, int cell_index, - int beg_pos, int end_pos); - - DEFINE_FIELD_OFFSET_CONSTANTS( - Struct::kHeaderSize, - TORQUE_GENERATED_SOURCE_TEXT_MODULE_INFO_ENTRY_FIELDS) + Isolate* isolate, Handle<HeapObject> export_name, + Handle<HeapObject> local_name, Handle<HeapObject> import_name, + int module_request, int cell_index, int beg_pos, int end_pos); - OBJECT_CONSTRUCTORS(SourceTextModuleInfoEntry, Struct); + TQ_OBJECT_CONSTRUCTORS(SourceTextModuleInfoEntry) }; } // namespace internal diff --git a/deps/v8/src/objects/stack-frame-info-inl.h b/deps/v8/src/objects/stack-frame-info-inl.h index e72af4df94..42e3a4a10a 100644 --- a/deps/v8/src/objects/stack-frame-info-inl.h +++ b/deps/v8/src/objects/stack-frame-info-inl.h @@ -28,6 +28,8 @@ SMI_ACCESSORS(StackFrameInfo, line_number, kLineNumberOffset) SMI_ACCESSORS(StackFrameInfo, column_number, kColumnNumberOffset) SMI_ACCESSORS(StackFrameInfo, script_id, kScriptIdOffset) SMI_ACCESSORS(StackFrameInfo, promise_all_index, kPromiseAllIndexOffset) +SMI_ACCESSORS_CHECKED(StackFrameInfo, function_offset, kPromiseAllIndexOffset, + is_wasm()) ACCESSORS(StackFrameInfo, script_name, Object, kScriptNameOffset) ACCESSORS(StackFrameInfo, script_name_or_source_url, Object, kScriptNameOrSourceUrlOffset) @@ -36,6 +38,7 @@ ACCESSORS(StackFrameInfo, method_name, Object, kMethodNameOffset) ACCESSORS(StackFrameInfo, type_name, Object, kTypeNameOffset) ACCESSORS(StackFrameInfo, eval_origin, Object, kEvalOriginOffset) ACCESSORS(StackFrameInfo, wasm_module_name, Object, kWasmModuleNameOffset) +ACCESSORS(StackFrameInfo, wasm_instance, Object, kWasmInstanceOffset) SMI_ACCESSORS(StackFrameInfo, flag, kFlagOffset) BOOL_ACCESSORS(StackFrameInfo, flag, is_eval, kIsEvalBit) BOOL_ACCESSORS(StackFrameInfo, flag, is_constructor, kIsConstructorBit) @@ -46,14 +49,11 @@ BOOL_ACCESSORS(StackFrameInfo, flag, is_toplevel, kIsToplevelBit) BOOL_ACCESSORS(StackFrameInfo, flag, is_async, kIsAsyncBit) BOOL_ACCESSORS(StackFrameInfo, flag, is_promise_all, kIsPromiseAllBit) -OBJECT_CONSTRUCTORS_IMPL(StackTraceFrame, Struct) +TQ_OBJECT_CONSTRUCTORS_IMPL(StackTraceFrame) NEVER_READ_ONLY_SPACE_IMPL(StackTraceFrame) -CAST_ACCESSOR(StackTraceFrame) -ACCESSORS(StackTraceFrame, frame_array, Object, kFrameArrayOffset) -SMI_ACCESSORS(StackTraceFrame, frame_index, kFrameIndexOffset) -ACCESSORS(StackTraceFrame, frame_info, Object, kFrameInfoOffset) -SMI_ACCESSORS(StackTraceFrame, id, kIdOffset) +TQ_SMI_ACCESSORS(StackTraceFrame, frame_index) +TQ_SMI_ACCESSORS(StackTraceFrame, id) } // namespace internal } // namespace v8 diff --git a/deps/v8/src/objects/stack-frame-info.cc b/deps/v8/src/objects/stack-frame-info.cc index 558449d85a..323c4b8fcb 100644 --- a/deps/v8/src/objects/stack-frame-info.cc +++ b/deps/v8/src/objects/stack-frame-info.cc @@ -52,6 +52,12 @@ int StackTraceFrame::GetPromiseAllIndex(Handle<StackTraceFrame> frame) { } // static +int StackTraceFrame::GetFunctionOffset(Handle<StackTraceFrame> frame) { + DCHECK(IsWasm(frame)); + return GetFrameInfo(frame)->function_offset(); +} + +// static Handle<Object> StackTraceFrame::GetFileName(Handle<StackTraceFrame> frame) { auto name = GetFrameInfo(frame)->script_name(); return handle(name, frame->GetIsolate()); @@ -96,6 +102,13 @@ Handle<Object> StackTraceFrame::GetWasmModuleName( } // static +Handle<WasmInstanceObject> StackTraceFrame::GetWasmInstance( + Handle<StackTraceFrame> frame) { + Object instance = GetFrameInfo(frame)->wasm_instance(); + return handle(WasmInstanceObject::cast(instance), frame->GetIsolate()); +} + +// static bool StackTraceFrame::IsEval(Handle<StackTraceFrame> frame) { return GetFrameInfo(frame)->is_eval(); } diff --git a/deps/v8/src/objects/stack-frame-info.h b/deps/v8/src/objects/stack-frame-info.h index 3d91c5374f..7c4918a3c6 100644 --- a/deps/v8/src/objects/stack-frame-info.h +++ b/deps/v8/src/objects/stack-frame-info.h @@ -14,6 +14,7 @@ namespace v8 { namespace internal { class FrameArray; +class WasmInstanceObject; class StackFrameInfo : public Struct { public: @@ -22,6 +23,8 @@ class StackFrameInfo : public Struct { DECL_INT_ACCESSORS(column_number) DECL_INT_ACCESSORS(script_id) DECL_INT_ACCESSORS(promise_all_index) + // Wasm frames only: function_offset instead of promise_all_index. + DECL_INT_ACCESSORS(function_offset) DECL_ACCESSORS(script_name, Object) DECL_ACCESSORS(script_name_or_source_url, Object) DECL_ACCESSORS(function_name, Object) @@ -29,6 +32,7 @@ class StackFrameInfo : public Struct { DECL_ACCESSORS(type_name, Object) DECL_ACCESSORS(eval_origin, Object) DECL_ACCESSORS(wasm_module_name, Object) + DECL_ACCESSORS(wasm_instance, Object) DECL_BOOLEAN_ACCESSORS(is_eval) DECL_BOOLEAN_ACCESSORS(is_constructor) DECL_BOOLEAN_ACCESSORS(is_wasm) @@ -67,22 +71,15 @@ class StackFrameInfo : public Struct { // The first time any of the Get* or Is* methods is called, a // StackFrameInfo object is allocated and all necessary information // retrieved. -class StackTraceFrame : public Struct { +class StackTraceFrame + : public TorqueGeneratedStackTraceFrame<StackTraceFrame, Struct> { public: NEVER_READ_ONLY_SPACE - DECL_ACCESSORS(frame_array, Object) DECL_INT_ACCESSORS(frame_index) - DECL_ACCESSORS(frame_info, Object) DECL_INT_ACCESSORS(id) - DECL_CAST(StackTraceFrame) - // Dispatched behavior. DECL_PRINTER(StackTraceFrame) - DECL_VERIFIER(StackTraceFrame) - - DEFINE_FIELD_OFFSET_CONSTANTS(Struct::kHeaderSize, - TORQUE_GENERATED_STACK_TRACE_FRAME_FIELDS) static int GetLineNumber(Handle<StackTraceFrame> frame); static int GetOneBasedLineNumber(Handle<StackTraceFrame> frame); @@ -90,6 +87,7 @@ class StackTraceFrame : public Struct { static int GetOneBasedColumnNumber(Handle<StackTraceFrame> frame); static int GetScriptId(Handle<StackTraceFrame> frame); static int GetPromiseAllIndex(Handle<StackTraceFrame> frame); + static int GetFunctionOffset(Handle<StackTraceFrame> frame); static Handle<Object> GetFileName(Handle<StackTraceFrame> frame); static Handle<Object> GetScriptNameOrSourceUrl(Handle<StackTraceFrame> frame); @@ -98,6 +96,8 @@ class StackTraceFrame : public Struct { static Handle<Object> GetTypeName(Handle<StackTraceFrame> frame); static Handle<Object> GetEvalOrigin(Handle<StackTraceFrame> frame); static Handle<Object> GetWasmModuleName(Handle<StackTraceFrame> frame); + static Handle<WasmInstanceObject> GetWasmInstance( + Handle<StackTraceFrame> frame); static bool IsEval(Handle<StackTraceFrame> frame); static bool IsConstructor(Handle<StackTraceFrame> frame); @@ -109,10 +109,10 @@ class StackTraceFrame : public Struct { static bool IsPromiseAll(Handle<StackTraceFrame> frame); private: - OBJECT_CONSTRUCTORS(StackTraceFrame, Struct); - static Handle<StackFrameInfo> GetFrameInfo(Handle<StackTraceFrame> frame); static void InitializeFrameInfo(Handle<StackTraceFrame> frame); + + TQ_OBJECT_CONSTRUCTORS(StackTraceFrame) }; // Small helper that retrieves the FrameArray from a stack-trace diff --git a/deps/v8/src/objects/string-inl.h b/deps/v8/src/objects/string-inl.h index db724e0cf1..083928d211 100644 --- a/deps/v8/src/objects/string-inl.h +++ b/deps/v8/src/objects/string-inl.h @@ -137,6 +137,65 @@ STATIC_ASSERT((kExternalStringTag | kTwoByteStringTag) == STATIC_ASSERT(v8::String::TWO_BYTE_ENCODING == kTwoByteStringTag); +template <typename TDispatcher, typename TResult, typename... TArgs> +inline TResult StringShape::DispatchToSpecificTypeWithoutCast(TArgs&&... args) { + switch (full_representation_tag()) { + case kSeqStringTag | kOneByteStringTag: + return TDispatcher::HandleSeqOneByteString(std::forward<TArgs>(args)...); + case kSeqStringTag | kTwoByteStringTag: + return TDispatcher::HandleSeqTwoByteString(std::forward<TArgs>(args)...); + case kConsStringTag | kOneByteStringTag: + case kConsStringTag | kTwoByteStringTag: + return TDispatcher::HandleConsString(std::forward<TArgs>(args)...); + case kExternalStringTag | kOneByteStringTag: + return TDispatcher::HandleExternalOneByteString( + std::forward<TArgs>(args)...); + case kExternalStringTag | kTwoByteStringTag: + return TDispatcher::HandleExternalTwoByteString( + std::forward<TArgs>(args)...); + case kSlicedStringTag | kOneByteStringTag: + case kSlicedStringTag | kTwoByteStringTag: + return TDispatcher::HandleSlicedString(std::forward<TArgs>(args)...); + case kThinStringTag | kOneByteStringTag: + case kThinStringTag | kTwoByteStringTag: + return TDispatcher::HandleThinString(std::forward<TArgs>(args)...); + default: + return TDispatcher::HandleInvalidString(std::forward<TArgs>(args)...); + } +} + +// All concrete subclasses of String (leaves of the inheritance tree). +#define STRING_CLASS_TYPES(V) \ + V(SeqOneByteString) \ + V(SeqTwoByteString) \ + V(ConsString) \ + V(ExternalOneByteString) \ + V(ExternalTwoByteString) \ + V(SlicedString) \ + V(ThinString) + +template <typename TDispatcher, typename TResult, typename... TArgs> +inline TResult StringShape::DispatchToSpecificType(String str, + TArgs&&... args) { + class CastingDispatcher : public AllStatic { + public: +#define DEFINE_METHOD(Type) \ + static inline TResult Handle##Type(String str, TArgs&&... args) { \ + return TDispatcher::Handle##Type(Type::cast(str), \ + std::forward<TArgs>(args)...); \ + } + STRING_CLASS_TYPES(DEFINE_METHOD) +#undef DEFINE_METHOD + static inline TResult HandleInvalidString(String str, TArgs&&... args) { + return TDispatcher::HandleInvalidString(str, + std::forward<TArgs>(args)...); + } + }; + + return DispatchToSpecificTypeWithoutCast<CastingDispatcher, TResult>( + str, std::forward<TArgs>(args)...); +} + DEF_GETTER(String, IsOneByteRepresentation, bool) { uint32_t type = map(isolate).instance_type(); return (type & kStringEncodingMask) == kOneByteStringTag; @@ -340,29 +399,22 @@ Handle<String> String::Flatten(Isolate* isolate, Handle<String> string, uint16_t String::Get(int index) { DCHECK(index >= 0 && index < length()); - switch (StringShape(*this).full_representation_tag()) { - case kSeqStringTag | kOneByteStringTag: - return SeqOneByteString::cast(*this).Get(index); - case kSeqStringTag | kTwoByteStringTag: - return SeqTwoByteString::cast(*this).Get(index); - case kConsStringTag | kOneByteStringTag: - case kConsStringTag | kTwoByteStringTag: - return ConsString::cast(*this).Get(index); - case kExternalStringTag | kOneByteStringTag: - return ExternalOneByteString::cast(*this).Get(index); - case kExternalStringTag | kTwoByteStringTag: - return ExternalTwoByteString::cast(*this).Get(index); - case kSlicedStringTag | kOneByteStringTag: - case kSlicedStringTag | kTwoByteStringTag: - return SlicedString::cast(*this).Get(index); - case kThinStringTag | kOneByteStringTag: - case kThinStringTag | kTwoByteStringTag: - return ThinString::cast(*this).Get(index); - default: - break; + + class StringGetDispatcher : public AllStatic { + public: +#define DEFINE_METHOD(Type) \ + static inline uint16_t Handle##Type(Type str, int index) { \ + return str.Get(index); \ } + STRING_CLASS_TYPES(DEFINE_METHOD) +#undef DEFINE_METHOD + static inline uint16_t HandleInvalidString(String str, int index) { + UNREACHABLE(); + } + }; - UNREACHABLE(); + return StringShape(*this) + .DispatchToSpecificType<StringGetDispatcher, uint16_t>(*this, index); } void String::Set(int index, uint16_t value) { diff --git a/deps/v8/src/objects/string.cc b/deps/v8/src/objects/string.cc index d1981fd24d..41de3aef04 100644 --- a/deps/v8/src/objects/string.cc +++ b/deps/v8/src/objects/string.cc @@ -110,6 +110,8 @@ void String::MakeThin(Isolate* isolate, String internalized) { } } + bool has_pointers = StringShape(*this).IsIndirect(); + int old_size = this->Size(); isolate->heap()->NotifyObjectLayoutChange(*this, old_size, no_gc); bool one_byte = internalized.IsOneByteRepresentation(); @@ -123,7 +125,9 @@ void String::MakeThin(Isolate* isolate, String internalized) { int size_delta = old_size - ThinString::kSize; if (size_delta != 0) { Heap* heap = isolate->heap(); - heap->CreateFillerObjectAt(thin_end, size_delta, ClearRecordedSlots::kNo); + heap->CreateFillerObjectAt( + thin_end, size_delta, + has_pointers ? ClearRecordedSlots::kYes : ClearRecordedSlots::kNo); } } @@ -178,7 +182,8 @@ bool String::MakeExternal(v8::String::ExternalStringResource* resource) { // Byte size of the external String object. int new_size = this->SizeFromMap(new_map); isolate->heap()->CreateFillerObjectAt( - this->address() + new_size, size - new_size, ClearRecordedSlots::kNo); + this->address() + new_size, size - new_size, + has_pointers ? ClearRecordedSlots::kYes : ClearRecordedSlots::kNo); if (has_pointers) { isolate->heap()->ClearRecordedSlotRange(this->address(), this->address() + new_size); @@ -250,7 +255,8 @@ bool String::MakeExternal(v8::String::ExternalOneByteStringResource* resource) { // Byte size of the external String object. int new_size = this->SizeFromMap(new_map); isolate->heap()->CreateFillerObjectAt( - this->address() + new_size, size - new_size, ClearRecordedSlots::kNo); + this->address() + new_size, size - new_size, + has_pointers ? ClearRecordedSlots::kYes : ClearRecordedSlots::kNo); if (has_pointers) { isolate->heap()->ClearRecordedSlotRange(this->address(), this->address() + new_size); diff --git a/deps/v8/src/objects/string.h b/deps/v8/src/objects/string.h index 1a826eee3b..27bd7e8765 100644 --- a/deps/v8/src/objects/string.h +++ b/deps/v8/src/objects/string.h @@ -61,6 +61,13 @@ class StringShape { inline void invalidate() {} #endif + // Run different behavior for each concrete string class type, as defined by + // the dispatcher. + template <typename TDispatcher, typename TResult, typename... TArgs> + inline TResult DispatchToSpecificTypeWithoutCast(TArgs&&... args); + template <typename TDispatcher, typename TResult, typename... TArgs> + inline TResult DispatchToSpecificType(String str, TArgs&&... args); + private: uint32_t type_; #ifdef DEBUG diff --git a/deps/v8/src/objects/struct-inl.h b/deps/v8/src/objects/struct-inl.h index 47d55a876f..af0fed126b 100644 --- a/deps/v8/src/objects/struct-inl.h +++ b/deps/v8/src/objects/struct-inl.h @@ -24,10 +24,9 @@ TQ_OBJECT_CONSTRUCTORS_IMPL(Tuple2) TQ_OBJECT_CONSTRUCTORS_IMPL(Tuple3) OBJECT_CONSTRUCTORS_IMPL(AccessorPair, Struct) -OBJECT_CONSTRUCTORS_IMPL(ClassPositions, Struct) +TQ_OBJECT_CONSTRUCTORS_IMPL(ClassPositions) CAST_ACCESSOR(AccessorPair) -CAST_ACCESSOR(ClassPositions) void Struct::InitializeBody(int object_size) { Object value = GetReadOnlyRoots().undefined_value(); @@ -39,8 +38,8 @@ void Struct::InitializeBody(int object_size) { ACCESSORS(AccessorPair, getter, Object, kGetterOffset) ACCESSORS(AccessorPair, setter, Object, kSetterOffset) -SMI_ACCESSORS(ClassPositions, start, kStartOffset) -SMI_ACCESSORS(ClassPositions, end, kEndOffset) +TQ_SMI_ACCESSORS(ClassPositions, start) +TQ_SMI_ACCESSORS(ClassPositions, end) Object AccessorPair::get(AccessorComponent component) { return component == ACCESSOR_GETTER ? getter() : setter(); diff --git a/deps/v8/src/objects/struct.h b/deps/v8/src/objects/struct.h index b01a33561b..c9372d9ada 100644 --- a/deps/v8/src/objects/struct.h +++ b/deps/v8/src/objects/struct.h @@ -60,6 +60,7 @@ class AccessorPair : public Struct { // Note: Returns undefined if the component is not set. static Handle<Object> GetComponent(Isolate* isolate, + Handle<NativeContext> native_context, Handle<AccessorPair> accessor_pair, AccessorComponent component); @@ -79,22 +80,17 @@ class AccessorPair : public Struct { OBJECT_CONSTRUCTORS(AccessorPair, Struct); }; -class ClassPositions : public Struct { +class ClassPositions + : public TorqueGeneratedClassPositions<ClassPositions, Struct> { public: DECL_INT_ACCESSORS(start) DECL_INT_ACCESSORS(end) - DECL_CAST(ClassPositions) - // Dispatched behavior. DECL_PRINTER(ClassPositions) - DECL_VERIFIER(ClassPositions) void BriefPrintDetails(std::ostream& os); - DEFINE_FIELD_OFFSET_CONSTANTS(HeapObject::kHeaderSize, - TORQUE_GENERATED_CLASS_POSITIONS_FIELDS) - - OBJECT_CONSTRUCTORS(ClassPositions, Struct); + TQ_OBJECT_CONSTRUCTORS(ClassPositions) }; } // namespace internal diff --git a/deps/v8/src/objects/synthetic-module.h b/deps/v8/src/objects/synthetic-module.h index 9f91f2ce4a..6f3bb0438e 100644 --- a/deps/v8/src/objects/synthetic-module.h +++ b/deps/v8/src/objects/synthetic-module.h @@ -17,26 +17,17 @@ namespace internal { // instantiated by an embedder with embedder-defined exports and evaluation // steps. // https://heycam.github.io/webidl/#synthetic-module-records -class SyntheticModule : public Module { +class SyntheticModule + : public TorqueGeneratedSyntheticModule<SyntheticModule, Module> { public: NEVER_READ_ONLY_SPACE - DECL_CAST(SyntheticModule) DECL_VERIFIER(SyntheticModule) DECL_PRINTER(SyntheticModule) - // The list of all names exported by this module - DECL_ACCESSORS(name, String) - DECL_ACCESSORS(export_names, FixedArray) - DECL_ACCESSORS(evaluation_steps, Foreign) - static void SetExport(Isolate* isolate, Handle<SyntheticModule> module, Handle<String> export_name, Handle<Object> export_value); - // Layout description. - DEFINE_FIELD_OFFSET_CONSTANTS(Module::kHeaderSize, - TORQUE_GENERATED_SYNTHETIC_MODULE_FIELDS) - using BodyDescriptor = SubclassBodyDescriptor< Module::BodyDescriptor, FixedBodyDescriptor<kExportNamesOffset, kSize, kSize>>; @@ -58,7 +49,7 @@ class SyntheticModule : public Module { static V8_WARN_UNUSED_RESULT MaybeHandle<Object> Evaluate( Isolate* isolate, Handle<SyntheticModule> module); - OBJECT_CONSTRUCTORS(SyntheticModule, Module); + TQ_OBJECT_CONSTRUCTORS(SyntheticModule) }; } // namespace internal diff --git a/deps/v8/src/objects/template-objects-inl.h b/deps/v8/src/objects/template-objects-inl.h index 85c1e6c8f4..b0f73e873b 100644 --- a/deps/v8/src/objects/template-objects-inl.h +++ b/deps/v8/src/objects/template-objects-inl.h @@ -15,16 +15,11 @@ namespace v8 { namespace internal { -OBJECT_CONSTRUCTORS_IMPL(TemplateObjectDescription, Struct) +TQ_OBJECT_CONSTRUCTORS_IMPL(TemplateObjectDescription) OBJECT_CONSTRUCTORS_IMPL(CachedTemplateObject, Tuple3) -CAST_ACCESSOR(TemplateObjectDescription) CAST_ACCESSOR(CachedTemplateObject) -ACCESSORS(TemplateObjectDescription, raw_strings, FixedArray, kRawStringsOffset) -ACCESSORS(TemplateObjectDescription, cooked_strings, FixedArray, - kCookedStringsOffset) - SMI_ACCESSORS(CachedTemplateObject, slot_id, kSlotIdOffset) ACCESSORS(CachedTemplateObject, template_object, JSArray, kTemplateObjectOffset) ACCESSORS(CachedTemplateObject, next, HeapObject, kNextOffset) diff --git a/deps/v8/src/objects/template-objects.h b/deps/v8/src/objects/template-objects.h index 20ad742338..7bac29206b 100644 --- a/deps/v8/src/objects/template-objects.h +++ b/deps/v8/src/objects/template-objects.h @@ -39,25 +39,16 @@ class CachedTemplateObject final : public Tuple3 { // TemplateObjectDescription is a tuple of raw strings and cooked strings for // tagged template literals. Used to communicate with the runtime for template // object creation within the {Runtime_GetTemplateObject} method. -class TemplateObjectDescription final : public Struct { +class TemplateObjectDescription final + : public TorqueGeneratedTemplateObjectDescription<TemplateObjectDescription, + Struct> { public: - DECL_ACCESSORS(raw_strings, FixedArray) - DECL_ACCESSORS(cooked_strings, FixedArray) - - DECL_CAST(TemplateObjectDescription) - static Handle<JSArray> GetTemplateObject( Isolate* isolate, Handle<NativeContext> native_context, Handle<TemplateObjectDescription> description, Handle<SharedFunctionInfo> shared_info, int slot_id); - DECL_PRINTER(TemplateObjectDescription) - DECL_VERIFIER(TemplateObjectDescription) - - DEFINE_FIELD_OFFSET_CONSTANTS( - Struct::kHeaderSize, TORQUE_GENERATED_TEMPLATE_OBJECT_DESCRIPTION_FIELDS) - - OBJECT_CONSTRUCTORS(TemplateObjectDescription, Struct); + TQ_OBJECT_CONSTRUCTORS(TemplateObjectDescription) }; } // namespace internal diff --git a/deps/v8/src/objects/templates-inl.h b/deps/v8/src/objects/templates-inl.h index d344174a0c..be58fc12bc 100644 --- a/deps/v8/src/objects/templates-inl.h +++ b/deps/v8/src/objects/templates-inl.h @@ -17,29 +17,16 @@ namespace v8 { namespace internal { -OBJECT_CONSTRUCTORS_IMPL(TemplateInfo, Struct) -OBJECT_CONSTRUCTORS_IMPL(FunctionTemplateInfo, TemplateInfo) -OBJECT_CONSTRUCTORS_IMPL(ObjectTemplateInfo, TemplateInfo) -OBJECT_CONSTRUCTORS_IMPL(FunctionTemplateRareData, Struct) +TQ_OBJECT_CONSTRUCTORS_IMPL(TemplateInfo) +TQ_OBJECT_CONSTRUCTORS_IMPL(FunctionTemplateInfo) +TQ_OBJECT_CONSTRUCTORS_IMPL(ObjectTemplateInfo) +TQ_OBJECT_CONSTRUCTORS_IMPL(FunctionTemplateRareData) NEVER_READ_ONLY_SPACE_IMPL(TemplateInfo) -ACCESSORS(TemplateInfo, tag, Object, kTagOffset) -ACCESSORS(TemplateInfo, serial_number, Object, kSerialNumberOffset) -SMI_ACCESSORS(TemplateInfo, number_of_properties, kNumberOfPropertiesOffset) -ACCESSORS(TemplateInfo, property_list, Object, kPropertyListOffset) -ACCESSORS(TemplateInfo, property_accessors, Object, kPropertyAccessorsOffset) - -ACCESSORS(FunctionTemplateInfo, call_code, Object, kCallCodeOffset) -ACCESSORS(FunctionTemplateInfo, class_name, Object, kClassNameOffset) -ACCESSORS(FunctionTemplateInfo, signature, Object, kSignatureOffset) -ACCESSORS(FunctionTemplateInfo, shared_function_info, Object, - kSharedFunctionInfoOffset) -ACCESSORS(FunctionTemplateInfo, rare_data, HeapObject, - kFunctionTemplateRareDataOffset) -ACCESSORS(FunctionTemplateInfo, cached_property_name, Object, - kCachedPropertyNameOffset) -SMI_ACCESSORS(FunctionTemplateInfo, length, kLengthOffset) +TQ_SMI_ACCESSORS(TemplateInfo, number_of_properties) + +TQ_SMI_ACCESSORS(FunctionTemplateInfo, length) BOOL_ACCESSORS(FunctionTemplateInfo, flag, undetectable, kUndetectableBit) BOOL_ACCESSORS(FunctionTemplateInfo, flag, needs_access_check, kNeedsAccessCheckBit) @@ -50,7 +37,7 @@ BOOL_ACCESSORS(FunctionTemplateInfo, flag, remove_prototype, BOOL_ACCESSORS(FunctionTemplateInfo, flag, do_not_cache, kDoNotCacheBit) BOOL_ACCESSORS(FunctionTemplateInfo, flag, accept_any_receiver, kAcceptAnyReceiver) -SMI_ACCESSORS(FunctionTemplateInfo, flag, kFlagOffset) +TQ_SMI_ACCESSORS(FunctionTemplateInfo, flag) // static FunctionTemplateRareData FunctionTemplateInfo::EnsureFunctionTemplateRareData( @@ -88,31 +75,6 @@ RARE_ACCESSORS(instance_call_handler, InstanceCallHandler, Object) RARE_ACCESSORS(access_check_info, AccessCheckInfo, Object) #undef RARE_ACCESSORS -ACCESSORS(FunctionTemplateRareData, prototype_template, Object, - kPrototypeTemplateOffset) -ACCESSORS(FunctionTemplateRareData, prototype_provider_template, Object, - kPrototypeProviderTemplateOffset) -ACCESSORS(FunctionTemplateRareData, parent_template, Object, - kParentTemplateOffset) -ACCESSORS(FunctionTemplateRareData, named_property_handler, Object, - kNamedPropertyHandlerOffset) -ACCESSORS(FunctionTemplateRareData, indexed_property_handler, Object, - kIndexedPropertyHandlerOffset) -ACCESSORS(FunctionTemplateRareData, instance_template, Object, - kInstanceTemplateOffset) -ACCESSORS(FunctionTemplateRareData, instance_call_handler, Object, - kInstanceCallHandlerOffset) -ACCESSORS(FunctionTemplateRareData, access_check_info, Object, - kAccessCheckInfoOffset) - -ACCESSORS(ObjectTemplateInfo, constructor, Object, kConstructorOffset) -ACCESSORS(ObjectTemplateInfo, data, Object, kDataOffset) - -CAST_ACCESSOR(TemplateInfo) -CAST_ACCESSOR(FunctionTemplateInfo) -CAST_ACCESSOR(FunctionTemplateRareData) -CAST_ACCESSOR(ObjectTemplateInfo) - bool FunctionTemplateInfo::instantiated() { return shared_function_info().IsSharedFunctionInfo(); } diff --git a/deps/v8/src/objects/templates.h b/deps/v8/src/objects/templates.h index 99142266ed..29671db83c 100644 --- a/deps/v8/src/objects/templates.h +++ b/deps/v8/src/objects/templates.h @@ -13,21 +13,10 @@ namespace v8 { namespace internal { -class TemplateInfo : public Struct { +class TemplateInfo : public TorqueGeneratedTemplateInfo<TemplateInfo, Struct> { public: NEVER_READ_ONLY_SPACE - DECL_ACCESSORS(tag, Object) - DECL_ACCESSORS(serial_number, Object) DECL_INT_ACCESSORS(number_of_properties) - DECL_ACCESSORS(property_list, Object) - DECL_ACCESSORS(property_accessors, Object) - - DECL_VERIFIER(TemplateInfo) - - DECL_CAST(TemplateInfo) - - DEFINE_FIELD_OFFSET_CONSTANTS(HeapObject::kHeaderSize, - TORQUE_GENERATED_TEMPLATE_INFO_FIELDS) static const int kFastTemplateInstantiationsCacheSize = 1 * KB; @@ -36,55 +25,25 @@ class TemplateInfo : public Struct { // instead of caching them. static const int kSlowTemplateInstantiationsCacheSize = 1 * MB; - OBJECT_CONSTRUCTORS(TemplateInfo, Struct); + TQ_OBJECT_CONSTRUCTORS(TemplateInfo) }; // Contains data members that are rarely set on a FunctionTemplateInfo. -class FunctionTemplateRareData : public Struct { +class FunctionTemplateRareData + : public TorqueGeneratedFunctionTemplateRareData<FunctionTemplateRareData, + Struct> { public: - // See DECL_RARE_ACCESSORS in FunctionTemplateInfo. - DECL_ACCESSORS(prototype_template, Object) - DECL_ACCESSORS(prototype_provider_template, Object) - DECL_ACCESSORS(parent_template, Object) - DECL_ACCESSORS(named_property_handler, Object) - DECL_ACCESSORS(indexed_property_handler, Object) - DECL_ACCESSORS(instance_template, Object) - DECL_ACCESSORS(instance_call_handler, Object) - DECL_ACCESSORS(access_check_info, Object) - - DECL_CAST(FunctionTemplateRareData) - // Dispatched behavior. DECL_PRINTER(FunctionTemplateRareData) - DECL_VERIFIER(FunctionTemplateRareData) - DEFINE_FIELD_OFFSET_CONSTANTS( - HeapObject::kHeaderSize, - TORQUE_GENERATED_FUNCTION_TEMPLATE_RARE_DATA_FIELDS) - - OBJECT_CONSTRUCTORS(FunctionTemplateRareData, Struct); + TQ_OBJECT_CONSTRUCTORS(FunctionTemplateRareData) }; // See the api-exposed FunctionTemplate for more information. -class FunctionTemplateInfo : public TemplateInfo { +class FunctionTemplateInfo + : public TorqueGeneratedFunctionTemplateInfo<FunctionTemplateInfo, + TemplateInfo> { public: - // Handler invoked when calling an instance of this FunctionTemplateInfo. - // Either CallInfoHandler or Undefined. - DECL_ACCESSORS(call_code, Object) - - DECL_ACCESSORS(class_name, Object) - - // If the signature is a FunctionTemplateInfo it is used to check whether the - // receiver calling the associated JSFunction is a compatible receiver, i.e. - // it is an instance of the signature FunctionTemplateInfo or any of the - // receiver's prototypes are. - DECL_ACCESSORS(signature, Object) - - // If any of the setters below declared by DECL_RARE_ACCESSORS are used then - // a FunctionTemplateRareData will be stored here. Until then this contains - // undefined. - DECL_ACCESSORS(rare_data, HeapObject) - #define DECL_RARE_ACCESSORS(Name, CamelName, Type) \ DECL_GETTER(Get##CamelName, Type) \ static inline void Set##CamelName( \ @@ -125,19 +84,12 @@ class FunctionTemplateInfo : public TemplateInfo { DECL_RARE_ACCESSORS(access_check_info, AccessCheckInfo, Object) #undef DECL_RARE_ACCESSORS - DECL_ACCESSORS(shared_function_info, Object) - // Internal field to store a flag bitfield. DECL_INT_ACCESSORS(flag) // "length" property of the final JSFunction. DECL_INT_ACCESSORS(length) - // Either the_hole or a private symbol. Used to cache the result on - // the receiver under the the cached_property_name when this - // FunctionTemplateInfo is used as a getter. - DECL_ACCESSORS(cached_property_name, Object) - // Begin flag bits --------------------- DECL_BOOLEAN_ACCESSORS(undetectable) @@ -160,17 +112,11 @@ class FunctionTemplateInfo : public TemplateInfo { DECL_BOOLEAN_ACCESSORS(accept_any_receiver) // End flag bits --------------------- - DECL_CAST(FunctionTemplateInfo) - // Dispatched behavior. DECL_PRINTER(FunctionTemplateInfo) - DECL_VERIFIER(FunctionTemplateInfo) static const int kInvalidSerialNumber = 0; - DEFINE_FIELD_OFFSET_CONSTANTS(TemplateInfo::kHeaderSize, - TORQUE_GENERATED_FUNCTION_TEMPLATE_INFO_FIELDS) - static Handle<SharedFunctionInfo> GetOrCreateSharedFunctionInfo( Isolate* isolate, Handle<FunctionTemplateInfo> info, MaybeHandle<Name> maybe_name); @@ -202,36 +148,28 @@ class FunctionTemplateInfo : public TemplateInfo { static FunctionTemplateRareData AllocateFunctionTemplateRareData( Isolate* isolate, Handle<FunctionTemplateInfo> function_template_info); - OBJECT_CONSTRUCTORS(FunctionTemplateInfo, TemplateInfo); + TQ_OBJECT_CONSTRUCTORS(FunctionTemplateInfo) }; -class ObjectTemplateInfo : public TemplateInfo { +class ObjectTemplateInfo + : public TorqueGeneratedObjectTemplateInfo<ObjectTemplateInfo, + TemplateInfo> { public: - DECL_ACCESSORS(constructor, Object) - DECL_ACCESSORS(data, Object) DECL_INT_ACCESSORS(embedder_field_count) DECL_BOOLEAN_ACCESSORS(immutable_proto) - DECL_CAST(ObjectTemplateInfo) - // Dispatched behavior. DECL_PRINTER(ObjectTemplateInfo) - DECL_VERIFIER(ObjectTemplateInfo) - - // Layout description. - DEFINE_FIELD_OFFSET_CONSTANTS(TemplateInfo::kHeaderSize, - TORQUE_GENERATED_OBJECT_TEMPLATE_INFO_FIELDS) // Starting from given object template's constructor walk up the inheritance // chain till a function template that has an instance template is found. inline ObjectTemplateInfo GetParent(Isolate* isolate); private: - class IsImmutablePrototype : public BitField<bool, 0, 1> {}; - class EmbedderFieldCount - : public BitField<int, IsImmutablePrototype::kNext, 29> {}; + using IsImmutablePrototype = BitField<bool, 0, 1>; + using EmbedderFieldCount = IsImmutablePrototype::Next<int, 29>; - OBJECT_CONSTRUCTORS(ObjectTemplateInfo, TemplateInfo); + TQ_OBJECT_CONSTRUCTORS(ObjectTemplateInfo) }; } // namespace internal diff --git a/deps/v8/src/objects/value-serializer.cc b/deps/v8/src/objects/value-serializer.cc index 5a72dd6532..3b3506fbb9 100644 --- a/deps/v8/src/objects/value-serializer.cc +++ b/deps/v8/src/objects/value-serializer.cc @@ -417,9 +417,6 @@ Maybe<bool> ValueSerializer::WriteObject(Handle<Object> object) { case HEAP_NUMBER_TYPE: WriteHeapNumber(HeapNumber::cast(*object)); return ThrowIfOutOfMemory(); - case MUTABLE_HEAP_NUMBER_TYPE: - WriteMutableHeapNumber(MutableHeapNumber::cast(*object)); - return ThrowIfOutOfMemory(); case BIGINT_TYPE: WriteBigInt(BigInt::cast(*object)); return ThrowIfOutOfMemory(); @@ -485,11 +482,6 @@ void ValueSerializer::WriteHeapNumber(HeapNumber number) { WriteDouble(number.value()); } -void ValueSerializer::WriteMutableHeapNumber(MutableHeapNumber number) { - WriteTag(SerializationTag::kDouble); - WriteDouble(number.value()); -} - void ValueSerializer::WriteBigInt(BigInt bigint) { WriteTag(SerializationTag::kBigInt); WriteBigIntContents(bigint); diff --git a/deps/v8/src/objects/value-serializer.h b/deps/v8/src/objects/value-serializer.h index 9e381d7e76..cc9bc1caea 100644 --- a/deps/v8/src/objects/value-serializer.h +++ b/deps/v8/src/objects/value-serializer.h @@ -30,7 +30,6 @@ class JSMap; class JSPrimitiveWrapper; class JSRegExp; class JSSet; -class MutableHeapNumber; class Object; class Oddball; class Smi; @@ -111,7 +110,6 @@ class ValueSerializer { void WriteOddball(Oddball oddball); void WriteSmi(Smi smi); void WriteHeapNumber(HeapNumber number); - void WriteMutableHeapNumber(MutableHeapNumber number); void WriteBigInt(BigInt bigint); void WriteString(Handle<String> string); Maybe<bool> WriteJSReceiver(Handle<JSReceiver> receiver) |