src/trusted/validator_x86/ncval_tests.c - Issue 625923004: Delete old x86 validator.

Side by Side Diff: src/trusted/validator_x86/ncval_tests.c

Issue 625923004: Delete old x86 validator. (Closed) Base URL: svn://svn.chromium.org/native_client/trunk/src/native_client

Patch Set: rebase master Created 6 years, 2 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch | Annotate | Revision Log

OLD	NEW
	(Empty)
1 /*

2 * Copyright (c) 2012 The Native Client Authors. All rights reserved.

3 * Use of this source code is governed by a BSD-style license that can be

4 * found in the LICENSE file.

5 */

6

7 /*

8 * ncval_tests.c - simple unit tests for NaCl validator

9 */

10

11 #ifndef NACL_TRUSTED_BUT_NOT_TCB

12 #error("This file is not meant for use in the TCB")

13 #endif

14

15 #include <assert.h>

16 #include <stdarg.h>

17 #include <stdio.h>

18 #include <stdlib.h>

19 #include <string.h>

20 #include "native_client/src/include/nacl_macros.h"

21 #include "native_client/src/include/portability.h"

22 #include "native_client/src/shared/gio/gio.h"

23 #include "native_client/src/shared/platform/nacl_check.h"

24 #include "native_client/src/shared/platform/nacl_log.h"

25 #include "native_client/src/trusted/validator/x86/ncval_seg_sfi/ncdecode_verbose .h"

26 #include "native_client/src/trusted/validator/x86/ncval_seg_sfi/ncvalidate.h"

27 #include "native_client/src/trusted/validator/x86/ncval_seg_sfi/ncvalidate_inter naltypes.h"

28

29 /* Define the set of CPU features to use while validating. */

30 static NaClCPUFeaturesX86 g_ncval_cpu_features;

31

32 void Info(const char *fmt, ...)

33 {

34 va_list ap;

35 fprintf(stdout, "I: ");

36 va_start(ap, fmt);

37 vfprintf(stdout, fmt, ap);

38 va_end(ap);

39 }

40

41 struct NCValTestCase {

42 char *name;

43 char *description;

44

45 /* Expected results: */

46 int sawfailure; /* Whether code is expected to fail validation */

47 uint32_t illegalinst; /* Expected number of disallowed instructions */

48 uint32_t instructions; /* Expected number of instructions (excluding final HLT ) */

49

50 /* Input to validator: */

51 uint32_t vaddr; /* Load address (shouldn't matter) */

52 const char *data_as_hex;

53 };

54

