33d367d · Idris-dev · git.iko.soy

git.iko.soy/Idris-dev

on master help sign in

Merge pull request #4429 from jacereda/master-unboxed-bits8-bits16

33d367dNiklas Larsson8 years ago

rts/idris_bitstring.c+2−8

compare with master

unifiedsplit

@@ -3,17 +3,11 @@

3#include "idris_rts.h"

5VAL idris_b8const(VM *vm, uint8_t a) {

6− Bits8 * cl = iallocate(vm, sizeof(*cl), 0);

6+ return MKINT(a);

7− SETTY(cl, CT_BITS8);

8− cl->bits8 = a;

9− return (VAL)cl;

10}

12VAL idris_b16const(VM *vm, uint16_t a) {

9VAL idris_b16const(VM *vm, uint16_t a) {

13− Bits16 * cl = iallocate(vm, sizeof(*cl), 0);

10+ return MKINT(a);

14− SETTY(cl, CT_BITS16);

15− cl->bits16 = a;

16− return (VAL)cl;

17}

11}

19VAL idris_b32const(VM *vm, uint32_t a) {

13VAL idris_b32const(VM *vm, uint32_t a) {

rts/idris_gc.c+15−9

@@ -4,17 +4,27 @@

4#include "idris_bitstring.h"

5#include <assert.h>

7+static inline VAL copy_plain(VM* vm, VAL x, size_t sz) {

8+ VAL cl = iallocate(vm, sz, 1);

9+ memcpy(cl, x, sz);

10+ return cl;

11+}

12+

7VAL copy(VM* vm, VAL x) {

13VAL copy(VM* vm, VAL x) {

8 int ar;

14 int ar;

9 VAL cl;

15 VAL cl;

10− if (x==NULL || ISINT(x)) {

16+ if (x==NULL) {

11 return x;

17 return x;

12 }

18 }

13 switch(GETTY(x)) {

19 switch(GETTY(x)) {

20+ case CT_INT: return x;

21+ case CT_BITS32: return copy_plain(vm, x, sizeof(Bits32));

22+ case CT_BITS64: return copy_plain(vm, x, sizeof(Bits64));

23+ case CT_FLOAT: return copy_plain(vm, x, sizeof(Float));

14 case CT_FWD:

24 case CT_FWD:

15 return GETPTR(x);

25 return GETPTR(x);

16 case CT_CDATA:

26 case CT_CDATA:

17− cl = MKCDATAc(vm, GETCDATA(x));

27+ cl = copy_plain(vm, x, sizeof(CDataC));

18 c_heap_mark_item(GETCDATA(x));

28 c_heap_mark_item(GETCDATA(x));

19 break;

29 break;

20 case CT_BIGINT:

30 case CT_BIGINT:

@@ -29,22 +39,18 @@ VAL copy(VM* vm, VAL x) {

29 case CT_ARRAY:

39 case CT_ARRAY:

30 case CT_STRING:

40 case CT_STRING:

31 case CT_REF:

41 case CT_REF:

32− case CT_FLOAT:

33 case CT_STROFFSET:

42 case CT_STROFFSET:

34 case CT_PTR:

43 case CT_PTR:

35 case CT_MANAGEDPTR:

44 case CT_MANAGEDPTR:

36− case CT_BITS8:

37− case CT_BITS16:

38− case CT_BITS32:

39− case CT_BITS64:

40 case CT_RAWDATA:

45 case CT_RAWDATA:

41− cl = iallocate(vm, x->hdr.sz, 1);

46+ cl = copy_plain(vm, x, x->hdr.sz);

42− memcpy(cl, x, x->hdr.sz);

43 break;

47 break;

44 default:

48 default:

45 cl = NULL;

49 cl = NULL;

50+ assert(0);

46 break;

51 break;

47 }

52 }

53+ assert(x->hdr.sz >= sizeof(Fwd));

48 SETTY(x, CT_FWD);

54 SETTY(x, CT_FWD);

49 ((Fwd*)x)->fwd = cl;

55 ((Fwd*)x)->fwd = cl;

50 return cl;

56 return cl;

rts/idris_gmp.c+10−10

@@ -67,17 +67,17 @@ VAL MKBIGSI(VM* vm, signed long val) {

67}

69static BigInt * getbig(VM * vm, VAL x) {

70− if (ISINT(x)) {

70+ switch(GETTY(x)) {

71+ case CT_INT:

72+ {

71− BigInt * cl = allocBig(vm);

73+ BigInt * cl = allocBig(vm);

72− mpz_set_si(*getmpz(cl), GETINT(x));

74+ mpz_set_si(*getmpz(cl), GETINT(x));

73− return cl;

75+ return cl;

74− } else {

75− switch(GETTY(x)) {

76− case CT_FWD:

77− return getbig(vm, ((Fwd*)x)->fwd);

78− default:

79− return (BigInt*)x;

80 }

76 }

77+ case CT_FWD:

78+ return getbig(vm, ((Fwd*)x)->fwd);

79+ default:

80+ return (BigInt*)x;

81 }

82}

rts/idris_rts.c+12−24

@@ -209,7 +209,7 @@ void * allocate(size_t sz, int lock) {

209}

210

211void* iallocate(VM * vm, size_t isize, int outerlock) {

212−// return malloc(size);

212+// return malloc(isize);

213 size_t size = aligned(isize);

214

215#ifdef HAS_PTHREAD

@@ -364,17 +364,11 @@ VAL MKMPTRc(VM* vm, void* ptr, size_t size) {

364}

365

366VAL MKB8(VM* vm, uint8_t bits8) {

367− Bits8 * cl = iallocate(vm, sizeof(*cl), 1);

368− SETTY(cl, CT_BITS8);

369− cl->bits8 = bits8;

370− return (VAL)cl;

367+ return MKINT(bits8);

371}

368}

372

369

373VAL MKB16(VM* vm, uint16_t bits16) {

370VAL MKB16(VM* vm, uint16_t bits16) {

374− Bits16 * cl = iallocate(vm, sizeof(*cl), 1);

375− SETTY(cl, CT_BITS16);

376− cl->bits16 = bits16;

377− return (VAL)cl;

371+ return MKINT(bits16);

378}

372}

379

373

380VAL MKB32(VM* vm, uint32_t bits32) {

374VAL MKB32(VM* vm, uint32_t bits32) {

@@ -417,11 +411,10 @@ void dumpStack(VM* vm) {

417void dumpVal(VAL v) {

411void dumpVal(VAL v) {

418 if (v==NULL) return;

412 if (v==NULL) return;

419 int i;

413 int i;

420− if (ISINT(v)) {

421− printf("%d ", (int)(GETINT(v)));

422− return;

423− }

424 switch(GETTY(v)) {

414 switch(GETTY(v)) {

415+ case CT_INT:

416+ printf("%" PRIdPTR " ", GETINT(v));

417+ break;

425 case CT_CON:

418 case CT_CON:

426 {

419 {

427 Con * cl = (Con*)v;

420 Con * cl = (Con*)v;

@@ -517,15 +510,10 @@ VAL idris_castBitsStr(VM* vm, VAL i) {

517 ClosureType ty = GETTY(i);

510 ClosureType ty = GETTY(i);

518

511

519 switch (ty) {

512 switch (ty) {

520− case CT_BITS8:

513+ case CT_INT: // 8/16 bits

521− // max length 8 bit unsigned int str 3 chars (256)

522− cl = allocStr(vm, 4, 0);

523− cl->slen = sprintf(cl->str, "%" PRIu8, GETBITS8(i));

524− break;

525− case CT_BITS16:

526 // max length 16 bit unsigned int str 5 chars (65,535)

514 // max length 16 bit unsigned int str 5 chars (65,535)

527 cl = allocStr(vm, 6, 0);

515 cl = allocStr(vm, 6, 0);

528− cl->slen = sprintf(cl->str, "%" PRIu16, GETBITS16(i));

516+ cl->slen = sprintf(cl->str, "%" PRIu16, (uint16_t)GETBITS16(i));

529 break;

517 break;

530 case CT_BITS32:

518 case CT_BITS32:

531 // max length 32 bit unsigned int str 10 chars (4,294,967,295)

519 // max length 32 bit unsigned int str 10 chars (4,294,967,295)

@@ -859,10 +847,12 @@ static void copyArray(VM* vm, VAL * dst, VAL * src, size_t len) {

859static VAL doCopyTo(VM* vm, VAL x) {

847static VAL doCopyTo(VM* vm, VAL x) {

860 int ar;

848 int ar;

861 VAL cl;

849 VAL cl;

862− if (x==NULL || ISINT(x)) {

850+ if (x==NULL) {

863 return x;

851 return x;

864 }

852 }

865 switch(GETTY(x)) {

853 switch(GETTY(x)) {

854+ case CT_INT:

855+ return x;

866 case CT_CDATA:

856 case CT_CDATA:

867 cl = MKCDATAc(vm, GETCDATA(x));

857 cl = MKCDATAc(vm, GETCDATA(x));

868 break;

858 break;

@@ -889,8 +879,6 @@ static VAL doCopyTo(VM* vm, VAL x) {

889 case CT_FLOAT:

879 case CT_FLOAT:

890 case CT_PTR:

880 case CT_PTR:

891 case CT_MANAGEDPTR:

881 case CT_MANAGEDPTR:

892− case CT_BITS8:

893− case CT_BITS16:

894 case CT_BITS32:

882 case CT_BITS32:

895 case CT_BITS64:

883 case CT_BITS64:

896 case CT_RAWDATA:

884 case CT_RAWDATA:

@@ -901,6 +889,7 @@ static VAL doCopyTo(VM* vm, VAL x) {

901 break;

889 break;

902 default:

890 default:

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

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

892+ cl = NULL;

904 }

893 }

905 return cl;

894 return cl;

906}

895}

@@ -1091,7 +1080,6 @@ Msg* idris_recvMessageFrom(VM* vm, int channel_id, VM* sender) {

1091 fprintf(stderr, "No messages waiting");

1080 fprintf(stderr, "No messages waiting");

1092 exit(-1);

1081 exit(-1);

1093 }

1082 }

1094−

1095 return ret;

1083 return ret;

1096}

1084}

1097#endif

1085#endif

rts/idris_rts.h+6−22

@@ -24,10 +24,9 @@

24// Closures

25typedef enum {

26 CT_CON, CT_ARRAY, CT_INT, CT_BIGINT,

27− CT_FLOAT, CT_STRING, CT_STROFFSET, CT_BITS8,

27+ CT_FLOAT, CT_STRING, CT_STROFFSET, CT_BITS32,

28− CT_BITS16, CT_BITS32, CT_BITS64, CT_PTR,

28+ CT_BITS64, CT_PTR, CT_REF, CT_FWD,

29− CT_REF, CT_FWD, CT_MANAGEDPTR, CT_RAWDATA,

29+ CT_MANAGEDPTR, CT_RAWDATA, CT_CDATA

30− CT_CDATA

31} ClosureType;

30} ClosureType;

33typedef struct Hdr {

32typedef struct Hdr {

@@ -54,11 +53,6 @@ typedef struct Array {

54 VAL array[0];

53 VAL array[0];

55} Array;

54} Array;

57−typedef struct Int {

58− Hdr hdr;

59− int i;

60−} Int;

61−

62typedef struct BigInt {

56typedef struct BigInt {

63 Hdr hdr;

57 Hdr hdr;

64 char big[0];

58 char big[0];

@@ -81,16 +75,6 @@ typedef struct StrOffset {

81 size_t offset;

75 size_t offset;

82} StrOffset;

76} StrOffset;

84−typedef struct Bits8 {

85− Hdr hdr;

86− uint8_t bits8;

87−} Bits8;

88−

89−typedef struct Bits16 {

90− Hdr hdr;

91− uint16_t bits16;

92−} Bits16;

93−

94typedef struct Bits32 {

78typedef struct Bits32 {

95 Hdr hdr;

79 Hdr hdr;

96 uint32_t bits32;

80 uint32_t bits32;

@@ -254,8 +238,8 @@ static inline size_t getstrlen(String * x) {

254#define GETFLOAT(x) (((Float*)(x))->f)

238#define GETFLOAT(x) (((Float*)(x))->f)

255#define GETCDATA(x) (((CDataC*)(x))->item)

239#define GETCDATA(x) (((CDataC*)(x))->item)

256

240

257−#define GETBITS8(x) (((Bits8*)(x))->bits8)

241+#define GETBITS8(x) (GETINT(x))

258−#define GETBITS16(x) (((Bits16*)(x))->bits16)

242+#define GETBITS16(x) (GETINT(x))

259#define GETBITS32(x) (((Bits32*)(x))->bits32)

243#define GETBITS32(x) (((Bits32*)(x))->bits32)

260#define GETBITS64(x) (((Bits64*)(x))->bits64)

244#define GETBITS64(x) (((Bits64*)(x))->bits64)

261

245

@@ -268,7 +252,7 @@ static inline size_t getstrlen(String * x) {

268

252

269#define CELEM(x) (((x)->hdr.sz - sizeof(Array)) / sizeof(VAL))

253#define CELEM(x) (((x)->hdr.sz - sizeof(Array)) / sizeof(VAL))

270

254

271−#define GETTY(x) ((ClosureType)((x)->hdr.ty))

255+#define GETTY(x) (ISINT(x)? CT_INT : (ClosureType)((x)->hdr.ty))

272#define SETTY(x,t) ((x)->hdr.ty = t)

256#define SETTY(x,t) ((x)->hdr.ty = t)

273

257

274// Integers, floats and operators

258// Integers, floats and operators