From 2ae43be7b9d4118335c9d2cef6e098f9b9f807fe Mon Sep 17 00:00:00 2001 From: xleroy Date: Thu, 9 Feb 2006 14:55:48 +0000 Subject: Initial import of compcert git-svn-id: https://yquem.inria.fr/compcert/svn/compcert/trunk@1 fca1b0fc-160b-0410-b1d3-a4f43f01ea2e --- test/cminor/Makefile | 76 ++++++++++ test/cminor/aes.cmp | 364 ++++++++++++++++++++++++++++++++++++++++++++++ test/cminor/almabench.cmp | 159 ++++++++++++++++++++ test/cminor/fft.cm | 149 +++++++++++++++++++ test/cminor/fib.cm | 7 + test/cminor/integr.cm | 25 ++++ test/cminor/manyargs.cm | 53 +++++++ test/cminor/qsort.cm | 30 ++++ test/cminor/sha1.cmp | 189 ++++++++++++++++++++++++ 9 files changed, 1052 insertions(+) create mode 100644 test/cminor/Makefile create mode 100644 test/cminor/aes.cmp create mode 100644 test/cminor/almabench.cmp create mode 100644 test/cminor/fft.cm create mode 100644 test/cminor/fib.cm create mode 100644 test/cminor/integr.cm create mode 100644 test/cminor/manyargs.cm create mode 100644 test/cminor/qsort.cm create mode 100644 test/cminor/sha1.cmp (limited to 'test/cminor') diff --git a/test/cminor/Makefile b/test/cminor/Makefile new file mode 100644 index 0000000..35d3e07 --- /dev/null +++ b/test/cminor/Makefile @@ -0,0 +1,76 @@ +CCOMP=../../ccomp +CPP=cpp -P +CC=gcc +CFLAGS=-g +VPATH=../harness ../lib + +PROGS=fib integr qsort fft sha1 aes almabench manyargs + +all_s: $(PROGS:%=%.s) + +all: $(PROGS) + +$(PROGS:%=%.s): $(CCOMP) + +fib: fib.o mainfib.o + $(CC) $(CFLAGS) -o fib fib.o mainfib.o +clean:: + rm -f fib + +integr: integr.o mainintegr.o + $(CC) $(CFLAGS) -o integr integr.o mainintegr.o +clean:: + rm -f integr + +qsort: qsort.o mainqsort.o + $(CC) $(CFLAGS) -o qsort qsort.o mainqsort.o +clean:: + rm -f qsort + +fft: fft.o mainfft.o staticlib.o + $(CC) $(CFLAGS) -o fft fft.o mainfft.o staticlib.o -lm +clean:: + rm -f fft + +sha1: sha1.o mainsha1.o staticlib.o + $(CC) $(CFLAGS) -o sha1 sha1.o mainsha1.o staticlib.o +clean:: + rm -f sha1 sha1.cm + +aes: aes.o mainaes.o + $(CC) $(CFLAGS) -o aes aes.o mainaes.o +clean:: + rm -f aes aes.cm + +almabench: almabench.o mainalmabench.o staticlib.o + $(CC) $(CFLAGS) -o almabench almabench.o mainalmabench.o staticlib.o -lm +clean:: + rm -f almabench almabench.cm + +manyargs: manyargs.o mainmanyargs.o + $(CC) $(CFLAGS) -o manyargs manyargs.o mainmanyargs.o +clean:: + rm -f manyargs + +.SUFFIXES: + +.SUFFIXES: .cmp .cm .s .o .c .S + +.cmp.s: + $(CPP) $*.cmp > $*.cm + $(CCOMP) $(FLAGS) $*.cm + +.cm.s: + $(CCOMP) $(FLAGS) $*.cm + +.c.o: + $(CC) $(CFLAGS) -c $< + +.s.o: + $(AS) $(ASFLAGS) -o $*.o $< + +.S.o: + $(AS) $(ASFLAGS) -o $*.o $< + +clean:: + rm -f *.s *.o *~ diff --git a/test/cminor/aes.cmp b/test/cminor/aes.cmp new file mode 100644 index 0000000..35eabc4 --- /dev/null +++ b/test/cminor/aes.cmp @@ -0,0 +1,364 @@ +/* AES cipher. To be preprocessed with cpp -P. */ + +#define GETU32(pt) int32[pt] +#define PUTU32(ct,st) int32[ct] = st + +#define rk(n) int32[rk_ + (n) * 4] +#define Te0(n) int32["Te0" + (n) * 4] +#define Te1(n) int32["Te1" + (n) * 4] +#define Te2(n) int32["Te2" + (n) * 4] +#define Te3(n) int32["Te3" + (n) * 4] +#define Te4(n) int32["Te4" + (n) * 4] +#define Td0(n) int32["Td0" + (n) * 4] +#define Td1(n) int32["Td1" + (n) * 4] +#define Td2(n) int32["Td2" + (n) * 4] +#define Td3(n) int32["Td3" + (n) * 4] +#define Td4(n) int32["Td4" + (n) * 4] +#define rcon(n) int32["rcon" + (n) * 4] + +/** + * Expand the cipher key into the encryption key schedule. + * + * @return the number of rounds for the given cipher key size. + */ +"rijndaelKeySetupEnc"(rk_, cipherKey, keyBits) : int -> int -> int -> int +{ + var i, temp; + i = 0; + + rk(0) = GETU32(cipherKey ); + rk(1) = GETU32(cipherKey + 4); + rk(2) = GETU32(cipherKey + 8); + rk(3) = GETU32(cipherKey + 12); + if (keyBits == 128) { + {{ loop { + temp = rk(3); + rk(4) = rk(0) ^ + (Te4((temp >>u 16) & 0xff) & 0xff000000) ^ + (Te4((temp >>u 8) & 0xff) & 0x00ff0000) ^ + (Te4((temp ) & 0xff) & 0x0000ff00) ^ + (Te4((temp >>u 24) ) & 0x000000ff) ^ + rcon(i); + rk(5) = rk(1) ^ rk(4); + rk(6) = rk(2) ^ rk(5); + rk(7) = rk(3) ^ rk(6); + if ((i = i + 1) == 10) { + return 10; + } + rk_ = rk_ + 4 * 4; + } }} + } + rk(4) = GETU32(cipherKey + 16); + rk(5) = GETU32(cipherKey + 20); + if (keyBits == 192) { + {{ loop { + temp = rk( 5); + rk( 6) = rk( 0) ^ + (Te4((temp >>u 16) & 0xff) & 0xff000000) ^ + (Te4((temp >>u 8) & 0xff) & 0x00ff0000) ^ + (Te4((temp ) & 0xff) & 0x0000ff00) ^ + (Te4((temp >>u 24) ) & 0x000000ff) ^ + rcon(i); + rk( 7) = rk( 1) ^ rk( 6); + rk( 8) = rk( 2) ^ rk( 7); + rk( 9) = rk( 3) ^ rk( 8); + if ((i = i + 1) == 8) { + return 12; + } + rk(10) = rk( 4) ^ rk( 9); + rk(11) = rk( 5) ^ rk(10); + rk_ = rk_ + 6 * 4; + } }} + } + rk(6) = GETU32(cipherKey + 24); + rk(7) = GETU32(cipherKey + 28); + if (keyBits == 256) { + {{ loop { + temp = rk( 7); + rk( 8) = rk( 0) ^ + (Te4((temp >>u 16) & 0xff) & 0xff000000) ^ + (Te4((temp >>u 8) & 0xff) & 0x00ff0000) ^ + (Te4((temp ) & 0xff) & 0x0000ff00) ^ + (Te4((temp >>u 24) ) & 0x000000ff) ^ + rcon(i); + rk( 9) = rk( 1) ^ rk( 8); + rk(10) = rk( 2) ^ rk( 9); + rk(11) = rk( 3) ^ rk(10); + if ((i = i + 1) == 7) { + return 14; + } + temp = rk(11); + rk(12) = rk( 4) ^ + (Te4((temp >>u 24) ) & 0xff000000) ^ + (Te4((temp >>u 16) & 0xff) & 0x00ff0000) ^ + (Te4((temp >>u 8) & 0xff) & 0x0000ff00) ^ + (Te4((temp ) & 0xff) & 0x000000ff); + rk(13) = rk( 5) ^ rk(12); + rk(14) = rk( 6) ^ rk(13); + rk(15) = rk( 7) ^ rk(14); + + rk_ = rk_ + 8 * 4; + } }} + } + return 0; +} + +/** + * Expand the cipher key into the decryption key schedule. + * + * @return the number of rounds for the given cipher key size. + */ +"rijndaelKeySetupDec"(rk_, cipherKey, keyBits) : int -> int -> int -> int +{ + var Nr, i, j, temp; + + /* expand the cipher key: */ + Nr = "rijndaelKeySetupEnc"(rk_, cipherKey, keyBits) : int -> int -> int -> int; + /* invert the order of the round keys: */ + i = 0; j = 4 * Nr; + {{ loop { + if (! (i < j)) exit; + temp = rk(i ); rk(i ) = rk(j ); rk(j ) = temp; + temp = rk(i + 1); rk(i + 1) = rk(j + 1); rk(j + 1) = temp; + temp = rk(i + 2); rk(i + 2) = rk(j + 2); rk(j + 2) = temp; + temp = rk(i + 3); rk(i + 3) = rk(j + 3); rk(j + 3) = temp; + i = i + 4; + j = j - 4; + } }} + /* apply the inverse MixColumn transform to all round keys but the first and the last: */ + i = 1; + {{ loop { + if (! (i < Nr)) exit; + rk_ = rk_ + 4 * 4; + rk(0) = + Td0(Te4((rk(0) >>u 24) ) & 0xff) ^ + Td1(Te4((rk(0) >>u 16) & 0xff) & 0xff) ^ + Td2(Te4((rk(0) >>u 8) & 0xff) & 0xff) ^ + Td3(Te4((rk(0) ) & 0xff) & 0xff); + rk(1) = + Td0(Te4((rk(1) >>u 24) ) & 0xff) ^ + Td1(Te4((rk(1) >>u 16) & 0xff) & 0xff) ^ + Td2(Te4((rk(1) >>u 8) & 0xff) & 0xff) ^ + Td3(Te4((rk(1) ) & 0xff) & 0xff); + rk(2) = + Td0(Te4((rk(2) >>u 24) ) & 0xff) ^ + Td1(Te4((rk(2) >>u 16) & 0xff) & 0xff) ^ + Td2(Te4((rk(2) >>u 8) & 0xff) & 0xff) ^ + Td3(Te4((rk(2) ) & 0xff) & 0xff); + rk(3) = + Td0(Te4((rk(3) >>u 24) ) & 0xff) ^ + Td1(Te4((rk(3) >>u 16) & 0xff) & 0xff) ^ + Td2(Te4((rk(3) >>u 8) & 0xff) & 0xff) ^ + Td3(Te4((rk(3) ) & 0xff) & 0xff); + i = i + 1; + } }} + return Nr; +} + +"rijndaelEncrypt"(rk_, Nr, pt, ct): int -> int -> int -> int -> void +{ + var s0, s1, s2, s3, t0, t1, t2, t3, r; + + /* + * map byte array block to cipher state + * and add initial round key: + */ + s0 = GETU32(pt ) ^ rk(0); + s1 = GETU32(pt + 4) ^ rk(1); + s2 = GETU32(pt + 8) ^ rk(2); + s3 = GETU32(pt + 12) ^ rk(3); + /* + * Nr - 1 full rounds: + */ + r = Nr >>u 1; + {{ loop { + t0 = + Te0((s0 >>u 24) ) ^ + Te1((s1 >>u 16) & 0xff) ^ + Te2((s2 >>u 8) & 0xff) ^ + Te3((s3 ) & 0xff) ^ + rk(4); + t1 = + Te0((s1 >>u 24) ) ^ + Te1((s2 >>u 16) & 0xff) ^ + Te2((s3 >>u 8) & 0xff) ^ + Te3((s0 ) & 0xff) ^ + rk(5); + t2 = + Te0((s2 >>u 24) ) ^ + Te1((s3 >>u 16) & 0xff) ^ + Te2((s0 >>u 8) & 0xff) ^ + Te3((s1 ) & 0xff) ^ + rk(6); + t3 = + Te0((s3 >>u 24) ) ^ + Te1((s0 >>u 16) & 0xff) ^ + Te2((s1 >>u 8) & 0xff) ^ + Te3((s2 ) & 0xff) ^ + rk(7); + + rk_ = rk_ + 8 * 4; + if ((r = r - 1) == 0) exit; + + s0 = + Te0((t0 >>u 24) ) ^ + Te1((t1 >>u 16) & 0xff) ^ + Te2((t2 >>u 8) & 0xff) ^ + Te3((t3 ) & 0xff) ^ + rk(0); + s1 = + Te0((t1 >>u 24) ) ^ + Te1((t2 >>u 16) & 0xff) ^ + Te2((t3 >>u 8) & 0xff) ^ + Te3((t0 ) & 0xff) ^ + rk(1); + s2 = + Te0((t2 >>u 24) ) ^ + Te1((t3 >>u 16) & 0xff) ^ + Te2((t0 >>u 8) & 0xff) ^ + Te3((t1 ) & 0xff) ^ + rk(2); + s3 = + Te0((t3 >>u 24) ) ^ + Te1((t0 >>u 16) & 0xff) ^ + Te2((t1 >>u 8) & 0xff) ^ + Te3((t2 ) & 0xff) ^ + rk(3); + } }} + /* + * apply last round and + * map cipher state to byte array block: + */ + s0 = + (Te4((t0 >>u 24) ) & 0xff000000) ^ + (Te4((t1 >>u 16) & 0xff) & 0x00ff0000) ^ + (Te4((t2 >>u 8) & 0xff) & 0x0000ff00) ^ + (Te4((t3 ) & 0xff) & 0x000000ff) ^ + rk(0); + PUTU32(ct , s0); + s1 = + (Te4((t1 >>u 24) ) & 0xff000000) ^ + (Te4((t2 >>u 16) & 0xff) & 0x00ff0000) ^ + (Te4((t3 >>u 8) & 0xff) & 0x0000ff00) ^ + (Te4((t0 ) & 0xff) & 0x000000ff) ^ + rk(1); + PUTU32(ct + 4, s1); + s2 = + (Te4((t2 >>u 24) ) & 0xff000000) ^ + (Te4((t3 >>u 16) & 0xff) & 0x00ff0000) ^ + (Te4((t0 >>u 8) & 0xff) & 0x0000ff00) ^ + (Te4((t1 ) & 0xff) & 0x000000ff) ^ + rk(2); + PUTU32(ct + 8, s2); + s3 = + (Te4((t3 >>u 24) ) & 0xff000000) ^ + (Te4((t0 >>u 16) & 0xff) & 0x00ff0000) ^ + (Te4((t1 >>u 8) & 0xff) & 0x0000ff00) ^ + (Te4((t2 ) & 0xff) & 0x000000ff) ^ + rk(3); + PUTU32(ct + 12, s3); +} + +"rijndaelDecrypt"(rk_, Nr, ct, pt) : int -> int -> int -> int -> void +{ + var s0, s1, s2, s3, t0, t1, t2, t3, r; + + /* + * map byte array block to cipher state + * and add initial round key: + */ + s0 = GETU32(ct ) ^ rk(0); + s1 = GETU32(ct + 4) ^ rk(1); + s2 = GETU32(ct + 8) ^ rk(2); + s3 = GETU32(ct + 12) ^ rk(3); + /* + * Nr - 1 full rounds: + */ + r = Nr >>u 1; + {{ loop { + t0 = + Td0((s0 >>u 24) ) ^ + Td1((s3 >>u 16) & 0xff) ^ + Td2((s2 >>u 8) & 0xff) ^ + Td3((s1 ) & 0xff) ^ + rk(4); + t1 = + Td0((s1 >>u 24) ) ^ + Td1((s0 >>u 16) & 0xff) ^ + Td2((s3 >>u 8) & 0xff) ^ + Td3((s2 ) & 0xff) ^ + rk(5); + t2 = + Td0((s2 >>u 24) ) ^ + Td1((s1 >>u 16) & 0xff) ^ + Td2((s0 >>u 8) & 0xff) ^ + Td3((s3 ) & 0xff) ^ + rk(6); + t3 = + Td0((s3 >>u 24) ) ^ + Td1((s2 >>u 16) & 0xff) ^ + Td2((s1 >>u 8) & 0xff) ^ + Td3((s0 ) & 0xff) ^ + rk(7); + + rk_ = rk_ + 8 * 4; + if ((r = r - 1) == 0) exit; + + s0 = + Td0((t0 >>u 24) ) ^ + Td1((t3 >>u 16) & 0xff) ^ + Td2((t2 >>u 8) & 0xff) ^ + Td3((t1 ) & 0xff) ^ + rk(0); + s1 = + Td0((t1 >>u 24) ) ^ + Td1((t0 >>u 16) & 0xff) ^ + Td2((t3 >>u 8) & 0xff) ^ + Td3((t2 ) & 0xff) ^ + rk(1); + s2 = + Td0((t2 >>u 24) ) ^ + Td1((t1 >>u 16) & 0xff) ^ + Td2((t0 >>u 8) & 0xff) ^ + Td3((t3 ) & 0xff) ^ + rk(2); + s3 = + Td0((t3 >>u 24) ) ^ + Td1((t2 >>u 16) & 0xff) ^ + Td2((t1 >>u 8) & 0xff) ^ + Td3((t0 ) & 0xff) ^ + rk(3); + } }} + /* + * apply last round and + * map cipher state to byte array block: + */ + s0 = + (Td4((t0 >>u 24) ) & 0xff000000) ^ + (Td4((t3 >>u 16) & 0xff) & 0x00ff0000) ^ + (Td4((t2 >>u 8) & 0xff) & 0x0000ff00) ^ + (Td4((t1 ) & 0xff) & 0x000000ff) ^ + rk(0); + PUTU32(pt , s0); + s1 = + (Td4((t1 >>u 24) ) & 0xff000000) ^ + (Td4((t0 >>u 16) & 0xff) & 0x00ff0000) ^ + (Td4((t3 >>u 8) & 0xff) & 0x0000ff00) ^ + (Td4((t2 ) & 0xff) & 0x000000ff) ^ + rk(1); + PUTU32(pt + 4, s1); + s2 = + (Td4((t2 >>u 24) ) & 0xff000000) ^ + (Td4((t1 >>u 16) & 0xff) & 0x00ff0000) ^ + (Td4((t0 >>u 8) & 0xff) & 0x0000ff00) ^ + (Td4((t3 ) & 0xff) & 0x000000ff) ^ + rk(2); + PUTU32(pt + 8, s2); + s3 = + (Td4((t3 >>u 24) ) & 0xff000000) ^ + (Td4((t2 >>u 16) & 0xff) & 0x00ff0000) ^ + (Td4((t1 >>u 8) & 0xff) & 0x0000ff00) ^ + (Td4((t0 ) & 0xff) & 0x000000ff) ^ + rk(3); + PUTU32(pt + 12, s3); +} diff --git a/test/cminor/almabench.cmp b/test/cminor/almabench.cmp new file mode 100644 index 0000000..e9e8392 --- /dev/null +++ b/test/cminor/almabench.cmp @@ -0,0 +1,159 @@ +#define PI 3.14159265358979323846 +#define J2000 2451545.0 +#define JCENTURY 36525.0 +#define JMILLENIA 365250.0 +#define TWOPI (2.0 *f PI) +#define A2R (PI /f 648000.0) +#define R2H (12.0 /f PI) +#define R2D (180.0 /f PI) +#define GAUSSK 0.01720209895 +#define TEST_LOOPS 20 +#define TEST_LENGTH 36525 +#define sineps 0.3977771559319137 +#define coseps 0.9174820620691818 + +/* Access to tables */ +#define amas(n) float64["amas" + (n) * 8] +#define a(x,y) float64["a" + ((x) * 24 + (y) * 8)] +#define dlm(x,y) float64["dlm" + ((x) * 24 + (y) * 8)] +#define e(x,y) float64["e" + ((x) * 24 + (y) * 8)] +#define pi(x,y) float64["pi" + ((x) * 24 + (y) * 8)] +#define dinc(x,y) float64["dinc" + ((x) * 24 + (y) * 8)] +#define omega(x,y) float64["omega" + ((x) * 24 + (y) * 8)] +#define kp(x,y) float64["kp" + ((x) * 72 + (y) * 8)] +#define ca(x,y) float64["ca" + ((x) * 72 + (y) * 8)] +#define sa(x,y) float64["sa" + ((x) * 72 + (y) * 8)] +#define kq(x,y) float64["kq" + ((x) * 80 + (y) * 8)] +#define cl(x,y) float64["cl" + ((x) * 80 + (y) * 8)] +#define sl(x,y) float64["sl" + ((x) * 80 + (y) * 8)] + +/* Function calls */ +#define cos(x) ("cos_static"(x): float -> float) +#define sin(x) ("sin_static"(x): float -> float) +#define atan2(x,y) ("atan2_static"(x,y): float -> float -> float) +#define asin(x) ("asin_static"(x): float -> float) +#define sqrt(x) ("sqrt_static"(x): float -> float) +#define fmod(x,y) ("fmod_static"(x,y): float -> float -> float) +#define anpm(x) ("anpm"(x) : float -> float) + +"anpm"(a): float -> float +{ + var w; + w = fmod(a,TWOPI); + if (absf(w) >=f PI) + w = w -f ((a int -> int -> void +{ +#define epoch(x) float64[epoch_ + (x) * 8] +#define pv(x,y) float64[pv_ + (x) * 24 + (y) * 8] + + var i, j, k; + var t, da, dl, de, dp, di; + var doh, dmu, arga, argl, am; + var ae, dae, ae2, at, r, v; + var si2, xq, xp, tl, xsw; + var xcw, xm2, xf, ci2, xms, xmc; + var xpxq2, x, y, z; + + t = ((epoch(0) -f J2000) +f epoch(1)) /f JMILLENIA; + + da = a(np,0) +f (a(np,1) +f a(np,2) *f t ) *f t; + dl = (3600.0 *f dlm(np,0) +f (dlm(np,1) +f dlm(np,2) *f t ) *f t ) *f A2R; + de = e(np,0) +f (e(np,1) +f e(np,2) *f t ) *f t; + dp = anpm((3600.0 *f pi(np,0) +f (pi(np,1) +f pi(np,2) *f t ) *f t ) *f A2R ); + di = (3600.0 *f dinc(np,0) +f (dinc(np,1) +f dinc(np,2) *f t ) *f t ) *f A2R; + doh = anpm((3600.0 *f omega(np,0) +f (omega(np,1) +f omega(np,2) *f t ) *f t ) *f A2R ); + + dmu = 0.35953620 *f t; + + k = 0; + {{ loop { + if (! (k < 8)) exit; + arga = kp(np,k) *f dmu; + argl = kq(np,k) *f dmu; + da = da +f (ca(np,k) *f cos(arga) +f sa(np,k) *f sin(arga)) *f 0.0000001; + dl = dl +f (cl(np,k) *f cos(argl) +f sl(np,k) *f sin(argl)) *f 0.0000001; + k = k + 1; + } }} + + arga = kp(np,8) *f dmu; + da = da +f t *f (ca(np,8) *f cos(arga) +f sa(np,8) *f sin(arga)) *f 0.0000001; + + k = 8; + {{ loop { + if (! (k <= 9)) exit; + argl = kq(np,k) *f dmu; + dl = dl +f t *f ( cl(np,k) *f cos(argl) +f sl(np,k) *f sin(argl) ) *f 0.0000001; + k = k + 1; + } }} + + dl = "fmod_static"(dl,TWOPI) : float -> float -> float; + + am = dl -f dp; + ae = am +f de *f sin(am); + k = 0; + + {{ loop { + dae = (am -f ae +f de *f sin(ae)) /f (1.0 -f de *f cos(ae)); + ae = ae +f dae; + k = k + 1; + + if ((k >= 10) || (absf(dae) int -> void +{ +#define state(x,y) float64[state_ + (x) * 24 + (y) * 8] +#define rdd(x) float64[rdd_ + (x) * 8] + + rdd(2) = sqrt(state(0,0) *f state(0,0) +f state(0,1) *f state(0,1) +f state(0,2) *f state(0,2)); + rdd(0) = atan2(state(0,1), state(0,0)) *f R2H; + if (rdd(0) int /*float ptr*/ -> int -> int +{ + var px, py, /*float ptr*/ + i, j, k, m, n, i0, i1, i2, i3, is, id, n1, n2, n4, a, e, a3, /*int*/ + cc1, ss1, cc3, ss3, r1, r2, s1, s2, s3, xt, tpi /*float*/; + + px = x - 8; + py = y - 8; + i = 2; + m = 1; + + {{ loop { + if (! (i < np)) exit; + i = i+i; + m = m+1; + } }} + + n = i; + + if (n != np) + { + i = np + 1; + {{ loop { + if (! (i <= n)) exit; + float64[px + i*8] = 0.0; + float64[py + i*8] = 0.0; + i = i + 1; + } }} + } + + n2 = n+n; + tpi = 2.0 *f 3.14159265358979323846; + k = 1; + {{ loop { + if (! (k <= m - 1)) exit; + n2 = n2 / 2; + n4 = n2 / 4; + e = tpi /f floatofint(n2); + a = 0.0; + + j = 1; + {{ loop { + if (! (j <= n4)) exit; + cc1 = "cos_static"(a) : float -> float; + ss1 = "sin_static"(a) : float -> float; + a3 = 3.0 *f a; + cc3 = "cos_static"(a3) : float -> float; + ss3 = "sin_static"(a3) : float -> float; + a = e *f floatofint(j); + is = j; + id = 2 * n2; + + {{ loop { + if (! ( is < n )) exit; + i0 = is; + {{ loop { + /* DEBUG "trace"(); */ + if (! (i0 <= n - 1)) exit; + i1 = i0 + n4; /*DEBUG "print_int"(i1); */ + i2 = i1 + n4; /*DEBUG "print_int"(i2); */ + i3 = i2 + n4; /*DEBUG "print_int"(i3); */ + r1 = float64[px+i0*8] -f float64[px+i2*8]; + /* DEBUG "print_float"(r1); */ + float64[px+i0*8] = float64[px+i0*8] +f float64[px+i2*8]; + r2 = float64[px+i1*8] -f float64[px+i3*8]; + /* DEBUG "print_float"(r2); */ + float64[px+i1*8] = float64[px+i1*8] +f float64[px+i3*8]; + s1 = float64[py+i0*8] -f float64[py+i2*8]; + /* DEBUG "print_float"(s1); */ + float64[py+i0*8] = float64[py+i0*8] +f float64[py+i2*8]; + s2 = float64[py+i1*8] -f float64[py+i3*8]; + /* DEBUG "print_float"(s2); */ + float64[py+i1*8] = float64[py+i1*8] +f float64[py+i3*8]; + s3 = r1 -f s2; r1 = r1 +f s2; + s2 = r2 -f s1; r2 = r2 +f s1; + float64[px+i2*8] = (r1 *f cc1) -f (s2 *f ss1); + float64[py+i2*8] = (-f s2 *f cc1) -f (r1 *f ss1); + float64[px+i3*8] = (s3 *f cc3) +f (r2 *f ss3); + float64[py+i3*8] = (r2 *f cc3) -f (s3 *f ss3); + i0 = i0 + id; + } }} + is = 2 * id - n2 + j; + id = 4 * id; + } }} + j = j + 1; + } }} + k = k + 1; + } }} + +/************************************/ +/* Last stage, length=2 butterfly */ +/************************************/ + is = 1; + id = 4; + + {{ loop { + if (! ( is < n)) exit; + i0 = is; + {{ loop { + if (! (i0 <= n)) exit; + i1 = i0 + 1; + r1 = float64[px+i0*8]; + float64[px+i0*8] = r1 +f float64[px+i1*8]; + float64[px+i1*8] = r1 -f float64[px+i1*8]; + r1 = float64[py+i0*8]; + float64[py+i0*8] = r1 +f float64[py+i1*8]; + float64[py+i1*8] = r1 -f float64[py+i1*8]; + i0 = i0 + id; + } }} + is = 2*id - 1; + id = 4 * id; + } }} + +/*************************/ +/* Bit reverse counter */ +/*************************/ + j = 1; + n1 = n - 1; + + i = 1; + {{ loop { + if (! (i <= n1)) exit; + if (i < j) { + xt = float64[px+j*8]; + float64[px+j*8] = float64[px+i*8]; + float64[px+i*8] = xt; + xt = float64[py+j*8]; + float64[py+j*8] = float64[py+i*8]; + float64[py+i*8] = xt; + } + k = n / 2; + {{ loop { + if (! (k < j)) exit; + j = j - k; + k = k / 2; + } }} + j = j + k; + i = i + 1; + } }} + + return(n); +} diff --git a/test/cminor/fib.cm b/test/cminor/fib.cm new file mode 100644 index 0000000..42fbdd6 --- /dev/null +++ b/test/cminor/fib.cm @@ -0,0 +1,7 @@ +"fib"(n): int -> int +{ + if (n < 2) + return 1; + else + return "fib"(n - 1) : int -> int + "fib"(n - 2) : int -> int; +} diff --git a/test/cminor/integr.cm b/test/cminor/integr.cm new file mode 100644 index 0000000..28f0a1d --- /dev/null +++ b/test/cminor/integr.cm @@ -0,0 +1,25 @@ +"square" (x): float -> float +{ + return x *f x; +} + +"integr"(f, low, high, n): int -> float -> float -> int -> float +{ + var h, x, s, i; + h = (high -f low) /f floatofint n; + x = low; + s = 0.0; + i = n; + {{ loop { + if (! (i > 0)) exit; + s = s +f (f(x): float -> float); + x = x +f h; + i = i - 1; + } }} + return s *f h; +} + +"test"(n) : int -> float +{ + return "integr"("square", 0.0, 1.0, n): int -> float -> float -> int -> float; +} diff --git a/test/cminor/manyargs.cm b/test/cminor/manyargs.cm new file mode 100644 index 0000000..97b1662 --- /dev/null +++ b/test/cminor/manyargs.cm @@ -0,0 +1,53 @@ +"f" (i1, i2, i3, i4, i5, + i6, i7, i8, i9, i10, + f1, f2, f3, f4, f5, + f6, f7, f8, f9, f10, + f11, f12, f13, f14, f15): + int -> int -> int -> int -> int -> + int -> int -> int -> int -> int -> + float -> float -> float -> float -> float -> + float -> float -> float -> float -> float -> + float -> float -> float -> float -> float -> void +{ + "print_int"(i1): int -> void; + "print_int"(i2): int -> void; + "print_int"(i3): int -> void; + "print_int"(i4): int -> void; + "print_int"(i5): int -> void; + "print_int"(i6): int -> void; + "print_int"(i7): int -> void; + "print_int"(i8): int -> void; + "print_int"(i9): int -> void; + "print_int"(i10): int -> void; + "print_float"(f1): float -> void; + "print_float"(f2): float -> void; + "print_float"(f3): float -> void; + "print_float"(f4): float -> void; + "print_float"(f5): float -> void; + "print_float"(f6): float -> void; + "print_float"(f7): float -> void; + "print_float"(f8): float -> void; + "print_float"(f9): float -> void; + "print_float"(f10): float -> void; + "print_float"(f11): float -> void; + "print_float"(f12): float -> void; + "print_float"(f13): float -> void; + "print_float"(f14): float -> void; + "print_float"(f15): float -> void; +} + +"g" (i1, i2, i3, i4, i5, + f1, f2, f3, f4, f5): + int -> int -> int -> int -> int -> + float -> float -> float -> float -> float -> void +{ + "f"(i1,i2,i3,i4,i5, i1,i2,i3,i4,i5, + f1,f2,f3,f4,f5, f1,f2,f3,f4,f5, f1,f2,f3,f4,f5): + int -> int -> int -> int -> int -> + int -> int -> int -> int -> int -> + float -> float -> float -> float -> float -> + float -> float -> float -> float -> float -> + float -> float -> float -> float -> float -> void; + +} + diff --git a/test/cminor/qsort.cm b/test/cminor/qsort.cm new file mode 100644 index 0000000..004f8cd --- /dev/null +++ b/test/cminor/qsort.cm @@ -0,0 +1,30 @@ +"quicksort"(lo, hi, a): int -> int -> int -> void +{ + var i, j, pivot, temp; + + if (! (lo < hi)) return; + i = lo; + j = hi; + pivot = int32[a + hi * 4]; + {{ loop { + if (! (i < j)) exit; + {{ loop { + if (i >= hi || int32[a + i * 4] > pivot) exit; + i = i + 1; + } }} + {{ loop { + if (j <= lo || int32[a + j * 4] < pivot) exit; + j = j - 1; + } }} + if (i < j) { + temp = int32[a + i * 4]; + int32[a + i * 4] = int32[a + j * 4]; + int32[a + j * 4] = temp; + } + } }} + temp = int32[a + i * 4]; + int32[a + i * 4] = int32[a + hi * 4]; + int32[a + hi * 4] = temp; + "quicksort"(lo, i - 1, a) : int -> int -> int -> void; + "quicksort"(i + 1, hi, a) : int -> int -> int -> void; +} diff --git a/test/cminor/sha1.cmp b/test/cminor/sha1.cmp new file mode 100644 index 0000000..9a588e4 --- /dev/null +++ b/test/cminor/sha1.cmp @@ -0,0 +1,189 @@ +/* SHA-1 cryptographic hash function */ +/* Ref: Handbook of Applied Cryptography, section 9.4.2, algorithm 9.53 */ + +/* To be preprocessed by cpp -P */ + +#define ARCH_BIG_ENDIAN + +#define rol1(x) (((x) << 1) | ((x) >>u 31)) +#define rol5(x) (((x) << 5) | ((x) >>u 27)) +#define rol30(x) (((x) << 30) | ((x) >>u 2)) + +"SHA1_copy_and_swap"(src, dst, numwords) : int -> int -> int -> void +{ +#ifdef ARCH_BIG_ENDIAN + "memcpy_static"(dst, src, numwords * 4) : int -> int -> int -> void; +#else + var s, d, a, b; + s = src; + d = dst; + {{ loop { + if (numwords <= 0) exit; + a = int8u[s]; + b = int8u[s + 1]; + int8u[d] = int8u[s + 3]; + int8u[d + 1] = int8u[s + 2]; + int8u[d + 2] = b; + int8u[d + 3] = a; + s = s + 4; + d = d + 4; + numwords = numwords - 1; + } }} +#endif +} + +#define F(x,y,z) ( z ^ (x & (y ^ z) ) ) +#define G(x,y,z) ( (x & y) | (z & (x | y) ) ) +#define H(x,y,z) ( x ^ y ^ z ) + +#define Y1 0x5A827999 +#define Y2 0x6ED9EBA1 +#define Y3 0x8F1BBCDC +#define Y4 0xCA62C1D6 + +#define context_state(ctx,n) int32[ctx + n * 4] +#define context_length(ctx) ctx + 20 +#define context_length_hi(ctx) int32[ctx + 20] +#define context_length_lo(ctx) int32[ctx + 24] +#define context_numbytes(ctx) int32[ctx + 28] +#define context_buffer(ctx) (ctx + 32) +#define context_size 96 + +"SHA1_transform"(ctx) : int -> void +{ + stack 320 + var i, p, a, b, c, d, e, t; + + /* Convert buffer data to 16 big-endian integers */ + "SHA1_copy_and_swap"(context_buffer(ctx), &0, 16) : int -> int -> int -> void; + /* Expand into 80 integers */ + i = 16; + {{ loop { + if (! (i < 80)) exit; + p = &0 + i * 4; + t = int32[p - 12] ^ int32[p - 32] ^ int32[p - 56] ^ int32[p - 64]; + int32[p] = rol1(t); + i = i + 1; + } }} + + /* Initialize working variables */ + a = context_state(ctx, 0); + b = context_state(ctx, 1); + c = context_state(ctx, 2); + d = context_state(ctx, 3); + e = context_state(ctx, 4); + + /* Perform rounds */ + i = 0; + {{ loop { + if (! (i < 20)) exit; + t = F(b, c, d) + Y1 + rol5(a) + e + int32[&0 + i * 4]; + e = d; d = c; c = rol30(b); b = a; a = t; + i = i + 1; + } }} + {{ loop { + if (! (i < 40)) exit; + t = H(b, c, d) + Y2 + rol5(a) + e + int32[&0 + i * 4]; + e = d; d = c; c = rol30(b); b = a; a = t; + i = i + 1; + } }} + {{ loop { + if (! (i < 60)) exit; + t = G(b, c, d) + Y3 + rol5(a) + e + int32[&0 + i * 4]; + e = d; d = c; c = rol30(b); b = a; a = t; + i = i + 1; + } }} + {{ loop { + if (! (i < 80)) exit; + t = H(b, c, d) + Y4 + rol5(a) + e + int32[&0 + i * 4]; + e = d; d = c; c = rol30(b); b = a; a = t; + i = i + 1; + } }} + + /* Update chaining values */ + context_state(ctx, 0) = context_state(ctx, 0) + a; + context_state(ctx, 1) = context_state(ctx, 1) + b; + context_state(ctx, 2) = context_state(ctx, 2) + c; + context_state(ctx, 3) = context_state(ctx, 3) + d; + context_state(ctx, 4) = context_state(ctx, 4) + e; +} + +"SHA1_init"(ctx) : int -> void +{ + context_state(ctx, 0) = 0x67452301; + context_state(ctx, 1) = 0xEFCDAB89; + context_state(ctx, 2) = 0x98BADCFE; + context_state(ctx, 3) = 0x10325476; + context_state(ctx, 4) = 0xC3D2E1F0; + context_numbytes(ctx) = 0; + context_length_lo(ctx) = 0; + context_length_hi(ctx) = 0; +} + +"SHA1_add_data"(ctx, data, len) : int -> int -> int -> void +{ + var t; + + /* Update length */ + t = context_length_lo(ctx); + if ((context_length_lo(ctx) = t + (len << 3)) >u 29); + + /* If data was left in buffer, pad it with fresh data and munge block */ + if (context_numbytes(ctx) != 0) { + t = 64 - context_numbytes(ctx); + if (len int -> int -> void; + context_numbytes(ctx) = context_numbytes(ctx) + len; + return; + } + "memcpy_static"(context_buffer(ctx) + context_numbytes(ctx), data, t) + : int -> int -> int -> void; + "SHA1_transform"(ctx) : int -> void; + data = data + t; + len = len - t; + } + /* Munge data in 64-byte chunks */ + {{ loop { + if (! (len >=u 64)) exit; + "memcpy_static"(context_buffer(ctx), data, 64) + : int -> int -> int -> void; + "SHA1_transform"(ctx) : int -> void; + data = data + 64; + len = len - 64; + } }} + /* Save remaining data */ + "memcpy_static"(context_buffer(ctx), data, len) + : int -> int -> int -> void; + context_numbytes(ctx) = len; +} + +"SHA1_finish"(ctx, output) : int -> int -> void +{ + var i; + i = context_numbytes(ctx); + /* Set first char of padding to 0x80. There is always room. */ + int8u[context_buffer(ctx) + i] = 0x80; + i = i + 1; + /* If we do not have room for the length (8 bytes), pad to 64 bytes + with zeroes and munge the data block */ + if (i > 56) { + "memset_static"(context_buffer(ctx) + i, 0, 64 - i) + : int -> int -> int -> void; + "SHA1_transform"(ctx) : int -> void; + i = 0; + } + /* Pad to byte 56 with zeroes */ + "memset_static"(context_buffer(ctx) + i, 0, 56 - i) + : int -> int -> int -> void; + /* Add length in big-endian */ + "SHA1_copy_and_swap"(context_length(ctx), context_buffer(ctx) + 56, 2) + : int -> int -> int -> void; + /* Munge the final block */ + "SHA1_transform"(ctx) : int -> void; + /* Final hash value is in ctx->state modulo big-endian conversion */ + "SHA1_copy_and_swap"(ctx, output, 5) + : int -> int -> int -> void; +} -- cgit v1.2.3