55 struct NCValTestCase NCValTests[] = {

56 /* NOTE: Many of these tests are now in the textual testing structure in

57 * native_client/src/trusted/validator_x86/testdata/32 using

58 * files "test-n.hex", "test-n.ndis", "test-n.nvals", and

59 * "test-n.nvals16".

60 */

61 {

62 "test 1",

63 "a first very simple test with an illegal inst.",

64 /* sawfailure= / 1, / illegalinst= */ 1,

65 /* instructions= */ 9,

66 /* vaddr= */ 0x80000000,

67 "55 \n" /* push %ebp */

68 "89 e5 \n" /* mov %esp,%ebp */

69 "83 ec 08 \n" /* sub $0x8,%esp */

70 "e8 81 00 00 00 \n" /* call 0x86 */

71 "e8 d3 00 00 00 \n" /* call 0xd8 */

72 "e8 f3 04 00 00 \n" /* call 0x4f8 */

73 "c9 \n" /* leave */

74 "c3 \n" /* ret */

75 "00 00 f4 \n"

76 },

77 {

78 "test 6",

79 "test 6: 3c 25 cmp %al, $I",

80 /* sawfailure= / 0, / illegalinst= */ 0,

81 /* instructions= */ 7,

82 /* vaddr= */ 0x80000000,

83 "3c 25 \n" /* cmp $0x25,%al */

84 "90 90 90 90 90 90 f4 \n"

85 },

86 {

87 "test 7",

88 "test 7: group2, three byte move",

89 /* sawfailure= / 0, / illegalinst= */ 0,

90 /* instructions= */ 8,

91 /* vaddr= */ 0x80000000,

92 "c1 f9 1f 89 4d e4 \n"

93 "90 90 90 90 90 90 f4 \n"

94 },

95 {

96 "test 8",

97 "test 8: five byte move",

98 /* sawfailure= / 0, / illegalinst= */ 0,

99 /* instructions= */ 7,

100 /* vaddr= */ 0x80000000,

101 "c6 44 05 d6 00 \n" /* movb $0x0,-0x2a(%ebp,%eax,1) */

102 "90 90 90 90 90 90 f4 \n"

103 },

104 {

105 "test 9",

106 "test 9: seven byte control transfer, unprotected",

107 /* sawfailure= / 1, / illegalinst= */ 0,

108 /* instructions= */ 7,

109 /* vaddr= */ 0x80000000,

110 "ff 24 95 c8 6e 05 08 \n" /* jmp 0x8056ec8(,%edx,4) /

111 "90 90 90 90 90 90 f4 \n"

112 },

113 {

114 "test 10",

115 "test 10: eight byte bts instruction",

116 /* sawfailure= / 1, / illegalinst= */ 1,

117 /* instructions= */ 7,

118 /* vaddr= */ 0x80000000,

119 "0f ab 14 85 40 fb 27 08 \n" /* bts %edx,0x827fb40(,%eax,4) */

120 "90 90 90 90 90 90 f4 \n"

121 },

122 {

123 "test 11",

124 "test 11: four byte move",

125 /* sawfailure= / 0, / illegalinst= */ 0,

126 /* instructions= */ 7,

127 /* vaddr= */ 0x80000000,

128 "66 bf 08 00 \n" /* mov $0x8,%di */

129 "90 90 90 90 90 90 f4 \n"

130 },

131 {

132 "test 12",

133 "test 12: five byte movsx",

134 /* sawfailure= / 0, / illegalinst= */ 0,

135 /* instructions= */ 7,

136 /* vaddr= */ 0x80000000,

137 "66 0f be 04 10 \n" /* movsbw (%eax,%edx,1),%ax */

138 "90 90 90 90 90 90 f4 \n"

139 },

140 /* ldmxcsr, stmxcsr */

141 {

142 "test 14",

143 "test 14: ldmxcsr, stmxcsr",

144 /* sawfailure= / 0, / illegalinst= */ 0,

145 /* instructions= */ 10,

146 /* vaddr= */ 0x80000000,

147 "90 0f ae 10 90 0f ae 18 \n"

148 "90 90 90 90 90 90 f4 \n"

149 },

150 /* invalid */

151 {

152 "test 15",

153 "test 15: invalid instruction",

154 /* sawfailure= / 1, / illegalinst= */ 1,

155 /* instructions= */ 8,

156 /* vaddr= */ 0x80000000,

157 "90 0f ae 21 \n"

158 "90 90 90 90 90 90 f4 \n"

159 },

160 /* lfence */

161 {

162 "test 16",

163 "test 16: lfence",

164 /* sawfailure= / 0, / illegalinst= */ 0,

165 /* instructions= */ 8,

166 /* vaddr= */ 0x80000000,

167 "90 0f ae ef \n"

168 "90 90 90 90 90 90 f4 \n"

169 },

170 {

171 "test 17",

172 "test 17: lock cmpxchg",

173 /* sawfailure= / 0, / illegalinst= */ 0,

174 /* instructions= */ 4,

175 /* vaddr= */ 0x80000000,

176 "f0 0f b1 8f a8 01 00 00 \n" /* lock cmpxchg %ecx,0x1a8(%edi) */

177 "90 90 90 f4 \n"

178 },

179 {

180 "test 18",

181 "test 18: loop branch into overlapping instruction",

182 /* sawfailure= / 1, / illegalinst= */ 1,

183 /* instructions= */ 3,

184 /* vaddr= */ 0x80000000,

185 "bb 90 40 cd 80 85 c0 e1 f8 f4 \n"

186 },

187 {

188 "test 19",

189 "test 19: aad test",

190 /* sawfailure= / 1, / illegalinst= */ 2,

191 /* instructions= */ 5,

192 /* vaddr= */ 0x80000000,

193 "68 8a 80 04 08 d5 b0 c3 90 bb 90 40 cd 80 f4 \n"

194 },

195 {

196 "test 20",

197 "test 20: addr16 lea",

198 /* sawfailure= / 1, / illegalinst= */ 2,

199 /* instructions= */ 5,

200 /* vaddr= */ 0x80000000,

201 "68 8e 80 04 08 66 67 8d 98 ff ff c3 90 bb 90 40 cd 80 f4 \n"

202 },

203 {

204 "test 21",

205 "test 21: aam",

206 /* sawfailure= / 1, / illegalinst= */ 2,

207 /* instructions= */ 4,

208 /* vaddr= */ 0x80000000,

209 "68 89 80 04 08 \n" /* push $0x8048089 */

210 "d4 b0 \n" /* aam $0xffffffb0 */

211 "c3 \n" /* ret */

212 "bb 90 40 cd f4 \n" /* mov $0xf4cd4090,%ebx */

213 "f4 \n" /* hlt */

214 },

215 {

216 "test 22",

217 "test 22: pshufw",

218 /* sawfailure= / 1, / illegalinst= */ 1,

219 /* instructions= */ 4,

220 /* vaddr= */ 0x80000000,

221 "68 8b 80 04 08 0f 70 ca b3 c3 bb 90 40 cd 80 f4 \n"

222 },

223 {

224 "test 23",

225 "test 23: 14-byte nacljmp using eax",

226 /* sawfailure= / 1, / illegalinst= */ 0,

227 /* instructions= */ 3,

228 /* vaddr= */ 0x80000000,

229 "81 e0 ff ff ff ff 81 c8 00 00 00 00 ff d0 f4 \n"

230 },

231 {

232 "test 24",

233 "test 24: 5-byte nacljmp",

234 /* sawfailure= / 0, / illegalinst= */ 0,

235 /* instructions= */ 2,

236 /* vaddr= */ 0x80000000,

237 "83 e0 e0 ff e0 f4 \n"

238 },

239 {

240 "test 25",

241 "test 25: 0xe3 jmp",

242 /* sawfailure= / 1, / illegalinst= */ 1,

243 /* instructions= */ 1,

244 /* vaddr= */ 0x80000000,

245 "e3 00 f4 \n"

246 },

247 {

248 "test 26",

249 "test 26: 0xe9 jmp, nop",

250 /* sawfailure= / 0, / illegalinst= */ 0,

251 /* instructions= */ 2,

252 /* vaddr= */ 0x80000000,

253 "e9 00 00 00 00 90 f4 \n"

254 },

255 {

256 "test 27",

257 "test 27: 0xf0 0x80 jmp, nop",

258 /* sawfailure= / 0, / illegalinst= */ 0,

259 /* instructions= */ 2,

260 /* vaddr= */ 0x80000000,

261 "0f 80 00 00 00 00 90 f4 \n"

262 },

263 {

264 "test 28",

265 "test 28: 0xe9 jmp",

266 /* sawfailure= / 1, / illegalinst= */ 0,

267 /* instructions= */ 1,

268 /* vaddr= */ 0x80000000,

269 "e9 00 00 00 00 f4 \n"

270 },

271 {

272 "test 30",

273 "test 30: addr16 lea ret",

274 /* sawfailure= / 1, / illegalinst= */ 2,

275 /* instructions= */ 3,

276 /* vaddr= */ 0x80000000,

277 "67 8d b4 9a 40 c3 90 f4 \n"

278 },

279 {

280 "test 31",

281 "test 31: repz movsbl",

282 /* sawfailure= / 1, / illegalinst= */ 2,

283 /* instructions= */ 3,

284 /* vaddr= */ 0x80000000,

285 "f3 0f be 40 d0 c3 90 f4 \n"

286 },

287 {

288 "test 32",

289 "test 32: infinite loop",

290 /* sawfailure= / 0, / illegalinst= */ 0,

291 /* instructions= */ 1,

292 /* vaddr= */ 0x80000000,

293 "7f fe f4 \n"

294 },

295 {

296 "test 33",

297 "test 33: bad branch",

298 /* sawfailure= / 1, / illegalinst= */ 0,

299 /* instructions= */ 1,

300 /* vaddr= */ 0x80000000,

301 "7f fd f4 \n"

302 },

303 {

304 "test 34",

305 "test 34: bad branch",

306 /* sawfailure= / 1, / illegalinst= */ 0,

307 /* instructions= */ 1,

308 /* vaddr= */ 0x80000000,

309 "7f ff f4 \n"

310 },

311 {

312 "test 35",

313 "test 35: bad branch",

314 /* sawfailure= / 1, / illegalinst= */ 0,

315 /* instructions= */ 1,

316 /* vaddr= */ 0x80000000,

317 "7f 00 f4 \n"

318 },

319 {

320 "test 36",

321 "test 36: bad branch",

322 /* sawfailure= / 1, / illegalinst= */ 0,

323 /* instructions= */ 1,

324 /* vaddr= */ 0x80000000,

325 "7f 01 f4 \n"

326 },

327 {

328 "test 37",

329 "test 37: bad branch",

330 /* sawfailure= / 1, / illegalinst= */ 0,

331 /* instructions= */ 1,

332 /* vaddr= */ 0x80000000,

333 "7f 02 f4 \n"

334 },

335 {

336 "test 38",

337 "test 38: intc",

338 /* sawfailure= / 1, / illegalinst= */ 8,

339 /* instructions= */ 10,

340 /* vaddr= */ 0x80000000,

341 "66 eb 1b 31 51 3d ef cc 2f 36 48 6e 44 2e cc 14 f4 f4 \n"

342 },

343 {

344 "test 39",

345 "test 39: bad branch",

346 /* sawfailure= / 1, / illegalinst= */ 2,

347 /* instructions= */ 7,

348 /* vaddr= */ 0x80000000,

349 "67 8d 1d 22 a0 05 e3 7b 9c db 08 04 b1 90 ed 12 f4 f4 \n"

350 },

351 {

352 "test 40",

353 "test 40: more addr16 problems",

354 /* sawfailure= / 1, / illegalinst= */ 2,

355 /* instructions= */ 4,

356 /* vaddr= */ 0x80000000,

357 "67 a0 00 00 cd 80 90 90 f4 \n"

358 },

359 {

360 "test 41",

361 "test 41: the latest non-bug from hcf",

362 /* sawfailure= / 1, / illegalinst= */ 1,

363 /* instructions= */ 5,

364 /* vaddr= */ 0x80000000,

365 "84 d4 04 53 a0 04 6a 5a 20 cc b8 48 03 2b 96 11 f4 \n"

366 },

367 {

368 "test 42",

369 "test 42: another case from hcf",

370 /* sawfailure= / 1, / illegalinst= */ 1,

371 /* instructions= */ 7,

372 /* vaddr= */ 0x80000000,

373 "45 7f 89 58 94 04 24 1b c3 e2 6f 1a 94 87 8f 0b f4 \n"

374 },

375 {

376 "test 43",

377 "test 43: too many prefix bytes",

378 /* sawfailure= / 1, / illegalinst= */ 1,

379 /* instructions= */ 2,

380 /* vaddr= */ 0x80000000,

381 "66 66 66 66 00 00 90 f4 \n"

382 },

383 {

384 "test 44",

385 "test 44: palignr (SSSE3)",

386 /* sawfailure= / 0, / illegalinst= */ 0,

387 /* instructions= */ 2,

388 /* vaddr= */ 0x80000000,

389 "66 0f 3a 0f d0 c0 90 f4 \n"

390 },

391 {

392 "test 45",

393 "test 45: undefined inst in 3-byte opcode space",

394 /* sawfailure= / 1, / illegalinst= */ 2,

395 /* instructions= */ 2,

396 /* vaddr= */ 0x80000000,

397 "66 0f 39 0f d0 c0 90 f4 \n"

398 },

399 {

400 "test 46",

401 "test 46: SSE2x near miss",

402 /* sawfailure= / 1, / illegalinst= */ 1,

403 /* instructions= */ 2,

404 /* vaddr= */ 0x80000000,

405 "66 0f 73 00 00 90 f4 \n"

406 },

407 {

408 "test 47",

409 "test 47: SSE2x",

410 /* sawfailure= / 0, / illegalinst= */ 0,

411 /* instructions= */ 2,

412 /* vaddr= */ 0x80000000,

413 "66 0f 73 ff 00 90 f4 \n"

414 },

415 {

416 "test 48",

417 "test 48: SSE2x, missing required prefix byte",

418 /* sawfailure= / 1, / illegalinst= */ 1,

419 /* instructions= */ 2,

420 /* vaddr= */ 0x80000000,

421 "0f 73 ff 00 90 f4 \n"

422 },

423 {

424 "test 49",

425 "test 49: 3DNow example",

426 /* sawfailure= / 0, / illegalinst= */ 0,

427 /* instructions= */ 2,

428 /* vaddr= */ 0x80000000,

429 "0f 0f 46 01 bf 90 f4 \n"

430 },

431 {

432 "test 50",

433 "test 50: 3DNow error example 1",

434 /* sawfailure= / 1, / illegalinst= */ 1,

435 /* instructions= */ 2,

436 /* vaddr= */ 0x80000000,

437 "0f 0f 46 01 00 90 f4 \n"

438 },

439 {

440 "test 51",

441 "test 51: 3DNow error example 2",

442 /* sawfailure= / 1, / illegalinst= */ 0,

443 /* instructions= */ 0,

444 /* vaddr= */ 0x80000000,

445 "0f 0f 46 01 f4 \n"

446 },

447 {

448 "test 52",

449 "test 52: 3DNow error example 3",

450 /* sawfailure= / 1, / illegalinst= */ 1,

451 /* instructions= */ 2,

452 /* vaddr= */ 0x80000000,

453 "0f 0f 46 01 be 90 f4 \n"

454 },

455 {

456 "test 53",

457 "test 53: 3DNow error example 4",

458 /* sawfailure= / 1, / illegalinst= */ 1,

459 /* instructions= */ 2,

460 /* vaddr= */ 0x80000000,

461 "0f 0f 46 01 af 90 f4 \n"

462 },

463 {

464 "test 54",

465 "test 54: SSE4",

466 /* sawfailure= / 0, / illegalinst= */ 0,

467 /* instructions= */ 2,

468 /* vaddr= */ 0x80000000,

469 "66 0f 3a 0e d0 c0 90 f4 \n"

470 },

471 {

472 "test 55",

473 "test 55: SSE4",

474 /* sawfailure= / 0, / illegalinst= */ 0,

475 /* instructions= */ 3,

476 /* vaddr= */ 0x80000000,

477 "66 0f 38 0a d0 90 90 f4 \n"

478 },

479 {

480 "test 56",

481 "test 56: incb decb",

482 /* sawfailure= / 0, / illegalinst= */ 0,

483 /* instructions= */ 3,

484 /* vaddr= */ 0x80000000,

485 "fe 85 4f fd ff ff fe 8d 73 fd ff ff 90 f4 \n"

486 },

487 {

488 "test 57",

489 "test 57: lzcnt",

490 /* sawfailure= / 0, / illegalinst= */ 0,

491 /* instructions= */ 2,

492 /* vaddr= */ 0x80000000,

493 "f3 0f bd 00 90 f4 \n"

494 },

495 {

496 "test 58",

497 "test 58: fldz",

498 /* sawfailure= / 0, / illegalinst= */ 0,

499 /* instructions= */ 2,

500 /* vaddr= */ 0x80000000,

501 "d9 ee 90 f4 \n"

502 },

503 {

504 "test 59",

505 "test 59: x87",

506 /* sawfailure= / 0, / illegalinst= */ 0,

507 /* instructions= */ 7,

508 /* vaddr= */ 0x80000000,

509 "dd 9c fd b0 fe ff ff \n" /* fstpl -0x150(%ebp,%edi,8) */

510 "dd 9d 40 ff ff ff \n" /* fstpl -0xc0(%ebp) */

511 "db 04 24 \n" /* fildl (%esp) */

512 "dd 5d a0 \n" /* fstpl -0x60(%ebp) */

513 "da e9 \n" /* fucompp */

514 "df e0 \n" /* fnstsw %ax */

515 "90 f4 \n"

516 },

517 {

518 "test 60",

519 "test 60: x87 bad instructions",

520 /* sawfailure= / 1, / illegalinst= */ 9,

521 /* instructions= */ 19,

522 /* vaddr= */ 0x80000000,

523 "dd cc \n" /* (bad) */

524 "dd c0 \n" /* ffree %st(0) */

525 "dd c7 \n" /* ffree %st(7) */

526 "dd c8 \n" /* (bad) */

527 "dd cf \n" /* (bad) */

528 "dd f0 \n" /* (bad) */

529 "dd ff \n" /* (bad) */

530 "dd fd \n" /* (bad) */

531 "de d1 \n" /* (bad) */

532 "de d9 \n" /* fcompp */

533 "db 04 24 \n" /* fildl (%esp) */

534 "dd 5d a0 \n" /* fstpl -0x60(%ebp) */

535 "db e0 \n" /* feni(287 only) */

536 "db ff \n" /* (bad) */

537 "db e8 \n" /* fucomi %st(0),%st */

538 "db f7 \n" /* fcomi %st(7),%st */

539 "da e9 \n" /* fucompp */

540 "df e0 \n" /* fnstsw %ax */

541 "90 f4 \n"

542 },

543 {

544 "test 61",

545 "test 61: 3DNow prefetch",

546 /* sawfailure= / 0, / illegalinst= */ 0,

547 /* instructions= */ 2,

548 /* vaddr= */ 0x80000000,

549 "0f 0d 00 \n" /* prefetch (%eax) */

550 "90 f4 \n"

551 },

552 {

553 "test 61.1",

554 "test 61.1: F2 0F ...",

555 /* sawfailure= / 1, / illegalinst= */ 1,

556 /* instructions= */ 3,

557 /* vaddr= */ 0x80000000,

558 "f2 0f 48 0f 48 a4 52 \n"

559 "f2 0f 10 c8 \n" /* movsd %xmm0,%xmm1 */

560 "90 f4 \n"

561 },

562 {

563 "test 62",

564 "test 62: f6/f7 test Ib/Iv ...",

565 /* sawfailure= / 0, / illegalinst= */ 0,

566 /* instructions= */ 10,

567 /* vaddr= */ 0x80000000,

568 "f6 c1 ff \n" /* test $0xff,%cl */

569 "f6 44 43 01 02 \n" /* testb $0x2,0x1(%ebx,%eax,2) */

570 "f7 c6 03 00 00 00 \n" /* test $0x3,%esi */

571 "90 90 90 90 90 \n"

572 "f7 45 18 00 00 00 20 \n" /* testl $0x20000000,0x18(%ebp) */

573 "90 f4 \n"

574 },

575 {

576 "test 63",

577 "test 63: addr16 corner cases ...",

578 /* sawfailure= / 1, / illegalinst= */ 4,

579 /* instructions= */ 5,

580 /* vaddr= */ 0x80000000,

581 "67 01 00 \n" /* addr16 add %eax,(%bx,%si) */

582 "67 01 40 00 \n" /* addr16 add %eax,0x0(%bx,%si) */

583 "67 01 80 00 90 \n" /* addr16 add %eax,-0x7000(%bx,%si) */

584 "67 01 c0 \n" /* addr16 add %eax,%eax */

585 "90 f4 \n"

586 },

587 {

588 "test 64",

589 "test 64: text starts with indirect jmp ...",

590 /* sawfailure= / 1, / illegalinst= */ 0,

591 /* instructions= */ 2,

592 /* vaddr= */ 0x80000000,

593 "ff d0 90 f4 \n"

594 },

595 {

596 "test 65",

597 "test 65: nacljmp crosses 32-byte boundary ...",

598 /* sawfailure= / 1, / illegalinst= */ 0,

599 /* instructions= */ 32,

600 /* vaddr= */ 0x80000000,

601 "90 90 90 90 90 90 90 90 \n"

602 "90 90 90 90 90 90 90 90 \n"

603 "90 90 90 90 90 90 90 90 \n"

604 "90 90 90 90 90 83 e0 ff \n"

605 "ff d0 90 f4 \n"

606 },

607 {

608 /* I think this is currently NACLi_ILLEGAL */

609 "test 65",

610 "test 65: fxsave",

611 /* sawfailure= / 1, / illegalinst= */ 1,

612 /* instructions= */ 2,

613 /* vaddr= */ 0x80000000,

614 "0f ae 00 00 90 90 90 90 90 f4 \n"

615 },

616 {

617 "test 66",

618 "test 66: NACLi_CMPXCHG8B",

619 /* sawfailure= / 0, / illegalinst= */ 0,

620 /* instructions= */ 2,

621 /* vaddr= */ 0x80000000,

622 "f0 0f c7 08 90 f4 \n"

623 },

624 {

625 "test 67",

626 "test 67: NACLi_FCMOV",

627 /* sawfailure= / 0, / illegalinst= */ 0,

628 /* instructions= */ 7,

629 /* vaddr= */ 0x80000000,

630 "da c0 00 00 90 90 90 90 90 f4 \n"

631 },

632 {

633 "test 68",

634 "test 68: NACLi_MMX",

635 /* sawfailure= / 0, / illegalinst= */ 0,

636 /* instructions= */ 4,

637 /* vaddr= */ 0x80000000,

638 "0f 60 00 \n" /* punpcklbw (%eax),%mm0 */

639 "90 90 90 f4 \n"

640 },

641 {

642 "test 69",

643 "test 69: NACLi_SSE",

644 /* sawfailure= / 0, / illegalinst= */ 0,

645 /* instructions= */ 2,

646 /* vaddr= */ 0x80000000,

647 "0f 5e 90 90 90 90 90 90 f4 \n"

648 },

649 {

650 "test 70",

651 "test 70: NACLi_SSE2",

652 /* sawfailure= / 0, / illegalinst= */ 0,

653 /* instructions= */ 4,

654 /* vaddr= */ 0x80000000,

655 "66 0f 60 00 90 90 90 f4 \n"

656 },

657 {

658 "test 71",

659 "test 71: NACLi_SSE3",

660 /* sawfailure= / 0, / illegalinst= */ 0,

661 /* instructions= */ 4,

662 /* vaddr= */ 0x80000000,

663 "66 0f 7d 00 90 90 90 f4 \n"

664 },

665 {

666 "test 72",

667 "test 72: NACLi_SSE4A",

668 /* sawfailure= / 0, / illegalinst= */ 0,

669 /* instructions= */ 4,

670 /* vaddr= */ 0x80000000,

671 "f2 0f 79 00 90 90 90 f4 \n"

672 },

673 {

674 "test 73",

675 "test 73: NACLi_POPCNT",

676 /* sawfailure= / 0, / illegalinst= */ 0,

677 /* instructions= */ 2,

678 /* vaddr= */ 0x80000000,

679 "f3 0f b8 00 90 f4 \n"

680 },

681 {

682 "test 74",

683 "test 74: NACLi_E3DNOW",

684 /* sawfailure= / 0, / illegalinst= */ 0,

685 /* instructions= */ 2,

686 /* vaddr= */ 0x80000000,

687 "0f 0f 46 01 bb 90 f4 \n"

688 },

689 {

690 "test 75",

691 "test 75: NACLi_MMXSSE2",

692 /* sawfailure= / 0, / illegalinst= */ 0,

693 /* instructions= */ 2,

694 /* vaddr= */ 0x80000000,

695 "66 0f 71 f6 00 90 f4 \n"

696 },

697 {

698 "test 76",

699 "test 76: mov eax, ss",

700 /* sawfailure= / 1, / illegalinst= */ 4,

701 /* instructions= */ 4,

702 /* vaddr= */ 0x80000000,

703 "8e d0 8c d0 66 8c d0 90 f4 \n"

704 },

705 {

706 "test 77",

707 "test 77: call esp",

708 /* sawfailure= / 1, / illegalinst= */ 0,

709 /* instructions= */ 3,

710 /* vaddr= */ 0x80000000,

711 "83 e4 f0 ff d4 90 f4 \n"

712 },

713 /* code.google.com issue 23 reported by defend.the.world on 11 Dec 2008 */

714 {

715 "test 78",

716 "test 78: call (*edx)",

717 /* sawfailure= / 1, / illegalinst= */ 0,

718 /* instructions= */ 30,

719 /* vaddr= */ 0x80000000,

720 "90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 \n"

721 "90 90 90 90 90 90 90 90 90 90 90 \n"

722 "83 e2 e0 \n" /* and */

723 "ff 12 \n" /* call (edx) /

724 "90 f4 \n" /* nop halt */

725 },

726 {

727 "test 79",

728 "test 79: call *edx",

729 /* sawfailure= / 0, / illegalinst= */ 0,

730 /* instructions= */ 30,

731 /* vaddr= */ 0x80000000,

732 "90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 \n"

733 "90 90 90 90 90 90 90 90 90 90 90 \n"

734 "83 e2 e0 \n" /* and */

735 "ff d2 \n" /* call edx /

736 "90 f4 \n" /* nop halt */

737 },

738 {

739 "test 80",

740 "test 80: roundss",

741 /* sawfailure= / 0, / illegalinst= */ 0,

742 /* instructions= */ 3,

743 /* vaddr= */ 0x80000000,

744 "66 0f 3a 0a c0 00 \n" /* roundss $0x0,%xmm0,%xmm0 */

745 "90 90 \n"

746 "f4 \n" /* hlt */

747 },

748 {

749 "test 81",

750 "test 81: crc32",

751 /* sawfailure= / 0, / illegalinst= */ 0,

752 /* instructions= */ 3,

753 /* vaddr= */ 0x80000000,

754 "f2 0f 38 f1 c8 \n" /* crc32l %eax,%ecx */

755 "90 90 \n"

756 "f4 \n" /* hlt */

757 },

758 {

759 "test 82",

760 "test 82: SSE4 error 1",

761 /* sawfailure= / 1, / illegalinst= */ 2,

762 /* instructions= */ 4,

763 /* vaddr= */ 0x80000000,

764 "f3 0f 3a 0e d0 c0 90 f4 \n"

765 },

766 {

767 "test 83",

768 "test 83: SSE4 error 2",

769 /* sawfailure= / 1, / illegalinst= */ 2,

770 /* instructions= */ 2,

771 /* vaddr= */ 0x80000000,

772 "f3 0f 38 0f d0 c0 90 f4 \n"

773 },

774 {

775 "test 84",

776 "test 84: SSE4 error 3",

777 /* sawfailure= / 1, / illegalinst= */ 1,

778 /* instructions= */ 3,

779 /* vaddr= */ 0x80000000,

780 "66 0f 38 0f d0 c0 90 f4 \n"

781 },

782 {

783 "test 85",

784 "test 85: SSE4 error 4",

785 /* sawfailure= / 1, / illegalinst= */ 1,

786 /* instructions= */ 3,

787 /* vaddr= */ 0x80000000,

788 "f2 66 0f 3a 0a c0 00 \n"

789 "90 90 \n"

790 "f4 \n" /* hlt */

791 },

792 {

793 "test 86",

794 "test 86: bad SSE4 crc32",

795 /* sawfailure= / 1, / illegalinst= */ 1,

796 /* instructions= */ 3,

797 /* vaddr= */ 0x80000000,

798 "f2 f3 0f 38 f1 c8 \n"

799 "90 90 \n"

800 "f4 \n" /* hlt */

801 },

802 {

803 "test 87",

804 "test 87: bad NACLi_3BYTE instruction (SEGCS prefix)",

805 /* sawfailure= / 1, / illegalinst= */ 1,

806 /* instructions= */ 3,

807 /* vaddr= */ 0x80000000,

808 /* Note: Fixed so that this is a legal instruction,

809 * except for the prefix! (karl)

810 */

811 "2e 0f 3a 0f bb ab 00 00 00 00 \n"

812 "90 90 \n"

813 "f4 \n" /* hlt */

814 },

815 {

816 "test 87a",

817 "test 87a: bad NACLi_3BYTE instruction (not really an instruction)",

818 /* sawfailure= / 1, / illegalinst= */ 2,

819 /* instructions= */ 2,

820 /* vaddr= */ 0x80000000,

821 /* Note: Fixed so that this is a legal instruction,

822 * except for the prefix! (karl)

823 */

824 "2e 0f 3a 7d bb ab 00 00 00 00 \n"

825 "90 90 \n"

826 "f4 \n" /* hlt */

827 },

828 {

829 "test 88",

830 "test 88: two-byte jump with prefix (bug reported by Mark Dowd)",

831 /* sawfailure= / 1, / illegalinst= */ 1,

832 /* instructions= */ 4,

833 /* vaddr= */ 0x80000000,

834 "66 0f 84 00 00 \n" /* data16 je 0x5 */

835 "90 90 \n"

836 "f4 \n" /* hlt */

837 },

838 {

839 "test 89",

840 "test 89: sfence",

841 /* sawfailure= / 0, / illegalinst= */ 0,

842 /* instructions= */ 8,

843 /* vaddr= */ 0x80000000,

844 "90 0f ae ff \n"

845 "90 90 90 90 90 90 f4 \n"

846 },

847 {

848 "test 90",

849 "test 90: clflush",

850 /* sawfailure= / 0, / illegalinst= */ 0,

851 /* instructions= */ 8,

852 /* vaddr= */ 0x80000000,

853 "90 0f ae 3f \n"

854 "90 90 90 90 90 90 f4 \n"

855 },

856 {

857 "test 91",

858 "test 91: mfence",

859 /* sawfailure= / 0, / illegalinst= */ 0,

860 /* instructions= */ 8,

861 /* vaddr= */ 0x80000000,

862 "90 0f ae f7 \n"

863 "90 90 90 90 90 90 f4 \n"

864 },

865 {

866 "test 92",

867 "test 92: jump to zero should be allowed",

868 /* A jump/call to a zero address will be emitted for a jump/call

869 to a weak symbol that is undefined. */

870 /* sawfailure= / 0, / illegalinst= */ 0,

871 /* instructions= */ 1,

872 /* vaddr= */ 0x08049000,

873 "e9 fb 6f fb f7 \n" /* jmp 0 */

874 "f4 \n" /* hlt */

875 },

876 {

877 "test 93",

878 "test 93: jump to bundle-aligned zero page address is currently allowed",

879 /* sawfailure= / 0, / illegalinst= */ 0,

880 /* instructions= */ 1,

881 /* vaddr= */ 0x08049000,

882 "e9 fb 70 fb f7 \n" /* jmp 100 */

883 "f4 \n" /* hlt */

884 },

885 {

886 "test 94",

887 "test 94: jump to syscall trampoline should be allowed",

888 /* sawfailure= / 0, / illegalinst= */ 0,

889 /* instructions= */ 1,

890 /* vaddr= */ 0x08049000,

891 "e9 fb 6f fc f7 \n" /* jmp 10000 */

892 "f4 \n" /* hlt */

893 },

894 {

895 "test 95",

896 "test 95: unaligned jump to trampoline area must be disallowed",

897 /* sawfailure= / 1, / illegalinst= */ 0,

898 /* instructions= */ 1,

899 /* vaddr= */ 0x08049000,

900 "e9 fc 6f fc f7 \n" /* jmp 10001 */

901 "f4 \n" /* hlt */

902 },

903 {

904 "test 96",

905 "test 96: bundle-aligned jump to before the code chunk is allowed",

906 /* sawfailure= / 0, / illegalinst= */ 0,

907 /* instructions= */ 1,

908 /* vaddr= */ 0x08049000,

909 "e9 fb 6f fb f8 \n" /* jmp 1000000 */

910 "f4 \n" /* hlt */

911 },

912 {

913 "test 97",

914 "test 97: bundle-aligned jump to after the code chunk is allowed",

915 /* sawfailure= / 0, / illegalinst= */ 0,

916 /* instructions= */ 1,

917 /* vaddr= */ 0x08049000,

918 "e9 fb 6f fb 07 \n" /* jmp 10000000 */

919 "f4 \n" /* hlt */

920 },

921 };

