rts/idris_bitstring.c · Idris-dev

git.iko.soy/Idris-dev

on 465cc1c help sign in

Idris-dev/rts/idris_bitstring.c

892 lines 22 kB history raw

1#include <assert.h>

3#include "idris_rts.h"

5VAL idris_b8CopyForGC(VM *vm, VAL a) {

6 uint8_t A = a->info.bits8;

7 VAL cl = allocate(sizeof(Closure), 1);

8 SETTY(cl, BITS8);

9 cl->info.bits8 = A;

10 return cl;

11}

13VAL idris_b16CopyForGC(VM *vm, VAL a) {

14 uint16_t A = a->info.bits16;

15 VAL cl = allocate(sizeof(Closure), 1);

16 SETTY(cl, BITS16);

17 cl->info.bits16 = A;

18 return cl;

19}

21VAL idris_b32CopyForGC(VM *vm, VAL a) {

22 uint32_t A = a->info.bits32;

23 VAL cl = allocate(sizeof(Closure), 1);

24 SETTY(cl, BITS32);

25 cl->info.bits32 = A;

26 return cl;

27}

29VAL idris_b64CopyForGC(VM *vm, VAL a) {

30 uint64_t A = a->info.bits64;

31 VAL cl = allocate(sizeof(Closure), 1);

32 SETTY(cl, BITS64);

33 cl->info.bits64 = A;

34 return cl;

35}

37VAL idris_b8(VM *vm, VAL a) {

38 uint8_t A = GETINT(a);

39 VAL cl = allocate(sizeof(Closure), 0);

40 SETTY(cl, BITS8);

41 cl->info.bits8 = (uint8_t) A;

42 return cl;

43}

45VAL idris_b16(VM *vm, VAL a) {

46 uint16_t A = GETINT(a);

47 VAL cl = allocate(sizeof(Closure), 0);

48 SETTY(cl, BITS16);

49 cl->info.bits16 = (uint16_t) A;

50 return cl;

51}

53VAL idris_b32(VM *vm, VAL a) {

54 uint32_t A = GETINT(a);

55 VAL cl = allocate(sizeof(Closure), 0);

56 SETTY(cl, BITS32);

57 cl->info.bits32 = (uint32_t) A;

58 return cl;

59}

61VAL idris_b64(VM *vm, VAL a) {

62 uint64_t A = GETINT(a);

63 VAL cl = allocate(sizeof(Closure), 0);

64 SETTY(cl, BITS64);

65 cl->info.bits64 = (uint64_t) A;

66 return cl;

67}

69VAL idris_castB32Int(VM *vm, VAL a) {

70 return MKINT((i_int)a->info.bits32);

71}

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

74 VAL cl = allocate(sizeof(Closure), 0);

75 SETTY(cl, BITS8);

76 cl->info.bits8 = a;

77 return cl;

78}

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

81 VAL cl = allocate(sizeof(Closure), 0);

82 SETTY(cl, BITS16);

83 cl->info.bits16 = a;

84 return cl;

85}

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

88 VAL cl = allocate(sizeof(Closure), 0);

89 SETTY(cl, BITS32);

90 cl->info.bits32 = a;

91 return cl;

92}

94VAL idris_b64const(VM *vm, uint64_t a) {

95 VAL cl = allocate(sizeof(Closure), 0);

96 SETTY(cl, BITS64);

97 cl->info.bits64 = a;

98 return cl;

99}

100

101VAL idris_b8Plus(VM *vm, VAL a, VAL b) {

102 uint8_t A = a->info.bits8;

103 uint8_t B = b->info.bits8;

104 VAL cl = allocate(sizeof(Closure), 0);

105 SETTY(cl, BITS8);

106 cl->info.bits8 = A + B;

107 return cl;

108}

109

110VAL idris_b8Minus(VM *vm, VAL a, VAL b) {

111 uint8_t A = a->info.bits8;

112 uint8_t B = b->info.bits8;

113 VAL cl = allocate(sizeof(Closure), 0);

114 SETTY(cl, BITS8);

115 cl->info.bits8 = A - B;

116 return cl;

117}

118

119VAL idris_b8Times(VM *vm, VAL a, VAL b) {

120 uint8_t A = a->info.bits8;

121 uint8_t B = b->info.bits8;

122 VAL cl = allocate(sizeof(Closure), 0);

123 SETTY(cl, BITS8);

124 cl->info.bits8 = A * B;

125 return cl;

126}

127

