Unify MachineType and RepType.

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/graph-visualizer.h"
 #include "src/compiler/node-properties-inl.h"
@@ skipping 11 matching lines @@
 #include "test/cctest/compiler/codegen-tester.h"
 #include "test/cctest/compiler/graph-builder-tester.h"
 #include "test/cctest/compiler/value-helper.h"
 
 using namespace v8::internal;
 using namespace v8::internal::compiler;
 
 template <typename ReturnType>
 class SimplifiedLoweringTester : public GraphBuilderTester<ReturnType> {
  public:
-  SimplifiedLoweringTester(MachineType p0 = kMachineLast,
-                           MachineType p1 = kMachineLast,
-                           MachineType p2 = kMachineLast,
-                           MachineType p3 = kMachineLast,
-                           MachineType p4 = kMachineLast)
+  SimplifiedLoweringTester(MachineType p0 = kMachNone,
+                           MachineType p1 = kMachNone,
+                           MachineType p2 = kMachNone,
+                           MachineType p3 = kMachNone,
+                           MachineType p4 = kMachNone)
       : GraphBuilderTester<ReturnType>(p0, p1, p2, p3, p4),
         typer(this->zone()),
         source_positions(this->graph()),
         jsgraph(this->graph(), this->common(), &typer),
         lowering(&jsgraph, &source_positions) {}
 
   Typer typer;
   SourcePositionTable source_positions;
   JSGraph jsgraph;
   SimplifiedLowering lowering;
 
   void LowerAllNodes() {
     this->End();
     lowering.LowerAllNodes();
   }
 
   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 = {kTaggedBase, JSObject::kMapOffset, Handle<Name>(),
-                        Type::Any(), kMachineTagged};
+                        Type::Any(), kMachAnyTagged};
   return access;
 }
 
 
 FieldAccess ForJSObjectProperties() {
   FieldAccess access = {kTaggedBase, JSObject::kPropertiesOffset,
-                        Handle<Name>(), Type::Any(), kMachineTagged};
+                        Handle<Name>(), Type::Any(), kMachAnyTagged};
   return access;
 }
 
 
 FieldAccess ForArrayBufferBackingStore() {
   FieldAccess access = {
       kTaggedBase,                           JSArrayBuffer::kBackingStoreOffset,
       Handle<Name>(),                        Type::UntaggedPtr(),
       MachineOperatorBuilder::pointer_rep(),
   };
   return access;
 }
 
 
 ElementAccess ForFixedArrayElement() {
   ElementAccess access = {kTaggedBase, FixedArray::kHeaderSize, Type::Any(),
-                          kMachineTagged};
+                          kMachAnyTagged};
   return access;
 }
 
 
 ElementAccess ForBackingStoreElement(MachineType 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++);
   return Handle<JSObject>::cast(v8::Utils::OpenHandle(*CompileRun(buffer)));
 }
 
 
 TEST(RunLoadMap) {
-  SimplifiedLoweringTester<Object*> t(kMachineTagged);
+  SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
   FieldAccess access = ForJSObjectMap();
   Node* load = t.LoadField(access, t.Parameter(0));
   t.Return(load);
 
   t.LowerAllNodes();
   t.GenerateCode();
 
   if (Pipeline::SupportedTarget()) {
     Handle<JSObject> src = TestObject();
     Handle<Map> src_map(src->map());
     Object* result = t.Call(*src);  // TODO(titzer): raw pointers in call
     CHECK_EQ(*src_map, result);
   }
 }
 
 
 TEST(RunStoreMap) {
-  SimplifiedLoweringTester<int32_t> t(kMachineTagged, kMachineTagged);
+  SimplifiedLoweringTester<int32_t> t(kMachAnyTagged, kMachAnyTagged);
   FieldAccess access = ForJSObjectMap();
   t.StoreField(access, t.Parameter(1), t.Parameter(0));
   t.Return(t.jsgraph.TrueConstant());
 
   t.LowerAllNodes();
   t.GenerateCode();
 
   if (Pipeline::SupportedTarget()) {
     Handle<JSObject> src = TestObject();
     Handle<Map> src_map(src->map());
     Handle<JSObject> dst = TestObject();
     CHECK(src->map() != dst->map());
     t.Call(*src_map, *dst);  // TODO(titzer): raw pointers in call
     CHECK(*src_map == dst->map());
   }
 }
 
 
 TEST(RunLoadProperties) {
-  SimplifiedLoweringTester<Object*> t(kMachineTagged);
+  SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
   FieldAccess access = ForJSObjectProperties();
   Node* load = t.LoadField(access, t.Parameter(0));
   t.Return(load);
 
   t.LowerAllNodes();
   t.GenerateCode();
 
   if (Pipeline::SupportedTarget()) {
     Handle<JSObject> src = TestObject();
     Handle<FixedArray> src_props(src->properties());
     Object* result = t.Call(*src);  // TODO(titzer): raw pointers in call
     CHECK_EQ(*src_props, result);
   }
 }
 
 
 TEST(RunLoadStoreMap) {
-  SimplifiedLoweringTester<Object*> t(kMachineTagged, kMachineTagged);
+  SimplifiedLoweringTester<Object*> t(kMachAnyTagged, kMachAnyTagged);
   FieldAccess access = ForJSObjectMap();
   Node* load = t.LoadField(access, t.Parameter(0));
   t.StoreField(access, t.Parameter(1), load);
   t.Return(load);
 
   t.LowerAllNodes();
   t.GenerateCode();
 
   if (Pipeline::SupportedTarget()) {
     Handle<JSObject> src = TestObject();
     Handle<Map> src_map(src->map());
     Handle<JSObject> dst = TestObject();
     CHECK(src->map() != dst->map());
     Object* result = t.Call(*src, *dst);  // TODO(titzer): raw pointers in call
     CHECK(result->IsMap());
     CHECK_EQ(*src_map, result);
     CHECK(*src_map == dst->map());
   }
 }
 
 
 TEST(RunLoadStoreFixedArrayIndex) {
-  SimplifiedLoweringTester<Object*> t(kMachineTagged);
+  SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
   ElementAccess access = ForFixedArrayElement();
   Node* load = t.LoadElement(access, t.Parameter(0), t.Int32Constant(0));
   t.StoreElement(access, t.Parameter(0), t.Int32Constant(1), load);
   t.Return(load);
 
   t.LowerAllNodes();
   t.GenerateCode();
 
   if (Pipeline::SupportedTarget()) {
     Handle<FixedArray> array = t.factory()->NewFixedArray(2);
     Handle<JSObject> src = TestObject();
     Handle<JSObject> dst = TestObject();
     array->set(0, *src);
     array->set(1, *dst);
     Object* result = t.Call(*array);
     CHECK_EQ(*src, result);
     CHECK_EQ(*src, array->get(0));
     CHECK_EQ(*src, array->get(1));
   }
 }
 
 
 TEST(RunLoadStoreArrayBuffer) {
-  SimplifiedLoweringTester<Object*> t(kMachineTagged);
+  SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
   const int index = 12;
-  ElementAccess buffer_access = ForBackingStoreElement(kMachineWord8);
+  ElementAccess buffer_access = ForBackingStoreElement(kMachInt8);
   Node* backing_store =
       t.LoadField(ForArrayBufferBackingStore(), t.Parameter(0));
   Node* load =
       t.LoadElement(buffer_access, backing_store, t.Int32Constant(index));
   t.StoreElement(buffer_access, backing_store, t.Int32Constant(index + 1),
                  load);
   t.Return(t.jsgraph.TrueConstant());
 
   t.LowerAllNodes();
   t.GenerateCode();
@@ skipping 18 matching lines @@
   }
 }
 
 
 TEST(RunLoadFieldFromUntaggedBase) {
   Smi* smis[] = {Smi::FromInt(1), Smi::FromInt(2), Smi::FromInt(3)};
 
   for (size_t i = 0; i < ARRAY_SIZE(smis); i++) {
     int offset = static_cast<int>(i * sizeof(Smi*));
     FieldAccess access = {kUntaggedBase, offset, Handle<Name>(),
-                          Type::Integral32(), kMachineTagged};
+                          Type::Integral32(), kMachAnyTagged};
 
     SimplifiedLoweringTester<Object*> t;
     Node* load = t.LoadField(access, t.PointerConstant(smis));
     t.Return(load);
     t.LowerAllNodes();
 
     if (!Pipeline::SupportedTarget()) continue;
 
     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++) {
     int offset = static_cast<int>(i * sizeof(Smi*));
     FieldAccess access = {kUntaggedBase, offset, Handle<Name>(),
-                          Type::Integral32(), kMachineTagged};
+                          Type::Integral32(), kMachAnyTagged};
 
