[turbofan] Introduce an ExternalPointer type.

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/js-typed-lowering.h"
 #include "src/code-factory.h"
 #include "src/compilation-dependencies.h"
 #include "src/compiler/access-builder.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/js-operator.h"
@@ skipping 52 matching lines @@
                             zone());
     return reducer.Reduce(node);
   }
 
   Handle<JSArrayBuffer> NewArrayBuffer(void* bytes, size_t byte_length) {
     Handle<JSArrayBuffer> buffer = factory()->NewJSArrayBuffer();
     JSArrayBuffer::Setup(buffer, isolate(), 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_;
   CompilationDependencies deps_;
 };
 
 
 // -----------------------------------------------------------------------------
 // JSToBoolean
@@ skipping 474 matching lines @@
     Matcher<Node*> offset_matcher =
         element_size == 1
             ? key
             : IsNumberShiftLeft(key,
                                 IsNumberConstant(WhichPowerOf2(element_size)));
 
     ASSERT_TRUE(r.Changed());
     EXPECT_THAT(
         r.replacement(),
         IsLoadBuffer(BufferAccess(type),
-                     IsIntPtrConstant(bit_cast<intptr_t>(&backing_store[0])),
+                     IsPointerConstant(bit_cast<intptr_t>(&backing_store[0])),
                      offset_matcher,
                      IsNumberConstant(array->byte_length()->Number()), effect,
                      control));
   }
 }
 
 
 TEST_F(JSTypedLoweringTest, JSLoadPropertyFromExternalTypedArrayWithSafeKey) {
   const size_t kLength = 17;
   double backing_store[kLength];
@@ skipping 15 matching lines @@
     Node* effect = graph()->start();
     Node* control = graph()->start();
     Reduction r = Reduce(graph()->NewNode(javascript()->LoadProperty(feedback),
                                           base, key, vector, context,
                                           EmptyFrameState(), effect, control));
 
     ASSERT_TRUE(r.Changed());
     EXPECT_THAT(
         r.replacement(),
         IsLoadElement(access,
-                      IsIntPtrConstant(bit_cast<intptr_t>(&backing_store[0])),
+                      IsPointerConstant(bit_cast<intptr_t>(&backing_store[0])),
                       key, effect, control));
   }
 }
 
 
 // -----------------------------------------------------------------------------
 // JSStoreProperty
 
 
 TEST_F(JSTypedLoweringTest, JSStorePropertyToExternalTypedArray) {
@@ skipping 24 matching lines @@
 
       Matcher<Node*> offset_matcher =
           element_size == 1
               ? key
               : IsNumberShiftLeft(
                     key, IsNumberConstant(WhichPowerOf2(element_size)));
 
       ASSERT_TRUE(r.Changed());
       EXPECT_THAT(
           r.replacement(),
-          IsStoreBuffer(BufferAccess(type),
-                        IsIntPtrConstant(bit_cast<intptr_t>(&backing_store[0])),
-                        offset_matcher,
-                        IsNumberConstant(array->byte_length()->Number()), value,
-                        effect, control));
+          IsStoreBuffer(
+              BufferAccess(type),
+              IsPointerConstant(bit_cast<intptr_t>(&backing_store[0])),
+              offset_matcher, IsNumberConstant(array->byte_length()->Number()),
+              value, effect, control));
     }
   }
 }
 
 
 TEST_F(JSTypedLoweringTest, JSStorePropertyToExternalTypedArrayWithConversion) {
   const size_t kLength = 17;
   double backing_store[kLength];
   Handle<JSArrayBuffer> buffer =
       NewArrayBuffer(backing_store, sizeof(backing_store));
@@ skipping 28 matching lines @@
                     key, IsNumberConstant(WhichPowerOf2(element_size)));
 
       Matcher<Node*> value_matcher =
           IsToNumber(value, context, checkpoint, control);
       Matcher<Node*> effect_matcher = value_matcher;
       Matcher<Node*> control_matcher = IsIfSuccess(value_matcher);
 
       ASSERT_TRUE(r.Changed());
       EXPECT_THAT(
           r.replacement(),
-          IsStoreBuffer(BufferAccess(type),
-                        IsIntPtrConstant(bit_cast<intptr_t>(&backing_store[0])),
-                        offset_matcher,
-                        IsNumberConstant(array->byte_length()->Number()),
-                        value_matcher, effect_matcher, control_matcher));
+          IsStoreBuffer(
+              BufferAccess(type),
+              IsPointerConstant(bit_cast<intptr_t>(&backing_store[0])),
+              offset_matcher, IsNumberConstant(array->byte_length()->Number()),
+              value_matcher, effect_matcher, control_matcher));
     }
   }
 }
 
 
 TEST_F(JSTypedLoweringTest, JSStorePropertyToExternalTypedArrayWithSafeKey) {
   const size_t kLength = 17;
   double backing_store[kLength];
   Handle<JSArrayBuffer> buffer =
       NewArrayBuffer(backing_store, sizeof(backing_store));
@@ skipping 16 matching lines @@
       VectorSlotPair feedback;
       const Operator* op = javascript()->StoreProperty(language_mode, feedback);
       Node* node = graph()->NewNode(op, base, key, value, vector, context,
                                     EmptyFrameState(), effect, control);
       Reduction r = Reduce(node);
 
       ASSERT_TRUE(r.Changed());
       EXPECT_THAT(
           r.replacement(),
           IsStoreElement(
-              access, IsIntPtrConstant(bit_cast<intptr_t>(&backing_store[0])),
+              access, IsPointerConstant(bit_cast<intptr_t>(&backing_store[0])),
               key, value, effect, control));
     }
   }
 }
 
 
 // -----------------------------------------------------------------------------
 // JSLoadNamed
 
 
@@ skipping 249 matching lines @@
                                         EmptyFrameState(), effect, control));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(), IsSpeculativeNumberBitwiseXor(
                                    NumberOperationHint::kNumberOrOddball, lhs,
                                    rhs, effect, control));
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8