128VAL idris_b8UDiv(VM *vm, VAL a, VAL b) {

129 uint8_t A = a->info.bits8;

130 uint8_t B = b->info.bits8;

131 VAL cl = allocate(sizeof(Closure), 0);

132 SETTY(cl, BITS8);

133 cl->info.bits8 = A / B;

134 return cl;

135}

136

137VAL idris_b8SDiv(VM *vm, VAL a, VAL b) {

138 uint8_t A = a->info.bits8;

139 uint8_t B = b->info.bits8;

140 VAL cl = allocate(sizeof(Closure), 0);

141 SETTY(cl, BITS8);

142 cl->info.bits8 = (uint8_t) (((int8_t) A) / ((int8_t) B));

143 return cl;

144}

145

146VAL idris_b8URem(VM *vm, VAL a, VAL b) {

147 uint8_t A = a->info.bits8;

148 uint8_t B = b->info.bits8;

149 VAL cl = allocate(sizeof(Closure), 0);

150 SETTY(cl, BITS8);

151 cl->info.bits8 = A % B;

152 return cl;

153}

154

155VAL idris_b8SRem(VM *vm, VAL a, VAL b) {

156 uint8_t A = a->info.bits8;

157 uint8_t B = b->info.bits8;

158 VAL cl = allocate(sizeof(Closure), 0);

159 SETTY(cl, BITS8);

160 cl->info.bits8 = (uint8_t) (((int8_t) A) % ((int8_t) B));

161 return cl;

162}

163

164VAL idris_b8Lt(VM *vm, VAL a, VAL b) {

165 return MKINT((i_int) (a->info.bits8 < b->info.bits8));

166}

167

168VAL idris_b8Gt(VM *vm, VAL a, VAL b) {

169 return MKINT((i_int) (a->info.bits8 > b->info.bits8));

170}

171

172VAL idris_b8Eq(VM *vm, VAL a, VAL b) {

173 return MKINT((i_int) (a->info.bits8 == b->info.bits8));

174}

175

176VAL idris_b8Lte(VM *vm, VAL a, VAL b) {

177 return MKINT((i_int) (a->info.bits8 <= b->info.bits8));

178}

179

180VAL idris_b8Gte(VM *vm, VAL a, VAL b) {

181 return MKINT((i_int) (a->info.bits8 >= b->info.bits8));

182}

183

184VAL idris_b8Compl(VM *vm, VAL a) {

185 uint8_t A = a->info.bits8;

186 VAL cl = allocate(sizeof(Closure), 0);

187 SETTY(cl, BITS8);

188 cl->info.bits8 = ~ A;

189 return cl;

190}

191

192VAL idris_b8And(VM *vm, VAL a, VAL b) {

193 uint8_t A = a->info.bits8;

194 uint8_t B = b->info.bits8;

195 VAL cl = allocate(sizeof(Closure), 0);

196 SETTY(cl, BITS8);

197 cl->info.bits8 = A & B;

198 return cl;

199}

200

201VAL idris_b8Or(VM *vm, VAL a, VAL b) {

202 uint8_t A = a->info.bits8;

203 uint8_t B = b->info.bits8;

204 VAL cl = allocate(sizeof(Closure), 0);

205 SETTY(cl, BITS8);

206 cl->info.bits8 = A | B;

207 return cl;

208}

209

210VAL idris_b8Xor(VM *vm, VAL a, VAL b) {

211 uint8_t A = a->info.bits8;

212 uint8_t B = b->info.bits8;

213 VAL cl = allocate(sizeof(Closure), 0);

214 SETTY(cl, BITS8);

215 cl->info.bits8 = A ^ B;

216 return cl;

217}

218

219VAL idris_b8Shl(VM *vm, VAL a, VAL b) {

220 uint8_t A = a->info.bits8;

221 uint8_t B = b->info.bits8;

222 VAL cl = allocate(sizeof(Closure), 0);

223 SETTY(cl, BITS8);

224 cl->info.bits8 = A << B;

225 return cl;

226}

227

228VAL idris_b8LShr(VM *vm, VAL a, VAL b) {

229 uint8_t A = a->info.bits8;

230 uint8_t B = b->info.bits8;

231 VAL cl = allocate(sizeof(Closure), 0);

232 SETTY(cl, BITS8);

233 cl->info.bits8 = A >> B;

234 return cl;

235}

236

