958 lines
37 KiB
C
958 lines
37 KiB
C
/*
|
|
* gf_unit.c
|
|
*
|
|
* Performs unit testing for gf arithmetic
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <getopt.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <time.h>
|
|
|
|
#include "gf.h"
|
|
#include "gf_int.h"
|
|
#include "gf_method.h"
|
|
#include "gf_rand.h"
|
|
|
|
#define REGION_SIZE (65536)
|
|
|
|
static
|
|
uint8_t get_alt_map_2w8(int offset, uint8_t *buf, int region_size)
|
|
{
|
|
uint8_t symbol = 0;
|
|
int bit_off = offset % 2;
|
|
|
|
if (bit_off == 0) {
|
|
symbol = buf[offset / 2] & 0x0f | ((buf[(offset / 2)+region_size] & 0x0f) << 4);
|
|
} else {
|
|
symbol = ((buf[offset / 2] & 0xf0) >> 4) | (buf[(offset / 2)+region_size] & 0xf0);
|
|
}
|
|
|
|
return symbol;
|
|
}
|
|
|
|
static
|
|
uint16_t get_alt_map_2w16(int offset, uint8_t *buf, int region_size)
|
|
{
|
|
uint16_t symbol = 0;
|
|
|
|
symbol = buf[offset] | (buf[offset+region_size] << 8);
|
|
|
|
return symbol;
|
|
}
|
|
|
|
static
|
|
uint32_t get_alt_map_2w32(int offset, uint8_t *buf, int region_size)
|
|
{
|
|
uint32_t symbol = 0;
|
|
uint16_t buf_a = buf[offset] | (buf[offset + 1] << 8);
|
|
uint16_t buf_b = buf[offset + region_size] | (buf[offset + region_size + 1] << 8);
|
|
|
|
symbol = buf_a | (buf_b << 16);
|
|
|
|
return symbol;
|
|
}
|
|
|
|
static
|
|
void test_alt_map()
|
|
{
|
|
uint8_t* buf = (uint8_t*)malloc(sizeof(uint8_t)*REGION_SIZE);
|
|
int i=0;
|
|
uint8_t c=1, next_c;
|
|
|
|
for (i=0; i < REGION_SIZE/2;i++) {
|
|
if (c == 255) c = 1;
|
|
buf[i] = c;
|
|
buf[i+(REGION_SIZE/2)] = c;
|
|
c++;
|
|
}
|
|
|
|
|
|
c = 1;
|
|
for (i=0; i < REGION_SIZE;i++) {
|
|
uint8_t sym_w8 = get_alt_map_2w8(i, buf, REGION_SIZE/2);
|
|
uint8_t c_val = ((i % 2) == 0) ? (c & 0x0f) : ((c & 0xf0) >> 4);
|
|
uint8_t exp_sym_w8 = c_val | c_val << 4;
|
|
|
|
if (exp_sym_w8 != sym_w8) {
|
|
fprintf(stderr, "Alt mapping failure (w=8,c=%d,i=%d): %u != %u\n", c, i, exp_sym_w8, sym_w8);
|
|
exit(1);
|
|
}
|
|
|
|
if ((i % 2) == 1) {
|
|
c++;
|
|
}
|
|
if (c == 255) {
|
|
c = 1;
|
|
}
|
|
}
|
|
|
|
c = 1;
|
|
|
|
for (i=0; i < REGION_SIZE/2;i++) {
|
|
uint16_t sym_w16 = get_alt_map_2w16(i, buf, REGION_SIZE/2);
|
|
uint16_t exp_sym_w16 = c | c << 8;
|
|
|
|
if (exp_sym_w16 != sym_w16) {
|
|
fprintf(stderr, "Alt mapping failure (w=16,c=%d,i=%d): %u != %u\n", c, i, exp_sym_w16, sym_w16);
|
|
exit(1);
|
|
}
|
|
|
|
c++;
|
|
if (c == 255) {
|
|
c = 1;
|
|
}
|
|
}
|
|
|
|
c = 1;
|
|
next_c = 2;
|
|
|
|
for (i=0; i < REGION_SIZE/4;i++) {
|
|
uint32_t sym_w32 = get_alt_map_2w32(i, buf, REGION_SIZE/2);
|
|
uint32_t exp_sym_w32 = c | (next_c << 8) | c << 16 | (next_c << 24);
|
|
|
|
if (exp_sym_w32 != sym_w32) {
|
|
fprintf(stderr, "Alt mapping failure (w=32,c=%d,i=%d): %u != %u\n", c, i, exp_sym_w32, sym_w32);
|
|
exit(1);
|
|
}
|
|
c++;
|
|
next_c++;
|
|
if (c == 255) {
|
|
c = 1;
|
|
next_c = 2;
|
|
} else if (c == 254) {
|
|
next_c = 1;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void fill_random_region(void *reg, int size)
|
|
{
|
|
uint32_t *r;
|
|
int i;
|
|
|
|
r = (uint32_t *) reg;
|
|
for (i = 0; i < size/sizeof(uint32_t); i++) {
|
|
r[i] = MOA_Random_32();
|
|
}
|
|
}
|
|
|
|
void problem(char *s)
|
|
{
|
|
fprintf(stderr, "Unit test failed.\n");
|
|
fprintf(stderr, "%s\n", s);
|
|
exit(1);
|
|
}
|
|
|
|
void usage(char *s)
|
|
{
|
|
fprintf(stderr, "usage: gf_unit w tests seed [method] - does unit testing in GF(2^w)\n");
|
|
fprintf(stderr, "\n");
|
|
fprintf(stderr, "Legal w are: 4, 8, 16, 32, 64 and 128\n");
|
|
fprintf(stderr, "\n");
|
|
fprintf(stderr, "Tests may be any combination of:\n");
|
|
fprintf(stderr, " A: All\n");
|
|
fprintf(stderr, " S: Single operations (multiplication/division)\n");
|
|
fprintf(stderr, " R: Region operations\n");
|
|
fprintf(stderr, " V: Verbose Output\n");
|
|
fprintf(stderr, "\n");
|
|
fprintf(stderr, "Use -1 for time(0) as a seed.\n");
|
|
fprintf(stderr, "\n");
|
|
fprintf(stderr, "For method specification, type gf_methods\n");
|
|
fprintf(stderr, "\n");
|
|
if (s != NULL) fprintf(stderr, "%s\n", s);
|
|
exit(1);
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
int w, i, j, verbose, single, region, xor, off, size, sindex, eindex, tested, top;
|
|
uint32_t a, b, c, d, ai, da, bi, mask;
|
|
uint64_t a64, b64, c64, d64;
|
|
uint64_t a128[2], b128[2], c128[2], d128[2], e128[2];
|
|
gf_t gf, gf_def;
|
|
uint8_t *r8b, *r8c, *r8d;
|
|
uint16_t *r16b, *r16c, *r16d;
|
|
uint32_t *r32b, *r32c, *r32d;
|
|
uint64_t *r64b, *r64c, *r64d;
|
|
uint64_t *r128b, *r128c, *r128d;
|
|
time_t t0;
|
|
gf_internal_t *h;
|
|
|
|
if (argc < 4) usage(NULL);
|
|
if (sscanf(argv[1], "%d", &w) == 0) usage("Bad w\n");
|
|
if (sscanf(argv[3], "%ld", &t0) == 0) usage("Bad seed\n");
|
|
if (t0 == -1) t0 = time(0);
|
|
MOA_Seed(t0);
|
|
|
|
if (w > 32 && w != 64 && w != 128) usage("Bad w");
|
|
|
|
if (create_gf_from_argv(&gf, w, argc, argv, 4) == 0) usage("Bad Method");
|
|
|
|
for (i = 0; i < strlen(argv[2]); i++) {
|
|
if (strchr("ASRV", argv[2][i]) == NULL) usage("Bad test\n");
|
|
}
|
|
|
|
h = (gf_internal_t *) gf.scratch;
|
|
if (w <= 32) {
|
|
mask = 0;
|
|
for (i = 0; i < w; i++) mask |= (1 << i);
|
|
}
|
|
|
|
verbose = (strchr(argv[2], 'V') != NULL);
|
|
single = (strchr(argv[2], 'S') != NULL || strchr(argv[2], 'A') != NULL);
|
|
region = (strchr(argv[2], 'R') != NULL || strchr(argv[2], 'A') != NULL);
|
|
|
|
if (((h->region_type & GF_REGION_ALTMAP) != 0) && (h->mult_type == GF_MULT_COMPOSITE)) {
|
|
test_alt_map();
|
|
}
|
|
|
|
if (!gf_init_easy(&gf_def, w, GF_MULT_DEFAULT)) problem("No default for this value of w");
|
|
|
|
if (verbose) printf("Seed: %ld\n", t0);
|
|
|
|
if (single) {
|
|
|
|
if (w <= 32) {
|
|
if (gf.multiply.w32 == NULL) problem("No multiplication operation defined.");
|
|
if (verbose) { printf("Testing single multiplications/divisions.\n"); fflush(stdout); }
|
|
if (w <= 10) {
|
|
top = (1 << w)*(1 << w);
|
|
} else {
|
|
top = 1000000;
|
|
}
|
|
for (i = 0; i < top; i++) {
|
|
if (w <= 10) {
|
|
a = i % (1 << w);
|
|
b = i >> w;
|
|
} else if (i < 10) {
|
|
a = 0;
|
|
b = MOA_Random_W(w, 1);
|
|
} else if (i < 20) {
|
|
b = 0;
|
|
a = MOA_Random_W(w, 1);
|
|
} else if (i < 30) {
|
|
a = 1;
|
|
b = MOA_Random_W(w, 1);
|
|
} else if (i < 40) {
|
|
b = 1;
|
|
a = MOA_Random_W(w, 1);
|
|
} else {
|
|
a = MOA_Random_W(w, 1);
|
|
b = MOA_Random_W(w, 1);
|
|
}
|
|
|
|
c = gf.multiply.w32(&gf, a, b);
|
|
tested = 0;
|
|
|
|
/* If this is not composite, then first test against the default: */
|
|
|
|
if (h->mult_type != GF_MULT_COMPOSITE) {
|
|
tested = 1;
|
|
d = gf_def.multiply.w32(&gf_def, a, b);
|
|
|
|
if (c != d) {
|
|
printf("Error in single multiplication (all numbers in hex):\n\n");
|
|
printf(" gf.multiply.w32() of %x and %x returned %x\n", a, b, c);
|
|
printf(" The default returned %x\n", d);
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
/* Now, we also need to double-check, in case the default is wanky, and when
|
|
we're performing composite operations. Start with 0 and 1: */
|
|
|
|
if (a == 0 || b == 0 || a == 1 || b == 1) {
|
|
tested = 1;
|
|
if (((a == 0 || b == 0) && c != 0) ||
|
|
(a == 1 && c != b) ||
|
|
(b == 1 && c != a)) {
|
|
printf("Error in single multiplication (all numbers in hex):\n\n");
|
|
printf(" gf.multiply.w32() of %x and %x returned %x, which is clearly wrong.\n", a, b, c);
|
|
exit(1);
|
|
}
|
|
|
|
/* If division or inverses are defined, let's test all combinations to make sure
|
|
that the operations are consistent with each other. */
|
|
|
|
} else {
|
|
if ((c & mask) != c) {
|
|
printf("Error in single multiplication (all numbers in hex):\n\n");
|
|
printf(" gf.multiply.w32() of %x and %x returned %x, which is too big.\n", a, b, c);
|
|
exit(1);
|
|
}
|
|
|
|
}
|
|
if (gf.inverse.w32 != NULL && (a != 0 || b != 0)) {
|
|
tested = 1;
|
|
if (a != 0) {
|
|
ai = gf.inverse.w32(&gf, a);
|
|
|
|
if (gf.multiply.w32(&gf, c, ai) != b) {
|
|
printf("Error in single multiplication (all numbers in hex):\n\n");
|
|
printf(" gf.multiply.w32() of %x and %x returned %x\n", a, b, c);
|
|
printf(" The inverse of %x is %x, and gf_multiply.w32() of %x and %x equals %x\n",
|
|
a, ai, c, ai, gf.multiply.w32(&gf, c, ai));
|
|
exit(1);
|
|
}
|
|
}
|
|
if (b != 0) {
|
|
bi = gf.inverse.w32(&gf, b);
|
|
if (gf.multiply.w32(&gf, c, bi) != a) {
|
|
printf("Error in single multiplication (all numbers in hex):\n\n");
|
|
printf(" gf.multiply.w32() of %x and %x returned %x\n", a, b, c);
|
|
printf(" The inverse of %x is %x, and gf_multiply.w32() of %x and %x equals %x\n",
|
|
b, bi, c, bi, gf.multiply.w32(&gf, c, bi));
|
|
exit(1);
|
|
}
|
|
}
|
|
}
|
|
if (gf.divide.w32 != NULL && (a != 0 || b != 0)) {
|
|
tested = 1;
|
|
|
|
if (a != 0) {
|
|
ai = gf.divide.w32(&gf, c, a);
|
|
|
|
if (ai != b) {
|
|
printf("Error in single multiplication/division (all numbers in hex):\n\n");
|
|
printf(" gf.multiply.w32() of %x and %x returned %x\n", a, b, c);
|
|
printf(" gf.divide.w32() of %x and %x returned %x\n", c, a, ai);
|
|
exit(1);
|
|
}
|
|
}
|
|
if (b != 0) {
|
|
bi = gf.divide.w32(&gf, c, b);
|
|
|
|
if (bi != a) {
|
|
printf("Error in single multiplication/division (all numbers in hex):\n\n");
|
|
printf(" gf.multiply.w32() of %x and %x returned %x\n", a, b, c);
|
|
printf(" gf.divide.w32() of %x and %x returned %x\n", c, b, bi);
|
|
exit(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!tested) problem("There is no way to test multiplication.\n");
|
|
}
|
|
|
|
} else if (w == 64) {
|
|
if (verbose) { printf("Testing single multiplications/divisions.\n"); fflush(stdout); }
|
|
if (gf.multiply.w64 == NULL) problem("No multiplication operation defined.");
|
|
for (i = 0; i < 1000; i++) {
|
|
for (j = 0; j < 1000; j++) {
|
|
a64 = MOA_Random_64();
|
|
b64 = MOA_Random_64();
|
|
c64 = gf.multiply.w64(&gf, a64, b64);
|
|
if ((a64 == 0 || b64 == 0) && c64 != 0) problem("Single Multiplication by zero Failed");
|
|
if (a64 != 0 && b64 != 0) {
|
|
d64 = (gf.divide.w64 == NULL) ? gf_def.divide.w64(&gf_def, c64, b64) : gf.divide.w64(&gf, c64, b64);
|
|
if (d64 != a64) {
|
|
printf("0x%llx * 0x%llx =? 0x%llx (check-a: 0x%llx)\n", a64, b64, c64, d64);
|
|
problem("Single multiplication/division failed");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (gf.inverse.w64 == NULL) {
|
|
printf("No inverse defined for this method.\n");
|
|
} else {
|
|
if (verbose) { printf("Testing Inversions.\n"); fflush(stdout); }
|
|
for (i = 0; i < 1000; i++) {
|
|
do { a64 = MOA_Random_64(); } while (a64 == 0);
|
|
b64 = gf.inverse.w64(&gf, a64);
|
|
if (gf.multiply.w64(&gf, a64, b64) != 1) problem("Inversion failed.\n");
|
|
}
|
|
}
|
|
} else if (w == 128) {
|
|
if (verbose) { printf("Testing single multiplications/divisions.\n"); fflush(stdout); }
|
|
if (gf.multiply.w128 == NULL) problem("No multiplication operation defined.");
|
|
for (i = 0; i < 500; i++) {
|
|
for (j = 0; j < 500; j++) {
|
|
MOA_Random_128(a128);
|
|
MOA_Random_128(b128);
|
|
gf.multiply.w128(&gf, a128, b128, c128);
|
|
if ((GF_W128_IS_ZERO(a128) && GF_W128_IS_ZERO(b128)) && !(GF_W128_IS_ZERO(c128))) problem("Single Multiplication by zero Failed");
|
|
if (!GF_W128_IS_ZERO(a128) && !GF_W128_IS_ZERO(b128)) {
|
|
gf.divide.w128 == NULL ? gf_def.divide.w128(&gf_def, c128, b128, d128) : gf.divide.w128(&gf, c128, b128, d128);
|
|
if (!GF_W128_EQUAL(a128, d128)) {
|
|
printf("0x%llx 0x%llx * 0x%llx 0x%llx =? 0x%llx 0x%llx (check-a: 0x%llx 0x%llx)\n", a128[0], a128[1], b128[0], b128[1], c128[0], c128[1], d128[0], d128[1]);
|
|
problem("Single multiplication/division failed");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (gf.inverse.w128 == NULL) {
|
|
printf("No inverse defined for this method.\n");
|
|
} else {
|
|
if (verbose) { printf("Testing Inversions.\n"); fflush(stdout); }
|
|
for (i = 0; i < 1000; i++) {
|
|
do { MOA_Random_128(a128); } while (GF_W128_IS_ZERO(a128));
|
|
gf.inverse.w128(&gf, a128, b128);
|
|
gf.multiply.w128(&gf, a128, b128, c128);
|
|
if (!(c128[0] == 0 && c128[1] == 1)) problem("Inversion failed.\n");
|
|
}
|
|
}
|
|
|
|
} else {
|
|
problem("Value of w not implemented yet");
|
|
}
|
|
}
|
|
|
|
if (region) {
|
|
|
|
if (w == 4) {
|
|
if (gf.multiply_region.w32 == NULL) {
|
|
printf("No multiply_region.\n");
|
|
} else {
|
|
r8b = (uint8_t *) malloc(REGION_SIZE);
|
|
r8c = (uint8_t *) malloc(REGION_SIZE);
|
|
r8d = (uint8_t *) malloc(REGION_SIZE);
|
|
fill_random_region(r8b, REGION_SIZE);
|
|
for (xor = 0; xor < 2; xor++) {
|
|
if (verbose) {
|
|
printf("Testing buffer-constant, src != dest, xor = %d\n", xor);
|
|
fflush(stdout);
|
|
}
|
|
for (a = 0; a < 16; a++) {
|
|
fill_random_region(r8c, REGION_SIZE);
|
|
memcpy(r8d, r8c, REGION_SIZE);
|
|
sindex = MOA_Random_W(3, 1);
|
|
eindex = REGION_SIZE/sizeof(uint8_t)-MOA_Random_W(3, 1);
|
|
size = (eindex-sindex)*sizeof(uint8_t);
|
|
gf.multiply_region.w32(&gf, (void *) (r8b+sindex), (void *) (r8c+sindex), a, size, xor);
|
|
for (i = sindex; i < eindex; i++) {
|
|
b = (r8b[i] >> 4);
|
|
c = (r8c[i] >> 4);
|
|
d = (r8d[i] >> 4);
|
|
if (!xor && gf.multiply.w32(&gf, a, b) != c) {
|
|
printf("i=%d. Address 0x%lx\n", i, (unsigned long) (r8b+i));
|
|
printf(" %d * %d = %d, but should equal %d\n", a, b, c, gf.multiply.w32(&gf, a, b) );
|
|
printf("i=%d. %d %d %d %d\n", i, a, r8b[i], r8c[i], r8d[i]);
|
|
problem("Failed buffer-constant, xor=0");
|
|
}
|
|
if (xor && (gf.multiply.w32(&gf, a, b) ^ d) != c) {
|
|
printf("i=%d. Address 0x%lx\n", i, (unsigned long) (r8b+i));
|
|
printf(" %d %d %d %d\n", a, b, c, d);
|
|
printf(" %d %d %d %d\n", a, r8b[i], r8c[i], r8d[i]);
|
|
problem("Failed buffer-constant, xor=1");
|
|
}
|
|
b = (r8b[i] & 0xf);
|
|
c = (r8c[i] & 0xf);
|
|
d = (r8d[i] & 0xf);
|
|
if (!xor && gf.multiply.w32(&gf, a, b) != c) {
|
|
printf("i=%d. Address 0x%lx\n", i, (unsigned long) (r8b+i));
|
|
printf(" %d * %d = %d, but should equal %d\n", a, b, c, gf.multiply.w32(&gf, a, b) );
|
|
printf("i=%d. 0x%x 0x%x 0x%x 0x%x\n", i, a, r8b[i], r8c[i], r8d[i]);
|
|
problem("Failed buffer-constant, xor=0");
|
|
}
|
|
if (xor && (gf.multiply.w32(&gf, a, b) ^ d) != c) {
|
|
printf("i=%d. Address 0x%lx\n", i, (unsigned long) (r8b+i));
|
|
printf(" (%d * %d ^ %d) should equal %d - equals %d\n",
|
|
a, b, d, (gf.multiply.w32(&gf, a, b) ^ d), c);
|
|
printf(" %d %d %d %d\n", a, r8b[i], r8c[i], r8d[i]);
|
|
problem("Failed buffer-constant, xor=1");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (xor = 0; xor < 2; xor++) {
|
|
if (verbose) {
|
|
printf("Testing buffer-constant, src == dest, xor = %d\n", xor);
|
|
fflush(stdout);
|
|
}
|
|
for (a = 0; a < 16; a++) {
|
|
fill_random_region(r8b, REGION_SIZE);
|
|
memcpy(r8d, r8b, REGION_SIZE);
|
|
sindex = MOA_Random_W(3, 1);
|
|
eindex = REGION_SIZE/sizeof(uint8_t)-MOA_Random_W(3, 1);
|
|
size = (eindex-sindex)*sizeof(uint8_t);
|
|
gf.multiply_region.w32(&gf, (void *) (r8b+sindex), (void *) (r8b+sindex), a, size, xor);
|
|
for (i = sindex; i < eindex; i++) {
|
|
b = (r8b[i] >> 4);
|
|
d = (r8d[i] >> 4);
|
|
if (!xor && gf.multiply.w32(&gf, a, d) != b) problem("Failed buffer-constant, xor=0");
|
|
if (xor && (gf.multiply.w32(&gf, a, d) ^ d) != b) {
|
|
printf("i=%d. %d %d %d\n", i, a, b, d);
|
|
printf("i=%d. %d %d %d\n", i, a, r8b[i], r8d[i]);
|
|
problem("Failed buffer-constant, xor=1");
|
|
}
|
|
b = (r8b[i] & 0xf);
|
|
d = (r8d[i] & 0xf);
|
|
if (!xor && gf.multiply.w32(&gf, a, d) != b) problem("Failed buffer-constant, xor=0");
|
|
if (xor && (gf.multiply.w32(&gf, a, d) ^ d) != b) {
|
|
printf("%d %d %d\n", a, b, d);
|
|
problem("Failed buffer-constant, xor=1");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
free(r8b);
|
|
free(r8c);
|
|
free(r8d);
|
|
}
|
|
} else if (w == 8) {
|
|
if (gf.multiply_region.w32 == NULL) {
|
|
printf("No multiply_region.\n");
|
|
} else {
|
|
r8b = (uint8_t *) malloc(REGION_SIZE);
|
|
r8c = (uint8_t *) malloc(REGION_SIZE);
|
|
r8d = (uint8_t *) malloc(REGION_SIZE);
|
|
fill_random_region(r8b, REGION_SIZE);
|
|
for (xor = 0; xor < 2; xor++) {
|
|
if (verbose) {
|
|
printf("Testing buffer-constant, src != dest, xor = %d\n", xor);
|
|
fflush(stdout);
|
|
}
|
|
for (a = 0; a < 256; a++) {
|
|
fill_random_region(r8c, REGION_SIZE);
|
|
memcpy(r8d, r8c, REGION_SIZE);
|
|
if ((((gf_internal_t*)gf.scratch)->region_type & GF_REGION_ALTMAP) != 0 &&
|
|
(((gf_internal_t*)gf.scratch)->mult_type == GF_MULT_COMPOSITE)) {
|
|
sindex = 0;
|
|
eindex = REGION_SIZE;
|
|
} else {
|
|
sindex = MOA_Random_W(3, 1);
|
|
eindex = REGION_SIZE/sizeof(uint8_t)-MOA_Random_W(3, 1);
|
|
}
|
|
size = (eindex-sindex)*sizeof(uint8_t);
|
|
gf.multiply_region.w32(&gf, (void *) (r8b+sindex), (void *) (r8c+sindex), a, size, xor);
|
|
for (i = sindex; i < eindex; i++) {
|
|
if ((((gf_internal_t*)gf.scratch)->region_type & GF_REGION_ALTMAP) != 0 &&
|
|
(((gf_internal_t*)gf.scratch)->mult_type == GF_MULT_COMPOSITE)) {
|
|
b = get_alt_map_2w8(i, (uint8_t*)r8b, REGION_SIZE / 2);
|
|
c = get_alt_map_2w8(i, (uint8_t*)r8c, REGION_SIZE / 2);
|
|
d = get_alt_map_2w8(i, (uint8_t*)r8d, REGION_SIZE / 2);
|
|
} else {
|
|
b = r8b[i];
|
|
c = r8c[i];
|
|
d = r8d[i];
|
|
}
|
|
if (!xor && gf.multiply.w32(&gf, a, b) != c) {
|
|
printf("i=%d. %d %d %d %d\n", i, a, b, c, d);
|
|
printf("i=%d. %d %d %d %d\n", i, a, r8b[i], r8c[i], r8d[i]);
|
|
printf("%llx. Sindex: %d\n", r8b+i, sindex);
|
|
problem("Failed buffer-constant, xor=0");
|
|
}
|
|
if (xor && (gf.multiply.w32(&gf, a, b) ^ d) != c) {
|
|
printf("i=%d. %d %d %d %d\n", i, a, b, c, d);
|
|
printf("i=%d. %d %d %d %d\n", i, a, r8b[i], r8c[i], r8d[i]);
|
|
problem("Failed buffer-constant, xor=1");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (xor = 0; xor < 2; xor++) {
|
|
if ((((gf_internal_t*)gf.scratch)->region_type & GF_REGION_ALTMAP) != 0 &&
|
|
(((gf_internal_t*)gf.scratch)->mult_type == GF_MULT_COMPOSITE)) {
|
|
continue;
|
|
}
|
|
if (verbose) {
|
|
printf("Testing buffer-constant, src == dest, xor = %d\n", xor);
|
|
fflush(stdout);
|
|
}
|
|
for (a = 0; a < 256; a++) {
|
|
fill_random_region(r8b, REGION_SIZE);
|
|
memcpy(r8d, r8b, REGION_SIZE);
|
|
sindex = MOA_Random_W(3, 1);
|
|
eindex = REGION_SIZE/sizeof(uint8_t)-MOA_Random_W(3, 1);
|
|
size = (eindex-sindex)*sizeof(uint8_t);
|
|
gf.multiply_region.w32(&gf, (void *) (r8b+sindex), (void *) (r8b+sindex), a, size, xor);
|
|
for (i = sindex; i < eindex; i++) {
|
|
b = r8b[i];
|
|
d = r8d[i];
|
|
if (!xor && gf.multiply.w32(&gf, a, d) != b) problem("Failed buffer-constant, xor=0");
|
|
if (xor && (gf.multiply.w32(&gf, a, d) ^ d) != b) {
|
|
printf("i=%d. %d %d %d\n", i, a, b, d);
|
|
printf("i=%d. %d %d %d\n", i, a, r8b[i], r8d[i]);
|
|
problem("Failed buffer-constant, xor=1");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
free(r8b);
|
|
free(r8c);
|
|
free(r8d);
|
|
}
|
|
} else if (w == 16) {
|
|
if (gf.multiply_region.w32 == NULL) {
|
|
printf("No multiply_region.\n");
|
|
} else {
|
|
r16b = (uint16_t *) malloc(REGION_SIZE);
|
|
r16c = (uint16_t *) malloc(REGION_SIZE);
|
|
r16d = (uint16_t *) malloc(REGION_SIZE);
|
|
for (xor = 0; xor < 2; xor++) {
|
|
if (verbose) {
|
|
printf("Testing buffer-constant, src != dest, xor = %d\n", xor);
|
|
fflush(stdout);
|
|
}
|
|
for (j = 0; j < 1000; j++) {
|
|
fill_random_region(r16b, REGION_SIZE);
|
|
a = MOA_Random_W(w, 0);
|
|
fill_random_region(r16c, REGION_SIZE);
|
|
memcpy(r16d, r16c, REGION_SIZE);
|
|
if ((((gf_internal_t*)gf.scratch)->region_type & GF_REGION_ALTMAP) != 0 &&
|
|
(((gf_internal_t*)gf.scratch)->mult_type == GF_MULT_COMPOSITE)) {
|
|
sindex = 0;
|
|
eindex = REGION_SIZE / sizeof(uint16_t);
|
|
} else {
|
|
sindex = MOA_Random_W(3, 1);
|
|
eindex = REGION_SIZE/sizeof(uint16_t)-MOA_Random_W(3, 1);
|
|
}
|
|
size = (eindex-sindex)*sizeof(uint16_t);
|
|
gf.multiply_region.w32(&gf, (void *) (r16b+sindex), (void *) (r16c+sindex), a, size, xor);
|
|
ai = gf.inverse.w32(&gf, a);
|
|
if (!xor) {
|
|
gf.multiply_region.w32(&gf, (void *) (r16c+sindex), (void *) (r16d+sindex), ai, size, xor);
|
|
} else {
|
|
gf.multiply_region.w32(&gf, (void *) (r16c+sindex), (void *) (r16d+sindex), 1, size, xor);
|
|
gf.multiply_region.w32(&gf, (void *) (r16d+sindex), (void *) (r16b+sindex), ai, size, xor);
|
|
}
|
|
|
|
for (i = sindex; i < eindex; i++) {
|
|
if ((((gf_internal_t*)gf.scratch)->region_type & GF_REGION_ALTMAP) != 0 &&
|
|
(((gf_internal_t*)gf.scratch)->mult_type == GF_MULT_COMPOSITE)) {
|
|
b = get_alt_map_2w16(i, (uint8_t*)r16b, size / 2);
|
|
c = get_alt_map_2w16(i, (uint8_t*)r16c, size / 2);
|
|
d = get_alt_map_2w16(i, (uint8_t*)r16d, size / 2);
|
|
} else {
|
|
b = r16b[i];
|
|
c = r16c[i];
|
|
d = r16d[i];
|
|
}
|
|
if (!xor && d != b) {
|
|
printf("i=%d. Address 0x%lx\n", i, (unsigned long) (r16b+i));
|
|
printf("We have %d * %d = %d, and %d * %d = %d.\n", a, b, c, c, ai, d);
|
|
printf("%d is the inverse of %d\n", ai, a);
|
|
problem("Failed buffer-constant, xor=0");
|
|
}
|
|
if (xor && b != 0) {
|
|
printf("i=%d. Address 0x%lx\n", i, (unsigned long) (r16b+i));
|
|
printf("We did d=c; c ^= ba; d ^= c; b ^= (a^-1)d;\n");
|
|
printf(" b should equal 0, but it doesn't. Probe into it.\n");
|
|
problem("Failed buffer-constant, xor=1");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (xor = 0; xor < 2; xor++) {
|
|
if ((((gf_internal_t*)gf.scratch)->region_type & GF_REGION_ALTMAP) != 0 &&
|
|
(((gf_internal_t*)gf.scratch)->mult_type == GF_MULT_COMPOSITE)) {
|
|
continue;
|
|
}
|
|
if (verbose) {
|
|
printf("Testing buffer-constant, src == dest, xor = %d\n", xor);
|
|
fflush(stdout);
|
|
}
|
|
for (j = 0; j < 1000; j++) {
|
|
a = MOA_Random_W(w, 0);
|
|
fill_random_region(r16b, REGION_SIZE);
|
|
memcpy(r16d, r16b, REGION_SIZE);
|
|
sindex = MOA_Random_W(3, 1);
|
|
eindex = REGION_SIZE/sizeof(uint16_t)-MOA_Random_W(3, 1);
|
|
size = (eindex-sindex)*sizeof(uint16_t);
|
|
gf.multiply_region.w32(&gf, (void *) (r16b+sindex), (void *) (r16b+sindex), a, size, xor);
|
|
ai = gf.inverse.w32(&gf, a);
|
|
if (!xor) {
|
|
gf.multiply_region.w32(&gf, (void *) (r16b+sindex), (void *) (r16b+sindex), ai, size, xor);
|
|
} else {
|
|
gf.multiply_region.w32(&gf, (void *) (r16d+sindex), (void *) (r16b+sindex), 1, size, xor);
|
|
gf.multiply_region.w32(&gf, (void *) (r16b+sindex), (void *) (r16b+sindex), ai, size, 0);
|
|
}
|
|
|
|
for (i = sindex; i < eindex; i++) {
|
|
b = r16b[i];
|
|
c = r16c[i];
|
|
d = r16d[i];
|
|
if (!xor && (d != b)) {
|
|
printf("i=%d. Address 0x%lx\n", i, (unsigned long) (r16b+i));
|
|
printf("We did d=b; b = ba; b = b(a^-1).\n");
|
|
printf("So, b should equal d, but it doesn't. Look into it.\n");
|
|
printf("b = %d. d = %d. a = %d\n", b, d, a);
|
|
problem("Failed buffer-constant, xor=0");
|
|
}
|
|
if (xor && d != b) {
|
|
printf("i=%d. Address 0x%lx\n", i, (unsigned long) (r16b+i));
|
|
printf("We did d=b; b = b + ba; b += d; b = b(a^-1);\n");
|
|
printf("We did d=c; c ^= ba; d ^= c; b ^= (a^-1)d;\n");
|
|
printf("So, b should equal d, but it doesn't. Look into it.\n");
|
|
problem("Failed buffer-constant, xor=1");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
free(r16b);
|
|
free(r16c);
|
|
free(r16d);
|
|
}
|
|
} else if (w == 32) {
|
|
if (gf.multiply_region.w32 == NULL) {
|
|
printf("No multiply_region.\n");
|
|
} else {
|
|
r32b = (uint32_t *) malloc(REGION_SIZE);
|
|
r32c = (uint32_t *) malloc(REGION_SIZE);
|
|
r32d = (uint32_t *) malloc(REGION_SIZE);
|
|
for (xor = 0; xor < 2; xor++) {
|
|
if (verbose) {
|
|
printf("Testing buffer-constant, src != dest, xor = %d\n", xor);
|
|
fflush(stdout);
|
|
}
|
|
for (j = 0; j < 1000; j++) {
|
|
a = MOA_Random_32();
|
|
fill_random_region(r32b, REGION_SIZE);
|
|
fill_random_region(r32c, REGION_SIZE);
|
|
memcpy(r32d, r32c, REGION_SIZE);
|
|
if ((((gf_internal_t*)gf.scratch)->region_type & GF_REGION_ALTMAP) != 0 &&
|
|
(((gf_internal_t*)gf.scratch)->mult_type == GF_MULT_COMPOSITE)) {
|
|
sindex = 0;
|
|
eindex = REGION_SIZE / sizeof(uint32_t);
|
|
} else {
|
|
sindex = MOA_Random_W(3, 1);
|
|
eindex = REGION_SIZE/sizeof(uint32_t)-MOA_Random_W(3, 1);
|
|
}
|
|
size = (eindex-sindex)*sizeof(uint32_t);
|
|
gf.multiply_region.w32(&gf, (void *) (r32b+sindex), (void *) (r32c+sindex), a, size, xor);
|
|
ai = gf.inverse.w32(&gf, a);
|
|
if (!xor) {
|
|
gf.multiply_region.w32(&gf, (void *) (r32c+sindex), (void *) (r32d+sindex), ai, size, xor);
|
|
} else {
|
|
gf.multiply_region.w32(&gf, (void *) (r32c+sindex), (void *) (r32d+sindex), 1, size, xor);
|
|
gf.multiply_region.w32(&gf, (void *) (r32d+sindex), (void *) (r32b+sindex), ai, size, xor);
|
|
}
|
|
for (i = sindex; i < eindex; i++) {
|
|
if ((((gf_internal_t*)gf.scratch)->region_type & GF_REGION_ALTMAP) != 0 &&
|
|
(((gf_internal_t*)gf.scratch)->mult_type == GF_MULT_COMPOSITE)) {
|
|
b = get_alt_map_2w32(i, (uint8_t*)r32b, size / 2);
|
|
c = get_alt_map_2w32(i, (uint8_t*)r32c, size / 2);
|
|
d = get_alt_map_2w32(i, (uint8_t*)r32d, size / 2);
|
|
i++;
|
|
} else {
|
|
b = r32b[i];
|
|
c = r32c[i];
|
|
d = r32d[i];
|
|
}
|
|
if (!xor && d != b) {
|
|
printf("i=%d. Addresses: b: 0x%lx\n", i, (unsigned long) (r32b+i));
|
|
printf("We have %d * %d = %d, and %d * %d = %d.\n", a, b, c, c, ai, d);
|
|
printf("%d is the inverse of %d\n", ai, a);
|
|
problem("Failed buffer-constant, xor=0");
|
|
}
|
|
if (xor && b != 0) {
|
|
printf("i=%d. Addresses: b: 0x%lx c: 0x%lx d: 0x%lx\n", i,
|
|
(unsigned long) (r32b+i), (unsigned long) (r32c+i), (unsigned long) (r32d+i));
|
|
printf("We did d=c; c ^= ba; d ^= c; b ^= (a^-1)d;\n");
|
|
printf(" b should equal 0, but it doesn't. Probe into it.\n");
|
|
printf("a: %8x b: %8x c: %8x, d: %8x\n", a, b, c, d);
|
|
problem("Failed buffer-constant, xor=1");
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
for (xor = 0; xor < 2; xor++) {
|
|
if ((((gf_internal_t*)gf.scratch)->region_type & GF_REGION_ALTMAP) != 0 &&
|
|
(((gf_internal_t*)gf.scratch)->mult_type == GF_MULT_COMPOSITE)) {
|
|
continue;
|
|
}
|
|
if (verbose) {
|
|
printf("Testing buffer-constant, src == dest, xor = %d\n", xor);
|
|
fflush(stdout);
|
|
}
|
|
for (j = 0; j < 1000; j++) {
|
|
a = MOA_Random_32();
|
|
fill_random_region(r32b, REGION_SIZE);
|
|
memcpy(r32d, r32b, REGION_SIZE);
|
|
sindex = MOA_Random_W(3, 1);
|
|
eindex = REGION_SIZE/sizeof(uint32_t)-MOA_Random_W(3, 1);
|
|
size = (eindex-sindex)*sizeof(uint32_t);
|
|
gf.multiply_region.w32(&gf, (void *) (r32b+sindex), (void *) (r32b+sindex), a, size, xor);
|
|
ai = gf.inverse.w32(&gf, a);
|
|
if (!xor) {
|
|
gf.multiply_region.w32(&gf, (void *) (r32b+sindex), (void *) (r32b+sindex), ai, size, xor);
|
|
} else {
|
|
gf.multiply_region.w32(&gf, (void *) (r32d+sindex), (void *) (r32b+sindex), 1, size, xor);
|
|
gf.multiply_region.w32(&gf, (void *) (r32b+sindex), (void *) (r32b+sindex), ai, size, 0);
|
|
}
|
|
|
|
for (i = sindex; i < eindex; i++) {
|
|
b = r32b[i];
|
|
c = r32c[i];
|
|
d = r32d[i];
|
|
if (!xor && (d != b)) {
|
|
printf("i=%d. Address 0x%lx\n", i, (unsigned long) (r32b+i));
|
|
printf("We did d=b; b = ba; b = b(a^-1).\n");
|
|
printf("So, b should equal d, but it doesn't. Look into it.\n");
|
|
printf("b = %d. d = %d. a = %d\n", b, d, a);
|
|
problem("Failed buffer-constant, xor=0");
|
|
}
|
|
if (xor && d != b) {
|
|
printf("i=%d. Address 0x%lx\n", i, (unsigned long) (r32b+i));
|
|
printf("We did d=b; b = b + ba; b += d; b = b(a^-1);\n");
|
|
printf("We did d=c; c ^= ba; d ^= c; b ^= (a^-1)d;\n");
|
|
printf("So, b should equal d, but it doesn't. Look into it.\n");
|
|
problem("Failed buffer-constant, xor=1");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
free(r32b);
|
|
free(r32c);
|
|
free(r32d);
|
|
}
|
|
} else if (w == 64) {
|
|
if (gf.multiply_region.w64 == NULL) {
|
|
printf("No multiply_region.\n");
|
|
} else {
|
|
r64b = (uint64_t *) malloc(REGION_SIZE);
|
|
r64c = (uint64_t *) malloc(REGION_SIZE);
|
|
r64d = (uint64_t *) malloc(REGION_SIZE);
|
|
fill_random_region(r64b, REGION_SIZE);
|
|
for (xor = 0; xor < 2; xor++) {
|
|
if (verbose) {
|
|
printf("Testing buffer-constant, src != dest, xor = %d\n", xor);
|
|
fflush(stdout);
|
|
}
|
|
for (j = 0; j < 1000; j++) {
|
|
a64 = MOA_Random_64();
|
|
fill_random_region(r64c, REGION_SIZE);
|
|
memcpy(r64d, r64c, REGION_SIZE);
|
|
sindex = MOA_Random_W(3, 1);
|
|
eindex = REGION_SIZE/sizeof(uint64_t)-MOA_Random_W(3, 1);
|
|
size = (eindex-sindex)*sizeof(uint64_t);
|
|
gf.multiply_region.w64(&gf, (void *) (r64b+sindex), (void *) (r64c+sindex), a64, size, xor);
|
|
for (i = sindex; i < eindex; i++) {
|
|
b64 = r64b[i];
|
|
c64 = r64c[i];
|
|
d64 = r64d[i];
|
|
if (!xor && gf.multiply.w64(&gf, a64, b64) != c64) {
|
|
printf("i=%d. 0x%llx 0x%llx 0x%llx should be 0x%llx\n", i, a64, b64, c64,
|
|
gf.multiply.w64(&gf, a64, b64));
|
|
printf("i=%d. 0x%llx 0x%llx 0x%llx\n", i, a64, r64b[i], r64c[i]);
|
|
problem("Failed buffer-constant, xor=0");
|
|
}
|
|
if (xor && (gf.multiply.w64(&gf, a64, b64) ^ d64) != c64) {
|
|
printf("i=%d. 0x%llx 0x%llx 0x%llx 0x%llx\n", i, a64, b64, c64, d64);
|
|
printf("i=%d. 0x%llx 0x%llx 0x%llx 0x%llx\n", i, a64, r64b[i], r64c[i], r64d[i]);
|
|
problem("Failed buffer-constant, xor=1");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (xor = 0; xor < 2; xor++) {
|
|
if (verbose) {
|
|
printf("Testing buffer-constant, src == dest, xor = %d\n", xor);
|
|
fflush(stdout);
|
|
}
|
|
for (j = 0; j < 1000; j++) {
|
|
a64 = MOA_Random_64();
|
|
fill_random_region(r64b, REGION_SIZE);
|
|
memcpy(r64d, r64b, REGION_SIZE);
|
|
sindex = MOA_Random_W(3, 1);
|
|
eindex = REGION_SIZE/sizeof(uint64_t)-MOA_Random_W(3, 1);
|
|
size = (eindex-sindex)*sizeof(uint64_t);
|
|
gf.multiply_region.w64(&gf, (void *) (r64b+sindex), (void *) (r64b+sindex), a64, size, xor);
|
|
for (i = sindex; i < eindex; i++) {
|
|
b64 = r64b[i];
|
|
d64 = r64d[i];
|
|
if (!xor && gf.multiply.w64(&gf, a64, d64) != b64) problem("Failed buffer-constant, xor=0");
|
|
if (xor && (gf.multiply.w64(&gf, a64, d64) ^ d64) != b64) {
|
|
printf("i=%d. 0x%llx 0x%llx 0x%llx\n", i, a64, b64, d64);
|
|
printf("i=%d. 0x%llx 0x%llx 0x%llx\n", i, a64, r64b[i], r64d[i]);
|
|
problem("Failed buffer-constant, xor=1");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
free(r64b);
|
|
free(r64c);
|
|
free(r64d);
|
|
}
|
|
} else if (w == 128) {
|
|
if (gf.multiply_region.w128 == NULL) {
|
|
printf("No multiply_region.\n");
|
|
} else {
|
|
r128b = (uint64_t *) malloc(REGION_SIZE);
|
|
r128c = (uint64_t *) malloc(REGION_SIZE);
|
|
r128d = (uint64_t *) malloc(REGION_SIZE);
|
|
fill_random_region(r128b, REGION_SIZE);
|
|
for (xor = 0; xor < 2; xor++) {
|
|
if (verbose) {
|
|
printf("Testing buffer-constant, src != dest, xor = %d\n", xor);
|
|
fflush(stdout);
|
|
}
|
|
for (j = 0; j < 1000; j++) {
|
|
MOA_Random_128(a128);
|
|
fill_random_region(r128c, REGION_SIZE);
|
|
memcpy(r128d, r128c, REGION_SIZE);
|
|
sindex = MOA_Random_W(3, 1);
|
|
eindex = REGION_SIZE/(2*sizeof(uint64_t))-MOA_Random_W(3, 1);
|
|
size = (eindex-sindex)*sizeof(uint64_t)*2;
|
|
gf.multiply_region.w128(&gf, (void *) (r128b+sindex*2), (void *) (r128c+sindex*2), a128, size, xor);
|
|
for (i = sindex; i < eindex; i++) {
|
|
b128[0] = r128b[2*i];
|
|
b128[1] = r128b[2*i+1];
|
|
c128[0] = r128c[2*i];
|
|
c128[1] = r128c[2*i+1];
|
|
d128[0] = r128d[2*i];
|
|
d128[1] = r128d[2*i+1];
|
|
gf.multiply.w128(&gf, a128, b128, e128);
|
|
if (xor) {
|
|
e128[0] ^= d128[0];
|
|
e128[1] ^= d128[1];
|
|
}
|
|
if (!xor && !GF_W128_EQUAL(c128, e128)) {
|
|
printf("i=%d. 0x%llx%llx 0x%llx%llx 0x%llx%llx should be 0x%llx%llx\n",
|
|
i, a128[0], a128[1], b128[0], b128[1], c128[0], c128[1], e128[0], e128[1]);
|
|
problem("Failed buffer-constant, xor=0");
|
|
}
|
|
if (xor && !GF_W128_EQUAL(e128, c128)) {
|
|
printf("i=%d. 0x%llx%llx 0x%llx%llx 0x%llx%llx 0x%llx%llx\n", i,
|
|
a128[0], a128[1], b128[0], b128[1], c128[0], c128[1], d128[0], d128[1]);
|
|
problem("Failed buffer-constant, xor=1");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (xor = 0; xor < 2; xor++) {
|
|
if (verbose) {
|
|
printf("Testing buffer-constant, src == dest, xor = %d\n", xor);
|
|
fflush(stdout);
|
|
}
|
|
for (j = 0; j < 1000; j++) {
|
|
MOA_Random_128(a128);
|
|
fill_random_region(r128b, REGION_SIZE);
|
|
memcpy(r128d, r128b, REGION_SIZE);
|
|
sindex = MOA_Random_W(3, 1);
|
|
sindex = 0;
|
|
eindex = REGION_SIZE/(2*sizeof(uint64_t))-MOA_Random_W(3, 1);
|
|
eindex = REGION_SIZE/(2*sizeof(uint64_t));
|
|
size = (eindex-sindex)*sizeof(uint64_t)*2;
|
|
gf.multiply_region.w128(&gf, (void *) (r128b+sindex), (void *) (r128b+sindex), a128, size, xor);
|
|
for (i = sindex; i < eindex; i++) {
|
|
b128[0] = r128b[2*i];
|
|
b128[1] = r128b[2*i + 1];
|
|
d128[0] = r128d[2*i];
|
|
d128[1] = r128d[2*i + 1];
|
|
gf.multiply.w128(&gf, a128, d128, e128);
|
|
if (xor) {
|
|
e128[0] ^= d128[0];
|
|
e128[1] ^= d128[1];
|
|
}
|
|
if (!xor && !GF_W128_EQUAL(b128, e128)) problem("Failed buffer-constant, xor=0");
|
|
if (xor && !GF_W128_EQUAL(b128, e128)) {
|
|
problem("Failed buffer-constant, xor=1");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
free(r128b);
|
|
free(r128c);
|
|
free(r128d);
|
|
}
|
|
}
|
|
}
|
|
exit(0);
|
|
}
|