7518b0c · Idris-dev · git.iko.soy

git.iko.soy/Idris-dev

Absolutely untested implementations of a few bitstring primitives.

commit7518b0c18bfc76bd3ad11f79ad7b8f2932bc7076 authorIrene Knapp <irene.knapp@icloud.com> dateThu 20 Dec 2012, 16:42 (14 years ago) parentb896224

9 files changed+495−5

compare with master

unifiedsplit

rts/Makefile+2−2 rts/idris_bitstring.c+327 rts/idris_bitstring.h+60 rts/idris_gc.c+12 rts/idris_rts.c+12 rts/idris_rts.h+6−1 src/IRTS/CodegenC.hs+66 src/IRTS/Lang.hs+2−2 src/Idris/Primitives.hs+8

rts/Makefile+2−2

@@ -1,7 +1,7 @@

11include ../config.mk

3−OBJS = idris_rts.o idris_gc.o idris_gmp.o idris_stdfgn.o

4−HDRS = idris_rts.h idris_gc.h idris_gmp.h idris_stdfgn.h

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 idris_bitstring.h

55CFLAGS = -O2 -Wall

66ifneq ($(GMP_INCLUDE_DIR),)

77 CFLAGS += -isystem $(GMP_INCLUDE_DIR)

rts/idris_bitstring.cnew file+327

@@ -0,0 +1,327 @@

1+#include "idris_rts.h"

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+}

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

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);

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) {

2929 case PTR:

3030 cl = MKPTRc(vm, x->info.ptr);

3131 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;

3244 case FWD:

3345 return x->info.ptr;

3446 default:

rts/idris_rts.c+12

@@ -444,6 +444,18 @@ VAL copyTo(VM* vm, VAL x) {

444444 case PTR:

445445 cl = MKPTRc(vm, x->info.ptr);

446446 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;

447459 default:

448460 assert(0); // We're in trouble if this happens...

449461 }

rts/idris_rts.h+6−1

@@ -7,11 +7,12 @@

77#include <unistd.h>

88#include <stdarg.h>

99#include <pthread.h>

10+#include <stdint.h>

1011

1112// Closures

1213

1314typedef enum {

14− CON, INT, BIGINT, FLOAT, STRING, UNIT, PTR, FWD

15+ CON, INT, BIGINT, FLOAT, STRING, BITS8, BITS16, BITS32, BITS64, UNIT, PTR, FWD

1516} ClosureType;

1617

1718typedef struct Closure *VAL;

@@ -31,6 +32,10 @@ typedef struct Closure {

3132 double f;

3233 char* str;

3334 void* ptr;

35+ uint8_t bits8;

36+ uint16_t bits16;

37+ uint32_t bits32;

38+ uint64_t bits64;

3439 } info;

3540} Closure;

3641

src/IRTS/CodegenC.hs+66

@@ -297,6 +297,72 @@ doOp v LReadStr [x] = v ++ "idris_readStr(vm, GETPTR(" ++ creg x ++ "))"

297297doOp _ LPrintNum [x] = "printf(\"%ld\\n\", GETINT(" ++ creg x ++ "))"

298298doOp _ LPrintStr [x] = "fputs(GETSTR(" ++ creg x ++ "), stdout)"

299299

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+

300366doOp v LFExp [x] = v ++ "MKFLOAT(exp(GETFLOAT(" ++ creg x ++ ")))"

301367doOp v LFLog [x] = v ++ "MKFLOAT(log(GETFLOAT(" ++ creg x ++ ")))"

302368doOp 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

4040 | LIntBig | LBigInt | LStrBig | LBigStr

4141 | LPrintNum | LPrintStr | LReadStr

4242

43− | LB8 | LB16

43+ | LB8 | LB16 | LB32 | LB64

4444

4646 | LB8Z16 | LB8Z32 | LB8Z64 | LB8S16 | LB8S32 | LB8S64 -- Zero/Sign extension

4848 | LB16Z32 | LB16Z64 | LB16S32 | LB16S64 | LB16T8 -- and Truncation

50− | LB32Z64 | LB32S32 | LB32T8 | LB32T16

50+ | LB32Z64 | LB32S64 | LB32T8 | LB32T16

5252 | LB64T8 | LB64T16 | LB64T32

5353

src/Idris/Primitives.hs+8

@@ -161,6 +161,10 @@ primitives =

161161 (1, LB8) total,

162162 Prim (UN "prim__intToBits16") (ty [IType] B16Type) 1 intToBits16

163163 (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,

164168

165169 Prim (UN "prim__addBigInt") (ty [BIType, BIType] BIType) 2 (bBin (+))

166170 (2, LBPlus) total,

@@ -400,6 +404,10 @@ intToBits8 [VConstant (I x)] = Just $ toB8 x

400404intToBits8 _ = Nothing

401405intToBits16 [VConstant (I x)] = Just $ toB16 x

402406intToBits16 _ = Nothing

407+intToBits32 [VConstant (I x)] = Just $ toB32 x

408+intToBits32 _ = Nothing

409+intToBits64 [VConstant (I x)] = Just $ toB64 x

410+intToBits64 _ = Nothing

403411

404412c_intToStr [VConstant (I x)] = Just $ VConstant (Str (show x))

405413c_intToStr _ = Nothing