237VAL idris_b8AShr(VM *vm, VAL a, VAL b) {

238 uint8_t A = a->info.bits8;

239 uint8_t B = b->info.bits8;

240 VAL cl = allocate(sizeof(Closure), 0);

241 SETTY(cl, BITS8);

242 cl->info.bits8 = (uint8_t) (((int8_t) A) >> ((int8_t) B));

243 return cl;

244}

245

246VAL idris_b16Plus(VM *vm, VAL a, VAL b) {

247 uint16_t A = a->info.bits16;

248 uint16_t B = b->info.bits16;

249 VAL cl = allocate(sizeof(Closure), 0);

250 SETTY(cl, BITS16);

251 cl->info.bits16 = A + B;

252 return cl;

253}

254

255VAL idris_b16Minus(VM *vm, VAL a, VAL b) {

256 uint16_t A = a->info.bits16;

257 uint16_t B = b->info.bits16;

258 VAL cl = allocate(sizeof(Closure), 0);

259 SETTY(cl, BITS16);

260 cl->info.bits16 = A - B;

261 return cl;

262}

263

264VAL idris_b16Times(VM *vm, VAL a, VAL b) {

265 uint16_t A = a->info.bits16;

266 uint16_t B = b->info.bits16;

267 VAL cl = allocate(sizeof(Closure), 0);

268 SETTY(cl, BITS16);

269 cl->info.bits16 = A * B;

270 return cl;

271}

272

273VAL idris_b16UDiv(VM *vm, VAL a, VAL b) {

274 uint16_t A = a->info.bits16;

275 uint16_t B = b->info.bits16;

276 VAL cl = allocate(sizeof(Closure), 0);

277 SETTY(cl, BITS16);

278 cl->info.bits16 = A / B;

279 return cl;

280}

281

282VAL idris_b16SDiv(VM *vm, VAL a, VAL b) {

283 uint16_t A = a->info.bits16;

284 uint16_t B = b->info.bits16;

285 VAL cl = allocate(sizeof(Closure), 0);

286 SETTY(cl, BITS16);

287 cl->info.bits16 = (uint16_t) (((int16_t) A) / ((int16_t) B));

288 return cl;

289}

290

291VAL idris_b16URem(VM *vm, VAL a, VAL b) {

292 uint16_t A = a->info.bits16;

293 uint16_t B = b->info.bits16;

294 VAL cl = allocate(sizeof(Closure), 0);

295 SETTY(cl, BITS16);

296 cl->info.bits16 = A % B;

297 return cl;

298}

299

300VAL idris_b16SRem(VM *vm, VAL a, VAL b) {

301 uint16_t A = a->info.bits16;

302 uint16_t B = b->info.bits16;

303 VAL cl = allocate(sizeof(Closure), 0);

304 SETTY(cl, BITS16);

305 cl->info.bits16 = (uint16_t) (((int16_t) A) % ((int16_t) B));

306 return cl;

307}

308

309VAL idris_b16Lt(VM *vm, VAL a, VAL b) {

310 return MKINT((i_int) (a->info.bits16 < b->info.bits16));

311}

312

313VAL idris_b16Gt(VM *vm, VAL a, VAL b) {

314 return MKINT((i_int) (a->info.bits16 > b->info.bits16));

315}

316

317VAL idris_b16Eq(VM *vm, VAL a, VAL b) {

318 return MKINT((i_int) (a->info.bits16 == b->info.bits16));

319}

320

321VAL idris_b16Lte(VM *vm, VAL a, VAL b) {

322 return MKINT((i_int) (a->info.bits16 <= b->info.bits16));

323}

324

325VAL idris_b16Gte(VM *vm, VAL a, VAL b) {

326 return MKINT((i_int) (a->info.bits16 >= b->info.bits16));

327}

328

329VAL idris_b16Compl(VM *vm, VAL a) {

330 uint16_t A = a->info.bits16;

331 VAL cl = allocate(sizeof(Closure), 0);

332 SETTY(cl, BITS16);

333 cl->info.bits16 = ~ A;

334 return cl;

335}

336

337VAL idris_b16And(VM *vm, VAL a, VAL b) {

338 uint16_t A = a->info.bits16;

339 uint16_t B = b->info.bits16;

340 VAL cl = allocate(sizeof(Closure), 0);

341 SETTY(cl, BITS16);

342 cl->info.bits16 = A & B;

343 return cl;

344}

345

