[WIP] TrapHandler 2014/11/27.

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/base/platform/platform.h"
 #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 "test/unittests/compiler/node-test-utils.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)
-#undef TYPED_ARRAY_CASE
-};
-
-
 Type* const kJSTypes[] = {Type::Undefined(), Type::Null(),   Type::Boolean(),
                           Type::Number(),    Type::String(), Type::Object()};
 
 
-const StrictMode kStrictModes[] = {SLOPPY, STRICT};
-
 }  // namespace
 
 
 class JSTypedLoweringTest : public TypedGraphTest {
  public:
-  JSTypedLoweringTest() : TypedGraphTest(3), javascript_(zone()) {}
+  JSTypedLoweringTest()
+      : TypedGraphTest(3), javascript_(zone()), machine_(zone()) {}
   virtual ~JSTypedLoweringTest() {}
 
  protected:
   Reduction Reduce(Node* node) {
-    MachineOperatorBuilder machine(zone());
-    JSGraph jsgraph(graph(), common(), javascript(), &machine);
+    JSGraph jsgraph(graph(), common(), javascript(), machine());
     JSTypedLowering reducer(&jsgraph);
     return reducer.Reduce(node);
   }
 
   Node* Parameter(Type* type, int index = 0) {
     Node* node = graph()->NewNode(common()->Parameter(index), graph()->start());
     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);
+    // TODO(bmeurer): Use SetupAllocatingData here.
+    Runtime::SetupArrayBuffer(isolate(), buffer, true, false, 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_; }
+  MachineOperatorBuilder* machine() { return &machine_; }
 
  private:
   JSOperatorBuilder javascript_;
+  MachineOperatorBuilder machine_;
 };
 
 
 // -----------------------------------------------------------------------------
 // JSToBoolean
 
 
 TEST_F(JSTypedLoweringTest, JSToBooleanWithString) {
   Node* input = Parameter(Type::String());
   Node* context = UndefinedConstant();
@@ skipping 140 matching lines @@
   Node* const context = UndefinedConstant();
   Node* const effect = graph()->start();
   Node* const control = graph()->start();
   Reduction r = Reduce(graph()->NewNode(javascript()->ShiftRightLogical(), lhs,
                                         rhs, context, effect, control));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(),
               IsWord32Shr(lhs, IsWord32And(rhs, IsInt32Constant(0x1f))));
 }
 
-
-// -----------------------------------------------------------------------------
-// JSLoadProperty
-
-
-TEST_F(JSTypedLoweringTest, JSLoadPropertyFromExternalTypedArray) {
-  const size_t kLength = 17;
-  double backing_store[kLength];
-  Handle<JSArrayBuffer> buffer =
-      NewArrayBuffer(backing_store, sizeof(backing_store));
-  VectorSlotPair feedback(Handle<TypeFeedbackVector>::null(),
-                          FeedbackVectorICSlot::Invalid());
-  TRACED_FOREACH(ExternalArrayType, type, kExternalArrayTypes) {
-    Handle<JSTypedArray> array =
-        factory()->NewJSTypedArray(type, buffer, 0, kLength);
-
-    Node* key = Parameter(Type::Integral32());
-    Node* base = HeapConstant(array);
-    Node* context = UndefinedConstant();
-    Node* effect = graph()->start();
-    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);
-
-    ASSERT_TRUE(r.Changed());
-    EXPECT_THAT(r.replacement(),
-                IsLoadElement(
-                    AccessBuilder::ForTypedArrayElement(type, true),
-                    IsIntPtrConstant(bit_cast<intptr_t>(&backing_store[0])),
-                    key, IsNumberConstant(array->length()->Number()), effect));
-  }
-}
-
-
-// -----------------------------------------------------------------------------
-// JSStoreProperty
-
-
-TEST_F(JSTypedLoweringTest, JSStorePropertyToExternalTypedArray) {
-  const size_t kLength = 17;
-  double backing_store[kLength];
-  Handle<JSArrayBuffer> buffer =
-      NewArrayBuffer(backing_store, sizeof(backing_store));
-  TRACED_FOREACH(ExternalArrayType, type, kExternalArrayTypes) {
-    TRACED_FOREACH(StrictMode, strict_mode, kStrictModes) {
-      Handle<JSTypedArray> array =
-          factory()->NewJSTypedArray(type, buffer, 0, kLength);
-
-      Node* key = Parameter(Type::Integral32());
-      Node* base = HeapConstant(array);
-      Node* value =
-          Parameter(AccessBuilder::ForTypedArrayElement(type, true).type);
-      Node* context = UndefinedConstant();
-      Node* effect = graph()->start();
-      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);
-
-      ASSERT_TRUE(r.Changed());
-      EXPECT_THAT(r.replacement(),
-                  IsStoreElement(
-                      AccessBuilder::ForTypedArrayElement(type, true),
-                      IsIntPtrConstant(bit_cast<intptr_t>(&backing_store[0])),
-                      key, IsNumberConstant(array->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));
-  TRACED_FOREACH(ExternalArrayType, type, kExternalArrayTypes) {
-    TRACED_FOREACH(StrictMode, strict_mode, kStrictModes) {
-      Handle<JSTypedArray> array =
-          factory()->NewJSTypedArray(type, buffer, 0, kLength);
-
-      Node* key = Parameter(Type::Integral32());
-      Node* base = HeapConstant(array);
-      Node* value = Parameter(Type::Any());
-      Node* context = UndefinedConstant();
-      Node* effect = graph()->start();
-      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);
-
-      Matcher<Node*> value_matcher =
-          IsToNumber(value, context, effect, control);
-      Matcher<Node*> effect_matcher = value_matcher;
-      if (AccessBuilder::ForTypedArrayElement(type, true)
-              .type->Is(Type::Signed32())) {
-        value_matcher = IsNumberToInt32(value_matcher);
-      } else if (AccessBuilder::ForTypedArrayElement(type, true)
-                     .type->Is(Type::Unsigned32())) {
-        value_matcher = IsNumberToUint32(value_matcher);
-      }
-
-      ASSERT_TRUE(r.Changed());
-      EXPECT_THAT(r.replacement(),
-                  IsStoreElement(
-                      AccessBuilder::ForTypedArrayElement(type, true),
-                      IsIntPtrConstant(bit_cast<intptr_t>(&backing_store[0])),
-                      key, IsNumberConstant(array->length()->Number()),
-                      value_matcher, effect_matcher, control));
-    }
-  }
-}
-
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8