[HashRecognize] Introduce CRC macros, factoring code (#262)

Author: artagnon

SingleSource/UnitTests/HashRecognize/crc16.be.c

@@ -1,58 +1,31 @@
+#include "crc_macros.h"
 #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];
-  }
-}
+static void crc_init(void) { CRCINIT_BE(uint16_t, CRCTable, GENPOLY); }
 
 // 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, uint16_t data) {
   uint16_t crc = crc_initval;
-
-  if (CRCTable[255] == 0)
-    crc_init();
-
-  for (size_t i = 0; i < 2; ++i) {
-    uint8_t pos = (crc ^ (data << (i << 3))) >> 8;
-    crc = (crc << 8) ^ CRCTable[pos];
-  }
-
+  CRCTABLE_BE(uint16_t, CRCTable, crc_init, crc, data);
   return crc;
 }
 
 static uint16_t crc_loop(uint16_t crc_initval, uint16_t data) {
   uint16_t crc = crc_initval;
 
   // This loop will be optimized by HashRecognize.
-  for (size_t i = 0; i < 16; ++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;
-  }
+  CRCLOOP_BE(uint16_t, GENPOLY, crc, data);
   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 uint16_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;
+  int res = 0;
+  VERIFY_RESULT(crc_table, crc_loop, res);
+  return res;
 }

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

@@ -1,58 +1,31 @@
+#include "crc_macros.h"
 #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];
-  }
-}
+static void crc_init(void) { CRCINIT_BE(uint16_t, CRCTable, GENPOLY); }
 
 // 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];
-  }
-
+  CRCTABLE_BE(uint16_t, CRCTable, crc_init, crc, data);
   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;
-  }
+  CRCLOOP_BE(uint16_t, GENPOLY, crc, data);
   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;
+  int res = 0;
+  VERIFY_RESULT(crc_table, crc_loop, res);
+  return res;
 }

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

@@ -1,58 +1,31 @@
+#include "crc_macros.h"
 #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];
-  }
-}
+static void crc_init(void) { CRCINIT_BE(uint16_t, CRCTable, GENPOLY); }
 
 // 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];
-  }
-
+  CRCTABLE_BE(uint16_t, CRCTable, crc_init, crc, data);
   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;
-  }
+  CRCLOOP_BE(uint16_t, GENPOLY, crc, data);
   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;
+  int res = 0;
+  VERIFY_RESULT(crc_table, crc_loop, res);
+  return res;
 }

SingleSource/UnitTests/HashRecognize/crc16.le.c

@@ -1,58 +1,31 @@
+#include "crc_macros.h"
 #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];
-  }
-}
+static void crc_init(void) { CRCINIT_LE(uint16_t, CRCTable, GENPOLY); }
 
 // 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, uint16_t data) {
   uint16_t crc = crc_initval;
-
-  if (CRCTable[255] == 0)
-    crc_init();
-
-  for (size_t i = 0; i < 2; ++i) {
-    uint8_t pos = crc ^ (data >> (i << 3));
-    crc = (crc >> 8) ^ CRCTable[pos];
-  }
-
+  CRCTABLE_LE(uint16_t, CRCTable, crc_init, crc, data);
   return crc;
 }
 
 static uint16_t crc_loop(uint16_t crc_initval, uint16_t data) {
   uint16_t crc = crc_initval;
 
   // This loop will be optimized by HashRecognize.
-  for (size_t i = 0; i < 16; ++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;
-  }
+  CRCLOOP_LE(uint16_t, GENPOLY, crc, data);
   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 uint16_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;
+  int res = 0;
+  VERIFY_RESULT(crc_table, crc_loop, res);
+  return res;
 }

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

@@ -1,58 +1,31 @@
+#include "crc_macros.h"
 #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];
-  }
-}
+static void crc_init(void) { CRCINIT_LE(uint16_t, CRCTable, GENPOLY); }
 
 // 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];
-  }
-
+  CRCTABLE_LE(uint16_t, CRCTable, crc_init, crc, data);
   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;
-  }
+  CRCLOOP_LE(uint16_t, GENPOLY, crc, data);
   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;
+  int res = 0;
+  VERIFY_RESULT(crc_table, crc_loop, res);
+  return res;
 }

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

@@ -1,58 +1,31 @@
+#include "crc_macros.h"
 #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];
-  }
-}
+static void crc_init(void) { CRCINIT_LE(uint16_t, CRCTable, GENPOLY); }
 
 // 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];
-  }
-
+  CRCTABLE_LE(uint16_t, CRCTable, crc_init, crc, data);
   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;
-  }
+  CRCLOOP_LE(uint16_t, GENPOLY, crc, data);
   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;
+  int res = 0;
+  VERIFY_RESULT(crc_table, crc_loop, res);
+  return res;
 }