346VAL idris_b16Or(VM *vm, VAL a, VAL b) {

347 uint16_t A = a->info.bits16;

348 uint16_t B = b->info.bits16;

349 VAL cl = allocate(sizeof(Closure), 0);

350 SETTY(cl, BITS16);

351 cl->info.bits16 = A | B;

352 return cl;

353}

354

355VAL idris_b16Xor(VM *vm, VAL a, VAL b) {

356 uint16_t A = a->info.bits16;

357 uint16_t B = b->info.bits16;

358 VAL cl = allocate(sizeof(Closure), 0);

359 SETTY(cl, BITS16);

360 cl->info.bits16 = A ^ B;

361 return cl;

362}

363

364VAL idris_b16Shl(VM *vm, VAL a, VAL b) {

365 uint16_t A = a->info.bits16;

366 uint16_t B = b->info.bits16;

367 VAL cl = allocate(sizeof(Closure), 0);

368 SETTY(cl, BITS16);

369 cl->info.bits16 = A << B;

370 return cl;

371}

372

373VAL idris_b16LShr(VM *vm, VAL a, VAL b) {

374 uint16_t A = a->info.bits16;

375 uint16_t B = b->info.bits16;

376 VAL cl = allocate(sizeof(Closure), 0);

377 SETTY(cl, BITS16);

378 cl->info.bits16 = A >> B;

379 return cl;

380}

381

382VAL idris_b16AShr(VM *vm, VAL a, VAL b) {

383 uint16_t A = a->info.bits16;

384 uint16_t B = b->info.bits16;

385 VAL cl = allocate(sizeof(Closure), 0);

386 SETTY(cl, BITS16);

387 cl->info.bits16 = (uint16_t) (((int16_t) A) >> ((int16_t) B));

388 return cl;

389}

390

391VAL idris_b32Plus(VM *vm, VAL a, VAL b) {

392 uint32_t A = a->info.bits32;

393 uint32_t B = b->info.bits32;

394 VAL cl = allocate(sizeof(Closure), 0);

395 SETTY(cl, BITS32);

396 cl->info.bits32 = A + B;

397 return cl;

398}

399

400VAL idris_b32Minus(VM *vm, VAL a, VAL b) {

401 uint32_t A = a->info.bits32;

402 uint32_t B = b->info.bits32;

403 VAL cl = allocate(sizeof(Closure), 0);

404 SETTY(cl, BITS32);

405 cl->info.bits32 = A - B;

406 return cl;

407}

408

409VAL idris_b32Times(VM *vm, VAL a, VAL b) {

410 uint32_t A = a->info.bits32;

411 uint32_t B = b->info.bits32;

412 VAL cl = allocate(sizeof(Closure), 0);

413 SETTY(cl, BITS32);

414 cl->info.bits32 = A * B;

415 return cl;

416}

417

418VAL idris_b32UDiv(VM *vm, VAL a, VAL b) {

419 uint32_t A = a->info.bits32;

420 uint32_t B = b->info.bits32;

421 VAL cl = allocate(sizeof(Closure), 0);

422 SETTY(cl, BITS32);

423 cl->info.bits32 = A / B;

424 return cl;

425}

426

427VAL idris_b32SDiv(VM *vm, VAL a, VAL b) {

428 uint32_t A = a->info.bits32;

429 uint32_t B = b->info.bits32;

430 VAL cl = allocate(sizeof(Closure), 0);

431 SETTY(cl, BITS32);

432 cl->info.bits32 = (uint32_t) (((int32_t) A) / ((int32_t) B));

433 return cl;

434}

435

436VAL idris_b32URem(VM *vm, VAL a, VAL b) {

437 uint32_t A = a->info.bits32;

438 uint32_t B = b->info.bits32;

439 VAL cl = allocate(sizeof(Closure), 0);

440 SETTY(cl, BITS32);

441 cl->info.bits32 = A % B;

442 return cl;

443}

444

445VAL idris_b32SRem(VM *vm, VAL a, VAL b) {

446 uint32_t A = a->info.bits32;

447 uint32_t B = b->info.bits32;

448 VAL cl = allocate(sizeof(Closure), 0);

449 SETTY(cl, BITS32);

450 cl->info.bits32 = (uint32_t) (((int32_t) A) % ((int32_t) B));

451 return cl;

452}

453

454VAL idris_b32Lt(VM *vm, VAL a, VAL b) {

455 return MKINT((i_int) (a->info.bits32 < b->info.bits32));

456}

457

458VAL idris_b32Gt(VM *vm, VAL a, VAL b) {

459 return MKINT((i_int) (a->info.bits32 > b->info.bits32));

460}