-    SimplifiedLoweringTester<Object*> t(kMachineTagged);
+    SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
     Node* p0 = t.Parameter(0);
     t.StoreField(access, t.PointerConstant(smis), p0);
     t.Return(p0);
     t.LowerAllNodes();
 
     if (!Pipeline::SupportedTarget()) continue;
 
     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 = 0; (i + j) < ARRAY_SIZE(smis); j++) {  // for element index
       int offset = static_cast<int>(i * sizeof(Smi*));
       ElementAccess access = {kUntaggedBase, offset, Type::Integral32(),
-                              kMachineTagged};
+                              kMachAnyTagged};
 
       SimplifiedLoweringTester<Object*> t;
       Node* load = t.LoadElement(access, t.PointerConstant(smis),
                                  t.Int32Constant(static_cast<int>(j)));
       t.Return(load);
       t.LowerAllNodes();
 
       if (!Pipeline::SupportedTarget()) continue;
 
       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 = 0; (i + j) < ARRAY_SIZE(smis); j++) {  // for element index
       int offset = static_cast<int>(i * sizeof(Smi*));
       ElementAccess access = {kUntaggedBase, offset, Type::Integral32(),
-                              kMachineTagged};
+                              kMachAnyTagged};
 
-      SimplifiedLoweringTester<Object*> t(kMachineTagged);
+      SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
       Node* p0 = t.Parameter(0);
       t.StoreElement(access, t.PointerConstant(smis),
                      t.Int32Constant(static_cast<int>(j)), p0);
       t.Return(p0);
       t.LowerAllNodes();
 
       if (!Pipeline::SupportedTarget()) continue;
 
       for (int k = -5; k <= 5; k++) {
         Smi* expected = Smi::FromInt(k);
@@ skipping 204 matching lines @@
         }
       }
     }
   }
 }
 
 
 TEST(RunAccessTests_uint8) {
   uint8_t data[] = {0x07, 0x16, 0x25, 0x34, 0x43, 0x99,
                     0xab, 0x78, 0x89, 0x19, 0x2b, 0x38};
-  RunAccessTest<uint8_t>(kMachineWord8, data, ARRAY_SIZE(data));
+  RunAccessTest<uint8_t>(kMachInt8, data, ARRAY_SIZE(data));
 }
 
 
 TEST(RunAccessTests_uint16) {
   uint16_t data[] = {0x071a, 0x162b, 0x253c, 0x344d, 0x435e, 0x7777};
-  RunAccessTest<uint16_t>(kMachineWord16, data, ARRAY_SIZE(data));
+  RunAccessTest<uint16_t>(kMachInt16, data, ARRAY_SIZE(data));
 }
 
 
 TEST(RunAccessTests_int32) {
   int32_t data[] = {-211, 211, 628347, 2000000000, -2000000000, -1, -100000034};
-  RunAccessTest<int32_t>(kMachineWord32, data, ARRAY_SIZE(data));
+  RunAccessTest<int32_t>(kMachInt32, data, ARRAY_SIZE(data));
 }
 
 
 #define V8_2PART_INT64(a, b) (((static_cast<int64_t>(a) << 32) + 0x##b##u))
 
 
 TEST(RunAccessTests_int64) {
   if (kPointerSize != 8) return;
   int64_t data[] = {V8_2PART_INT64(0x10111213, 14151617),
                     V8_2PART_INT64(0x20212223, 24252627),
                     V8_2PART_INT64(0x30313233, 34353637),
                     V8_2PART_INT64(0xa0a1a2a3, a4a5a6a7),
                     V8_2PART_INT64(0xf0f1f2f3, f4f5f6f7)};
-  RunAccessTest<int64_t>(kMachineWord64, data, ARRAY_SIZE(data));
+  RunAccessTest<int64_t>(kMachInt64, data, ARRAY_SIZE(data));
 }
 
 
 TEST(RunAccessTests_float64) {
   double data[] = {1.25, -1.25, 2.75, 11.0, 11100.8};
-  RunAccessTest<double>(kMachineFloat64, data, ARRAY_SIZE(data));
+  RunAccessTest<double>(kMachFloat64, data, ARRAY_SIZE(data));
 }
 
 
 TEST(RunAccessTests_Smi) {
   Smi* data[] = {Smi::FromInt(-1),    Smi::FromInt(-9),
                  Smi::FromInt(0),     Smi::FromInt(666),
                  Smi::FromInt(77777), Smi::FromInt(Smi::kMaxValue)};
-  RunAccessTest<Smi*>(kMachineTagged, data, ARRAY_SIZE(data));
+  RunAccessTest<Smi*>(kMachAnyTagged, data, ARRAY_SIZE(data));
 }
 
 
 // Fills in most of the nodes of the graph in order to make tests shorter.
 class TestingGraph : public HandleAndZoneScope, public GraphAndBuilders {
  public:
   Typer typer;
   JSGraph jsgraph;
   Node* p0;
   Node* p1;
@@ skipping 38 matching lines @@
 
   // Inserts the node as the return value of the graph.
   Node* Return(Node* node) {
     ret->ReplaceInput(0, node);
     return node;
   }
 
   // Inserts the node as the effect input to the return of the graph.
   void Effect(Node* node) { ret->ReplaceInput(1, node); }
 
-  Node* ExampleWithOutput(RepType type) {
+  Node* ExampleWithOutput(MachineType type) {
     // TODO(titzer): use parameters with guaranteed representations.
-    if (type & tInt32) {
+    if (type & kTypeInt32) {
       return graph()->NewNode(machine()->Int32Add(), jsgraph.Int32Constant(1),
                               jsgraph.Int32Constant(1));
-    } else if (type & tUint32) {
+    } else if (type & kTypeUint32) {
       return graph()->NewNode(machine()->Word32Shr(), jsgraph.Int32Constant(1),
                               jsgraph.Int32Constant(1));
-    } else if (type & rFloat64) {
+    } else if (type & kRepFloat64) {
       return graph()->NewNode(machine()->Float64Add(),
                               jsgraph.Float64Constant(1),
                               jsgraph.Float64Constant(1));
-    } else if (type & rBit) {
+    } else if (type & kRepBit) {
       return graph()->NewNode(machine()->Word32Equal(),
                               jsgraph.Int32Constant(1),
                               jsgraph.Int32Constant(1));
-    } else if (type & rWord64) {
+    } else if (type & kRepWord64) {
       return graph()->NewNode(machine()->Int64Add(), Int64Constant(1),
                               Int64Constant(1));
     } else {
-      CHECK(type & rTagged);
+      CHECK(type & kRepTagged);
       return p0;
     }
   }
 
-  Node* Use(Node* node, RepType type) {
-    if (type & tInt32) {
+  Node* Use(Node* node, MachineType type) {
+    if (type & kTypeInt32) {
       return graph()->NewNode(machine()->Int32LessThan(), node,
                               jsgraph.Int32Constant(1));
-    } else if (type & tUint32) {
+    } else if (type & kTypeUint32) {
       return graph()->NewNode(machine()->Uint32LessThan(), node,
                               jsgraph.Int32Constant(1));
-    } else if (type & rFloat64) {
+    } else if (type & kRepFloat64) {
       return graph()->NewNode(machine()->Float64Add(), node,
                               jsgraph.Float64Constant(1));
-    } else if (type & rWord64) {
+    } else if (type & kRepWord64) {
       return graph()->NewNode(machine()->Int64LessThan(), node,
                               Int64Constant(1));
     } else {
       return graph()->NewNode(simplified()->ReferenceEqual(Type::Any()), node,
                               jsgraph.TrueConstant());
     }
   }
 
   Node* Branch(Node* cond) {
     Node* br = graph()->NewNode(common()->Branch(), cond, start);
     Node* tb = graph()->NewNode(common()->IfTrue(), br);
     Node* fb = graph()->NewNode(common()->IfFalse(), br);
     Node* m = graph()->NewNode(common()->Merge(2), tb, fb);
     NodeProperties::ReplaceControlInput(ret, m);
     return br;
   }
 
   Node* Int64Constant(int64_t v) {
     return graph()->NewNode(common()->Int64Constant(v));
   }
 
   SimplifiedOperatorBuilder* simplified() { return &main_simplified_; }
   MachineOperatorBuilder* machine() { return &main_machine_; }
   CommonOperatorBuilder* common() { return &main_common_; }
   Graph* graph() { return main_graph_; }
 };
 
 
 TEST(LowerBooleanNot_bit_bit) {
-  // BooleanNot(x: rBit) used as rBit
+  // BooleanNot(x: kRepBit) used as kRepBit
   TestingGraph t(Type::Boolean());
-  Node* b = t.ExampleWithOutput(rBit);
+  Node* b = t.ExampleWithOutput(kRepBit);
   Node* inv = t.graph()->NewNode(t.simplified()->BooleanNot(), b);
   Node* use = t.Branch(inv);
   t.Lower();
   Node* cmp = use->InputAt(0);
   CHECK_EQ(t.machine()->WordEqual()->opcode(), cmp->opcode());
   CHECK(b == cmp->InputAt(0) || b == cmp->InputAt(1));
   Node* f = t.jsgraph.Int32Constant(0);
   CHECK(f == cmp->InputAt(0) || f == cmp->InputAt(1));
 }
 
 
 TEST(LowerBooleanNot_bit_tagged) {
-  // BooleanNot(x: rBit) used as rTagged
+  // BooleanNot(x: kRepBit) used as kRepTagged
   TestingGraph t(Type::Boolean());
-  Node* b = t.ExampleWithOutput(rBit);
+  Node* b = t.ExampleWithOutput(kRepBit);
   Node* inv = t.graph()->NewNode(t.simplified()->BooleanNot(), b);
-  Node* use = t.Use(inv, rTagged);
+  Node* use = t.Use(inv, kRepTagged);
   t.Return(use);
   t.Lower();
   CHECK_EQ(IrOpcode::kChangeBitToBool, use->InputAt(0)->opcode());
   Node* cmp = use->InputAt(0)->InputAt(0);
   CHECK_EQ(t.machine()->WordEqual()->opcode(), cmp->opcode());
   CHECK(b == cmp->InputAt(0) || b == cmp->InputAt(1));
   Node* f = t.jsgraph.Int32Constant(0);
   CHECK(f == cmp->InputAt(0) || f == cmp->InputAt(1));
 }
 
 
 TEST(LowerBooleanNot_tagged_bit) {
-  // BooleanNot(x: rTagged) used as rBit
+  // BooleanNot(x: kRepTagged) used as kRepBit
   TestingGraph t(Type::Boolean());
   Node* b = t.p0;
   Node* inv = t.graph()->NewNode(t.simplified()->BooleanNot(), b);
   Node* use = t.Branch(inv);
   t.Lower();
   Node* cmp = use->InputAt(0);
   CHECK_EQ(t.machine()->WordEqual()->opcode(), cmp->opcode());
   CHECK(b == cmp->InputAt(0) || b == cmp->InputAt(1));
   Node* f = t.jsgraph.FalseConstant();
   CHECK(f == cmp->InputAt(0) || f == cmp->InputAt(1));
 }
 
 
 TEST(LowerBooleanNot_tagged_tagged) {
-  // BooleanNot(x: rTagged) used as rTagged
+  // BooleanNot(x: kRepTagged) used as kRepTagged
   TestingGraph t(Type::Boolean());
   Node* b = t.p0;
   Node* inv = t.graph()->NewNode(t.simplified()->BooleanNot(), b);
-  Node* use = t.Use(inv, rTagged);
+  Node* use = t.Use(inv, kRepTagged);
   t.Return(use);
   t.Lower();
   CHECK_EQ(IrOpcode::kChangeBitToBool, use->InputAt(0)->opcode());
   Node* cmp = use->InputAt(0)->InputAt(0);
   CHECK_EQ(t.machine()->WordEqual()->opcode(), cmp->opcode());
   CHECK(b == cmp->InputAt(0) || b == cmp->InputAt(1));
   Node* f = t.jsgraph.FalseConstant();
   CHECK(f == cmp->InputAt(0) || f == cmp->InputAt(1));
 }
 
@@ skipping 84 matching lines @@
 }
 
 
 static void CheckChangeOf(IrOpcode::Value change, Node* of, Node* node) {
   CHECK_EQ(change, node->opcode());
   CHECK_EQ(of, node->InputAt(0));
 }
 
 
 TEST(LowerNumberToInt32_to_nop) {
-  // NumberToInt32(x: rTagged | tInt32) used as rTagged
+  // NumberToInt32(x: kRepTagged | kTypeInt32) used as kRepTagged
   TestingGraph t(Type::Signed32());
   Node* trunc = t.graph()->NewNode(t.simplified()->NumberToInt32(), t.p0);
-  Node* use = t.Use(trunc, rTagged);
+  Node* use = t.Use(trunc, kRepTagged);
   t.Return(use);
   t.Lower();
   CHECK_EQ(t.p0, use->InputAt(0));
 }
 
 
 TEST(LowerNumberToInt32_to_ChangeTaggedToFloat64) {
-  // NumberToInt32(x: rTagged | tInt32) used as rFloat64
+  // NumberToInt32(x: kRepTagged | kTypeInt32) used as kRepFloat64
   TestingGraph t(Type::Signed32());
   Node* trunc = t.graph()->NewNode(t.simplified()->NumberToInt32(), t.p0);
-  Node* use = t.Use(trunc, rFloat64);
+  Node* use = t.Use(trunc, kRepFloat64);
   t.Return(use);
   t.Lower();
   CheckChangeOf(IrOpcode::kChangeTaggedToFloat64, t.p0, use->InputAt(0));
 }
 
 
 TEST(LowerNumberToInt32_to_ChangeTaggedToInt32) {
-  // NumberToInt32(x: rTagged | tInt32) used as rWord32
+  // NumberToInt32(x: kRepTagged | kTypeInt32) used as kRepWord32
   TestingGraph t(Type::Signed32());
   Node* trunc = t.graph()->NewNode(t.simplified()->NumberToInt32(), t.p0);
-  Node* use = t.Use(trunc, tInt32);
+  Node* use = t.Use(trunc, kTypeInt32);
   t.Return(use);
   t.Lower();
   CheckChangeOf(IrOpcode::kChangeTaggedToInt32, t.p0, use->InputAt(0));
 }
 
 
 TEST(LowerNumberToInt32_to_ChangeFloat64ToTagged) {
-  // TODO(titzer): NumberToInt32(x: rFloat64 | tInt32) used as rTagged
+  // TODO(titzer): NumberToInt32(x: kRepFloat64 | kTypeInt32) used as kRepTagged
 }
 
 
 TEST(LowerNumberToInt32_to_ChangeFloat64ToInt32) {
-  // TODO(titzer): NumberToInt32(x: rFloat64 | tInt32) used as rWord32 | tInt32
+  // TODO(titzer): NumberToInt32(x: kRepFloat64 | kTypeInt32) used as kRepWord32
+  // | kTypeInt32
 }
 
 
 TEST(LowerNumberToInt32_to_TruncateFloat64ToInt32) {
-  // TODO(titzer): NumberToInt32(x: rFloat64) used as rWord32 | tUint32
+  // TODO(titzer): NumberToInt32(x: kRepFloat64) used as kRepWord32 |
+  // kTypeUint32
 }
 
 
 TEST(LowerNumberToUint32_to_nop) {
-  // NumberToUint32(x: rTagged | tUint32) used as rTagged
+  // NumberToUint32(x: kRepTagged | kTypeUint32) used as kRepTagged
   TestingGraph t(Type::Unsigned32());
   Node* trunc = t.graph()->NewNode(t.simplified()->NumberToUint32(), t.p0);
-  Node* use = t.Use(trunc, rTagged);
+  Node* use = t.Use(trunc, kRepTagged);
   t.Return(use);
   t.Lower();
   CHECK_EQ(t.p0, use->InputAt(0));
 }
 
 
 TEST(LowerNumberToUint32_to_ChangeTaggedToFloat64) {
-  // NumberToUint32(x: rTagged | tUint32) used as rWord32
+  // NumberToUint32(x: kRepTagged | kTypeUint32) used as kRepWord32
   TestingGraph t(Type::Unsigned32());
   Node* trunc = t.graph()->NewNode(t.simplified()->NumberToUint32(), t.p0);
-  Node* use = t.Use(trunc, rFloat64);
+  Node* use = t.Use(trunc, kRepFloat64);
   t.Return(use);
   t.Lower();
   CheckChangeOf(IrOpcode::kChangeTaggedToFloat64, t.p0, use->InputAt(0));
 }
 
 
 TEST(LowerNumberToUint32_to_ChangeTaggedToUint32) {
-  // NumberToUint32(x: rTagged | tUint32) used as rWord32
+  // NumberToUint32(x: kRepTagged | kTypeUint32) used as kRepWord32
   TestingGraph t(Type::Unsigned32());
   Node* trunc = t.graph()->NewNode(t.simplified()->NumberToUint32(), t.p0);
-  Node* use = t.Use(trunc, tUint32);
+  Node* use = t.Use(trunc, kTypeUint32);
   t.Return(use);
   t.Lower();
   CheckChangeOf(IrOpcode::kChangeTaggedToUint32, t.p0, use->InputAt(0));
 }
 
 
 TEST(LowerNumberToUint32_to_ChangeFloat64ToTagged) {
-  // TODO(titzer): NumberToUint32(x: rFloat64 | tUint32) used as rTagged
+  // TODO(titzer): NumberToUint32(x: kRepFloat64 | kTypeUint32) used as
+  // kRepTagged
 }
 
 
 TEST(LowerNumberToUint32_to_ChangeFloat64ToUint32) {
-  // TODO(titzer): NumberToUint32(x: rFloat64 | tUint32) used as rWord32
+  // TODO(titzer): NumberToUint32(x: kRepFloat64 | kTypeUint32) used as
+  // kRepWord32
 }
 
 
 TEST(LowerNumberToUint32_to_TruncateFloat64ToUint32) {
-  // TODO(titzer): NumberToUint32(x: rFloat64) used as rWord32
+  // TODO(titzer): NumberToUint32(x: kRepFloat64) used as kRepWord32
 }
 
 
 TEST(LowerReferenceEqual_to_wordeq) {
   TestingGraph t(Type::Any(), Type::Any());
   IrOpcode::Value opcode =
       static_cast<IrOpcode::Value>(t.machine()->WordEqual()->opcode());
   t.CheckLoweringBinop(opcode, t.simplified()->ReferenceEqual(Type::Any()));
 }
 
 
 TEST(LowerStringOps_to_rtcalls) {
   if (false) {  // TODO(titzer): lower StringOps to runtime calls
     TestingGraph t(Type::String(), Type::String());
     t.CheckLoweringBinop(IrOpcode::kCall, t.simplified()->StringEqual());
     t.CheckLoweringBinop(IrOpcode::kCall, t.simplified()->StringLessThan());
     t.CheckLoweringBinop(IrOpcode::kCall,
                          t.simplified()->StringLessThanOrEqual());
     t.CheckLoweringBinop(IrOpcode::kCall, t.simplified()->StringAdd());
   }
 }
 
 
-void CheckChangeInsertion(IrOpcode::Value expected, RepType from, RepType to) {
+void CheckChangeInsertion(IrOpcode::Value expected, MachineType from,
+                          MachineType to) {
   TestingGraph t(Type::Any());
   Node* in = t.ExampleWithOutput(from);
   Node* use = t.Use(in, to);
   t.Return(use);
   t.Lower();
   CHECK_EQ(expected, use->InputAt(0)->opcode());
   CHECK_EQ(in, use->InputAt(0)->InputAt(0));
 }
 
 
 TEST(InsertBasicChanges) {
   if (false) {
     // TODO(titzer): these changes need the output to have the right type.
-    CheckChangeInsertion(IrOpcode::kChangeFloat64ToInt32, rFloat64, tInt32);
-    CheckChangeInsertion(IrOpcode::kChangeFloat64ToUint32, rFloat64, tUint32);
-    CheckChangeInsertion(IrOpcode::kChangeTaggedToInt32, rTagged, tInt32);
-    CheckChangeInsertion(IrOpcode::kChangeTaggedToUint32, rTagged, tUint32);
+    CheckChangeInsertion(IrOpcode::kChangeFloat64ToInt32, kRepFloat64,
+                         kTypeInt32);
+    CheckChangeInsertion(IrOpcode::kChangeFloat64ToUint32, kRepFloat64,
+                         kTypeUint32);
+    CheckChangeInsertion(IrOpcode::kChangeTaggedToInt32, kRepTagged,
+                         kTypeInt32);
+    CheckChangeInsertion(IrOpcode::kChangeTaggedToUint32, kRepTagged,
+                         kTypeUint32);
   }
 
-  CheckChangeInsertion(IrOpcode::kChangeFloat64ToTagged, rFloat64, rTagged);
-  CheckChangeInsertion(IrOpcode::kChangeTaggedToFloat64, rTagged, rFloat64);
+  CheckChangeInsertion(IrOpcode::kChangeFloat64ToTagged, kRepFloat64,
+                       kRepTagged);
+  CheckChangeInsertion(IrOpcode::kChangeTaggedToFloat64, kRepTagged,
+                       kRepFloat64);
 
-  CheckChangeInsertion(IrOpcode::kChangeInt32ToFloat64, tInt32, rFloat64);
-  CheckChangeInsertion(IrOpcode::kChangeInt32ToTagged, tInt32, rTagged);
+  CheckChangeInsertion(IrOpcode::kChangeInt32ToFloat64, kTypeInt32,
+                       kRepFloat64);
+  CheckChangeInsertion(IrOpcode::kChangeInt32ToTagged, kTypeInt32, kRepTagged);
 
-  CheckChangeInsertion(IrOpcode::kChangeUint32ToFloat64, tUint32, rFloat64);
-  CheckChangeInsertion(IrOpcode::kChangeUint32ToTagged, tUint32, rTagged);
+  CheckChangeInsertion(IrOpcode::kChangeUint32ToFloat64, kTypeUint32,
+                       kRepFloat64);
+  CheckChangeInsertion(IrOpcode::kChangeUint32ToTagged, kTypeUint32,
+                       kRepTagged);
 }
 
 
 static void CheckChangesAroundBinop(TestingGraph* t, Operator* op,
                                     IrOpcode::Value input_change,
                                     IrOpcode::Value output_change) {
   Node* binop = t->graph()->NewNode(op, t->p0, t->p1);
   t->Return(binop);
   t->Lower();
   CHECK_EQ(input_change, binop->InputAt(0)->opcode());
@@ skipping 81 matching lines @@
   Int32Matcher index = Int32Matcher(load_or_store->InputAt(1));
   CHECK(index.Is(access.offset - access.tag()));
 }
 
 
 Node* CheckElementAccessArithmetic(ElementAccess access, Node* load_or_store) {
   Int32BinopMatcher index(load_or_store->InputAt(1));
   CHECK_EQ(IrOpcode::kInt32Add, index.node()->opcode());
   CHECK(index.right().Is(access.header_size - access.tag()));
 
-  int element_size = 0;
-  switch (access.representation) {
-    case kMachineTagged:
-      element_size = kPointerSize;
-      break;
-    case kMachineWord8:
-      element_size = 1;
-      break;
-    case kMachineWord16:
-      element_size = 2;
-      break;
-    case kMachineWord32:
-      element_size = 4;
-      break;
-    case kMachineWord64:
-    case kMachineFloat64:
-      element_size = 8;
-      break;
-    case kMachineLast:
-      UNREACHABLE();
-      break;
-  }
+  int element_size = ElementSizeOf(access.machine_type);
 
   if (element_size != 1) {
     Int32BinopMatcher mul(index.left().node());
     CHECK_EQ(IrOpcode::kInt32Mul, mul.node()->opcode());
     CHECK(mul.right().Is(element_size));
     return mul.left().node();
   } else {
     return index.left().node();
   }
 }
 
 
-static const MachineType machine_reps[] = {kMachineWord8,   kMachineWord16,
-                                           kMachineWord32,  kMachineWord64,
-                                           kMachineFloat64, kMachineTagged};
-
-
-// Representation types corresponding to those above.
-static const RepType rep_types[] = {static_cast<RepType>(rWord32 | tUint32),
-                                    static_cast<RepType>(rWord32 | tUint32),
-                                    static_cast<RepType>(rWord32 | tInt32),
-                                    static_cast<RepType>(rWord64),
-                                    static_cast<RepType>(rFloat64 | tNumber),
-                                    static_cast<RepType>(rTagged | tAny)};
+static const MachineType machine_reps[] = {
+    kRepBit,    kMachInt8,    kMachInt16,    kMachInt32,
+    kMachInt64, kMachFloat64, kMachAnyTagged};
 
 
 TEST(LowerLoadField_to_load) {
   TestingGraph t(Type::Any(), Type::Signed32());
 
   for (size_t i = 0; i < ARRAY_SIZE(machine_reps); i++) {
     FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
                           Handle<Name>::null(), Type::Any(), machine_reps[i]};
 
     Node* load =
         t.graph()->NewNode(t.simplified()->LoadField(access), t.p0, t.start);
-    Node* use = t.Use(load, rep_types[i]);
+    Node* use = t.Use(load, machine_reps[i]);
     t.Return(use);
     t.Lower();
     CHECK_EQ(IrOpcode::kLoad, load->opcode());
     CHECK_EQ(t.p0, load->InputAt(0));
     CheckFieldAccessArithmetic(access, load);
 
     MachineType rep = OpParameter<MachineType>(load);
     CHECK_EQ(machine_reps[i], rep);
   }
 }
 
 
 TEST(LowerStoreField_to_store) {
   TestingGraph t(Type::Any(), Type::Signed32());
 
   for (size_t i = 0; i < ARRAY_SIZE(machine_reps); i++) {
     FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
                           Handle<Name>::null(), Type::Any(), machine_reps[i]};
 
 
-    Node* val = t.ExampleWithOutput(rep_types[i]);
+    Node* val = t.ExampleWithOutput(machine_reps[i]);
     Node* store = t.graph()->NewNode(t.simplified()->StoreField(access), t.p0,
                                      val, t.start, t.start);
     t.Effect(store);
     t.Lower();
     CHECK_EQ(IrOpcode::kStore, store->opcode());
     CHECK_EQ(val, store->InputAt(2));
     CheckFieldAccessArithmetic(access, store);
 
     StoreRepresentation rep = OpParameter<StoreRepresentation>(store);
-    if (rep_types[i] & rTagged) {
+    if (machine_reps[i] & kRepTagged) {
       CHECK_EQ(kFullWriteBarrier, rep.write_barrier_kind);
     }
-    CHECK_EQ(machine_reps[i], rep.rep);
+    CHECK_EQ(machine_reps[i], rep.machine_type);
   }
 }
 
 
 TEST(LowerLoadElement_to_load) {
   TestingGraph t(Type::Any(), Type::Signed32());
 
   for (size_t i = 0; i < ARRAY_SIZE(machine_reps); i++) {
     ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
                             Type::Any(), machine_reps[i]};
 
     Node* load = t.graph()->NewNode(t.simplified()->LoadElement(access), t.p0,
                                     t.p1, t.start);
-    Node* use = t.Use(load, rep_types[i]);
+    Node* use = t.Use(load, machine_reps[i]);
     t.Return(use);
     t.Lower();
     CHECK_EQ(IrOpcode::kLoad, load->opcode());
     CHECK_EQ(t.p0, load->InputAt(0));
     CheckElementAccessArithmetic(access, load);
 
     MachineType rep = OpParameter<MachineType>(load);
     CHECK_EQ(machine_reps[i], rep);
   }
 }
 
 
 TEST(LowerStoreElement_to_store) {
   TestingGraph t(Type::Any(), Type::Signed32());
 
   for (size_t i = 0; i < ARRAY_SIZE(machine_reps); i++) {
     ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
                             Type::Any(), machine_reps[i]};
 
-    Node* val = t.ExampleWithOutput(rep_types[i]);
+    Node* val = t.ExampleWithOutput(machine_reps[i]);
     Node* store = t.graph()->NewNode(t.simplified()->StoreElement(access), t.p0,
                                      t.p1, val, t.start, t.start);
     t.Effect(store);
     t.Lower();
     CHECK_EQ(IrOpcode::kStore, store->opcode());
     CHECK_EQ(val, store->InputAt(2));
     CheckElementAccessArithmetic(access, store);
 
     StoreRepresentation rep = OpParameter<StoreRepresentation>(store);
-    if (rep_types[i] & rTagged) {
+    if (machine_reps[i] & kRepTagged) {
       CHECK_EQ(kFullWriteBarrier, rep.write_barrier_kind);
     }
-    CHECK_EQ(machine_reps[i], rep.rep);
+    CHECK_EQ(machine_reps[i], rep.machine_type);
   }
 }
 
 
 TEST(InsertChangeForLoadElementIndex) {
-  // LoadElement(obj: Tagged, index: tInt32 | rTagged) =>
+  // LoadElement(obj: Tagged, index: kTypeInt32 | kRepTagged) =>
   //   Load(obj, Int32Add(Int32Mul(ChangeTaggedToInt32(index), #k), #k))
   TestingGraph t(Type::Any(), Type::Signed32());
   ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, Type::Any(),
-                          kMachineTagged};
+                          kMachAnyTagged};
 
   Node* load = t.graph()->NewNode(t.simplified()->LoadElement(access), t.p0,
                                   t.p1, t.start);
   t.Return(load);
   t.Lower();
   CHECK_EQ(IrOpcode::kLoad, load->opcode());
   CHECK_EQ(t.p0, load->InputAt(0));
 
   Node* index = CheckElementAccessArithmetic(access, load);
   CheckChangeOf(IrOpcode::kChangeTaggedToInt32, t.p1, index);
 }
 
 
 TEST(InsertChangeForStoreElementIndex) {
-  // StoreElement(obj: Tagged, index: tInt32 | rTagged, val) =>
+  // StoreElement(obj: Tagged, index: kTypeInt32 | kRepTagged, val) =>
   //   Store(obj, Int32Add(Int32Mul(ChangeTaggedToInt32(index), #k), #k), val)
   TestingGraph t(Type::Any(), Type::Signed32());
   ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, Type::Any(),
-                          kMachineTagged};
+                          kMachAnyTagged};
 
   Node* store =
       t.graph()->NewNode(t.simplified()->StoreElement(access), t.p0, t.p1,
                          t.jsgraph.TrueConstant(), t.start, t.start);
   t.Effect(store);
   t.Lower();
   CHECK_EQ(IrOpcode::kStore, store->opcode());
   CHECK_EQ(t.p0, store->InputAt(0));
 
   Node* index = CheckElementAccessArithmetic(access, store);
   CheckChangeOf(IrOpcode::kChangeTaggedToInt32, t.p1, index);
 }
 
 
 TEST(InsertChangeForLoadElement) {
   // TODO(titzer): test all load/store representation change insertions.
   TestingGraph t(Type::Any(), Type::Signed32());
   ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, Type::Any(),
-                          kMachineFloat64};
+                          kMachFloat64};
 
   Node* load = t.graph()->NewNode(t.simplified()->LoadElement(access), t.p0,
                                   t.p1, t.start);
   t.Return(load);
   t.Lower();
   CHECK_EQ(IrOpcode::kLoad, load->opcode());
   CHECK_EQ(t.p0, load->InputAt(0));
   CheckChangeOf(IrOpcode::kChangeFloat64ToTagged, load, t.ret->InputAt(0));
 }
 
 
 TEST(InsertChangeForLoadField) {
   // TODO(titzer): test all load/store representation change insertions.
   TestingGraph t(Type::Any(), Type::Signed32());
   FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
-                        Handle<Name>::null(), Type::Any(), kMachineFloat64};
+                        Handle<Name>::null(), Type::Any(), kMachFloat64};
 
   Node* load =
       t.graph()->NewNode(t.simplified()->LoadField(access), t.p0, t.start);
   t.Return(load);
   t.Lower();
   CHECK_EQ(IrOpcode::kLoad, load->opcode());
   CHECK_EQ(t.p0, load->InputAt(0));
   CheckChangeOf(IrOpcode::kChangeFloat64ToTagged, load, t.ret->InputAt(0));
 }
 
 
 TEST(InsertChangeForStoreElement) {
   // TODO(titzer): test all load/store representation change insertions.
   TestingGraph t(Type::Any(), Type::Signed32());
   ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, Type::Any(),
-                          kMachineFloat64};
+                          kMachFloat64};
 
   Node* store =
       t.graph()->NewNode(t.simplified()->StoreElement(access), t.p0,
                          t.jsgraph.Int32Constant(0), t.p1, t.start, t.start);
   t.Effect(store);
   t.Lower();
 
   CHECK_EQ(IrOpcode::kStore, store->opcode());
   CHECK_EQ(t.p0, store->InputAt(0));
   CheckChangeOf(IrOpcode::kChangeTaggedToFloat64, t.p1, store->InputAt(2));
 }
 
 
 TEST(InsertChangeForStoreField) {
   // TODO(titzer): test all load/store representation change insertions.
   TestingGraph t(Type::Any(), Type::Signed32());
   FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
-                        Handle<Name>::null(), Type::Any(), kMachineFloat64};
+                        Handle<Name>::null(), Type::Any(), kMachFloat64};
 
   Node* store = t.graph()->NewNode(t.simplified()->StoreField(access), t.p0,
                                    t.p1, t.start, t.start);
   t.Effect(store);
   t.Lower();
 
   CHECK_EQ(IrOpcode::kStore, store->opcode());
   CHECK_EQ(t.p0, store->InputAt(0));
   CheckChangeOf(IrOpcode::kChangeTaggedToFloat64, t.p1, store->InputAt(2));
 }