#include <xmmintrin.h>
#include <stdint.h>

typedef __m128i vector; // vector of 4 int   (mmx)

inline void
bitxor_vdiff(vector *a, vector *b, vector *c)
{
  *c = *a ^ *b; 
}

union vec128 {
  vector   v;
  struct {
    uint64_t a;
    uint64_t b;
  } data;
};

int
bitxor_buf(unsigned char *ibuf, unsigned char *obuf,
	  int size, int bsize)
{
  int numblocks = size/bsize;
  int numvec = bsize/sizeof(vector);
  union vec128 *ba, *bb, *bc;
  union vec128 va __attribute__ ((aligned(16)));
  union vec128 vb __attribute__ ((aligned(16)));
  union vec128 vc __attribute__ ((aligned(16)));
  int i,j;

  for (i=0; i<(numblocks-1); i++) {
    ba=(union vec128 *)&ibuf[i*bsize];
    bb=(union vec128 *)&ibuf[(i+1)*bsize];
    bc=(union vec128 *)&obuf[i*bsize];
    for (j=0; j<numvec; j++) {
      va.data.a = ba[j].data.a;
      va.data.b = ba[j].data.b;
      vb.data.a = bb[j].data.a;
      vb.data.b = bb[j].data.b;
      bitxor_vdiff(&(va.v), &(vb.v), &(vc.v));
      bc[j].data.a = vc.data.a;
      bc[j].data.b = vc.data.b;
    }
    // take care of excess bytes that are not taken care of by vector
    // ops -- could get fancy but lets just do byte ops for the moment
    // could have done 64s, 32s, 16s, and then 8s
    unsigned char *ca, *cb, *cc;
    ca=&ibuf[i*bsize];
    cb=&ibuf[(i+1)*bsize];
    cc=&obuf[i*bsize];
    for (j=numvec * sizeof(vector); j<bsize; j++) {
      cc[j] = ca[j] ^ cb[j]; 
    }
  }
  return (numblocks-1) * bsize;
}

#ifdef __BITXOR_STAND_ALONE__
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <unistd.h>

#define BUF_NUMBLOCKS 1024

/* USAGE: bitxor <blocksize> */

int 
main(int argc, char **argv)
{
  int            n, p, rc, blocksize, bufsize, bufsize_read;
  unsigned char *ibuf, *obuf, *ibuf_read;
  int            i;
  
  blocksize = atoi(argv[1]);
  bufsize   = blocksize * BUF_NUMBLOCKS;
  
  if (posix_memalign((void *)&ibuf, 4096, bufsize) != 0) {
    perror("ERROR: posix_malloc");
    return -1;
  }

  if (posix_memalign((void *)&obuf, 4096, bufsize) != 0) {
    perror("ERROR: posix_malloc");
    return -1;
  }
  
  ibuf_read = ibuf;
  bufsize_read = bufsize;
  if (freopen(NULL, "rb", stdin) == 0) {
    perror("ERROR: freopen");
    return -1;
  }
  while ((n = fread(ibuf_read, 1, bufsize_read, stdin)) > 0) {
    if (n % blocksize) {
      fprintf(stderr, "ERROR: n=%d fread not a multiple of blocksize=%d\n", 
	      n, blocksize);
    }
    if (ibuf != ibuf_read) n += blocksize;

    rc = bitxor_buf(ibuf, obuf, n, blocksize);
    if (rc != n-blocksize) {
      fprintf(stderr, "n=%d but only did %d bytes (blocksize=%d)\n",
	      n, rc, blocksize);
    }

    p = fwrite(obuf, 1, rc, stdout);
    if (p != rc) {
      perror("write");
      return -1;
    }
    /* copy over the last sv for bitxor with the next block */
    for (i=0; i<blocksize; i++){
      ibuf[i] = ibuf[n-blocksize+i];
    }
    ibuf_read = ibuf + blocksize;
    bufsize_read = bufsize - blocksize;
  }

  fclose(stdin);

  return 0;
}
#endif