Added NaCl crypto library.

47 files changed, 1724 insertions, 0 deletions

diff --git a/nacl/cpucycles/alpha.c b/nacl/cpucycles/alpha.c
new file mode 100644
index 00000000..ef497999
--- /dev/null
+++ b/nacl/cpucycles/alpha.c
@@ -0,0 +1,80 @@
+/*
+cpucycles/alpha.c version 20060316
+D. J. Bernstein
+Public domain.
+*/
+
+#include <time.h>
+#include <unistd.h>
+#include <sys/time.h>
+
+static long long tod(void)
+{
+  struct timeval t;
+  gettimeofday(&t,(struct timezone *) 0);
+  return t.tv_sec * (long long) 1000000 + t.tv_usec;
+}
+
+static long long rpcc(void)
+{
+  unsigned long long t;
+  asm volatile("rpcc %0" : "=r"(t));
+  return t & 0xffffffff;
+}
+
+static long long firstrpcc;
+static long long firsttod;
+static long long lastrpcc;
+static long long lasttod;
+static double mhz = 0;
+
+static void init(void)
+{
+  firstrpcc = rpcc();
+  firsttod = tod();
+
+  do {
+    lastrpcc = rpcc();
+    lasttod = tod();
+  } while (lasttod - firsttod < 10000);
+
+  lastrpcc -= firstrpcc; lastrpcc &= 0xffffffff;
+  lasttod -= firsttod;
+
+  mhz = (double) lastrpcc / (double) lasttod;
+}
+
+long long cpucycles_alpha(void)
+{
+  double x;
+  long long y;
+
+  if (!mhz) init();
+
+  lastrpcc = rpcc();
+  lasttod = tod();
+
+  lastrpcc -= firstrpcc; lastrpcc &= 0xffffffff;
+  lasttod -= firsttod;
+
+  /* Number of cycles since firstrpcc is lastrpcc + 2^32 y for unknown y. */
+  /* Number of microseconds since firsttod is lasttod. */
+
+  x = (lasttod * mhz - lastrpcc) * 0.00000000023283064365386962890625;
+  y = x;
+  while (x > y + 0.5) y += 1;
+  while (x < y - 0.5) y -= 1;
+
+  y *= 4294967296ULL;
+  lastrpcc += y;
+
+  mhz = (double) lastrpcc / (double) lasttod;
+
+  return firstrpcc + lastrpcc;
+}
+
+long long cpucycles_alpha_persecond(void)
+{
+  if (!mhz) init();
+  return 1000000.0 * mhz;
+}
diff --git a/nacl/cpucycles/alpha.h b/nacl/cpucycles/alpha.h
new file mode 100644
index 00000000..c97672af
--- /dev/null
+++ b/nacl/cpucycles/alpha.h
@@ -0,0 +1,27 @@
+/*
+cpucycles alpha.h version 20060318
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_alpha_h
+#define CPUCYCLES_alpha_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_alpha(void);
+extern long long cpucycles_alpha_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "alpha"
+#define cpucycles cpucycles_alpha
+#define cpucycles_persecond cpucycles_alpha_persecond
+#endif
+
+#endif
diff --git a/nacl/cpucycles/amd64cpuinfo.c b/nacl/cpucycles/amd64cpuinfo.c
new file mode 100644
index 00000000..729f2612
--- /dev/null
+++ b/nacl/cpucycles/amd64cpuinfo.c
@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include "osfreq.c"
+
+long long cpucycles_amd64cpuinfo(void)
+{
+  unsigned long long result;
+  asm volatile(".byte 15;.byte 49;shlq $32,%%rdx;orq %%rdx,%%rax"
+    : "=a" (result) ::  "%rdx");
+  return result;
+}
+
+long long cpucycles_amd64cpuinfo_persecond(void)
+{
+  return osfreq();
+}
diff --git a/nacl/cpucycles/amd64cpuinfo.h b/nacl/cpucycles/amd64cpuinfo.h
new file mode 100644
index 00000000..8f858ae7
--- /dev/null
+++ b/nacl/cpucycles/amd64cpuinfo.h
@@ -0,0 +1,27 @@
+/*
+cpucycles amd64cpuinfo.h version 20100803
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_amd64cpuinfo_h
+#define CPUCYCLES_amd64cpuinfo_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_amd64cpuinfo(void);
+extern long long cpucycles_amd64cpuinfo_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "amd64cpuinfo"
+#define cpucycles cpucycles_amd64cpuinfo
+#define cpucycles_persecond cpucycles_amd64cpuinfo_persecond
+#endif
+
+#endif
diff --git a/nacl/cpucycles/amd64cpuspeed.c b/nacl/cpucycles/amd64cpuspeed.c
new file mode 100644
index 00000000..7e89511c
--- /dev/null
+++ b/nacl/cpucycles/amd64cpuspeed.c
@@ -0,0 +1,25 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/sysctl.h>
+
+long long cpucycles_amd64cpuspeed(void)
+{
+  unsigned long long result;
+  asm volatile(".byte 15;.byte 49;shlq $32,%%rdx;orq %%rdx,%%rax"
+    : "=a" (result) ::  "%rdx");
+  return result;
+}
+
+long long cpucycles_amd64cpuspeed_persecond(void)
+{
+  int oid[2];
+  int val;
+  size_t size;
+  oid[0] = CTL_HW;
+  oid[1] = HW_CPUSPEED;
+  size = sizeof val;
+  if (sysctl(oid,2,&val,&size,0,0) == -1) return 0;
+  if (size != sizeof val) return 0;
+  return val * 1000000LL;
+}
diff --git a/nacl/cpucycles/amd64cpuspeed.h b/nacl/cpucycles/amd64cpuspeed.h
new file mode 100644
index 00000000..1f6ed54d
--- /dev/null
+++ b/nacl/cpucycles/amd64cpuspeed.h
@@ -0,0 +1,27 @@
+/*
+cpucycles amd64cpuspeed.h version 20090716
+Matthew Dempsky
+Public domain.
+*/
+
+#ifndef CPUCYCLES_amd64cpuspeed_h
+#define CPUCYCLES_amd64cpuspeed_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_amd64cpuspeed(void);
+extern long long cpucycles_amd64cpuspeed_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "amd64cpuspeed"
+#define cpucycles cpucycles_amd64cpuspeed
+#define cpucycles_persecond cpucycles_amd64cpuspeed_persecond
+#endif
+
+#endif
diff --git a/nacl/cpucycles/amd64tscfreq.c b/nacl/cpucycles/amd64tscfreq.c
new file mode 100644
index 00000000..ef182c1b
--- /dev/null
+++ b/nacl/cpucycles/amd64tscfreq.c
@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include <sys/types.h>
+
+long long cpucycles_amd64tscfreq(void)
+{
+  unsigned long long result;
+  asm volatile(".byte 15;.byte 49;shlq $32,%%rdx;orq %%rdx,%%rax"
+    : "=a" (result) ::  "%rdx");
+  return result;
+}
+
+long long cpucycles_amd64tscfreq_persecond(void)
+{
+  long result = 0;
+  size_t resultlen = sizeof(long);
+  sysctlbyname("machdep.tsc_freq",&result,&resultlen,0,0);
+  return result;
+}
diff --git a/nacl/cpucycles/amd64tscfreq.h b/nacl/cpucycles/amd64tscfreq.h
new file mode 100644
index 00000000..a3c7aa6f
--- /dev/null
+++ b/nacl/cpucycles/amd64tscfreq.h
@@ -0,0 +1,27 @@
+/*
+cpucycles amd64tscfreq.h version 20060318
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_amd64tscfreq_h
+#define CPUCYCLES_amd64tscfreq_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_amd64tscfreq(void);
+extern long long cpucycles_amd64tscfreq_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "amd64tscfreq"
+#define cpucycles cpucycles_amd64tscfreq
+#define cpucycles_persecond cpucycles_amd64tscfreq_persecond
+#endif
+
+#endif
diff --git a/nacl/cpucycles/celllinux.c b/nacl/cpucycles/celllinux.c
new file mode 100644
index 00000000..83a0c38a
--- /dev/null
+++ b/nacl/cpucycles/celllinux.c
@@ -0,0 +1,83 @@
+#include <time.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <spu_mfcio.h>
+
+static long myround(double u)
+{
+  long result = u;
+  while (result + 0.5 < u) result += 1;
+  while (result - 0.5 > u) result -= 1;
+  return result;
+}
+
+static long long microseconds(void)
+{
+  struct timeval t;
+  gettimeofday(&t,(struct timezone *) 0);
+  return t.tv_sec * (long long) 1000000 + t.tv_usec;
+}
+
+static long long timebase(void)
+{
+  unsigned long long result;
+  result = -spu_read_decrementer();
+  return 0xffffffff & result;
+}
+
+static double cpufrequency = 0;
+static long tbcycles = 0;
+
+static double guesstbcycles(void)
+{
+  long long tb0; long long us0;
+  long long tb1; long long us1;
+
+  tb0 = timebase();
+  us0 = microseconds();
+  do {
+    tb1 = timebase();
+    us1 = microseconds();
+  } while (us1 - us0 < 10000 || tb1 - tb0 < 1000);
+  if (tb1 <= tb0) return 0;
+  tb1 -= tb0;
+  us1 -= us0;
+  return (cpufrequency * 0.000001 * (double) us1) / (double) tb1;
+}
+
+static void init(void)
+{
+  int loop;
+  double guess1;
+  double guess2;
+
+  spu_write_decrementer(0xffffffff);
+
+  cpufrequency = 3192000000.0;
+
+  for (loop = 0;loop < 100;++loop) {
+    guess1 = guesstbcycles();
+    guess2 = guesstbcycles();
+    tbcycles = myround(guess1);
+    if (guess1 - tbcycles > 0.1) continue;
+    if (tbcycles - guess1 > 0.1) continue;
+    if (guess2 - tbcycles > 0.1) continue;
+    if (tbcycles - guess2 > 0.1) continue;
+    return;
+  }
+  tbcycles = 0;
+}
+
+long long cpucycles_celllinux(void)
+{
+  if (!tbcycles) init();
+  return timebase() * tbcycles;
+}
+
+long long cpucycles_celllinux_persecond(void)
+{
+  if (!tbcycles) init();
+  return cpufrequency;
+}
diff --git a/nacl/cpucycles/celllinux.h b/nacl/cpucycles/celllinux.h
new file mode 100644
index 00000000..75a5a3f2
--- /dev/null
+++ b/nacl/cpucycles/celllinux.h
@@ -0,0 +1,27 @@
+/*
+cpucycles celllinux.h version 20081201
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_celllinux_h
+#define CPUCYCLES_celllinux_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_celllinux(void);
+extern long long cpucycles_celllinux_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "celllinux"
+#define cpucycles cpucycles_celllinux
+#define cpucycles_persecond cpucycles_celllinux_persecond
+#endif
+
+#endif
diff --git a/nacl/cpucycles/cortex.c b/nacl/cpucycles/cortex.c
new file mode 100644
index 00000000..07e2fa02
--- /dev/null
+++ b/nacl/cpucycles/cortex.c
@@ -0,0 +1,73 @@
+/*
+cpucycles/cortex.c version 20101203
+D. J. Bernstein
+Public domain.
+*/
+
+#define SCALE 1
+#include <time.h>
+#include <unistd.h>
+#include <sys/time.h>
+
+static int enabled = 0;
+
+static int prev[3];
+static unsigned long long prevcycles = 0;
+static int now[3];
+static long long cyclespersec = 0;
+
+static void readticks(unsigned int *result)
+{
+  struct timeval t;
+  unsigned int cc;
+  if (!enabled) {
+    asm volatile("mcr p15, 0, %0, c9, c12, 0" :: "r"(17));
+    asm volatile("mcr p15, 0, %0, c9, c12, 1" :: "r"(0x8000000f));
+    asm volatile("mcr p15, 0, %0, c9, c12, 3" :: "r"(0x8000000f));
+    enabled = 1;
+  }
+  asm volatile("mrc p15, 0, %0, c9, c13, 0" : "=r"(cc));
+  gettimeofday(&t,(struct timezone *) 0);
+  result[0] = cc;
+  result[1] = t.tv_usec;
+  result[2] = t.tv_sec;
+}
+
+long long cpucycles_cortex(void)
+{
+  unsigned long long delta4;
+  int deltan;
+  int deltas;
+  unsigned long long guesscycles;
+  
+  readticks(now);
+  delta4 = (unsigned int) (now[0] - prev[0]); /* unsigned change in number of cycles mod 2^32 */
+  deltan = now[1] - prev[1]; /* signed change in number of nanoseconds mod 10^9 */
+  deltas = now[2] - prev[2]; /* signed change in number of seconds */
+  if ((deltas == 0 && deltan < 200000) || (deltas == 1 && deltan < -800000))
+    return (prevcycles + delta4) * SCALE;
+
+  prev[0] = now[0];
+  prev[1] = now[1];
+  prev[2] = now[2];
+
+  if ((deltas == 0 && deltan < 300000) || (deltas == 1 && deltan < -700000)) {
+    // actual number of cycles cannot have increased by 2^32 in <0.3ms
+    cyclespersec = 1000000 * (unsigned long long) delta4;
+    cyclespersec /= deltan + 1000000 * (long long) deltas;
+  } else {
+    guesscycles = deltas * cyclespersec;
+    guesscycles += (deltan * cyclespersec) / 1000000;
+    while (delta4 + 2147483648ULL < guesscycles) delta4 += 4294967296ULL;
+    /* XXX: could do longer-term extrapolation here */
+  }
+
+  prevcycles += delta4;
+  return prevcycles * SCALE;
+}
+
+long long cpucycles_cortex_persecond(void)
+{
+  while (!cyclespersec) cpucycles_cortex();
+  return cyclespersec * SCALE;
+}
diff --git a/nacl/cpucycles/cortex.h b/nacl/cpucycles/cortex.h
new file mode 100644
index 00000000..e622f132
--- /dev/null
+++ b/nacl/cpucycles/cortex.h
@@ -0,0 +1,27 @@
+/*
+cpucycles cortex.h version 20100912
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_cortex_h
+#define CPUCYCLES_cortex_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_cortex(void);
+extern long long cpucycles_cortex_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "cortex"
+#define cpucycles cpucycles_cortex
+#define cpucycles_persecond cpucycles_cortex_persecond
+#endif
+
+#endif
diff --git a/nacl/cpucycles/dev4ns.c b/nacl/cpucycles/dev4ns.c
new file mode 100644
index 00000000..73ff5755
--- /dev/null
+++ b/nacl/cpucycles/dev4ns.c
@@ -0,0 +1,62 @@
+#include <sys/types.h>
+#include <fcntl.h>
+#include <time.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/time.h>
+
+static int fddev = -1;
+static int prev[3];
+static unsigned long long prevcycles = 0;
+static int now[3];
+static long long cyclespersec = 0;
+
+static void readdev(unsigned int *result)
+{
+  if (read(fddev,result,12) == 12) return;
+  result[0] = result[1] = result[2] = 0;
+}
+
+long long cpucycles_dev4ns(void)
+{
+  unsigned long long delta4;
+  int deltan;
+  int deltas;
+  unsigned long long guesscycles;
+
+  if (fddev == -1) {
+    fddev = open("/dev/cpucycles4ns",O_RDONLY);
+    readdev(prev);
+  }
+  
+  readdev(now);
+  delta4 = (unsigned int) (now[0] - prev[0]); /* unsigned change in number of cycles mod 2^32 */
+  deltan = now[1] - prev[1]; /* signed change in number of nanoseconds mod 10^9 */
+  deltas = now[2] - prev[2]; /* signed change in number of seconds */
+  if ((deltas == 0 && deltan < 200000000) || (deltas == 1 && deltan < -800000000))
+    return prevcycles + delta4;
+
+  prev[0] = now[0];
+  prev[1] = now[1];
+  prev[2] = now[2];
+
+  if ((deltas == 0 && deltan < 300000000) || (deltas == 1 && deltan < -700000000)) {
+    // actual number of cycles cannot have increased by 2^32 in <0.3ms
+    cyclespersec = 1000000000 * (unsigned long long) delta4;
+    cyclespersec /= deltan + 1000000000 * (long long) deltas;
+  } else {
+    guesscycles = deltas * cyclespersec;
+    guesscycles += (deltan * cyclespersec) / 1000000000;
+    while (delta4 + 2147483648ULL < guesscycles) delta4 += 4294967296ULL;
+    /* XXX: could do longer-term extrapolation here */
+  }
+
+  prevcycles += delta4;
+  return prevcycles;
+}
+
+long long cpucycles_dev4ns_persecond(void)
+{
+  while (!cyclespersec) cpucycles_dev4ns();
+  return cyclespersec;
+}
diff --git a/nacl/cpucycles/dev4ns.h b/nacl/cpucycles/dev4ns.h
new file mode 100644
index 00000000..1d99639a
--- /dev/null
+++ b/nacl/cpucycles/dev4ns.h
@@ -0,0 +1,27 @@
+/*
+cpucycles dev4ns.h version 20100803
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_dev4ns_h
+#define CPUCYCLES_dev4ns_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_dev4ns(void);
+extern long long cpucycles_dev4ns_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "dev4ns"
+#define cpucycles cpucycles_dev4ns
+#define cpucycles_persecond cpucycles_dev4ns_persecond
+#endif
+
+#endif
diff --git a/nacl/cpucycles/do b/nacl/cpucycles/do
new file mode 100755
index 00000000..efc063de
--- /dev/null
+++ b/nacl/cpucycles/do
@@ -0,0 +1,105 @@
+#!/bin/sh -e
+
+okabi | (
+  while read abi
+  do
+
+    rm -f cpucycles.o cpucycles.h
+    
+    (
+      case "$abi" in
+        ppc*)
+          echo powerpccpuinfo
+          echo powerpcmacos
+          ;;
+        amd64*)
+          echo amd64tscfreq
+          echo amd64cpuinfo
+          echo amd64cpuspeed
+          ;;
+        x86*)
+          echo x86tscfreq
+          echo x86cpuinfo
+          echo x86cpuspeed
+          echo x86estimate
+          ;;
+        cell*)
+          echo celllinux
+          ;;
+        sparc*)
+          echo sparccpuinfo
+          echo sparc32cpuinfo
+          ;;
+        mips*)
+          echo mips
+          ;;
+        hppa*)
+          echo hppapstat
+          ;;
+        alpha*)
+          echo alpha
+          ;;
+        sgi*)
+          echo sgi
+          ;;
+        arm*)
+          echo cortex
+          echo dev4ns
+          ;;
+      esac
+
+      echo amd64tscfreq
+      echo amd64cpuinfo
+      echo amd64cpuspeed
+      echo x86tscfreq
+      echo x86cpuinfo
+      echo x86cpuspeed
+      echo x86estimate
+      echo ia64cpuinfo
+      echo powerpccpuinfo
+      echo powerpcmacos
+      echo celllinux
+      echo sparccpuinfo
+      echo sparc32cpuinfo
+      echo mips
+      echo hppapstat
+      echo alpha
+      echo sgi
+      echo cortex
+      echo dev4ns
+      echo monotoniccpuinfo
+      echo monotonic
+      echo gettimeofday
+    ) | (
+      while read n
+      do
+        okc-$abi | (
+          while read c
+          do
+            echo "=== `date` === Trying $n.c with $c..." >&2
+            rm -f test cpucycles-impl.o cpucycles-impl.h cpucycles-impl.c
+            cp $n.c cpucycles-impl.c || continue
+            cp $n.h cpucycles-impl.h || continue
+            $c -c cpucycles-impl.c || continue
+            $c -o test test.c cpucycles-impl.o || continue
+            ./test || continue
+            echo "=== `date` === Success. Using $n.c." >&2
+            mkdir -p lib/$abi
+            mv cpucycles-impl.o lib/$abi/cpucycles.o
+            mkdir -p include/$abi
+            mv cpucycles-impl.h include/$abi/cpucycles.h
+            exit 0
+          done
+          exit 111
+        ) && exit 0
+      done
+      exit 111
+    ) || (
+      echo ===== Giving up. >&2
+      rm -f test cpucycles-impl.o cpucycles-impl.h cpucycles-impl.c
+      exit 111
+    ) || exit 0
+
+  done
+  exit 0
+) || exit 111
diff --git a/nacl/cpucycles/gettimeofday.c b/nacl/cpucycles/gettimeofday.c
new file mode 100644
index 00000000..0bf5e03c
--- /dev/null
+++ b/nacl/cpucycles/gettimeofday.c
@@ -0,0 +1,32 @@
+#include <time.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include "osfreq.c"
+
+static double cpufrequency = 0;
+
+static void init(void)
+{
+  cpufrequency = osfreq();
+}
+
+long long cpucycles_gettimeofday(void)
+{
+  double result;
+  struct timeval t;
+  if (!cpufrequency) init();
+  gettimeofday(&t,(struct timezone *) 0);
+  result = t.tv_usec;
+  result *= 0.000001;
+  result += (double) t.tv_sec;
+  result *= cpufrequency;
+  return result;
+}
+
+long long cpucycles_gettimeofday_persecond(void)
+{
+  if (!cpufrequency) init();
+  return cpufrequency;
+}
diff --git a/nacl/cpucycles/gettimeofday.h b/nacl/cpucycles/gettimeofday.h
new file mode 100644
index 00000000..147b127b
--- /dev/null
+++ b/nacl/cpucycles/gettimeofday.h
@@ -0,0 +1,27 @@
+/*
+cpucycles gettimeofday.h version 20060318
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_gettimeofday_h
+#define CPUCYCLES_gettimeofday_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_gettimeofday(void);
+extern long long cpucycles_gettimeofday_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "gettimeofday"
+#define cpucycles cpucycles_gettimeofday
+#define cpucycles_persecond cpucycles_gettimeofday_persecond
+#endif
+
+#endif
diff --git a/nacl/cpucycles/hppapstat.c b/nacl/cpucycles/hppapstat.c
new file mode 100644
index 00000000..5ae1e843
--- /dev/null
+++ b/nacl/cpucycles/hppapstat.c
@@ -0,0 +1,26 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/pstat.h>
+#include <machine/inline.h>
+
+long long cpucycles_hppapstat(void)
+{
+  register long long result;
+  _MFCTL(16,result);
+  return result;
+}
+
+long long cpucycles_hppapstat_persecond(void)
+{
+  struct pst_processor pst;
+  union pstun pu;
+  double result;
+
+  pu.pst_processor = &pst;
+  if (pstat(PSTAT_PROCESSOR,pu,sizeof(pst),1,0) < 0) return 0;
+  result = pst.psp_iticksperclktick;
+  result *= (double) sysconf(_SC_CLK_TCK);
+  return result;
+}
diff --git a/nacl/cpucycles/hppapstat.h b/nacl/cpucycles/hppapstat.h
new file mode 100644
index 00000000..721814bb
--- /dev/null
+++ b/nacl/cpucycles/hppapstat.h
@@ -0,0 +1,27 @@
+/*
+cpucycles hppapstat.h version 20060319
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_hppapstat_h
+#define CPUCYCLES_hppapstat_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_hppapstat(void);
+extern long long cpucycles_hppapstat_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "hppapstat"
+#define cpucycles cpucycles_hppapstat
+#define cpucycles_persecond cpucycles_hppapstat_persecond
+#endif
+
+#endif
diff --git a/nacl/cpucycles/ia64cpuinfo.c b/nacl/cpucycles/ia64cpuinfo.c
new file mode 100644
index 00000000..580c6cee
--- /dev/null
+++ b/nacl/cpucycles/ia64cpuinfo.c
@@ -0,0 +1,15 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include "osfreq.c"
+
+long long cpucycles_ia64cpuinfo(void)
+{
+  long long result;
+  asm volatile("mov %0=ar.itc" : "=r"(result));
+  return result;
+}
+
+long long cpucycles_ia64cpuinfo_persecond(void)
+{
+  return osfreq();
+}
diff --git a/nacl/cpucycles/ia64cpuinfo.h b/nacl/cpucycles/ia64cpuinfo.h
new file mode 100644
index 00000000..a6bcf47d
--- /dev/null
+++ b/nacl/cpucycles/ia64cpuinfo.h
@@ -0,0 +1,27 @@
+/*
+cpucycles ia64cpuinfo.h version 20100803
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_ia64cpuinfo_h
+#define CPUCYCLES_ia64cpuinfo_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_ia64cpuinfo(void);
+extern long long cpucycles_ia64cpuinfo_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "ia64cpuinfo"
+#define cpucycles cpucycles_ia64cpuinfo
+#define cpucycles_persecond cpucycles_ia64cpuinfo_persecond
+#endif
+
+#endif
diff --git a/nacl/cpucycles/mips.c b/nacl/cpucycles/mips.c
new file mode 100644
index 00000000..8b75f824
--- /dev/null
+++ b/nacl/cpucycles/mips.c
@@ -0,0 +1,65 @@
+/*
+cpucycles/mips.c version 20100803
+D. J. Bernstein
+Public domain.
+*/
+
+#define SCALE 2
+#include <time.h>
+#include <unistd.h>
+#include <sys/time.h>
+
+static int prev[3];
+static unsigned long long prevcycles = 0;
+static int now[3];
+static long long cyclespersec = 0;
+
+static void readticks(unsigned int *result)
+{
+  struct timeval t;
+  unsigned int cc;
+  asm volatile(".byte 59; .byte 16; .byte 2; .byte 124; move %0,$2" : "=r"(cc) : : "$2");
+  gettimeofday(&t,(struct timezone *) 0);
+  result[0] = cc;
+  result[1] = t.tv_usec;
+  result[2] = t.tv_sec;
+}
+
+long long cpucycles_mips(void)
+{
+  unsigned long long delta4;
+  int deltan;
+  int deltas;
+  unsigned long long guesscycles;
+  
+  readticks(now);
+  delta4 = (unsigned int) (now[0] - prev[0]); /* unsigned change in number of cycles mod 2^32 */
+  deltan = now[1] - prev[1]; /* signed change in number of nanoseconds mod 10^9 */
+  deltas = now[2] - prev[2]; /* signed change in number of seconds */
+  if ((deltas == 0 && deltan < 200000) || (deltas == 1 && deltan < -800000))
+    return (prevcycles + delta4) * SCALE;
+
+  prev[0] = now[0];
+  prev[1] = now[1];
+  prev[2] = now[2];
+
+  if ((deltas == 0 && deltan < 300000) || (deltas == 1 && deltan < -700000)) {
+    // actual number of cycles cannot have increased by 2^32 in <0.3ms
+    cyclespersec = 1000000 * (unsigned long long) delta4;
+    cyclespersec /= deltan + 1000000 * (long long) deltas;
+  } else {
+    guesscycles = deltas * cyclespersec;
+    guesscycles += (deltan * cyclespersec) / 1000000;
+    while (delta4 + 2147483648ULL < guesscycles) delta4 += 4294967296ULL;
+    /* XXX: could do longer-term extrapolation here */
+  }
+
+  prevcycles += delta4;
+  return prevcycles * SCALE;
+}
+
+long long cpucycles_mips_persecond(void)
+{
+  while (!cyclespersec) cpucycles_mips();
+  return cyclespersec * SCALE;
+}
diff --git a/nacl/cpucycles/mips.h b/nacl/cpucycles/mips.h
new file mode 100644
index 00000000..6f1b26c3
--- /dev/null
+++ b/nacl/cpucycles/mips.h
@@ -0,0 +1,27 @@
+/*
+cpucycles mips.h version 20100802
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_mips_h
+#define CPUCYCLES_mips_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_mips(void);
+extern long long cpucycles_mips_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "mips"
+#define cpucycles cpucycles_mips
+#define cpucycles_persecond cpucycles_mips_persecond
+#endif
+
+#endif
diff --git a/nacl/cpucycles/monotonic.c b/nacl/cpucycles/monotonic.c
new file mode 100644
index 00000000..412a44fb
--- /dev/null
+++ b/nacl/cpucycles/monotonic.c
@@ -0,0 +1,34 @@
+#include <time.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/sysctl.h>
+
+static double cpufrequency = 0;
+
+static void init(void)
+{
+  long result = 0; size_t resultlen = sizeof(long);
+  sysctlbyname("machdep.tsc_freq",&result,&resultlen,0,0);
+  cpufrequency = result;
+}
+
+long long cpucycles_monotonic(void)
+{
+  double result;
+  struct timespec t;
+  if (!cpufrequency) init();
+  clock_gettime(CLOCK_MONOTONIC,&t);
+  result = t.tv_nsec;
+  result *= 0.000000001;
+  result += (double) t.tv_sec;
+  result *= cpufrequency;
+  return result;
+}
+
+long long cpucycles_monotonic_persecond(void)
+{
+  if (!cpufrequency) init();
+  return cpufrequency;
+}
diff --git a/nacl/cpucycles/monotonic.h b/nacl/cpucycles/monotonic.h
new file mode 100644
index 00000000..9070860b
--- /dev/null
+++ b/nacl/cpucycles/monotonic.h
@@ -0,0 +1,27 @@
+/*
+cpucycles monotonic.h version 20100803
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_monotonic_h
+#define CPUCYCLES_monotonic_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_monotonic(void);
+extern long long cpucycles_monotonic_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "monotonic"
+#define cpucycles cpucycles_monotonic
+#define cpucycles_persecond cpucycles_monotonic_persecond
+#endif
+
+#endif
diff --git a/nacl/cpucycles/monotoniccpuinfo.c b/nacl/cpucycles/monotoniccpuinfo.c
new file mode 100644
index 00000000..609c6305
--- /dev/null
+++ b/nacl/cpucycles/monotoniccpuinfo.c
@@ -0,0 +1,33 @@
+#include <time.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#include "osfreq.c"
+
+static double cpufrequency = 0;
+
+static void init(void)
+{
+  cpufrequency = osfreq();
+}
+
+long long cpucycles_monotoniccpuinfo(void)
+{
+  double result;
+  struct timespec t;
+  if (!cpufrequency) init();
+  clock_gettime(CLOCK_MONOTONIC,&t);
+  result = t.tv_nsec;
+  result *= 0.000000001;
+  result += (double) t.tv_sec;
+  result *= cpufrequency;
+  return result;
+}
+
+long long cpucycles_monotoniccpuinfo_persecond(void)
+{
+  if (!cpufrequency) init();
+  return cpufrequency;
+}
diff --git a/nacl/cpucycles/monotoniccpuinfo.h b/nacl/cpucycles/monotoniccpuinfo.h
new file mode 100644
index 00000000..d4ba7ea8
--- /dev/null
+++ b/nacl/cpucycles/monotoniccpuinfo.h
@@ -0,0 +1,27 @@
+/*
+cpucycles monotoniccpuinfo.h version 20100804
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_monotoniccpuinfo_h
+#define CPUCYCLES_monotoniccpuinfo_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_monotoniccpuinfo(void);
+extern long long cpucycles_monotoniccpuinfo_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "monotoniccpuinfo"
+#define cpucycles cpucycles_monotoniccpuinfo
+#define cpucycles_persecond cpucycles_monotoniccpuinfo_persecond
+#endif
+
+#endif
diff --git a/nacl/cpucycles/osfreq.c b/nacl/cpucycles/osfreq.c
new file mode 100644
index 00000000..4e106a23
--- /dev/null
+++ b/nacl/cpucycles/osfreq.c
@@ -0,0 +1,65 @@
+static double osfreq(void)
+{
+  FILE *f;
+  double result;
+  int s;
+
+  f = fopen("/sys/devices/system/cpu/cpu0/cpufreq/scaling_max_freq", "r");
+  if (f) {
+    s = fscanf(f,"%lf",&result);
+    fclose(f);
+    if (s > 0) return 1000.0 * result;
+  }
+
+  f = fopen("/sys/devices/system/cpu/cpu0/clock_tick", "r");
+  if (f) {
+    s = fscanf(f,"%lf",&result);
+    fclose(f);
+    if (s > 0) return result;
+  }
+
+  f = fopen("/proc/cpuinfo","r");
+  if (f) {
+    for (;;) {
+      s = fscanf(f,"cpu MHz : %lf",&result);
+      if (s > 0) break;
+      if (s == 0) s = fscanf(f,"%*[^\n]\n");
+      if (s < 0) { result = 0; break; }
+    }
+    fclose(f);
+    if (result) return 1000000.0 * result;
+  }
+
+  f = fopen("/proc/cpuinfo","r");
+  if (f) {
+    for (;;) {
+      s = fscanf(f,"clock : %lf",&result);
+      if (s > 0) break;
+      if (s == 0) s = fscanf(f,"%*[^\n]\n");
+      if (s < 0) { result = 0; break; }
+    }
+    fclose(f);
+    if (result) return 1000000.0 * result;
+  }
+
+  f = popen("/usr/sbin/lsattr -E -l proc0 -a frequency 2>/dev/null","r");
+  if (f) {
+    s = fscanf(f,"frequency %lf",&result);
+    pclose(f);
+    if (s > 0) return result;
+  }
+
+  f = popen("/usr/sbin/psrinfo -v 2>/dev/null","r");
+  if (f) {
+    for (;;) {
+      s = fscanf(f," The %*s processor operates at %lf MHz",&result);
+      if (s > 0) break;
+      if (s == 0) s = fscanf(f,"%*[^\n]\n");
+      if (s < 0) { result = 0; break; }
+    }
+    pclose(f);
+    if (result) return 1000000.0 * result;
+  }
+
+  return 0;
+}
diff --git a/nacl/cpucycles/powerpccpuinfo.c b/nacl/cpucycles/powerpccpuinfo.c
new file mode 100644
index 00000000..b70c745a
--- /dev/null
+++ b/nacl/cpucycles/powerpccpuinfo.c
@@ -0,0 +1,95 @@
+#include <time.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include "osfreq.c"
+
+static long myround(double u)
+{
+  long result = u;
+  while (result + 0.5 < u) result += 1;
+  while (result - 0.5 > u) result -= 1;
+  return result;
+}
+
+static long long microseconds(void)
+{
+  struct timeval t;
+  gettimeofday(&t,(struct timezone *) 0);
+  return t.tv_sec * (long long) 1000000 + t.tv_usec;
+}
+
+static int tbshift = 0;
+
+static long long timebase(void)
+{
+  unsigned long high;
+  unsigned long low;
+  unsigned long newhigh;
+  unsigned long long result;
+  asm volatile(
+    "7:mftbu %0;mftb %1;mftbu %2;cmpw %0,%2;bne 7b"
+    : "=r" (high), "=r" (low), "=r" (newhigh)
+  );
+  result = high;
+  result <<= 32;
+  result |= low;
+  return result >> tbshift;
+}
+
+static double cpufrequency = 0;
+static long tbcycles = 0;
+
+static double guesstbcycles(void)
+{
+  long long tb0; long long us0;
+  long long tb1; long long us1;
+
+  tb0 = timebase();
+  us0 = microseconds();
+  do {
+    tb1 = timebase();
+    us1 = microseconds();
+  } while (us1 - us0 < 10000 || tb1 - tb0 < 1000);
+  if (tb1 <= tb0) return 0;
+  tb1 -= tb0;
+  us1 -= us0;
+  return (cpufrequency * 0.000001 * (double) us1) / (double) tb1;
+}
+
+static void init(void)
+{
+  int loop;
+  double guess1;
+  double guess2;
+
+  cpufrequency = osfreq();
+  if (!cpufrequency) return;
+
+  for (tbshift = 0;tbshift < 10;++tbshift) {
+    for (loop = 0;loop < 100;++loop) {
+      guess1 = guesstbcycles();
+      guess2 = guesstbcycles();
+      tbcycles = myround(guess1);
+      if (guess1 - tbcycles > 0.1) continue;
+      if (tbcycles - guess1 > 0.1) continue;
+      if (guess2 - tbcycles > 0.1) continue;
+      if (tbcycles - guess2 > 0.1) continue;
+      return;
+    }
+  }
+  tbcycles = 0;
+}
+
+long long cpucycles_powerpccpuinfo(void)
+{
+  if (!tbcycles) init();
+  return timebase() * tbcycles;
+}
+
+long long cpucycles_powerpccpuinfo_persecond(void)
+{
+  if (!tbcycles) init();
+  return cpufrequency;
+}
diff --git a/nacl/cpucycles/powerpccpuinfo.h b/nacl/cpucycles/powerpccpuinfo.h
new file mode 100644
index 00000000..c763a1b4
--- /dev/null
+++ b/nacl/cpucycles/powerpccpuinfo.h
@@ -0,0 +1,27 @@
+/*
+cpucycles powerpccpuinfo.h version 20100803
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_powerpccpuinfo_h
+#define CPUCYCLES_powerpccpuinfo_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_powerpccpuinfo(void);
+extern long long cpucycles_powerpccpuinfo_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "powerpccpuinfo"
+#define cpucycles cpucycles_powerpccpuinfo
+#define cpucycles_persecond cpucycles_powerpccpuinfo_persecond
+#endif
+
+#endif
diff --git a/nacl/cpucycles/powerpcmacos.c b/nacl/cpucycles/powerpcmacos.c
new file mode 100644
index 00000000..ab0be1ea
--- /dev/null
+++ b/nacl/cpucycles/powerpcmacos.c
@@ -0,0 +1,42 @@
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#include <mach/mach_time.h>
+
+#define timebase mach_absolute_time
+
+static int cpumib[2] = { CTL_HW, HW_CPU_FREQ } ;
+static int tbmib[2] = { CTL_HW, HW_TB_FREQ } ;
+
+static long myround(double u)
+{
+  long result = u;
+  while (result + 0.5 < u) result += 1;
+  while (result - 0.5 > u) result -= 1;
+  return result;
+}
+
+static long tbcycles = 0;
+
+static void init(void)
+{
+  unsigned int cpufrequency = 0; size_t cpufrequencylen = sizeof(unsigned int);
+  unsigned int tbfrequency = 0; size_t tbfrequencylen = sizeof(unsigned int);
+  sysctl(cpumib,2,&cpufrequency,&cpufrequencylen,0,0);
+  sysctl(tbmib,2,&tbfrequency,&tbfrequencylen,0,0);
+  if (tbfrequency > 0)
+    tbcycles = myround((double) (unsigned long long) cpufrequency
+                     / (double) (unsigned long long) tbfrequency);
+}
+
+long long cpucycles_powerpcmacos(void)
+{
+  if (!tbcycles) init();
+  return timebase() * tbcycles;
+}
+
+long long cpucycles_powerpcmacos_persecond(void)
+{
+  unsigned int result = 0; size_t resultlen = sizeof(unsigned int);
+  sysctl(cpumib,2,&result,&resultlen,0,0);
+  return (unsigned long long) result;
+}
diff --git a/nacl/cpucycles/powerpcmacos.h b/nacl/cpucycles/powerpcmacos.h
new file mode 100644
index 00000000..f66c0e36
--- /dev/null
+++ b/nacl/cpucycles/powerpcmacos.h
@@ -0,0 +1,27 @@
+/*
+cpucycles powerpcmacos.h version 20060319
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_powerpcmacos_h
+#define CPUCYCLES_powerpcmacos_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_powerpcmacos(void);
+extern long long cpucycles_powerpcmacos_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "powerpcmacos"
+#define cpucycles cpucycles_powerpcmacos
+#define cpucycles_persecond cpucycles_powerpcmacos_persecond
+#endif
+
+#endif
diff --git a/nacl/cpucycles/sgi.c b/nacl/cpucycles/sgi.c
new file mode 100644
index 00000000..c232af09
--- /dev/null
+++ b/nacl/cpucycles/sgi.c
@@ -0,0 +1,38 @@
+#include <time.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/sysctl.h>
+
+static double cpufrequency = 0;
+
+static void init(void)
+{
+  FILE *f;
+
+  f = popen("hinv -c processor | awk '{if ($3==\"MHZ\") print $2*1000000}'","r");
+  if (!f) return;
+  if (fscanf(f,"%lf",&cpufrequency) < 1) cpufrequency = 0;
+  pclose(f);
+  if (!cpufrequency) return;
+}
+
+long long cpucycles_sgi(void)
+{
+  double result;
+  struct timespec t;
+  if (!cpufrequency) init();
+  clock_gettime(CLOCK_SGI_CYCLE,&t);
+  result = t.tv_nsec;
+  result *= 0.000000001;
+  result += (double) t.tv_sec;
+  result *= cpufrequency;
+  return result;
+}
+
+long long cpucycles_sgi_persecond(void)
+{
+  if (!cpufrequency) init();
+  return cpufrequency;
+}
diff --git a/nacl/cpucycles/sgi.h b/nacl/cpucycles/sgi.h
new file mode 100644
index 00000000..56bad976
--- /dev/null
+++ b/nacl/cpucycles/sgi.h
@@ -0,0 +1,27 @@
+/*
+cpucycles sgi.h version 20070916
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_sgi_h
+#define CPUCYCLES_sgi_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_sgi(void);
+extern long long cpucycles_sgi_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "sgi"
+#define cpucycles cpucycles_sgi
+#define cpucycles_persecond cpucycles_sgi_persecond
+#endif
+
+#endif
diff --git a/nacl/cpucycles/sparc32cpuinfo.c b/nacl/cpucycles/sparc32cpuinfo.c
new file mode 100644
index 00000000..1fc53d06
--- /dev/null
+++ b/nacl/cpucycles/sparc32cpuinfo.c
@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include "osfreq.c"
+
+long long cpucycles_sparc32cpuinfo(void)
+{
+  long long result;
+  asm volatile(".word 2202075136; .word 2570088480; srl %%g1,0,%L0; mov %%o4,%H0"
+    : "=r" (result) : : "g1","o4");
+  return result;
+}
+
+long long cpucycles_sparc32cpuinfo_persecond(void)
+{
+  return osfreq();
+}
diff --git a/nacl/cpucycles/sparc32cpuinfo.h b/nacl/cpucycles/sparc32cpuinfo.h
new file mode 100644
index 00000000..9d39dc65
--- /dev/null
+++ b/nacl/cpucycles/sparc32cpuinfo.h
@@ -0,0 +1,27 @@
+/*
+cpucycles sparc32cpuinfo.h version 20100804
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_sparc32cpuinfo_h
+#define CPUCYCLES_sparc32cpuinfo_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_sparc32cpuinfo(void);
+extern long long cpucycles_sparc32cpuinfo_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "sparc32cpuinfo"
+#define cpucycles cpucycles_sparc32cpuinfo
+#define cpucycles_persecond cpucycles_sparc32cpuinfo_persecond
+#endif
+
+#endif
diff --git a/nacl/cpucycles/sparccpuinfo.c b/nacl/cpucycles/sparccpuinfo.c
new file mode 100644
index 00000000..d07aafec
--- /dev/null
+++ b/nacl/cpucycles/sparccpuinfo.c
@@ -0,0 +1,15 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include "osfreq.c"
+
+long long cpucycles_sparccpuinfo(void)
+{
+  long long result;
+  asm volatile("rd %%tick,%0" : "=r" (result));
+  return result;
+}
+
+long long cpucycles_sparccpuinfo_persecond(void)
+{
+  return osfreq();
+}
diff --git a/nacl/cpucycles/sparccpuinfo.h b/nacl/cpucycles/sparccpuinfo.h
new file mode 100644
index 00000000..badb2144
--- /dev/null
+++ b/nacl/cpucycles/sparccpuinfo.h
@@ -0,0 +1,27 @@
+/*
+cpucycles sparccpuinfo.h version 20100803
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_sparccpuinfo_h
+#define CPUCYCLES_sparccpuinfo_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_sparccpuinfo(void);
+extern long long cpucycles_sparccpuinfo_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "sparccpuinfo"
+#define cpucycles cpucycles_sparccpuinfo
+#define cpucycles_persecond cpucycles_sparccpuinfo_persecond
+#endif
+
+#endif
diff --git a/nacl/cpucycles/test.c b/nacl/cpucycles/test.c
new file mode 100644
index 00000000..bc43d719
--- /dev/null
+++ b/nacl/cpucycles/test.c
@@ -0,0 +1,77 @@
+#include <time.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include "cpucycles-impl.h"
+
+static long long tod(void)
+{
+  struct timeval t;
+  gettimeofday(&t,(struct timezone *) 0);
+  return t.tv_sec * (long long) 1000000 + t.tv_usec;
+}
+
+long long todstart;
+long long todend;
+long long cpustart;
+long long cpuend;
+
+long long cyclespersecond;
+long long cyclespertod;
+
+long long t[1001];
+
+int main()
+{
+  int j;
+  int i;
+
+  if (!cpucycles()) {
+    fprintf(stderr,"cpucycles() = %lld\n",cpucycles());
+    return 100;
+  }
+  for (i = 0;i <= 1000;++i) t[i] = cpucycles();
+  for (i = 0;i < 1000;++i) if (t[i] > t[i + 1]) {
+    fprintf(stderr,"t[%d] = %lld\n",i,t[i]);
+    fprintf(stderr,"t[%d] = %lld\n",i + 1,t[i + 1]);
+    fprintf(stderr,"cpucycles_persecond() = %lld\n",cpucycles_persecond());
+    return 100;
+  }
+  if (t[0] == t[1000]) {
+    fprintf(stderr,"t[%d] = %lld\n",0,t[0]);
+    fprintf(stderr,"t[%d] = %lld\n",1000,t[1000]);
+    fprintf(stderr,"cpucycles_persecond() = %lld\n",cpucycles_persecond());
+    return 100;
+  } 
+
+  cyclespersecond = cpucycles_persecond();
+
+  if (cyclespersecond <= 0) {
+    fprintf(stderr,"cpucycles_persecond() = %lld\n",cyclespersecond);
+    return 100;
+  }
+
+  todstart = tod();
+  cpustart = cpucycles();
+  for (j = 0;j < 1000;++j) for (i = 0;i <= 1000;++i) t[i] = t[i] + i + j;
+  todend = tod();
+  cpuend = cpucycles();
+
+  todend -= todstart;
+  cpuend -= cpustart;
+
+  cyclespertod = (long long) (((double) cpuend) * 1000000.0 / (double) todend);
+
+  if (cyclespertod > 10 * cyclespersecond) {
+    fprintf(stderr,"cyclespertod = %lld, cyclespersecond = %lld\n",cyclespertod,cyclespersecond);
+    return 100;
+  }
+
+  for (i = 0;i <= 1000;++i) t[i] = cpucycles();
+  printf("%s",cpucycles_implementation);
+  printf(" %lld",cyclespersecond);
+  printf(" %lld",cyclespertod);
+  for (i = 0;i < 64;++i) printf(" %lld",t[i + 1] - t[i]);
+  printf("\n");
+  return 0;
+}
diff --git a/nacl/cpucycles/x86cpuinfo.c b/nacl/cpucycles/x86cpuinfo.c
new file mode 100644
index 00000000..3fb0a1b0
--- /dev/null
+++ b/nacl/cpucycles/x86cpuinfo.c
@@ -0,0 +1,15 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include "osfreq.c"
+
+long long cpucycles_x86cpuinfo(void)
+{
+  long long result;
+  asm volatile(".byte 15;.byte 49" : "=A" (result));
+  return result;
+}
+
+long long cpucycles_x86cpuinfo_persecond(void)
+{
+  return osfreq();
+}
diff --git a/nacl/cpucycles/x86cpuinfo.h b/nacl/cpucycles/x86cpuinfo.h
new file mode 100644
index 00000000..88f151dd
--- /dev/null
+++ b/nacl/cpucycles/x86cpuinfo.h
@@ -0,0 +1,27 @@
+/*
+cpucycles x86cpuinfo.h version 20100803
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_x86cpuinfo_h
+#define CPUCYCLES_x86cpuinfo_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_x86cpuinfo(void);
+extern long long cpucycles_x86cpuinfo_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "x86cpuinfo"
+#define cpucycles cpucycles_x86cpuinfo
+#define cpucycles_persecond cpucycles_x86cpuinfo_persecond
+#endif
+
+#endif
diff --git a/nacl/cpucycles/x86cpuspeed.c b/nacl/cpucycles/x86cpuspeed.c
new file mode 100644
index 00000000..34222565
--- /dev/null
+++ b/nacl/cpucycles/x86cpuspeed.c
@@ -0,0 +1,24 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/sysctl.h>
+
+long long cpucycles_x86cpuspeed(void)
+{
+  long long result;
+  asm volatile(".byte 15;.byte 49" : "=A" (result));
+  return result;
+}
+
+long long cpucycles_x86cpuspeed_persecond(void)
+{
+  int oid[2];
+  int val;
+  size_t size;
+  oid[0] = CTL_HW;
+  oid[1] = HW_CPUSPEED;
+  size = sizeof val;
+  if (sysctl(oid,2,&val,&size,0,0) == -1) return 0;
+  if (size != sizeof val) return 0;
+  return val * 1000000LL;
+}
diff --git a/nacl/cpucycles/x86cpuspeed.h b/nacl/cpucycles/x86cpuspeed.h
new file mode 100644
index 00000000..43005cda
--- /dev/null
+++ b/nacl/cpucycles/x86cpuspeed.h
@@ -0,0 +1,27 @@
+/*
+cpucycles x86cpuspeed.h version 20090716
+Matthew Dempsky
+Public domain.
+*/
+
+#ifndef CPUCYCLES_x86cpuspeed_h
+#define CPUCYCLES_x86cpuspeed_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_x86cpuspeed(void);
+extern long long cpucycles_x86cpuspeed_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "x86cpuspeed"
+#define cpucycles cpucycles_x86cpuspeed
+#define cpucycles_persecond cpucycles_x86cpuspeed_persecond
+#endif
+
+#endif
diff --git a/nacl/cpucycles/x86estimate.c b/nacl/cpucycles/x86estimate.c
new file mode 100644
index 00000000..e5ae66cf
--- /dev/null
+++ b/nacl/cpucycles/x86estimate.c
@@ -0,0 +1,59 @@
+#include <time.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/sysctl.h>
+
+long long cpucycles_x86estimate(void)
+{
+  long long result;
+  asm volatile(".byte 15;.byte 49" : "=A" (result));
+  return result;
+}
+
+static long long microseconds(void)
+{
+  struct timeval t;
+  gettimeofday(&t,(struct timezone *) 0);
+  return t.tv_sec * (long long) 1000000 + t.tv_usec;
+}
+
+static double guessfreq(void)
+{
+  long long tb0; long long us0;
+  long long tb1; long long us1;
+
+  tb0 = cpucycles_x86estimate();
+  us0 = microseconds();
+  do {
+    tb1 = cpucycles_x86estimate();
+    us1 = microseconds();
+  } while (us1 - us0 < 10000 || tb1 - tb0 < 1000);
+  if (tb1 <= tb0) return 0;
+  tb1 -= tb0;
+  us1 -= us0;
+  return ((double) tb1) / (0.000001 * (double) us1);
+}
+
+static double cpufrequency = 0;
+
+static void init(void)
+{
+  double guess1;
+  double guess2;
+  int loop;
+
+  for (loop = 0;loop < 100;++loop) {
+    guess1 = guessfreq();
+    guess2 = guessfreq();
+    if (guess1 > 1.01 * guess2) continue;
+    if (guess2 > 1.01 * guess1) continue;
+    cpufrequency = 0.5 * (guess1 + guess2);
+    break;
+  }
+}
+
+long long cpucycles_x86estimate_persecond(void)
+{
+  if (!cpufrequency) init();
+  return cpufrequency;
+}
diff --git a/nacl/cpucycles/x86estimate.h b/nacl/cpucycles/x86estimate.h
new file mode 100644
index 00000000..98f2dd15
--- /dev/null
+++ b/nacl/cpucycles/x86estimate.h
@@ -0,0 +1,27 @@
+/*
+cpucycles x86estimate.h version 20070121
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_x86estimate_h
+#define CPUCYCLES_x86estimate_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_x86estimate(void);
+extern long long cpucycles_x86estimate_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "x86estimate"
+#define cpucycles cpucycles_x86estimate
+#define cpucycles_persecond cpucycles_x86estimate_persecond
+#endif
+
+#endif
diff --git a/nacl/cpucycles/x86tscfreq.c b/nacl/cpucycles/x86tscfreq.c
new file mode 100644
index 00000000..a1b94b62
--- /dev/null
+++ b/nacl/cpucycles/x86tscfreq.c
@@ -0,0 +1,17 @@
+#include <sys/types.h>
+#include <sys/sysctl.h>
+
+long long cpucycles_x86tscfreq(void)
+{
+  long long result;
+  asm volatile(".byte 15;.byte 49" : "=A" (result));
+  return result;
+}
+
+long long cpucycles_x86tscfreq_persecond(void)
+{
+  long result = 0;
+  size_t resultlen = sizeof(long);
+  sysctlbyname("machdep.tsc_freq",&result,&resultlen,0,0);
+  return result;
+}
diff --git a/nacl/cpucycles/x86tscfreq.h b/nacl/cpucycles/x86tscfreq.h
new file mode 100644
index 00000000..abf616e5
--- /dev/null
+++ b/nacl/cpucycles/x86tscfreq.h
@@ -0,0 +1,27 @@
+/*
+cpucycles x86tscfreq.h version 20060318
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_x86tscfreq_h
+#define CPUCYCLES_x86tscfreq_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_x86tscfreq(void);
+extern long long cpucycles_x86tscfreq_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "x86tscfreq"
+#define cpucycles cpucycles_x86tscfreq
+#define cpucycles_persecond cpucycles_x86tscfreq_persecond
+#endif
+
+#endif