git.iko.soy/Idris-dev
on master help sign in
Absolutely untested implementations of a few bitstring primitives.
7518b0cIrene Knapp
rts/Makefile+2−2
compare with master
unifiedsplit
@@ -1,7 +1,7 @@
1include ../config.mk
1include ../config.mk
2
2
3−OBJS = idris_rts.o idris_gc.o idris_gmp.o idris_stdfgn.o
3+OBJS = idris_rts.o idris_gc.o idris_gmp.o idris_stdfgn.o idris_bitstring.o
4−HDRS = idris_rts.h idris_gc.h idris_gmp.h idris_stdfgn.h
4+HDRS = idris_rts.h idris_gc.h idris_gmp.h idris_stdfgn.h idris_bitstring.h
5CFLAGS = -O2 -Wall
5CFLAGS = -O2 -Wall
6ifneq ($(GMP_INCLUDE_DIR),)
6ifneq ($(GMP_INCLUDE_DIR),)
7 CFLAGS += -isystem $(GMP_INCLUDE_DIR)
7 CFLAGS += -isystem $(GMP_INCLUDE_DIR)
rts/idris_bitstring.cnew file+327
@@ -0,0 +1,327 @@
1+#include "idris_rts.h"
2+
3+VAL idris_b8CopyForGC(VM *vm, VAL a) {
4+ VAL cl = allocate(vm, sizeof(Closure), 1);
5+ SETTY(cl, BITS8);
6+ cl->info.bits8 = a->info.bits8;
7+ return cl;
8+}
9+
10+VAL idris_b16CopyForGC(VM *vm, VAL a) {
11+ VAL cl = allocate(vm, sizeof(Closure), 1);
12+ SETTY(cl, BITS16);
13+ cl->info.bits16 = a->info.bits16;
14+ return cl;
15+}
16+
17+VAL idris_b32CopyForGC(VM *vm, VAL a) {
18+ VAL cl = allocate(vm, sizeof(Closure), 1);
19+ SETTY(cl, BITS32);
20+ cl->info.bits32 = a->info.bits32;
21+ return cl;
22+}
23+
24+VAL idris_b64CopyForGC(VM *vm, VAL a) {
25+ VAL cl = allocate(vm, sizeof(Closure), 1);
26+ SETTY(cl, BITS64);
27+ cl->info.bits64 = a->info.bits64;
28+ return cl;
29+}
30+
31+VAL idris_b8(VM *vm, VAL a) {
32+ VAL cl = allocate(vm, sizeof(Closure), 0);
33+ SETTY(cl, BITS8);
34+ cl->info.bits8 = (uint8_t) GETINT(a);
35+ return cl;
36+}
37+
38+VAL idris_b16(VM *vm, VAL a) {
39+ VAL cl = allocate(vm, sizeof(Closure), 0);
40+ SETTY(cl, BITS16);
41+ cl->info.bits16 = (uint16_t) GETINT(a);
42+ return cl;
43+}
44+
45+VAL idris_b32(VM *vm, VAL a) {
46+ VAL cl = allocate(vm, sizeof(Closure), 0);
47+ SETTY(cl, BITS32);
48+ cl->info.bits32 = (uint32_t) GETINT(a);
49+ return cl;
50+}
51+
52+VAL idris_b64(VM *vm, VAL a) {
53+ VAL cl = allocate(vm, sizeof(Closure), 0);
54+ SETTY(cl, BITS64);
55+ cl->info.bits64 = (uint64_t) GETINT(a);
56+ return cl;
57+}
58+
59+VAL idris_b8Plus(VM *vm, VAL a, VAL b) {
60+ VAL cl = allocate(vm, sizeof(Closure), 0);
61+ SETTY(cl, BITS8);
62+ cl->info.bits8 = a->info.bits8 + b->info.bits8;
63+ return cl;
64+}
65+
66+VAL idris_b8Minus(VM *vm, VAL a, VAL b) {
67+ VAL cl = allocate(vm, sizeof(Closure), 0);
68+ SETTY(cl, BITS8);
69+ cl->info.bits8 = a->info.bits8 - b->info.bits8;
70+ return cl;
71+}
72+
73+VAL idris_b8Times(VM *vm, VAL a, VAL b) {
74+ VAL cl = allocate(vm, sizeof(Closure), 0);
75+ SETTY(cl, BITS8);
76+ cl->info.bits8 = a->info.bits8 * b->info.bits8;
77+ return cl;
78+}
79+
80+VAL idris_b8UDiv(VM *vm, VAL a, VAL b) {
81+ VAL cl = allocate(vm, sizeof(Closure), 0);
82+ SETTY(cl, BITS8);
83+ cl->info.bits8 = a->info.bits8 / b->info.bits8;
84+ return cl;
85+}
86+
87+VAL idris_b8SDiv(VM *vm, VAL a, VAL b) {
88+ VAL cl = allocate(vm, sizeof(Closure), 0);
89+ SETTY(cl, BITS8);
90+ cl->info.bits8 = (uint8_t) (((int8_t) a->info.bits8) / ((int8_t) b->info.bits8));
91+ return cl;
92+}
93+
94+VAL idris_b8Z16(VM *vm, VAL a) {
95+ VAL cl = allocate(vm, sizeof(Closure), 0);
96+ SETTY(cl, BITS16);
97+ cl->info.bits16 = (uint16_t) a->info.bits8;
98+ return cl;
99+}
100+
101+VAL idris_b8Z32(VM *vm, VAL a) {
102+ VAL cl = allocate(vm, sizeof(Closure), 0);
103+ SETTY(cl, BITS32);
104+ cl->info.bits32 = (uint32_t) a->info.bits8;
105+ return cl;
106+}
107+
108+VAL idris_b8Z64(VM *vm, VAL a) {
109+ VAL cl = allocate(vm, sizeof(Closure), 0);
110+ SETTY(cl, BITS16);
111+ cl->info.bits64 = (uint64_t) a->info.bits8;
112+ return cl;
113+}
114+
115+VAL idris_b8S16(VM *vm, VAL a) {
116+ VAL cl = allocate(vm, sizeof(Closure), 0);
117+ SETTY(cl, BITS16);
118+ cl->info.bits16 = (uint16_t) (int16_t) (int8_t) a->info.bits8;
119+ return cl;
120+}
121+
122+VAL idris_b8S32(VM *vm, VAL a) {
123+ VAL cl = allocate(vm, sizeof(Closure), 0);
124+ SETTY(cl, BITS32);
125+ cl->info.bits32 = (uint32_t) (int32_t) (int8_t) a->info.bits8;
126+ return cl;
127+}
128+
129+VAL idris_b8S64(VM *vm, VAL a) {
130+ VAL cl = allocate(vm, sizeof(Closure), 0);
131+ SETTY(cl, BITS64);
132+ cl->info.bits64 = (uint64_t) (int64_t) (int8_t) a->info.bits8;
133+ return cl;
134+}
135+
136+VAL idris_b16Plus(VM *vm, VAL a, VAL b) {
137+ VAL cl = allocate(vm, sizeof(Closure), 0);
138+ SETTY(cl, BITS16);
139+ cl->info.bits16 = a->info.bits16 + b->info.bits16;
140+ return cl;
141+}
142+
143+VAL idris_b16Minus(VM *vm, VAL a, VAL b) {
144+ VAL cl = allocate(vm, sizeof(Closure), 0);
145+ SETTY(cl, BITS16);
146+ cl->info.bits16 = a->info.bits16 - b->info.bits16;
147+ return cl;
148+}
149+
150+VAL idris_b16Times(VM *vm, VAL a, VAL b) {
151+ VAL cl = allocate(vm, sizeof(Closure), 0);
152+ SETTY(cl, BITS16);
153+ cl->info.bits16 = a->info.bits16 * b->info.bits16;
154+ return cl;
155+}
156+
157+VAL idris_b16UDiv(VM *vm, VAL a, VAL b) {
158+ VAL cl = allocate(vm, sizeof(Closure), 0);
159+ SETTY(cl, BITS16);
160+ cl->info.bits16 = a->info.bits16 / b->info.bits16;
161+ return cl;
162+}
163+
164+VAL idris_b16SDiv(VM *vm, VAL a, VAL b) {
165+ VAL cl = allocate(vm, sizeof(Closure), 0);
166+ SETTY(cl, BITS16);
167+ cl->info.bits16 =
168+ (uint16_t) (((int16_t) a->info.bits16) / ((int16_t) b->info.bits16));
169+ return cl;
170+}
171+
172+VAL idris_b16Z32(VM *vm, VAL a) {
173+ VAL cl = allocate(vm, sizeof(Closure), 0);
174+ SETTY(cl, BITS32);
175+ cl->info.bits32 = (uint32_t) a->info.bits16;
176+ return cl;
177+}
178+
179+VAL idris_b16Z64(VM *vm, VAL a) {
180+ VAL cl = allocate(vm, sizeof(Closure), 0);
181+ SETTY(cl, BITS64);
182+ cl->info.bits64 = (uint64_t) a->info.bits16;
183+ return cl;
184+}
185+
186+VAL idris_b16S32(VM *vm, VAL a) {
187+ VAL cl = allocate(vm, sizeof(Closure), 0);
188+ SETTY(cl, BITS32);
189+ cl->info.bits32 = (uint32_t) (int32_t) (int16_t) a->info.bits16;
190+ return cl;
191+}
192+
193+VAL idris_b16S64(VM *vm, VAL a) {
194+ VAL cl = allocate(vm, sizeof(Closure), 0);
195+ SETTY(cl, BITS64);
196+ cl->info.bits64 = (uint64_t) (int64_t) (int16_t) a->info.bits16;
197+ return cl;
198+}
199+
200+VAL idris_b16T8(VM *vm, VAL a) {
201+ VAL cl = allocate(vm, sizeof(Closure), 0);
202+ SETTY(cl, BITS8);
203+ cl->info.bits8 = (uint8_t) a->info.bits16;
204+ return cl;
205+}
206+
207+VAL idris_b32Plus(VM *vm, VAL a, VAL b) {
208+ VAL cl = allocate(vm, sizeof(Closure), 0);
209+ SETTY(cl, BITS32);
210+ cl->info.bits32 = a->info.bits32 + b->info.bits32;
211+ return cl;
212+}
213+
214+VAL idris_b32Minus(VM *vm, VAL a, VAL b) {
215+ VAL cl = allocate(vm, sizeof(Closure), 0);
216+ SETTY(cl, BITS32);
217+ cl->info.bits32 = a->info.bits32 - b->info.bits32;
218+ return cl;
219+}
220+
221+VAL idris_b32Times(VM *vm, VAL a, VAL b) {
222+ VAL cl = allocate(vm, sizeof(Closure), 0);
223+ SETTY(cl, BITS32);
224+ cl->info.bits32 = a->info.bits32 * b->info.bits32;
225+ return cl;
226+}
227+
228+VAL idris_b32UDiv(VM *vm, VAL a, VAL b) {
229+ VAL cl = allocate(vm, sizeof(Closure), 0);
230+ SETTY(cl, BITS32);
231+ cl->info.bits32 = a->info.bits32 / b->info.bits32;
232+ return cl;
233+}
234+
235+VAL idris_b32SDiv(VM *vm, VAL a, VAL b) {
236+ VAL cl = allocate(vm, sizeof(Closure), 0);
237+ SETTY(cl, BITS32);
238+ cl->info.bits32 =
239+ (uint32_t) (((int32_t) a->info.bits32) / ((int32_t) b->info.bits32));
240+ return cl;
241+}
242+
243+VAL idris_b32Z64(VM *vm, VAL a) {
244+ VAL cl = allocate(vm, sizeof(Closure), 0);
245+ SETTY(cl, BITS64);
246+ cl->info.bits64 = (uint64_t) a->info.bits32;
247+ return cl;
248+}
249+
250+VAL idris_b32S64(VM *vm, VAL a) {
251+ VAL cl = allocate(vm, sizeof(Closure), 0);
252+ SETTY(cl, BITS64);
253+ cl->info.bits64 = (uint64_t) (int64_t) (int32_t) a->info.bits32;
254+ return cl;
255+}
256+
257+VAL idris_b32T8(VM *vm, VAL a) {
258+ VAL cl = allocate(vm, sizeof(Closure), 0);
259+ SETTY(cl, BITS8);
260+ cl->info.bits8 = (uint8_t) a->info.bits32;
261+ return cl;
262+}
263+
264+VAL idris_b32T16(VM *vm, VAL a) {
265+ VAL cl = allocate(vm, sizeof(Closure), 0);
266+ SETTY(cl, BITS16);
267+ cl->info.bits16 = (uint16_t) a->info.bits32;
268+ return cl;
269+}
270+
271+VAL idris_b64Plus(VM *vm, VAL a, VAL b) {
272+ VAL cl = allocate(vm, sizeof(Closure), 0);
273+ SETTY(cl, BITS64);
274+ cl->info.bits64 = a->info.bits64 + b->info.bits64;
275+ return cl;
276+}
277+
278+VAL idris_b64Minus(VM *vm, VAL a, VAL b) {
279+ VAL cl = allocate(vm, sizeof(Closure), 0);
280+ SETTY(cl, BITS64);
281+ cl->info.bits64 = a->info.bits64 - b->info.bits64;
282+ return cl;
283+}
284+
285+VAL idris_b64Times(VM *vm, VAL a, VAL b) {
286+ VAL cl = allocate(vm, sizeof(Closure), 0);
287+ SETTY(cl, BITS64);
288+ cl->info.bits64 = a->info.bits64 * b->info.bits64;
289+ return cl;
290+}
291+
292+VAL idris_b64UDiv(VM *vm, VAL a, VAL b) {
293+ VAL cl = allocate(vm, sizeof(Closure), 0);
294+ SETTY(cl, BITS64);
295+ cl->info.bits64 = a->info.bits64 / b->info.bits64;
296+ return cl;
297+}
298+
299+VAL idris_b64SDiv(VM *vm, VAL a, VAL b) {
300+ VAL cl = allocate(vm, sizeof(Closure), 0);
301+ SETTY(cl, BITS64);
302+ cl->info.bits64 =
303+ (uint64_t) (((int64_t) a->info.bits64) / ((int64_t) b->info.bits64));
304+ return cl;
305+}
306+
307+VAL idris_b64T8(VM *vm, VAL a) {
308+ VAL cl = allocate(vm, sizeof(Closure), 0);
309+ SETTY(cl, BITS8);
310+ cl->info.bits8 = (uint8_t) a->info.bits64;
311+ return cl;
312+}
313+
314+VAL idris_b64T16(VM *vm, VAL a) {
315+ VAL cl = allocate(vm, sizeof(Closure), 0);
316+ SETTY(cl, BITS16);
317+ cl->info.bits16 = (uint16_t) a->info.bits64;
318+ return cl;
319+}
320+
321+VAL idris_b64T32(VM *vm, VAL a) {
322+ VAL cl = allocate(vm, sizeof(Closure), 0);
323+ SETTY(cl, BITS32);
324+ cl->info.bits32 = (uint32_t) a->info.bits64;
325+ return cl;
326+}
327+
rts/idris_bitstring.hnew file+60
@@ -0,0 +1,60 @@
1+#ifndef _IDRISBITSTRING_H
2+#define _IDRISBITSTRING_H
3+
4+VAL idris_b8CopyForGC(VM *vm, VAL a);
5+VAL idris_b16CopyForGC(VM *vm, VAL a);
6+VAL idris_b32CopyForGC(VM *vm, VAL a);
7+VAL idris_b64CopyForGC(VM *vm, VAL a);
8+
9+VAL idris_b8(VM *vm, VAL a);
10+VAL idris_b16(VM *vm, VAL a);
11+VAL idris_b32(VM *vm, VAL a);
12+VAL idris_b64(VM *vm, VAL a);
13+
14+VAL idris_b8Plus(VM *vm, VAL a, VAL b);
15+VAL idris_b8Minus(VM *vm, VAL a, VAL b);
16+VAL idris_b8Times(VM *vm, VAL a, VAL b);
17+VAL idris_b8UDiv(VM *vm, VAL a, VAL b);
18+VAL idris_b8SDiv(VM *vm, VAL a, VAL b);
19+
20+VAL idris_b8Z16(VM *vm, VAL a);
21+VAL idris_b8Z32(VM *vm, VAL a);
22+VAL idris_b8Z64(VM *vm, VAL a);
23+VAL idris_b8S16(VM *vm, VAL a);
24+VAL idris_b8S32(VM *vm, VAL a);
25+VAL idris_b8S64(VM *vm, VAL a);
26+
27+VAL idris_b16Plus(VM *vm, VAL a, VAL b);
28+VAL idris_b16Minus(VM *vm, VAL a, VAL b);
29+VAL idris_b16Times(VM *vm, VAL a, VAL b);
30+VAL idris_b16UDiv(VM *vm, VAL a, VAL b);
31+VAL idris_b16SDiv(VM *vm, VAL a, VAL b);
32+
33+VAL idris_b16Z32(VM *vm, VAL a);
34+VAL idris_b16Z64(VM *vm, VAL a);
35+VAL idris_b16S32(VM *vm, VAL a);
36+VAL idris_b16S64(VM *vm, VAL a);
37+VAL idris_b16T8(VM *vm, VAL a);
38+
39+VAL idris_b32Plus(VM *vm, VAL a, VAL b);
40+VAL idris_b32Minus(VM *vm, VAL a, VAL b);
41+VAL idris_b32Times(VM *vm, VAL a, VAL b);
42+VAL idris_b32UDiv(VM *vm, VAL a, VAL b);
43+VAL idris_b32SDiv(VM *vm, VAL a, VAL b);
44+
45+VAL idris_b32Z64(VM *vm, VAL a);
46+VAL idris_b32S64(VM *vm, VAL a);
47+VAL idris_b32T8(VM *vm, VAL a);
48+VAL idris_b32T16(VM *vm, VAL a);
49+
50+VAL idris_b64Plus(VM *vm, VAL a, VAL b);
51+VAL idris_b64Minus(VM *vm, VAL a, VAL b);
52+VAL idris_b64Times(VM *vm, VAL a, VAL b);
53+VAL idris_b64UDiv(VM *vm, VAL a, VAL b);
54+VAL idris_b64SDiv(VM *vm, VAL a, VAL b);
55+
56+VAL idris_b64T8(VM *vm, VAL a);
57+VAL idris_b64T16(VM *vm, VAL a);
58+VAL idris_b64T32(VM *vm, VAL a);
59+
60+#endif
rts/idris_gc.c+12
@@ -29,6 +29,18 @@ VAL copy(VM* vm, VAL x) {
29 case PTR:
29 case PTR:
30 cl = MKPTRc(vm, x->info.ptr);
30 cl = MKPTRc(vm, x->info.ptr);
31 break;
31 break;
32+ case BITS8:
33+ cl = idris_b8CopyForGC(vm, x);
34+ break;
35+ case BITS16:
36+ cl = idris_b16CopyForGC(vm, x);
37+ break;
38+ case BITS32:
39+ cl = idris_b32CopyForGC(vm, x);
40+ break;
41+ case BITS64:
42+ cl = idris_b64CopyForGC(vm, x);
43+ break;
32 case FWD:
44 case FWD:
33 return x->info.ptr;
45 return x->info.ptr;
34 default:
46 default:
rts/idris_rts.c+12
@@ -444,6 +444,18 @@ VAL copyTo(VM* vm, VAL x) {
444 case PTR:
444 case PTR:
445 cl = MKPTRc(vm, x->info.ptr);
445 cl = MKPTRc(vm, x->info.ptr);
446 break;
446 break;
447+ case BITS8:
448+ cl = idris_b8CopyForGC(vm, x);
449+ break;
450+ case BITS16:
451+ cl = idris_b16CopyForGC(vm, x);
452+ break;
453+ case BITS32:
454+ cl = idris_b32CopyForGC(vm, x);
455+ break;
456+ case BITS64:
457+ cl = idris_b64CopyForGC(vm, x);
458+ break;
447 default:
459 default:
448 assert(0); // We're in trouble if this happens...
460 assert(0); // We're in trouble if this happens...
449 }
461 }
rts/idris_rts.h+6−1
@@ -7,11 +7,12 @@
7#include <unistd.h>
7#include <unistd.h>
8#include <stdarg.h>
8#include <stdarg.h>
9#include <pthread.h>
9#include <pthread.h>
10+#include <stdint.h>
10
11
11// Closures
12// Closures
12
13
13typedef enum {
14typedef enum {
14− CON, INT, BIGINT, FLOAT, STRING, UNIT, PTR, FWD
15+ CON, INT, BIGINT, FLOAT, STRING, BITS8, BITS16, BITS32, BITS64, UNIT, PTR, FWD
15} ClosureType;
16} ClosureType;
16
17
17typedef struct Closure *VAL;
18typedef struct Closure *VAL;
@@ -31,6 +32,10 @@ typedef struct Closure {
31 double f;
32 double f;
32 char* str;
33 char* str;
33 void* ptr;
34 void* ptr;
35+ uint8_t bits8;
36+ uint16_t bits16;
37+ uint32_t bits32;
38+ uint64_t bits64;
34 } info;
39 } info;
35} Closure;
40} Closure;
36
41
src/IRTS/CodegenC.hs+66
@@ -297,6 +297,72 @@ doOp v LReadStr [x] = v ++ "idris_readStr(vm, GETPTR(" ++ creg x ++ "))"
297doOp _ LPrintNum [x] = "printf(\"%ld\\n\", GETINT(" ++ creg x ++ "))"
297doOp _ LPrintNum [x] = "printf(\"%ld\\n\", GETINT(" ++ creg x ++ "))"
298doOp _ LPrintStr [x] = "fputs(GETSTR(" ++ creg x ++ "), stdout)"
298doOp _ LPrintStr [x] = "fputs(GETSTR(" ++ creg x ++ "), stdout)"
299
299
300+doOp v LB8 [x] = v ++ "idris_b8(" ++ creg x ++ ")"
301+doOp v LB16 [x] = v ++ "idris_b16(" ++ creg x ++ ")"
302+doOp v LB32 [x] = v ++ "idris_b32(" ++ creg x ++ ")"
303+doOp v LB64 [x] = v ++ "idris_b64(" ++ creg x ++ ")"
304+
305+doOp v LB8Plus [x, y] = v ++ "idris_b8Plus(" ++ creg x ++ "," ++ creg y ++ ")"
306+doOp v LB8Minus [x, y] = v ++ "idris_b8Minus(" ++ creg x ++ "," ++ creg y ++ ")"
307+doOp v LB8Times [x, y] = v ++ "idris_b8Times(" ++ creg x ++ "," ++ creg y ++ ")"
308+doOp v LB8UDiv [x, y] = v ++ "idris_b8UDiv(" ++ creg x ++ "," ++ creg y ++ ")"
309+doOp v LB8SDiv [x, y] = v ++ "idris_b8SDiv(" ++ creg x ++ "," ++ creg y ++ ")"
310+
311+doOp v LB8Z16 [x] = v ++ "idris_b8Z16(" ++ creg x ++ ")"
312+doOp v LB8Z32 [x] = v ++ "idris_b8Z32(" ++ creg x ++ ")"
313+doOp v LB8Z64 [x] = v ++ "idris_b8Z64(" ++ creg x ++ ")"
314+doOp v LB8S16 [x] = v ++ "idris_b8S16(" ++ creg x ++ ")"
315+doOp v LB8S32 [x] = v ++ "idris_b8S32(" ++ creg x ++ ")"
316+doOp v LB8S64 [x] = v ++ "idris_b8S64(" ++ creg x ++ ")"
317+
318+doOp v LB16Plus [x, y] =
319+ v ++ "idris_b16Plus(" ++ creg x ++ "," ++ creg y ++ ")"
320+doOp v LB16Minus [x, y] =
321+ v ++ "idris_b16Minus(" ++ creg x ++ "," ++ creg y ++ ")"
322+doOp v LB16Times [x, y] =
323+ v ++ "idris_b16Times(" ++ creg x ++ "," ++ creg y ++ ")"
324+doOp v LB16UDiv [x, y] =
325+ v ++ "idris_b16UDiv(" ++ creg x ++ "," ++ creg y ++ ")"
326+doOp v LB16SDiv [x, y] =
327+ v ++ "idris_b16SDiv(" ++ creg x ++ "," ++ creg y ++ ")"
328+
329+doOp v LB16Z32 [x] = v ++ "idris_b16Z32(" ++ creg x ++ ")"
330+doOp v LB16Z64 [x] = v ++ "idris_b16Z64(" ++ creg x ++ ")"
331+doOp v LB16S32 [x] = v ++ "idris_b16S32(" ++ creg x ++ ")"
332+doOp v LB16S64 [x] = v ++ "idris_b16S64(" ++ creg x ++ ")"
333+doOp v LB16T8 [x] = v ++ "idris_b16T8(" ++ creg x ++ ")"
334+
335+doOp v LB32Plus [x, y] =
336+ v ++ "idris_b32Plus(" ++ creg x ++ "," ++ creg y ++ ")"
337+doOp v LB32Minus [x, y] =
338+ v ++ "idris_b32Minus(" ++ creg x ++ "," ++ creg y ++ ")"
339+doOp v LB32Times [x, y] =
340+ v ++ "idris_b32Times(" ++ creg x ++ "," ++ creg y ++ ")"
341+doOp v LB32UDiv [x, y] =
342+ v ++ "idris_b32UDiv(" ++ creg x ++ "," ++ creg y ++ ")"
343+doOp v LB32SDiv [x, y] =
344+ v ++ "idris_b32SDiv(" ++ creg x ++ "," ++ creg y ++ ")"
345+
346+doOp v LB32Z64 [x] = v ++ "idris_b32Z64(" ++ creg x ++ ")"
347+doOp v LB32S64 [x] = v ++ "idris_b32S64(" ++ creg x ++ ")"
348+doOp v LB32T8 [x] = v ++ "idris_b32T8(" ++ creg x ++ ")"
349+doOp v LB32T16 [x] = v ++ "idris_b32T16(" ++ creg x ++ ")"
350+
351+doOp v LB64Plus [x, y] =
352+ v ++ "idris_b64Plus(" ++ creg x ++ "," ++ creg y ++ ")"
353+doOp v LB64Minus [x, y] =
354+ v ++ "idris_b64Minus(" ++ creg x ++ "," ++ creg y ++ ")"
355+doOp v LB64Times [x, y] =
356+ v ++ "idris_b64Times(" ++ creg x ++ "," ++ creg y ++ ")"
357+doOp v LB64UDiv [x, y] =
358+ v ++ "idris_b64UDiv(" ++ creg x ++ "," ++ creg y ++ ")"
359+doOp v LB64SDiv [x, y] =
360+ v ++ "idris_b64SDiv(" ++ creg x ++ "," ++ creg y ++ ")"
361+
362+doOp v LB64T8 [x] = v ++ "idris_b64T8(" ++ creg x ++ ")"
363+doOp v LB64T16 [x] = v ++ "idris_b64T16(" ++ creg x ++ ")"
364+doOp v LB64T32 [x] = v ++ "idris_b64T32(" ++ creg x ++ ")"
365+
300doOp v LFExp [x] = v ++ "MKFLOAT(exp(GETFLOAT(" ++ creg x ++ ")))"
366doOp v LFExp [x] = v ++ "MKFLOAT(exp(GETFLOAT(" ++ creg x ++ ")))"
301doOp v LFLog [x] = v ++ "MKFLOAT(log(GETFLOAT(" ++ creg x ++ ")))"
367doOp v LFLog [x] = v ++ "MKFLOAT(log(GETFLOAT(" ++ creg x ++ ")))"
302doOp v LFSin [x] = v ++ "MKFLOAT(sin(GETFLOAT(" ++ creg x ++ ")))"
368doOp v LFSin [x] = v ++ "MKFLOAT(sin(GETFLOAT(" ++ creg x ++ ")))"
src/IRTS/Lang.hs+2−2
@@ -40,14 +40,14 @@ data PrimFn = LPlus | LMinus | LTimes | LDiv | LMod
40 | LIntBig | LBigInt | LStrBig | LBigStr
40 | LIntBig | LBigInt | LStrBig | LBigStr
41 | LPrintNum | LPrintStr | LReadStr
41 | LPrintNum | LPrintStr | LReadStr
42
42
43− | LB8 | LB16
43+ | LB8 | LB16 | LB32 | LB64
44
44
45 | LB8Plus | LB8Minus | LB8Times | LB8UDiv | LB8SDiv
45 | LB8Plus | LB8Minus | LB8Times | LB8UDiv | LB8SDiv
46 | LB8Z16 | LB8Z32 | LB8Z64 | LB8S16 | LB8S32 | LB8S64 -- Zero/Sign extension
46 | LB8Z16 | LB8Z32 | LB8Z64 | LB8S16 | LB8S32 | LB8S64 -- Zero/Sign extension
47 | LB16Plus | LB16Minus | LB16Times | LB16UDiv | LB16SDiv
47 | LB16Plus | LB16Minus | LB16Times | LB16UDiv | LB16SDiv
48 | LB16Z32 | LB16Z64 | LB16S32 | LB16S64 | LB16T8 -- and Truncation
48 | LB16Z32 | LB16Z64 | LB16S32 | LB16S64 | LB16T8 -- and Truncation
49 | LB32Plus | LB32Minus | LB32Times | LB32UDiv | LB32SDiv
49 | LB32Plus | LB32Minus | LB32Times | LB32UDiv | LB32SDiv
50− | LB32Z64 | LB32S32 | LB32T8 | LB32T16
50+ | LB32Z64 | LB32S64 | LB32T8 | LB32T16
51 | LB64Plus | LB64Minus | LB64Times | LB64UDiv | LB64SDiv
51 | LB64Plus | LB64Minus | LB64Times | LB64UDiv | LB64SDiv
52 | LB64T8 | LB64T16 | LB64T32
52 | LB64T8 | LB64T16 | LB64T32
53
53
src/Idris/Primitives.hs+8
@@ -161,6 +161,10 @@ primitives =
161 (1, LB8) total,
161 (1, LB8) total,
162 Prim (UN "prim__intToBits16") (ty [IType] B16Type) 1 intToBits16
162 Prim (UN "prim__intToBits16") (ty [IType] B16Type) 1 intToBits16
163 (1, LB16) total,
163 (1, LB16) total,
164+ Prim (UN "prim__intToBits32") (ty [IType] B32Type) 1 intToBits32
165+ (1, LB32) total,
166+ Prim (UN "prim__intToBits64") (ty [IType] B64Type) 1 intToBits64
167+ (1, LB64) total,
164
168
165 Prim (UN "prim__addBigInt") (ty [BIType, BIType] BIType) 2 (bBin (+))
169 Prim (UN "prim__addBigInt") (ty [BIType, BIType] BIType) 2 (bBin (+))
166 (2, LBPlus) total,
170 (2, LBPlus) total,
@@ -400,6 +404,10 @@ intToBits8 [VConstant (I x)] = Just $ toB8 x
400intToBits8 _ = Nothing
404intToBits8 _ = Nothing
401intToBits16 [VConstant (I x)] = Just $ toB16 x
405intToBits16 [VConstant (I x)] = Just $ toB16 x
402intToBits16 _ = Nothing
406intToBits16 _ = Nothing
407+intToBits32 [VConstant (I x)] = Just $ toB32 x
408+intToBits32 _ = Nothing
409+intToBits64 [VConstant (I x)] = Just $ toB64 x
410+intToBits64 _ = Nothing
403
411
404c_intToStr [VConstant (I x)] = Just $ VConstant (Str (show x))
412c_intToStr [VConstant (I x)] = Just $ VConstant (Str (show x))
405c_intToStr _ = Nothing
413c_intToStr _ = Nothing