Add support for untagged LoadField, StoreField, LoadElement, and StoreElement simplfied operators. …

test/cctest/compiler/test-simplified-lowering.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 <limits>
 
 #include "src/compiler/control-builders.h"
 #include "src/compiler/generic-node-inl.h"
 #include "src/compiler/node-properties-inl.h"
 #include "src/compiler/pipeline.h"
@@ skipping 68 matching lines @@
 
   Factory* factory() { return this->isolate()->factory(); }
   Heap* heap() { return this->isolate()->heap(); }
 };
 
 
 // TODO(dcarney): find a home for these functions.
 namespace {
 
 FieldAccess ForJSObjectMap() {
-  FieldAccess access = {JSObject::kMapOffset, Handle<Name>(), Type::Any(),
-                        kMachineTagged};
+  FieldAccess access = {kTaggedBase, JSObject::kMapOffset, Handle<Name>(),
+                        Type::Any(), kMachineTagged};
   return access;
 }
 
 
 FieldAccess ForJSObjectProperties() {
-  FieldAccess access = {JSObject::kPropertiesOffset, Handle<Name>(),
-                        Type::Any(), kMachineTagged};
+  FieldAccess access = {kTaggedBase, JSObject::kPropertiesOffset,
+                        Handle<Name>(), Type::Any(), kMachineTagged};
   return access;
 }
 
 
 FieldAccess ForArrayBufferBackingStore() {
   FieldAccess access = {
-      JSArrayBuffer::kBackingStoreOffset, Handle<Name>(), Type::UntaggedPtr(),
+      kTaggedBase,                           JSArrayBuffer::kBackingStoreOffset,
+      Handle<Name>(),                        Type::UntaggedPtr(),
       MachineOperatorBuilder::pointer_rep(),
   };
   return access;
 }
 
 
 ElementAccess ForFixedArrayElement() {
-  ElementAccess access = {FixedArray::kHeaderSize, Type::Any(), kMachineTagged};
+  ElementAccess access = {kTaggedBase, FixedArray::kHeaderSize, Type::Any(),
+                          kMachineTagged};
   return access;
 }
 
 
 ElementAccess ForBackingStoreElement(MachineRepresentation rep) {
-  ElementAccess access = {kNonHeapObjectHeaderSize, Type::Any(), rep};
+  ElementAccess access = {kUntaggedBase,
+                          kNonHeapObjectHeaderSize - kHeapObjectTag,
+                          Type::Any(), rep};
   return access;
 }
 }
 
 
 // Create a simple JSObject with a unique map.
 static Handle<JSObject> TestObject() {
   static int index = 0;
   char buffer[50];
   v8::base::OS::SNPrintF(buffer, 50, "({'a_%d':1})", index++);
@@ skipping 175 matching lines @@
     src->set(i, *TestObject());
     src_copy->set(i, src->get(i));
     dst->set(i, *TestObject());
     CHECK_NE(src_copy->get(i), dst->get(i));
   }
   CHECK_EQ(kArraySize, t.Call(*src, *dst));
   for (int i = 0; i < kArraySize; i++) {
     CHECK_EQ(src_copy->get(i), dst->get(i));
   }
 }
+
+
+TEST(RunLoadFieldFromUntaggedBase) {
+  Smi* smis[] = {Smi::FromInt(1), Smi::FromInt(2), Smi::FromInt(3)};
+
+  for (size_t i = 0; i < ARRAY_SIZE(smis); i++) {
+    FieldAccess access = {kUntaggedBase,     // untagged base
+                          i * sizeof(Smi*),  // offset
+                          Handle<Name>(), Type::Integral32(), kMachineTagged};
+
+    SimplifiedGraphBuilderTester<Object*> t;
+    Node* load = t.LoadField(access, t.PointerConstant(smis));
+    t.Return(load);
+    t.LowerAllNodes();
+
+    for (int j = -5; j <= 5; j++) {
+      Smi* expected = Smi::FromInt(j);
+      smis[i] = expected;
+      CHECK_EQ(expected, t.Call());
+    }
+  }
+}
+
+
+TEST(RunStoreFieldToUntaggedBase) {
+  Smi* smis[] = {Smi::FromInt(1), Smi::FromInt(2), Smi::FromInt(3)};
+
+  for (size_t i = 0; i < ARRAY_SIZE(smis); i++) {
+    FieldAccess access = {kUntaggedBase,     // untagged base
+                          i * sizeof(Smi*),  // offset
+                          Handle<Name>(), Type::Integral32(), kMachineTagged};
+
+    SimplifiedGraphBuilderTester<Object*> t(kMachineTagged);
+    Node* p0 = t.Parameter(0);
+    t.StoreField(access, t.PointerConstant(smis), p0);
+    t.Return(p0);
+    t.LowerAllNodes();
+
+    for (int j = -5; j <= 5; j++) {
+      Smi* expected = Smi::FromInt(j);
+      smis[i] = Smi::FromInt(-100);
+      CHECK_EQ(expected, t.Call(expected));
+      CHECK_EQ(expected, smis[i]);
+    }
+  }
+}
+
+
+TEST(RunLoadElementFromUntaggedBase) {
+  Smi* smis[] = {Smi::FromInt(1), Smi::FromInt(2), Smi::FromInt(3),
+                 Smi::FromInt(4), Smi::FromInt(5)};
+
+  for (size_t i = 0; i < ARRAY_SIZE(smis); i++) {    // for header sizes
+    for (size_t j = i; j < ARRAY_SIZE(smis); j++) {  // for element index
+      ElementAccess access = {kUntaggedBase,         // untagged base
+                              i * sizeof(Smi*),      // header size
+                              Type::Integral32(), kMachineTagged};
+
+      SimplifiedGraphBuilderTester<Object*> t;
+      Node* load =
+          t.LoadElement(access, t.PointerConstant(smis), t.Int32Constant(j));
+      t.Return(load);
+      t.LowerAllNodes();
+
+      for (int k = -5; k <= 5; k++) {
+        Smi* expected = Smi::FromInt(k);
+        smis[i + j] = expected;
+        CHECK_EQ(expected, t.Call());
+      }
+    }
+  }
+}
+
+
+TEST(RunStoreElementFromUntaggedBase) {
+  Smi* smis[] = {Smi::FromInt(1), Smi::FromInt(2), Smi::FromInt(3),
+                 Smi::FromInt(4), Smi::FromInt(5)};
+
+  for (size_t i = 0; i < ARRAY_SIZE(smis); i++) {    // for header sizes
+    for (size_t j = i; j < ARRAY_SIZE(smis); j++) {  // for element index
+      ElementAccess access = {kUntaggedBase,         // untagged base
+                              i * sizeof(Smi*),      // header size
+                              Type::Integral32(), kMachineTagged};
+
+      SimplifiedGraphBuilderTester<Object*> t(kMachineTagged);
+      Node* p0 = t.Parameter(0);
+      t.StoreElement(access, t.PointerConstant(smis), t.Int32Constant(j), p0);
+      t.Return(p0);
+      t.LowerAllNodes();
+
+      for (int k = -5; k <= 5; k++) {
+        Smi* expected = Smi::FromInt(k);
+        smis[i + j] = Smi::FromInt(-100);
+        CHECK_EQ(expected, t.Call(expected));
+        CHECK_EQ(expected, smis[i + j]);
+      }
+    }
+  }
+}