Skip to content

V
V8
Commit 1f1e4cdb authored by Mythri A's avatar Mythri A Committed by Commit Bot
Browse files
Options

[cleanpup][ic] Tnodify accessor-assembler 

Bug: v8:9810
Change-Id: I30c6265904c43ec86abc91a28d789fe5bfb22694
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1910106
Commit-Queue: Mythri Alle <mythria@chromium.org>
Reviewed-by: 's avatarSantiago Aboy Solanes <solanes@chromium.org>
Reviewed-by: 's avatarIgor Sheludko <ishell@chromium.org>
Cr-Commit-Position: refs/heads/master@{#64934}
parent 53201194
Hide whitespace changes
Inline Side-by-side
Showing with 319 additions and 304 deletions
src/ic/accessor-assembler.cc
View file @ 1f1e4cdb
......@@ -30,7 +30,7 @@ using compiler::Node;
// Loads dataX field from the DataHandler object.
TNode<MaybeObject> AccessorAssembler::LoadHandlerDataField(
SloppyTNode<DataHandler> handler, int data_index) {
TNode<DataHandler> handler, int data_index) {
#ifdef DEBUG
TNode<Map> handler_map = LoadMap(handler);
TNode<Uint16T> instance_type = LoadMapInstanceType(handler_map);
......@@ -139,8 +139,8 @@ void AccessorAssembler::HandleLoadICHandlerCase(
ElementSupport support_elements, LoadAccessMode access_mode) {
Comment("have_handler");
VARIABLE(var_holder, MachineRepresentation::kTagged, p->holder());
VARIABLE(var_smi_handler, MachineRepresentation::kTagged, handler);
TVARIABLE(Object, var_holder, p->holder());
TVARIABLE(Object, var_smi_handler, handler);
Variable* vars[] = {&var_holder, &var_smi_handler};
Label if_smi_handler(this, 2, vars);
......@@ -161,14 +161,14 @@ void AccessorAssembler::HandleLoadICHandlerCase(
// for the encoding format.
BIND(&if_smi_handler);
{
HandleLoadICSmiHandlerCase(p, var_holder.value(), var_smi_handler.value(),
handler, miss, exit_point, ic_mode,
on_nonexistent, support_elements, access_mode);
HandleLoadICSmiHandlerCase(
p, var_holder.value(), CAST(var_smi_handler.value()), handler, miss,
exit_point, ic_mode, on_nonexistent, support_elements, access_mode);
}
BIND(&call_handler);
{
exit_point->ReturnCallStub(LoadWithVectorDescriptor{}, handler,
exit_point->ReturnCallStub(LoadWithVectorDescriptor{}, CAST(handler),
p->context(), p->receiver(), p->name(),
p->slot(), p->vector());
}
......@@ -212,7 +212,7 @@ void AccessorAssembler::HandleLoadAccessor(
TNode<Object> data =
LoadObjectField(call_handler_info, CallHandlerInfo::kDataOffset);
VARIABLE(api_holder, MachineRepresentation::kTagged, p->receiver());
TVARIABLE(HeapObject, api_holder, CAST(p->receiver()));
Label load(this);
GotoIf(WordEqual(handler_kind, IntPtrConstant(LoadHandler::kApiGetter)),
&load);
......@@ -222,7 +222,7 @@ void AccessorAssembler::HandleLoadAccessor(
WordEqual(handler_kind,
IntPtrConstant(LoadHandler::kApiGetterHolderIsPrototype)));
api_holder.Bind(LoadMapPrototype(LoadMap(p->receiver())));
api_holder = LoadMapPrototype(LoadMap(CAST(p->receiver())));
Goto(&load);
BIND(&load);
......@@ -232,7 +232,7 @@ void AccessorAssembler::HandleLoadAccessor(
api_holder.value(), p->receiver()));
}
void AccessorAssembler::HandleLoadField(SloppyTNode<JSObject> holder,
void AccessorAssembler::HandleLoadField(TNode<JSObject> holder,
TNode<WordT> handler_word,
Variable* var_double_value,
Label* rebox_double, Label* miss,
......@@ -301,11 +301,11 @@ TNode<MaybeObject> AccessorAssembler::LoadDescriptorValueOrFieldType(
}
void AccessorAssembler::HandleLoadICSmiHandlerCase(
const LazyLoadICParameters* p, SloppyTNode<HeapObject> holder,
SloppyTNode<Smi> smi_handler, SloppyTNode<Object> handler, Label* miss,
ExitPoint* exit_point, ICMode ic_mode, OnNonExistent on_nonexistent,
ElementSupport support_elements, LoadAccessMode access_mode) {
VARIABLE(var_double_value, MachineRepresentation::kFloat64);
const LazyLoadICParameters* p, TNode<Object> holder, TNode<Smi> smi_handler,
TNode<Object> handler, Label* miss, ExitPoint* exit_point, ICMode ic_mode,
OnNonExistent on_nonexistent, ElementSupport support_elements,
LoadAccessMode access_mode) {
TVARIABLE(Float64T, var_double_value);
Label rebox_double(this, &var_double_value);
TNode<IntPtrT> handler_word = SmiUntag(smi_handler);
......@@ -363,7 +363,7 @@ void AccessorAssembler::HandleLoadICSmiHandlerCase(
IsSetWord<LoadHandler::IsJsArrayBits>(handler_word);
TNode<Uint32T> elements_kind =
DecodeWord32FromWord<LoadHandler::ElementsKindBits>(handler_word);
EmitElementLoad(holder, elements_kind, var_intptr_index.value(),
EmitElementLoad(CAST(holder), elements_kind, var_intptr_index.value(),
is_jsarray_condition, &if_hole, &rebox_double,
&var_double_value, &unimplemented_elements_kind,
&if_oob, miss, exit_point, access_mode);
......@@ -393,12 +393,12 @@ void AccessorAssembler::HandleLoadICSmiHandlerCase(
// in V8, not elements. So we cannot handle them here, except
// in case of typed arrays, where integer indexed properties
// aren't looked up in the prototype chain.
GotoIf(IsJSTypedArray(holder), &return_undefined);
GotoIf(IsJSTypedArray(CAST(holder)), &return_undefined);
GotoIf(IntPtrLessThan(var_intptr_index.value(), IntPtrConstant(0)), miss);
// For all other receivers we need to check that the prototype chain
// doesn't contain any elements.
BranchIfPrototypesHaveNoElements(LoadMap(holder), &return_undefined,
BranchIfPrototypesHaveNoElements(LoadMap(CAST(holder)), &return_undefined,
miss);
BIND(&return_undefined);
......@@ -457,9 +457,9 @@ void AccessorAssembler::HandleLoadICSmiHandlerCase(
}
void AccessorAssembler::HandleLoadICSmiHandlerLoadNamedCase(
const LazyLoadICParameters* p, TNode<HeapObject> holder,
const LazyLoadICParameters* p, TNode<Object> holder,
TNode<IntPtrT> handler_kind, TNode<WordT> handler_word, Label* rebox_double,
Variable* var_double_value, SloppyTNode<Object> handler, Label* miss,
Variable* var_double_value, TNode<Object> handler, Label* miss,
ExitPoint* exit_point, ICMode ic_mode, OnNonExistent on_nonexistent,
ElementSupport support_elements) {
Label constant(this), field(this), normal(this, Label::kDeferred),
......@@ -536,8 +536,8 @@ void AccessorAssembler::HandleLoadICSmiHandlerLoadNamedCase(
&var_name_index, miss);
BIND(&found);
{
VARIABLE(var_details, MachineRepresentation::kWord32);
VARIABLE(var_value, MachineRepresentation::kTagged);
TVARIABLE(Uint32T, var_details);
TVARIABLE(Object, var_value);
LoadPropertyFromNameDictionary(properties, var_name_index.value(),
&var_details, &var_value);
TNode<Object> value =
......@@ -553,7 +553,7 @@ void AccessorAssembler::HandleLoadICSmiHandlerLoadNamedCase(
TNode<IntPtrT> descriptor =
Signed(DecodeWord<LoadHandler::DescriptorBits>(handler_word));
TNode<AccessorPair> accessor_pair =
CAST(LoadDescriptorValue(LoadMap(holder), descriptor));
CAST(LoadDescriptorValue(LoadMap(CAST(holder)), descriptor));
TNode<Object> getter =
LoadObjectField(accessor_pair, AccessorPair::kGetterOffset);
CSA_ASSERT(this, Word32BinaryNot(IsTheHole(getter)));
......@@ -618,11 +618,12 @@ void AccessorAssembler::HandleLoadICSmiHandlerLoadNamedCase(
BIND(&global);
{
CSA_ASSERT(this, IsPropertyCell(holder));
CSA_ASSERT(this, IsPropertyCell(CAST(holder)));
// Ensure the property cell doesn't contain the hole.
TNode<Object> value = LoadObjectField(holder, PropertyCell::kValueOffset);
TNode<Object> value =
LoadObjectField(CAST(holder), PropertyCell::kValueOffset);
TNode<Int32T> details = LoadAndUntagToWord32ObjectField(
holder, PropertyCell::kPropertyDetailsRawOffset);
CAST(holder), PropertyCell::kPropertyDetailsRawOffset);
GotoIf(IsTheHole(value), miss);
exit_point->Return(CallGetterIfAccessor(value, details, p->context(),
......@@ -654,8 +655,8 @@ void AccessorAssembler::HandleLoadICSmiHandlerLoadNamedCase(
Comment("module export");
TNode<UintPtrT> index =
DecodeWord<LoadHandler::ExportsIndexBits>(handler_word);
TNode<Module> module =
CAST(LoadObjectField(p->receiver(), JSModuleNamespace::kModuleOffset));
TNode<Module> module = CAST(
LoadObjectField(CAST(p->receiver()), JSModuleNamespace::kModuleOffset));
TNode<ObjectHashTable> exports =
LoadObjectField<ObjectHashTable>(module, Module::kExportsOffset);
TNode<Cell> cell = CAST(LoadFixedArrayElement(exports, index));
......@@ -678,7 +679,7 @@ void AccessorAssembler::HandleLoadICSmiHandlerLoadNamedCase(
}
void AccessorAssembler::HandleLoadICSmiHandlerHasNamedCase(
const LazyLoadICParameters* p, TNode<HeapObject> holder,
const LazyLoadICParameters* p, TNode<Object> holder,
TNode<IntPtrT> handler_kind, Label* miss, ExitPoint* exit_point,
ICMode ic_mode) {
Label return_true(this), return_false(this), return_lookup(this),
......@@ -752,9 +753,10 @@ void AccessorAssembler::HandleLoadICSmiHandlerHasNamedCase(
BIND(&global);
{
CSA_ASSERT(this, IsPropertyCell(holder));
CSA_ASSERT(this, IsPropertyCell(CAST(holder)));
// Ensure the property cell doesn't contain the hole.
TNode<Object> value = LoadObjectField(holder, PropertyCell::kValueOffset);
TNode<Object> value =
LoadObjectField(CAST(holder), PropertyCell::kValueOffset);
GotoIf(IsTheHole(value), miss);
exit_point->Return(TrueConstant());
......@@ -847,8 +849,8 @@ TNode<Object> AccessorAssembler::HandleProtoHandler(
CSA_ASSERT(this, IsWeakOrCleared(data2));
TNode<Context> expected_native_context =
CAST(GetHeapObjectAssumeWeak(data2, miss));
EmitAccessCheck(expected_native_context, p->context(),
CAST(p->receiver()), &done, miss);
EmitAccessCheck(expected_native_context, p->context(), p->receiver(),
&done, miss);
}
// Dictionary lookup on receiver is not necessary for Load/StoreGlobalIC
......@@ -858,10 +860,10 @@ TNode<Object> AccessorAssembler::HandleProtoHandler(
{
DCHECK_EQ(ICMode::kNonGlobalIC, ic_mode);
CSA_ASSERT(this, Word32BinaryNot(HasInstanceType(
p->receiver(), JS_GLOBAL_OBJECT_TYPE)));
CAST(p->receiver()), JS_GLOBAL_OBJECT_TYPE)));
TNode<NameDictionary> properties =
CAST(LoadSlowProperties(p->receiver()));
CAST(LoadSlowProperties(CAST(p->receiver())));
TVARIABLE(IntPtrT, var_name_index);
Label found(this, &var_name_index);
NameDictionaryLookup<NameDictionary>(properties, CAST(p->name()),
......@@ -884,12 +886,9 @@ TNode<Object> AccessorAssembler::HandleProtoHandler(
void AccessorAssembler::HandleLoadICProtoHandler(
const LazyLoadICParameters* p, TNode<DataHandler> handler,
Variable* var_holder, Variable* var_smi_handler, Label* if_smi_handler,
Label* miss, ExitPoint* exit_point, ICMode ic_mode,
TVariable<Object>* var_holder, TVariable<Object>* var_smi_handler,
Label* if_smi_handler, Label* miss, ExitPoint* exit_point, ICMode ic_mode,
LoadAccessMode access_mode) {
DCHECK_EQ(MachineRepresentation::kTagged, var_holder->rep());
DCHECK_EQ(MachineRepresentation::kTagged, var_smi_handler->rep());
TNode<Smi> smi_handler = CAST(HandleProtoHandler<LoadHandler>(
p, handler,
// Code sub-handlers are not expected in LoadICs, so no |on_code_handler|.
......@@ -899,8 +898,8 @@ void AccessorAssembler::HandleLoadICProtoHandler(
if (access_mode == LoadAccessMode::kHas) {
exit_point->Return(TrueConstant());
} else {
VARIABLE(var_details, MachineRepresentation::kWord32);
VARIABLE(var_value, MachineRepresentation::kTagged);
TVARIABLE(Uint32T, var_details);
TVARIABLE(Object, var_value);
LoadPropertyFromNameDictionary(properties, name_index, &var_details,
&var_value);
TNode<Object> value =
......@@ -943,13 +942,13 @@ void AccessorAssembler::HandleLoadICProtoHandler(
CSA_ASSERT(this, IsWeakOrCleared(maybe_holder_or_constant));
TNode<HeapObject> holder =
GetHeapObjectAssumeWeak(maybe_holder_or_constant, miss);
var_holder->Bind(holder);
*var_holder = holder;
Goto(&done);
}
BIND(&done);
{
var_smi_handler->Bind(smi_handler);
*var_smi_handler = smi_handler;
Goto(if_smi_handler);
}
}
......@@ -989,7 +988,7 @@ void AccessorAssembler::JumpIfDataProperty(TNode<Uint32T> details,
}
void AccessorAssembler::HandleStoreICNativeDataProperty(
const StoreICParameters* p, SloppyTNode<HeapObject> holder,
const StoreICParameters* p, TNode<HeapObject> holder,
TNode<Word32T> handler_word) {
Comment("native_data_property_store");
TNode<IntPtrT> descriptor =
......@@ -1014,7 +1013,7 @@ void AccessorAssembler::HandleStoreICHandlerCase(
// for the encoding format.
BIND(&if_smi_handler);
{
Node* holder = p->receiver();
TNode<Object> holder = p->receiver();
TNode<Int32T> handler_word = SmiToInt32(CAST(handler));
Label if_fast_smi(this), if_proxy(this), if_interceptor(this),
......@@ -1039,7 +1038,7 @@ void AccessorAssembler::HandleStoreICHandlerCase(
&if_slow);
CSA_ASSERT(this,
Word32Equal(handler_kind, Int32Constant(StoreHandler::kNormal)));
TNode<NameDictionary> properties = CAST(LoadSlowProperties(holder));
TNode<NameDictionary> properties = CAST(LoadSlowProperties(CAST(holder)));
TVARIABLE(IntPtrT, var_name_index);
Label dictionary_found(this, &var_name_index);
......@@ -1073,18 +1072,18 @@ void AccessorAssembler::HandleStoreICHandlerCase(
&native_data_property, &data);
BIND(&accessor);
HandleStoreAccessor(p, holder, handler_word);
HandleStoreAccessor(p, CAST(holder), handler_word);
BIND(&native_data_property);
HandleStoreICNativeDataProperty(p, holder, handler_word);
HandleStoreICNativeDataProperty(p, CAST(holder), handler_word);
BIND(&data);
// Handle non-transitioning field stores.
HandleStoreICSmiHandlerCase(handler_word, holder, p->value(), miss);
HandleStoreICSmiHandlerCase(handler_word, CAST(holder), p->value(), miss);
}
BIND(&if_proxy);
HandleStoreToProxy(p, holder, miss, support_elements);
HandleStoreToProxy(p, CAST(holder), miss, support_elements);
BIND(&if_interceptor);
{
......@@ -1214,15 +1213,15 @@ void AccessorAssembler::HandleStoreICTransitionMapHandlerCase(
BIND(&attributes_ok);
}
OverwriteExistingFastDataProperty(p->receiver(), transition_map, descriptors,
last_key_index, details, p->value(), miss,
true);
OverwriteExistingFastDataProperty(CAST(p->receiver()), transition_map,
descriptors, last_key_index, details,
p->value(), miss, true);
}
void AccessorAssembler::CheckFieldType(TNode<DescriptorArray> descriptors,
TNode<IntPtrT> name_index,
TNode<Word32T> representation,
Node* value, Label* bailout) {
TNode<Object> value, Label* bailout) {
Label r_smi(this), r_double(this), r_heapobject(this), all_fine(this);
// Ignore FLAG_track_fields etc. and always emit code for all checks,
// because this builtin is part of the snapshot and therefore should
......@@ -1246,7 +1245,7 @@ void AccessorAssembler::CheckFieldType(TNode<DescriptorArray> descriptors,
BIND(&r_double);
{
GotoIf(TaggedIsSmi(value), &all_fine);
Branch(IsHeapNumber(value), &all_fine, bailout);
Branch(IsHeapNumber(CAST(value)), &all_fine, bailout);
}
BIND(&r_heapobject);
......@@ -1271,7 +1270,8 @@ void AccessorAssembler::CheckFieldType(TNode<DescriptorArray> descriptors,
TNode<Map> field_type_map =
CAST(GetHeapObjectAssumeWeak(field_type, bailout));
// FieldType::Class(...) performs a map check.
Branch(TaggedEqual(LoadMap(value), field_type_map), &all_fine, bailout);
Branch(TaggedEqual(LoadMap(CAST(value)), field_type_map), &all_fine,
bailout);
}
BIND(&all_fine);
......@@ -1283,7 +1283,7 @@ TNode<BoolT> AccessorAssembler::IsPropertyDetailsConst(TNode<Uint32T> details) {
}
void AccessorAssembler::OverwriteExistingFastDataProperty(
SloppyTNode<HeapObject> object, TNode<Map> object_map,
TNode<HeapObject> object, TNode<Map> object_map,
TNode<DescriptorArray> descriptors, TNode<IntPtrT> descriptor_name_index,
TNode<Uint32T> details, TNode<Object> value, Label* slow,
bool do_transitioning_store) {
......@@ -1386,7 +1386,7 @@ void AccessorAssembler::OverwriteExistingFastDataProperty(
// Allocate mutable heap number before extending properties backing
// store to ensure that heap verifier will not see the heap in
// inconsistent state.
VARIABLE(var_value, MachineRepresentation::kTagged, value);
TVARIABLE(Object, var_value, value);
{
Label cont(this);
GotoIf(Word32NotEqual(representation,
......@@ -1396,14 +1396,14 @@ void AccessorAssembler::OverwriteExistingFastDataProperty(
TNode<Float64T> double_value = ChangeNumberToFloat64(CAST(value));
TNode<HeapNumber> heap_number =
AllocateHeapNumberWithValue(double_value);
var_value.Bind(heap_number);
var_value = heap_number;
Goto(&cont);
}
BIND(&cont);
}
TNode<PropertyArray> properties =
CAST(ExtendPropertiesBackingStore(object, backing_store_index));
ExtendPropertiesBackingStore(object, backing_store_index);
StorePropertyArrayElement(properties, backing_store_index,
var_value.value());
StoreMap(object, object_map);
......@@ -1480,7 +1480,7 @@ void AccessorAssembler::CheckPrototypeValidityCell(
}
void AccessorAssembler::HandleStoreAccessor(const StoreICParameters* p,
SloppyTNode<HeapObject> holder,
TNode<HeapObject> holder,
TNode<Word32T> handler_word) {
Comment("accessor_store");
TNode<IntPtrT> descriptor =
......@@ -1594,7 +1594,7 @@ void AccessorAssembler::HandleStoreICProtoHandler(
CSA_ASSERT(this,
Word32Equal(handler_kind, Int32Constant(StoreHandler::kProxy)));
HandleStoreToProxy(p, holder, miss, support_elements);
HandleStoreToProxy(p, CAST(holder), miss, support_elements);
BIND(&if_slow);
{
......@@ -1626,11 +1626,11 @@ void AccessorAssembler::HandleStoreICProtoHandler(
// case is covered above by LookupOnReceiver bit handling of the smi
// handler.
Label slow(this);
TNode<Map> receiver_map = LoadMap(p->receiver());
TNode<Map> receiver_map = LoadMap(CAST(p->receiver()));
InvalidateValidityCellIfPrototype(receiver_map);
TNode<NameDictionary> properties =
CAST(LoadSlowProperties(p->receiver()));
CAST(LoadSlowProperties(CAST(p->receiver())));
Add<NameDictionary>(properties, CAST(p->name()), p->value(), &slow);
Return(p->value());
......@@ -1649,7 +1649,7 @@ void AccessorAssembler::HandleStoreICProtoHandler(
{
Comment("api_setter");
CSA_ASSERT(this, TaggedIsNotSmi(handler));
Node* call_handler_info = holder;
TNode<CallHandlerInfo> call_handler_info = CAST(holder);
// Context is stored either in data2 or data3 field depending on whether
// the access check is enabled for this handler or not.
......@@ -1663,14 +1663,14 @@ void AccessorAssembler::HandleStoreICProtoHandler(
IsCleared(maybe_context), [=] { return SmiConstant(0); },
[=] { return GetHeapObjectAssumeWeak(maybe_context); });
TNode<Foreign> foreign = CAST(LoadObjectField(
call_handler_info, CallHandlerInfo::kJsCallbackOffset));
Node* callback = LoadObjectField(foreign, Foreign::kForeignAddressOffset,
MachineType::Pointer());
TNode<Foreign> foreign = LoadObjectField<Foreign>(
call_handler_info, CallHandlerInfo::kJsCallbackOffset);
TNode<RawPtrT> callback =
LoadObjectField<RawPtrT>(foreign, Foreign::kForeignAddressOffset);
TNode<Object> data =
LoadObjectField(call_handler_info, CallHandlerInfo::kDataOffset);
VARIABLE(api_holder, MachineRepresentation::kTagged, p->receiver());
TVARIABLE(Object, api_holder, p->receiver());
Label store(this);
GotoIf(Word32Equal(handler_kind, Int32Constant(StoreHandler::kApiSetter)),
&store);
......@@ -1680,7 +1680,7 @@ void AccessorAssembler::HandleStoreICProtoHandler(
handler_kind,
Int32Constant(StoreHandler::kApiSetterHolderIsPrototype)));
api_holder.Bind(LoadMapPrototype(LoadMap(p->receiver())));
api_holder = LoadMapPrototype(LoadMap(CAST(p->receiver())));
Goto(&store);
BIND(&store);
......@@ -1693,13 +1693,14 @@ void AccessorAssembler::HandleStoreICProtoHandler(
BIND(&if_store_global_proxy);
{
ExitPoint direct_exit(this);
StoreGlobalIC_PropertyCellCase(holder, p->value(), &direct_exit, miss);
StoreGlobalIC_PropertyCellCase(CAST(holder), p->value(), &direct_exit,
miss);
}
}
}
void AccessorAssembler::HandleStoreToProxy(const StoreICParameters* p,
Node* proxy, Label* miss,
TNode<JSProxy> proxy, Label* miss,
ElementSupport support_elements) {
TVARIABLE(IntPtrT, var_index);
TVARIABLE(Name, var_unique);
......@@ -1733,9 +1734,10 @@ void AccessorAssembler::HandleStoreToProxy(const StoreICParameters* p,
}
}
void AccessorAssembler::HandleStoreICSmiHandlerCase(
SloppyTNode<Word32T> handler_word, SloppyTNode<JSObject> holder,
SloppyTNode<Object> value, Label* miss) {
void AccessorAssembler::HandleStoreICSmiHandlerCase(TNode<Word32T> handler_word,
TNode<JSObject> holder,
TNode<Object> value,
Label* miss) {
Comment("field store");
#ifdef DEBUG
TNode<Uint32T> handler_kind =
......@@ -1929,21 +1931,20 @@ void AccessorAssembler::HandleStoreFieldAndReturn(
Return(value);
}
Node* AccessorAssembler::ExtendPropertiesBackingStore(Node* object,
Node* index) {
TNode<PropertyArray> AccessorAssembler::ExtendPropertiesBackingStore(
TNode<HeapObject> object, TNode<IntPtrT> index) {
Comment("[ Extend storage");
ParameterMode mode = OptimalParameterMode();
// TODO(gsathya): Clean up the type conversions by creating smarter
// helpers that do the correct op based on the mode.
VARIABLE(var_properties, MachineRepresentation::kTaggedPointer);
VARIABLE(var_encoded_hash, MachineRepresentation::kWord32);
TVARIABLE(HeapObject, var_properties);
TVARIABLE(Int32T, var_encoded_hash);
VARIABLE(var_length, ParameterRepresentation(mode));
TNode<Object> properties =
LoadObjectField(object, JSObject::kPropertiesOrHashOffset);
var_properties.Bind(properties);
Label if_smi_hash(this), if_property_array(this), extend_store(this);
Branch(TaggedIsSmi(properties), &if_smi_hash, &if_property_array);
......@@ -1953,18 +1954,19 @@ Node* AccessorAssembler::ExtendPropertiesBackingStore(Node* object,
TNode<Int32T> hash = SmiToInt32(CAST(properties));
TNode<Int32T> encoded_hash =
Word32Shl(hash, Int32Constant(PropertyArray::HashField::kShift));
var_encoded_hash.Bind(encoded_hash);
var_encoded_hash = encoded_hash;
var_length.Bind(IntPtrOrSmiConstant(0, mode));
var_properties.Bind(EmptyFixedArrayConstant());
var_properties = EmptyFixedArrayConstant();
Goto(&extend_store);
}
BIND(&if_property_array);
{
var_properties = CAST(properties);
TNode<Int32T> length_and_hash_int32 = LoadAndUntagToWord32ObjectField(
var_properties.value(), PropertyArray::kLengthAndHashOffset);
var_encoded_hash.Bind(Word32And(
length_and_hash_int32, Int32Constant(PropertyArray::HashField::kMask)));
var_encoded_hash = Word32And(
length_and_hash_int32, Int32Constant(PropertyArray::HashField::kMask));
TNode<IntPtrT> length_intptr = ChangeInt32ToIntPtr(
Word32And(length_and_hash_int32,
Int32Constant(PropertyArray::LengthField::kMask)));
......@@ -1975,8 +1977,7 @@ Node* AccessorAssembler::ExtendPropertiesBackingStore(Node* object,
BIND(&extend_store);
{
VARIABLE(var_new_properties, MachineRepresentation::kTaggedPointer,
var_properties.value());
TVARIABLE(HeapObject, var_new_properties, var_properties.value());
Label done(this);
// Previous property deletion could have left behind unused backing store
// capacity even for a map that think it doesn't have any unused fields.
......@@ -1999,8 +2000,9 @@ Node* AccessorAssembler::ExtendPropertiesBackingStore(Node* object,
kMaxNumberOfDescriptors + JSObject::kFieldsAdded, mode),
mode));
Node* new_properties = AllocatePropertyArray(new_capacity, mode);
var_new_properties.Bind(new_properties);
TNode<PropertyArray> new_properties =
CAST(AllocatePropertyArray(new_capacity, mode));
var_new_properties = new_properties;
FillPropertyArrayWithUndefined(new_properties, var_length.value(),
new_capacity, mode);
......@@ -2016,33 +2018,32 @@ Node* AccessorAssembler::ExtendPropertiesBackingStore(Node* object,
TNode<Int32T> new_capacity_int32 =
TruncateIntPtrToInt32(ParameterToIntPtr(new_capacity, mode));
TNode<Int32T> new_length_and_hash_int32 =
Signed(Word32Or(var_encoded_hash.value(), new_capacity_int32));
Word32Or(var_encoded_hash.value(), new_capacity_int32);
StoreObjectField(new_properties, PropertyArray::kLengthAndHashOffset,
SmiFromInt32(new_length_and_hash_int32));
StoreObjectField(object, JSObject::kPropertiesOrHashOffset, new_properties);
Comment("] Extend storage");
Goto(&done);
BIND(&done);
return var_new_properties.value();
return CAST(var_new_properties.value());
}
}
void AccessorAssembler::EmitFastElementsBoundsCheck(Node* object,
Node* elements,
Node* intptr_index,
Node* is_jsarray_condition,
Label* miss) {
VARIABLE(var_length, MachineType::PointerRepresentation());
void AccessorAssembler::EmitFastElementsBoundsCheck(
TNode<JSObject> object, TNode<FixedArrayBase> elements,
TNode<IntPtrT> intptr_index, TNode<BoolT> is_jsarray_condition,
Label* miss) {
TVARIABLE(IntPtrT, var_length);
Comment("Fast elements bounds check");
Label if_array(this), length_loaded(this, &var_length);
GotoIf(is_jsarray_condition, &if_array);
{
var_length.Bind(SmiUntag(LoadFixedArrayBaseLength(elements)));
var_length = SmiUntag(LoadFixedArrayBaseLength(elements));
Goto(&length_loaded);
}
BIND(&if_array);
{
var_length.Bind(SmiUntag(LoadFastJSArrayLength(object)));
var_length = SmiUntag(LoadFastJSArrayLength(CAST(object)));
Goto(&length_loaded);
}
BIND(&length_loaded);
......@@ -2050,9 +2051,9 @@ void AccessorAssembler::EmitFastElementsBoundsCheck(Node* object,
}
void AccessorAssembler::EmitElementLoad(
Node* object, TNode<Word32T> elements_kind,
SloppyTNode<IntPtrT> intptr_index, Node* is_jsarray_condition,
Label* if_hole, Label* rebox_double, Variable* var_double_value,
TNode<HeapObject> object, TNode<Word32T> elements_kind,
TNode<IntPtrT> intptr_index, TNode<BoolT> is_jsarray_condition,
Label* if_hole, Label* rebox_double, TVariable<Float64T>* var_double_value,
Label* unimplemented_elements_kind, Label* out_of_bounds, Label* miss,
ExitPoint* exit_point, LoadAccessMode access_mode) {
Label if_typed_array(this), if_fast(this), if_fast_packed(this),
......@@ -2065,7 +2066,7 @@ void AccessorAssembler::EmitElementLoad(
BIND(&if_fast);
{
TNode<FixedArrayBase> elements = LoadJSObjectElements(CAST(object));
EmitFastElementsBoundsCheck(object, elements, intptr_index,
EmitFastElementsBoundsCheck(CAST(object), elements, intptr_index,
is_jsarray_condition, out_of_bounds);
int32_t kinds[] = {
// Handled by if_fast_packed.
......@@ -2116,8 +2117,8 @@ void AccessorAssembler::EmitElementLoad(
if (access_mode == LoadAccessMode::kHas) {
exit_point->Return(TrueConstant());
} else {
var_double_value->Bind(LoadFixedDoubleArrayElement(
CAST(elements), intptr_index, MachineType::Float64()));
*var_double_value = LoadFixedDoubleArrayElement(
CAST(elements), intptr_index, MachineType::Float64());
Goto(rebox_double);
}
}
......@@ -2131,7 +2132,7 @@ void AccessorAssembler::EmitElementLoad(
if (access_mode == LoadAccessMode::kHas) {
exit_point->Return(TrueConstant());
} else {
var_double_value->Bind(value);
*var_double_value = value;
Goto(rebox_double);
}
}
......@@ -2199,57 +2200,57 @@ void AccessorAssembler::EmitElementLoad(
BIND(&uint8_elements);
{
Comment("UINT8_ELEMENTS"); // Handles UINT8_CLAMPED_ELEMENTS too.
Node* element = Load(MachineType::Uint8(), data_ptr, intptr_index);
TNode<Int32T> element = Load<Uint8T>(data_ptr, intptr_index);
exit_point->Return(SmiFromInt32(element));
}
BIND(&int8_elements);
{
Comment("INT8_ELEMENTS");
Node* element = Load(MachineType::Int8(), data_ptr, intptr_index);
TNode<Int32T> element = Load<Int8T>(data_ptr, intptr_index);
exit_point->Return(SmiFromInt32(element));
}
BIND(&uint16_elements);
{
Comment("UINT16_ELEMENTS");
TNode<IntPtrT> index = WordShl(intptr_index, IntPtrConstant(1));
Node* element = Load(MachineType::Uint16(), data_ptr, index);
TNode<Int32T> element = Load<Uint16T>(data_ptr, index);
exit_point->Return(SmiFromInt32(element));
}
BIND(&int16_elements);
{
Comment("INT16_ELEMENTS");
TNode<IntPtrT> index = WordShl(intptr_index, IntPtrConstant(1));
Node* element = Load(MachineType::Int16(), data_ptr, index);
TNode<Int32T> element = Load<Int16T>(data_ptr, index);
exit_point->Return(SmiFromInt32(element));
}
BIND(&uint32_elements);
{
Comment("UINT32_ELEMENTS");
TNode<IntPtrT> index = WordShl(intptr_index, IntPtrConstant(2));
Node* element = Load(MachineType::Uint32(), data_ptr, index);
TNode<Uint32T> element = Load<Uint32T>(data_ptr, index);
exit_point->Return(ChangeUint32ToTagged(element));
}
BIND(&int32_elements);
{
Comment("INT32_ELEMENTS");
TNode<IntPtrT> index = WordShl(intptr_index, IntPtrConstant(2));
Node* element = Load(MachineType::Int32(), data_ptr, index);
TNode<Int32T> element = Load<Int32T>(data_ptr, index);
exit_point->Return(ChangeInt32ToTagged(element));
}
BIND(&float32_elements);
{
Comment("FLOAT32_ELEMENTS");
TNode<IntPtrT> index = WordShl(intptr_index, IntPtrConstant(2));
Node* element = Load(MachineType::Float32(), data_ptr, index);
var_double_value->Bind(ChangeFloat32ToFloat64(element));
TNode<Float32T> element = Load<Float32T>(data_ptr, index);
*var_double_value = ChangeFloat32ToFloat64(element);
Goto(rebox_double);
}
BIND(&float64_elements);
{
Comment("FLOAT64_ELEMENTS");
TNode<IntPtrT> index = WordShl(intptr_index, IntPtrConstant(3));
Node* element = Load(MachineType::Float64(), data_ptr, index);
var_double_value->Bind(element);
TNode<Float64T> element = Load<Float64T>(data_ptr, index);
*var_double_value = element;
Goto(rebox_double);
}
BIND(&bigint64_elements);
......@@ -2269,23 +2270,13 @@ void AccessorAssembler::EmitElementLoad(
}
}
void AccessorAssembler::NameDictionaryNegativeLookup(Node* object,
SloppyTNode<Name> name,
Label* miss) {
CSA_ASSERT(this, IsDictionaryMap(LoadMap(object)));
TNode<NameDictionary> properties = CAST(LoadSlowProperties(object));
// Ensure the property does not exist in a dictionary-mode object.
TVARIABLE(IntPtrT, var_name_index);
Label done(this);
NameDictionaryLookup<NameDictionary>(properties, name, miss, &var_name_index,
&done);
BIND(&done);
}
void AccessorAssembler::InvalidateValidityCellIfPrototype(Node* map,
Node* bitfield3) {
void AccessorAssembler::InvalidateValidityCellIfPrototype(
TNode<Map> map, base::Optional<TNode<Uint32T>> maybe_bitfield3) {
Label is_prototype(this), cont(this);
if (bitfield3 == nullptr) {
TNode<Uint32T> bitfield3;
if (bitfield3) {
bitfield3 = maybe_bitfield3.value();
} else {
bitfield3 = LoadMapBitField3(map);
}
......@@ -2308,10 +2299,10 @@ void AccessorAssembler::InvalidateValidityCellIfPrototype(Node* map,
BIND(&cont);
}
void AccessorAssembler::GenericElementLoad(Node* receiver,
void AccessorAssembler::GenericElementLoad(TNode<HeapObject> receiver,
TNode<Map> receiver_map,
SloppyTNode<Int32T> instance_type,
Node* index, Label* slow) {
TNode<Int32T> instance_type,
TNode<IntPtrT> index, Label* slow) {
Comment("integer index");
ExitPoint direct_exit(this);
......@@ -2323,7 +2314,7 @@ void AccessorAssembler::GenericElementLoad(Node* receiver,
TNode<Int32T> elements_kind = LoadMapElementsKind(receiver_map);
TNode<BoolT> is_jsarray_condition =
InstanceTypeEqual(instance_type, JS_ARRAY_TYPE);
VARIABLE(var_double_value, MachineRepresentation::kFloat64);
TVARIABLE(Float64T, var_double_value);
Label rebox_double(this, &var_double_value);
// Unimplemented elements kinds fall back to a runtime call.
......@@ -2362,7 +2353,7 @@ void AccessorAssembler::GenericElementLoad(Node* receiver,
Comment("check if string");
GotoIfNot(IsStringInstanceType(instance_type), slow);
Comment("load string character");
TNode<IntPtrT> length = LoadStringLengthAsWord(receiver);
TNode<IntPtrT> length = LoadStringLengthAsWord(CAST(receiver));
GotoIfNot(UintPtrLessThan(index, length), slow);
IncrementCounter(isolate()->counters()->ic_keyed_load_generic_smi(), 1);
TailCallBuiltin(Builtins::kStringCharAt, NoContextConstant(), receiver,
......@@ -2370,16 +2361,19 @@ void AccessorAssembler::GenericElementLoad(Node* receiver,
}
}
void AccessorAssembler::GenericPropertyLoad(
Node* receiver, TNode<Map> receiver_map, SloppyTNode<Int32T> instance_type,
const LoadICParameters* p, Label* slow, UseStubCache use_stub_cache) {
void AccessorAssembler::GenericPropertyLoad(TNode<HeapObject> receiver,
TNode<Map> receiver_map,
TNode<Int32T> instance_type,
const LoadICParameters* p,
Label* slow,
UseStubCache use_stub_cache) {
ExitPoint direct_exit(this);
Comment("key is unique name");
Label if_found_on_receiver(this), if_property_dictionary(this),
lookup_prototype_chain(this), special_receiver(this);
VARIABLE(var_details, MachineRepresentation::kWord32);
VARIABLE(var_value, MachineRepresentation::kTagged);
TVARIABLE(Uint32T, var_details);
TVARIABLE(Object, var_value);
TNode<Name> name = CAST(p->name());
......@@ -2450,7 +2444,7 @@ void AccessorAssembler::GenericPropertyLoad(
TVARIABLE(IntPtrT, var_name_index);
Label dictionary_found(this, &var_name_index);
TNode<NameDictionary> properties = CAST(LoadSlowProperties(receiver));
TNode<NameDictionary> properties = CAST(LoadSlowProperties(CAST(receiver)));
NameDictionaryLookup<NameDictionary>(properties, name, &dictionary_found,
&var_name_index,
&lookup_prototype_chain);
......@@ -2473,13 +2467,13 @@ void AccessorAssembler::GenericPropertyLoad(
BIND(&lookup_prototype_chain);
{
TVARIABLE(Map, var_holder_map);
VARIABLE(var_holder_instance_type, MachineRepresentation::kWord32);
TVARIABLE(Int32T, var_holder_instance_type);
Label return_undefined(this), is_private_symbol(this);
Variable* merged_variables[] = {&var_holder_map, &var_holder_instance_type};
Label loop(this, arraysize(merged_variables), merged_variables);
var_holder_map = receiver_map;
var_holder_instance_type.Bind(instance_type);
var_holder_instance_type = instance_type;
GotoIf(IsPrivateSymbol(name), &is_private_symbol);
Goto(&loop);
......@@ -2494,7 +2488,7 @@ void AccessorAssembler::GenericPropertyLoad(
TNode<Map> proto_map = LoadMap(proto);
TNode<Uint16T> proto_instance_type = LoadMapInstanceType(proto_map);
var_holder_map = proto_map;
var_holder_instance_type.Bind(proto_instance_type);
var_holder_instance_type = proto_instance_type;
Label next_proto(this), return_value(this, &var_value), goto_slow(this);
TryGetOwnProperty(p->context(), receiver, proto, proto_map,
proto_instance_type, name, &return_value, &var_value,
......@@ -2548,7 +2542,8 @@ enum AccessorAssembler::StubCacheTable : int {
kSecondary = static_cast<int>(StubCache::kSecondary)
};
Node* AccessorAssembler::StubCachePrimaryOffset(Node* name, Node* map) {
TNode<IntPtrT> AccessorAssembler::StubCachePrimaryOffset(TNode<Name> name,
TNode<Map> map) {
// Compute the hash of the name (use entire hash field).
TNode<Uint32T> hash_field = LoadNameHashField(name);
CSA_ASSERT(this,
......@@ -2567,10 +2562,13 @@ Node* AccessorAssembler::StubCachePrimaryOffset(Node* name, Node* map) {
TNode<Word32T> hash = Int32Add(hash_field, map32);
uint32_t mask = (StubCache::kPrimaryTableSize - 1)
<< StubCache::kCacheIndexShift;
return ChangeUint32ToWord(Word32And(hash, Int32Constant(mask)));
TNode<UintPtrT> result =
ChangeUint32ToWord(Word32And(hash, Int32Constant(mask)));
return Signed(result);
}
Node* AccessorAssembler::StubCacheSecondaryOffset(Node* name, Node* seed) {
TNode<IntPtrT> AccessorAssembler::StubCacheSecondaryOffset(
TNode<Name> name, TNode<IntPtrT> seed) {
// See v8::internal::StubCache::SecondaryOffset().
// Use the seed from the primary cache in the secondary cache.
......@@ -2579,11 +2577,13 @@ Node* AccessorAssembler::StubCacheSecondaryOffset(Node* name, Node* seed) {
hash = Int32Add(hash, Int32Constant(StubCache::kSecondaryMagic));
int32_t mask = (StubCache::kSecondaryTableSize - 1)
<< StubCache::kCacheIndexShift;
return ChangeUint32ToWord(Word32And(hash, Int32Constant(mask)));
TNode<UintPtrT> result =
ChangeUint32ToWord(Word32And(hash, Int32Constant(mask)));
return Signed(result);
}
void AccessorAssembler::TryProbeStubCacheTable(
StubCache* stub_cache, StubCacheTable table_id, Node* entry_offset,
StubCache* stub_cache, StubCacheTable table_id, TNode<IntPtrT> entry_offset,
TNode<Object> name, TNode<Map> map, Label* if_handler,
TVariable<MaybeObject>* var_handler, Label* if_miss) {
StubCache::Table table = static_cast<StubCache::Table>(table_id);
......@@ -2618,8 +2618,9 @@ void AccessorAssembler::TryProbeStubCacheTable(
Goto(if_handler);
}
void AccessorAssembler::TryProbeStubCache(StubCache* stub_cache, Node* receiver,
TNode<Object> name, Label* if_handler,
void AccessorAssembler::TryProbeStubCache(StubCache* stub_cache,
TNode<Object> receiver,
TNode<Name> name, Label* if_handler,
TVariable<MaybeObject>* var_handler,
Label* if_miss) {
Label try_secondary(this), miss(this);
......@@ -2630,17 +2631,18 @@ void AccessorAssembler::TryProbeStubCache(StubCache* stub_cache, Node* receiver,
// Check that the {receiver} isn't a smi.
GotoIf(TaggedIsSmi(receiver), &miss);
TNode<Map> receiver_map = LoadMap(receiver);
TNode<Map> receiver_map = LoadMap(CAST(receiver));
// Probe the primary table.
Node* primary_offset = StubCachePrimaryOffset(name, receiver_map);
TNode<IntPtrT> primary_offset = StubCachePrimaryOffset(name, receiver_map);
TryProbeStubCacheTable(stub_cache, kPrimary, primary_offset, name,
receiver_map, if_handler, var_handler, &try_secondary);
BIND(&try_secondary);
{
// Probe the secondary table.
Node* secondary_offset = StubCacheSecondaryOffset(name, primary_offset);
TNode<IntPtrT> secondary_offset =
StubCacheSecondaryOffset(name, primary_offset);
TryProbeStubCacheTable(stub_cache, kSecondary, secondary_offset, name,
receiver_map, if_handler, var_handler, &miss);
}
......@@ -2792,17 +2794,17 @@ void AccessorAssembler::LoadIC_Noninlined(const LoadICParameters* p,
// Check megamorphic case.
GotoIfNot(TaggedEqual(feedback, MegamorphicSymbolConstant()), miss);
TryProbeStubCache(isolate()->load_stub_cache(), p->receiver(), p->name(),
if_handler, var_handler, miss);
TryProbeStubCache(isolate()->load_stub_cache(), p->receiver(),
CAST(p->name()), if_handler, var_handler, miss);
}
}
void AccessorAssembler::LoadIC_NoFeedback(const LoadICParameters* p,
TNode<Smi> ic_kind) {
Label miss(this, Label::kDeferred);
Node* receiver = p->receiver();
TNode<Object> receiver = p->receiver();
GotoIf(TaggedIsSmi(receiver), &miss);
TNode<Map> receiver_map = LoadMap(receiver);
TNode<Map> receiver_map = LoadMap(CAST(receiver));
GotoIf(IsDeprecatedMap(receiver_map), &miss);
TNode<Uint16T> instance_type = LoadMapInstanceType(receiver_map);
......@@ -2821,7 +2823,7 @@ void AccessorAssembler::LoadIC_NoFeedback(const LoadICParameters* p,
BIND(&not_function_prototype);
}
GenericPropertyLoad(receiver, receiver_map, instance_type, p, &miss,
GenericPropertyLoad(CAST(receiver), receiver_map, instance_type, p, &miss,
kDontUseStubCache);
BIND(&miss);
......@@ -3147,7 +3149,7 @@ void AccessorAssembler::KeyedLoadICGeneric(const LoadICParameters* p) {
TVARIABLE(Object, var_name, p->name());
Label if_runtime(this, Label::kDeferred);
Node* receiver = p->receiver();
TNode<Object> receiver = p->receiver();
GotoIf(TaggedIsSmi(receiver), &if_runtime);
GotoIf(IsNullOrUndefined(receiver), &if_runtime);
......@@ -3163,9 +3165,9 @@ void AccessorAssembler::KeyedLoadICGeneric(const LoadICParameters* p) {
BIND(&if_unique_name);
{
LoadICParameters pp(p, var_unique.value());
TNode<Map> receiver_map = LoadMap(receiver);
TNode<Map> receiver_map = LoadMap(CAST(receiver));
TNode<Uint16T> instance_type = LoadMapInstanceType(receiver_map);
GenericPropertyLoad(receiver, receiver_map, instance_type, &pp,
GenericPropertyLoad(CAST(receiver), receiver_map, instance_type, &pp,
&if_runtime);
}
......@@ -3196,9 +3198,9 @@ void AccessorAssembler::KeyedLoadICGeneric(const LoadICParameters* p) {
// experiments with this have shown that it causes too much traffic
// on the stub cache. We may want to re-evaluate that in the future.
LoadICParameters pp(p, var_unique.value());
TNode<Map> receiver_map = LoadMap(receiver);
TNode<Map> receiver_map = LoadMap(CAST(receiver));
TNode<Uint16T> instance_type = LoadMapInstanceType(receiver_map);
GenericPropertyLoad(receiver, receiver_map, instance_type, &pp,
GenericPropertyLoad(CAST(receiver), receiver_map, instance_type, &pp,
&if_runtime, kDontUseStubCache);
}
} else {
......@@ -3208,9 +3210,9 @@ void AccessorAssembler::KeyedLoadICGeneric(const LoadICParameters* p) {
BIND(&if_index);
{
TNode<Map> receiver_map = LoadMap(receiver);
TNode<Map> receiver_map = LoadMap(CAST(receiver));
TNode<Uint16T> instance_type = LoadMapInstanceType(receiver_map);
GenericElementLoad(receiver, receiver_map, instance_type,
GenericElementLoad(CAST(receiver), receiver_map, instance_type,
var_index.value(), &if_runtime);
}
}
......@@ -3230,7 +3232,7 @@ void AccessorAssembler::KeyedLoadICPolymorphicName(const LoadICParameters* p,
TVARIABLE(MaybeObject, var_handler);
Label if_handler(this, &var_handler), miss(this, Label::kDeferred);
Node* receiver = p->receiver();
TNode<Object> receiver = p->receiver();
TNode<Map> receiver_map = LoadReceiverMap(receiver);
TNode<Name> name = CAST(p->name());
TNode<FeedbackVector> vector = CAST(p->vector());
......@@ -3311,8 +3313,8 @@ void AccessorAssembler::StoreIC(const StoreICParameters* p) {
// Check megamorphic case.
GotoIfNot(TaggedEqual(strong_feedback, MegamorphicSymbolConstant()), &miss);
TryProbeStubCache(isolate()->store_stub_cache(), p->receiver(), p->name(),
&if_handler, &var_handler, &miss);
TryProbeStubCache(isolate()->store_stub_cache(), p->receiver(),
CAST(p->name()), &if_handler, &var_handler, &miss);
}
BIND(&no_feedback);
......@@ -3354,7 +3356,7 @@ void AccessorAssembler::StoreGlobalIC(const StoreICParameters* pp) {
GotoIf(TaggedEqual(handler, UninitializedSymbolConstant()), &miss);
DCHECK_NULL(pp->receiver());
DCHECK(pp->receiver_is_null());
TNode<NativeContext> native_context = LoadNativeContext(pp->context());
StoreICParameters p(
pp->context(),
......@@ -3386,12 +3388,10 @@ void AccessorAssembler::StoreGlobalIC(const StoreICParameters* pp) {
}
}
void AccessorAssembler::StoreGlobalIC_PropertyCellCase(Node* property_cell,
TNode<Object> value,
ExitPoint* exit_point,
Label* miss) {
void AccessorAssembler::StoreGlobalIC_PropertyCellCase(
TNode<PropertyCell> property_cell, TNode<Object> value,
ExitPoint* exit_point, Label* miss) {
Comment("StoreGlobalIC_TryPropertyCellCase");
CSA_ASSERT(this, IsPropertyCell(property_cell));
// Load the payload of the global parameter cell. A hole indicates that
// the cell has been invalidated and that the store must be handled by the
......@@ -3635,10 +3635,10 @@ void AccessorAssembler::StoreInArrayLiteralIC(const StoreICParameters* p) {
void AccessorAssembler::GenerateLoadIC() {
using Descriptor = LoadWithVectorDescriptor;
Node* receiver = Parameter(Descriptor::kReceiver);
TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
TNode<Object> name = CAST(Parameter(Descriptor::kName));
TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
Node* vector = Parameter(Descriptor::kVector);
TNode<HeapObject> vector = CAST(Parameter(Descriptor::kVector));
TNode<Context> context = CAST(Parameter(Descriptor::kContext));
LoadICParameters p(context, receiver, name, slot, vector);
......@@ -3648,18 +3648,18 @@ void AccessorAssembler::GenerateLoadIC() {
void AccessorAssembler::GenerateLoadIC_Megamorphic() {
using Descriptor = LoadWithVectorDescriptor;
Node* receiver = Parameter(Descriptor::kReceiver);
TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
TNode<Object> name = CAST(Parameter(Descriptor::kName));
TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
Node* vector = Parameter(Descriptor::kVector);
TNode<HeapObject> vector = CAST(Parameter(Descriptor::kVector));
TNode<Context> context = CAST(Parameter(Descriptor::kContext));
ExitPoint direct_exit(this);
TVARIABLE(MaybeObject, var_handler);
Label if_handler(this, &var_handler), miss(this, Label::kDeferred);
TryProbeStubCache(isolate()->load_stub_cache(), receiver, name, &if_handler,
&var_handler, &miss);
TryProbeStubCache(isolate()->load_stub_cache(), receiver, CAST(name),
&if_handler, &var_handler, &miss);
BIND(&if_handler);
LazyLoadICParameters p([=] { return context; }, receiver,
......@@ -3674,7 +3674,7 @@ void AccessorAssembler::GenerateLoadIC_Megamorphic() {
void AccessorAssembler::GenerateLoadIC_Noninlined() {
using Descriptor = LoadWithVectorDescriptor;
Node* receiver = Parameter(Descriptor::kReceiver);
TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
TNode<Object> name = CAST(Parameter(Descriptor::kName));
TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
TNode<FeedbackVector> vector = CAST(Parameter(Descriptor::kVector));
......@@ -3707,7 +3707,7 @@ void AccessorAssembler::GenerateLoadIC_Noninlined() {
void AccessorAssembler::GenerateLoadIC_NoFeedback() {
using Descriptor = LoadNoFeedbackDescriptor;
Node* receiver = Parameter(Descriptor::kReceiver);
TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
TNode<Object> name = CAST(Parameter(Descriptor::kName));
TNode<Context> context = CAST(Parameter(Descriptor::kContext));
TNode<Smi> ic_kind = CAST(Parameter(Descriptor::kICKind));
......@@ -3722,9 +3722,9 @@ void AccessorAssembler::GenerateLoadIC_NoFeedback() {
void AccessorAssembler::GenerateLoadICTrampoline() {
using Descriptor = LoadDescriptor;
Node* receiver = Parameter(Descriptor::kReceiver);
TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
TNode<Object> name = CAST(Parameter(Descriptor::kName));
Node* slot = Parameter(Descriptor::kSlot);
TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
TNode<Context> context = CAST(Parameter(Descriptor::kContext));
TNode<FeedbackVector> vector = LoadFeedbackVectorForStub();
......@@ -3734,9 +3734,9 @@ void AccessorAssembler::GenerateLoadICTrampoline() {
void AccessorAssembler::GenerateLoadICTrampoline_Megamorphic() {
using Descriptor = LoadDescriptor;
Node* receiver = Parameter(Descriptor::kReceiver);
TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
TNode<Object> name = CAST(Parameter(Descriptor::kName));
Node* slot = Parameter(Descriptor::kSlot);
TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
TNode<Context> context = CAST(Parameter(Descriptor::kContext));
TNode<FeedbackVector> vector = LoadFeedbackVectorForStub();
......@@ -3779,7 +3779,7 @@ void AccessorAssembler::GenerateLoadGlobalICTrampoline(TypeofMode typeof_mode) {
using Descriptor = LoadGlobalDescriptor;
TNode<Object> name = CAST(Parameter(Descriptor::kName));
Node* slot = Parameter(Descriptor::kSlot);
TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
TNode<Context> context = CAST(Parameter(Descriptor::kContext));
TNode<FeedbackVector> vector = LoadFeedbackVectorForStub();
......@@ -3791,10 +3791,10 @@ void AccessorAssembler::GenerateLoadGlobalICTrampoline(TypeofMode typeof_mode) {
void AccessorAssembler::GenerateKeyedLoadIC() {
using Descriptor = LoadWithVectorDescriptor;
Node* receiver = Parameter(Descriptor::kReceiver);
TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
TNode<Object> name = CAST(Parameter(Descriptor::kName));
TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
Node* vector = Parameter(Descriptor::kVector);
TNode<HeapObject> vector = CAST(Parameter(Descriptor::kVector));
TNode<Context> context = CAST(Parameter(Descriptor::kContext));
LoadICParameters p(context, receiver, name, slot, vector);
......@@ -3804,10 +3804,10 @@ void AccessorAssembler::GenerateKeyedLoadIC() {
void AccessorAssembler::GenerateKeyedLoadIC_Megamorphic() {
using Descriptor = LoadWithVectorDescriptor;
Node* receiver = Parameter(Descriptor::kReceiver);
TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
TNode<Object> name = CAST(Parameter(Descriptor::kName));
TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
Node* vector = Parameter(Descriptor::kVector);
TNode<HeapObject> vector = CAST(Parameter(Descriptor::kVector));
TNode<Context> context = CAST(Parameter(Descriptor::kContext));
LoadICParameters p(context, receiver, name, slot, vector);
......@@ -3817,7 +3817,7 @@ void AccessorAssembler::GenerateKeyedLoadIC_Megamorphic() {
void AccessorAssembler::GenerateKeyedLoadICTrampoline() {
using Descriptor = LoadDescriptor;
Node* receiver = Parameter(Descriptor::kReceiver);
TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
TNode<Object> name = CAST(Parameter(Descriptor::kName));
TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
TNode<Context> context = CAST(Parameter(Descriptor::kContext));
......@@ -3830,7 +3830,7 @@ void AccessorAssembler::GenerateKeyedLoadICTrampoline() {
void AccessorAssembler::GenerateKeyedLoadICTrampoline_Megamorphic() {
using Descriptor = LoadDescriptor;
Node* receiver = Parameter(Descriptor::kReceiver);
TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
TNode<Object> name = CAST(Parameter(Descriptor::kName));
TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
TNode<Context> context = CAST(Parameter(Descriptor::kContext));
......@@ -3843,10 +3843,10 @@ void AccessorAssembler::GenerateKeyedLoadICTrampoline_Megamorphic() {
void AccessorAssembler::GenerateKeyedLoadIC_PolymorphicName() {
using Descriptor = LoadWithVectorDescriptor;
Node* receiver = Parameter(Descriptor::kReceiver);
TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
TNode<Object> name = CAST(Parameter(Descriptor::kName));
TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
Node* vector = Parameter(Descriptor::kVector);
TNode<FeedbackVector> vector = CAST(Parameter(Descriptor::kVector));
TNode<Context> context = CAST(Parameter(Descriptor::kContext));
LoadICParameters p(context, receiver, name, slot, vector);
......@@ -3857,12 +3857,12 @@ void AccessorAssembler::GenerateStoreGlobalIC() {
using Descriptor = StoreGlobalWithVectorDescriptor;
TNode<Object> name = CAST(Parameter(Descriptor::kName));
Node* value = Parameter(Descriptor::kValue);
TNode<Object> value = CAST(Parameter(Descriptor::kValue));
TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
Node* vector = Parameter(Descriptor::kVector);
TNode<HeapObject> vector = CAST(Parameter(Descriptor::kVector));
TNode<Context> context = CAST(Parameter(Descriptor::kContext));
StoreICParameters p(context, nullptr, name, value, slot, vector);
StoreICParameters p(context, base::nullopt, name, value, slot, vector);
StoreGlobalIC(&p);
}
......@@ -3870,7 +3870,7 @@ void AccessorAssembler::GenerateStoreGlobalICTrampoline() {
using Descriptor = StoreGlobalDescriptor;
TNode<Object> name = CAST(Parameter(Descriptor::kName));
Node* value = Parameter(Descriptor::kValue);
TNode<Object> value = CAST(Parameter(Descriptor::kValue));
TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
TNode<Context> context = CAST(Parameter(Descriptor::kContext));
TNode<FeedbackVector> vector = LoadFeedbackVectorForStub();
......@@ -3881,11 +3881,11 @@ void AccessorAssembler::GenerateStoreGlobalICTrampoline() {
void AccessorAssembler::GenerateStoreIC() {
using Descriptor = StoreWithVectorDescriptor;
Node* receiver = Parameter(Descriptor::kReceiver);
TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
TNode<Object> name = CAST(Parameter(Descriptor::kName));
Node* value = Parameter(Descriptor::kValue);
TNode<Object> value = CAST(Parameter(Descriptor::kValue));
TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
Node* vector = Parameter(Descriptor::kVector);
TNode<HeapObject> vector = CAST(Parameter(Descriptor::kVector));
TNode<Context> context = CAST(Parameter(Descriptor::kContext));
StoreICParameters p(context, receiver, name, value, slot, vector);
......@@ -3895,9 +3895,9 @@ void AccessorAssembler::GenerateStoreIC() {
void AccessorAssembler::GenerateStoreICTrampoline() {
using Descriptor = StoreDescriptor;
Node* receiver = Parameter(Descriptor::kReceiver);
TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
TNode<Object> name = CAST(Parameter(Descriptor::kName));
Node* value = Parameter(Descriptor::kValue);
TNode<Object> value = CAST(Parameter(Descriptor::kValue));
TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
TNode<Context> context = CAST(Parameter(Descriptor::kContext));
TNode<FeedbackVector> vector = LoadFeedbackVectorForStub();
......@@ -3909,11 +3909,11 @@ void AccessorAssembler::GenerateStoreICTrampoline() {
void AccessorAssembler::GenerateKeyedStoreIC() {
using Descriptor = StoreWithVectorDescriptor;
Node* receiver = Parameter(Descriptor::kReceiver);
TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
TNode<Object> name = CAST(Parameter(Descriptor::kName));
Node* value = Parameter(Descriptor::kValue);
TNode<Object> value = CAST(Parameter(Descriptor::kValue));
TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
Node* vector = Parameter(Descriptor::kVector);
TNode<HeapObject> vector = CAST(Parameter(Descriptor::kVector));
TNode<Context> context = CAST(Parameter(Descriptor::kContext));
StoreICParameters p(context, receiver, name, value, slot, vector);
......@@ -3923,9 +3923,9 @@ void AccessorAssembler::GenerateKeyedStoreIC() {
void AccessorAssembler::GenerateKeyedStoreICTrampoline() {
using Descriptor = StoreDescriptor;
Node* receiver = Parameter(Descriptor::kReceiver);
TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
TNode<Object> name = CAST(Parameter(Descriptor::kName));
Node* value = Parameter(Descriptor::kValue);
TNode<Object> value = CAST(Parameter(Descriptor::kValue));
TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
TNode<Context> context = CAST(Parameter(Descriptor::kContext));
TNode<FeedbackVector> vector = LoadFeedbackVectorForStub();
......@@ -3937,11 +3937,11 @@ void AccessorAssembler::GenerateKeyedStoreICTrampoline() {
void AccessorAssembler::GenerateStoreInArrayLiteralIC() {
using Descriptor = StoreWithVectorDescriptor;
Node* array = Parameter(Descriptor::kReceiver);
TNode<Object> array = CAST(Parameter(Descriptor::kReceiver));
TNode<Object> index = CAST(Parameter(Descriptor::kName));
Node* value = Parameter(Descriptor::kValue);
TNode<Object> value = CAST(Parameter(Descriptor::kValue));
TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
Node* vector = Parameter(Descriptor::kVector);
TNode<HeapObject> vector = CAST(Parameter(Descriptor::kVector));
TNode<Context> context = CAST(Parameter(Descriptor::kContext));
StoreICParameters p(context, array, index, value, slot, vector);
......@@ -4172,10 +4172,10 @@ void AccessorAssembler::GenerateCloneObjectIC() {
void AccessorAssembler::GenerateKeyedHasIC() {
using Descriptor = LoadWithVectorDescriptor;
Node* receiver = Parameter(Descriptor::kReceiver);
TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
TNode<Object> name = CAST(Parameter(Descriptor::kName));
TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
Node* vector = Parameter(Descriptor::kVector);
TNode<HeapObject> vector = CAST(Parameter(Descriptor::kVector));
TNode<Context> context = CAST(Parameter(Descriptor::kContext));
LoadICParameters p(context, receiver, name, slot, vector);
......@@ -4185,7 +4185,7 @@ void AccessorAssembler::GenerateKeyedHasIC() {
void AccessorAssembler::GenerateKeyedHasIC_Megamorphic() {
using Descriptor = LoadWithVectorDescriptor;
Node* receiver = Parameter(Descriptor::kReceiver);
TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
TNode<Object> name = CAST(Parameter(Descriptor::kName));
TNode<Context> context = CAST(Parameter(Descriptor::kContext));
// TODO(magardn): implement HasProperty handling in KeyedLoadICGeneric
......@@ -4196,10 +4196,10 @@ void AccessorAssembler::GenerateKeyedHasIC_Megamorphic() {
void AccessorAssembler::GenerateKeyedHasIC_PolymorphicName() {
using Descriptor = LoadWithVectorDescriptor;
Node* receiver = Parameter(Descriptor::kReceiver);
TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
TNode<Object> name = CAST(Parameter(Descriptor::kName));
TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
Node* vector = Parameter(Descriptor::kVector);
TNode<HeapObject> vector = CAST(Parameter(Descriptor::kVector));
TNode<Context> context = CAST(Parameter(Descriptor::kContext));
LoadICParameters p(context, receiver, name, slot, vector);
......
src/ic/accessor-assembler.h
View file @ 1f1e4cdb
......@@ -55,26 +55,30 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
void GenerateStoreInArrayLiteralIC();
void TryProbeStubCache(StubCache* stub_cache, Node* receiver,
TNode<Object> name, Label* if_handler,
void TryProbeStubCache(StubCache* stub_cache, TNode<Object> receiver,
TNode<Name> name, Label* if_handler,
TVariable<MaybeObject>* var_handler, Label* if_miss);
Node* StubCachePrimaryOffsetForTesting(Node* name, Node* map) {
TNode<IntPtrT> StubCachePrimaryOffsetForTesting(TNode<Name> name,
TNode<Map> map) {
return StubCachePrimaryOffset(name, map);
}
Node* StubCacheSecondaryOffsetForTesting(Node* name, Node* map) {
return StubCacheSecondaryOffset(name, map);
TNode<IntPtrT> StubCacheSecondaryOffsetForTesting(TNode<Name> name,
TNode<IntPtrT> seed) {
return StubCacheSecondaryOffset(name, seed);
}
struct LoadICParameters {
LoadICParameters(TNode<Context> context, Node* receiver, TNode<Object> name,
TNode<Smi> slot, Node* vector, Node* holder = nullptr)
LoadICParameters(TNode<Context> context,
base::Optional<TNode<Object>> receiver, TNode<Object> name,
TNode<Smi> slot, TNode<HeapObject> vector,
base::Optional<TNode<Object>> holder = base::nullopt)
: context_(context),
receiver_(receiver),
name_(name),
slot_(slot),
vector_(vector),
holder_(holder ? holder : receiver) {}
holder_(holder ? holder.value() : receiver) {}
LoadICParameters(const LoadICParameters* p, TNode<Object> unique_name)
: context_(p->context_),
......@@ -85,31 +89,33 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
holder_(p->holder_) {}
TNode<Context> context() const { return context_; }
Node* receiver() const { return receiver_; }
TNode<Object> receiver() const { return receiver_.value(); }
TNode<Object> name() const { return name_; }
TNode<Smi> slot() const { return slot_; }
Node* vector() const { return vector_; }
Node* holder() const { return holder_; }
TNode<HeapObject> vector() const { return vector_; }
TNode<Object> holder() const { return holder_.value(); }
bool receiver_is_null() const { return !receiver_.has_value(); }
private:
TNode<Context> context_;
Node* receiver_;
base::Optional<TNode<Object>> receiver_;
TNode<Object> name_;
TNode<Smi> slot_;
Node* vector_;
Node* holder_;
TNode<HeapObject> vector_;
base::Optional<TNode<Object>> holder_;
};
struct LazyLoadICParameters {
LazyLoadICParameters(LazyNode<Context> context, Node* receiver,
LazyLoadICParameters(LazyNode<Context> context, TNode<Object> receiver,
LazyNode<Object> name, LazyNode<Smi> slot,
Node* vector, Node* holder = nullptr)
TNode<HeapObject> vector,
base::Optional<TNode<Object>> holder = base::nullopt)
: context_(context),
receiver_(receiver),
name_(name),
slot_(slot),
vector_(vector),
holder_(holder ? holder : receiver) {}
holder_(holder ? holder.value() : receiver) {}
explicit LazyLoadICParameters(const LoadICParameters* p)
: receiver_(p->receiver()),
......@@ -121,19 +127,19 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
}
TNode<Context> context() const { return context_(); }
Node* receiver() const { return receiver_; }
TNode<Object> receiver() const { return receiver_; }
TNode<Object> name() const { return name_(); }
TNode<Smi> slot() const { return slot_(); }
Node* vector() const { return vector_; }
Node* holder() const { return holder_; }
TNode<HeapObject> vector() const { return vector_; }
TNode<Object> holder() const { return holder_; }
private:
LazyNode<Context> context_;
Node* receiver_;
TNode<Object> receiver_;
LazyNode<Object> name_;
LazyNode<Smi> slot_;
Node* vector_;
Node* holder_;
TNode<HeapObject> vector_;
TNode<Object> holder_;
};
void LoadGlobalIC(TNode<HeapObject> maybe_feedback_vector,
......@@ -149,21 +155,22 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
ExitPoint* exit_point);
// Loads dataX field from the DataHandler object.
TNode<MaybeObject> LoadHandlerDataField(SloppyTNode<DataHandler> handler,
TNode<MaybeObject> LoadHandlerDataField(TNode<DataHandler> handler,
int data_index);
protected:
struct StoreICParameters : public LoadICParameters {
StoreICParameters(TNode<Context> context, Node* receiver,
TNode<Object> name, SloppyTNode<Object> value,
TNode<Smi> slot, Node* vector)
StoreICParameters(TNode<Context> context,
base::Optional<TNode<Object>> receiver,
TNode<Object> name, TNode<Object> value, TNode<Smi> slot,
TNode<HeapObject> vector)
: LoadICParameters(context, receiver, name, slot, vector),
value_(value) {}
SloppyTNode<Object> value() const { return value_; }
TNode<Object> value() const { return value_; }
private:
SloppyTNode<Object> value_;
TNode<Object> value_;
};
enum class LoadAccessMode { kLoad, kHas };
......@@ -186,9 +193,10 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
void JumpIfDataProperty(TNode<Uint32T> details, Label* writable,
Label* readonly);
void InvalidateValidityCellIfPrototype(Node* map, Node* bitfield3 = nullptr);
void InvalidateValidityCellIfPrototype(
TNode<Map> map, base::Optional<TNode<Uint32T>> bitfield3 = base::nullopt);
void OverwriteExistingFastDataProperty(SloppyTNode<HeapObject> object,
void OverwriteExistingFastDataProperty(TNode<HeapObject> object,
TNode<Map> object_map,
TNode<DescriptorArray> descriptors,
TNode<IntPtrT> descriptor_name_index,
......@@ -198,7 +206,7 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
void CheckFieldType(TNode<DescriptorArray> descriptors,
TNode<IntPtrT> name_index, TNode<Word32T> representation,
Node* value, Label* bailout);
TNode<Object> value, Label* bailout);
private:
// Stub generation entry points.
......@@ -226,7 +234,8 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
LoadAccessMode access_mode);
void StoreIC(const StoreICParameters* p);
void StoreGlobalIC(const StoreICParameters* p);
void StoreGlobalIC_PropertyCellCase(Node* property_cell, TNode<Object> value,
void StoreGlobalIC_PropertyCellCase(TNode<PropertyCell> property_cell,
TNode<Object> value,
ExitPoint* exit_point, Label* miss);
void KeyedStoreIC(const StoreICParameters* p);
void StoreInArrayLiteralIC(const StoreICParameters* p);
......@@ -250,15 +259,18 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
ElementSupport support_elements = kOnlyProperties,
LoadAccessMode access_mode = LoadAccessMode::kLoad);
void HandleLoadICSmiHandlerCase(
const LazyLoadICParameters* p, SloppyTNode<HeapObject> holder,
SloppyTNode<Smi> smi_handler, SloppyTNode<Object> handler, Label* miss,
ExitPoint* exit_point, ICMode ic_mode, OnNonExistent on_nonexistent,
ElementSupport support_elements, LoadAccessMode access_mode);
void HandleLoadICSmiHandlerCase(const LazyLoadICParameters* p,
TNode<Object> holder, TNode<Smi> smi_handler,
TNode<Object> handler, Label* miss,
ExitPoint* exit_point, ICMode ic_mode,
OnNonExistent on_nonexistent,
ElementSupport support_elements,
LoadAccessMode access_mode);
void HandleLoadICProtoHandler(const LazyLoadICParameters* p,
TNode<DataHandler> handler,
Variable* var_holder, Variable* var_smi_handler,
TVariable<Object>* var_holder,
TVariable<Object>* var_smi_handler,
Label* if_smi_handler, Label* miss,
ExitPoint* exit_point, ICMode ic_mode,
LoadAccessMode access_mode);
......@@ -273,7 +285,7 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
TNode<WordT> handler_word, TNode<DataHandler> handler,
TNode<IntPtrT> handler_kind, ExitPoint* exit_point);
void HandleLoadField(SloppyTNode<JSObject> holder, TNode<WordT> handler_word,
void HandleLoadField(TNode<JSObject> holder, TNode<WordT> handler_word,
Variable* var_double_value, Label* rebox_double,
Label* miss, ExitPoint* exit_point);
......@@ -282,15 +294,14 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
Label* can_access, Label* miss);
void HandleLoadICSmiHandlerLoadNamedCase(
const LazyLoadICParameters* p, TNode<HeapObject> holder,
const LazyLoadICParameters* p, TNode<Object> holder,
TNode<IntPtrT> handler_kind, TNode<WordT> handler_word,
Label* rebox_double, Variable* var_double_value,
SloppyTNode<Object> handler, Label* miss, ExitPoint* exit_point,
ICMode ic_mode, OnNonExistent on_nonexistent,
ElementSupport support_elements);
Label* rebox_double, Variable* var_double_value, TNode<Object> handler,
Label* miss, ExitPoint* exit_point, ICMode ic_mode,
OnNonExistent on_nonexistent, ElementSupport support_elements);
void HandleLoadICSmiHandlerHasNamedCase(const LazyLoadICParameters* p,
TNode<HeapObject> holder,
TNode<Object> holder,
TNode<IntPtrT> handler_kind,
Label* miss, ExitPoint* exit_point,
ICMode ic_mode);
......@@ -322,9 +333,9 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
TNode<StoreHandler> handler, Label* miss,
ICMode ic_mode,
ElementSupport support_elements);
void HandleStoreICSmiHandlerCase(SloppyTNode<Word32T> handler_word,
SloppyTNode<JSObject> holder,
SloppyTNode<Object> value, Label* miss);
void HandleStoreICSmiHandlerCase(TNode<Word32T> handler_word,
TNode<JSObject> holder, TNode<Object> value,
Label* miss);
void HandleStoreFieldAndReturn(TNode<Word32T> handler_word,
TNode<JSObject> holder, TNode<Object> value,
base::Optional<TNode<Float64T>> double_value,
......@@ -333,25 +344,24 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
void CheckPrototypeValidityCell(TNode<Object> maybe_validity_cell,
Label* miss);
void HandleStoreICNativeDataProperty(const StoreICParameters* p,
SloppyTNode<HeapObject> holder,
TNode<HeapObject> holder,
TNode<Word32T> handler_word);
void HandleStoreToProxy(const StoreICParameters* p, Node* proxy, Label* miss,
ElementSupport support_elements);
void HandleStoreToProxy(const StoreICParameters* p, TNode<JSProxy> proxy,
Label* miss, ElementSupport support_elements);
void HandleStoreAccessor(const StoreICParameters* p,
SloppyTNode<HeapObject> holder,
void HandleStoreAccessor(const StoreICParameters* p, TNode<HeapObject> holder,
TNode<Word32T> handler_word);
// KeyedLoadIC_Generic implementation.
void GenericElementLoad(Node* receiver, TNode<Map> receiver_map,
SloppyTNode<Int32T> instance_type, Node* index,
void GenericElementLoad(TNode<HeapObject> receiver, TNode<Map> receiver_map,
TNode<Int32T> instance_type, TNode<IntPtrT> index,
Label* slow);
enum UseStubCache { kUseStubCache, kDontUseStubCache };
void GenericPropertyLoad(Node* receiver, TNode<Map> receiver_map,
SloppyTNode<Int32T> instance_type,
void GenericPropertyLoad(TNode<HeapObject> receiver, TNode<Map> receiver_map,
TNode<Int32T> instance_type,
const LoadICParameters* p, Label* slow,
UseStubCache use_stub_cache = kUseStubCache);
......@@ -380,20 +390,21 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
// Extends properties backing store by JSObject::kFieldsAdded elements,
// returns updated properties backing store.
Node* ExtendPropertiesBackingStore(Node* object, Node* index);
void EmitFastElementsBoundsCheck(Node* object, Node* elements,
Node* intptr_index,
Node* is_jsarray_condition, Label* miss);
void EmitElementLoad(Node* object, TNode<Word32T> elements_kind,
SloppyTNode<IntPtrT> key, Node* is_jsarray_condition,
TNode<PropertyArray> ExtendPropertiesBackingStore(TNode<HeapObject> object,
TNode<IntPtrT> index);
void EmitFastElementsBoundsCheck(TNode<JSObject> object,
TNode<FixedArrayBase> elements,
TNode<IntPtrT> intptr_index,
TNode<BoolT> is_jsarray_condition,
Label* miss);
void EmitElementLoad(TNode<HeapObject> object, TNode<Word32T> elements_kind,
TNode<IntPtrT> key, TNode<BoolT> is_jsarray_condition,
Label* if_hole, Label* rebox_double,
Variable* var_double_value,
TVariable<Float64T>* var_double_value,
Label* unimplemented_elements_kind, Label* out_of_bounds,
Label* miss, ExitPoint* exit_point,
LoadAccessMode access_mode = LoadAccessMode::kLoad);
void NameDictionaryNegativeLookup(Node* object, SloppyTNode<Name> name,
Label* miss);
TNode<BoolT> IsPropertyDetailsConst(TNode<Uint32T> details);
// Stub cache access helpers.
......@@ -402,11 +413,12 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
// including stub cache header.
enum StubCacheTable : int;
Node* StubCachePrimaryOffset(Node* name, Node* map);
Node* StubCacheSecondaryOffset(Node* name, Node* seed);
TNode<IntPtrT> StubCachePrimaryOffset(TNode<Name> name, TNode<Map> map);
TNode<IntPtrT> StubCacheSecondaryOffset(TNode<Name> name,
TNode<IntPtrT> seed);
void TryProbeStubCacheTable(StubCache* stub_cache, StubCacheTable table_id,
Node* entry_offset, TNode<Object> name,
TNode<IntPtrT> entry_offset, TNode<Object> name,
TNode<Map> map, Label* if_handler,
TVariable<MaybeObject>* var_handler,
Label* if_miss);
......@@ -445,7 +457,7 @@ class ExitPoint {
}
template <class... TArgs>
void ReturnCallRuntime(Runtime::FunctionId function, Node* context,
void ReturnCallRuntime(Runtime::FunctionId function, TNode<Context> context,
TArgs... args) {
if (IsDirect()) {
asm_->TailCallRuntime(function, context, args...);
......@@ -455,7 +467,8 @@ class ExitPoint {
}
template <class... TArgs>
void ReturnCallStub(Callable const& callable, Node* context, TArgs... args) {
void ReturnCallStub(Callable const& callable, TNode<Context> context,
TArgs... args) {
if (IsDirect()) {
asm_->TailCallStub(callable, context, args...);
} else {
......@@ -464,8 +477,9 @@ class ExitPoint {
}
template <class... TArgs>
void ReturnCallStub(const CallInterfaceDescriptor& descriptor, Node* target,
Node* context, TArgs... args) {
void ReturnCallStub(const CallInterfaceDescriptor& descriptor,
TNode<Code> target, TNode<Context> context,
TArgs... args) {
if (IsDirect()) {
asm_->TailCallStub(descriptor, target, context, args...);
} else {
......
src/ic/keyed-store-generic.cc
View file @ 1f1e4cdb
......@@ -1023,7 +1023,7 @@ void KeyedStoreGenericAssembler::KeyedStoreGeneric(
{
Comment("key is unique name");
StoreICParameters p(context, receiver, var_unique.value(), value, {},
nullptr);
UndefinedConstant());
ExitPoint direct_exit(this);
EmitGenericPropertyStore(CAST(receiver), receiver_map, &p, &direct_exit,
&slow, language_mode);
......@@ -1112,7 +1112,8 @@ void KeyedStoreGenericAssembler::SetProperty(TNode<Context> context,
TNode<Name> unique_name,
TNode<Object> value,
LanguageMode language_mode) {
StoreICParameters p(context, receiver, unique_name, value, {}, nullptr);
StoreICParameters p(context, receiver, unique_name, value, {},
UndefinedConstant());
Label done(this), slow(this, Label::kDeferred);
ExitPoint exit_point(this, [&](TNode<Object> result) { Goto(&done); });
......
test/cctest/test-accessor-assembler.cc
View file @ 1f1e4cdb
......@@ -28,9 +28,10 @@ void TestStubCacheOffsetCalculation(StubCache::Table table) {
AccessorAssembler m(data.state());
{
Node* name = m.Parameter(0);
Node* map = m.Parameter(1);
Node* primary_offset = m.StubCachePrimaryOffsetForTesting(name, map);
TNode<Name> name = m.CAST(m.Parameter(0));
TNode<Map> map = m.CAST(m.Parameter(1));
TNode<IntPtrT> primary_offset =
m.StubCachePrimaryOffsetForTesting(name, map);
Node* result;
if (table == StubCache::kPrimary) {
result = primary_offset;
......@@ -59,7 +60,6 @@ void TestStubCacheOffsetCalculation(StubCache::Table table) {
};
Handle<Map> maps[] = {
Handle<Map>(Map(), isolate),
factory->cell_map(),
Map::Create(isolate, 0),
factory->meta_map(),
......@@ -128,8 +128,8 @@ TEST(TryProbeStubCache) {
stub_cache.Clear();
{
Node* receiver = m.Parameter(0);
TNode<Object> name = m.CAST(m.Parameter(1));
TNode<Object> receiver = m.CAST(m.Parameter(0));
TNode<Name> name = m.CAST(m.Parameter(1));
TNode<MaybeObject> expected_handler =
m.UncheckedCast<MaybeObject>(m.Parameter(2));
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment