summaryrefslogtreecommitdiff
path: root/deps/v8/src/compiler/node-properties.cc
diff options
context:
space:
mode:
Diffstat (limited to 'deps/v8/src/compiler/node-properties.cc')
-rw-r--r--deps/v8/src/compiler/node-properties.cc82
1 files changed, 47 insertions, 35 deletions
diff --git a/deps/v8/src/compiler/node-properties.cc b/deps/v8/src/compiler/node-properties.cc
index d72980f9fd..8e3421c1a0 100644
--- a/deps/v8/src/compiler/node-properties.cc
+++ b/deps/v8/src/compiler/node-properties.cc
@@ -364,11 +364,11 @@ bool NodeProperties::IsSame(Node* a, Node* b) {
// static
NodeProperties::InferReceiverMapsResult NodeProperties::InferReceiverMaps(
- Isolate* isolate, Node* receiver, Node* effect,
+ JSHeapBroker* broker, Node* receiver, Node* effect,
ZoneHandleSet<Map>* maps_return) {
HeapObjectMatcher m(receiver);
if (m.HasValue()) {
- Handle<HeapObject> receiver = m.Value();
+ HeapObjectRef receiver = m.Ref(broker).AsHeapObject();
// We don't use ICs for the Array.prototype and the Object.prototype
// because the runtime has to be able to intercept them properly, so
// we better make sure that TurboFan doesn't outsmart the system here
@@ -376,15 +376,12 @@ NodeProperties::InferReceiverMapsResult NodeProperties::InferReceiverMaps(
//
// TODO(bmeurer): This can be removed once the Array.prototype and
// Object.prototype have NO_ELEMENTS elements kind.
- if (!isolate->IsInAnyContext(*receiver,
- Context::INITIAL_ARRAY_PROTOTYPE_INDEX) &&
- !isolate->IsInAnyContext(*receiver,
- Context::INITIAL_OBJECT_PROTOTYPE_INDEX)) {
- Handle<Map> receiver_map(receiver->map(), isolate);
- if (receiver_map->is_stable()) {
+ if (!receiver.IsJSObject() ||
+ !broker->IsArrayOrObjectPrototype(receiver.AsJSObject())) {
+ if (receiver.map().is_stable()) {
// The {receiver_map} is only reliable when we install a stability
// code dependency.
- *maps_return = ZoneHandleSet<Map>(receiver_map);
+ *maps_return = ZoneHandleSet<Map>(receiver.map().object());
return kUnreliableReceiverMaps;
}
}
@@ -413,15 +410,14 @@ NodeProperties::InferReceiverMapsResult NodeProperties::InferReceiverMaps(
HeapObjectMatcher mtarget(GetValueInput(effect, 0));
HeapObjectMatcher mnewtarget(GetValueInput(effect, 1));
if (mtarget.HasValue() && mnewtarget.HasValue() &&
- mnewtarget.Value()->IsJSFunction()) {
- Handle<JSFunction> original_constructor =
- Handle<JSFunction>::cast(mnewtarget.Value());
- if (original_constructor->has_initial_map()) {
- Handle<Map> initial_map(original_constructor->initial_map(),
- isolate);
- if (initial_map->constructor_or_backpointer() ==
- *mtarget.Value()) {
- *maps_return = ZoneHandleSet<Map>(initial_map);
+ mnewtarget.Ref(broker).IsJSFunction()) {
+ JSFunctionRef original_constructor =
+ mnewtarget.Ref(broker).AsJSFunction();
+ if (original_constructor.has_initial_map()) {
+ original_constructor.Serialize();
+ MapRef initial_map = original_constructor.initial_map();
+ if (initial_map.GetConstructor().equals(mtarget.Ref(broker))) {
+ *maps_return = ZoneHandleSet<Map>(initial_map.object());
return result;
}
}
@@ -431,6 +427,16 @@ NodeProperties::InferReceiverMapsResult NodeProperties::InferReceiverMaps(
}
break;
}
+ case IrOpcode::kJSCreatePromise: {
+ if (IsSame(receiver, effect)) {
+ *maps_return = ZoneHandleSet<Map>(broker->native_context()
+ .promise_function()
+ .initial_map()
+ .object());
+ return result;
+ }
+ break;
+ }
case IrOpcode::kStoreField: {
// We only care about StoreField of maps.
Node* const object = GetValueInput(effect, 0);
@@ -441,7 +447,7 @@ NodeProperties::InferReceiverMapsResult NodeProperties::InferReceiverMaps(
Node* const value = GetValueInput(effect, 1);
HeapObjectMatcher m(value);
if (m.HasValue()) {
- *maps_return = ZoneHandleSet<Map>(Handle<Map>::cast(m.Value()));
+ *maps_return = ZoneHandleSet<Map>(m.Ref(broker).AsMap().object());
return result;
}
}
@@ -505,12 +511,13 @@ NodeProperties::InferReceiverMapsResult NodeProperties::InferReceiverMaps(
}
// static
-MaybeHandle<Map> NodeProperties::GetMapWitness(Isolate* isolate, Node* node) {
+MaybeHandle<Map> NodeProperties::GetMapWitness(JSHeapBroker* broker,
+ Node* node) {
ZoneHandleSet<Map> maps;
Node* receiver = NodeProperties::GetValueInput(node, 1);
Node* effect = NodeProperties::GetEffectInput(node);
NodeProperties::InferReceiverMapsResult result =
- NodeProperties::InferReceiverMaps(isolate, receiver, effect, &maps);
+ NodeProperties::InferReceiverMaps(broker, receiver, effect, &maps);
if (result == NodeProperties::kReliableReceiverMaps && maps.size() == 1) {
return maps[0];
}
@@ -518,19 +525,20 @@ MaybeHandle<Map> NodeProperties::GetMapWitness(Isolate* isolate, Node* node) {
}
// static
-bool NodeProperties::HasInstanceTypeWitness(Isolate* isolate, Node* receiver,
- Node* effect,
+bool NodeProperties::HasInstanceTypeWitness(JSHeapBroker* broker,
+ Node* receiver, Node* effect,
InstanceType instance_type) {
ZoneHandleSet<Map> receiver_maps;
NodeProperties::InferReceiverMapsResult result =
- NodeProperties::InferReceiverMaps(isolate, receiver, effect,
+ NodeProperties::InferReceiverMaps(broker, receiver, effect,
&receiver_maps);
switch (result) {
case NodeProperties::kUnreliableReceiverMaps:
case NodeProperties::kReliableReceiverMaps:
DCHECK_NE(0, receiver_maps.size());
for (size_t i = 0; i < receiver_maps.size(); ++i) {
- if (receiver_maps[i]->instance_type() != instance_type) return false;
+ MapRef map(broker, receiver_maps[i]);
+ if (map.instance_type() != instance_type) return false;
}
return true;
@@ -555,7 +563,7 @@ bool NodeProperties::NoObservableSideEffectBetween(Node* effect,
}
// static
-bool NodeProperties::CanBePrimitive(Isolate* isolate, Node* receiver,
+bool NodeProperties::CanBePrimitive(JSHeapBroker* broker, Node* receiver,
Node* effect) {
switch (receiver->opcode()) {
#define CASE(Opcode) case IrOpcode::k##Opcode:
@@ -568,19 +576,21 @@ bool NodeProperties::CanBePrimitive(Isolate* isolate, Node* receiver,
case IrOpcode::kJSToObject:
return false;
case IrOpcode::kHeapConstant: {
- Handle<HeapObject> value = HeapObjectMatcher(receiver).Value();
- return value->IsPrimitive();
+ HeapObjectRef value =
+ HeapObjectMatcher(receiver).Ref(broker).AsHeapObject();
+ return value.map().IsPrimitiveMap();
}
default: {
// We don't really care about the exact maps here,
// just the instance types, which don't change
// across potential side-effecting operations.
ZoneHandleSet<Map> maps;
- if (InferReceiverMaps(isolate, receiver, effect, &maps) !=
+ if (InferReceiverMaps(broker, receiver, effect, &maps) !=
kNoReceiverMaps) {
- // Check if all {maps} are actually JSReceiver maps.
+ // Check if one of the {maps} is not a JSReceiver map.
for (size_t i = 0; i < maps.size(); ++i) {
- if (!maps[i]->IsJSReceiverMap()) return true;
+ MapRef map(broker, maps[i]);
+ if (!map.IsJSReceiverMap()) return true;
}
return false;
}
@@ -590,9 +600,9 @@ bool NodeProperties::CanBePrimitive(Isolate* isolate, Node* receiver,
}
// static
-bool NodeProperties::CanBeNullOrUndefined(Isolate* isolate, Node* receiver,
+bool NodeProperties::CanBeNullOrUndefined(JSHeapBroker* broker, Node* receiver,
Node* effect) {
- if (CanBePrimitive(isolate, receiver, effect)) {
+ if (CanBePrimitive(broker, receiver, effect)) {
switch (receiver->opcode()) {
case IrOpcode::kCheckInternalizedString:
case IrOpcode::kCheckNumber:
@@ -608,8 +618,10 @@ bool NodeProperties::CanBeNullOrUndefined(Isolate* isolate, Node* receiver,
case IrOpcode::kToBoolean:
return false;
case IrOpcode::kHeapConstant: {
- Handle<HeapObject> value = HeapObjectMatcher(receiver).Value();
- return value->IsNullOrUndefined(isolate);
+ HeapObjectRef value =
+ HeapObjectMatcher(receiver).Ref(broker).AsHeapObject();
+ OddballType type = value.map().oddball_type();
+ return type == OddballType::kNull || type == OddballType::kUndefined;
}
default:
return true;
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-01 11:47:07 +0000