[csa][cleanup] Remove return values from Store operators

They are never used, and can't really be TNodified since they are
not a value output in any case.

BUG=v8:6949,v8:11074

Change-Id: Id6f5807247c6fe53fb12dce9e2cfc66b5a046398
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2532305
Commit-Queue: Ross McIlroy <rmcilroy@chromium.org>
Auto-Submit: Ross McIlroy <rmcilroy@chromium.org>
Reviewed-by: Santiago Aboy Solanes <solanes@chromium.org>
Cr-Commit-Position: refs/heads/master@{#71133}

src/compiler/code-assembler.cc

@@ -708,9 +708,9 @@ TNode<Object> CodeAssembler::LoadRoot(RootIndex root_index) {
       LoadFullTagged(isolate_root, IntPtrConstant(offset)));
 }
 
-Node* CodeAssembler::Store(Node* base, Node* value) {
-  return raw_assembler()->Store(MachineRepresentation::kTagged, base, value,
-                                kFullWriteBarrier);
+void CodeAssembler::Store(Node* base, Node* value) {
+  raw_assembler()->Store(MachineRepresentation::kTagged, base, value,
+                         kFullWriteBarrier);
 }
 
 void CodeAssembler::StoreToObject(MachineRepresentation rep,
@@ -763,51 +763,51 @@ void CodeAssembler::OptimizedStoreMap(TNode<HeapObject> object,
   raw_assembler()->OptimizedStoreMap(object, map);
 }
 
-Node* CodeAssembler::Store(Node* base, Node* offset, Node* value) {
-  return raw_assembler()->Store(MachineRepresentation::kTagged, base, offset,
-                                value, kFullWriteBarrier);
+void CodeAssembler::Store(Node* base, Node* offset, Node* value) {
+  raw_assembler()->Store(MachineRepresentation::kTagged, base, offset, value,
+                         kFullWriteBarrier);
 }
 
-Node* CodeAssembler::StoreEphemeronKey(Node* base, Node* offset, Node* value) {
-  return raw_assembler()->Store(MachineRepresentation::kTagged, base, offset,
-                                value, kEphemeronKeyWriteBarrier);
+void CodeAssembler::StoreEphemeronKey(Node* base, Node* offset, Node* value) {
+  raw_assembler()->Store(MachineRepresentation::kTagged, base, offset, value,
+                         kEphemeronKeyWriteBarrier);
 }
 
-Node* CodeAssembler::StoreNoWriteBarrier(MachineRepresentation rep, Node* base,
-                                         Node* value) {
-  return raw_assembler()->Store(
+void CodeAssembler::StoreNoWriteBarrier(MachineRepresentation rep, Node* base,
+                                        Node* value) {
+  raw_assembler()->Store(
       rep, base, value,
       CanBeTaggedPointer(rep) ? kAssertNoWriteBarrier : kNoWriteBarrier);
 }
 
-Node* CodeAssembler::StoreNoWriteBarrier(MachineRepresentation rep, Node* base,
-                                         Node* offset, Node* value) {
-  return raw_assembler()->Store(
+void CodeAssembler::StoreNoWriteBarrier(MachineRepresentation rep, Node* base,
+                                        Node* offset, Node* value) {
+  raw_assembler()->Store(
       rep, base, offset, value,
       CanBeTaggedPointer(rep) ? kAssertNoWriteBarrier : kNoWriteBarrier);
 }
 
-Node* CodeAssembler::UnsafeStoreNoWriteBarrier(MachineRepresentation rep,
-                                               Node* base, Node* value) {
-  return raw_assembler()->Store(rep, base, value, kNoWriteBarrier);
+void CodeAssembler::UnsafeStoreNoWriteBarrier(MachineRepresentation rep,
+                                              Node* base, Node* value) {
+  raw_assembler()->Store(rep, base, value, kNoWriteBarrier);
 }
 
-Node* CodeAssembler::UnsafeStoreNoWriteBarrier(MachineRepresentation rep,
-                                               Node* base, Node* offset,
-                                               Node* value) {
-  return raw_assembler()->Store(rep, base, offset, value, kNoWriteBarrier);
+void CodeAssembler::UnsafeStoreNoWriteBarrier(MachineRepresentation rep,
+                                              Node* base, Node* offset,
+                                              Node* value) {
+  raw_assembler()->Store(rep, base, offset, value, kNoWriteBarrier);
 }
 
-Node* CodeAssembler::StoreFullTaggedNoWriteBarrier(Node* base,
-                                                   Node* tagged_value) {
-  return StoreNoWriteBarrier(MachineType::PointerRepresentation(), base,
-                             BitcastTaggedToWord(tagged_value));
+void CodeAssembler::StoreFullTaggedNoWriteBarrier(Node* base,
+                                                  Node* tagged_value) {
+  StoreNoWriteBarrier(MachineType::PointerRepresentation(), base,
+                      BitcastTaggedToWord(tagged_value));
 }
 
-Node* CodeAssembler::StoreFullTaggedNoWriteBarrier(Node* base, Node* offset,
-                                                   Node* tagged_value) {
-  return StoreNoWriteBarrier(MachineType::PointerRepresentation(), base, offset,
-                             BitcastTaggedToWord(tagged_value));
+void CodeAssembler::StoreFullTaggedNoWriteBarrier(Node* base, Node* offset,
+                                                  Node* tagged_value) {
+  StoreNoWriteBarrier(MachineType::PointerRepresentation(), base, offset,
+                      BitcastTaggedToWord(tagged_value));
 }
 
 void CodeAssembler::AtomicStore(MachineRepresentation rep, TNode<RawPtrT> base,
@@ -880,13 +880,12 @@ CodeAssembler::AtomicCompareExchange64<AtomicUint64>(
     TNode<UintPtrT> new_value, TNode<UintPtrT> old_value_high,
     TNode<UintPtrT> new_value_high);
 
-Node* CodeAssembler::StoreRoot(RootIndex root_index, Node* value) {
+void CodeAssembler::StoreRoot(RootIndex root_index, Node* value) {
   DCHECK(!RootsTable::IsImmortalImmovable(root_index));
   TNode<ExternalReference> isolate_root =
       ExternalConstant(ExternalReference::isolate_root(isolate()));
   int offset = IsolateData::root_slot_offset(root_index);
-  return StoreFullTaggedNoWriteBarrier(isolate_root, IntPtrConstant(offset),
-                                       value);
+  StoreFullTaggedNoWriteBarrier(isolate_root, IntPtrConstant(offset), value);
 }
 
 Node* CodeAssembler::Projection(int index, Node* value) {

src/compiler/code-assembler.h

@@ -767,22 +767,22 @@ class V8_EXPORT_PRIVATE CodeAssembler {
   TNode<Object> LoadRoot(RootIndex root_index);
 
   // Store value to raw memory location.
-  Node* Store(Node* base, Node* value);
-  Node* Store(Node* base, Node* offset, Node* value);
-  Node* StoreEphemeronKey(Node* base, Node* offset, Node* value);
-  Node* StoreNoWriteBarrier(MachineRepresentation rep, Node* base, Node* value);
-  Node* StoreNoWriteBarrier(MachineRepresentation rep, Node* base, Node* offset,
-                            Node* value);
-  Node* UnsafeStoreNoWriteBarrier(MachineRepresentation rep, Node* base,
-                                  Node* value);
-  Node* UnsafeStoreNoWriteBarrier(MachineRepresentation rep, Node* base,
-                                  Node* offset, Node* value);
+  void Store(Node* base, Node* value);
+  void Store(Node* base, Node* offset, Node* value);
+  void StoreEphemeronKey(Node* base, Node* offset, Node* value);
+  void StoreNoWriteBarrier(MachineRepresentation rep, Node* base, Node* value);
+  void StoreNoWriteBarrier(MachineRepresentation rep, Node* base, Node* offset,
+                           Node* value);
+  void UnsafeStoreNoWriteBarrier(MachineRepresentation rep, Node* base,
+                                 Node* value);
+  void UnsafeStoreNoWriteBarrier(MachineRepresentation rep, Node* base,
+                                 Node* offset, Node* value);
 
   // Stores uncompressed tagged value to (most likely off JS heap) memory
   // location without write barrier.
-  Node* StoreFullTaggedNoWriteBarrier(Node* base, Node* tagged_value);
-  Node* StoreFullTaggedNoWriteBarrier(Node* base, Node* offset,
-                                      Node* tagged_value);
+  void StoreFullTaggedNoWriteBarrier(Node* base, Node* tagged_value);
+  void StoreFullTaggedNoWriteBarrier(Node* base, Node* offset,
+                                     Node* tagged_value);
 
   // Optimized memory operations that map to Turbofan simplified nodes.
   TNode<HeapObject> OptimizedAllocate(TNode<IntPtrT> size,
@@ -859,7 +859,7 @@ class V8_EXPORT_PRIVATE CodeAssembler {
                                       TNode<UintPtrT> new_value_high);
 
   // Store a value to the root array.
-  Node* StoreRoot(RootIndex root_index, Node* value);
+  void StoreRoot(RootIndex root_index, Node* value);
 
 // Basic arithmetic operations.
 #define DECLARE_CODE_ASSEMBLER_BINARY_OP(name, ResType, Arg1Type, Arg2Type) \