[turbofan] Embed the actual backing store address for typed loads/stores.

test/unittests/compiler/js-typed-lowering-unittest.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/access-builder.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/js-operator.h"
 #include "src/compiler/js-typed-lowering.h"
 #include "src/compiler/machine-operator.h"
 #include "src/compiler/node-properties-inl.h"
 #include "src/compiler/typer.h"
 #include "test/unittests/compiler/compiler-test-utils.h"
 #include "test/unittests/compiler/graph-unittest.h"
-#include "testing/gmock-support.h"
-
-using testing::_;
-using testing::AllOf;
-using testing::Capture;
-using testing::CaptureEq;
+#include "testing/gtest-support.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 namespace {
 
 const ExternalArrayType kExternalArrayTypes[] = {
 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) kExternal##Type##Array,
     TYPED_ARRAYS(TYPED_ARRAY_CASE)
@@ skipping 25 matching lines @@
     NodeProperties::SetBounds(node, Bounds(Type::None(), type));
     return node;
   }
 
   Handle<JSArrayBuffer> NewArrayBuffer(void* bytes, size_t byte_length) {
     Handle<JSArrayBuffer> buffer = factory()->NewJSArrayBuffer();
     Runtime::SetupArrayBuffer(isolate(), buffer, true, bytes, byte_length);
     return buffer;
   }
 
+  Matcher<Node*> IsIntPtrConstant(intptr_t value) {
+    return sizeof(value) == 4 ? IsInt32Constant(static_cast<int32_t>(value))
+                              : IsInt64Constant(static_cast<int64_t>(value));
+  }
+
   JSOperatorBuilder* javascript() { return &javascript_; }
 
  private:
   JSOperatorBuilder javascript_;
 };
 
 
 // -----------------------------------------------------------------------------
 // JSLoadProperty
 
@@ skipping 16 matching lines @@
     Node* control = graph()->start();
     Node* node = graph()->NewNode(javascript()->LoadProperty(feedback), base,
                                   key, context);
     if (FLAG_turbo_deoptimization) {
       node->AppendInput(zone(), UndefinedConstant());
     }
     node->AppendInput(zone(), effect);
     node->AppendInput(zone(), control);
     Reduction r = Reduce(node);
 
-    Capture<Node*> elements;
     ASSERT_TRUE(r.Changed());
     EXPECT_THAT(
         r.replacement(),
-        IsLoadElement(
-            AccessBuilder::ForTypedArrayElement(type, true),
-            IsLoadField(AccessBuilder::ForExternalArrayPointer(),
-                        AllOf(CaptureEq(&elements),
-                              IsLoadField(AccessBuilder::ForJSObjectElements(),
-                                          base, _)),
-                        CaptureEq(&elements)),
-            key, IsInt32Constant(static_cast<int>(kLength)), effect, control));
+        IsLoadElement(AccessBuilder::ForTypedArrayElement(type, true),
+                      IsIntPtrConstant(bit_cast<intptr_t>(&backing_store[0])),
+                      key, IsInt32Constant(static_cast<int>(kLength)), effect,
+                      control));
   }
 }
 
 
 // -----------------------------------------------------------------------------
 // JSStoreProperty
 
 
 TEST_F(JSTypedLoweringTest, JSStorePropertyToExternalTypedArray) {
   const size_t kLength = 17;
@@ skipping 13 matching lines @@
       Node* control = graph()->start();
       Node* node = graph()->NewNode(javascript()->StoreProperty(strict_mode),
                                     base, key, value, context);
       if (FLAG_turbo_deoptimization) {
         node->AppendInput(zone(), UndefinedConstant());
       }
       node->AppendInput(zone(), effect);
       node->AppendInput(zone(), control);
       Reduction r = Reduce(node);
 
-      Capture<Node*> elements;
       ASSERT_TRUE(r.Changed());
-      EXPECT_THAT(
-          r.replacement(),
-          IsStoreElement(
-              AccessBuilder::ForTypedArrayElement(type, true),
-              IsLoadField(
-                  AccessBuilder::ForExternalArrayPointer(),
-                  AllOf(CaptureEq(&elements),
-                        IsLoadField(AccessBuilder::ForJSObjectElements(), base,
-                                    _)),
-                  CaptureEq(&elements)),
-              key, IsInt32Constant(static_cast<int>(kLength)), value, effect,
-              control));
+      EXPECT_THAT(r.replacement(),
+                  IsStoreElement(
+                      AccessBuilder::ForTypedArrayElement(type, true),
+                      IsIntPtrConstant(bit_cast<intptr_t>(&backing_store[0])),
+                      key, IsInt32Constant(static_cast<int>(kLength)), value,
+                      effect, control));
     }
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8