TF: Rename ConvertXToY machine operators to ChangeXToY.

test/cctest/compiler/test-run-machops.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 <functional>
 #include <limits>
 
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/codegen-tester.h"
 #include "test/cctest/compiler/value-helper.h"
@@ skipping 464 matching lines @@
 
   m.Bind(&header);
   Node* phi = m.Phi(minus_3, ten);
   m.Branch(m.Float64LessThan(phi, ten), &body, end);
 
   m.Bind(&body);
   phi->ReplaceInput(1, m.Float64Add(phi, m.Float64Constant(0.5)));
   m.Goto(&header);
 
   m.Bind(end);
-  m.Return(m.ConvertFloat64ToInt32(phi));
+  m.Return(m.ChangeFloat64ToInt32(phi));
 
   CHECK_EQ(10, m.Call());
 }
 
 
 TEST(RunLoadInt32) {
   RawMachineAssemblerTester<int32_t> m;
 
   int32_t p1 = 0;  // loads directly from this location.
   m.Return(m.LoadFromPointer(&p1, kMachineWord32));
@@ skipping 2355 matching lines @@
   FOR_FLOAT64_INPUTS(i) {
     FOR_FLOAT64_INPUTS(j) {
       double expected = modulo(*i, *j);
       double found = bt.call(*i, *j);
       CHECK_EQ(expected, found);
     }
   }
 }
 
 