461

462VAL idris_b32Eq(VM *vm, VAL a, VAL b) {

463 return MKINT((i_int) (a->info.bits32 == b->info.bits32));

464}

465

466VAL idris_b32Lte(VM *vm, VAL a, VAL b) {

467 return MKINT((i_int) (a->info.bits32 <= b->info.bits32));

468}

469

470VAL idris_b32Gte(VM *vm, VAL a, VAL b) {

471 return MKINT((i_int) (a->info.bits32 >= b->info.bits32));

472}

473

474VAL idris_b32Compl(VM *vm, VAL a) {

475 uint32_t A = a->info.bits32;

476 VAL cl = allocate(sizeof(Closure), 0);

477 SETTY(cl, BITS32);

478 cl->info.bits32 = ~ A;

479 return cl;

480}

481

482VAL idris_b32And(VM *vm, VAL a, VAL b) {

483 uint32_t A = a->info.bits32;

484 uint32_t B = b->info.bits32;

485 VAL cl = allocate(sizeof(Closure), 0);

486 SETTY(cl, BITS32);

487 cl->info.bits32 = A & B;

488 return cl;

489}

490

491VAL idris_b32Or(VM *vm, VAL a, VAL b) {

492 uint32_t A = a->info.bits32;

493 uint32_t B = b->info.bits32;

494 VAL cl = allocate(sizeof(Closure), 0);

495 SETTY(cl, BITS32);

496 cl->info.bits32 = A | B;

497 return cl;

498}

499

500VAL idris_b32Xor(VM *vm, VAL a, VAL b) {

501 uint32_t A = a->info.bits32;

502 uint32_t B = b->info.bits32;

503 VAL cl = allocate(sizeof(Closure), 0);

504 SETTY(cl, BITS32);

505 cl->info.bits32 = A ^ B;

506 return cl;

507}

508

509VAL idris_b32Shl(VM *vm, VAL a, VAL b) {

510 uint32_t A = a->info.bits32;

511 uint32_t B = b->info.bits32;

512 VAL cl = allocate(sizeof(Closure), 0);

513 SETTY(cl, BITS32);

514 cl->info.bits32 = A << B;

515 return cl;

516}

517

518VAL idris_b32LShr(VM *vm, VAL a, VAL b) {

519 uint32_t A = a->info.bits32;

520 uint32_t B = b->info.bits32;

521 VAL cl = allocate(sizeof(Closure), 0);

522 SETTY(cl, BITS32);

523 cl->info.bits32 = A >> B;

524 return cl;

525}

526

527VAL idris_b32AShr(VM *vm, VAL a, VAL b) {

528 uint32_t A = a->info.bits32;

529 uint32_t B = b->info.bits32;

530 VAL cl = allocate(sizeof(Closure), 0);

531 SETTY(cl, BITS32);

532 cl->info.bits32 = (uint32_t) (((int32_t)A) >> ((int32_t)B));

533 return cl;

534}

535

536VAL idris_b64Plus(VM *vm, VAL a, VAL b) {

537 uint64_t A = a->info.bits64;

538 uint64_t B = b->info.bits64;

539 VAL cl = allocate(sizeof(Closure), 0);

540 SETTY(cl, BITS64);

541 cl->info.bits64 = A + B;

542 return cl;

543}

544

545VAL idris_b64Minus(VM *vm, VAL a, VAL b) {

546 uint64_t A = a->info.bits64;

547 uint64_t B = b->info.bits64;

548 VAL cl = allocate(sizeof(Closure), 0);

549 SETTY(cl, BITS64);

550 cl->info.bits64 = A - B;

551 return cl;

552}

553

554VAL idris_b64Times(VM *vm, VAL a, VAL b) {

555 uint64_t A = a->info.bits64;

556 uint64_t B = b->info.bits64;

557 VAL cl = allocate(sizeof(Closure), 0);

558 SETTY(cl, BITS64);

559 cl->info.bits64 = A * B;

560 return cl;

561}

562

563VAL idris_b64UDiv(VM *vm, VAL a, VAL b) {

564 uint64_t A = a->info.bits64;

565 uint64_t B = b->info.bits64;

566 VAL cl = allocate(sizeof(Closure), 0);

567 SETTY(cl, BITS64);

568 cl->info.bits64 = A / B;

569 return cl;

570}

571

