[HashRecognize] Add CRC optz tests with type-mismatch (#261)

Author: artagnon

SingleSource/UnitTests/HashRecognize/crc16.be.c

@@ -24,8 +24,8 @@ static uint16_t crc_table(uint16_t crc_initval, uint16_t data) {
     crc_init();
 
   for (size_t i = 0; i < 2; ++i) {
-    uint16_t pos = (crc >> 8) ^ (data << (i << 3) >> 8);
-    crc = (crc << 8) ^ CRCTable[pos & 0xFF];
+    uint8_t pos = (crc ^ (data << (i << 3))) >> 8;
+    crc = (crc << 8) ^ CRCTable[pos];
   }
 
   return crc;

SingleSource/UnitTests/HashRecognize/crc16.be.data32.c

@@ -0,0 +1,58 @@
+#include <stdint.h>
+#include <stdlib.h>
+
+#define GENPOLY 4129
+
+static uint16_t CRCTable[256];
+
+static void crc_init(void) {
+  uint16_t crc = 0x8000;
+  for (unsigned int i = 1; i < 256; i <<= 1) {
+    crc = (crc << 1) ^ (crc & 0x8000 ? GENPOLY : 0);
+    for (unsigned int j = 0; j < i; j++)
+      CRCTable[i + j] = crc ^ CRCTable[j];
+  }
+}
+
+// This table-lookup should be equivalent to the code emitted when optimizing
+// CRC with HashRecognize. This function itself will be untouched by
+// HashRecognize.
+static uint16_t crc_table(uint16_t crc_initval, uint32_t data) {
+  uint16_t crc = crc_initval;
+
+  if (CRCTable[255] == 0)
+    crc_init();
+
+  for (size_t i = 0; i < 4; ++i) {
+    uint8_t pos = (crc ^ (data << (i << 3))) >> 8;
+    crc = (crc << 8) ^ CRCTable[pos];
+  }
+
+  return crc;
+}
+
+static uint16_t crc_loop(uint16_t crc_initval, uint32_t data) {
+  uint16_t crc = crc_initval;
+
+  // This loop will be optimized by HashRecognize.
+  for (size_t i = 0; i < 32; ++i) {
+    uint16_t xor_crc_data = crc ^ data;
+    uint16_t crc_shl = crc << 1;
+    crc = (xor_crc_data & 0x8000) ? (crc_shl ^ GENPOLY) : crc_shl;
+    data <<= 1;
+  }
+  return crc;
+}
+
+int main() {
+  // These are random hand-picked values.
+  static const uint16_t crc_initval[8] = {0, 129, 11, 255, 16, 4129, 16384, 1};
+  static const uint32_t data[8] = {0, 1, 11, 16, 129, 255, 4129, 16384};
+  for (size_t i = 0; i < 8; ++i) {
+    uint16_t actual = crc_loop(crc_initval[i], data[i]);
+    uint16_t expected = crc_table(crc_initval[i], data[i]);
+    if (actual != expected)
+      return 1;
+  }
+  return 0;
+}

SingleSource/UnitTests/HashRecognize/crc16.be.data32.reference_output

@@ -0,0 +1 @@
+exit 0

SingleSource/UnitTests/HashRecognize/crc16.be.data8.c

@@ -0,0 +1,58 @@
+#include <stdint.h>
+#include <stdlib.h>
+
+#define GENPOLY 4129
+
+static uint16_t CRCTable[256];
+
+static void crc_init(void) {
+  uint16_t crc = 0x8000;
+  for (unsigned int i = 1; i < 256; i <<= 1) {
+    crc = (crc << 1) ^ (crc & 0x8000 ? GENPOLY : 0);
+    for (unsigned int j = 0; j < i; j++)
+      CRCTable[i + j] = crc ^ CRCTable[j];
+  }
+}
+
+// This table-lookup should be equivalent to the code emitted when optimizing
+// CRC with HashRecognize. This function itself will be untouched by
+// HashRecognize.
+static uint16_t crc_table(uint16_t crc_initval, uint8_t data) {
+  uint16_t crc = crc_initval;
+
+  if (CRCTable[255] == 0)
+    crc_init();
+
+  for (size_t i = 0; i < 1; ++i) {
+    uint8_t pos = (crc ^ (data << (i << 3))) >> 8;
+    crc = (crc << 8) ^ CRCTable[pos];
+  }
+
+  return crc;
+}
+
+static uint16_t crc_loop(uint16_t crc_initval, uint8_t data) {
+  uint16_t crc = crc_initval;
+
+  // This loop will be optimized by HashRecognize.
+  for (size_t i = 0; i < 8; ++i) {
+    uint16_t xor_crc_data = crc ^ data;
+    uint16_t crc_shl = crc << 1;
+    crc = (xor_crc_data & 0x8000) ? (crc_shl ^ GENPOLY) : crc_shl;
+    data <<= 1;
+  }
+  return crc;
+}
+
+int main() {
+  // These are random hand-picked values.
+  static const uint16_t crc_initval[8] = {0, 129, 11, 255, 16, 4129, 16384, 1};
+  static const uint8_t data[8] = {0, 1, 11, 16, 129, 255, 142, 255};
+  for (size_t i = 0; i < 8; ++i) {
+    uint16_t actual = crc_loop(crc_initval[i], data[i]);
+    uint16_t expected = crc_table(crc_initval[i], data[i]);
+    if (actual != expected)
+      return 1;
+  }
+  return 0;
+}

SingleSource/UnitTests/HashRecognize/crc16.be.data8.reference_output

@@ -0,0 +1 @@
+exit 0

SingleSource/UnitTests/HashRecognize/crc16.be.nodata.c

@@ -24,8 +24,8 @@ static uint16_t crc_table(uint16_t crc_initval) {
     crc_init();
 
   for (size_t i = 0; i < 2; ++i) {
-    uint16_t pos = (crc >> 8);
-    crc = (crc << 8) ^ CRCTable[pos & 0xFF];
+    uint8_t pos = crc >> 8;
+    crc = (crc << 8) ^ CRCTable[pos];
   }
 
   return crc;

SingleSource/UnitTests/HashRecognize/crc16.le.c

@@ -24,8 +24,8 @@ static uint16_t crc_table(uint16_t crc_initval, uint16_t data) {
     crc_init();
 
   for (size_t i = 0; i < 2; ++i) {
-    uint16_t pos = crc ^ (data >> (i << 3));
-    crc = (crc >> 8) ^ CRCTable[pos & 0xFF];
+    uint8_t pos = crc ^ (data >> (i << 3));
+    crc = (crc >> 8) ^ CRCTable[pos];
   }
 
   return crc;

SingleSource/UnitTests/HashRecognize/crc16.le.data32.c

@@ -0,0 +1,58 @@
+#include <stdint.h>
+#include <stdlib.h>
+
+#define GENPOLY -24575
+
+static uint16_t CRCTable[256];
+
+static void crc_init(void) {
+  uint16_t crc = 1;
+  for (unsigned int i = 128; i; i >>= 1) {
+    crc = (crc >> 1) ^ (crc & 1 ? GENPOLY : 0);
+    for (unsigned int j = 0; j < 256; j += 2 * i)
+      CRCTable[i + j] = crc ^ CRCTable[j];
+  }
+}
+
+// This table-lookup should be equivalent to the code emitted when optimizing
+// CRC with HashRecognize. This function itself will be untouched by
+// HashRecognize.
+static uint16_t crc_table(uint16_t crc_initval, uint32_t data) {
+  uint16_t crc = crc_initval;
+
+  if (CRCTable[255] == 0)
+    crc_init();
+
+  for (size_t i = 0; i < 4; ++i) {
+    uint8_t pos = crc ^ (data >> (i << 3));
+    crc = (crc >> 8) ^ CRCTable[pos];
+  }
+
+  return crc;
+}
+
+static uint16_t crc_loop(uint16_t crc_initval, uint32_t data) {
+  uint16_t crc = crc_initval;
+
+  // This loop will be optimized by HashRecognize.
+  for (size_t i = 0; i < 32; ++i) {
+    uint16_t xor_crc_data = crc ^ data;
+    uint16_t crc_lshr = crc >> 1;
+    crc = (xor_crc_data & 1) ? (crc_lshr ^ GENPOLY) : crc_lshr;
+    data >>= 1;
+  }
+  return crc;
+}
+
+int main() {
+  // These are random hand-picked values.
+  static const uint16_t crc_initval[8] = {0, 129, 11, 255, 16, 4129, 16384, 1};
+  static const uint32_t data[8] = {0, 1, 11, 16, 129, 255, 4129, 16384};
+  for (size_t i = 0; i < 8; ++i) {
+    uint16_t actual = crc_loop(crc_initval[i], data[i]);
+    uint16_t expected = crc_table(crc_initval[i], data[i]);
+    if (actual != expected)
+      return 1;
+  }
+  return 0;
+}

SingleSource/UnitTests/HashRecognize/crc16.le.data32.reference_output

@@ -0,0 +1 @@
+exit 0

SingleSource/UnitTests/HashRecognize/crc16.le.data8.c

@@ -0,0 +1,58 @@
+#include <stdint.h>
+#include <stdlib.h>
+
+#define GENPOLY -24575
+
+static uint16_t CRCTable[256];
+
+static void crc_init(void) {
+  uint16_t crc = 1;
+  for (unsigned int i = 128; i; i >>= 1) {
+    crc = (crc >> 1) ^ (crc & 1 ? GENPOLY : 0);
+    for (unsigned int j = 0; j < 256; j += 2 * i)
+      CRCTable[i + j] = crc ^ CRCTable[j];
+  }
+}
+
+// This table-lookup should be equivalent to the code emitted when optimizing
+// CRC with HashRecognize. This function itself will be untouched by
+// HashRecognize.
+static uint16_t crc_table(uint16_t crc_initval, uint8_t data) {
+  uint16_t crc = crc_initval;
+
+  if (CRCTable[255] == 0)
+    crc_init();
+
+  for (size_t i = 0; i < 1; ++i) {
+    uint8_t pos = crc ^ (data >> (i << 3));
+    crc = (crc >> 8) ^ CRCTable[pos];
+  }
+
+  return crc;
+}
+
+static uint16_t crc_loop(uint16_t crc_initval, uint8_t data) {
+  uint16_t crc = crc_initval;
+
+  // This loop will be optimized by HashRecognize.
+  for (size_t i = 0; i < 8; ++i) {
+    uint16_t xor_crc_data = crc ^ data;
+    uint16_t crc_lshr = crc >> 1;
+    crc = (xor_crc_data & 1) ? (crc_lshr ^ GENPOLY) : crc_lshr;
+    data >>= 1;
+  }
+  return crc;
+}
+
+int main() {
+  // These are random hand-picked values.
+  static const uint16_t crc_initval[8] = {0, 129, 11, 255, 16, 4129, 16384, 1};
+  static const uint8_t data[8] = {0, 1, 11, 16, 129, 255, 142, 255};
+  for (size_t i = 0; i < 8; ++i) {
+    uint16_t actual = crc_loop(crc_initval[i], data[i]);
+    uint16_t expected = crc_table(crc_initval[i], data[i]);
+    if (actual != expected)
+      return 1;
+  }
+  return 0;
+}