Implemented the BufferedRawMachineAssemblerTester.

test/cctest/compiler/codegen-tester.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 "test/cctest/cctest.h"
 #include "test/cctest/compiler/codegen-tester.h"
 #include "test/cctest/compiler/value-helper.h"
 
 using namespace v8::internal;
 using namespace v8::internal::compiler;
@@ skipping 550 matching lines @@
   }
 
   {
     RawMachineAssemblerTester<int32_t> m;
     Float64BinopTester bt(&m);
     bt.AddReturn(bt.param1);
 
     FOR_FLOAT64_INPUTS(i) { CheckDoubleEq(*i, bt.call(-11.25, *i)); }
   }
 }
+
+
+#if V8_TARGET_ARCH_64_BIT
+// TODO(ahaas): run int64 tests on all platforms when supported.
+TEST(RunBufferedRawMachineAssemblerTesterTester) {
+  {
+    BufferedRawMachineAssemblerTester<int64_t> m;
+    m.Return(m.Int64Constant(0x12500000000));
+    CHECK_EQ(0x12500000000, m.Call());
+  }
+  {
+    BufferedRawMachineAssemblerTester<double> m(kMachFloat64);
+    m.Return(m.Parameter(0));
+    CHECK_EQ(1.25, m.Call(1.25));
+  }
+  {
+    BufferedRawMachineAssemblerTester<int64_t> m(kMachInt64, kMachInt64);
+    m.Return(m.Int64Add(m.Parameter(0), m.Parameter(1)));
+    CHECK_EQ(0x300000000, m.Call(0x100000000, 0x200000000));
+  }
+  {
+    BufferedRawMachineAssemblerTester<int64_t> m(kMachInt64, kMachInt64,
+                                                 kMachInt64);
+    m.Return(
+        m.Int64Add(m.Int64Add(m.Parameter(0), m.Parameter(1)), m.Parameter(2)));
+    CHECK_EQ(0x600000000, m.Call(0x100000000, 0x200000000, 0x300000000));

[titzer, 2015/10/30 19:48:52]

Probably want to check some real 64-bit numbers here. There should be some
MACRO-loops in value-helper.h

[ahaas, 2015/10/30 21:13:09]

Done.

+  }
+  {
+    BufferedRawMachineAssemblerTester<int64_t> m(kMachInt64, kMachInt64,
+                                                 kMachInt64, kMachInt64);
+    m.Return(m.Int64Add(
+        m.Int64Add(m.Int64Add(m.Parameter(0), m.Parameter(1)), m.Parameter(2)),
+        m.Parameter(3)));
+    CHECK_EQ(0xa00000000,
+             m.Call(0x100000000, 0x200000000, 0x300000000, 0x400000000));
+  }
+  {
+    BufferedRawMachineAssemblerTester<void> m;
+    int64_t result;
+    m.Store(MachineTypeForC<int64_t>(), m.PointerConstant(&result),
+            m.Int64Constant(0x12500000000), kNoWriteBarrier);
+    m.Return(m.Int32Constant(0));
+    m.Call();
+    CHECK_EQ(0x12500000000, result);
+  }
+  {
+    BufferedRawMachineAssemblerTester<void> m(kMachFloat64);
+    double result;
+    m.Store(MachineTypeForC<double>(), m.PointerConstant(&result),
+            m.Parameter(0), kNoWriteBarrier);
+    m.Return(m.Int32Constant(0));
+    m.Call(1.25);
+    CHECK_EQ(1.25, result);
+  }
+  {
+    BufferedRawMachineAssemblerTester<void> m(kMachInt64, kMachInt64);
+    int64_t result;
+    m.Store(MachineTypeForC<int64_t>(), m.PointerConstant(&result),
+            m.Int64Add(m.Parameter(0), m.Parameter(1)), kNoWriteBarrier);
+    m.Return(m.Int32Constant(0));
+    m.Call(0x100000000, 0x200000000);
+    CHECK_EQ(0x300000000, result);
+  }
+  {
+    BufferedRawMachineAssemblerTester<void> m(kMachInt64, kMachInt64,
+                                              kMachInt64);
+    int64_t result;
+    m.Store(
+        MachineTypeForC<int64_t>(), m.PointerConstant(&result),
+        m.Int64Add(m.Int64Add(m.Parameter(0), m.Parameter(1)), m.Parameter(2)),
+        kNoWriteBarrier);
+    m.Return(m.Int32Constant(0));
+    m.Call(0x100000000, 0x200000000, 0x300000000);
+    CHECK_EQ(0x600000000, result);
+  }
+  {
+    BufferedRawMachineAssemblerTester<void> m(kMachInt64, kMachInt64,
+                                              kMachInt64, kMachInt64);
+    int64_t result;
+    m.Store(MachineTypeForC<int64_t>(), m.PointerConstant(&result),
+            m.Int64Add(m.Int64Add(m.Int64Add(m.Parameter(0), m.Parameter(1)),
+                                  m.Parameter(2)),
+                       m.Parameter(3)),
+            kNoWriteBarrier);
+    m.Return(m.Int32Constant(0));
+    m.Call(0x100000000, 0x200000000, 0x300000000, 0x400000000);
+    CHECK_EQ(0xa00000000, result);
+  }
+}
+
+#endif