572VAL idris_b64SDiv(VM *vm, VAL a, VAL b) {

573 uint64_t A = a->info.bits64;

574 uint64_t B = b->info.bits64;

575 VAL cl = allocate(sizeof(Closure), 0);

576 SETTY(cl, BITS64);

577 cl->info.bits64 = (uint64_t) (((int64_t) A) / ((int64_t) B));

578 return cl;

579}

580

581VAL idris_b64URem(VM *vm, VAL a, VAL b) {

582 uint64_t A = a->info.bits64;

583 uint64_t B = b->info.bits64;

584 VAL cl = allocate(sizeof(Closure), 0);

585 SETTY(cl, BITS64);

586 cl->info.bits64 = A % B;

587 return cl;

588}

589

590VAL idris_b64SRem(VM *vm, VAL a, VAL b) {

591 uint64_t A = a->info.bits64;

592 uint64_t B = b->info.bits64;

593 VAL cl = allocate(sizeof(Closure), 0);

594 SETTY(cl, BITS64);

595 cl->info.bits64 = (uint64_t) (((int64_t) A) % ((int64_t) B));

596 return cl;

597}

598

599VAL idris_b64Lt(VM *vm, VAL a, VAL b) {

600 return MKINT((i_int) (a->info.bits64 < b->info.bits64));

601}

602

603VAL idris_b64Gt(VM *vm, VAL a, VAL b) {

604 return MKINT((i_int) (a->info.bits64 > b->info.bits64));

605}

606

607VAL idris_b64Eq(VM *vm, VAL a, VAL b) {

608 return MKINT((i_int) (a->info.bits64 == b->info.bits64));

609}

610

611VAL idris_b64Lte(VM *vm, VAL a, VAL b) {

612 return MKINT((i_int) (a->info.bits64 <= b->info.bits64));

613}

614

615VAL idris_b64Gte(VM *vm, VAL a, VAL b) {

616 return MKINT((i_int) (a->info.bits64 >= b->info.bits64));

617}

618

619VAL idris_b64Compl(VM *vm, VAL a) {

620 uint64_t A = a->info.bits64;

621 VAL cl = allocate(sizeof(Closure), 0);

622 SETTY(cl, BITS64);

623 cl->info.bits64 = ~ A;

624 return cl;

625}

626

627VAL idris_b64And(VM *vm, VAL a, VAL b) {

628 uint64_t A = a->info.bits64;

629 uint64_t B = b->info.bits64;

630 VAL cl = allocate(sizeof(Closure), 0);

631 SETTY(cl, BITS64);

632 cl->info.bits64 = A & B;

633 return cl;

634}

635

636VAL idris_b64Or(VM *vm, VAL a, VAL b) {

637 uint64_t A = a->info.bits64;

638 uint64_t B = b->info.bits64;

639 VAL cl = allocate(sizeof(Closure), 0);

640 SETTY(cl, BITS64);

641 cl->info.bits64 = A | B;

642 return cl;

643}

644

645VAL idris_b64Xor(VM *vm, VAL a, VAL b) {

646 uint64_t A = a->info.bits64;

647 uint64_t B = b->info.bits64;

648 VAL cl = allocate(sizeof(Closure), 0);

649 SETTY(cl, BITS64);

650 cl->info.bits64 = A ^ B;

651 return cl;

652}

653

654VAL idris_b64Shl(VM *vm, VAL a, VAL b) {

655 uint64_t A = a->info.bits64;

656 uint64_t B = b->info.bits64;

657 VAL cl = allocate(sizeof(Closure), 0);

658 SETTY(cl, BITS64);

659 cl->info.bits64 = A << B;

660 return cl;

661}

662

663VAL idris_b64LShr(VM *vm, VAL a, VAL b) {

664 uint64_t A = a->info.bits64;

665 uint64_t B = b->info.bits64;

666 VAL cl = allocate(sizeof(Closure), 0);

667 SETTY(cl, BITS64);

668 cl->info.bits64 = A >> B;

669 return cl;

670}

671

672VAL idris_b64AShr(VM *vm, VAL a, VAL b) {

673 uint64_t A = a->info.bits64;

674 uint64_t B = b->info.bits64;

675 VAL cl = allocate(sizeof(Closure), 0);

676 SETTY(cl, BITS64);

677 cl->info.bits64 = (uint64_t) (((int64_t) A) >> ((int64_t) B));

678 return cl;

679}

680