-TEST(RunConvertInt32ToFloat64_A) {
+TEST(RunChangeInt32ToFloat64_A) {
   RawMachineAssemblerTester<int32_t> m;
   int32_t magic = 0x986234;
   double result = 0;
 
-  Node* convert = m.ConvertInt32ToFloat64(m.Int32Constant(magic));
+  Node* convert = m.ChangeInt32ToFloat64(m.Int32Constant(magic));
   m.Store(kMachineFloat64, m.PointerConstant(&result), m.Int32Constant(0),
           convert);
   m.Return(m.Int32Constant(magic));
 
   CHECK_EQ(magic, m.Call());
   CHECK_EQ(static_cast<double>(magic), result);
 }
 
 
-TEST(RunConvertInt32ToFloat64_B) {
+TEST(RunChangeInt32ToFloat64_B) {
   RawMachineAssemblerTester<int32_t> m(kMachineWord32);
   double output = 0;
 
-  Node* convert = m.ConvertInt32ToFloat64(m.Parameter(0));
+  Node* convert = m.ChangeInt32ToFloat64(m.Parameter(0));
   m.Store(kMachineFloat64, m.PointerConstant(&output), m.Int32Constant(0),
           convert);
   m.Return(m.Parameter(0));
 
   FOR_INT32_INPUTS(i) {
     int32_t expect = *i;
     CHECK_EQ(expect, m.Call(expect));
     CHECK_EQ(static_cast<double>(expect), output);
   }
 }
 
 
-TEST(RunConvertUint32ToFloat64_B) {
+TEST(RunChangeUint32ToFloat64_B) {
   RawMachineAssemblerTester<int32_t> m(kMachineWord32);
   double output = 0;
 
-  Node* convert = m.ConvertUint32ToFloat64(m.Parameter(0));
+  Node* convert = m.ChangeUint32ToFloat64(m.Parameter(0));
   m.Store(kMachineFloat64, m.PointerConstant(&output), m.Int32Constant(0),
           convert);
   m.Return(m.Parameter(0));
 
   FOR_UINT32_INPUTS(i) {
     uint32_t expect = *i;
     CHECK_EQ(expect, m.Call(expect));
     CHECK_EQ(static_cast<double>(expect), output);
   }
 }
 
 
-TEST(RunConvertFloat64ToInt32_A) {
+TEST(RunChangeFloat64ToInt32_A) {
   RawMachineAssemblerTester<int32_t> m;
   int32_t magic = 0x786234;
   double input = 11.1;
   int32_t result = 0;
 
   m.Store(kMachineWord32, m.PointerConstant(&result), m.Int32Constant(0),
-          m.ConvertFloat64ToInt32(m.Float64Constant(input)));
+          m.ChangeFloat64ToInt32(m.Float64Constant(input)));
   m.Return(m.Int32Constant(magic));
 
   CHECK_EQ(magic, m.Call());
   CHECK_EQ(static_cast<int32_t>(input), result);
 }
 
 
-TEST(RunConvertFloat64ToInt32_B) {
+TEST(RunChangeFloat64ToInt32_B) {
   RawMachineAssemblerTester<int32_t> m;
   double input = 0;
   int32_t output = 0;
 
   Node* load =
       m.Load(kMachineFloat64, m.PointerConstant(&input), m.Int32Constant(0));
-  Node* convert = m.ConvertFloat64ToInt32(load);
+  Node* convert = m.ChangeFloat64ToInt32(load);
   m.Store(kMachineWord32, m.PointerConstant(&output), m.Int32Constant(0),
           convert);
   m.Return(convert);
 
   {
     FOR_INT32_INPUTS(i) {
       input = *i;
       int32_t expect = *i;
       CHECK_EQ(expect, m.Call());
       CHECK_EQ(expect, output);
@@ skipping 14 matching lines @@
       int32_t expect = static_cast<int32_t>(input);
       CHECK_EQ(expect, m.Call());
       CHECK_EQ(expect, output);
     }
   }
   // Note we don't check fractional inputs, because these Convert operators
   // really should be Change operators.
 }
 
 
-TEST(RunConvertFloat64ToUint32_B) {
+TEST(RunChangeFloat64ToUint32_B) {
   RawMachineAssemblerTester<int32_t> m;
   double input = 0;
   int32_t output = 0;
 
   Node* load =
       m.Load(kMachineFloat64, m.PointerConstant(&input), m.Int32Constant(0));
-  Node* convert = m.ConvertFloat64ToUint32(load);
+  Node* convert = m.ChangeFloat64ToUint32(load);
   m.Store(kMachineWord32, m.PointerConstant(&output), m.Int32Constant(0),
           convert);
   m.Return(convert);
 
   {
     FOR_UINT32_INPUTS(i) {
       input = *i;
       // TODO(titzer): add a CheckEqualsHelper overload for uint32_t.
       int32_t expect = static_cast<int32_t>(*i);
       CHECK_EQ(expect, m.Call());
@@ skipping 15 matching lines @@
       int32_t expect = static_cast<int32_t>(static_cast<uint32_t>(input));
       CHECK_EQ(expect, m.Call());
       CHECK_EQ(expect, output);
     }
   }
   // Note we don't check fractional inputs, because these Convert operators
   // really should be Change operators.
 }
 
 
-TEST(RunConvertFloat64ToInt32_spilled) {
+TEST(RunChangeFloat64ToInt32_spilled) {
   RawMachineAssemblerTester<int32_t> m;
   const int kNumInputs = 32;
   int32_t magic = 0x786234;
   double input[kNumInputs];
   int32_t result[kNumInputs];
   Node* input_node[kNumInputs];
 
   for (int i = 0; i < kNumInputs; i++) {
     input_node[i] = m.Load(kMachineFloat64, m.PointerConstant(&input),
                            m.Int32Constant(i * 8));
   }
 
   for (int i = 0; i < kNumInputs; i++) {
     m.Store(kMachineWord32, m.PointerConstant(&result), m.Int32Constant(i * 4),
-            m.ConvertFloat64ToInt32(input_node[i]));
+            m.ChangeFloat64ToInt32(input_node[i]));
   }
 
   m.Return(m.Int32Constant(magic));
 
   for (int i = 0; i < kNumInputs; i++) {
     input[i] = 100.9 + i;
   }
 
   CHECK_EQ(magic, m.Call());
 
   for (int i = 0; i < kNumInputs; i++) {
     CHECK_EQ(result[i], 100 + i);
   }
 }
 
 
-TEST(RunDeadConvertFloat64ToInt32) {
+TEST(RunDeadChangeFloat64ToInt32) {
   RawMachineAssemblerTester<int32_t> m;
   const int magic = 0x88abcda4;
-  m.ConvertFloat64ToInt32(m.Float64Constant(999.78));
+  m.ChangeFloat64ToInt32(m.Float64Constant(999.78));
   m.Return(m.Int32Constant(magic));
   CHECK_EQ(magic, m.Call());
 }
 
 
-TEST(RunDeadConvertInt32ToFloat64) {
+TEST(RunDeadChangeInt32ToFloat64) {
   RawMachineAssemblerTester<int32_t> m;
   const int magic = 0x8834abcd;
-  m.ConvertInt32ToFloat64(m.Int32Constant(magic - 6888));
+  m.ChangeInt32ToFloat64(m.Int32Constant(magic - 6888));
   m.Return(m.Int32Constant(magic));
   CHECK_EQ(magic, m.Call());
 }
 
 
 TEST(RunLoopPhiInduction2) {
   RawMachineAssemblerTester<int32_t> m;
 
   int false_val = 0x10777;
 
@@ skipping 901 matching lines @@
   FOR_UINT32_INPUTS(i) {
     FOR_UINT32_INPUTS(j) {
       int32_t expected;
       if (sadd_overflow(*i, *j, &expected)) expected = ~expected;
       CHECK_EQ(expected, bt.call(*i, *j));
     }
   }
 }
 
 #endif  // V8_TURBOFAN_TARGET