922

923 static void DecodeHexString(const char input, uint8_t *result_data,

924 size_t *result_size) {

925 size_t buf_size = strlen(input) / 2; /* Over-estimate size */

926 uint8_t *output;

927 uint8_t *buf = malloc(buf_size);

928 assert(buf != NULL);

929

930 output = buf;

931 while (*input != '\0') {

932 if (input == ' ' \|\| input == '\n') {

933 input++;

934 } else {

935 char *end;

936 assert(output < buf + buf_size);

937 *output++ = (uint8_t) strtoul(input, &end, 16);

938 /* Expect 2 digits of hex. */

939 assert(end == input + 2);

940 input = end;

941 }

942 }

943 *result_data = buf;

944 *result_size = output - buf;

945 }

946

947 static void TestValidator(struct NCValTestCase *vtest, int didstubout) {

948 struct NCValidatorState *vstate;

949 uint8_t *byte0;

950 size_t data_size;

951 int rc;

952

953 DecodeHexString(vtest->data_as_hex, &byte0, &data_size);

954 /*

955 * The validator used to require that code chunks end in HLT. We

956 * have left the HLTs in, but don't pass them to the validator.

957 * TODO(mseaborn): Remove the HLTs.

958 */

959 assert(byte0[data_size - 1] == 0xf4 /* HLT */);

960

961 vstate = NCValidateInit(vtest->vaddr, data_size - 1,

962 FALSE, &g_ncval_cpu_features);

963 assert (vstate != NULL);

964 NCValidateSetErrorReporter(vstate, &kNCVerboseErrorReporter);

965 NCValidateSegment(byte0, (uint32_t)vtest->vaddr, data_size - 1, vstate);

966 free(byte0);

967 rc = NCValidateFinish(vstate);

968

969 do {

970 printf("vtest->sawfailure = %d, vstate->stats.sawfailure = %d\n",

971 vtest->sawfailure, vstate->stats.sawfailure);

972 NCStatsPrint(vstate);

973 if (vtest->sawfailure != rc) break;

974 if (vtest->sawfailure ^ vstate->stats.sawfailure) break;

975 if (didstubout != vstate->stats.didstubout) break;

976 if (vtest->instructions != vstate->stats.instructions) break;

977 if (vtest->illegalinst != vstate->stats.illegalinst) break;

978 Info("*** %s passed (%s)\n", vtest->name, vtest->description);

979 printf("\n");

980 NCValidateFreeState(&vstate);

981 return;

982 } while (0);

983 NCStatsPrint(vstate);

984 NCValidateFreeState(&vstate);

985 Info("*** %s failed (%s)\n", vtest->name, vtest->description);

986 exit(-1);

987 }