681VAL idris_b8Z16(VM *vm, VAL a) {

682 uint8_t A = a->info.bits8;

683 VAL cl = allocate(sizeof(Closure), 0);

684 SETTY(cl, BITS16);

685 cl->info.bits16 = (uint16_t) A;

686 return cl;

687}

688

689VAL idris_b8Z32(VM *vm, VAL a) {

690 uint8_t A = a->info.bits8;

691 VAL cl = allocate(sizeof(Closure), 0);

692 SETTY(cl, BITS32);

693 cl->info.bits32 = (uint32_t) A;

694 return cl;

695}

696

697VAL idris_b8Z64(VM *vm, VAL a) {

698 uint8_t A = a->info.bits8;

699 VAL cl = allocate(sizeof(Closure), 0);

700 SETTY(cl, BITS64);

701 cl->info.bits64 = (uint64_t) A;

702 return cl;

703}

704

705VAL idris_b8S16(VM *vm, VAL a) {

706 uint8_t A = a->info.bits8;

707 VAL cl = allocate(sizeof(Closure), 0);

708 SETTY(cl, BITS16);

709 cl->info.bits16 = (uint16_t) (int16_t) (int8_t) A;

710 return cl;

711}

712

713VAL idris_b8S32(VM *vm, VAL a) {

714 uint8_t A = a->info.bits8;

715 VAL cl = allocate(sizeof(Closure), 0);

716 SETTY(cl, BITS32);

717 cl->info.bits32 = (uint32_t) (int32_t) (int8_t) A;

718 return cl;

719}

720

721VAL idris_b8S64(VM *vm, VAL a) {

722 uint8_t A = a->info.bits8;

723 VAL cl = allocate(sizeof(Closure), 0);

724 SETTY(cl, BITS64);

725 cl->info.bits64 = (uint64_t) (int64_t) (int8_t) A;

726 return cl;

727}

728

729VAL idris_b16Z32(VM *vm, VAL a) {

730 uint16_t A = a->info.bits16;

731 VAL cl = allocate(sizeof(Closure), 0);

732 SETTY(cl, BITS32);

733 cl->info.bits32 = (uint32_t) A;

734 return cl;

735}

736

737VAL idris_b16Z64(VM *vm, VAL a) {

738 uint16_t A = a->info.bits16;

739 VAL cl = allocate(sizeof(Closure), 0);

740 SETTY(cl, BITS64);

741 cl->info.bits64 = (uint64_t) A;

742 return cl;

743}

744

745VAL idris_b16S32(VM *vm, VAL a) {

746 uint16_t A = a->info.bits16;

747 VAL cl = allocate(sizeof(Closure), 0);

748 SETTY(cl, BITS32);

749 cl->info.bits32 = (uint32_t) (int32_t) (int16_t) A;

750 return cl;

751}

752

753VAL idris_b16S64(VM *vm, VAL a) {

754 uint16_t A = a->info.bits16;

755 VAL cl = allocate(sizeof(Closure), 0);

756 SETTY(cl, BITS64);

757 cl->info.bits64 = (uint64_t) (int64_t) (int16_t) A;

758 return cl;

759}

760

761VAL idris_b16T8(VM *vm, VAL a) {

762 uint16_t A = a->info.bits16;

763 VAL cl = allocate(sizeof(Closure), 0);

764 SETTY(cl, BITS8);

765 cl->info.bits8 = (uint8_t) A;

766 return cl;

767}

768

769VAL idris_b32Z64(VM *vm, VAL a) {

770 uint32_t A = a->info.bits32;

771 VAL cl = allocate(sizeof(Closure), 0);

772 SETTY(cl, BITS64);

773 cl->info.bits64 = (uint64_t) A;

774 return cl;

775}

776

777VAL idris_b32S64(VM *vm, VAL a) {

778 uint32_t A = a->info.bits32;

779 VAL cl = allocate(sizeof(Closure), 0);

780 SETTY(cl, BITS64);

781 cl->info.bits64 = (uint64_t) (int64_t) (int32_t) A;

782 return cl;

783}

784

785VAL idris_b32T8(VM *vm, VAL a) {

786 uint32_t A = a->info.bits32;

787 VAL cl = allocate(sizeof(Closure), 0);

788 SETTY(cl, BITS8);

789 cl->info.bits8 = (uint8_t) A;

790 return cl;

791}

792

793VAL idris_b32T16(VM *vm, VAL a) {

794 uint32_t A = a->info.bits32;

795 VAL cl = allocate(sizeof(Closure), 0);

796 SETTY(cl, BITS16);

797 cl->info.bits16 = (uint16_t) A;

798 return cl;

799}

