AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

Revert "Reimplement Object.entries/values as CSA to optimize performance."

Browse Source 
This reverts commit d30a8fa9b4.

Reason for revert: no-snap test failures here
https://build.chromium.org/p/client.v8/builders/V8%20Linux%20-%20nosnap%20-%20debug/builds/17068
You need to update the whitelist in src/debug/debug-evaluate.cc.
I'm a bit surprised this only happens in no-snap builds.


Original change's description:
> Reimplement Object.entries/values as CSA to optimize performance.
> 
> This implementation based on runtime implementation.
> 
> Bug: v8:6804
> Change-Id: Ib8bfcc4648e44a999789237effc0275c5e4d9936
> Reviewed-on: https://chromium-review.googlesource.com/810504
> Commit-Queue: Camillo Bruni <cbruni@chromium.org>
> Reviewed-by: Camillo Bruni <cbruni@chromium.org>
> Reviewed-by: Jakob Gruber <jgruber@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#50477}

TBR=cbruni@chromium.org,jgruber@chromium.org,ishell@chromium.org,brn@b6n.ch

Change-Id: I1a0c8e3c054a57ca4d15f7a064ff4b28ca133b16
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: v8:6804
Reviewed-on: https://chromium-review.googlesource.com/859937
Reviewed-by: Yang Guo <yangguo@chromium.org>
Commit-Queue: Yang Guo <yangguo@chromium.org>
Cr-Commit-Position: refs/heads/master@{#50478}
This commit is contained in:
Yang Guo 2018-01-10 13:34:42 +00:00 committed by Commit Bot
parent d30a8fa9b4
commit 1b49f725ac
11 changed files with 67 additions and 416 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
AUTHORS
View File

@ -135,7 +135,6 @@ Sanjoy Das <sanjoy@playingwithpointers.com>
Seo Sanghyeon <sanxiyn@gmail.com>
Stefan Penner <stefan.penner@gmail.com>
Sylvestre Ledru <sledru@mozilla.com>
Taketoshi Aono <brn@b6n.ch>
Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Tobias Burnus <burnus@net-b.de>
Victor Costan <costan@gmail.com>

4
src/bootstrapper.cc
View File

@ -1506,9 +1506,9 @@ void Genesis::InitializeGlobal(Handle<JSGlobalObject> global_object,
object_function, "keys", Builtins::kObjectKeys, 1, true);
native_context()->set_object_keys(*object_keys);
SimpleInstallFunction(object_function, factory->entries_string(),
Builtins::kObjectEntries, 1, true);
Builtins::kObjectEntries, 1, false);
SimpleInstallFunction(object_function, factory->values_string(),
Builtins::kObjectValues, 1, true);
Builtins::kObjectValues, 1, false);
SimpleInstallFunction(isolate->initial_object_prototype(),
"__defineGetter__", Builtins::kObjectDefineGetter, 2,

4
src/builtins/builtins-definitions.h
View File

@ -754,7 +754,7 @@ namespace internal {
CPP(ObjectDefineProperties) \
CPP(ObjectDefineProperty) \
CPP(ObjectDefineSetter) \
TFJ(ObjectEntries, 1, kObject) \
CPP(ObjectEntries) \
CPP(ObjectFreeze) \
TFJ(ObjectGetOwnPropertyDescriptor, \
SharedFunctionInfo::kDontAdaptArgumentsSentinel) \
@ -784,7 +784,7 @@ namespace internal {
/* ES #sec-object.prototype.tolocalestring */ \
TFJ(ObjectPrototypeToLocaleString, 0) \
CPP(ObjectSeal) \
TFJ(ObjectValues, 1, kObject) \
CPP(ObjectValues) \
\
/* instanceof */ \
TFC(OrdinaryHasInstance, Compare, 1) \

301
src/builtins/builtins-object-gen.cc
View File

@ -16,8 +16,6 @@ namespace internal {
// ES6 section 19.1 Object Objects
typedef compiler::Node Node;
template <class T>
using TNode = CodeStubAssembler::TNode<T>;
class ObjectBuiltinsAssembler : public CodeStubAssembler {
public:
@ -36,46 +34,6 @@ class ObjectBuiltinsAssembler : public CodeStubAssembler {
Node* ConstructDataDescriptor(Node* context, Node* value, Node* writable,
Node* enumerable, Node* configurable);
Node* GetAccessorOrUndefined(Node* accessor, Label* if_bailout);
Node* IsSpecialReceiverMap(SloppyTNode<Map> map);
};
class ObjectEntriesValuesBuiltinsAssembler : public ObjectBuiltinsAssembler {
public:
explicit ObjectEntriesValuesBuiltinsAssembler(
compiler::CodeAssemblerState* state)
: ObjectBuiltinsAssembler(state) {}
protected:
enum CollectType { kEntries, kValues };
TNode<Word32T> IsStringWrapperElementsKind(TNode<Map> map);
TNode<BoolT> IsPropertyEnumerable(TNode<Uint32T> details);
TNode<BoolT> IsPropertyKindAccessor(TNode<Uint32T> kind);
TNode<BoolT> IsPropertyKindData(TNode<Uint32T> kind);
TNode<Uint32T> HasHiddenPrototype(TNode<Map> map);
TNode<Uint32T> LoadPropertyKind(TNode<Uint32T> details) {
return DecodeWord32<PropertyDetails::KindField>(details);
}
void GetOwnValuesOrEntries(TNode<Context> context, TNode<Object> maybe_object,
CollectType collect_type);
void GotoIfMapHasSlowProperties(TNode<Map> map, Label* if_slow);
TNode<JSArray> FastGetOwnValuesOrEntries(
TNode<Context> context, TNode<JSObject> object,
Label* if_call_runtime_with_fast_path, Label* if_no_properties,
CollectType collect_type);
TNode<JSArray> FinalizeValuesOrEntriesJSArray(
TNode<Context> context, TNode<FixedArray> values_or_entries,
TNode<IntPtrT> size, TNode<Map> array_map, Label* if_empty);
};
void ObjectBuiltinsAssembler::ReturnToStringFormat(Node* context,
@ -139,249 +97,6 @@ Node* ObjectBuiltinsAssembler::ConstructDataDescriptor(Node* context,
return js_desc;
}
Node* ObjectBuiltinsAssembler::IsSpecialReceiverMap(SloppyTNode<Map> map) {
CSA_SLOW_ASSERT(this, IsMap(map));
Node* is_special = IsSpecialReceiverInstanceType(LoadMapInstanceType(map));
uint32_t mask =
Map::HasNamedInterceptorBit::kMask | Map::IsAccessCheckNeededBit::kMask;
USE(mask);
// Interceptors or access checks imply special receiver.
CSA_ASSERT(this,
SelectConstant(IsSetWord32(LoadMapBitField(map), mask), is_special,
Int32Constant(1), MachineRepresentation::kWord32));
return is_special;
}
TNode<Word32T>
ObjectEntriesValuesBuiltinsAssembler::IsStringWrapperElementsKind(
TNode<Map> map) {
Node* kind = LoadMapElementsKind(map);
return Word32Or(
Word32Equal(kind, Int32Constant(FAST_STRING_WRAPPER_ELEMENTS)),
Word32Equal(kind, Int32Constant(SLOW_STRING_WRAPPER_ELEMENTS)));
}
TNode<BoolT> ObjectEntriesValuesBuiltinsAssembler::IsPropertyEnumerable(
TNode<Uint32T> details) {
TNode<Uint32T> attributes =
DecodeWord32<PropertyDetails::AttributesField>(details);
return IsNotSetWord32(attributes, PropertyAttributes::DONT_ENUM);
}
TNode<BoolT> ObjectEntriesValuesBuiltinsAssembler::IsPropertyKindAccessor(
TNode<Uint32T> kind) {
return Word32Equal(kind, Int32Constant(PropertyKind::kAccessor));
}
TNode<BoolT> ObjectEntriesValuesBuiltinsAssembler::IsPropertyKindData(
TNode<Uint32T> kind) {
return Word32Equal(kind, Int32Constant(PropertyKind::kData));
}
TNode<Uint32T> ObjectEntriesValuesBuiltinsAssembler::HasHiddenPrototype(
TNode<Map> map) {
TNode<Uint32T> bit_field3 = LoadMapBitField3(map);
return DecodeWord32<Map::HasHiddenPrototypeBit>(bit_field3);
}
void ObjectEntriesValuesBuiltinsAssembler::GetOwnValuesOrEntries(
TNode<Context> context, TNode<Object> maybe_object,
CollectType collect_type) {
TNode<JSObject> object = TNode<JSObject>::UncheckedCast(
CallBuiltin(Builtins::kToObject, context, maybe_object));
Label if_call_runtime_with_fast_path(this, Label::kDeferred),
if_call_runtime(this, Label::kDeferred),
if_no_properties(this, Label::kDeferred);
TNode<Map> map = LoadMap(object);
GotoIfNot(IsJSObjectMap(map), &if_call_runtime);
GotoIfMapHasSlowProperties(map, &if_call_runtime);
TNode<FixedArrayBase> elements = LoadElements(object);
// If the object has elements, we treat it as slow case.
// So, we go to runtime call.
GotoIfNot(IsEmptyFixedArray(elements), &if_call_runtime_with_fast_path);
TNode<JSArray> result = FastGetOwnValuesOrEntries(
context, object, &if_call_runtime_with_fast_path, &if_no_properties,
collect_type);
Return(result);
BIND(&if_no_properties);
{
Node* native_context = LoadNativeContext(context);
Node* array_map = LoadJSArrayElementsMap(PACKED_ELEMENTS, native_context);
Node* empty_array = AllocateJSArray(PACKED_ELEMENTS, array_map,
IntPtrConstant(0), SmiConstant(0));
Return(empty_array);
}
BIND(&if_call_runtime_with_fast_path);
{
// In slow case, we simply call runtime.
if (collect_type == CollectType::kEntries) {
Return(CallRuntime(Runtime::kObjectEntries, context, object));
} else {
DCHECK(collect_type == CollectType::kValues);
Return(CallRuntime(Runtime::kObjectValues, context, object));
}
}
BIND(&if_call_runtime);
{
// In slow case, we simply call runtime.
if (collect_type == CollectType::kEntries) {
Return(CallRuntime(Runtime::kObjectEntriesSkipFastPath, context, object));
} else {
DCHECK(collect_type == CollectType::kValues);
Return(CallRuntime(Runtime::kObjectValuesSkipFastPath, context, object));
}
}
}
void ObjectEntriesValuesBuiltinsAssembler::GotoIfMapHasSlowProperties(
TNode<Map> map, Label* if_slow) {
GotoIf(IsStringWrapperElementsKind(map), if_slow);
GotoIf(IsSpecialReceiverMap(map), if_slow);
GotoIf(HasHiddenPrototype(map), if_slow);
GotoIf(IsDictionaryMap(map), if_slow);
}
TNode<JSArray> ObjectEntriesValuesBuiltinsAssembler::FastGetOwnValuesOrEntries(
TNode<Context> context, TNode<JSObject> object,
Label* if_call_runtime_with_fast_path, Label* if_no_properties,
CollectType collect_type) {
Node* native_context = LoadNativeContext(context);
TNode<Map> array_map =
LoadJSArrayElementsMap(PACKED_ELEMENTS, native_context);
TNode<Map> map = LoadMap(object);
TNode<Uint32T> bit_field3 = LoadMapBitField3(map);
Label if_has_enum_cache(this), if_not_has_enum_cache(this),
collect_entries(this);
Node* object_enum_length =
DecodeWordFromWord32<Map::EnumLengthBits>(bit_field3);
Node* has_enum_cache = WordNotEqual(
object_enum_length, IntPtrConstant(kInvalidEnumCacheSentinel));
// In case, we found enum_cache in object,
// we use it as array_length becuase it has same size for
// Object.(entries/values) result array object length.
// So object_enum_length use less memory space than
// NumberOfOwnDescriptorsBits value.
// And in case, if enum_cache_not_found,
// we call runtime and initialize enum_cache for subsequent call of
// CSA fast path.
Branch(has_enum_cache, &if_has_enum_cache, if_call_runtime_with_fast_path);
BIND(&if_has_enum_cache);
{
GotoIf(WordEqual(object_enum_length, IntPtrConstant(0)), if_no_properties);
TNode<FixedArray> values_or_entries = TNode<FixedArray>::UncheckedCast(
AllocateFixedArray(PACKED_ELEMENTS, object_enum_length,
INTPTR_PARAMETERS, kAllowLargeObjectAllocation));
// If in case we have enum_cache,
// we can't detect accessor of object until loop through descritpros.
// So if object might have accessor,
// we will remain invalid addresses of FixedArray.
// Because in that case, we need to jump to runtime call.
// So the array filled by the-hole even if enum_cache exists.
FillFixedArrayWithValue(PACKED_ELEMENTS, values_or_entries,
IntPtrConstant(0), object_enum_length,
Heap::kTheHoleValueRootIndex);
TVARIABLE(IntPtrT, var_result_index, IntPtrConstant(0));
TVARIABLE(IntPtrT, var_descriptor_index, IntPtrConstant(0));
Variable* vars[] = {&var_descriptor_index, &var_result_index};
// Let desc be ? O.[[GetOwnProperty]](key).
TNode<DescriptorArray> descriptors = LoadMapDescriptors(map);
Label loop(this, 2, vars), after_loop(this), loop_condition(this);
Branch(IntPtrEqual(var_descriptor_index, object_enum_length), &after_loop,
&loop);
// We dont use BuildFastLoop.
// Instead, we use hand-written loop
// because of we need to use 'continue' functionality.
BIND(&loop);
{
// Currently, we will not invoke getters,
// so, map will not be changed.
CSA_ASSERT(this, WordEqual(map, LoadMap(object)));
TNode<Uint32T> descriptor_index = TNode<Uint32T>::UncheckedCast(
TruncateWordToWord32(var_descriptor_index));
Node* next_key = DescriptorArrayGetKey(descriptors, descriptor_index);
// Skip Symbols.
GotoIf(IsSymbol(next_key), &loop_condition);
TNode<Uint32T> details = TNode<Uint32T>::UncheckedCast(
DescriptorArrayGetDetails(descriptors, descriptor_index));
TNode<Uint32T> kind = LoadPropertyKind(details);
// If property is accessor, we escape fast path and call runtime.
GotoIf(IsPropertyKindAccessor(kind), if_call_runtime_with_fast_path);
CSA_ASSERT(this, IsPropertyKindData(kind));
// If desc is not undefined and desc.[[Enumerable]] is true, then
GotoIfNot(IsPropertyEnumerable(details), &loop_condition);
VARIABLE(var_property_value, MachineRepresentation::kTagged,
UndefinedConstant());
Node* descriptor_name_index = DescriptorNumberToIndex(descriptor_index);
// Let value be ? Get(O, key).
LoadPropertyFromFastObject(object, map, descriptors,
descriptor_name_index, details,
&var_property_value);
// If kind is "value", append value to properties.
Node* value = var_property_value.value();
if (collect_type == CollectType::kEntries) {
// Let entry be CreateArrayFromList(« key, value »).
Node* array = nullptr;
Node* elements = nullptr;
std::tie(array, elements) = AllocateUninitializedJSArrayWithElements(
PACKED_ELEMENTS, array_map, SmiConstant(2), nullptr,
IntPtrConstant(2));
StoreFixedArrayElement(elements, 0, next_key, SKIP_WRITE_BARRIER);
StoreFixedArrayElement(elements, 1, value, SKIP_WRITE_BARRIER);
value = array;
}
StoreFixedArrayElement(values_or_entries, var_result_index, value);
Increment(&var_result_index, 1);
Goto(&loop_condition);
BIND(&loop_condition);
{
Increment(&var_descriptor_index, 1);
Branch(IntPtrEqual(var_descriptor_index, object_enum_length),
&after_loop, &loop);
}
}
BIND(&after_loop);
return FinalizeValuesOrEntriesJSArray(context, values_or_entries,
var_result_index, array_map,
if_no_properties);
}
}
TNode<JSArray>
ObjectEntriesValuesBuiltinsAssembler::FinalizeValuesOrEntriesJSArray(
TNode<Context> context, TNode<FixedArray> result, TNode<IntPtrT> size,
TNode<Map> array_map, Label* if_empty) {
CSA_ASSERT(this, IsJSArrayMap(array_map));
GotoIf(IntPtrEqual(size, IntPtrConstant(0)), if_empty);
Node* array = AllocateUninitializedJSArrayWithoutElements(
array_map, SmiTag(size), nullptr);
StoreObjectField(array, JSArray::kElementsOffset, result);
return TNode<JSArray>::UncheckedCast(array);
}
TF_BUILTIN(ObjectPrototypeToLocaleString, CodeStubAssembler) {
TNode<Context> context = CAST(Parameter(Descriptor::kContext));
TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
@ -553,22 +268,6 @@ TF_BUILTIN(ObjectKeys, ObjectBuiltinsAssembler) {
}
}
TF_BUILTIN(ObjectValues, ObjectEntriesValuesBuiltinsAssembler) {
TNode<JSObject> object =
TNode<JSObject>::UncheckedCast(Parameter(Descriptor::kObject));
TNode<Context> context =
TNode<Context>::UncheckedCast(Parameter(Descriptor::kContext));
GetOwnValuesOrEntries(context, object, CollectType::kValues);
}
TF_BUILTIN(ObjectEntries, ObjectEntriesValuesBuiltinsAssembler) {
TNode<JSObject> object =
TNode<JSObject>::UncheckedCast(Parameter(Descriptor::kObject));
TNode<Context> context =
TNode<Context>::UncheckedCast(Parameter(Descriptor::kContext));
GetOwnValuesOrEntries(context, object, CollectType::kEntries);
}
// ES #sec-object.prototype.isprototypeof
TF_BUILTIN(ObjectPrototypeIsPrototypeOf, ObjectBuiltinsAssembler) {
Node* receiver = Parameter(Descriptor::kReceiver);

25
src/builtins/builtins-object.cc
View File

@ -395,6 +395,31 @@ BUILTIN(ObjectIsSealed) {
return isolate->heap()->ToBoolean(result.FromJust());
}
BUILTIN(ObjectValues) {
HandleScope scope(isolate);
Handle<Object> object = args.atOrUndefined(isolate, 1);
Handle<JSReceiver> receiver;
ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, receiver,
Object::ToObject(isolate, object));
Handle<FixedArray> values;
ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
isolate, values, JSReceiver::GetOwnValues(receiver, ENUMERABLE_STRINGS));
return *isolate->factory()->NewJSArrayWithElements(values);
}
BUILTIN(ObjectEntries) {
HandleScope scope(isolate);
Handle<Object> object = args.atOrUndefined(isolate, 1);
Handle<JSReceiver> receiver;
ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, receiver,
Object::ToObject(isolate, object));
Handle<FixedArray> entries;
ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
isolate, entries,
JSReceiver::GetOwnEntries(receiver, ENUMERABLE_STRINGS));
return *isolate->factory()->NewJSArrayWithElements(entries);
}
BUILTIN(ObjectGetOwnPropertyDescriptors) {
HandleScope scope(isolate);
Handle<Object> object = args.atOrUndefined(isolate, 1);

59
src/code-stub-assembler.cc
View File

@ -4019,6 +4019,19 @@ Node* CodeStubAssembler::InstanceTypeEqual(Node* instance_type, int type) {
return Word32Equal(instance_type, Int32Constant(type));
}
Node* CodeStubAssembler::IsSpecialReceiverMap(Node* map) {
CSA_SLOW_ASSERT(this, IsMap(map));
Node* is_special = IsSpecialReceiverInstanceType(LoadMapInstanceType(map));
uint32_t mask =
Map::HasNamedInterceptorBit::kMask | Map::IsAccessCheckNeededBit::kMask;
USE(mask);
// Interceptors or access checks imply special receiver.
CSA_ASSERT(this,
SelectConstant(IsSetWord32(LoadMapBitField(map), mask), is_special,
Int32Constant(1), MachineRepresentation::kWord32));
return is_special;
}
TNode<BoolT> CodeStubAssembler::IsDictionaryMap(SloppyTNode<Map> map) {
CSA_SLOW_ASSERT(this, IsMap(map));
Node* bit_field3 = LoadMapBitField3(map);
@ -6367,38 +6380,36 @@ Node* CodeStubAssembler::DescriptorArrayNumberOfEntries(Node* descriptors) {
descriptors, IntPtrConstant(DescriptorArray::kDescriptorLengthIndex));
}
Node* CodeStubAssembler::DescriptorNumberToIndex(
SloppyTNode<Uint32T> descriptor_number) {
Node* descriptor_size = Int32Constant(DescriptorArray::kEntrySize);
Node* index = Int32Mul(descriptor_number, descriptor_size);
return ChangeInt32ToIntPtr(index);
namespace {
Node* DescriptorNumberToIndex(CodeStubAssembler* a, Node* descriptor_number) {
Node* descriptor_size = a->Int32Constant(DescriptorArray::kEntrySize);
Node* index = a->Int32Mul(descriptor_number, descriptor_size);
return a->ChangeInt32ToIntPtr(index);
}
} // namespace
Node* CodeStubAssembler::DescriptorArrayToKeyIndex(Node* descriptor_number) {
return IntPtrAdd(IntPtrConstant(DescriptorArray::ToKeyIndex(0)),
DescriptorNumberToIndex(descriptor_number));
DescriptorNumberToIndex(this, descriptor_number));
}
Node* CodeStubAssembler::DescriptorArrayGetSortedKeyIndex(
Node* descriptors, Node* descriptor_number) {
Node* details = DescriptorArrayGetDetails(
TNode<DescriptorArray>::UncheckedCast(descriptors),
TNode<Uint32T>::UncheckedCast(descriptor_number));
const int details_offset = DescriptorArray::ToDetailsIndex(0) * kPointerSize;
Node* details = LoadAndUntagToWord32FixedArrayElement(
descriptors, DescriptorNumberToIndex(this, descriptor_number),
details_offset);
return DecodeWord32<PropertyDetails::DescriptorPointer>(details);
}
Node* CodeStubAssembler::DescriptorArrayGetKey(Node* descriptors,
Node* descriptor_number) {
const int key_offset = DescriptorArray::ToKeyIndex(0) * kPointerSize;
return LoadFixedArrayElement(
descriptors, DescriptorNumberToIndex(descriptor_number), key_offset);
}
TNode<Uint32T> CodeStubAssembler::DescriptorArrayGetDetails(
TNode<DescriptorArray> descriptors, TNode<Uint32T> descriptor_number) {
const int details_offset = DescriptorArray::ToDetailsIndex(0) * kPointerSize;
return TNode<Uint32T>::UncheckedCast(LoadAndUntagToWord32FixedArrayElement(
descriptors, DescriptorNumberToIndex(descriptor_number), details_offset));
return LoadFixedArrayElement(descriptors,
DescriptorNumberToIndex(this, descriptor_number),
key_offset);
}
void CodeStubAssembler::DescriptorLookupBinary(Node* unique_name,
@ -6597,22 +6608,12 @@ void CodeStubAssembler::LoadPropertyFromFastObject(Node* object, Node* map,
Variable* var_value) {
DCHECK_EQ(MachineRepresentation::kWord32, var_details->rep());
DCHECK_EQ(MachineRepresentation::kTagged, var_value->rep());
Comment("[ LoadPropertyFromFastObject");
Node* details =
LoadDetailsByKeyIndex<DescriptorArray>(descriptors, name_index);
var_details->Bind(details);
LoadPropertyFromFastObject(object, map, descriptors, name_index, details,
var_value);
}
void CodeStubAssembler::LoadPropertyFromFastObject(Node* object, Node* map,
Node* descriptors,
Node* name_index,
Node* details,
Variable* var_value) {
Comment("[ LoadPropertyFromFastObject");
Node* location = DecodeWord32<PropertyDetails::LocationField>(details);
Label if_in_field(this), if_in_descriptor(this), done(this);

9
src/code-stub-assembler.h
View File

@ -1114,6 +1114,7 @@ class V8_EXPORT_PRIVATE CodeStubAssembler : public compiler::CodeAssembler {
Node* IsSequentialStringInstanceType(Node* instance_type);
Node* IsShortExternalStringInstanceType(Node* instance_type);
Node* IsSpecialReceiverInstanceType(Node* instance_type);
Node* IsSpecialReceiverMap(Node* map);
Node* IsSpeciesProtectorCellInvalid();
Node* IsStringInstanceType(Node* instance_type);
Node* IsString(Node* object);
@ -1571,10 +1572,6 @@ class V8_EXPORT_PRIVATE CodeStubAssembler : public compiler::CodeAssembler {
Node* name_index, Variable* var_details,
Variable* var_value);
void LoadPropertyFromFastObject(Node* object, Node* map, Node* descriptors,
Node* name_index, Node* details,
Variable* var_value);
void LoadPropertyFromNameDictionary(Node* dictionary, Node* entry,
Variable* var_details,
Variable* var_value);
@ -1897,15 +1894,11 @@ class V8_EXPORT_PRIVATE CodeStubAssembler : public compiler::CodeAssembler {
void DescriptorLookupBinary(Node* unique_name, Node* descriptors, Node* nof,
Label* if_found, Variable* var_name_index,
Label* if_not_found);
Node* DescriptorNumberToIndex(SloppyTNode<Uint32T> descriptor_number);
// Implements DescriptorArray::ToKeyIndex.
// Returns an untagged IntPtr.
Node* DescriptorArrayToKeyIndex(Node* descriptor_number);
// Implements DescriptorArray::GetKey.
Node* DescriptorArrayGetKey(Node* descriptors, Node* descriptor_number);
// Implements DescriptorArray::GetKey.
TNode<Uint32T> DescriptorArrayGetDetails(TNode<DescriptorArray> descriptors,
TNode<Uint32T> descriptor_number);
Node* CallGetterIfAccessor(Node* value, Node* details, Node* context,
Node* receiver, Label* if_bailout,

15
src/objects.cc
View File

@ -8791,10 +8791,9 @@ MUST_USE_RESULT Maybe<bool> FastGetOwnValuesOrEntries(
MaybeHandle<FixedArray> GetOwnValuesOrEntries(Isolate* isolate,
Handle<JSReceiver> object,
PropertyFilter filter,
bool try_fast_path,
bool get_entries) {
Handle<FixedArray> values_or_entries;
if (try_fast_path && filter == ENUMERABLE_STRINGS) {
if (filter == ENUMERABLE_STRINGS) {
Maybe<bool> fast_values_or_entries = FastGetOwnValuesOrEntries(
isolate, object, get_entries, &values_or_entries);
if (fast_values_or_entries.IsNothing()) return MaybeHandle<FixedArray>();
@ -8847,17 +8846,13 @@ MaybeHandle<FixedArray> GetOwnValuesOrEntries(Isolate* isolate,
}
MaybeHandle<FixedArray> JSReceiver::GetOwnValues(Handle<JSReceiver> object,
PropertyFilter filter,
bool try_fast_path) {
return GetOwnValuesOrEntries(object->GetIsolate(), object, filter,
try_fast_path, false);
PropertyFilter filter) {
return GetOwnValuesOrEntries(object->GetIsolate(), object, filter, false);
}
MaybeHandle<FixedArray> JSReceiver::GetOwnEntries(Handle<JSReceiver> object,
PropertyFilter filter,
bool try_fast_path) {
return GetOwnValuesOrEntries(object->GetIsolate(), object, filter,
try_fast_path, true);
PropertyFilter filter) {
return GetOwnValuesOrEntries(object->GetIsolate(), object, filter, true);
}
bool Map::DictionaryElementsInPrototypeChainOnly() {

6
src/objects.h
View File

@ -2182,12 +2182,10 @@ class JSReceiver: public HeapObject {
Handle<JSReceiver> object);
MUST_USE_RESULT static MaybeHandle<FixedArray> GetOwnValues(
Handle<JSReceiver> object, PropertyFilter filter,
bool try_fast_path = true);
Handle<JSReceiver> object, PropertyFilter filter);
MUST_USE_RESULT static MaybeHandle<FixedArray> GetOwnEntries(
Handle<JSReceiver> object, PropertyFilter filter,
bool try_fast_path = true);
Handle<JSReceiver> object, PropertyFilter filter);
static const int kHashMask = PropertyArray::HashField::kMask;

55
src/runtime/runtime-object.cc
View File

@ -439,61 +439,6 @@ RUNTIME_FUNCTION(Runtime_OptimizeObjectForAddingMultipleProperties) {
return *object;
}
RUNTIME_FUNCTION(Runtime_ObjectValues) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
CONVERT_ARG_HANDLE_CHECKED(JSReceiver, receiver, 0);
Handle<FixedArray> values;
ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
isolate, values,
JSReceiver::GetOwnValues(receiver, PropertyFilter::ENUMERABLE_STRINGS,
true));
return *isolate->factory()->NewJSArrayWithElements(values);
}
RUNTIME_FUNCTION(Runtime_ObjectValuesSkipFastPath) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
CONVERT_ARG_HANDLE_CHECKED(JSReceiver, receiver, 0);
Handle<FixedArray> value;
ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
isolate, value,
JSReceiver::GetOwnValues(receiver, PropertyFilter::ENUMERABLE_STRINGS,
false));
return *isolate->factory()->NewJSArrayWithElements(value);
}
RUNTIME_FUNCTION(Runtime_ObjectEntries) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
CONVERT_ARG_HANDLE_CHECKED(JSReceiver, receiver, 0);
Handle<FixedArray> entries;
ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
isolate, entries,
JSReceiver::GetOwnEntries(receiver, PropertyFilter::ENUMERABLE_STRINGS,
true));
return *isolate->factory()->NewJSArrayWithElements(entries);
}
RUNTIME_FUNCTION(Runtime_ObjectEntriesSkipFastPath) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
CONVERT_ARG_HANDLE_CHECKED(JSReceiver, receiver, 0);
Handle<FixedArray> entries;
ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
isolate, entries,
JSReceiver::GetOwnEntries(receiver, PropertyFilter::ENUMERABLE_STRINGS,
false));
return *isolate->factory()->NewJSArrayWithElements(entries);
}
RUNTIME_FUNCTION(Runtime_GetProperty) {
HandleScope scope(isolate);

4
src/runtime/runtime.h
View File

@ -392,10 +392,6 @@ namespace internal {
F(ObjectCreate, 2, 1) \
F(InternalSetPrototype, 2, 1) \
F(OptimizeObjectForAddingMultipleProperties, 2, 1) \
F(ObjectValues, 1, 1) \
F(ObjectValuesSkipFastPath, 1, 1) \
F(ObjectEntries, 1, 1) \
F(ObjectEntriesSkipFastPath, 1, 1) \
F(GetProperty, 2, 1) \
F(KeyedGetProperty, 2, 1) \
F(AddNamedProperty, 4, 1) \