Rename Int32{UMod,UDiv} to Uint32{Div,Mod} and Int64{UMod,UDiv} to Uint64{Div,Mod}.

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 "src/base/bits.h"
 #include "src/compiler/generic-node-inl.h"
 #include "test/cctest/cctest.h"
@@ skipping 46 matching lines @@
 
 TEST(CodeGenInt32Binop) {
   RawMachineAssemblerTester<void> m;
 
   const Operator* ops[] = {
       m.machine()->Word32And(),      m.machine()->Word32Or(),
       m.machine()->Word32Xor(),      m.machine()->Word32Shl(),
       m.machine()->Word32Shr(),      m.machine()->Word32Sar(),
       m.machine()->Word32Equal(),    m.machine()->Int32Add(),
       m.machine()->Int32Sub(),       m.machine()->Int32Mul(),
-      m.machine()->Int32Div(),       m.machine()->Int32UDiv(),
-      m.machine()->Int32Mod(),       m.machine()->Int32UMod(),
+      m.machine()->Int32Div(),       m.machine()->Uint32Div(),
+      m.machine()->Int32Mod(),       m.machine()->Uint32Mod(),
       m.machine()->Int32LessThan(),  m.machine()->Int32LessThanOrEqual(),
       m.machine()->Uint32LessThan(), m.machine()->Uint32LessThanOrEqual(),
       NULL};
 
   for (int i = 0; ops[i] != NULL; i++) {
     for (int j = 0; j < 8; j++) {
       for (int k = 0; k < 8; k++) {
         RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
         Node* a = Int32Input(&m, j);
         Node* b = Int32Input(&m, k);
@@ skipping 1295 matching lines @@
         if (p1 != 0 && (static_cast<uint32_t>(p0) != 0x80000000 || p1 != -1)) {
           int expected = static_cast<int32_t>(p0 + (p0 / p1));
           CHECK_EQ(expected, bt.call(p0, p1));
         }
       }
     }
   }
 }
 
 
-TEST(RunInt32UDivP) {
+TEST(RunUint32DivP) {
   {
     RawMachineAssemblerTester<int32_t> m;
     Int32BinopTester bt(&m);
-    bt.AddReturn(m.Int32UDiv(bt.param0, bt.param1));
+    bt.AddReturn(m.Uint32Div(bt.param0, bt.param1));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         uint32_t p0 = *i;
         uint32_t p1 = *j;
         if (p1 != 0) {
           uint32_t expected = static_cast<uint32_t>(p0 / p1);
           CHECK_EQ(expected, bt.call(p0, p1));
         }
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
     Int32BinopTester bt(&m);
-    bt.AddReturn(m.Int32Add(bt.param0, m.Int32UDiv(bt.param0, bt.param1)));
+    bt.AddReturn(m.Int32Add(bt.param0, m.Uint32Div(bt.param0, bt.param1)));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         uint32_t p0 = *i;
         uint32_t p1 = *j;
         if (p1 != 0) {
           uint32_t expected = static_cast<uint32_t>(p0 + (p0 / p1));
           CHECK_EQ(expected, bt.call(p0, p1));
         }
       }
     }
@@ skipping 28 matching lines @@
         if (p1 != 0 && (static_cast<uint32_t>(p0) != 0x80000000 || p1 != -1)) {
           int expected = static_cast<int32_t>(p0 + (p0 % p1));
           CHECK_EQ(expected, bt.call(p0, p1));
         }
       }
     }
   }
 }
 
 
-TEST(RunInt32UModP) {
+TEST(RunUint32ModP) {
   {
     RawMachineAssemblerTester<int32_t> m;
     Int32BinopTester bt(&m);
-    bt.AddReturn(m.Int32UMod(bt.param0, bt.param1));
+    bt.AddReturn(m.Uint32Mod(bt.param0, bt.param1));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         uint32_t p0 = *i;
         uint32_t p1 = *j;
         if (p1 != 0) {
           uint32_t expected = static_cast<uint32_t>(p0 % p1);
           CHECK_EQ(expected, bt.call(p0, p1));
         }
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
     Int32BinopTester bt(&m);
-    bt.AddReturn(m.Int32Add(bt.param0, m.Int32UMod(bt.param0, bt.param1)));
+    bt.AddReturn(m.Int32Add(bt.param0, m.Uint32Mod(bt.param0, bt.param1)));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         uint32_t p0 = *i;
         uint32_t p1 = *j;
         if (p1 != 0) {
           uint32_t expected = static_cast<uint32_t>(p0 + (p0 % p1));
           CHECK_EQ(expected, bt.call(p0, p1));
         }
       }
     }
@@ skipping 1176 matching lines @@
 TEST(RunDeadInt32Binops) {
   RawMachineAssemblerTester<int32_t> m;
 
   const Operator* ops[] = {
       m.machine()->Word32And(),             m.machine()->Word32Or(),
       m.machine()->Word32Xor(),             m.machine()->Word32Shl(),
       m.machine()->Word32Shr(),             m.machine()->Word32Sar(),
       m.machine()->Word32Ror(),             m.machine()->Word32Equal(),
       m.machine()->Int32Add(),              m.machine()->Int32Sub(),
       m.machine()->Int32Mul(),              m.machine()->Int32Div(),
-      m.machine()->Int32UDiv(),             m.machine()->Int32Mod(),
-      m.machine()->Int32UMod(),             m.machine()->Int32LessThan(),
+      m.machine()->Uint32Div(),             m.machine()->Int32Mod(),
+      m.machine()->Uint32Mod(),             m.machine()->Int32LessThan(),
       m.machine()->Int32LessThanOrEqual(),  m.machine()->Uint32LessThan(),
       m.machine()->Uint32LessThanOrEqual(), NULL};
 
   for (int i = 0; ops[i] != NULL; i++) {
     RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
     int constant = 0x55555 + i;
     m.NewNode(ops[i], m.Parameter(0), m.Parameter(1));
     m.Return(m.Int32Constant(constant));
 
     CHECK_EQ(constant, m.Call(1, 1));
@@ skipping 1634 matching lines @@
     float actual = *i;
     RawMachineAssemblerTester<int32_t> m;
     m.StoreToPointer(&actual, kMachFloat32, m.Float32Constant(expected));
     m.Return(m.Int32Constant(0));
     CHECK_EQ(0, m.Call());
     CHECK_EQ(expected, actual);
   }
 }
 
 #endif  // V8_TURBOFAN_TARGET