988

989 void test_fail_on_bad_alignment(void) {

990 struct NCValidatorState *vstate;

991

992 printf("Running test_fail_on_bad_alignment...\n");

993

994 vstate = NCValidateInit(0x80000000, 0x1000, FALSE, &g_ncval_cpu_features);

995 CHECK(vstate != NULL);

996 NCValidateFreeState(&vstate);

997

998 /* Unaligned start addresses are not allowed. */

999 vstate = NCValidateInit(0x80000001, 0x1000, FALSE, &g_ncval_cpu_features);

1000 CHECK(vstate == NULL);

1001 }

1002

1003 void test_stubout(void) {

1004 /* Similar to test 68 */

1005 struct NCValTestCase test = {

1006 "test stubout",

1007 "test stubout: NACLi_MMX",

1008 /* sawfailure= / 0, / illegalinst= */ 0,

1009 /* instructions= */ 1,

1010 /* vaddr= */ 0x80000000,

1011 "0f 60 00 f4 \n" /* punpcklbw (%eax),%mm0 */

1012 };

1013

1014 printf("Running test_stubout...\n");

1015

1016 /* If MMX instructions are not allowed, stubout will occur. */

1017 NaClSetCPUFeatureX86(&g_ncval_cpu_features, NaClCPUFeatureX86_MMX, FALSE);

1018 TestValidator(&test, TRUE);

1019 NaClSetCPUFeatureX86(&g_ncval_cpu_features, NaClCPUFeatureX86_MMX, TRUE);

1020 }

