[ptr-compr][turbofan] Removing LoadMessage/StoreMessage simplified operators

Going back on https://chromium-review.googlesource.com/c/v8/v8/+/1445978
since now 'tagged' means 'full tagged' again.

Cq-Include-Trybots: luci.v8.try:v8_linux64_pointer_compression_rel_ng
Cq-Include-Trybots: luci.v8.try:v8_linux64_arm64_pointer_compression_rel_ng
Bug: v8:8977, v8:7703
Change-Id: I3e39d631cc720a28577dad482dadfcc8332b6b18
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1593301
Commit-Queue: Santiago Aboy Solanes <solanes@chromium.org>
Reviewed-by: Jaroslav Sevcik <jarin@chromium.org>
Reviewed-by: Sigurd Schneider <sigurds@chromium.org>
Reviewed-by: Michael Stanton <mvstanton@chromium.org>
Cr-Commit-Position: refs/heads/master@{#61339}

src/compiler/access-builder.cc

@@ -23,9 +23,10 @@ namespace internal {
 namespace compiler {
 
 // static
-FieldAccess AccessBuilder::ForExternalIntPtr() {
-  FieldAccess access = {kUntaggedBase,      0,           MaybeHandle<Name>(),
-                        MaybeHandle<Map>(), Type::Any(), MachineType::IntPtr(),
+FieldAccess AccessBuilder::ForExternalTaggedValue() {
+  FieldAccess access = {kUntaggedBase,       0,
+                        MaybeHandle<Name>(), MaybeHandle<Map>(),
+                        Type::Any(),         MachineType::AnyTagged(),
                         kNoWriteBarrier};
   return access;
 }

src/compiler/access-builder.h

@@ -24,8 +24,8 @@ class V8_EXPORT_PRIVATE AccessBuilder final
   // ===========================================================================
   // Access to external values (based on external references).
 
-  // Provides access to an intptr field identified by an external reference.
-  static FieldAccess ForExternalIntPtr();
+  // Provides access to a tagged field identified by an external reference.
+  static FieldAccess ForExternalTaggedValue();
 
   // Provides access to an uint8 field identified by an external reference.
   static FieldAccess ForExternalUint8Value();

src/compiler/effect-control-linearizer.cc

@@ -998,12 +998,6 @@ bool EffectControlLinearizer::TryWireInStateEffect(Node* node,
     case IrOpcode::kTransitionElementsKind:
       LowerTransitionElementsKind(node);
       break;
-    case IrOpcode::kLoadMessage:
-      result = LowerLoadMessage(node);
-      break;
-    case IrOpcode::kStoreMessage:
-      LowerStoreMessage(node);
-      break;
     case IrOpcode::kLoadFieldByIndex:
       result = LowerLoadFieldByIndex(node);
       break;
@@ -4330,20 +4324,6 @@ void EffectControlLinearizer::LowerTransitionElementsKind(Node* node) {
   __ Bind(&done);
 }
 
-Node* EffectControlLinearizer::LowerLoadMessage(Node* node) {
-  Node* offset = node->InputAt(0);
-  Node* object_pattern =
-      __ LoadField(AccessBuilder::ForExternalIntPtr(), offset);
-  return __ BitcastWordToTagged(object_pattern);
-}
-
-void EffectControlLinearizer::LowerStoreMessage(Node* node) {
-  Node* offset = node->InputAt(0);
-  Node* object = node->InputAt(1);
-  Node* object_pattern = __ BitcastTaggedToWord(object);
-  __ StoreField(AccessBuilder::ForExternalIntPtr(), offset, object_pattern);
-}
-
 Node* EffectControlLinearizer::LowerLoadFieldByIndex(Node* node) {
   Node* object = node->InputAt(0);
   Node* index = node->InputAt(1);

src/compiler/effect-control-linearizer.h

@@ -172,11 +172,9 @@ class V8_EXPORT_PRIVATE EffectControlLinearizer {
   Node* LowerMaybeGrowFastElements(Node* node, Node* frame_state);
   void LowerTransitionElementsKind(Node* node);
   Node* LowerLoadFieldByIndex(Node* node);
-  Node* LowerLoadMessage(Node* node);
   Node* LowerLoadTypedElement(Node* node);
   Node* LowerLoadDataViewElement(Node* node);
   Node* LowerLoadStackArgument(Node* node);
-  void LowerStoreMessage(Node* node);
   void LowerStoreTypedElement(Node* node);
   void LowerStoreDataViewElement(Node* node);
   void LowerStoreSignedSmallElement(Node* node);

src/compiler/js-typed-lowering.cc

@@ -2022,7 +2022,8 @@ Reduction JSTypedLowering::ReduceJSLoadMessage(Node* node) {
   ExternalReference const ref =
       ExternalReference::address_of_pending_message_obj(isolate());
   node->ReplaceInput(0, jsgraph()->ExternalConstant(ref));
-  NodeProperties::ChangeOp(node, simplified()->LoadMessage());
+  NodeProperties::ChangeOp(
+      node, simplified()->LoadField(AccessBuilder::ForExternalTaggedValue()));
   return Changed(node);
 }
 
@@ -2033,7 +2034,8 @@ Reduction JSTypedLowering::ReduceJSStoreMessage(Node* node) {
   Node* value = NodeProperties::GetValueInput(node, 0);
   node->ReplaceInput(0, jsgraph()->ExternalConstant(ref));
   node->ReplaceInput(1, value);
-  NodeProperties::ChangeOp(node, simplified()->StoreMessage());
+  NodeProperties::ChangeOp(
+      node, simplified()->StoreField(AccessBuilder::ForExternalTaggedValue()));
   return Changed(node);
 }
 

src/compiler/load-elimination.cc

@@ -116,10 +116,6 @@ Reduction LoadElimination::Reduce(Node* node) {
       return ReduceLoadField(node, FieldAccessOf(node->op()));
     case IrOpcode::kStoreField:
       return ReduceStoreField(node, FieldAccessOf(node->op()));
-    case IrOpcode::kStoreMessage:
-      return ReduceStoreField(node, AccessBuilder::ForExternalIntPtr());
-    case IrOpcode::kLoadMessage:
-      return ReduceLoadField(node, AccessBuilder::ForExternalIntPtr());
     case IrOpcode::kLoadElement:
       return ReduceLoadElement(node);
     case IrOpcode::kStoreElement:
@@ -1156,10 +1152,6 @@ LoadElimination::AbstractState const* LoadElimination::ComputeLoopState(
             state = ComputeLoopStateForStoreField(current, state,
                                                   FieldAccessOf(current->op()));
             break;
-          case IrOpcode::kStoreMessage:
-            state = ComputeLoopStateForStoreField(
-                current, state, AccessBuilder::ForExternalIntPtr());
-            break;
           case IrOpcode::kStoreElement: {
             Node* const object = NodeProperties::GetValueInput(current, 0);
             Node* const index = NodeProperties::GetValueInput(current, 1);

src/compiler/load-elimination.h

@@ -251,8 +251,6 @@ class V8_EXPORT_PRIVATE LoadElimination final
   Reduction ReduceStoreTypedElement(Node* node);
   Reduction ReduceEffectPhi(Node* node);
   Reduction ReduceStart(Node* node);
-  Reduction ReduceStoreMessage(Node* node);
-  Reduction ReduceLoadMessage(Node* node);
   Reduction ReduceOtherNode(Node* node);
 
   Reduction UpdateState(Node* node, AbstractState const* state);

src/compiler/opcodes.h

@@ -411,13 +411,11 @@
   V(LoadFieldByIndex)                   \
   V(LoadField)                          \
   V(LoadElement)                        \
-  V(LoadMessage)                        \
   V(LoadTypedElement)                   \
   V(LoadDataViewElement)                \
   V(LoadStackArgument)                  \
   V(StoreField)                         \
   V(StoreElement)                       \
-  V(StoreMessage)                       \
   V(StoreTypedElement)                  \
   V(StoreDataViewElement)               \
   V(StoreSignedSmallElement)            \

src/compiler/simplified-lowering.cc

@@ -2769,18 +2769,6 @@ class RepresentationSelector {
         SetOutput(node, MachineRepresentation::kTaggedPointer);
         return;
       }
-      case IrOpcode::kLoadMessage: {
-        if (truncation.IsUnused()) return VisitUnused(node);
-        VisitUnop(node, UseInfo::Word(), MachineRepresentation::kTagged);
-        return;
-      }
-      case IrOpcode::kStoreMessage: {
-        ProcessInput(node, 0, UseInfo::Word());
-        ProcessInput(node, 1, UseInfo::AnyTagged());
-        ProcessRemainingInputs(node, 2);
-        SetOutput(node, MachineRepresentation::kNone);
-        return;
-      }
       case IrOpcode::kLoadFieldByIndex: {
         if (truncation.IsUnused()) return VisitUnused(node);
         VisitBinop(node, UseInfo::AnyTagged(), UseInfo::TruncatingWord32(),

src/compiler/simplified-operator.cc

@@ -1119,28 +1119,6 @@ struct SimplifiedOperatorGlobalCache final {
   };
   LoadStackArgumentOperator kLoadStackArgument;
 
-  struct LoadMessageOperator final : public Operator {
-    LoadMessageOperator()
-        : Operator(                    // --
-              IrOpcode::kLoadMessage,  // opcode
-              Operator::kNoDeopt | Operator::kNoThrow |
-                  Operator::kNoWrite,  // flags
-              "LoadMessage",           // name
-              1, 1, 1, 1, 1, 0) {}     // counts
-  };
-  LoadMessageOperator kLoadMessage;
-
-  struct StoreMessageOperator final : public Operator {
-    StoreMessageOperator()
-        : Operator(                     // --
-              IrOpcode::kStoreMessage,  // opcode
-              Operator::kNoDeopt | Operator::kNoThrow |
-                  Operator::kNoRead,  // flags
-              "StoreMessage",         // name
-              2, 1, 1, 0, 1, 0) {}    // counts
-  };
-  StoreMessageOperator kStoreMessage;
-
 #define SPECULATIVE_NUMBER_BINOP(Name)                                      \
   template <NumberOperationHint kHint>                                      \
   struct Name##Operator final : public Operator1<NumberOperationHint> {     \
@@ -1733,14 +1711,6 @@ SPECULATIVE_NUMBER_BINOP_LIST(SPECULATIVE_NUMBER_BINOP)
 ACCESS_OP_LIST(ACCESS)
 #undef ACCESS
 
-const Operator* SimplifiedOperatorBuilder::LoadMessage() {
-  return &cache_.kLoadMessage;
-}
-
-const Operator* SimplifiedOperatorBuilder::StoreMessage() {
-  return &cache_.kStoreMessage;
-}
-
 const Operator* SimplifiedOperatorBuilder::LoadStackArgument() {
   return &cache_.kLoadStackArgument;
 }

src/compiler/simplified-operator.h

@@ -806,9 +806,6 @@ class V8_EXPORT_PRIVATE SimplifiedOperatorBuilder final
   const Operator* LoadField(FieldAccess const&);
   const Operator* StoreField(FieldAccess const&);
 
-  const Operator* LoadMessage();
-  const Operator* StoreMessage();
-
   // load-element [base + index]
   const Operator* LoadElement(ElementAccess const&);
 

src/compiler/typer.cc

@@ -2151,8 +2151,6 @@ Type Typer::Visitor::TypeLoadField(Node* node) {
   return FieldAccessOf(node->op()).type;
 }
 
-Type Typer::Visitor::TypeLoadMessage(Node* node) { return Type::Any(); }
-
 Type Typer::Visitor::TypeLoadElement(Node* node) {
   return ElementAccessOf(node->op()).type;
 }
@@ -2184,7 +2182,6 @@ Type Typer::Visitor::TypeLoadDataViewElement(Node* node) {
 }
 
 Type Typer::Visitor::TypeStoreField(Node* node) { UNREACHABLE(); }
-Type Typer::Visitor::TypeStoreMessage(Node* node) { UNREACHABLE(); }
 
 Type Typer::Visitor::TypeStoreElement(Node* node) { UNREACHABLE(); }
 

src/compiler/verifier.cc

@@ -1553,7 +1553,6 @@ void Verifier::Visitor::Check(Node* node, const AllNodes& all) {
       CheckTypeIs(node, Type::NonInternal());
       break;
     case IrOpcode::kLoadField:
-    case IrOpcode::kLoadMessage:
       // Object -> fieldtype
       // TODO(rossberg): activate once machine ops are typed.
       // CheckValueInputIs(node, 0, Type::Object());
@@ -1571,7 +1570,6 @@ void Verifier::Visitor::Check(Node* node, const AllNodes& all) {
     case IrOpcode::kLoadDataViewElement:
       break;
     case IrOpcode::kStoreField:
-    case IrOpcode::kStoreMessage:
       // (Object, fieldtype) -> _|_
       // TODO(rossberg): activate once machine ops are typed.
       // CheckValueInputIs(node, 0, Type::Object());