Remove memcpy test workaround for name mangling substitutions.

Now that the name mangling is a bit smarter (from commit:
217dc082d5cc2af1cc7c544f51ef15b4abe5be8b), we don't need to
avoid having the same type twice in the function signature.

BUG=none
R=stichnot@chromium.org

Review URL: https://codereview.chromium.org/389683003

diff --git a/crosstest/mem_intrin.cpp b/crosstest/mem_intrin.cpp
index baeb06d..4a65995 100644 (file)
--- a/crosstest/mem_intrin.cpp
+++ b/crosstest/mem_intrin.cpp
@@ -48,29 +48,29 @@ int memcpy_test_fixed_len(uint8_t init) {
   elem_t buf2[NWORDS];
   reset_buf((uint8_t *)buf, init, BYTE_LENGTH);
   memcpy((void *)buf2, (void *)buf, BYTE_LENGTH);
-  return fletcher_checksum((uint8_t*)buf2, BYTE_LENGTH);
+  return fletcher_checksum((uint8_t *)buf2, BYTE_LENGTH);
 }
 
 int memmove_test_fixed_len(uint8_t init) {
   elem_t buf[NWORDS];
   reset_buf((uint8_t *)buf, init, BYTE_LENGTH);
   memmove((void *)(buf + 4), (void *)buf, BYTE_LENGTH - (4 * sizeof(elem_t)));
-  return fletcher_checksum((uint8_t*)buf + 4, BYTE_LENGTH - 4);
+  return fletcher_checksum((uint8_t *)buf + 4, BYTE_LENGTH - 4);
 }
 
 int memset_test_fixed_len(uint8_t init) {
   elem_t buf[NWORDS];
   memset((void *)buf, init, BYTE_LENGTH);
-  return fletcher_checksum((uint8_t*)buf, BYTE_LENGTH);
+  return fletcher_checksum((uint8_t *)buf, BYTE_LENGTH);
 }
 
-int memcpy_test(uint8_t *buf, void *buf2, uint8_t init, size_t length) {
+int memcpy_test(uint8_t *buf, uint8_t *buf2, uint8_t init, size_t length) {
   reset_buf(buf, init, length);
-  memcpy(buf2, (void *)buf, length);
-  return fletcher_checksum((uint8_t *)buf2, length);
+  memcpy((void *)buf2, (void *)buf, length);
+  return fletcher_checksum(buf2, length);
 }
 
-int memmove_test(uint8_t *buf, void *buf2, uint8_t init, size_t length) {
+int memmove_test(uint8_t *buf, uint8_t *buf2, uint8_t init, size_t length) {
   int sum1;
   int sum2;
   const int overlap_bytes = 4 * sizeof(elem_t);
@@ -84,14 +84,13 @@ int memmove_test(uint8_t *buf, void *buf2, uint8_t init, size_t length) {
   memmove((void *)overlap_buf, (void *)buf, reduced_length);
   sum1 = fletcher_checksum(overlap_buf, reduced_length);
   /* Test w/out overlap. */
-  memmove(buf2, (void *)buf, length);
-  sum2 = fletcher_checksum((uint8_t *)buf2, length);
+  memmove((void *)buf2, (void *)buf, length);
+  sum2 = fletcher_checksum(buf2, length);
   return sum1 + sum2;
 }
 
-int memset_test(uint8_t *buf, void *buf2, uint8_t init, size_t length) {
+int memset_test(uint8_t *buf, uint8_t *buf2, uint8_t init, size_t length) {
   memset((void *)buf, init, length);
-  memset(buf2, init + 4, length);
-  return fletcher_checksum(buf, length) +
-      fletcher_checksum((uint8_t *)buf2, length);
+  memset((void *)buf2, init + 4, length);
+  return fletcher_checksum(buf, length) + fletcher_checksum(buf2, length);
 }

diff --git a/crosstest/mem_intrin.h b/crosstest/mem_intrin.h
index 97e6dcc..70f02ae 100644 (file)
--- a/crosstest/mem_intrin.h
+++ b/crosstest/mem_intrin.h
@@ -5,14 +5,9 @@
  * under different namespaces.
  */
 
-/* Declare first buf as uint8_t * and second as void *, to avoid C++
- * name mangling's use of substitutions. Otherwise Subzero's name
- * mangling injection will need to bump each substitution sequence ID
- * up by one (e.g., from S_ to S0_ and S1_ to S2_).
- */
-int memcpy_test(uint8_t *buf, void *buf2, uint8_t init, size_t length);
-int memmove_test(uint8_t *buf, void *buf2, uint8_t init, size_t length);
-int memset_test(uint8_t *buf, void *buf2, uint8_t init, size_t length);
+int memcpy_test(uint8_t *buf, uint8_t *buf2, uint8_t init, size_t length);
+int memmove_test(uint8_t *buf, uint8_t *buf2, uint8_t init, size_t length);
+int memset_test(uint8_t *buf, uint8_t *buf2, uint8_t init, size_t length);
 
 int memcpy_test_fixed_len(uint8_t init);
 int memmove_test_fixed_len(uint8_t init);

diff --git a/crosstest/mem_intrin_main.cpp b/crosstest/mem_intrin_main.cpp
index 76df66a..b529273 100644 (file)
--- a/crosstest/mem_intrin_main.cpp
+++ b/crosstest/mem_intrin_main.cpp
@@ -40,8 +40,8 @@ void testVariableLen(size_t &TotalTests, size_t &Passes, size_t &Failures) {
   for (size_t len = 4; len < 128; ++len) {                              \
     for (uint8_t init_val = 0; init_val < 100; ++init_val) {            \
       ++TotalTests;                                                     \
-      int llc_result = test_func(buf, (void *)buf2, init_val, len);     \
-      int sz_result = Subzero_::test_func(buf, (void *)buf2, init_val, len); \
+      int llc_result = test_func(buf, buf2, init_val, len);             \
+      int sz_result = Subzero_::test_func(buf, buf2, init_val, len);    \
       if (llc_result == sz_result) {                                    \
         ++Passes;                                                       \
       } else {                                                          \