1021

1022 void ncvalidate_unittests(void) {

1023 size_t i;

1024

1025 /* Default to stubbing out nothing. */

1026 NaClSetAllCPUFeaturesX86((NaClCPUFeatures *) &g_ncval_cpu_features);

1027

1028 for (i = 0; i < NACL_ARRAY_SIZE(NCValTests); i++) {

1029 TestValidator(&NCValTests[i], FALSE);

1030 }

1031

1032 test_fail_on_bad_alignment();

1033 test_stubout();

1034

1035 Info("\nAll tests passed.\n\n");

1036 }

1037

1038

1039 int main(void) {

1040 struct GioFile gio_out_stream;

1041 struct Gio gout = (struct Gio) &gio_out_stream;

1042 if (!GioFileRefCtor(&gio_out_stream, stdout)) {

1043 fprintf(stderr, "Unable to create gio file for stdout!\n");

1044 return 1;

1045 }

1046

1047 NaClLogModuleInitExtended(LOG_INFO, gout);

1048 ncvalidate_unittests();

1049 GioFileDtor(gout);

1050 return 0;

1051 }

OLD	NEW

« no previous file with comments | « src/trusted/validator_x86/ncval_annotate.py ('k') | src/trusted/validator_x86/testdata/32/README » ('j') | no next file with comments »