800

801VAL idris_b64T8(VM *vm, VAL a) {

802 uint64_t A = a->info.bits64;

803 VAL cl = allocate(sizeof(Closure), 0);

804 SETTY(cl, BITS8);

805 cl->info.bits8 = (uint8_t) A;

806 return cl;

807}

808

809VAL idris_b64T16(VM *vm, VAL a) {

810 uint64_t A = a->info.bits64;

811 VAL cl = allocate(sizeof(Closure), 0);

812 SETTY(cl, BITS16);

813 cl->info.bits16 = (uint16_t) A;

814 return cl;

815}

816

817VAL idris_b64T32(VM *vm, VAL a) {

818 uint64_t A = a->info.bits64;

819 VAL cl = allocate(sizeof(Closure), 0);

820 SETTY(cl, BITS32);

821 cl->info.bits32 = (uint32_t) A;

822 return cl;

823}

824

825// SSE vectors

826VAL idris_IDXB8x16(VM* vm, VAL vec, VAL idx) {

827 __m128i sse = *vec->info.bits128p;

828 uint8_t data[16];

829 _mm_storeu_si128((__m128i*)&data, sse);

830 return MKB8(vm, data[idx->info.bits32]);

831}

832

833VAL idris_IDXB16x8(VM* vm, VAL vec, VAL idx) {

834 __m128i sse = *vec->info.bits128p;

835 uint16_t data[8];

836 _mm_storeu_si128((__m128i*)&data, sse);

837 return MKB16(vm, data[idx->info.bits32]);

838}

839

840VAL idris_IDXB32x4(VM* vm, VAL vec, VAL idx) {

841 __m128i sse = *vec->info.bits128p;

842 uint32_t data[4];

843 _mm_storeu_si128((__m128i*)&data, sse);

844 return MKB32(vm, data[idx->info.bits32]);

845}

846

847VAL idris_IDXB64x2(VM* vm, VAL vec, VAL idx) {

848 __m128i sse = *vec->info.bits128p;

849 uint64_t data[2];

850 _mm_storeu_si128((__m128i*)&data, sse);

851 return MKB64(vm, data[idx->info.bits32]);

852}

853

854VAL idris_b8x16CopyForGC(VM *vm, VAL vec) {

855 __m128i sse = *vec->info.bits128p;

856 VAL cl = allocate(sizeof(Closure) + 16 + sizeof(__m128i), 1);

857 SETTY(cl, BITS8X16);

858 cl->info.bits128p = (__m128i*)ALIGN((uintptr_t)cl + sizeof(Closure), 16);

859 assert ((uintptr_t)cl->info.bits128p % 16 == 0);

860 *cl->info.bits128p = sse;

861 return cl;

862}

863

864VAL idris_b16x8CopyForGC(VM *vm, VAL vec) {

865 __m128i sse = *vec->info.bits128p;

866 VAL cl = allocate(sizeof(Closure) + 16 + sizeof(__m128i), 1);

867 SETTY(cl, BITS16X8);

868 cl->info.bits128p = (__m128i*)ALIGN((uintptr_t)cl + sizeof(Closure), 16);

869 assert ((uintptr_t)cl->info.bits128p % 16 == 0);

870 *cl->info.bits128p = sse;

871 return cl;

872}

873

874VAL idris_b32x4CopyForGC(VM *vm, VAL vec) {

875 __m128i sse = *vec->info.bits128p;

876 VAL cl = allocate(sizeof(Closure) + 16 + sizeof(__m128i), 1);

877 SETTY(cl, BITS32X4);

878 cl->info.bits128p = (__m128i*)ALIGN((uintptr_t)cl + sizeof(Closure), 16);

879 assert ((uintptr_t)cl->info.bits128p % 16 == 0);

880 *cl->info.bits128p = sse;

881 return cl;

882}

883

884VAL idris_b64x2CopyForGC(VM *vm, VAL vec) {

885 __m128i sse = *vec->info.bits128p;

886 VAL cl = allocate(sizeof(Closure) + 16 + sizeof(__m128i), 1);

887 SETTY(cl, BITS64X2);

888 cl->info.bits128p = (__m128i*)ALIGN((uintptr_t)cl + sizeof(Closure), 16);

889 assert ((uintptr_t)cl->info.bits128p % 16 == 0);

890 *cl->info.bits128p = sse;

891 return cl;

892}