#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include "test.h"
uint32_t data[64];
/* The result of a checksum operation */
typedef struct {
uint64_t addr;
uint64_t len;
uint32_t sum;
char cc;
} cksm_t;
/* Compute the checksum via the cksm insn */
static __attribute__((noinline)) cksm_t
cksm_by_insn(const uint32_t *buff, uint64_t len, uint32_t sum)
{
const uint32_t *init_addr = buff;
uint64_t init_length = len;
uint64_t addr;
char cc;
cksm_t result;
register uint64_t reg2 asm("2") = (uint64_t) buff;
register uint64_t reg3 asm("3") = len;
asm volatile( " lhi 4,42\n\t"
" xr 4,4\n\t" /* set cc to != 0 */
"0: cksm %0,%1\n\t" /* do checksum on longs */
" jo 0b\n\t"
: "+d" (sum), "+d" (reg2), "+d" (reg3) : : "cc", "memory");
cc = get_cc();
len = reg3;
addr = reg2;
/* Check the results */
if(addr != (uint64_t)init_addr + init_length)
printf("FAIL: address not updated properly\n");
if(len != 0)
printf("FAIL: length not zero\n");
if (cc != 0)
printf("FAIL: condition code not zero\n");
result.addr = addr;
result.len = len;
result.cc = cc;
result.sum = sum;
return result;
}
/* Compute the checksum via hand-crafted algorithm */
static __attribute__((noinline)) cksm_t
cksm_by_hand(const uint32_t *buff, uint64_t len, uint32_t sum)
{
cksm_t result;
unsigned int n;
uint64_t v64;
uint32_t final;
for (n=0; n < len/4; n++) {
/* Add 4 bytes to the sum. Do this in 64-bit arithmetic so it's
easy to see whether there was a carry-out. */
v64 = sum;
v64 += buff[n];
/* If there was a carry-out, add 1 to the sum. */
if (v64 >> 32)
sum = sum + buff[n] + 1;
else
sum = sum + buff[n];
}
if (len != 0) {
switch (len % 4) {
case 0:
final = 0; // suppress gcc warning
/* done */
break;
case 1:
final = buff[n] & 0xFF000000;
break;
case 2:
final = buff[n] & 0xFFFF0000;
break;
case 3:
final = buff[n] & 0xFFFFFF00;
break;
}
if (len % 4) {
v64 = sum;
v64 += final;
/* If there was a carry-out, add 1 to the sum. */
if (v64 >> 32)
sum = sum + final + 1;
else
sum = sum + final;
}
}
result.addr = (uint64_t)buff + len;
result.len = 0;
result.cc = 0;
result.sum = sum;
return result;
}
/* The results computed by-insn and by-hand must compare equal and
the sum must be identical to EXPECTED_SUM. */
int
compare_results(cksm_t by_hand, cksm_t by_insn, uint32_t expected_sum)
{
int rc = 0;
if (by_hand.sum != by_insn.sum) {
++rc;
printf("FAIL: sum: by-hand %"PRIx32" by-insn %"PRIx32"\n",
by_hand.sum, by_insn.sum);
}
if (by_hand.addr != by_insn.addr) {
++rc;
printf("FAIL: addr: by-hand %"PRIx64" by-insn %"PRIx64"\n",
by_hand.addr, by_insn.addr);
}
if (by_hand.len != by_insn.len) {
++rc;
printf("FAIL: len: by-hand %"PRIx64" by-insn %"PRIx64"\n",
by_hand.len, by_insn.len);
}
if (by_hand.cc != by_insn.cc) {
++rc;
printf("FAIL: cc: by-hand %d by-insn %d\n",
by_hand.cc, by_insn.cc);
}
if (by_insn.sum != expected_sum) {
++rc;
printf("FAIL: sum: by-insn %"PRIx32" expected %"PRIx32"\n",
by_insn.sum, expected_sum);
}
if (by_hand.sum != expected_sum) {
++rc;
printf("FAIL: sum: by-hand %"PRIx32" expected %"PRIx32"\n",
by_hand.sum, expected_sum);
}
return rc;
}
/* Run a testcase. Compute the checksum by-hand and by-insn and compare
the results */
void
run_test(const char *name, const uint32_t *buff, uint64_t len, uint32_t sum,
uint32_t expected_sum)
{
cksm_t by_hand, by_insn;
by_hand = cksm_by_hand(buff, len, sum);
by_insn = cksm_by_insn(buff, len, sum);
if (compare_results(by_hand, by_insn, expected_sum) != 0) {
printf("%s failed\n", name);
}
}
int main ()
{
uint32_t sum, expected_sum;
uint64_t len;
/* ---------------- test 1 ------------------------------ */
/* Add one word to an initial sum; no carry */
sum = 2;
data[0] = 1;
len = 4;
expected_sum = 3;
run_test("test1", data, len, sum, expected_sum);
/* ---------------- test 2 ------------------------------ */
/* Add one word to an initial sum; with carry */
sum = 1;
data[0] = 0xffffffff;
len = 4;
expected_sum = 1;
run_test("test2", data, len, sum, expected_sum);
/* ---------------- test 3 ------------------------------ */
/* Add 15 words to an initial sum; no carry */
sum = 0x1;
data[0] = 0x4;
data[1] = 0x10;
data[2] = 0x40;
data[3] = 0x100;
data[4] = 0x400;
data[5] = 0x1000;
data[6] = 0x4000;
data[7] = 0x10000;
data[8] = 0x40000;
data[9] = 0x100000;
data[10] = 0x400000;
data[11] = 0x1000000;
data[12] = 0x4000000;
data[13] = 0x10000000;
data[14] = 0x40000000;
len = 60;
expected_sum = 0x55555555;
run_test("test3", data, len, sum, expected_sum);
/* ---------------- test 4 ------------------------------ */
/* Add some words such that every addition generates a carry.
The data is such that the least significant byte is zero,
and the carrys from intermediate additions will accumulate
in the least significant byte. */
sum = 0xff000000;
data[0] = 0x80000000; /* 7f0000001 */
data[1] = 0x85000000; /* 040000002 */
data[2] = 0xff000000; /* 030000003 */
data[3] = 0xff000000; /* 020000004 */
data[4] = 0xff000000; /* 010000005 */
data[5] = 0xff000000; /* 000000006 */
len = 24;
expected_sum = 0x00000006;
run_test("test4", data, len, sum, expected_sum);
/* ---------------- test 5 ------------------------------ */
/* No words are added. Pass a NULL pointer so an attempt to
load would raise a SIGSEGV. */
len = 0;
sum = 42;
expected_sum = sum;
run_test("test5", NULL, len, sum, expected_sum);
/* ---------------- test 6 ------------------------------ */
/* Add 1 byte; no carry */
sum = 0x02000000;
len = 1;
data[0] = 0x7fffffff;
expected_sum = 0x81000000;
run_test("test6", data, len, sum, expected_sum);
/* ---------------- test 7 ------------------------------ */
/* Add 1 byte; carry */
sum = 0x02000000;
len = 1;
data[0] = 0xffffffff;
expected_sum = 0x01000001;
run_test("test7", data, len, sum, expected_sum);
/* ---------------- test 8 ------------------------------ */
/* Add 2 bytes; no carry */
sum = 0x00020000;
len = 2;
data[0] = 0x7fffffff;
expected_sum = 0x80010000;
run_test("test8", data, len, sum, expected_sum);
/* ---------------- test 9 ------------------------------ */
/* Add 2 bytes; carry */
sum = 0x00020000;
len = 2;
data[0] = 0xffffffff;
expected_sum = 0x00010001;
run_test("test9", data, len, sum, expected_sum);
/* ---------------- test 10 ------------------------------ */
/* Add 3 bytes; no carry */
sum = 0x00000200;
len = 3;
data[0] = 0x7fffffff;
expected_sum = 0x80000100;
run_test("test10", data, len, sum, expected_sum);
/* ---------------- test 11 ------------------------------ */
/* Add 3 bytes; carry */
sum = 0x00000200;
len = 3;
data[0] = 0xffffffff;
expected_sum = 0x00000101;
run_test("test11", data, len, sum, expected_sum);
return 0;
}