88eb2bf · Idris-dev · git.iko.soy

git.iko.soy/Idris-dev

on master help sign in

C codegen for bitmanip and bit comparators

88eb2bfErkin Batu Altunbaş14 years ago

rts/idris_bitstring.c+384−48

compare with master

unifiedsplit

@@ -95,45 +95,87 @@ VAL idris_b8SDiv(VM *vm, VAL a, VAL b) {

95 return cl;

96}

98−VAL idris_b8Z16(VM *vm, VAL a) {

98+VAL idris_b8Lt(VM *vm, VAL a, VAL b) {

99 VAL cl = allocate(vm, sizeof(Closure), 0);

100− SETTY(cl, BITS16);

100+ SETTY(cl, BITS8);

101− cl->info.bits16 = (uint16_t) a->info.bits8;

101+ cl->info.bits8 = a->info.bits8 < b->info.bits8;

102 return cl;

103}

104

105−VAL idris_b8Z32(VM *vm, VAL a) {

105+VAL idris_b8Gt(VM *vm, VAL a, VAL b) {

106 VAL cl = allocate(vm, sizeof(Closure), 0);

107− SETTY(cl, BITS32);

107+ SETTY(cl, BITS8);

108− cl->info.bits32 = (uint32_t) a->info.bits8;

108+ cl->info.bits8 = a->info.bits8 > b->info.bits8;

109 return cl;

110}

111

112−VAL idris_b8Z64(VM *vm, VAL a) {

112+VAL idris_b8Eq(VM *vm, VAL a, VAL b) {

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

114− SETTY(cl, BITS16);

114+ SETTY(cl, BITS8);

115− cl->info.bits64 = (uint64_t) a->info.bits8;

115+ cl->info.bits8 = a->info.bits8 == b->info.bits8;

116 return cl;

117}

118

119−VAL idris_b8S16(VM *vm, VAL a) {

119+VAL idris_b8Lte(VM *vm, VAL a, VAL b) {

120 VAL cl = allocate(vm, sizeof(Closure), 0);

121− SETTY(cl, BITS16);

121+ SETTY(cl, BITS8);

122− cl->info.bits16 = (uint16_t) (int16_t) (int8_t) a->info.bits8;

122+ cl->info.bits8 = a->info.bits8 <= b->info.bits8;

123 return cl;

124}

125

126−VAL idris_b8S32(VM *vm, VAL a) {

126+VAL idris_b8Gte(VM *vm, VAL a, VAL b) {

127 VAL cl = allocate(vm, sizeof(Closure), 0);

128− SETTY(cl, BITS32);

128+ SETTY(cl, BITS8);

129− cl->info.bits32 = (uint32_t) (int32_t) (int8_t) a->info.bits8;

129+ cl->info.bits8 = a->info.bits8 >= b->info.bits8;

130 return cl;

131}

132

133−VAL idris_b8S64(VM *vm, VAL a) {

133+VAL idris_b8Compl(VM *vm, VAL a) {

134 VAL cl = allocate(vm, sizeof(Closure), 0);

135− SETTY(cl, BITS64);

135+ SETTY(cl, BITS8);

136− cl->info.bits64 = (uint64_t) (int64_t) (int8_t) a->info.bits8;

136+ cl->info.bits8 = ~ a->info.bits8;

137+ return cl;

138+}

139+

140+VAL idris_b8And(VM *vm, VAL a, VAL b) {

141+ VAL cl = allocate(vm, sizeof(Closure), 0);

142+ SETTY(cl, BITS8);

143+ cl->info.bits8 = a->info.bits8 & b->info.bits8;

144+ return cl;

145+}

146+

147+VAL idris_b8Or(VM *vm, VAL a, VAL b) {

148+ VAL cl = allocate(vm, sizeof(Closure), 0);

149+ SETTY(cl, BITS8);

150+ cl->info.bits8 = a->info.bits8 | b->info.bits8;

151+ return cl;

152+}

153+

154+VAL idris_b8Xor(VM *vm, VAL a, VAL b) {

155+ VAL cl = allocate(vm, sizeof(Closure), 0);

156+ SETTY(cl, BITS8);

157+ cl->info.bits8 = a->info.bits8 ^ b->info.bits8;

158+ return cl;

159+}

160+

161+VAL idris_b8Shl(VM *vm, VAL a, VAL b) {

162+ VAL cl = allocate(vm, sizeof(Closure), 0);

163+ SETTY(cl, BITS8);

164+ cl->info.bits8 = a->info.bits8 << b->info.bits8;

165+ return cl;

166+}

167+

168+VAL idris_b8LShr(VM *vm, VAL a, VAL b) {

169+ VAL cl = allocate(vm, sizeof(Closure), 0);

170+ SETTY(cl, BITS8);

171+ cl->info.bits8 = a->info.bits8 >> b->info.bits8;

172+ return cl;

173+}

174+

175+VAL idris_b8AShr(VM *vm, VAL a, VAL b) {

176+ VAL cl = allocate(vm, sizeof(Closure), 0);

177+ SETTY(cl, BITS8);

178+ cl->info.bits8 = (uint8_t) (((int8_t)a->info.bits8) >> ((int8_t)b->info.bits8));

137 return cl;

179 return cl;

138}

180}

139

181

@@ -169,42 +211,91 @@ VAL idris_b16SDiv(VM *vm, VAL a, VAL b) {

169 VAL cl = allocate(vm, sizeof(Closure), 0);

211 VAL cl = allocate(vm, sizeof(Closure), 0);

170 SETTY(cl, BITS16);

212 SETTY(cl, BITS16);

171 cl->info.bits16 =

213 cl->info.bits16 =

172− (uint16_t) (((int16_t) a->info.bits16) / ((int16_t) b->info.bits16));

214+ (uint16_t) (((int16_t) a->info.bits16) / ((int16_t) b->info.bits16));

173 return cl;

215 return cl;

174}

216}

175

217

176−VAL idris_b16Z32(VM *vm, VAL a) {

218+VAL idris_b16Lt(VM *vm, VAL a, VAL b) {

177 VAL cl = allocate(vm, sizeof(Closure), 0);

219 VAL cl = allocate(vm, sizeof(Closure), 0);

178− SETTY(cl, BITS32);

220+ SETTY(cl, BITS16);

179− cl->info.bits32 = (uint32_t) a->info.bits16;

221+ cl->info.bits16 = a->info.bits16 < b->info.bits16;

180 return cl;

222 return cl;

181}

223}

182

224

183−VAL idris_b16Z64(VM *vm, VAL a) {

225+VAL idris_b16Gt(VM *vm, VAL a, VAL b) {

184 VAL cl = allocate(vm, sizeof(Closure), 0);

226 VAL cl = allocate(vm, sizeof(Closure), 0);

185− SETTY(cl, BITS64);

227+ SETTY(cl, BITS16);

186− cl->info.bits64 = (uint64_t) a->info.bits16;

228+ cl->info.bits16 = a->info.bits16 > b->info.bits16;

187 return cl;

229 return cl;

188}

230}

189

231

190−VAL idris_b16S32(VM *vm, VAL a) {

232+VAL idris_b16Eq(VM *vm, VAL a, VAL b) {

191 VAL cl = allocate(vm, sizeof(Closure), 0);

233 VAL cl = allocate(vm, sizeof(Closure), 0);

192− SETTY(cl, BITS32);

234+ SETTY(cl, BITS16);

193− cl->info.bits32 = (uint32_t) (int32_t) (int16_t) a->info.bits16;

235+ cl->info.bits16 = a->info.bits16 == b->info.bits16;

194 return cl;

236 return cl;

195}

237}

196

238

197−VAL idris_b16S64(VM *vm, VAL a) {

239+VAL idris_b16Lte(VM *vm, VAL a, VAL b) {

198 VAL cl = allocate(vm, sizeof(Closure), 0);

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

199− SETTY(cl, BITS64);

241+ SETTY(cl, BITS16);

200− cl->info.bits64 = (uint64_t) (int64_t) (int16_t) a->info.bits16;

242+ cl->info.bits16 = a->info.bits16 <= b->info.bits16;

201 return cl;

243 return cl;

202}

244}

203

245

204−VAL idris_b16T8(VM *vm, VAL a) {

246+VAL idris_b16Gte(VM *vm, VAL a, VAL b) {

205 VAL cl = allocate(vm, sizeof(Closure), 0);

247 VAL cl = allocate(vm, sizeof(Closure), 0);

206− SETTY(cl, BITS8);

248+ SETTY(cl, BITS16);

249+ cl->info.bits16 = a->info.bits16 >= b->info.bits16;

250+ return cl;

251+}

252+

253+VAL idris_b16Compl(VM *vm, VAL a) {

254+ VAL cl = allocate(vm, sizeof(Closure), 0);

255+ SETTY(cl, BITS16);

207− cl->info.bits8 = (uint8_t) a->info.bits16;

256+ cl->info.bits16 = ~ a->info.bits16;

257+ return cl;

258+}

259+

260+VAL idris_b16And(VM *vm, VAL a, VAL b) {

261+ VAL cl = allocate(vm, sizeof(Closure), 0);

262+ SETTY(cl, BITS16);

263+ cl->info.bits16 = a->info.bits16 & b->info.bits16;

264+ return cl;

265+}

266+

267+VAL idris_b16Or(VM *vm, VAL a, VAL b) {

268+ VAL cl = allocate(vm, sizeof(Closure), 0);

269+ SETTY(cl, BITS16);

270+ cl->info.bits16 = a->info.bits16 | b->info.bits16;

271+ return cl;

272+}

273+

274+VAL idris_b16Xor(VM *vm, VAL a, VAL b) {

275+ VAL cl = allocate(vm, sizeof(Closure), 0);

276+ SETTY(cl, BITS16);

277+ cl->info.bits16 = a->info.bits16 ^ b->info.bits16;

278+ return cl;

279+}

280+

281+VAL idris_b16Shl(VM *vm, VAL a, VAL b) {

282+ VAL cl = allocate(vm, sizeof(Closure), 0);

283+ SETTY(cl, BITS16);

284+ cl->info.bits16 = a->info.bits16 << b->info.bits16;

285+ return cl;

286+}

287+

288+VAL idris_b16LShr(VM *vm, VAL a, VAL b) {

289+ VAL cl = allocate(vm, sizeof(Closure), 0);

290+ SETTY(cl, BITS16);

291+ cl->info.bits16 = a->info.bits16 >> b->info.bits16;

292+ return cl;

293+}

294+

295+VAL idris_b16AShr(VM *vm, VAL a, VAL b) {

296+ VAL cl = allocate(vm, sizeof(Closure), 0);

297+ SETTY(cl, BITS16);

298+ cl->info.bits16 = (uint16_t) (((int16_t)a->info.bits16) >> ((int16_t)b->info.bits16));

208 return cl;

299 return cl;

209}

300}

210

301

@@ -240,35 +331,91 @@ VAL idris_b32SDiv(VM *vm, VAL a, VAL b) {

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

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

241 SETTY(cl, BITS32);

332 SETTY(cl, BITS32);

242 cl->info.bits32 =

333 cl->info.bits32 =

243− (uint32_t) (((int32_t) a->info.bits32) / ((int32_t) b->info.bits32));

334+ (uint32_t) (((int32_t) a->info.bits32) / ((int32_t) b->info.bits32));

244 return cl;

335 return cl;

245}

336}

246

337

247−VAL idris_b32Z64(VM *vm, VAL a) {

338+VAL idris_b32Lt(VM *vm, VAL a, VAL b) {

248 VAL cl = allocate(vm, sizeof(Closure), 0);

339 VAL cl = allocate(vm, sizeof(Closure), 0);

249− SETTY(cl, BITS64);

340+ SETTY(cl, BITS32);

250− cl->info.bits64 = (uint64_t) a->info.bits32;

341+ cl->info.bits32 = a->info.bits32 < b->info.bits32;

251 return cl;

342 return cl;

252}

343}

253

344

254−VAL idris_b32S64(VM *vm, VAL a) {

345+VAL idris_b32Gt(VM *vm, VAL a, VAL b) {

255 VAL cl = allocate(vm, sizeof(Closure), 0);

346 VAL cl = allocate(vm, sizeof(Closure), 0);

256− SETTY(cl, BITS64);

347+ SETTY(cl, BITS32);

257− cl->info.bits64 = (uint64_t) (int64_t) (int32_t) a->info.bits32;

348+ cl->info.bits32 = a->info.bits32 > b->info.bits32;

258 return cl;

349 return cl;

259}

350}

260

351

261−VAL idris_b32T8(VM *vm, VAL a) {

352+VAL idris_b32Eq(VM *vm, VAL a, VAL b) {

262 VAL cl = allocate(vm, sizeof(Closure), 0);

353 VAL cl = allocate(vm, sizeof(Closure), 0);

263− SETTY(cl, BITS8);

354+ SETTY(cl, BITS32);

264− cl->info.bits8 = (uint8_t) a->info.bits32;

355+ cl->info.bits32 = a->info.bits32 == b->info.bits32;

265 return cl;

356 return cl;

266}

357}

267

358

268−VAL idris_b32T16(VM *vm, VAL a) {

359+VAL idris_b32Lte(VM *vm, VAL a, VAL b) {

269 VAL cl = allocate(vm, sizeof(Closure), 0);

360 VAL cl = allocate(vm, sizeof(Closure), 0);

270− SETTY(cl, BITS16);

361+ SETTY(cl, BITS32);

271− cl->info.bits16 = (uint16_t) a->info.bits32;

362+ cl->info.bits32 = a->info.bits32 <= b->info.bits32;

363+ return cl;

364+}

365+

366+VAL idris_b32Gte(VM *vm, VAL a, VAL b) {

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

368+ SETTY(cl, BITS32);

369+ cl->info.bits32 = a->info.bits32 >= b->info.bits32;

370+ return cl;

371+}

372+

373+VAL idris_b32Compl(VM *vm, VAL a) {

374+ VAL cl = allocate(vm, sizeof(Closure), 0);

375+ SETTY(cl, BITS32);

376+ cl->info.bits32 = ~ a->info.bits32;

377+ return cl;

378+}

379+

380+VAL idris_b32And(VM *vm, VAL a, VAL b) {

381+ VAL cl = allocate(vm, sizeof(Closure), 0);

382+ SETTY(cl, BITS32);

383+ cl->info.bits32 = a->info.bits32 & b->info.bits32;

384+ return cl;

385+}

386+

387+VAL idris_b32Or(VM *vm, VAL a, VAL b) {

388+ VAL cl = allocate(vm, sizeof(Closure), 0);

389+ SETTY(cl, BITS32);

390+ cl->info.bits32 = a->info.bits32 | b->info.bits32;

391+ return cl;

392+}

393+

394+VAL idris_b32Xor(VM *vm, VAL a, VAL b) {

395+ VAL cl = allocate(vm, sizeof(Closure), 0);

396+ SETTY(cl, BITS32);

397+ cl->info.bits32 = a->info.bits32 ^ b->info.bits32;

398+ return cl;

399+}

400+

401+VAL idris_b32Shl(VM *vm, VAL a, VAL b) {

402+ VAL cl = allocate(vm, sizeof(Closure), 0);

403+ SETTY(cl, BITS32);

404+ cl->info.bits32 = a->info.bits32 << b->info.bits32;

405+ return cl;

406+}

407+

408+VAL idris_b32LShr(VM *vm, VAL a, VAL b) {

409+ VAL cl = allocate(vm, sizeof(Closure), 0);

410+ SETTY(cl, BITS32);

411+ cl->info.bits32 = a->info.bits32 >> b->info.bits32;

412+ return cl;

413+}

414+

415+VAL idris_b32AShr(VM *vm, VAL a, VAL b) {

416+ VAL cl = allocate(vm, sizeof(Closure), 0);

417+ SETTY(cl, BITS32);

418+ cl->info.bits32 = (uint32_t) (((int32_t)a->info.bits32) >> ((int32_t)b->info.bits32));

272 return cl;

419 return cl;

273}

420}

274

421

@@ -304,7 +451,196 @@ VAL idris_b64SDiv(VM *vm, VAL a, VAL b) {

304 VAL cl = allocate(vm, sizeof(Closure), 0);

451 VAL cl = allocate(vm, sizeof(Closure), 0);

305 SETTY(cl, BITS64);

452 SETTY(cl, BITS64);

306 cl->info.bits64 =

453 cl->info.bits64 =

307− (uint64_t) (((int64_t) a->info.bits64) / ((int64_t) b->info.bits64));

454+ (uint64_t) (((int64_t) a->info.bits64) / ((int64_t) b->info.bits64));

455+ return cl;

456+}

457+

458+VAL idris_b64Lt(VM *vm, VAL a, VAL b) {

459+ VAL cl = allocate(vm, sizeof(Closure), 0);

460+ SETTY(cl, BITS64);

461+ cl->info.bits64 = a->info.bits64 < b->info.bits64;

462+ return cl;

463+}

464+

465+VAL idris_b64Gt(VM *vm, VAL a, VAL b) {

466+ VAL cl = allocate(vm, sizeof(Closure), 0);

467+ SETTY(cl, BITS64);

468+ cl->info.bits64 = a->info.bits64 > b->info.bits64;

469+ return cl;

470+}

471+

472+VAL idris_b64Eq(VM *vm, VAL a, VAL b) {

473+ VAL cl = allocate(vm, sizeof(Closure), 0);

474+ SETTY(cl, BITS64);

475+ cl->info.bits64 = a->info.bits64 == b->info.bits64;

476+ return cl;

477+}

478+

479+VAL idris_b64Lte(VM *vm, VAL a, VAL b) {

480+ VAL cl = allocate(vm, sizeof(Closure), 0);

481+ SETTY(cl, BITS64);

482+ cl->info.bits64 = a->info.bits64 <= b->info.bits64;

483+ return cl;

484+}

485+

486+VAL idris_b64Gte(VM *vm, VAL a, VAL b) {

487+ VAL cl = allocate(vm, sizeof(Closure), 0);

488+ SETTY(cl, BITS64);

489+ cl->info.bits64 = a->info.bits64 >= b->info.bits64;

490+ return cl;

491+}

492+

493+VAL idris_b64Compl(VM *vm, VAL a) {

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

495+ SETTY(cl, BITS64);

496+ cl->info.bits64 = ~ a->info.bits64;

497+ return cl;

498+}

499+

500+VAL idris_b64And(VM *vm, VAL a, VAL b) {

501+ VAL cl = allocate(vm, sizeof(Closure), 0);

502+ SETTY(cl, BITS64);

503+ cl->info.bits64 = a->info.bits64 & b->info.bits64;

504+ return cl;

505+}

506+

507+VAL idris_b64Or(VM *vm, VAL a, VAL b) {

508+ VAL cl = allocate(vm, sizeof(Closure), 0);

509+ SETTY(cl, BITS64);

510+ cl->info.bits64 = a->info.bits64 | b->info.bits64;

511+ return cl;

512+}

513+

514+VAL idris_b64Xor(VM *vm, VAL a, VAL b) {

515+ VAL cl = allocate(vm, sizeof(Closure), 0);

516+ SETTY(cl, BITS64);

517+ cl->info.bits64 = a->info.bits64 ^ b->info.bits64;

518+ return cl;

519+}

520+

521+VAL idris_b64Shl(VM *vm, VAL a, VAL b) {

522+ VAL cl = allocate(vm, sizeof(Closure), 0);

523+ SETTY(cl, BITS64);

524+ cl->info.bits64 = a->info.bits64 << b->info.bits64;

525+ return cl;

526+}

527+

528+VAL idris_b64LShr(VM *vm, VAL a, VAL b) {

529+ VAL cl = allocate(vm, sizeof(Closure), 0);

530+ SETTY(cl, BITS64);

531+ cl->info.bits64 = a->info.bits64 >> b->info.bits64;

532+ return cl;

533+}

534+

535+VAL idris_b64AShr(VM *vm, VAL a, VAL b) {

536+ VAL cl = allocate(vm, sizeof(Closure), 0);

537+ SETTY(cl, BITS64);

538+ cl->info.bits64 = (uint64_t) (((int64_t)a->info.bits64) >> ((int64_t)b->info.bits64));

539+ return cl;

540+}

541+

542+VAL idris_b8Z16(VM *vm, VAL a) {

543+ VAL cl = allocate(vm, sizeof(Closure), 0);

544+ SETTY(cl, BITS16);

545+ cl->info.bits16 = (uint16_t) a->info.bits8;

546+ return cl;

547+}

548+

549+VAL idris_b8Z32(VM *vm, VAL a) {

550+ VAL cl = allocate(vm, sizeof(Closure), 0);

551+ SETTY(cl, BITS32);

552+ cl->info.bits32 = (uint32_t) a->info.bits8;

553+ return cl;

554+}

555+

556+VAL idris_b8Z64(VM *vm, VAL a) {

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

558+ SETTY(cl, BITS16);

559+ cl->info.bits64 = (uint64_t) a->info.bits8;

560+ return cl;

561+}

562+

563+VAL idris_b8S16(VM *vm, VAL a) {

564+ VAL cl = allocate(vm, sizeof(Closure), 0);

565+ SETTY(cl, BITS16);

566+ cl->info.bits16 = (uint16_t) (int16_t) (int8_t) a->info.bits8;

567+ return cl;

568+}

569+

570+VAL idris_b8S32(VM *vm, VAL a) {

571+ VAL cl = allocate(vm, sizeof(Closure), 0);

572+ SETTY(cl, BITS32);

573+ cl->info.bits32 = (uint32_t) (int32_t) (int8_t) a->info.bits8;

574+ return cl;

575+}

576+

577+VAL idris_b8S64(VM *vm, VAL a) {

578+ VAL cl = allocate(vm, sizeof(Closure), 0);

579+ SETTY(cl, BITS64);

580+ cl->info.bits64 = (uint64_t) (int64_t) (int8_t) a->info.bits8;

581+ return cl;

582+}

583+

584+VAL idris_b16Z32(VM *vm, VAL a) {

585+ VAL cl = allocate(vm, sizeof(Closure), 0);

586+ SETTY(cl, BITS32);

587+ cl->info.bits32 = (uint32_t) a->info.bits16;

588+ return cl;

589+}

590+

591+VAL idris_b16Z64(VM *vm, VAL a) {

592+ VAL cl = allocate(vm, sizeof(Closure), 0);

593+ SETTY(cl, BITS64);

594+ cl->info.bits64 = (uint64_t) a->info.bits16;

595+ return cl;

596+}

597+

598+VAL idris_b16S32(VM *vm, VAL a) {

599+ VAL cl = allocate(vm, sizeof(Closure), 0);

600+ SETTY(cl, BITS32);

601+ cl->info.bits32 = (uint32_t) (int32_t) (int16_t) a->info.bits16;

602+ return cl;

603+}

604+

605+VAL idris_b16S64(VM *vm, VAL a) {

606+ VAL cl = allocate(vm, sizeof(Closure), 0);

607+ SETTY(cl, BITS64);

608+ cl->info.bits64 = (uint64_t) (int64_t) (int16_t) a->info.bits16;

609+ return cl;

610+}

611+

612+VAL idris_b16T8(VM *vm, VAL a) {

613+ VAL cl = allocate(vm, sizeof(Closure), 0);

614+ SETTY(cl, BITS8);

615+ cl->info.bits8 = (uint8_t) a->info.bits16;

616+ return cl;

617+}

618+

619+VAL idris_b32Z64(VM *vm, VAL a) {

620+ VAL cl = allocate(vm, sizeof(Closure), 0);

621+ SETTY(cl, BITS64);

622+ cl->info.bits64 = (uint64_t) a->info.bits32;

623+ return cl;

624+}

625+

626+VAL idris_b32S64(VM *vm, VAL a) {

627+ VAL cl = allocate(vm, sizeof(Closure), 0);

628+ SETTY(cl, BITS64);

629+ cl->info.bits64 = (uint64_t) (int64_t) (int32_t) a->info.bits32;

630+ return cl;

631+}

632+

633+VAL idris_b32T8(VM *vm, VAL a) {

634+ VAL cl = allocate(vm, sizeof(Closure), 0);

635+ SETTY(cl, BITS8);

636+ cl->info.bits8 = (uint8_t) a->info.bits32;

637+ return cl;

638+}

639+

640+VAL idris_b32T16(VM *vm, VAL a) {

641+ VAL cl = allocate(vm, sizeof(Closure), 0);

642+ SETTY(cl, BITS16);

643+ cl->info.bits16 = (uint16_t) a->info.bits32;

308 return cl;

644 return cl;

309}

645}

310

646

rts/idris_bitstring.h+52

@@ -16,6 +16,22 @@ VAL idris_b8Minus(VM *vm, VAL a, VAL b);

16VAL idris_b8Times(VM *vm, VAL a, VAL b);

17VAL idris_b8UDiv(VM *vm, VAL a, VAL b);

18VAL idris_b8SDiv(VM *vm, VAL a, VAL b);

19+VAL idris_b8Lt(VM *vm, VAL a, VAL b);

20+VAL idris_b8Gt(VM *vm, VAL a, VAL b);

21+VAL idris_b8Eq(VM *vm, VAL a, VAL b);

22+VAL idris_b8Lte(VM *vm, VAL a, VAL b);

23+VAL idris_b8Gte(VM *vm, VAL a, VAL b);

24+VAL idris_b8And(VM *vm, VAL a, VAL b);

25+VAL idris_b8Or(VM *vm, VAL a, VAL b);

26+VAL idris_b8Neg(VM *vm, VAL a);

27+VAL idris_b8XOr(VM *vm, VAL a, VAL b);

28+VAL idris_b8Shl(VM *vm, VAL a, VAL b);

29+VAL idris_b8LShr(VM *vm, VAL a, VAL b);

30+VAL idris_b8AShr(VM *vm, VAL a, VAL b);

31+

32+VAL idris_b16Eq(VM *vm, VAL a, VAL b);

33+VAL idris_b32Eq(VM *vm, VAL a, VAL b);

34+VAL idris_b64Eq(VM *vm, VAL a, VAL b);

20VAL idris_b8Z16(VM *vm, VAL a);

36VAL idris_b8Z16(VM *vm, VAL a);

21VAL idris_b8Z32(VM *vm, VAL a);

37VAL idris_b8Z32(VM *vm, VAL a);

@@ -29,6 +45,18 @@ VAL idris_b16Minus(VM *vm, VAL a, VAL b);

29VAL idris_b16Times(VM *vm, VAL a, VAL b);

45VAL idris_b16Times(VM *vm, VAL a, VAL b);

30VAL idris_b16UDiv(VM *vm, VAL a, VAL b);

46VAL idris_b16UDiv(VM *vm, VAL a, VAL b);

31VAL idris_b16SDiv(VM *vm, VAL a, VAL b);

47VAL idris_b16SDiv(VM *vm, VAL a, VAL b);

48+VAL idris_b16Lt(VM *vm, VAL a, VAL b);

49+VAL idris_b16Gt(VM *vm, VAL a, VAL b);

50+VAL idris_b16Eq(VM *vm, VAL a, VAL b);

51+VAL idris_b16Lte(VM *vm, VAL a, VAL b);

52+VAL idris_b16Gte(VM *vm, VAL a, VAL b);

53+VAL idris_b16And(VM *vm, VAL a, VAL b);

54+VAL idris_b16Or(VM *vm, VAL a, VAL b);

55+VAL idris_b16Neg(VM *vm, VAL a);

56+VAL idris_b16XOr(VM *vm, VAL a, VAL b);

57+VAL idris_b16Shl(VM *vm, VAL a, VAL b);

58+VAL idris_b16LShr(VM *vm, VAL a, VAL b);

59+VAL idris_b16AShr(VM *vm, VAL a, VAL b);

33VAL idris_b16Z32(VM *vm, VAL a);

61VAL idris_b16Z32(VM *vm, VAL a);

34VAL idris_b16Z64(VM *vm, VAL a);

62VAL idris_b16Z64(VM *vm, VAL a);

@@ -41,6 +69,18 @@ VAL idris_b32Minus(VM *vm, VAL a, VAL b);

41VAL idris_b32Times(VM *vm, VAL a, VAL b);

69VAL idris_b32Times(VM *vm, VAL a, VAL b);

42VAL idris_b32UDiv(VM *vm, VAL a, VAL b);

70VAL idris_b32UDiv(VM *vm, VAL a, VAL b);

43VAL idris_b32SDiv(VM *vm, VAL a, VAL b);

71VAL idris_b32SDiv(VM *vm, VAL a, VAL b);

72+VAL idris_b32Lt(VM *vm, VAL a, VAL b);

73+VAL idris_b32Gt(VM *vm, VAL a, VAL b);

74+VAL idris_b32Eq(VM *vm, VAL a, VAL b);

75+VAL idris_b32Lte(VM *vm, VAL a, VAL b);

76+VAL idris_b32Gte(VM *vm, VAL a, VAL b);

77+VAL idris_b32And(VM *vm, VAL a, VAL b);

78+VAL idris_b32Or(VM *vm, VAL a, VAL b);

79+VAL idris_b32Neg(VM *vm, VAL a);

80+VAL idris_b32XOr(VM *vm, VAL a, VAL b);

81+VAL idris_b32Shl(VM *vm, VAL a, VAL b);

82+VAL idris_b32LShr(VM *vm, VAL a, VAL b);

83+VAL idris_b32AShr(VM *vm, VAL a, VAL b);

45VAL idris_b32Z64(VM *vm, VAL a);

85VAL idris_b32Z64(VM *vm, VAL a);

46VAL idris_b32S64(VM *vm, VAL a);

86VAL idris_b32S64(VM *vm, VAL a);

@@ -52,6 +92,18 @@ VAL idris_b64Minus(VM *vm, VAL a, VAL b);

52VAL idris_b64Times(VM *vm, VAL a, VAL b);

92VAL idris_b64Times(VM *vm, VAL a, VAL b);

53VAL idris_b64UDiv(VM *vm, VAL a, VAL b);

93VAL idris_b64UDiv(VM *vm, VAL a, VAL b);

54VAL idris_b64SDiv(VM *vm, VAL a, VAL b);

94VAL idris_b64SDiv(VM *vm, VAL a, VAL b);

95+VAL idris_b64Lt(VM *vm, VAL a, VAL b);

96+VAL idris_b64Gt(VM *vm, VAL a, VAL b);

97+VAL idris_b64Eq(VM *vm, VAL a, VAL b);

98+VAL idris_b64Lte(VM *vm, VAL a, VAL b);

99+VAL idris_b64Gte(VM *vm, VAL a, VAL b);

100+VAL idris_b64And(VM *vm, VAL a, VAL b);

101+VAL idris_b64Or(VM *vm, VAL a, VAL b);

102+VAL idris_b64Neg(VM *vm, VAL a);

103+VAL idris_b64XOr(VM *vm, VAL a, VAL b);

104+VAL idris_b64Shl(VM *vm, VAL a, VAL b);

105+VAL idris_b64LShr(VM *vm, VAL a, VAL b);

106+VAL idris_b64AShr(VM *vm, VAL a, VAL b);

107

56VAL idris_b64T8(VM *vm, VAL a);

108VAL idris_b64T8(VM *vm, VAL a);

57VAL idris_b64T16(VM *vm, VAL a);

109VAL idris_b64T16(VM *vm, VAL a);

src/IRTS/CodegenC.hs+56

@@ -304,6 +304,20 @@ doOp v LIntB64 [x] = v ++ "idris_b64(" ++ creg x ++ ")"

304

305doOp v LB32Int [x] = v ++ "idris_castB32Int(" ++ creg x ++ ")"

306

307+doOp v LB8Lt [x, y] = v ++ "idris_b8Lt(" ++ creg x ++ "," ++ creg y ++ ")"

308+doOp v LB8Lte [x, y] = v ++ "idris_b8Lte(" ++ creg x ++ "," ++ creg y ++ ")"

309+doOp v LB8Eq [x, y] = v ++ "idris_b8Eq(" ++ creg x ++ "," ++ creg y ++ ")"

310+doOp v LB8Gte [x, y] = v ++ "idris_b8Gte(" ++ creg x ++ "," ++ creg y ++ ")"

311+doOp v LB8Gt [x, y] = v ++ "idris_b8Gt(" ++ creg x ++ "," ++ creg y ++ ")"

312+

313+doOp v LB8Shl [x, y] = v ++ "idris_b8Shl(" ++ creg x ++ "," ++ creg y ++ ")"

314+doOp v LB8LShr [x, y] = v ++ "idris_b8Shr(" ++ creg x ++ "," ++ creg y ++ ")"

315+doOp v LB8AShr [x, y] = v ++ "idris_b8AShr(" ++ creg x ++ "," ++ creg y ++ ")"

316+doOp v LB8And [x, y] = v ++ "idris_b8And(" ++ creg x ++ "," ++ creg y ++ ")"

317+doOp v LB8Or [x, y] = v ++ "idris_b8Or(" ++ creg x ++ "," ++ creg y ++ ")"

318+doOp v LB8Xor [x, y] = v ++ "idris_b8Xor(" ++ creg x ++ "," ++ creg y ++ ")"

319+doOp v LB8Compl [x, y] = v ++ "idris_b8Compl(" ++ creg x ++ "," ++ creg y ++ ")"

320+

307doOp v LB8Plus [x, y] = v ++ "idris_b8Plus(" ++ creg x ++ "," ++ creg y ++ ")"

321doOp v LB8Plus [x, y] = v ++ "idris_b8Plus(" ++ creg x ++ "," ++ creg y ++ ")"

308doOp v LB8Minus [x, y] = v ++ "idris_b8Minus(" ++ creg x ++ "," ++ creg y ++ ")"

322doOp v LB8Minus [x, y] = v ++ "idris_b8Minus(" ++ creg x ++ "," ++ creg y ++ ")"

309doOp v LB8Times [x, y] = v ++ "idris_b8Times(" ++ creg x ++ "," ++ creg y ++ ")"

323doOp v LB8Times [x, y] = v ++ "idris_b8Times(" ++ creg x ++ "," ++ creg y ++ ")"

@@ -317,6 +331,20 @@ doOp v LB8S16 [x] = v ++ "idris_b8S16(" ++ creg x ++ ")"

317doOp v LB8S32 [x] = v ++ "idris_b8S32(" ++ creg x ++ ")"

331doOp v LB8S32 [x] = v ++ "idris_b8S32(" ++ creg x ++ ")"

318doOp v LB8S64 [x] = v ++ "idris_b8S64(" ++ creg x ++ ")"

332doOp v LB8S64 [x] = v ++ "idris_b8S64(" ++ creg x ++ ")"

319

333

334+doOp v LB16Lt [x, y] = v ++ "idris_b16Lt(" ++ creg x ++ "," ++ creg y ++ ")"

335+doOp v LB16Lte [x, y] = v ++ "idris_b16Lte(" ++ creg x ++ "," ++ creg y ++ ")"

336+doOp v LB16Eq [x, y] = v ++ "idris_b16Eq(" ++ creg x ++ "," ++ creg y ++ ")"

337+doOp v LB16Gte [x, y] = v ++ "idris_b16Gte(" ++ creg x ++ "," ++ creg y ++ ")"

338+doOp v LB16Gt [x, y] = v ++ "idris_b16Gt(" ++ creg x ++ "," ++ creg y ++ ")"

339+

340+doOp v LB16Shl [x, y] = v ++ "idris_b16Shl(" ++ creg x ++ "," ++ creg y ++ ")"

341+doOp v LB16LShr [x, y] = v ++ "idris_b16Shr(" ++ creg x ++ "," ++ creg y ++ ")"

342+doOp v LB16AShr [x, y] = v ++ "idris_b16AShr(" ++ creg x ++ "," ++ creg y ++ ")"

343+doOp v LB16And [x, y] = v ++ "idris_b16And(" ++ creg x ++ "," ++ creg y ++ ")"

344+doOp v LB16Or [x, y] = v ++ "idris_b16Or(" ++ creg x ++ "," ++ creg y ++ ")"

345+doOp v LB16Xor [x, y] = v ++ "idris_b16Xor(" ++ creg x ++ "," ++ creg y ++ ")"

346+doOp v LB16Compl [x, y] = v ++ "idris_b16Compl(" ++ creg x ++ "," ++ creg y ++ ")"

347+

320doOp v LB16Plus [x, y] =

348doOp v LB16Plus [x, y] =

321 v ++ "idris_b16Plus(" ++ creg x ++ "," ++ creg y ++ ")"

349 v ++ "idris_b16Plus(" ++ creg x ++ "," ++ creg y ++ ")"

322doOp v LB16Minus [x, y] =

350doOp v LB16Minus [x, y] =

@@ -334,6 +362,20 @@ doOp v LB16S32 [x] = v ++ "idris_b16S32(" ++ creg x ++ ")"

334doOp v LB16S64 [x] = v ++ "idris_b16S64(" ++ creg x ++ ")"

362doOp v LB16S64 [x] = v ++ "idris_b16S64(" ++ creg x ++ ")"

335doOp v LB16T8 [x] = v ++ "idris_b16T8(" ++ creg x ++ ")"

363doOp v LB16T8 [x] = v ++ "idris_b16T8(" ++ creg x ++ ")"

336

364

365+doOp v LB32Lt [x, y] = v ++ "idris_b32Lt(" ++ creg x ++ "," ++ creg y ++ ")"

366+doOp v LB32Lte [x, y] = v ++ "idris_b32Lte(" ++ creg x ++ "," ++ creg y ++ ")"

367+doOp v LB32Eq [x, y] = v ++ "idris_b32Eq(" ++ creg x ++ "," ++ creg y ++ ")"

368+doOp v LB32Gte [x, y] = v ++ "idris_b32Gte(" ++ creg x ++ "," ++ creg y ++ ")"

369+doOp v LB32Gt [x, y] = v ++ "idris_b32Gt(" ++ creg x ++ "," ++ creg y ++ ")"

370+

371+doOp v LB32Shl [x, y] = v ++ "idris_b32Shl(" ++ creg x ++ "," ++ creg y ++ ")"

372+doOp v LB32LShr [x, y] = v ++ "idris_b32Shr(" ++ creg x ++ "," ++ creg y ++ ")"

373+doOp v LB32AShr [x, y] = v ++ "idris_b32AShr(" ++ creg x ++ "," ++ creg y ++ ")"

374+doOp v LB32And [x, y] = v ++ "idris_b32And(" ++ creg x ++ "," ++ creg y ++ ")"

375+doOp v LB32Or [x, y] = v ++ "idris_b32Or(" ++ creg x ++ "," ++ creg y ++ ")"

376+doOp v LB32Xor [x, y] = v ++ "idris_b32Xor(" ++ creg x ++ "," ++ creg y ++ ")"

377+doOp v LB32Compl [x, y] = v ++ "idris_b32Compl(" ++ creg x ++ "," ++ creg y ++ ")"

378+

337doOp v LB32Plus [x, y] =

379doOp v LB32Plus [x, y] =

338 v ++ "idris_b32Plus(" ++ creg x ++ "," ++ creg y ++ ")"

380 v ++ "idris_b32Plus(" ++ creg x ++ "," ++ creg y ++ ")"

339doOp v LB32Minus [x, y] =

381doOp v LB32Minus [x, y] =

@@ -350,6 +392,20 @@ doOp v LB32S64 [x] = v ++ "idris_b32S64(" ++ creg x ++ ")"

350doOp v LB32T8 [x] = v ++ "idris_b32T8(" ++ creg x ++ ")"

392doOp v LB32T8 [x] = v ++ "idris_b32T8(" ++ creg x ++ ")"

351doOp v LB32T16 [x] = v ++ "idris_b32T16(" ++ creg x ++ ")"

393doOp v LB32T16 [x] = v ++ "idris_b32T16(" ++ creg x ++ ")"

352

394

395+doOp v LB64Lt [x, y] = v ++ "idris_b64Lt(" ++ creg x ++ "," ++ creg y ++ ")"

396+doOp v LB64Lte [x, y] = v ++ "idris_b64Lte(" ++ creg x ++ "," ++ creg y ++ ")"

397+doOp v LB64Eq [x, y] = v ++ "idris_b64Eq(" ++ creg x ++ "," ++ creg y ++ ")"

398+doOp v LB64Gte [x, y] = v ++ "idris_b64Gte(" ++ creg x ++ "," ++ creg y ++ ")"

399+doOp v LB64Gt [x, y] = v ++ "idris_b64Gt(" ++ creg x ++ "," ++ creg y ++ ")"

400+

401+doOp v LB64Shl [x, y] = v ++ "idris_b64Shl(" ++ creg x ++ "," ++ creg y ++ ")"

402+doOp v LB64LShr [x, y] = v ++ "idris_b64Shr(" ++ creg x ++ "," ++ creg y ++ ")"

403+doOp v LB64AShr [x, y] = v ++ "idris_b64AShr(" ++ creg x ++ "," ++ creg y ++ ")"

404+doOp v LB64And [x, y] = v ++ "idris_b64And(" ++ creg x ++ "," ++ creg y ++ ")"

405+doOp v LB64Or [x, y] = v ++ "idris_b64Or(" ++ creg x ++ "," ++ creg y ++ ")"

406+doOp v LB64Xor [x, y] = v ++ "idris_b64Xor(" ++ creg x ++ "," ++ creg y ++ ")"

407+doOp v LB64Compl [x, y] = v ++ "idris_b64Compl(" ++ creg x ++ "," ++ creg y ++ ")"

408+

353doOp v LB64Plus [x, y] =

409doOp v LB64Plus [x, y] =

354 v ++ "idris_b64Plus(" ++ creg x ++ "," ++ creg y ++ ")"

410 v ++ "idris_b64Plus(" ++ creg x ++ "," ++ creg y ++ ")"

355doOp v LB64Minus [x, y] =

411doOp v LB64Minus [x, y] =