static int
_mkdir(struct request *r, char *path, int exists_ok)
{
if (io_mkdir(path, S_IRWXU | S_IXGRP)) {
char buf[MSG_SIZE];
int err = errno;
if (err == EEXIST) {
struct stat st;
if (!exists_ok)
return EEXIST;
/*
* Verify the path is a directory.
*/
if (_stat(r, path, &st)) {
_error(r, "_mkdir: _stat() failed");
return ENOENT;
}
return S_ISDIR(st.st_mode) ? 0 : ENOTDIR;
}
snprintf(buf, sizeof buf, "mkdir(%s) failed: %s", path,
strerror(err));
_panic(r, buf);
}
return 0;
}
static void
_panic2(struct request *r, char *msg1, char *msg2)
{
char buf[MSG_SIZE];
_panic(r, log_strcpy2(buf, sizeof buf, msg1, msg2));
}
static void
_panic3(struct request *r, char *msg1, char *msg2, char *msg3)
{
char buf[MSG_SIZE];
_panic(r, log_strcpy3(buf, sizeof buf, msg1, msg2, msg3));
}
/*
* Synopsis:
* Handle reply from client after client took blob.
*/
static int
sha_fs_take_reply(struct request *r, char *reply)
{
struct sha_fs_request *sp = (struct sha_fs_request *)r->open_data;
/*
* If client replies 'ok', then delete the blob.
* Eventually need to lock the file.
*/
if (*reply == 'o') {
int exists = 1;
char *slash;
if (_unlink(r, sp->blob_path, &exists))
_panic(r, "_unlink() failed");
if (!exists)
_warn2(r, "expected blob file does not exist",
sp->blob_path);
/*
* Request trimming the empty directories.
*/
if ((slash = rindex(sp->blob_path, '/'))) {
*slash = 0;
arbor_trim(sp->blob_path);
*slash = '/';
}
else
_panic2(r, "slash missing from blob path",
sp->blob_path);
}
return 0;
}
// Issues a kernel panic when a fatal lock order violation is detected.
void SystemLockValidationFatal(AcquiredLockEntry* lock_entry,
ThreadLockState* state,
void* caller_address,
void* caller_frame,
LockResult result) {
_panic(caller_address, caller_frame,
"Fatal lock violation detected! name=%s reason=%s\n",
LockClassState::GetName(lock_entry->id()), ToString(result));
}
/*
* Private function to block SIGPOLL or SIGIO for a short time.
* Don't forget to call poll_unblock before return from the calling function.
* Don't change the mask between this calls (your changes will be lost).
*/
static void
poll_blocksig(void)
{
sigset_t set;
sigemptyset(&set);
sigaddset(&set, SIGNAL);
if(sigprocmask(SIG_BLOCK, &set, &bset))
_panic("sigprocmask(SIG_BLOCK): %s", strerror(errno));
}
/*
* Do a hard delete of a corrupted blob.
* Calling zap blob indicates a panicy situation with the server.
* Eventually will want to remove an empty, enclosing directory.
*/
static int
zap_blob(struct request *r)
{
struct sha_fs_request *sp = (struct sha_fs_request *)r->open_data;
int exists = 0;
if (_unlink(r, sp->blob_path, &exists)) {
_panic(r, "zap_blob: _unlink() failed");
return -1;
}
return 0;
}
static void *
_xrealloc(void *p, size_t s)
{
void *ptr;
if(p == NULL) {
if((ptr=malloc(s)) == NULL && (s!=0 || (ptr=malloc(1)) == NULL))
_panic("out of memory: xrealloc(%lx, %lu)",
(unsigned long)p, (unsigned long)s);
} else if(s == 0) {
free(p);
if((ptr=malloc(s)) == NULL && (ptr=malloc(1)) == NULL)
_panic("out of memory: xrealloc(%lx, %lu)",
(unsigned long)p, (unsigned long)s);
} else {
if((ptr = realloc(p, s)) == NULL)
_panic("out of memory: xrealloc(%lx, %lu)",
(unsigned long)p, (unsigned long)s);
}
return ptr;
}
void
infunc(int fd, int mask, void *arg)
{
char buf[1024];
int ret;
mask = mask;
arg = arg;
if((ret = read(fd, buf, sizeof(buf))) < 0)
_panic("read: %s", strerror(errno));
write(1, "stdin:", 6);
write(1, buf, ret);
}
static int
_stat(struct request *r, char *path, struct stat *p_st)
{
if (io_stat(path, p_st)) {
char buf[MSG_SIZE];
if (errno == ENOENT)
return ENOENT;
snprintf(buf, sizeof buf, "stat(%s) failed: %s", path,
strerror(errno));
_panic(r, buf);
}
return 0;
}
/*
* Open a local file to read, retrying on interupt and logging errors.
*/
static int
_open(struct request *r, char *path, int *p_fd)
{
int fd;
if ((fd = io_open(path, O_RDONLY, 0)) < 0) {
char buf[MSG_SIZE];
if (errno == ENOENT)
return ENOENT;
snprintf(buf, sizeof buf, "open(%s) failed: %s", path,
strerror(errno));
_panic(r, buf);
}
*p_fd = fd;
return 0;
}
void _interrupt(int vector) {
if (vector >= IRQ_OFFSET && vector < (IRQ_OFFSET+IRQ_COUNT)) {
int irq = vector - IRQ_OFFSET;
struct irq_action *item = handlers[irq];
while (item) {
struct irq_action *next = item->next;
item->isr(item);
item = next;
}
// Send the EOI signal, to PIC2 if necessary and then PIC1, so they
// can reset and continue sending future IRQs.
if (irq >= 8) {
outb (PIC2_CMD, PIC_EOI);
}
outb(PIC1_CMD, PIC_EOI);
} else {
_panic("unexpected interrupt #%d\n", vector);
}
}
int main(void)
{
unsigned rr;
int cnt, ix;
#if LTM_DEMO_TEST_VS_MTEST
unsigned long expt_n, add_n, sub_n, mul_n, div_n, sqr_n, mul2d_n, div2d_n,
gcd_n, lcm_n, inv_n, div2_n, mul2_n, add_d_n, sub_d_n;
char* ret;
#else
unsigned long s, t;
unsigned long long q, r;
mp_digit mp;
int i, n, err, should;
#endif
if (mp_init_multi(&a, &b, &c, &d, &e, &f, NULL)!= MP_OKAY)
return EXIT_FAILURE;
atexit(_cleanup);
#if defined(LTM_DEMO_REAL_RAND)
if (!fd_urandom) {
fd_urandom = fopen("/dev/urandom", "r");
if (!fd_urandom) {
#if !defined(_WIN32)
fprintf(stderr, "\ncould not open /dev/urandom\n");
#endif
}
}
#endif
srand(LTM_DEMO_RAND_SEED);
#ifdef MP_8BIT
printf("Digit size 8 Bit \n");
#endif
#ifdef MP_16BIT
printf("Digit size 16 Bit \n");
#endif
#ifdef MP_32BIT
printf("Digit size 32 Bit \n");
#endif
#ifdef MP_64BIT
printf("Digit size 64 Bit \n");
#endif
printf("Size of mp_digit: %u\n", (unsigned int)sizeof(mp_digit));
printf("Size of mp_word: %u\n", (unsigned int)sizeof(mp_word));
printf("DIGIT_BIT: %d\n", DIGIT_BIT);
printf("MP_PREC: %d\n", MP_PREC);
#if LTM_DEMO_TEST_VS_MTEST == 0
// trivial stuff
// a: 0->5
mp_set_int(&a, 5);
// a: 5-> b: -5
mp_neg(&a, &b);
if (mp_cmp(&a, &b) != MP_GT) {
return EXIT_FAILURE;
}
if (mp_cmp(&b, &a) != MP_LT) {
return EXIT_FAILURE;
}
// a: 5-> a: -5
mp_neg(&a, &a);
if (mp_cmp(&b, &a) != MP_EQ) {
return EXIT_FAILURE;
}
// a: -5-> b: 5
mp_abs(&a, &b);
if (mp_isneg(&b) != MP_NO) {
return EXIT_FAILURE;
}
// a: -5-> b: -4
mp_add_d(&a, 1, &b);
if (mp_isneg(&b) != MP_YES) {
return EXIT_FAILURE;
}
if (mp_get_int(&b) != 4) {
return EXIT_FAILURE;
}
// a: -5-> b: 1
mp_add_d(&a, 6, &b);
if (mp_get_int(&b) != 1) {
return EXIT_FAILURE;
}
// a: -5-> a: 1
mp_add_d(&a, 6, &a);
if (mp_get_int(&a) != 1) {
return EXIT_FAILURE;
}
mp_zero(&a);
// a: 0-> a: 6
mp_add_d(&a, 6, &a);
if (mp_get_int(&a) != 6) {
return EXIT_FAILURE;
}
mp_set_int(&a, 0);
mp_set_int(&b, 1);
if ((err = mp_jacobi(&a, &b, &i)) != MP_OKAY) {
printf("Failed executing mp_jacobi(0 | 1) %s.\n", mp_error_to_string(err));
return EXIT_FAILURE;
}
if (i != 1) {
printf("Failed trivial mp_jacobi(0 | 1) %d != 1\n", i);
return EXIT_FAILURE;
}
for (cnt = 0; cnt < (int)(sizeof(jacobi)/sizeof(jacobi[0])); ++cnt) {
mp_set_int(&b, jacobi[cnt].n);
/* only test positive values of a */
for (n = -5; n <= 10; ++n) {
mp_set_int(&a, abs(n));
should = MP_OKAY;
if (n < 0) {
mp_neg(&a, &a);
/* Until #44 is fixed the negative a's must fail */
should = MP_VAL;
}
if ((err = mp_jacobi(&a, &b, &i)) != should) {
printf("Failed executing mp_jacobi(%d | %lu) %s.\n", n, jacobi[cnt].n, mp_error_to_string(err));
return EXIT_FAILURE;
}
if (err == MP_OKAY && i != jacobi[cnt].c[n + 5]) {
printf("Failed trivial mp_jacobi(%d | %lu) %d != %d\n", n, jacobi[cnt].n, i, jacobi[cnt].c[n + 5]);
return EXIT_FAILURE;
}
}
}
// test mp_get_int
printf("\n\nTesting: mp_get_int");
for (i = 0; i < 1000; ++i) {
t = ((unsigned long) rand () * rand () + 1) & 0xFFFFFFFF;
mp_set_int (&a, t);
if (t != mp_get_int (&a)) {
printf ("\nmp_get_int() bad result!");
return EXIT_FAILURE;
}
}
mp_set_int(&a, 0);
if (mp_get_int(&a) != 0) {
printf("\nmp_get_int() bad result!");
return EXIT_FAILURE;
}
mp_set_int(&a, 0xffffffff);
if (mp_get_int(&a) != 0xffffffff) {
printf("\nmp_get_int() bad result!");
return EXIT_FAILURE;
}
printf("\n\nTesting: mp_get_long\n");
for (i = 0; i < (int)(sizeof(unsigned long)*CHAR_BIT) - 1; ++i) {
t = (1ULL << (i+1)) - 1;
if (!t)
t = -1;
printf(" t = 0x%lx i = %d\r", t, i);
do {
if (mp_set_long(&a, t) != MP_OKAY) {
printf("\nmp_set_long() error!");
return EXIT_FAILURE;
}
s = mp_get_long(&a);
if (s != t) {
printf("\nmp_get_long() bad result! 0x%lx != 0x%lx", s, t);
return EXIT_FAILURE;
}
t <<= 1;
} while(t);
}
printf("\n\nTesting: mp_get_long_long\n");
for (i = 0; i < (int)(sizeof(unsigned long long)*CHAR_BIT) - 1; ++i) {
r = (1ULL << (i+1)) - 1;
if (!r)
r = -1;
printf(" r = 0x%llx i = %d\r", r, i);
do {
if (mp_set_long_long(&a, r) != MP_OKAY) {
printf("\nmp_set_long_long() error!");
return EXIT_FAILURE;
}
q = mp_get_long_long(&a);
if (q != r) {
printf("\nmp_get_long_long() bad result! 0x%llx != 0x%llx", q, r);
return EXIT_FAILURE;
}
r <<= 1;
} while(r);
}
// test mp_sqrt
printf("\n\nTesting: mp_sqrt\n");
for (i = 0; i < 1000; ++i) {
printf ("%6d\r", i);
fflush (stdout);
n = (rand () & 15) + 1;
mp_rand (&a, n);
if (mp_sqrt (&a, &b) != MP_OKAY) {
printf ("\nmp_sqrt() error!");
return EXIT_FAILURE;
}
mp_n_root_ex (&a, 2, &c, 0);
mp_n_root_ex (&a, 2, &d, 1);
if (mp_cmp_mag (&c, &d) != MP_EQ) {
printf ("\nmp_n_root_ex() bad result!");
return EXIT_FAILURE;
}
if (mp_cmp_mag (&b, &c) != MP_EQ) {
printf ("mp_sqrt() bad result!\n");
return EXIT_FAILURE;
}
}
printf("\n\nTesting: mp_is_square\n");
for (i = 0; i < 1000; ++i) {
printf ("%6d\r", i);
fflush (stdout);
/* test mp_is_square false negatives */
n = (rand () & 7) + 1;
mp_rand (&a, n);
mp_sqr (&a, &a);
if (mp_is_square (&a, &n) != MP_OKAY) {
printf ("\nfn:mp_is_square() error!");
return EXIT_FAILURE;
}
if (n == 0) {
printf ("\nfn:mp_is_square() bad result!");
return EXIT_FAILURE;
}
/* test for false positives */
mp_add_d (&a, 1, &a);
if (mp_is_square (&a, &n) != MP_OKAY) {
printf ("\nfp:mp_is_square() error!");
return EXIT_FAILURE;
}
if (n == 1) {
printf ("\nfp:mp_is_square() bad result!");
return EXIT_FAILURE;
}
}
printf("\n\n");
// r^2 = n (mod p)
for (i = 0; i < (int)(sizeof(sqrtmod_prime)/sizeof(sqrtmod_prime[0])); ++i) {
mp_set_int(&a, sqrtmod_prime[i].p);
mp_set_int(&b, sqrtmod_prime[i].n);
if (mp_sqrtmod_prime(&b, &a, &c) != MP_OKAY) {
printf("Failed executing %d. mp_sqrtmod_prime\n", (i+1));
return EXIT_FAILURE;
}
if (mp_cmp_d(&c, sqrtmod_prime[i].r) != MP_EQ) {
printf("Failed %d. trivial mp_sqrtmod_prime\n", (i+1));
ndraw(&c, "r");
return EXIT_FAILURE;
}
}
/* test for size */
for (ix = 10; ix < 128; ix++) {
printf ("Testing (not safe-prime): %9d bits \r", ix);
fflush (stdout);
err = mp_prime_random_ex (&a, 8, ix,
(rand () & 1) ? 0 : LTM_PRIME_2MSB_ON, myrng,
NULL);
if (err != MP_OKAY) {
printf ("failed with err code %d\n", err);
return EXIT_FAILURE;
}
if (mp_count_bits (&a) != ix) {
printf ("Prime is %d not %d bits!!!\n", mp_count_bits (&a), ix);
return EXIT_FAILURE;
}
}
printf("\n");
for (ix = 16; ix < 128; ix++) {
printf ("Testing ( safe-prime): %9d bits \r", ix);
fflush (stdout);
err = mp_prime_random_ex (
&a, 8, ix, ((rand () & 1) ? 0 : LTM_PRIME_2MSB_ON) | LTM_PRIME_SAFE,
myrng, NULL);
if (err != MP_OKAY) {
printf ("failed with err code %d\n", err);
return EXIT_FAILURE;
}
if (mp_count_bits (&a) != ix) {
printf ("Prime is %d not %d bits!!!\n", mp_count_bits (&a), ix);
return EXIT_FAILURE;
}
/* let's see if it's really a safe prime */
mp_sub_d (&a, 1, &a);
mp_div_2 (&a, &a);
mp_prime_is_prime (&a, 8, &cnt);
if (cnt != MP_YES) {
printf ("sub is not prime!\n");
return EXIT_FAILURE;
}
}
printf("\n\n");
// test montgomery
printf("Testing: montgomery...\n");
for (i = 1; i <= 10; i++) {
if (i == 10)
i = 1000;
printf(" digit size: %2d\r", i);
fflush(stdout);
for (n = 0; n < 1000; n++) {
mp_rand(&a, i);
a.dp[0] |= 1;
// let's see if R is right
mp_montgomery_calc_normalization(&b, &a);
mp_montgomery_setup(&a, &mp);
// now test a random reduction
for (ix = 0; ix < 100; ix++) {
mp_rand(&c, 1 + abs(rand()) % (2*i));
mp_copy(&c, &d);
mp_copy(&c, &e);
mp_mod(&d, &a, &d);
mp_montgomery_reduce(&c, &a, mp);
mp_mulmod(&c, &b, &a, &c);
if (mp_cmp(&c, &d) != MP_EQ) {
printf("d = e mod a, c = e MOD a\n");
mp_todecimal(&a, buf); printf("a = %s\n", buf);
mp_todecimal(&e, buf); printf("e = %s\n", buf);
mp_todecimal(&d, buf); printf("d = %s\n", buf);
mp_todecimal(&c, buf); printf("c = %s\n", buf);
printf("compare no compare!\n"); return EXIT_FAILURE; }
/* only one big montgomery reduction */
if (i > 10)
{
n = 1000;
ix = 100;
}
}
}
}
printf("\n\n");
mp_read_radix(&a, "123456", 10);
mp_toradix_n(&a, buf, 10, 3);
printf("a == %s\n", buf);
mp_toradix_n(&a, buf, 10, 4);
printf("a == %s\n", buf);
mp_toradix_n(&a, buf, 10, 30);
printf("a == %s\n", buf);
#if 0
for (;;) {
fgets(buf, sizeof(buf), stdin);
mp_read_radix(&a, buf, 10);
mp_prime_next_prime(&a, 5, 1);
mp_toradix(&a, buf, 10);
printf("%s, %lu\n", buf, a.dp[0] & 3);
}
#endif
/* test mp_cnt_lsb */
printf("\n\nTesting: mp_cnt_lsb");
mp_set(&a, 1);
for (ix = 0; ix < 1024; ix++) {
if (mp_cnt_lsb (&a) != ix) {
printf ("Failed at %d, %d\n", ix, mp_cnt_lsb (&a));
return EXIT_FAILURE;
}
mp_mul_2 (&a, &a);
}
/* test mp_reduce_2k */
printf("\n\nTesting: mp_reduce_2k\n");
for (cnt = 3; cnt <= 128; ++cnt) {
mp_digit tmp;
mp_2expt (&a, cnt);
mp_sub_d (&a, 2, &a); /* a = 2**cnt - 2 */
printf ("\r %4d bits", cnt);
printf ("(%d)", mp_reduce_is_2k (&a));
mp_reduce_2k_setup (&a, &tmp);
printf ("(%lu)", (unsigned long) tmp);
for (ix = 0; ix < 1000; ix++) {
if (!(ix & 127)) {
printf (".");
fflush (stdout);
}
mp_rand (&b, (cnt / DIGIT_BIT + 1) * 2);
mp_copy (&c, &b);
mp_mod (&c, &a, &c);
mp_reduce_2k (&b, &a, 2);
if (mp_cmp (&c, &b)) {
printf ("FAILED\n");
return EXIT_FAILURE;
}
}
}
/* test mp_div_3 */
printf("\n\nTesting: mp_div_3...\n");
mp_set(&d, 3);
for (cnt = 0; cnt < 10000;) {
mp_digit r2;
if (!(++cnt & 127))
{
printf("%9d\r", cnt);
fflush(stdout);
}
mp_rand(&a, abs(rand()) % 128 + 1);
mp_div(&a, &d, &b, &e);
mp_div_3(&a, &c, &r2);
if (mp_cmp(&b, &c) || mp_cmp_d(&e, r2)) {
printf("\nmp_div_3 => Failure\n");
}
}
printf("\nPassed div_3 testing");
/* test the DR reduction */
printf("\n\nTesting: mp_dr_reduce...\n");
for (cnt = 2; cnt < 32; cnt++) {
printf ("\r%d digit modulus", cnt);
mp_grow (&a, cnt);
mp_zero (&a);
for (ix = 1; ix < cnt; ix++) {
a.dp[ix] = MP_MASK;
}
a.used = cnt;
a.dp[0] = 3;
mp_rand (&b, cnt - 1);
mp_copy (&b, &c);
rr = 0;
do {
if (!(rr & 127)) {
printf (".");
fflush (stdout);
}
mp_sqr (&b, &b);
mp_add_d (&b, 1, &b);
mp_copy (&b, &c);
mp_mod (&b, &a, &b);
mp_dr_setup(&a, &mp),
mp_dr_reduce (&c, &a, mp);
if (mp_cmp (&b, &c) != MP_EQ) {
printf ("Failed on trial %u\n", rr);
return EXIT_FAILURE;
}
} while (++rr < 500);
printf (" passed");
fflush (stdout);
}
#if LTM_DEMO_TEST_REDUCE_2K_L
/* test the mp_reduce_2k_l code */
#if LTM_DEMO_TEST_REDUCE_2K_L == 1
/* first load P with 2^1024 - 0x2A434 B9FDEC95 D8F9D550 FFFFFFFF FFFFFFFF */
mp_2expt(&a, 1024);
mp_read_radix(&b, "2A434B9FDEC95D8F9D550FFFFFFFFFFFFFFFF", 16);
mp_sub(&a, &b, &a);
#elif LTM_DEMO_TEST_REDUCE_2K_L == 2
/* p = 2^2048 - 0x1 00000000 00000000 00000000 00000000 4945DDBF 8EA2A91D 5776399B B83E188F */
mp_2expt(&a, 2048);
mp_read_radix(&b,
"1000000000000000000000000000000004945DDBF8EA2A91D5776399BB83E188F",
16);
mp_sub(&a, &b, &a);
#else
#error oops
#endif
mp_todecimal(&a, buf);
printf("\n\np==%s\n", buf);
/* now mp_reduce_is_2k_l() should return */
if (mp_reduce_is_2k_l(&a) != 1) {
printf("mp_reduce_is_2k_l() return 0, should be 1\n");
return EXIT_FAILURE;
}
mp_reduce_2k_setup_l(&a, &d);
/* now do a million square+1 to see if it varies */
mp_rand(&b, 64);
mp_mod(&b, &a, &b);
mp_copy(&b, &c);
printf("Testing: mp_reduce_2k_l...");
fflush(stdout);
for (cnt = 0; cnt < (int)(1UL << 20); cnt++) {
mp_sqr(&b, &b);
mp_add_d(&b, 1, &b);
mp_reduce_2k_l(&b, &a, &d);
mp_sqr(&c, &c);
mp_add_d(&c, 1, &c);
mp_mod(&c, &a, &c);
if (mp_cmp(&b, &c) != MP_EQ) {
printf("mp_reduce_2k_l() failed at step %d\n", cnt);
mp_tohex(&b, buf);
printf("b == %s\n", buf);
mp_tohex(&c, buf);
printf("c == %s\n", buf);
return EXIT_FAILURE;
}
}
printf("...Passed\n");
#endif /* LTM_DEMO_TEST_REDUCE_2K_L */
#else
div2_n = mul2_n = inv_n = expt_n = lcm_n = gcd_n = add_n =
sub_n = mul_n = div_n = sqr_n = mul2d_n = div2d_n = cnt = add_d_n =
sub_d_n = 0;
/* force KARA and TOOM to enable despite cutoffs */
KARATSUBA_SQR_CUTOFF = KARATSUBA_MUL_CUTOFF = 8;
TOOM_SQR_CUTOFF = TOOM_MUL_CUTOFF = 16;
for (;;) {
/* randomly clear and re-init one variable, this has the affect of triming the alloc space */
switch (abs(rand()) % 7) {
case 0:
mp_clear(&a);
mp_init(&a);
break;
case 1:
mp_clear(&b);
mp_init(&b);
break;
case 2:
mp_clear(&c);
mp_init(&c);
break;
case 3:
mp_clear(&d);
mp_init(&d);
break;
case 4:
mp_clear(&e);
mp_init(&e);
break;
case 5:
mp_clear(&f);
mp_init(&f);
break;
case 6:
break; /* don't clear any */
}
printf
("%4lu/%4lu/%4lu/%4lu/%4lu/%4lu/%4lu/%4lu/%4lu/%4lu/%4lu/%4lu/%4lu/%4lu/%4lu ",
add_n, sub_n, mul_n, div_n, sqr_n, mul2d_n, div2d_n, gcd_n, lcm_n,
expt_n, inv_n, div2_n, mul2_n, add_d_n, sub_d_n);
ret=fgets(cmd, 4095, stdin); if(!ret){_panic(__LINE__);}
cmd[strlen(cmd) - 1] = 0;
printf("%-6s ]\r", cmd);
fflush(stdout);
if (!strcmp(cmd, "mul2d")) {
++mul2d_n;
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&a, buf, 64);
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
sscanf(buf, "%d", &rr);
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&b, buf, 64);
mp_mul_2d(&a, rr, &a);
a.sign = b.sign;
if (mp_cmp(&a, &b) != MP_EQ) {
printf("mul2d failed, rr == %d\n", rr);
draw(&a);
draw(&b);
return EXIT_FAILURE;
}
} else if (!strcmp(cmd, "div2d")) {
++div2d_n;
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&a, buf, 64);
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
sscanf(buf, "%d", &rr);
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&b, buf, 64);
mp_div_2d(&a, rr, &a, &e);
a.sign = b.sign;
if (a.used == b.used && a.used == 0) {
a.sign = b.sign = MP_ZPOS;
}
if (mp_cmp(&a, &b) != MP_EQ) {
printf("div2d failed, rr == %d\n", rr);
draw(&a);
draw(&b);
return EXIT_FAILURE;
}
} else if (!strcmp(cmd, "add")) {
++add_n;
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&a, buf, 64);
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&b, buf, 64);
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&c, buf, 64);
mp_copy(&a, &d);
mp_add(&d, &b, &d);
if (mp_cmp(&c, &d) != MP_EQ) {
printf("add %lu failure!\n", add_n);
draw(&a);
draw(&b);
draw(&c);
draw(&d);
return EXIT_FAILURE;
}
/* test the sign/unsigned storage functions */
rr = mp_signed_bin_size(&c);
mp_to_signed_bin(&c, (unsigned char *) cmd);
memset(cmd + rr, rand() & 255, sizeof(cmd) - rr);
mp_read_signed_bin(&d, (unsigned char *) cmd, rr);
if (mp_cmp(&c, &d) != MP_EQ) {
printf("mp_signed_bin failure!\n");
draw(&c);
draw(&d);
return EXIT_FAILURE;
}
rr = mp_unsigned_bin_size(&c);
mp_to_unsigned_bin(&c, (unsigned char *) cmd);
memset(cmd + rr, rand() & 255, sizeof(cmd) - rr);
mp_read_unsigned_bin(&d, (unsigned char *) cmd, rr);
if (mp_cmp_mag(&c, &d) != MP_EQ) {
printf("mp_unsigned_bin failure!\n");
draw(&c);
draw(&d);
return EXIT_FAILURE;
}
} else if (!strcmp(cmd, "sub")) {
++sub_n;
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&a, buf, 64);
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&b, buf, 64);
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&c, buf, 64);
mp_copy(&a, &d);
mp_sub(&d, &b, &d);
if (mp_cmp(&c, &d) != MP_EQ) {
printf("sub %lu failure!\n", sub_n);
draw(&a);
draw(&b);
draw(&c);
draw(&d);
return EXIT_FAILURE;
}
} else if (!strcmp(cmd, "mul")) {
++mul_n;
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&a, buf, 64);
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&b, buf, 64);
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&c, buf, 64);
mp_copy(&a, &d);
mp_mul(&d, &b, &d);
if (mp_cmp(&c, &d) != MP_EQ) {
printf("mul %lu failure!\n", mul_n);
draw(&a);
draw(&b);
draw(&c);
draw(&d);
return EXIT_FAILURE;
}
} else if (!strcmp(cmd, "div")) {
++div_n;
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&a, buf, 64);
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&b, buf, 64);
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&c, buf, 64);
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&d, buf, 64);
mp_div(&a, &b, &e, &f);
if (mp_cmp(&c, &e) != MP_EQ || mp_cmp(&d, &f) != MP_EQ) {
printf("div %lu %d, %d, failure!\n", div_n, mp_cmp(&c, &e),
mp_cmp(&d, &f));
draw(&a);
draw(&b);
draw(&c);
draw(&d);
draw(&e);
draw(&f);
return EXIT_FAILURE;
}
} else if (!strcmp(cmd, "sqr")) {
++sqr_n;
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&a, buf, 64);
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&b, buf, 64);
mp_copy(&a, &c);
mp_sqr(&c, &c);
if (mp_cmp(&b, &c) != MP_EQ) {
printf("sqr %lu failure!\n", sqr_n);
draw(&a);
draw(&b);
draw(&c);
return EXIT_FAILURE;
}
} else if (!strcmp(cmd, "gcd")) {
++gcd_n;
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&a, buf, 64);
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&b, buf, 64);
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&c, buf, 64);
mp_copy(&a, &d);
mp_gcd(&d, &b, &d);
d.sign = c.sign;
if (mp_cmp(&c, &d) != MP_EQ) {
printf("gcd %lu failure!\n", gcd_n);
draw(&a);
draw(&b);
draw(&c);
draw(&d);
return EXIT_FAILURE;
}
} else if (!strcmp(cmd, "lcm")) {
++lcm_n;
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&a, buf, 64);
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&b, buf, 64);
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&c, buf, 64);
mp_copy(&a, &d);
mp_lcm(&d, &b, &d);
d.sign = c.sign;
if (mp_cmp(&c, &d) != MP_EQ) {
printf("lcm %lu failure!\n", lcm_n);
draw(&a);
draw(&b);
draw(&c);
draw(&d);
return EXIT_FAILURE;
}
} else if (!strcmp(cmd, "expt")) {
++expt_n;
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&a, buf, 64);
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&b, buf, 64);
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&c, buf, 64);
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&d, buf, 64);
mp_copy(&a, &e);
mp_exptmod(&e, &b, &c, &e);
if (mp_cmp(&d, &e) != MP_EQ) {
printf("expt %lu failure!\n", expt_n);
draw(&a);
draw(&b);
draw(&c);
draw(&d);
draw(&e);
return EXIT_FAILURE;
}
} else if (!strcmp(cmd, "invmod")) {
++inv_n;
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&a, buf, 64);
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&b, buf, 64);
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&c, buf, 64);
mp_invmod(&a, &b, &d);
mp_mulmod(&d, &a, &b, &e);
if (mp_cmp_d(&e, 1) != MP_EQ) {
printf("inv [wrong value from MPI?!] failure\n");
draw(&a);
draw(&b);
draw(&c);
draw(&d);
draw(&e);
mp_gcd(&a, &b, &e);
draw(&e);
return EXIT_FAILURE;
}
} else if (!strcmp(cmd, "div2")) {
++div2_n;
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&a, buf, 64);
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&b, buf, 64);
mp_div_2(&a, &c);
if (mp_cmp(&c, &b) != MP_EQ) {
printf("div_2 %lu failure\n", div2_n);
draw(&a);
draw(&b);
draw(&c);
return EXIT_FAILURE;
}
} else if (!strcmp(cmd, "mul2")) {
++mul2_n;
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&a, buf, 64);
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&b, buf, 64);
mp_mul_2(&a, &c);
if (mp_cmp(&c, &b) != MP_EQ) {
printf("mul_2 %lu failure\n", mul2_n);
draw(&a);
draw(&b);
draw(&c);
return EXIT_FAILURE;
}
} else if (!strcmp(cmd, "add_d")) {
++add_d_n;
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&a, buf, 64);
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
sscanf(buf, "%d", &ix);
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&b, buf, 64);
mp_add_d(&a, ix, &c);
if (mp_cmp(&b, &c) != MP_EQ) {
printf("add_d %lu failure\n", add_d_n);
draw(&a);
draw(&b);
draw(&c);
printf("d == %d\n", ix);
return EXIT_FAILURE;
}
} else if (!strcmp(cmd, "sub_d")) {
++sub_d_n;
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&a, buf, 64);
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
sscanf(buf, "%d", &ix);
ret=fgets(buf, 4095, stdin); if(!ret){_panic(__LINE__);}
mp_read_radix(&b, buf, 64);
mp_sub_d(&a, ix, &c);
if (mp_cmp(&b, &c) != MP_EQ) {
printf("sub_d %lu failure\n", sub_d_n);
draw(&a);
draw(&b);
draw(&c);
printf("d == %d\n", ix);
return EXIT_FAILURE;
}
} else if (!strcmp(cmd, "exit")) {
printf("\nokay, exiting now\n");
break;
}
}
#endif
return 0;
}
static int
sha_fs_put(struct request *r)
{
blk_SHA_CTX ctx;
char tmp_path[MAX_FILE_PATH_LEN];
unsigned char chunk[CHUNK_SIZE], *cp, *cp_end;
int fd = -1;
int status = 0;
char buf[MSG_SIZE];
/*
* Open a temporary file in $sha_fs_root/tmp to accumulate the
* blob read from the client. The file looks like
*
* [put|give]-time-pid-digest
*/
snprintf(tmp_path, sizeof tmp_path, "%s/%s-%d-%u-%s",
boot_data.tmp_dir_path,
r->verb,
/*
* Warning:
* Casting time() to int is
* incorrect!!
*/
(int)time((time_t *)0),
getpid(),
r->digest);
/*
* Open the file ... need O_LARGEFILE support!!
* Need to catch EINTR!!!!
*/
fd = io_open(tmp_path, O_CREAT|O_EXCL|O_WRONLY|O_APPEND, S_IRUSR);
if (fd < 0) {
snprintf(buf, sizeof buf, "open(%s) failed: %s", tmp_path,
strerror(errno));
_panic(r, buf);
}
/*
* Initialize digest of blob being scanned from the client.
*/
blk_SHA1_Init(&ctx);
/*
* An empty blob is always put.
* Note: the caller has already ensured that no more data has
* been written by the client, so no need to check r->scan_size.
*/
if (strcmp(r->digest, empty_ascii) == 0)
goto digested;
/*
* Copy what we have already read into the first chunk buffer.
*
* If we've read ahead more than we can chew,
* then croak. This should never happen.
*/
if (r->scan_size > 0) {
// Note: regress, sanity test ... remove later.
if ((u8)r->scan_size != r->blob_size)
_panic(r, "r->scan_size != r->blob_size");
if (r->scan_size > (int)(sizeof chunk - 1)) {
snprintf(buf, sizeof buf, "max=%lu",
(long unsigned)(sizeof chunk - 1));
_panic2(r, "scanned chunk too big", buf);
}
/*
* See if the entire blob fits in the first read.
*/
if (eat_chunk(r, &ctx, fd, r->scan_buf, r->scan_size))
goto digested;
}
cp = chunk;
cp_end = &chunk[sizeof chunk];
/*
* Read more chunks until we see the blob.
*/
again:
while (cp < cp_end) {
int nread = blob_read(r, cp, cp_end - cp);
/*
* Read error from client,
* so zap the partial, invalid blob.
*/
if (nread < 0) {
_error(r, "blob_read() failed");
goto croak;
}
if (nread == 0) {
_error(r, "blob_read() returns 0 before digest seen");
goto croak;
}
switch (eat_chunk(r, &ctx, fd, cp, nread)) {
case -1:
_panic(r, "eat_chunk(local) failed");
case 1:
goto digested;
}
cp += nread;
}
cp = chunk;
goto again;
digested:
if (fd >= 0)
_close(r, &fd);
/*
* Move the temp blob file to the final blob path.
*/
blob_path(r, r->digest);
arbor_rename(tmp_path,
((struct sha_fs_request *)r->open_data)->blob_path);
goto cleanup;
croak:
status = -1;
cleanup:
if (fd > -1)
_panic(r, "_close() failed");
if (tmp_path[0] && _unlink(r, tmp_path, (int *)0))
_panic(r, "_unlink() failed");
return status;
}
static int
sha_fs_eat(struct request *r)
{
struct sha_fs_request *sp = (struct sha_fs_request *)r->open_data;
int status = 0;
blk_SHA_CTX ctx;
unsigned char digest[20];
int fd;
unsigned char chunk[CHUNK_SIZE];
int nread;
blob_path(r, r->digest);
/*
* Open the file to the blob.
*/
switch (_open(r, sp->blob_path, &fd)) {
case 0:
break;
/*
* Blob not found.
*/
case ENOENT:
return 1;
default:
_panic(r, "_open(blob) failed");
}
blk_SHA1_Init(&ctx);
/*
* Read a chunk from the file and chew.
*/
while ((nread = _read(r, fd, chunk, sizeof chunk)) > 0)
/*
* Update the incremental digest.
*/
blk_SHA1_Update(&ctx, chunk, nread);
if (nread < 0)
_panic(r, "_read(blob) failed");
/*
* Finalize the digest.
*/
blk_SHA1_Final(digest, &ctx);
/*
* If the calculated digest does NOT match the stored digest,
* then zap the blob from storage and get panicy.
* A corrupt blob is a bad, bad thang.
*
* Note: unfortunately we've already deceived the client
* by sending "ok". Probably need to improve for
* the special case when the entire blob is read
* in first chunk.
*/
if (memcmp(sp->digest, digest, 20))
_panic2(r, "stored blob doesn't match digest", r->digest);
if (_close(r, &fd))
_panic(r, "_close(blob) failed");
return status;
}
static int
sha_fs_get(struct request *r)
{
struct sha_fs_request *sp = (struct sha_fs_request *)r->open_data;
int status = 0;
blk_SHA_CTX ctx;
unsigned char digest[20];
int fd;
unsigned char chunk[CHUNK_SIZE];
int nread;
blob_path(r, r->digest);
/*
* Open the file to the blob.
*/
switch (_open(r, sp->blob_path, &fd)) {
case 0:
break;
case ENOENT:
return 1;
default:
_panic(r, "_open(blob) failed");
}
/*
* Tell the client we have the blob.
*/
if (write_ok(r)) {
_error(r, "write_ok() failed");
goto croak;
}
blk_SHA1_Init(&ctx);
/*
* Read a chunk from the file, write chunk to client,
* update incremental digest.
*
* In principle, we ought to first scan the blob file
* before sending "ok" to the requestor.
*/
while ((nread = _read(r, fd, chunk, sizeof chunk)) > 0) {
if (blob_write(r, chunk, nread)) {
_error(r, "blob_write(blob chunk) failed");
goto croak;
}
/*
* Update the incremental digest.
*/
blk_SHA1_Update(&ctx, chunk, nread);
}
if (nread < 0)
_panic(r, "_read(blob) failed");
/*
* Finalize the digest.
*/
blk_SHA1_Final(digest, &ctx);
/*
* If the calculated digest does NOT match the stored digest,
* then zap the blob from storage and get panicy.
* A corrupt blob is a bad, bad thang.
*
* Note: unfortunately we've already deceived the client
* by sending "ok". Probably need to improve for
* the special case when the entire blob is read
* in first chunk.
*/
if (memcmp(sp->digest, digest, 20)) {
_error2(r, "PANIC: stored blob doesn't match digest",
r->digest);
if (zap_blob(r))
_panic(r, "zap_blob() failed");
goto croak;
}
goto cleanup;
croak:
status = -1;
cleanup:
if (_close(r, &fd))
_panic(r, "_close(blob) failed");
return status;
}
/*
* unblock the previously blocked signal
*/
static void
poll_unblocksig(void)
{
if(sigprocmask(SIG_SETMASK, &bset, NULL))
_panic("sigprocmask(SIG_SETMASK): %s", strerror(errno));
}
/*
* Poll the file descriptors and dispatch to the right function
* If wait is true the poll blocks until somewhat happens.
* Don't use a pointer here, because the called function may cause
* a reallocation! The check for pfd != NULL is required, because
* a sequence of unregister/register could make the wrong callback
* to be called. So we clear pfd in unregister and check here.
*/
void
poll_dispatch(int wait)
{
u_int i, idx;
int ret;
tval_t now;
tval_t tout;
static u_int last_index;
# ifdef USE_SELECT
fd_set nrset, nwset, nxset;
struct timeval tv;
# endif
in_dispatch = 1;
if(rebuild) {
rebuild = 0;
poll_build();
}
if(resort) {
resort = 0;
sort_timers();
}
/* in wait mode - compute the timeout */
if(wait) {
if(tfd_used) {
now = GETUSECS();
# ifdef DEBUG
{
fprintf(stderr, "now=%llu", now);
for(i = 0; i < tims_used; i++)
fprintf(stderr, "timers[%2d] = %lld",
i, tfd[i]->when - now);
}
# endif
if((tout = tims[tfd[0]].when - now) < 0)
tout = 0;
} else
tout = INFTIM;
} else
tout = 0;
# ifdef DEBUG
fprintf(stderr, "rpoll -- selecting with tout=%u", tout);
# endif
# ifdef USE_POLL
ret = poll(pfd, regs_used, tout == INFTIM ? INFTIM : (tout / 1000));
# endif
# ifdef USE_SELECT
nrset = rset;
nwset = wset;
nxset = xset;
if(tout != INFTIM) {
tv.tv_sec = tout / 1000000;
tv.tv_usec = tout % 1000000;
}
ret = select(maxfd+1,
SELECT_CAST(&nrset),
SELECT_CAST(&nwset),
SELECT_CAST(&nxset), (tout==INFTIM) ? NULL : &tv);
# endif
if(ret == -1) {
if(errno == EINTR)
return;
_panic("poll/select: %s", strerror(errno));
}
/* dispatch files */
if(ret > 0) {
for(i = 0; i < regs_alloc; i++) {
idx = rpoll_policy ? ((last_index+i) % regs_alloc) : i;
assert(idx < regs_alloc);
if(regs[idx].fd >= 0) {
int mask = 0;
# ifdef USE_POLL
if(regs[idx].pfd) {
if ((regs[idx].mask & POLL_IN) &&
(regs[idx].pfd->revents & poll_in))
mask |= POLL_IN;
if ((regs[idx].mask & POLL_OUT) &&
(regs[idx].pfd->revents & poll_out))
mask |= POLL_OUT;
if((regs[idx].mask & POLL_EXCEPT) &&
(regs[idx].pfd->revents & poll_except))
mask |= POLL_EXCEPT;
}
# endif
# ifdef USE_SELECT
if ((regs[idx].mask & POLL_IN) &&
FD_ISSET(regs[idx].fd, &nrset))
mask |= POLL_IN;
if ((regs[idx].mask & POLL_OUT) &&
FD_ISSET(regs[idx].fd, &nwset))
mask |= POLL_OUT;
if ((regs[idx].mask & POLL_EXCEPT) &&
FD_ISSET(regs[idx].fd, &nxset))
mask |= POLL_EXCEPT;
# endif
assert(idx < regs_alloc);
if(mask) {
if(rpoll_trace)
fprintf(stderr, "poll_dispatch() -- "
"file %d/%d %x",
regs[idx].fd, idx, mask);
(*regs[idx].func)(regs[idx].fd, mask, regs[idx].arg);
}
}
}
last_index++;
}
/* dispatch timeouts */
if(tfd_used) {
now = GETUSECS();
for(i = 0; i < tfd_used; i++) {
if(tfd[i] < 0)
continue;
if(tims[tfd[i]].when > now)
break;
if(rpoll_trace)
fprintf(stderr, "rpoll_dispatch() -- timeout %d",tfd[i]);
(*tims[tfd[i]].func)(tfd[i], tims[tfd[i]].arg);
if(tfd[i] < 0)
continue;
if(tims[tfd[i]].repeat)
tims[tfd[i]].when = now + tims[tfd[i]].usecs;
else {
tims[tfd[i]].func = NULL;
tims_used--;
tfd[i] = -1;
}
resort = 1;
}
}
in_dispatch = 0;
}
IRStmt *vx_dopyIRStmt(IRStmt *s)
{
switch (s->tag)
{
case Ist_NoOp:
return vx_IRStmt_NoOp();
case Ist_AbiHint:
return vx_IRStmt_AbiHint(vx_dopyIRExpr(s->Ist.AbiHint.base), s->Ist.AbiHint.len);
case Ist_IMark:
return vx_IRStmt_IMark(s->Ist.IMark.addr, s->Ist.IMark.len);
case Ist_Put:
return vx_IRStmt_Put(s->Ist.Put.offset, vx_dopyIRExpr(s->Ist.Put.data));
case Ist_PutI:
return vx_IRStmt_PutI(vx_dopyIRRegArray(s->Ist.PutI.details->descr),
vx_dopyIRExpr(s->Ist.PutI.details->ix),
s->Ist.PutI.details->bias,
vx_dopyIRExpr(s->Ist.PutI.details->data));
case Ist_WrTmp:
return vx_IRStmt_Tmp(s->Ist.WrTmp.tmp, vx_dopyIRExpr(s->Ist.WrTmp.data));
case Ist_Store:
return vx_IRStmt_Store(s->Ist.Store.end,
vx_dopyIRExpr(s->Ist.Store.addr),
vx_dopyIRExpr(s->Ist.Store.data));
case Ist_Dirty:
return vx_IRStmt_Dirty(vx_dopyIRDirty(s->Ist.Dirty.details));
case Ist_MFence:
return vx_IRStmt_MFence();
case Ist_Exit:
return vx_IRStmt_Exit(vx_dopyIRExpr(s->Ist.Exit.guard),
s->Ist.Exit.jk,
vx_dopyIRConst(s->Ist.Exit.dst));
case Ist_CAS:
return vx_IRStmt_CAS(vx_dopyIRCAS(s->Ist.CAS.details));
case Ist_LLSC:
return vx_IRStmt_LLSC(s->Ist.LLSC.end,
s->Ist.LLSC.result,
vx_dopyIRExpr(s->Ist.LLSC.addr),
s->Ist.LLSC.storedata
? vx_dopyIRExpr(s->Ist.LLSC.storedata)
: NULL);
default:
_panic("vx_dopyIRStmt(): unknown statement");
}
return NULL;
}
IRExpr *vx_dopyIRExpr(IRExpr *e)
{
switch (e->tag)
{
case Iex_Get:
return vx_IRExpr_Get(e->Iex.Get.offset, e->Iex.Get.ty);
case Iex_GetI:
return vx_IRExpr_GetI(vx_dopyIRRegArray(e->Iex.GetI.descr),
vx_dopyIRExpr(e->Iex.GetI.ix),
e->Iex.GetI.bias);
case Iex_RdTmp:
return vx_IRExpr_Tmp(e->Iex.RdTmp.tmp);
case Iex_Qop:
return vx_IRExpr_Qop(e->Iex.Qop.details->op,
vx_dopyIRExpr(e->Iex.Qop.details->arg1),
vx_dopyIRExpr(e->Iex.Qop.details->arg2),
vx_dopyIRExpr(e->Iex.Qop.details->arg3),
vx_dopyIRExpr(e->Iex.Qop.details->arg4));
case Iex_Triop:
return vx_IRExpr_Triop(e->Iex.Triop.details->op,
vx_dopyIRExpr(e->Iex.Triop.details->arg1),
vx_dopyIRExpr(e->Iex.Triop.details->arg2),
vx_dopyIRExpr(e->Iex.Triop.details->arg3));
case Iex_Binop:
return vx_IRExpr_Binop(e->Iex.Binop.op,
vx_dopyIRExpr(e->Iex.Binop.arg1),
vx_dopyIRExpr(e->Iex.Binop.arg2));
case Iex_Unop:
return vx_IRExpr_Unop(e->Iex.Unop.op,
vx_dopyIRExpr(e->Iex.Unop.arg));
case Iex_Load:
return vx_IRExpr_Load(e->Iex.Load.end,
e->Iex.Load.ty,
vx_dopyIRExpr(e->Iex.Load.addr));
case Iex_Const:
return vx_IRExpr_Const(vx_dopyIRConst(e->Iex.Const.con));
case Iex_CCall:
return vx_IRExpr_CCall(vx_dopyIRCallee(e->Iex.CCall.cee),
e->Iex.CCall.retty,
vx_dopyIRExprVec(e->Iex.CCall.args));
case Iex_ITE:
return vx_IRExpr_ITE(vx_dopyIRExpr(e->Iex.ITE.cond),
vx_dopyIRExpr(e->Iex.ITE.iftrue),
vx_dopyIRExpr(e->Iex.ITE.iffalse));
case Iex_BBPTR:
return vx_IRExpr_BBPTR();
case Iex_Binder:
_panic("vx_dopyIRExpr(): case Iex_Binder (this should not be seen outside VEX)");
default:
_panic("vx_dopyIRExpr(): unknown expression");
}
return NULL;
}
